REST API that shortens URLs, tracks click counts, and caches hot redirects in Redis. Deployed via Terraform to AWS ECS Fargate + RDS, with GitHub Actions building and pushing the image on every merge to main.

• Terraform provisions ECS Fargate, RDS Postgres, ECR, and IAM — full infra as code
• CI/CD: GitHub Actions runs tests, builds the image, and pushes to GHCR on every merge
• Redis cache on the redirect path — cold misses fall back to PostgreSQL and warm the cache
• Idempotent shortening: same URL in → same code out, atomic click counter
• Also ported to Python/FastAPI — see shortlink-api below

The Python/FastAPI counterpart to the Java URL Shortener above — same problem, same core decisions (idempotent shortening, Redis-aside caching, atomic click counting), rewritten idiomatically for the async Python stack.

• Built to confirm the Java version's design choices weren't accidental to Spring Boot
• Async SQLAlchemy 2.0 + asyncpg, Pydantic HttpUrl validation at the schema boundary
• Same cache-aside Redis pattern and collision-retry code generation as the Java original
• 10 tests against an in-memory SQLite engine — no Postgres needed to run the suite

Event-driven order processing: REST API publishes order events to Kafka, a consumer reads and persists them to PostgreSQL. Demonstrates producer/consumer, idempotent processing, and KRaft-mode Kafka.

• POST /api/orders returns 202 immediately — processing is async via Kafka
• Consumer deduplicates on order ID before persisting — safe for at-least-once delivery
• Topic created with 3 partitions, keyed by orderId for ordered per-order processing
• Kafka running in KRaft mode (no Zookeeper) via Docker Compose

Spring Boot service that receives events and fans them out to registered HTTP endpoints. Handles delivery failures with exponential-backoff retries and keeps a full audit trail of every attempt.

• POST /api/events returns 202 immediately — delivery is async via a scheduled worker
• Exponential backoff: attempt 1 → immediate, 2 → +1 min, 3 → +5 min, then FAILED
• Every delivery attempt records HTTP response status and body — full audit trail
• Endpoints can be deactivated without losing event history

CLI tool that parses log files and surfaces what actually needs attention — hourly error spikes and recurring patterns, normalized so similar errors with different IPs or IDs count as one incident instead of many.

• Parses nginx access logs and generic syslog-style lines, keeping unmatched lines instead of dropping them
• Normalizes messages — strips IPs, UUIDs, and numbers — so scattered errors collapse into one recurring pattern
• Hourly bucketing surfaces exactly when an incident started
• 13 tests covering parsing, normalization, and level filtering

Daily ETL pipeline: pulls repo metadata from the GitHub API, cleans it with pandas, and loads it into PostgreSQL as a dated snapshot — builds a time series of star growth and language mix instead of a single point-in-time read.

• Upserts on (full_name, snapshot_date) — idempotent re-runs, real history on new days
• Forks excluded from aggregation — a fork's stars belong to the upstream repo, not to the work done on it
• 10 tests against in-memory SQLite covering pure transform logic and upsert idempotency
• Scheduled via APScheduler — runs once immediately, then daily at a configured UTC hour

Production-shaped NestJS backend: product catalog, cart management, and checkout with real concurrency protection via SELECT FOR UPDATE. Built end-to-end as a take-home assignment.

• Checkout locks cart + product rows in sorted order to prevent deadlocks and overselling
• Soft-deleted products stay invisible in catalog but preserve order history snapshots
• Order cancellation with atomic stock restoration
• Concurrency stress test: two simultaneous checkouts compete for single-unit stock — exactly one wins
• One-command boot via Docker Compose; Swagger at /api