Microservices Task Management System

A production-pattern microservices application with separate auth, task, notification, and file-storage services — containerised with Docker and deployable to AWS ECS with load balancing and auto-scaling.

This project demonstrates microservices architecture patterns (service decomposition, inter-service communication, distributed deployment) using task management as a domain — keeping the focus on engineering rather than business complexity.

---

Architecture

                          ┌─────────────────┐
                          │   React Client  │
                          │  (TypeScript)   │
                          └────────┬────────┘
                                   │ HTTPS
                          ┌────────▼────────┐
                          │   API Gateway   │  ← Single entry point
                          │  (Spring Boot)  │     JWT validation
                          └────────┬────────┘     Rate limiting
                                   │
               ┌───────────────────┼────────────────────┐
               │                   │                    │
    ┌──────────▼──────┐  ┌─────────▼───────┐  ┌────────▼────────┐
    │  Task Service   │  │  Auth Service   │  │  File Service   │
    │  (Spring Boot)  │  │  (Spring Boot)  │  │  (Spring Boot)  │
    │  Port 8081      │  │  Port 8082      │  │  Port 8083      │
    └──────────┬──────┘  └─────────┬───────┘  └────────┬────────┘
               │                   │                    │
    ┌──────────▼──────┐  ┌─────────▼───────┐  ┌────────▼────────┐
    │  tasks_db       │  │  users_db       │  │  AWS S3         │
    │  (PostgreSQL)   │  │  (PostgreSQL)   │  │  (file storage) │
    └─────────────────┘  └─────────────────┘  └─────────────────┘
               │
    ┌──────────▼────────────────┐
    │   Notification Service    │  ← Async via message queue
    │   (Spring Boot)           │     Email + in-app alerts
    └──────────┬────────────────┘
               │
    ┌──────────▼──────┐
    │  RabbitMQ       │  ← Decouples task events from notifications
    └─────────────────┘

Services

Service	Responsibility	Port
API Gateway	Routing, JWT validation, rate limiting	8080
Task Service	CRUD, assignment, status, deadlines	8081
Auth Service	Register, login, JWT issue/refresh	8082
File Service	Upload/download via S3 presigned URLs	8083
Notification Service	Email + in-app alerts via RabbitMQ	8084

Tech Stack

Layer	Technology
Frontend	React 18, TypeScript, Redux Toolkit
Services	Java 17, Spring Boot 3 (×4 services)
Messaging	RabbitMQ (async notification delivery)
Database	PostgreSQL (per-service, isolated schemas)
File Storage	AWS S3 (presigned URLs — no proxy needed)
Auth	JWT (RS256 — gateway validates, services trust)
Containers	Docker, Docker Compose
Cloud	AWS ECS (Fargate), ALB, RDS
CI/CD	GitHub Actions → ECR → ECS rolling deploy

Getting Started

Run all services locally

# Starts all services + infrastructure
docker-compose up --build

Services available at:

• Frontend: http://localhost:5173
• API Gateway: http://localhost:8080
• RabbitMQ console: http://localhost:15672

Run tests

# All services
./scripts/test-all.sh

# Individual service
cd services/task-service && ./mvnw test

Key Design Decisions

Database per service Each service owns its own PostgreSQL schema — no shared tables, no cross-service joins. This enforces true service independence and lets each scale and deploy separately.

Async notifications via RabbitMQ Task events (created, assigned, deadline approaching) publish to RabbitMQ. The Notification Service subscribes and delivers asynchronously — task operations never block on email delivery.

RS256 JWT (asymmetric) Auth Service signs tokens with a private key. All other services verify with the public key only — they never need the private key, reducing the blast radius of a service compromise.

S3 presigned URLs for files Files upload/download directly to S3 from the browser using presigned URLs — the File Service never proxies binary data, keeping memory usage flat regardless of file size.

AWS Deployment Pattern

Internet → ALB → ECS Fargate (Task Service × 2)
                              (Auth Service × 1)
                              (File Service × 1)
                              (Notification Service × 1)
                → RDS PostgreSQL (Multi-AZ)
                → ElastiCache Redis (session cache)

Auto-scaling is configured per-service on CPU > 70% — Task Service scales independently from Auth Service.

CI/CD Pipeline

Push to main
  → GitHub Actions: build + test
  → Docker build + push to ECR
  → ECS rolling deployment (zero downtime)
  → Health check validation

Folder Structure

├── services/
│   ├── api-gateway/
│   ├── task-service/
│   ├── auth-service/
│   ├── file-service/
│   └── notification-service/
├── frontend/
├── infrastructure/          # AWS CDK / Terraform configs
├── scripts/
└── docker-compose.yml

---

Author

Shreya H S — Full Stack Software Engineer, London
LinkedIn · GitHub