A fully-featured, scalable LeetCode-style online judge built using a modern microservices architecture. Includes real-time code execution, WebSockets, problem solving interface with Monaco Editor, authenticated user system, distributed queues, and Kubernetes Job-based isolated execution.

This project uses a microservices architecture with 7 independent services communicating through an API Gateway.

• Real-time code execution with live feedback
• Monaco Editor with syntax highlighting
• Kubernetes Job-based sandboxed execution environment
• Distributed job processing with BullMQ
• Full monitoring stack (Prometheus + Grafana + Loki)
• CI/CD pipeline with GitHub Actions
• JWT authentication with refresh tokens
• Email verification and password reset

• Beautiful UI with shadcn/ui
• Problem-solving interface with Monaco Editor
• Live submission updates using Socket.IO
• Global state management with Zustand
• Fully typed with TypeScript
• Form handling with React Hook Form
• API interactions using Axios
• Tailwind CSS styling
• Day.js for handling timestamps and dates

• NestJS for all microservices
• Redis + BullMQ for distributed queues
• PostgreSQL (shared DB, Prisma ORM)
• Socket.IO (real-time communication)
• Kubernetes Jobs for isolated, resource-limited code execution
• JWT authentication
• Event-driven architecture

• Docker & Docker Compose - Containerized microservices orchestration for local development
• Kubernetes (kind) - Job-based execution sandbox with CPU/memory resource limits, security contexts, and automatic TTL cleanup
• GitHub Actions - CI/CD pipelines for automated linting, testing, building Docker images, and service deployment
• Prometheus - Metrics collection and monitoring
• Grafana - Visualization dashboards for system metrics
• Loki - Centralized log aggregation
• BullMQ + Redis - Distributed job queues for async processing
• Nginx - Reverse proxy and load balancing

• User clicks Submit → Frontend sends code via WebSocket to API Gateway
• API Gateway checks Redis for idempotencyKey → cache hit returns result immediately
• API Gateway → TCP request to Submission Service
• Submission Service checks DB unique constraint on (userId, idempotencyKey) → duplicate returns existing row
• Submission Service → Publishes job to execution-queue (BullMQ) with jobId: idempotencyKey
• Execution Service → Consumes job from execution-queue
• Execution Service → Acquires distributed Redis lock before execution
• Execution Service → Spawns a Kubernetes Job with CPU/memory resource limits and runs user code in an isolated container
  • backoffLimit: 0 — no retries on user code failure
  • activeDeadlineSeconds — hard kill on TLE
  • ttlSecondsAfterFinished: 60 — automatic Job cleanup
  • automountServiceAccountToken: false — no cluster API access for user code
  • allowPrivilegeEscalation: false — process cannot gain additional privileges
  • readOnlyRootFilesystem: false — write access scoped to /workspace only
• Execution Service → Publishes result to results-queue
• If execution fails due to infrastructure error:
  • → Job is moved to execution-dlq (Dead Letter Queue)
  • → DLQ Worker retries job once by re-publishing to execution-queue
• Submission Service → Consumes result from results-queue
• Submission Service → Updates database row Pending → Accepted / WrongAnswer
• Submission Service → Publishes notification to notifications-queue
• API Gateway → Consumes notification event
• API Gateway → Updates Redis cache with final result (closes idempotency loop)
• API Gateway → Pushes real-time update through WebSocket to user's browser

• Each service deploys independently
• Execution workload isolated from main API
• Faster horizontal scaling
• Services communicate through queues → highly resilient
• Matches real LeetCode-scale architecture

All services use PostgreSQL with logical isolation using database schemas.

Instead of each service sharing tables, every microservice owns its own schema using Prisma's @@schema feature.

This provides microservice-level data ownership while still using a single PostgreSQL instance.

• Clear service data boundaries
• Prevents accidental cross-service table access
• Easier migration to independent databases later
• Maintains microservice architecture principles

Example Prisma model:

model User {
  id    String @id @default(uuid())
  email String @unique

  @@schema("users")
}

Clone the repo

$ git clone https://github.com/naman22a/online-judge-platform
$ cd online-judge-platform

Copy env files

$ cp .env.example .env
$ cp ./apps/client/.env.example ./apps/client/.env

Add /tmp to Docker Desktop file sharing, then:

$ docker plugin install grafana/loki-docker-driver:3.3.2-arm64 --alias loki --grant-all-permissions
$ docker compose up

Create a local kind cluster and deploy all services:

# Create cluster
$ kind create cluster --name oj

# Apply manifests
$ kubectl apply -f k8s/ -n oj

The execution service spawns Kubernetes Jobs dynamically for each submission. Ensure the execution service's ServiceAccount has permission to create/get/delete Jobs in the oj namespace.

$ cd ./apps/client
$ pnpm install
$ pnpm dev

After running docker compose up, access:

• Grafana: http://localhost:3001 (default: admin/admin)
• Prometheus: http://localhost:9090

$ pnpm test

This project includes a complete OAS 3.0 compliant REST API.

.
├── apps
│   ├── api-gateway
│   ├── auth-service
│   ├── client
│   ├── companies-service
│   ├── execution-service
│   ├── problems-service
│   ├── submissions-service
│   ├── tags-service
│   └── users-service
├── assets
│   ├── architecture.png
│   ├── problems.png
│   └── two-sum.png
├── docker-compose.dev.yml
├── docker-compose.yml
├── Dockerfile.base
├── Dockerfile.web
├── .dockerignore
├── .env
├── .env.example
├── .env.test
├── .gitignore
├── k8s
├── LICENSE
├── nginx.conf
├── .npmrc
├── package.json
├── packages
│   ├── config
│   ├── constants
│   ├── database
│   ├── eslint-config
│   ├── types
│   └── typescript-config
├── pnpm-lock.yaml
├── pnpm-workspace.yaml
├── .prettierignore
├── .prettierrc
├── README.md
├── tsconfig.json
└── turbo.json

Contributions, issues, and suggestions are welcome! Feel free to fork the repository and submit pull requests.

• Author - Naman Arora
• Twitter - @naman_22a

Online Judge Platform is GPL V3