How I built an in-memory explicit content filter in Node.js (200ms latency, zero images saved)

Jozef — Wed, 26 Aug 2026 19:03:54 +0000

If you allow user-generated content in your app, you eventually run into a massive liability problem. Users will upload NSFW images.

I ran into this exact problem when Apple rejected my previous app under Guideline 1.2 (User Generated Content). I needed a filter, but the standard way most tutorials teach you to handle this is flawed.

Usually, the process goes like this:

User uploads an image from the client.
The server saves it to disk or cloud storage.
A background job runs a machine learning model to check the image.
If flagged, you delete the image.

The problem? The explicit image actually hits your hard drive before you know it is explicit. If the background job fails or is delayed, you are temporarily hosting illegal or policy-violating content on your servers.

To solve this, I built a single Node.js endpoint that runs the entire classification in memory.

The In-Memory Architecture

Instead of saving the file to disk, the server receives the image as a buffer, passes that buffer directly to a lightweight machine learning model, gets the score, and immediately destroys the buffer. The image never touches a hard drive.

Here is the core logic using the open-source nsfwjs library and TensorFlow.js:

const express = require('express');
const multer = require('multer');
const tf = require('@tensorflow/tfjs-node');
const nsfwjs = require('nsfwjs');

const app = express();
// Keep the file in memory, do not write to disk
const upload = multer({ storage: multer.memoryStorage() });

let _model;
const loadModel = async () => {
    _model = await nsfwjs.load();
};

app.post('/moderate', upload.single('image'), async (req, res) => {
    if (!req.file) {
        return res.status(400).json({ error: 'No image provided' });
    }

    try {
        // 1. Decode the image buffer directly from memory
        const imageTensor = tf.node.decodeImage(req.file.buffer, 3);

        // 2. Pass the tensor to the model
        const predictions = await _model.classify(imageTensor);

        // 3. Destroy the tensor to free memory immediately
        imageTensor.dispose();

        // 4. Return the scores
        return res.json(predictions);

    } catch (error) {
        return res.status(500).json({ error: 'Processing failed' });
    }
});

loadModel().then(() => app.listen(3000));

Why this approach wins

1. Total Privacy. Because we use multer.memoryStorage(), the image exists only in RAM for the fraction of a second it takes to run the classification. Once the request ends, Node.js garbage collects the buffer. You can legally guarantee your users that you are not storing their private photos.

2. Speed. Bypassing the file system completely keeps the classification extremely fast. In my testing, it drops to roughly 200ms per image on a standard VPS.

3. Simplicity. It is a synchronous API call. You can run this check before your database transaction even commits, keeping your backend architecture clean.

Wrapping up

If you want to run this yourself, the code snippet above is pretty much all you need to get started. Just watch your server memory, as TensorFlow tensors will cause a memory leak if you forget to call .dispose().

If you don't want to bother hosting the ML models or managing the RAM yourself, I actually wrapped this exact logic into an API called Tabu that I launched recently. It has a free tier that is plenty for testing, so feel free to use it if you want to skip the server setup.

Let me know how you guys handle image moderation in your own side projects!

I built an explicit content filter API for indie devs, and I'd love your feedback

Jozef — Tue, 25 Aug 2026 07:14:52 +0000

Hey everyone,

I'm Jozef. I work as a Product Manager and build side projects in my free time.

A few months ago, I needed a way to filter out explicit and NSFW images for an app. I realized the existing tools, like AWS Rekognition or Hive, target large companies. They have complicated pricing, heavy SDKs, and take too much time to set up for a solo dev trying to pass App Store guidelines.

So I built Tabu. It is an image and video moderation API made for indie developers and small teams.

Here is the tech stack:

Machine learning: It uses TensorFlow.js (MobileNetV2) running on my own servers. Inference takes about 200ms.
Privacy: Images process in memory and delete instantly. Nothing gets saved.
Caching: I added SHA-256 hashing with lru-cache to deduplicate requests. If you upload the exact same image twice, it skips the ML model and returns the cached result.

I need some feedback

I want to improve the product before a larger release. I am looking for a few developers to test it and tell me what is broken or confusing.

Read the docs: Tell me if the setup steps make sense.
Test the API: Get a free key, upload some edge-case images, and see if the caching works.
Check the dashboard: Tell me if the UI is hard to use.

The free tier includes 5,000 requests per month, so you do not need a credit card to try it.

If you have a few minutes, please let me know what you think in the comments. I am here to learn.