Java backend developer roadmap 2026: from Java to senior

A 7-stage Java backend developer roadmap: Java, Spring Boot, databases, AWS, microservices and senior interviews, with four projects you can talk about.

The Java backend roadmap has seven stages: Java and object-oriented programming, Spring Boot with SQL, data and performance, deploying to AWS, microservices, advanced backend, and senior interviews. The order matters, because each stage uses the knowledge of the one before it.

Where are you among these seven stages, and where should you start? Let's look at the map together.

What does a Java backend developer do?

Imagine a small café called Mộc (an illustrative situation that I will use throughout). The café sells online and gets a few hundred orders a day. A customer taps an order on a phone, and from that moment the backend takes care of everything: receiving the order, checking whether the item is in stock, calculating the price, saving it in a database, telling the kitchen, sending a confirmation email.

The backend has no screen to look at. It is just a program running on a server, receiving requests from the app of the customer and answering them. The hard part is that it must stay correct when many users arrive at once, must not lose data, must not leak the information of one person to another, and must keep running at three in the morning when nobody is on duty.

Java is one of the most widely used languages for this work, and Spring Boot is the most popular framework in the Java world. That is why this roadmap goes in that direction. If you are interested in another stack, the ideas about databases, deployment and system design still apply, only the tools differ.

What does the map of the 7 stages look like?

I arrange the stages by one principle: do not learn anything before you have the foundation to understand why it exists.

Map of the Java backend roadmap
 Stage 1        Stage 2              Stage 3
 Java basics -> Spring Boot + SQL -> Data and performance
 (OOP, collections,  (API, JPA, security,   (indexes, transactions,
  concurrency, JVM)   tests)                 cache, queues)
                                               |
                                               v
 Stage 6               Stage 5            Stage 4
 Advanced backend <-   Microservices <-   Deployment and AWS
 (concurrency, load,   (Spring Cloud,     (Docker, CI/CD, ECS,
  operations)           Kafka, saga)       RDS)
        |
        v
 Stage 7
 Senior interviews (algorithms, system design, ADRs, behavioural)

Stage 1 is Java from scratch. You install the tools, write your first program, write your first test, learn basic Git to save and share code, and then go through variables, loops and, most important of all, object-oriented programming: classes, inheritance, polymorphism, interfaces and the SOLID principles. After that come the things every Java program uses, such as collections, generics, streams, error handling, reading and writing files, dates and times, concurrency, and how the JVM manages memory. This part sounds basic, but it decides whether you use Spring as someone who understands the work or as someone who copies code.

Stage 2 is Spring Boot together with databases. You learn HTTP and REST, SQL, then build a real order API: Spring Boot and dependency injection, Spring Data JPA, input validation, error handling, transactions, security with JWT, and tests. This stage makes you ready to apply for a junior position.

Stage 3 is about data and performance: indexes, reading query plans, transaction isolation levels, locks, Redis as a cache, rate limiting, message queues. This is where an application that runs becomes an application that can take load.

Stage 4 puts the application on the internet: Linux, networking, how to work in a team with Git (branches, rebase, pull requests), Docker, GitHub Actions, then AWS with IAM, VPC, RDS, ECS, and automatic deployment that can roll back when something fails.

Stage 5 is microservices. I will cover both when to split and when not yet to, because splitting early is usually an expensive mistake. The topics include an API gateway, circuit breakers, Kafka, the outbox pattern and sagas.

Stage 6 holds the things that only show up with real load and real incidents: the Java memory model, load testing, database replication, infrastructure as code, observability, security and incident drills. Stage 7 pulls everything together for interviews: algorithms, system design, how to record and defend a technical decision, and behavioural questions.

Stages 1 and 2 come out first, then stages 3, 4 and 5. I will plan stages 6 and 7 after I see what readers need, and later posts will say so clearly.

Why learn in this order?

Because each stage explains why the next stage exists. Let me give three examples.

The first example is a bug that people new to Spring often hit: a method is annotated with @Transactional, but when another method in the same class calls it, the transaction has no effect. To understand why, you need to know that Spring wraps your object in a proxy, and a proxy is a direct application of the polymorphism from stage 1. If you jump straight into Spring, you only remember a trick, "don't call it from the same class", without the reason, and you will be stuck when the interviewer asks one more step.

The second example is the N+1 problem of JPA: one request returns a list of orders but actually runs a hundred SQL statements. You only notice it when you already know SQL and know what one JOIN does. That is why SQL sits at the start of stage 2, before JPA.

The third example is in deployment. When you configure an application on AWS so that it can talk to a database, you meet security groups, subnets and DNS. If you do not know basic networking yet, every connection error looks the same, "cannot connect", and your only option is to guess.

In my view, people who give up halfway usually do not do so because it is hard, but because they learn something without knowing what it is for. The order of this roadmap tries to avoid that.

What do junior, middle and senior levels need?

Here is one way of looking at it so you can place yourself. This is my own way of arranging it. Every company has different criteria and different names for levels, so compare it with real job postings of the companies you are aiming for.

For a junior position, job postings and collections of interview questions usually revolve around core Java (OOP, collections, concurrency, the JVM), SQL, and then Spring Boot with JPA. A collection of more than 45 Spring Boot questions from ITViec (a Vietnamese IT job site; the page is in Vietnamese) groups them by Spring Core, MVC and REST, Spring Data JPA, Security and microservices. An article from CareerLink (also Vietnamese) notes that interviewers usually ask "why" more than "what is". Stages 1 and 2 aim at exactly this range.

For a middle position, people usually expect you to build a feature end to end on your own: design the tables, write the API, write the tests, understand why a query is slow, deploy it, and read the log when something fails. Stages 3, 4 and 5 serve this.

For a senior position, the focus moves to trade-offs and scale: why this approach and not another, how the system behaves when load grows tenfold, what you do when an incident happens. A senior interviewer also cares about how you lead others and take responsibility for your decisions. Stages 6 and 7 touch the technical side of this.

Four projects to talk about in interviews

Recruiters rarely want to hear what you have read. They want to hear what you have built and what problems you met. That is why I attach four projects to the roadmap, and each project grows through the posts.

The four running projects
Project 1: order-api       An order API as one block (monolith): Spring Boot
                           + PostgreSQL + Docker + CI/CD, running on AWS ECS
Project 2: flash-sale      Selling a limited quantity when many people order
                           at once: stock never below zero, idempotency, cache, load tests
Project 3: order-services  The order system split into several services that
                           talk through events: Kafka, outbox, saga, tracing
Project 4: cloud-ops       Infrastructure as code, observability, incident drills

The name of each project says exactly what it does: order-api is an API for placing orders, flash-sale is selling limited stock, order-services is an order system made of several small services, and cloud-ops is the cloud infrastructure and operations part.

Each project will have an architecture diagram, real measurements from the machine I run it on, an ADR (a short document recording an architecture decision and the options that were dropped) and a README so that someone else can run it again. For the parts that run on AWS, I will state the cost and how to clean up the resources so you are not charged by accident.

I want to be direct about one thing: the Mộc café is an illustrative situation, not a business with real users. These four projects give you something to say about architecture, decisions and measurement, but they do not replace the experience of operating a system that has real customers. If you fork them into your own projects and replace the Mộc café with a problem that you care about, your story will be much more convincing.

How do you finish instead of quitting halfway?

Everyone can say how to do it, but doing it is the hard part. Here are a few concrete suggestions.

  1. After every post, run the code on your own machine and change one thing. Change the data, break it on purpose, see what error you get.
  2. Do not wait until you have learned everything before building. Every stage has a small product that runs, so stop and finish that product.
  3. Read the error message and the stack trace carefully before you ask anyone, or ask an AI. The post on how to read a stack trace in the Programming skills topic will help.
  4. Go to interviews earlier than you think. An interview is the fastest way to find out what you lack. After stage 2 you can already try applying for a junior position, and the post on 10 mistakes that get a CV rejected helps your application survive the first round.
  5. Take notes on what you learn. Writing it again in your own words is the best way to find out whether you understood.

If you already know Java, take a quick test: can you explain how equals and hashCode relate to a HashMap, why String is immutable, and why two threads that increment the same counter give a wrong result? If you can, you may skim stage 1 and go into stage 2. If you stumble on one question, read exactly the post on that topic, and there is no need to read the whole stage.

What can this roadmap do, and what can it not do?

I want to state the limits from the start, so you set the right expectations.

What it can do: arrange knowledge in an order that has a reason, give you running code with explanations, point out the mistakes that newcomers often make, and give you interview questions with ways to answer them.

What it cannot do yet: replace real work experience. A senior position does not only ask what you know, it also asks how you made decisions, how you handled incidents, and how you helped teammates improve. Those things only come from working with other people on a system that has users. The senior interview preparation in stage 7 will give you a frame to present them, but it does not promise that reading it is enough to pass.

One more thing: technology changes fast. New versions of Java and Spring Boot come out all the time. I will state the version used in every post and check it against the official documentation before I write. You can compare with the Spring Boot documentation and the official Java learning site of Oracle.

Where do you start?

If you do not know Java yet, start with stage 1, with the first post about installing the JDK and running your first program. If you already know Java and want to go straight to Spring, open stage 2. If you are preparing for interviews, try answering the interview questions first to see where you are missing something, then come back and read exactly that post.

Each stage has its own series page that lists the posts that are out (later stages will get posts when their turn comes): Learn Java from scratch for backend developers, Learn Spring Boot: build an order API from zero, Backend optimization, Deploy Spring Boot to AWS and Microservices with Spring Cloud and Kafka. You can also follow the other roadmaps of the blog.

Which stage are you at, and which part would you like me to go deeper into first? Let me know.

Get the next post by email.

One email a week, only when there is something worth reading. No spam.