Portfolio  ›  Projects  ›  Aegis
MicroservicesPythonFastAPIDocker

Aegis, Containerised
Content Intelligence Platform

Content analysis jobs take minutes, not milliseconds. Aegis is the architecture that follows from taking that seriously — six services, a job queue, and no request left hanging.

◆ Prototype · dashboard running
Context: Personal project  ·  Role: Sole engineer
Shape: 6 containerised services behind a reverse proxy
6Services
2Data stores
1Reverse proxy
📊 See the Dashboard🏗️ Architecture
Aegis operator dashboard showing content job status and progress
Actual dashboardOperator view of job status and live progress
Overview

Six services, one job queue

Aegis splits content processing across six containerised services orchestrated with Docker Compose. A gateway accepts the request, an orchestrator manages the flow, a worker performs the long-running scraping and file generation, and a content-intelligence service handles the AI analysis. PostgreSQL stores results; Redis carries live progress and shared state; nginx fronts the whole thing on a bridged network.

The reason for the split is simple: content jobs are slow. Running them inside the request that triggered them means timeouts, no progress reporting, and a system that falls over the moment two people use it at once.

The Problem

A slow job inside a web request is a design error

Scraping a set of pages and generating output from them takes minutes. Do that inside an HTTP handler and every layer between the browser and the code — proxy, load balancer, browser itself — is entitled to give up first.

Worse, there is nothing to show the user while they wait, and no way to recover if the process dies halfway through.

Technical Approach

Accept fast, work in the background

The gateway accepts a job and returns immediately with an identifier. The orchestrator places the work on a queue; workers pick it up and report progress into Redis as they go, which is what the dashboard reads. Results land in PostgreSQL, so a completed job survives a restart of any service that produced it.

Because each concern is its own container, the slow part scales independently of the part that answers the browser.

01 ACCEPTGateway takes the request, returns a job id
02 QUEUEOrchestrator schedules the work
03 WORKWorker scrapes and generates
04 ANALYSEContent-intelligence service
05 REPORTLive progress via Redis
06 STOREResults persisted to PostgreSQL
Capabilities

What it does

🏗️

Architecture

  • Six services, Docker Compose
  • nginx reverse proxy on a bridged network
  • Independent scaling of the slow path

Long jobs

  • Asynchronous job acceptance
  • Live progress reporting
  • Results survive a service restart
📊

Operation

  • Operator dashboard
  • Job status and history
  • Export gateway for generated files
Technologies

Actual stack

Services
FastAPIDocker Composenginx
State
PostgreSQLRedis
Pattern
Job queueBackground workersAsync acceptance
Limitations

Status

⚠️ A working prototype, not a deployed product

The architecture runs and the dashboard reports real job state, but this has not been operated under production load. There is no authentication layer, no horizontal-scaling story beyond "add worker containers", and no uptime or throughput figure is claimed.

The architecture is the point

Nothing here is exotic. It is the shape a system takes once you accept that the work is slower than the request that asks for it.