Web development · 5 stages · about 52 weeks
Backend developer (Java: Spring Boot) roadmap
0/28 tasks done (ticks are kept on this device)
- 1
Beginner · about 10 weeks
Core Java and object-oriented programming
What to learn
Java basics: Spring Boot is Java, so the language comes first.
Learn variables, data types, if/else, loops, methods and arrays. Java is strict about types: you must say a price is an int or a double, and a name is a String. Install a current LTS (long-term support) JDK and write small programs every day.
Classes and objects: Everything in Java lives inside a class.
A class is a blueprint, like BankAccount, and an object is one real account made from it. Fields hold the data, methods hold the actions, and a constructor sets up a new object. Learn access modifiers like private and public to protect data.
The four ideas of OOP: Interviews at Indian IT companies almost always ask about OOP.
Encapsulation hides data behind methods. Inheritance lets one class build on another, and polymorphism lets one method name do different things for different classes. Abstraction means showing only what matters, using interfaces and abstract classes.
Collections: Real programs work with lists and maps of data all the time.
The Collections Framework gives you List (like ArrayList), Set (no duplicates) and Map (key to value, like HashMap). Learn when to use each, and how HashMap finds values quickly. Generics, like List<String>, keep collections type-safe.
Exceptions: Good programs handle errors instead of crashing.
An exception is an error that happens while the program runs, like a missing file. Use try/catch/finally to handle it, and throw your own exceptions for business errors such as "insufficient balance". Learn the difference between checked and unchecked exceptions.
Lambdas and streams: Modern Java code uses them everywhere.
A lambda is a short, unnamed function, like x -> x * 2. Streams let you filter, change and sum collections in a clear chain, for example the total of all paid orders. Records give you simple data classes with very little code.
Maven or Gradle: Build tools download libraries and build your project.
Maven (pom.xml) and Gradle (build.gradle) list your project's dependencies and build it with one command. They download libraries from Maven Central for you. Most Spring Boot projects in India use Maven, so learn it first.
Git and GitHub: Every team uses Git, and GitHub shows your work to recruiters.
Git saves versions of your code as commits so you can go back. Push each practice project to GitHub with a README. Learn to create branches early, because every job uses them.
Tasks
Project
A console library management system in Java: books, members and loans in collections, fine calculation in rupees for late returns, custom exceptions, and data saved to a file, built with Maven.
Free resources
- 2
Beginner · about 10 weeks
SQL, HTTP and your first Spring Boot API
What to learn
SQL: Almost every Java backend stores data in a SQL database.
A SQL database keeps data in tables with rows and columns. Learn SELECT, INSERT, UPDATE, DELETE, WHERE, JOIN and GROUP BY. MySQL and PostgreSQL are both common in Indian companies.
HTTP and REST: Spring Boot apps talk to frontends and mobile apps over HTTP.
A request has a method (GET, POST, PUT, DELETE), a URL and often a JSON body. The server answers with a status code like 200, 201, 400 or 404. In REST, each thing has its own URL, like /api/accounts/12.
Spring Boot basics: Spring Boot is the most asked-for Java backend skill in India.
Spring Boot sets up a ready-to-run web server with sensible defaults. You create a project at start.spring.io, pick the starters you need, and run it. It handles much of the setup that older Java projects needed by hand.
Dependency injection: This is the core idea of Spring and a favourite interview topic.
Instead of a class creating the objects it needs, Spring creates them (called beans) and passes them in. This keeps classes loosely connected and easy to test. Prefer constructor injection over field injection.
Controllers, services and repositories: This layered structure is used in almost every Spring project.
A controller receives the HTTP request and returns the response. A service holds the business rules, like "a withdrawal cannot go below zero". A repository talks to the database, so each layer has one clear job.
Spring Data JPA: JPA lets you save and load Java objects without writing much SQL.
JPA (with Hibernate underneath) maps a Java class, called an entity, to a database table. A repository interface gives you save, findById and findAll for free, and you can add methods like findByCity. Learn relationships like @OneToMany and watch the SQL it creates.
Validation and error handling: APIs must reject bad data with clear messages.
Use annotations like @NotBlank, @Email and @Positive on request objects, with @Valid in the controller. A @RestControllerAdvice class turns exceptions into clean JSON errors. Use DTOs (simple request and response classes) instead of returning entities directly.
Tasks
Project
A Spring Boot REST API for a small bank: customers, accounts, deposits, withdrawals and transfers in rupees, with validation, clean error messages, and data in PostgreSQL or MySQL.
📘 Learn it here, free: Backend Development course
Free resources
- 3
Intermediate · about 10 weeks
Security, testing and production-ready Spring
What to learn
Spring Security: Every real API needs login and permissions.
Spring Security adds a chain of filters that check each request before it reaches your controller. Learn password hashing with BCrypt, roles like USER and ADMIN, and method-level rules with @PreAuthorize. It can feel hard at first, so build small examples.
JWT and OAuth2: Modern apps use tokens, and many log in with Google or a company login.
A JWT (JSON Web Token) is a signed token that the app sends with each request to prove who the user is. OAuth2 and OpenID Connect let users log in through another service. Spring Security has built-in support for both.
Testing with JUnit and Mockito: Companies expect tests, and they let you change code safely.
JUnit 5 runs your tests and checks results with assertions. Mockito creates fake versions of classes, so you can test a service without a real database. Spring Boot test slices like @WebMvcTest and @DataJpaTest test one layer at a time.
Integration tests with Testcontainers: Some bugs only show up with a real database.
Testcontainers starts a real PostgreSQL (or Kafka) in Docker during your tests and removes it after. This catches problems that fake databases miss. It is now common in good Java teams.
Transactions: Money and orders must never be half-saved.
A transaction groups several database changes so they all succeed or all fail together. In Spring you add @Transactional to a service method, for example a transfer that takes money from one account and adds it to another. Learn what happens when an exception is thrown inside it.
Database migrations: Database changes must be tracked like code.
Flyway or Liquibase keep numbered scripts that change the database structure step by step. Every developer and server runs the same steps in the same order. Never change production tables by hand.
Actuator, logging and configuration: You need to see what a running app is doing.
Spring Boot Actuator gives health checks and metrics endpoints. Use SLF4J with Logback for logs, and never log passwords or card numbers. Keep settings in application.yml with profiles for dev and prod, and secrets in environment variables.
API documentation: Frontend and mobile teams need to know how to call your API.
OpenAPI (Swagger) describes every route, input and output. The springdoc-openapi library creates it from your controllers and shows a Swagger UI page. Keep it updated as part of every change.
Tasks
Project
An insurance or loan application API: applicants, documents, status changes and EMI calculation, with JWT login, roles, transactions, Flyway migrations, tests with Testcontainers, and Swagger docs.
📘 Learn it here, free: Backend Development course
Free resources
- 4
Intermediate · about 10 weeks
Microservices, Kafka, Docker and Kubernetes basics
What to learn
Microservices: Many large Indian companies run Java as many small services.
A microservice is a small app that owns one job, such as payments or notifications, with its own database. Services talk over REST or through messages. This helps big teams work in parallel, but makes debugging and data consistency harder.
Service-to-service calls: Services must call each other reliably over a network.
Spring offers RestClient and WebClient for calling other services. Networks fail, so add timeouts, retries and circuit breakers (with a library like Resilience4j) that stop calling a broken service for a while. Always plan for the other service being down.
Kafka basics: Kafka is widely used for events in banking, e-commerce and logistics.
Kafka is a system that stores streams of events, like "order placed", in topics. Producers write events and consumers read them at their own speed. Learn topics, partitions, consumer groups and why a consumer must handle the same event twice safely.
Docker: Docker is how most Java services are packaged today.
A Docker image packs your app with the exact Java version it needs. Spring Boot can build images for you, or you can write a Dockerfile. Docker Compose starts several services, a database and Kafka together on your laptop.
Kubernetes basics: Kubernetes runs containers at scale in many Indian companies.
Kubernetes starts, restarts and scales containers across many machines. Learn Pods, Deployments, Services, ConfigMaps and Secrets. Use readiness and liveness probes, which can call Spring Boot Actuator health endpoints.
Caching: Caching reduces load on databases and other services.
Spring Cache lets you add @Cacheable to a method so its result is saved. Redis is a common shared cache for many service copies. Always decide how long data can stay old before it must be refreshed.
Tasks
Project
A small e-commerce order system with order, inventory and notification services: orders publish events to Kafka, inventory updates stock, notifications send a message, all running in Docker Compose and on a local Kubernetes cluster.
Free resources
- 5
Expert · about 12 weeks
Performance, system design and technical leadership
What to learn
JVM internals and tuning: Senior Java engineers must explain memory and speed problems.
Learn how the heap, the stack and garbage collection work. Use tools like JDK Flight Recorder and VisualVM to find memory leaks and slow code. Change JVM settings only after measuring, never by guessing.
Concurrency and virtual threads: Backends handle many requests at the same time.
Learn threads, thread pools, locks and the dangers of shared data. Virtual threads, added in Java 21, let one server handle a very large number of waiting requests cheaply. Know when they help (waiting on networks) and when they do not (heavy CPU work).
Database performance: Most slow Java apps are slow because of the database.
Watch the SQL that Hibernate creates and fix the "N+1" problem with fetch joins or entity graphs. Use EXPLAIN to check indexes. Learn connection pooling (HikariCP) and how pool size affects speed.
System design: Senior interviews at product companies focus on design.
Learn load balancing, database replicas and sharding, caching, queues, and eventual consistency between services. Practise designs like a payment system or a train ticket booking site. Always explain trade-offs and failure cases.
Observability: With many services, you need to follow one request across all of them.
Use Micrometer for metrics and OpenTelemetry for traces, with tools like Prometheus and Grafana. Put a trace id in every log line. Set alerts on error rates and slow responses that really affect users.
Security and compliance: Banks and fintech companies in India have strict rules about data.
Study the OWASP Top 10 and secure service-to-service calls with mutual TLS or tokens. Keep secrets in a secret manager, not in config files. Learn the basics of audit logs and data protection rules that apply to your company.
Technical leadership: Senior engineers guide design and help others grow.
Write design documents and architecture decision records that explain why a choice was made. Review code kindly and with reasons. Mentor juniors, especially freshers who join large services companies.
Tasks
Project
A production-style payment or ticket booking platform: several Spring Boot services, Kafka events, transactions where money moves, Redis cache, Testcontainers tests, metrics and traces, deployed on Kubernetes, with design documents for the key decisions.
Free resources