🧠 Building a Content-Aware Image Moderation Pipeline using ClarifAI and Kafka in a Spring Boot Microservice Architecture

yassine ramzi — Thu, 24 Apr 2025 12:16:07 +0000

As platforms grow and user-generated content scales, so does the risk
of inappropriate or non-compliant media uploads. Ensuring real-time
image moderation is not only an ethical responsibility but often a
legal requirement. This article explores how to build a content-aware
backend pipeline using Spring Boot (Java 21), Apache Kafka, and
ClarifAI, through a microservices architecture optimized for high
scalability and intelligent moderation.

🖼️ Use Case: Image Upload with AI Moderation

Let's imagine a social platform or SaaS product where users upload profile images or content. These images must be validated for:

NSFW content
Violence
Hate symbols
Brand safety concerns

The goal? Offload this task to an AI-powered moderation service while maintaining a decoupled and scalable architecture.

🧩 Architecture Overview: Kafka-Driven Moderation

Pipeline

Below is the event-driven architecture used for this flow:

📌 Diagram 1: High-Level Flow - Content-Aware Image Moderation

🔄 Flow Description:

1. User Uploads Image
The user uploads an image via the frontend. This request goes through the API Gateway.

2. Upload Microservice (Spring Boot)
Handles the upload and stores the image temporarily (e.g., in S3 or a blob store). It then publishes an image.uploaded event to Kafka.

3. Kafka Topic: image.uploaded
This topic broadcasts new uploads to all subscribed microservices.
ClarifAI Proxy Microservice (Spring Boot)
Subscribed to the image.uploaded topic. It:

4. Fetches the image URL
Sends it to the ClarifAI API for content analysis
Parses the response and evaluates thresholds (e.g., NSFW score)

5. Kafka Topic: image.moderated
The ClarifAI microservice then publishes a moderation result:
status: accepted | rejected | flagged
Scores, labels, categories

6. Upload MS Reacts to Moderation Result
Based on moderation status:
Store the image permanently (if accepted)
Discard or flag it (if rejected/flagged)
Notify the user or trigger manual review

📊 Diagram 2: Microservice Roles

Microservice Role API Gateway Entry point for requests, routing and authentication Upload Service Manages image reception, temporary storage, emits Kafka events ClarifAI Proxy MS Calls ClarifAI API, evaluates scores, emits moderation results Notification/Action (Optional) Sends user notifications or logs flagged images

🛠️ Why Kafka?

Kafka enables loose coupling between services:
Image upload doesn't wait for moderation
ClarifAI service can scale independently
Failures in one system don't block others
Supports retries and DLQ (Dead Letter Queue)

🚀 Key Benefits

Scalability: Each service can scale independently.
Auditability: All moderation decisions are event-driven and traceable.
Resilience: Failures don't block uploads; messages stay in Kafka.
Modularity: Easily swap ClarifAI with another provider or add secondary checks.

🧠 Final Thoughts

Moderating image content doesn't need to be manual or blocking. With AI-powered microservices, event-driven pipelines, and tools like ClarifAI, you can maintain platform safety while focusing on growth.
This architecture is production-ready, adaptable to Spring Boot 3 / Java 21, and perfect for platforms expecting to scale.

DEV Community: yassine ramzi

Check my new post where i discuss a content-aware image moderation using Kafka , ClarifAI and Spring boot Microservices