Junior → Middle Accelerator
A 12-week instructor-led program for working junior Java developers: reading and changing an existing codebase, going deep on Spring Boot, avoiding JPA and PostgreSQL pitfalls, testing properly, security and CI basics, and delivering a feature independently starting from a ticket. This is a planned syllabus that may be adjusted to the group; there is no job guarantee.
This program is planned and not scheduled yet. No date, cohort or admission has been announced, and we are not accepting applications. Register interest or ask for a consultation and we will contact you when it is scheduled.
- Duration
- 12 weeks
- Live sessions
- 2 per week, 90 minutes each
- Structure
- 4 phases
12 weeks
Week-by-week syllabus
This is the planned syllabus: order and depth may be adjusted to the group. It is not a job or title guarantee.
01 · Weeks 1–3
Working in an existing codebase and Spring Boot
Phase goal: Read and understand an unfamiliar Spring Boot project, make safe changes, work in a Git/Pull Request flow and build a clean layered architecture.
Week 1
Reading and safely changing an existing codebase
- Mapping an unfamiliar project: modules, entry points, configuration
- Tracing a request: controller → service → repository → DB
- Reading tests as documentation and characterization tests
- Finding causes with the debugger, stack traces and logs
- The principle of small, reversible changes
Lab: Run the instructor-provided ticket-tracker project for the first time, follow one request step by step with the debugger, then write a characterization test that reproduces a pagination bug and fix it.
Assignment: Produce a CODEBASE_MAP.md (modules, request-flow diagram), reproduce and fix the pagination bug with a test, add a small filter; submit as a Pull Request.
Week 2
Git workflow, Pull Requests and code review etiquette
- Branching, rebase vs merge, cleaning history with interactive rebase
- Small, readable Pull Requests: description, size, commit messages
- As a reviewer: what to look for and how to word feedback
- As an author: responding to feedback and resolving disagreement
- Resolving merge conflicts and using git bisect
Lab: Resolve a deliberately built merge conflict, find the bug-introducing commit with git bisect and write a review of a colleague's provided Pull Request.
Assignment: Make a change on your own feature branch with 3 small meaningful commits, open a Pull Request, and leave at least 5 reasoned review comments on a peer's Pull Request.
Week 3
Spring Boot in depth: layering, validation, error handling
- Controller / service / repository responsibilities and separating DTOs from entities
- Bean Validation, custom validators and validation groups
- @RestControllerAdvice and RFC 9457 ProblemDetail
- Configuration: @ConfigurationProperties and profiles
- Bean lifecycle and dependency injection pitfalls
Lab: Rewrite an endpoint that returns entities directly to use DTOs, validation and a uniform ProblemDetail error response.
Assignment: Add 'create ticket' and 'change status' endpoints to the tracker with validation, business-rule errors and tests; Pull Request.
Checkpoint: A reviewed Pull Request that adds a new endpoint with validation and a uniform error format to the provided codebase.
02 · Weeks 4–6
The data layer and testing strategy
Phase goal: Understand transactions, JPA pitfalls (N+1, lazy loading) and PostgreSQL query plans; write unit, slice and Testcontainers tests at the right layers.
Week 4
Transactions and JPA pitfalls: N+1, lazy loading
- @Transactional: boundaries, propagation, rollback rules and the self-invocation trap
- Persistence context, dirty checking, flush
- The N+1 problem and fetch join / EntityGraph / batch fetching
- LazyInitializationException and the cost of open-in-view
- Optimistic locking (@Version) to prevent lost updates
Lab: Measure an N+1 endpoint with SQL logs and Hibernate statistics, fix it three ways and compare query counts.
Assignment: Fix the N+1 in the ticket-list endpoint, add a test asserting the query count and protect concurrent edits with @Version; Pull Request.
Week 5
PostgreSQL: indexes and query plans
- EXPLAIN (ANALYZE, BUFFERS): reading a plan
- B-tree indexes, composite indexes and column order, partial indexes
- When a Seq Scan is right; statistics and selectivity
- Pagination: OFFSET vs keyset
- Safe migrations with Flyway and creating indexes online
Lab: Analyse a slow query on a one-million-row table with its plan, add an index and measure before/after.
Assignment: Design an index for the search endpoint with a Flyway migration, replace OFFSET with keyset pagination and compare plans in a short note; Pull Request.
Week 6
Testing strategy: unit, slice, Testcontainers
- The test pyramid and what to test at each layer
- Unit tests with Mockito and the over-mocking trap
- @WebMvcTest and @DataJpaTest slice tests
- Integration tests against real PostgreSQL with Testcontainers
- Causes of flaky tests and test data builders
Lab: Write a test strategy note for the project and add a Testcontainers integration test for a critical flow.
Assignment: For the tracker: write 5 unit, 2 slice and 2 Testcontainers tests and note flakiness risks; Pull Request.
Checkpoint: A measured diagnosis of a slow endpoint, its fix (fetch strategy + index) and a Testcontainers-backed test suite protecting it.
03 · Weeks 7–9
Quality, observability and security
Phase goal: Refactor under the protection of tests, diagnose problems with structured logging and metrics, and close the basic authn/authz and OWASP weaknesses.
Week 7
Clean code and refactoring
- Code smells: long method, feature envy, primitive obsession
- Refactoring in small steps under test protection
- Using sealed types, records and Optional properly
- Naming, function size and comments that say 'why'
- Safe entry into legacy code: seams and the strangler approach
Lab: Protect a 300-line service class with characterization tests and split it into small parts with clear responsibilities.
Assignment: Refactor the provided legacy module in 4–6 small commits, with tests staying green in every commit; Pull Request.
Week 8
Logging and observability basics
- Structured logging, log levels and correlation IDs (MDC)
- What not to log: personal data and secrets
- Micrometer metrics and Spring Boot Actuator
- Health checks, readiness and liveness
- Diagnosing a problem from logs and metrics
Lab: Diagnose a deliberately broken service (slow query, pool exhaustion) using only logs and metrics and write a short postmortem.
Assignment: Add a correlation-id filter, 3 business metrics and health groups to the tracker; prove with a test that secrets are not logged; Pull Request.
Week 9
Security basics: authn/authz and OWASP
- Authentication vs authorization; session vs JWT
- Spring Security: filter chain, method security, CSRF
- OWASP Top 10: injection, broken access control, sensitive data exposure
- IDOR and resource-level authorization checks
- Password storage, dependency vulnerabilities, secret management
Lab: Prove an SQL injection and an IDOR weakness in the provided project with tests, then close them.
Assignment: Role- and ownership-based authorization in the tracker (not seeing others' tickets → 404) with authorization tests and a security review note; Pull Request.
Checkpoint: A refactoring Pull Request for a legacy module, logging/metric additions and a security review note (weaknesses found and closed).
04 · Weeks 10–12
Delivery: Docker, CI and an independent feature
Phase goal: Containerize an application, build a CI pipeline, estimate and break down a ticket, and deliver a feature end to end on your own.
Week 10
Docker and CI pipelines
- Multi-stage Dockerfile, layer cache and small images
- Local environment with docker compose (app + PostgreSQL)
- GitHub Actions: build, test, cache, artifacts
- Testcontainers and quality gates in the pipeline
- 12-factor configuration and secrets in CI
Lab: Write a multi-stage Dockerfile for the app, shrink the image and build a CI workflow that runs the tests.
Assignment: A Dockerfile, compose.yaml and green CI workflow for the tracker; a 'run it with one command' README section; Pull Request.
Week 11
From ticket to feature: estimating and planning
- Clarifying a ticket: acceptance criteria and questions
- Splitting work into vertical slices
- Estimating: uncertainty, ranges and risk
- Feature flags and incremental delivery
- Communicating status: blockers, risks, dependencies
Lab: From a vague ticket produce a question list, task breakdown and ranged estimate, and discuss it with the instructor acting as product owner.
Assignment: Take the capstone ticket, write a plan (questions, slices, estimate, risks) and submit the first slice as a Pull Request.
Week 12
Capstone: independent feature delivery and demo
- Delivering the remaining slices of the feature
- Self-review and preparing the Pull Request
- Responding to review feedback and iterating
- Demo: what to show, how, and which trade-offs to name
- Retrospective and a next-step growth plan
Lab: Finish the feature, pass instructor and peer review, and give a 10-minute demo with CI green.
Assignment: The complete feature Pull Request (code, tests, migration, docs), review responses and demo notes; presentation and retrospective.
Checkpoint: A feature delivered independently in a realistic codebase, reviewed and demoed (code, tests, green CI, short write-up).