Spring Boot Roadmap

Introduction

This roadmap is designed to guide you through the fundamentals of Spring Boot and backend development, from beginner to advanced levels. Each stage is thoughtfully structured with specific goals, curated resources, and hands-on tasks to ensure practical learning.

Created and Prepared By Mohamed Zkrallah.

Criteria

Three Levels: Beginner, Intermediate, and Advanced, with a focus on building strong fundamentals before progressing to advanced topics.
Practical Approach: Tasks are abstracted for brevity, with more details available in Notion.
Bonuses: Bonuses are included for deeper learning. They are not optional, don’t skip them entirely, do them later if you don't have time then. Most bonuses will be already discussed in later weeks.
AI-Assisted Learning: Feel free to use AI to explore topics further but avoid relying on it to complete tasks or write code for you.
Time Interval: Some topics can not be finished in just one week, try to learn as much as you can and get back later.
Self-Learning & Research: As you progress to the advanced level, expect to do more self-learning and independent research. Not everything will be spoon-fed with resources. Developing the ability to learn on your own, read documentation, and experiment with implementations is crucial.
Quick Tip: I believe in learning by building. Build what you want to learn and learn from what you build. Do not just study theory, but implement what you have learned in a project or even a simple program.

Level 1: Beginner (Weeks 1–10)

Focus:

Version control using Git & GitHub.
Basic knowledge of HTML, CSS, and JavaScipt for the Front-end.
The OSI Model, specially, the application layer and HTTP internals.
Java programming language and OOP (Object-Oriented Programming) in Java.
Prerequisites for Spring Boot.
Introduction to Spring Boot and Spring MVC.
Introduction to Database sytems and RDBMS (MySQL Server & PostgreSQL).
Introduction to ORMs and Spring Data JPA.

Week 1: Introduction to Version Control with Git

Topics:

Git basics
GitHub
Branches
Commits
Pull requests

Resources:

Task: Setup your GitHub account and upload your first repository.

Week 2: Basic HTML, CSS, and JS for the Front-end

Topics:

HTML
CSS
JavaScipt
Basic Front-end Knowledge

Resources:

Task: Build a simple front-end for a website of your choice (portfolio, to-do list app, blog, etc).

Week 3: Basics of Web Development

Topics:

HTTP internals
REST APIs
Introduction to backend development
CCNA
OSI model

Resources:

Task:
1- Write a document explaining how a REST API works and how clients and servers communicate through HTTP.
2- Build a simple HTTP client program that performs GET, POST requests to some online fake API.

Note: Do not stop learning computer networking after this week. Computer networking is from the fundamentals of computer science, specially in backend.

Week 4: Introduction to Programming

Topics:

Java syntax
Basics of programming
Variables
Loops
Conditionals

Resources:

Task:
1- Write simple programs like calculating the sum of numbers or finding the largest number in an array.
2- Implement basic binary search in Java.
3- Try to solve some Leetcode easy questions using Java.

Bonus: Learn about Date Formatting.

Note: You should not know everything about Java for now, meaning that you don't have to watch those very long playlist to the end. Just get comfortable with the Java programming language.

Week 5: Object-Oriented Programming (OOP)

Topics:

Classes
Objects
Abstraction
Inheritance
polymorphism
Encapsulation

Resources:

Task:
1- Create a basic student management system with classes for Student and Course.
2- Shapes Task

Bonus: Learn about Regex (Regular Expressions).

Note: Do not stop learning OOP after this week. OOP is from the fundamentals of computer science. You should be learning OOP all the time, specially in Java.

Week 6: Java Essentials for Spring Boot

Topics:

Maven/Gradle
Basic file I/O
Java collections

Resources:

Task: Create a Java application to manage a library system using ArrayList.

Bonus: Learn about Java Generics and Callback functions.

Note: While it's okay to use either Maven or Gradle for both Java and Kotlin Spring Boot Projects, I recommend sticking with Maven as it's more easy to understand and work with than Gradle. Also it's more common to use Maven with Java projects and Gradle with Kotlin projects. Anyways, I recommend using Maven alawys (specially as long as you are a beginner).

Week 7: Introduction to Spring Boot

Topics:

Spring Boot overview and setup
Basic annotations (@RestController, @GetMapping, @PostMapping)
Spring MVC

Resources:

Task: Create a simple REST API to manage books.

Bonus: Learn about MULTIPART requests.

Note: Dependency Injection, Spring JPA, and some concepts are mentioned in this tutorial but we will go through the details of them in later weeks.

Week 8: Database Basics with MySQL and PostgreSQL

Topics:

What is a database?
Introduction to SQL
Introduction to PostgreSQL and MySQL Server
Setting up the RDBMS
Basic queries

Resources:

Task:
1- Create a database for the book management system.
2- Try to solve some easy SQL questions on HackerRank or Leetcode.

Bonus: Learn about relationships and join statements.

Note: Do not stop learning database after this week. Database is from the the fundamentals of computer science, specially in backend.

Week 9: Integrating Spring Boot with PostgreSQL & Spring Data JPA

Topics:

Spring Data JPA ORM
CRUD operations
SQL and ORMs

Resources:

Task: Enhance the book management system with a PostgreSQL database.

Bonus: Learn how to hot-reload a Spring Boot project.

Week 10: Building a Student Management System

Project: Build a Student Management System with REST APIs and PostgreSQL.

Objectives

Build a RESTful API for managing students.
Implement the Student and Course entities.
Implement a one-to-many relationship between Students and Books.
Implement a many-to-many relationship between Students and Courses (Bonus).
Use Spring Boot with Spring Data JPA and PostgreSQL.

Endpoints

Create a new student POST /students
Retrieve all students GET /students
Retrieve a student by ID GET /students/{id}
Update a student's details PUT /students/{id}
Delete a student DELETE /students/{id}
Same thing for books and courses.
Assign a book to a student POST /students/{studentId}/books/{bookId}
Retrieve the student who owns a book GET /books/{bookId}/owner
Retrieve all books of a student GET /students/{studentId}/books
Remove a book from a student DELETE /students/{studentId}/books/{bookId}
Enroll a student in a course POST /students/{studentId}/courses/{courseId}
Retrieve all students in a course GET /courses/{courseId}/students
Retrieve all the courses of a student GET /students/{studentId}/courses
Remove a student from a course DELETE /students/{studentId}/courses/{courseId}

Note: When a book or course is deleted, its association with any students should also be removed.

Level 2: Intermediate (Weeks 11–25)

Focus:

Spring Core concepts like IoC, DI, AOP, Resources, etc.
Input validation, error handling, and testing (unit & integration).
Middlewares and Spring Security.
Pagination, filtering, Lombok, file uploads.
Sending OTPs using SMTP servers and SMS.
More about SQL databases and difference between JPA, Spring Data JPA, and Hibernate ORM.
Introduction to NoSQL databases and MongoDB.
Asynchronous programming, Reactive Spring Boot, Spring Data R2DBC, and Spring WebFlux.
Caching mechanisms and Introduction to Redis cache.
Real-time communication with WebSockets and streaming with WebRTC.

Week 11: Spring Core (IoC & DI)

Topics:

Inversion of Control & IoC Container
Dependency Injection design pattern
Beans and Bean lifecycle.
Spring annotations (@Bean, @Component, @Configuration, etc)

Resources:

Task: Apply what you understood to the Student Management System or revisit what you already did for dependency injection.

Bonus: Learn about Spring Profiles.

Week 12: Validation and Error Handling

Topics:

Input validation (@Valid, @NotNull, Optional<>)
Custom exception handling (@ControllerAdvice)
Global exception handling (@RestControllerAdvice, @ExceptionHandler)

Resources:

Task: Add validation to the Student Management System and create custom error messages for invalid inputs.

Bonus: Learn about CORS.

Week 13: Testing in Spring Boot

Topics:

Unit testing with JUnit and Mockito
Integration testing with testcontainers
API documentation
Swagger and Postman API

Resources:

Task: Write unit tests for services and controllers, and integration tests for the database layer.

Bonus: Learn about Postman API.

Week 14: Filters & Interceptors, Lombok, Pagination & Filtering, File Uploads

Topics:

Spring Boot Filters
Spring Boot Interceptors
Lombok Annotations
Pagination & Filtering Data
Uploading a File with MULTIPART Requests

Resources:

Task:
1- Add logging feature to the students' management system using filters once and using interceptors once.
2- Add the pagination feature to the students' management system.
3- Add lombok annotations to the students' management system.
4- Create a simple Spring Boot application that allows users to upload files using multipart requests and stores them in the local file system (or database for learning purposes).

Bonus: Take a look on Firebase and try to implement file upload & download feature using Firebase instead of the above ways.

Note: In these resources, uploaded files are either stored in a database or saved as local files on the server. However, in most cases, this is not the best approach. Typically, uploaded files should be stored in a cloud service provider such as AWS or Firebase, while only the file URL is saved in the database. We will cover this in more detail during the Firebase week.

Week 15: Introduction to Spring Security (Part 1)

Topics:

Authentication vs Authorization
Basic Authentication
Session-based authentication
Role-based access control
CORS

Resources:

Task:
1- Implement basic authentication in your Spring Boot application.

Use httpBasic() in your security configuration.
Test the secured endpoints using Postman.

2- Implement session-based authentication.

Configure formLogin() for session management.
Use HttpSession to store user-specific data.

3- Configure role-based access control (e.g., allow only admins to delete resources).
4- Test the secured endpoints using Postman.

Bonus: Learn about REST Client in Spring Boot.

Note: I recommend the first part of Lazy Programmer's playlist for this week.

Week 16: Spring Security (Part 2): JWT and OAuth2

Topics:

JWT (JSON Web Tokens)
OAuth2
Custom security configurations

Resources:

Task:
1- Implement JWT-based authentication in your Spring Boot application.

Generate and validate JWTs.
Add a refresh token mechanism for token renewal.

2- Secure your REST APIs with role-based access using JWT.
3- Integrate OAuth2 with a provider like Google or GitHub.
4- Test the secured endpoints using Postman.

Bonus: Learn about Filters in Spring Boot.

Note: I recommend watching the second part of Lazy Programmer's playlist and Telusko's video for this week.

Week 17: Sending Messages to Users via E-mail & SMS

Topics:

SMTP servers
SMS messages
OTPs (One Time Password)

Resources:

Task:
1- Configure a Gmail SMTP and write the email sending service.
2- Create a simple email verification service by sending an OTP to the given email.

Bonus: Learn about pagination.

Week 18: More SQL Databases and Hibernate ORM

Topics:

Advanced SQL concepts
Hibernate ORM
Joins & relationships
Aggregate functions
Database Normalization

Resources:

Task: Solve SQL problems on HackerRank or Leetcode.

Bonus: Learn how to design a database.

Note: It's important to understand the difference between JPA, Hibernate, and Spring Data JPA. JPA is a specification or an interface, Hibernate is an implementation of this interface and an ORM, and Spring Data JPA is a framework that relies on JPA implementations like Hibernate or any other implementation (but Hibernate is the default one). While Spring Data JPA is the most used option for ORMs and database interactions and that you will rarely need to do raw Hibernate, it's good to understand what's happening under the hood. Do not get overwhelmed if you don't understand Hibernate well for now, it has a complex learning curve, just do your best.

Week 19: Building an E-Commerce Website Backend

Project Overview

In this project, you will build the backend of an E-Commerce website using Spring Boot. The backend should expose REST APIs for managing users, products, orders, and authentication. You will also implement security features, including JWT authentication and email verification, and enhance the system with pagination, filtration, file uploads, input validation, and exception handling.

Objectives

Develop a RESTful API for an e-commerce platform.
Implement user authentication and authorization using Spring Security & JWT.
Implement email verification using SMTP.
Support product pagination and filtering.
Enable file uploads for product images.
Implement input validation and exception handling.
Write unit tests for key functionalities.
Use Spring Data JPA with PostgreSQL.

Entities & Relationships

User (Can be a customer or admin)
Product (Sold by the e-commerce platform)
Category (Each product belongs to a category)
Order (Contains multiple products)
OrderItem (A product inside an order, with quantity and price)
Cart (Each user has a shopping cart)

Endpoints

Authentication & User Management

Register a new user POST /auth/register
Verify email GET /auth/verify-email?token={token}
Log in POST /auth/login
Refresh JWT token POST /auth/refresh-token
Get the current user's profile GET /users/me
Update user details PUT /users/{userId}

Product & Category Management

Create a new product POST /products
Retrieve all products with pagination & filtering GET /products?page={page}&size={size}&category={category}
Retrieve a product by ID GET /products/{productId}
Update a product PUT /products/{productId}
Delete a product DELETE /products/{productId}
Upload product images POST /products/{productId}/upload-image
Create a new category POST /categories
Retrieve all categories GET /categories

Shopping Cart & Order Management

Add a product to cart POST /cart/{userId}/add/{productId}
View cart items GET /cart/{userId}
Remove a product from cart DELETE /cart/{userId}/remove/{productId}
Place an order POST /orders/{userId}/checkout
Retrieve all orders of a user GET /orders/{userId}
Retrieve order details GET /orders/{orderId}

Bonus: Create a simple front-end that uses your API.

Week 20: Introduction to NoSQL Databases

Topics:

Introduction to NoSQL Databases
Spring Data MongoDB
MongoDB
Mongosh & MongoDBCompass
Spring Data MongoDB
Collections, Documents, CRUD operations

Resources:

Task:
1- Build a simple CRUD application of your choice (task manager, profile manager, books manager, etc) with Spring Data MongoDB.
2- Implement pagination and sorting in MongoDB queries.
3- Implement a search feature using MongoDB’s text indexes.

Bonus: Learn about filtering data.

Note: Spring Data MongoDB is so close to Spring Data JPA, if you are good with Spring Data JPA, this week would be easy for you.

Week 21: Introduction to Asynchronous Programming in Spring Boot

Topics:

Blocking vs Non-blocking Programming
Reactive Programming
Parallelism vs Concurrency
Threads and Threading
CompletableFuture in Java
@Async & @EnableAsync Annotations in Spring Boot

Resources:

Task:
1- Create a method that performs a long-running task asynchronously using CompletableFuture.

Apply what you have learned using runAsync and supplyAsync.
Apply what you have learned using thenAccept, thenApply, and thenRun.
Run multiple CompletableFuture tasks in parallel and combine their results.

2- Implement a Spring Boot service with an @Async annotated method.
3- Redo the above task but this time configure a custom thread pool executor.

Bonus: Learn about Java Virtual Threads (please note that this is an advanced topic, just take a quick look).

Week 22: Introduction to Spring WebFlux, Spring Data R2DBC, Reactive Programming in Spring Boot

Topics:

Introduction to Spring WebFlux
Non-blocking Code in Spring Boot
Mono & Flux
Spring WebFlux Annotation-based programming model
Spring WebFlux Functional programming model
Introduction to Spring Data R2DBC

Resources:

Task:
1- Create a Spring WebFlux REST API:

Set up a Spring Boot project with WebFlux.
Create a simple reactive endpoint that returns a Mono and a Flux.
Test the API using Postman.

2- Implement a Reactive CRUD API with WebFlux:

Create a Product entity and a corresponding ProductController.
Implement CRUD operations using Mono and Flux.
Use a reactive database (PostgreSQL + R2DBC for example).

3- Spring WebFlux Functional API:

Implement the same CRUD API using the functional programming model (instead of the annotation-based approach).

4- Create a Spring MVC REST API:

Recreate the REST API you did in the first task using Spring MVC instead of Spring WebFlux.
Add logs in both projects.
Observe the thread names handling each request.

Bonus:

Learn how to integrate Spring Security with WebFlux (SecurityWebFilterChain).
Explore WebClient as a non-blocking alternative to RestTemplate.

Note:

WebFlux is not always better than Spring MVC. It’s optimized for high-concurrency and real-time streaming applications.
Use Spring WebFlux when you need to handle thousands of concurrent requests with minimal resource usage.
If your project does not require reactive programming, sticking with Spring MVC might be a better choice.
Spring WebFlux is a big topic, don't get overwhelmed, learn as much as you can and revisit later.
Try to map what you've learned so far to WebFlux and explore alternative approaches for future topics to be applicable to Spring WebFlux.

Week 23: Caching and Introduction to Redis Cache in Spring Boot

Topics:

What is caching?
Caching in Spring Boot
Redis cache
Spring Data Redis
@EnableCaching, @Cacheable, @CacheEvict, and @CachePut annotations
Jedis and RedisTemplate

Resources:

Task:
1- Install and run a Redis server locally. 2- Integrate Redis into a Spring Boot Application:

Create a service class with methods that fetch data (e.g., from a database or an external API).
Annotate methods with @Cacheable to cache their results.
Use @CacheEvict and @CachePut annotations where appropriate to manage cache entries.

Bonus: Learn about Spring Data Reactive Redis.

Note: I highly recommend reading the final two articles in the resources of this week as well as the guide documentation.

Week 24: Real-Time Communication with Sockets & Socket.IO, Streaming with WebRTC Basics.

Topics:

Raw Sockets, WebSocket, and Socket.IO
Real-time communication
Introduction to WebRTC
ZegoCloud SDK
Socket.io in Spring Boot
SockJS & STOMP in Spring Boot

Resources:

Task:
1- Implement a Real-Time Chat Application:

Set up a Spring Boot project.
Integrate Socket.IO to handle real-time communication.
Create a simple chat interface where multiple users can send and receive messages instantly.
Test the application with a basic front-end or using postman to ensure messages are transmitted in real-time.

2- Explore WebRTC Basics:

Understand the fundamentals of WebRTC and its use cases.
Set up a basic peer-to-peer connection between two clients using WebRTC.
Transmit simple data (e.g., text messages) between the peers.

Bonus: Learn a little about message queues.

Note:

In most chat services, a cloud messaging service is used to initiate the socket connection programmatically when the receiver is inactive at the moment the sender sends a message. We will discuss cloud messaging services in detail later in the Firebase week in the advanced level.
There aren’t many good resources on implementing WebRTC in Spring Boot without using ZegoCloud, so feel free to use your preferred LLM or external resources to learn this part. If you find any useful implementations, consider contributing them to the roadmap.
Many open-source WebSocket implementations are available, with Socket.io being the most common. However, some companies use alternatives like Pusher or STOMP. For brevity, this week’s resources focus on Socket.io, but it’s good to be aware of other implementations you might encounter in different environments.

Week 25: Building a Real-Time Chat Application

Project Overview

In this project, you will build a real-time chat application using Spring WebFlux and MongoDB. The application will support private messaging between users, real-time communication using WebSockets (Socket.IO), and persistent chat history storage in MongoDB.

Objectives

Develop a fully reactive backend using Spring WebFlux.
Use MongoDB as a NoSQL database for storing users, messages, and conversations.
Implement WebSockets for real-time messaging.
Implement user authentication and authorization using Spring Security & JWT.
Implement email verification using SMTP.
Provide REST APIs for user management and chat history retrieval.
Implement input validation and exception handling.
Write unit tests for key functionalities.

Entities & Relationships

User (`users` collection)

id, username, email, password, profilePicture, status (online/offline).
Users can send and receive messages.
Email verification required before accessing chat.
Feel free to add any additional fields.

Message (`messages` collection)

id, senderId, receiverId, content, timestamp.
Messages are stored persistently in MongoDB.
Feel free to add any additional fields.

Conversation (`conversations` collection)

id, participants[], lastMessage, lastUpdated.
Stores user chat sessions for easy retrieval.
Feel free to add any additional fields.

Endpoints

User Management

Register a new user → POST /users/register
Verify email → GET /users/verify?token={token}
Login a user → POST /users/login
Update user profile → PUT /users/{userId}
Get user details → GET /users/{userId}
Add any missing endpoints.

Chat Management (REST APIs)

Retrieve chat history with a user → GET /chats/{userId}
Delete a conversation → DELETE /chats/{userId}
Add any missing endpoints.

Real-Time Chat (WebSockets - Socket.IO)

Connect to the chat → WS /chat/connect (JWT authentication required)
Send a message → WS /chat/send
Receive a message → WS /chat/receive
Typing indicator → WS /chat/typing
Mark message as read → WS /chat/status
Add any missing endpoints.

Level 3: Advanced (Weeks 26–35)

Focus:

Introduction to payment Gateways.
Firebase RTDB, Cloud Messaging, cloud Storage, Firestore, Authentication, and more.
More SQL and NoSQL and introduction to JDBC and more about R2DBC.
GraphQL and task scheduling.
Introduction to Deployment and Docker.
Introduction to Message queues.
Introduction to Microservices architecture.

Week 26: Payments and Stripe Payment Gateway

Topics:

Payments in Spring Boot
Stripe payment gateway
Paypal payment

Resources:

Task:
1- Set up a Stripe account and create API keys.
2- Integrate Stripe in a Spring Boot application to process payments.
3- Implement an endpoint for handling one-time payments.

Bonus: Learn about other payment gateways and SDKs like Fawry or Paymob for example.

Note: Stripe is one of the most widely used payment gateways, but it's not the only option available. Companies can choose any payment gateway that best suits their needs. This week focuses specifically on Stripe due to its popularity and extensive documentation. Feel free to learn more about other payment gateways.

Week 27: Building GraphQL Services

Topics:

Graphql vs REST
Graphql in Spring Boot
GraphQL schemas, queries, and mutations

Resources:

Task:

Set up a GraphQL server using Spring Boot and Spring GraphQL.
Define GraphQL schemas for a simple application (Users and Posts for example).
Implement queries to fetch data and mutations to modify data.
Integrate Spring Data JPA to fetch data from a relational database.
Implement error handling for invalid requests.
Test GraphQL APIs using GraphiQL or Postman.

Bonus: Learn how to avoid the N + 1 problem in Graphql and relational databases.

Note:

I recommend watching Spring Academy's, Amigoscode's, and Java Techie's videos for integrating Graphql in Spring Boot.
Most of the video resources mentioned above apply on the same example but each video might introduce a new idea or tool that might not have been mentioned in the the other videos.

Week 28: Introduction to Firebase Services

Topics:

Firebase as a BAAS.
Firebase Cloud Messaging (FCM)
Firebase Cloud Storage
Firebase Authentication
Firebase Firestore
Firebase Real-Time Database (RTDB)

Resources:

Task:
1- Modify the file uploading service you created before or create a new one that uses Firebase Storage instead of local storage.
2- Create a Firebase Cloud Messaging (FCM) service that sends push notifications tozz users.
3- Use Firebase Firebase or Firebase RTDB as a database in a simple CRUD application.

Bonus: Explore other Backend-as-a-Service (BaaS) providers like Supabase and compare them with Firebase. Additionally, check out alternative cloud service providers to understand their offerings.

Note:

I recommend reading the Medium article on Firebase Storage for the file uploading service.
Ulter's video provides a great guide on setting up Firebase FCM for push notifications.
There aren't many video resources for Firebase RTDB, so rely on the official documentation or explore other resources online.

Week 29: Task Scheduling

Topics:

Task Scheduling
@Scheduled and @EnableScheduling annotations
cron
Fixed-rate vs. fixed-delay scheduling
Handling asynchronous scheduled tasks

Resources:

Task:
1- Implement a basic scheduled task that runs every 10 seconds using @Scheduled.
2- Modify the task to use a cron expression to execute at a specific time of day.
3- Create a dynamic scheduling system, where tasks can be enabled/disabled based on application settings.
4- Implement an asynchronous scheduled task using @Async.

Bonus: Learn about the Decorator Design Pattern.

Note: If your application requires more control, consider Quartz Scheduler, which supports distributed job scheduling.

Week 30: More SQL Database, Spring JDBC, More Spring R2DBC.

Topics:

JDBC
Spring Data JDBC
Spring Data R2DBC
SQL database
Database migrations
Transactions
Triggers and Indexes

Resources:

Task:
1- Implement CRUD Operations using Spring JDBC (JdbcTemplate).
2- Create one or two database migrations to an old database using Flyway.
3- Solve More SQL questions on Leetcode and HackerRank.

Bonus: Learn about recursive queries and window functions in SQL.

Note:

The "Java Database Connectivity | JDBC (Telusko)" video is for pure JDBC without Spring Boot. It helps to understand JDBC fundamentals.
You will need to use JDBC instead of Spring Data JPA in some cases like: avoiding ORM overhead for high-performance applications, using raw SQL queries efficiently without automatic entity mapping (very useful in microservices), and when working with legacy databases that don’t fit well into JPA’s entity model

Week 31: More NoSQL Database and Spring Data MongoDB.

Topics:

Advanced MongoDB queries (aggregation, indexing, transactions)
Performance optimization with MongoDB
Advanced Spring Data MongoDB features (custom queries, projections, auditing)

Resources:

Task:
1- Create a MongoDB-backed Spring Boot application using Spring Data MongoDB.
2- Implement advanced CRUD operations with support for:

Custom queries using @Query
Pagination and Sorting
Transactions
Indexes

2- Use the Aggregation Framework to build advanced reporting queries (e.g. total sales per day, top products, etc.)
3- Add indexes for optimal query performance (e.g. on email, creation date).

Bonus: Explore other NoSQL databases like Cassandra, Redis, and CouchDB.

Week 32: Docker and Deployment.

Topics:

Virtualization vs Containarization
Docker and Docker Compose
Deployment

Resources:

Task:
1- Install Docker and Docker Compose on your system.
2- Pull and run basic images like ubuntu, postgresql, and mysql.
3- Create your own Dockerfile for a small web server.
4- Use Docker Compose to spin up a multi-container app.
5- Explore common docker CLI commands: ps, images, logs, exec, etc.
6- Write a document containing what you have learned about docker.

Bonus: Learn about Kubernetes.

Note: Docker is one of the most essential tools for modern backend developers. Understanding images, containers, and orchestration tools like Docker Compose is crucial for building scalable, portable applications.

Week 33: Microservices Architecture, Gateway, Discovery Server, and Config Server

Topics:

Resources:

Bonus:

Note:

Name		Name	Last commit message	Last commit date
Latest commit History 31 Commits
LICENSE		LICENSE
README.md		README.md

License

muhammadzkralla/spring-boot-roadmap

Folders and files

Latest commit

History

Repository files navigation

Spring Boot Roadmap

Introduction

Criteria

Level 1: Beginner (Weeks 1–10)

Week 1: Introduction to Version Control with Git

Week 2: Basic HTML, CSS, and JS for the Front-end

Week 3: Basics of Web Development

Week 4: Introduction to Programming

Week 5: Object-Oriented Programming (OOP)

Week 6: Java Essentials for Spring Boot

Week 7: Introduction to Spring Boot

Week 8: Database Basics with MySQL and PostgreSQL

Week 9: Integrating Spring Boot with PostgreSQL & Spring Data JPA

Week 10: Building a Student Management System

Objectives

Endpoints

Level 2: Intermediate (Weeks 11–25)

Week 11: Spring Core (IoC & DI)

Week 12: Validation and Error Handling

Week 13: Testing in Spring Boot

Week 14: Filters & Interceptors, Lombok, Pagination & Filtering, File Uploads

Week 15: Introduction to Spring Security (Part 1)

Week 16: Spring Security (Part 2): JWT and OAuth2

Week 17: Sending Messages to Users via E-mail & SMS

Week 18: More SQL Databases and Hibernate ORM

Week 19: Building an E-Commerce Website Backend

Project Overview

Objectives

Entities & Relationships

Endpoints

Authentication & User Management

Product & Category Management

Shopping Cart & Order Management

Week 20: Introduction to NoSQL Databases

Week 21: Introduction to Asynchronous Programming in Spring Boot

Week 22: Introduction to Spring WebFlux, Spring Data R2DBC, Reactive Programming in Spring Boot

Week 23: Caching and Introduction to Redis Cache in Spring Boot

Week 24: Real-Time Communication with Sockets & Socket.IO, Streaming with WebRTC Basics.

Week 25: Building a Real-Time Chat Application

Project Overview

Objectives

Entities & Relationships

User (users collection)

Message (messages collection)

Conversation (conversations collection)

Endpoints

User Management

Chat Management (REST APIs)

Real-Time Chat (WebSockets - Socket.IO)

Level 3: Advanced (Weeks 26–35)

Week 26: Payments and Stripe Payment Gateway

Week 27: Building GraphQL Services

Week 28: Introduction to Firebase Services

Week 29: Task Scheduling

Week 30: More SQL Database, Spring JDBC, More Spring R2DBC.

Week 31: More NoSQL Database and Spring Data MongoDB.

Week 32: Docker and Deployment.

Week 33: Microservices Architecture, Gateway, Discovery Server, and Config Server

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

User (`users` collection)

Message (`messages` collection)

Conversation (`conversations` collection)

Packages