Foundation Project 1: Pure HTTP API (No
Framework Magic)
Goal: Understand how the web actually works.
What to build
A tiny HTTP server that:
Listens on a port
Handles GET and POST
Parses request bodies
Returns proper status codes
Handles basic routing
Constraints
Java
Use minimal libraries
No Spring yet (you can use Java9s HTTP server or Netty-lite)
What you9ll learn
What an HTTP request really is
Headers vs body
Status codes that mean something
Why frameworks exist
After this, Spring stops feeling magical.
Foundation Project 2: Database + Transactions
(The Right Way)
Goal: Learn data correctness, not just SQL syntax.
What to build
A simple service that:
Creates users
Updates balances
Transfers money between users
Hard requirements
Use transactions
Prevent negative balances
Handle concurrent requests safely
Tech
Java
PostgreSQL
JDBC or JPA (but understand what it generates)
What you9ll learn
ACID properties
Race conditions
Isolation levels
Why <it works on my machine= is meaningless
This is critical for the payment/order project later.
Foundation Project 3: Simple Auth (Sessions, Not
JWTs Yet)
Goal: Learn auth fundamentals before modern abstractions.
What to build
Login
Logout
Session-based auth
Cookies
Access control for protected routes
No JWTs yet.
Use server-side sessions stored in:
memory ³ then
database or Redis
What you9ll learn
How auth really works
Why cookies are dangerous
CSRF basics
Stateless vs stateful tradeoffs
JWTs will make much more sense afterward.
Foundation Project 4: Error Handling & Logging
Goal: Learn to think in failures.
What to build
Take any previous project and add:
Structured logging
Global error handling
Meaningful error responses
Correlation/request IDs
What you9ll learn
Why stack traces aren9t enough
How production debugging works
Why observability matters
This is hugely under-taught.
Foundation Project 5: Concurrency &
Background Work (Small)
Goal: Learn async thinking safely.
What to build
API endpoint that triggers background work
Job processed in a thread pool
Status endpoint to check progress
Constraints
No Kafka
No heavy tools
Just Java concurrency
What you9ll learn
Thread pools
Race conditions
Graceful shutdown
Why async is hard
This prepares you perfectly for the async job system later.
The 3 Projects You MUST Do (Java + Spring)
Project 1: Production-Grade Authentication &
Authorization Service
Why this one is mandatory: Auth is where bad engineers reveal themselves. Doing it well instantly separates you.
What you build
A standalone auth service (no UI needed):
Core features
User registration & login
Password hashing (bcrypt or argon2)
JWT access tokens + refresh tokens
Token rotation
Role-based access control (RBAC)
Logout with token invalidation
Rate limiting on login attempts
Tech
Java + Spring Boot
Spring Security (don9t just copy config 4 understand it)
PostgreSQL
Redis (rate limiting + token blacklist)
What makes this <senior-leaning=
In your README, explain:
Why JWTs expire quickly
Why refresh tokens are stored server-side
How you prevent brute force attacks
What happens if Redis goes down
If you can explain failure modes, you9re already above junior level.
Project 2: Order & Payment Processing System
(Transactional Core)
Why this one matters: This shows you understand business logic, not just endpoints.
What you build
A backend for a fake e-commerce system:
Core flow
Create order
Reserve inventory
Process payment (mocked)
Confirm or fail order safely
Hard requirements
Database transactions
Idempotent APIs (safe retries)
Order state machine
Recovery from partial failures
No double-charging, ever
Tech
Java + Spring Boot
PostgreSQL
JPA / Hibernate
Clear transaction boundaries
What makes recruiters pause
You document things like:
<What happens if payment succeeds but DB commit fails?=
<Why retries can be dangerous=
<Why I chose this transaction isolation level=
Most juniors cannot answer these questions.
Project 3: Async Job Processing & Reliability
System
This is the knockout project. It proves you think about real production systems.
What you build
A service that handles background jobs (e.g. email sending, report generation).
Core features
Submit job via API
Process jobs asynchronously
Retry on failure with backoff
Dead-letter handling
Job status tracking
Graceful shutdown
Tech
Java + Spring Boot
Thread pools / async execution
Database-backed queue OR Redis
Structured logging
Metrics (basic counters are enough)
What makes this scream <hire=
You explain:
Why async is needed
How you avoid duplicate job execution
What happens if the worker crashes mid-job
How you9d scale workers horizontally
This is not junior thinking.