MsSpringDev

Professional

Spring

Creating and Deploying a Microservice Application

🔧

🔧 Full development cycle —

from code to production

🚀

🚀 A ready-to-hire technology stack

—everything you need for a Middle Java developer position.

💡

💡 Practice without "water" —

only real scenarios

Spring —
the standard of modern
Java development

Spring Framework is the basis for creating high-load and secure applications in Java. It is used in 80% of enterprise projects, including banking systems, streaming platforms and corporate services.

Developer workspace with code on laptops in neon lighting

Reasons to learn Spring

Speeds up
development

built-in modules (Boot, Security, Data) eliminate routine code.

Provides
scalability

supports microservices, caching and distributed systems.

Guarantees
security

ready-made solutions for authentication, authorization and protection against vulnerabilities.

Required by
employers

Spring Boot and Spring Cloud are among the top skills for Java developers.

Spring is a must-have for any Java developer who wants to build in-demand and technologically advanced products.

Who is the right person for the course?

✓ Beginner Java developers,

who want to move from the basics of Java to professional development on Spring Boot.

✴ Backend developers in other languages (Python, C#, PHP),

who want to master the Java ecosystem.

✴ Self-taught and students,

who want to add a real project with a full development cycle to their portfolio.

✴ Those preparing
for
interviews

the course covers key topics that are asked in top IT companies.

Learning illustration with person and educational icons

What you need to know
to start learning

This course is designed for developers who have experience with Java. We expect you to have basic knowledge of Java.

After training, you will have
all the necessary skills to work in Spring

✅

CREATE RESTFUL
APIS

on Spring Boot using controllers, services and repositories, including working with DTOs and documentation via Swagger

✅

WORK WITH
DATABASES

via Spring Data JPA and Hibernate, configure migrations with Flyway and write complex queries using Criteria API

✅

IMPLEMENT
APPLICATION SECURITY

with Spring Security, including JWT authentication and a role-based access model (User, Admin, SuperAdmin)

✅

MICROSERVICE ARCHITECTURE

breaking the application into separate services (IAM, Gateway) and organizing their interaction

✅

WORK WITH
ASYNCHRONOUS EVENT

via Apache Kafka, configure a message broker and process them in microservices

✅

CONTAINERIZE
APPLICATIONS

with Docker, create service images and manage them via Docker Compose

✅

CONFIGURE
DEPLOYMENT

to a real server with Nginx, SSL certificates and load balancing

✅

WRITE
TESTS

(unit and integration) for key components of the application, increasing its reliability

Mobile app mockups

During the training, you will develop your own project,
which you will add to your portfolio

You will develop a production-ready microservice application. The project includes 4 interconnected services (API Gateway, Auth Service, Core Service, Analytics Service) with a full CI/CD pipeline and test coverage of key modules.

RESULT:

a working cloud solution for a Middle+ developer, which can be immediately added to your portfolio and shown to employers as an example of professional skills.

Course Program

  • About the project
  • Functional demo
  • Demo of the final result: Project, Basics, Classes, Database
  • Swagger, Postman, Docker and Hosting
  • Tools and dependencies required for the course
  • Creating a Spring Boot project from scratch in Intellij IDEA
  • Project structure
  • Configuring configuration files and profiles
  • Overview
  • Accessing the GitLab repository
  • Dependency injection via constructor
  • Dependency injection via setter
  • Configuring service implementation via @Primary and @Qualifier annotations
  • Overview
  • Installing and connecting the Database
  • Configuring and connecting dependencies
  • SQL queries. CREATE, INSERT, DROP. Migrating data into tables
  • Working with Entities
  • Overview
  • Technical Note (working branches)
  • JpaRepository + @GetMapping, getting data from the DB
  • DTO, Service, Mapping, creating a response structure
  • Exception Handling: global error handler (@ControllerAdvice)
  • MapStruct, replacing manual mapping in services (@Mapper)
  • POST request, adding objects to the database via API
  • Data validation, @NotNull, @NotBlank and duplicate handling
  • PUT request: updating data in the database via API
  • Lossless deletion, @DeleteMapping and softDelete
  • Pagination, big data processing (Pageable, Page)
  • Filtering, searching and sorting (Specification, Criteria API)
  • Access to GitLab repository
  • Overview
  • Adding a User entity. Extending the database schema
  • Searching for a user by ID. Controller, service, mapping
  • Creating a user: POST request, validation, and saving
  • Relationship between Post and User. @ManyToOne, @OneToMany, FOREIGN KEY
  • Adding the post author name to the API (createdBy)
  • Extending UserController: updating, deleting, searching
  • Connecting Spring Security. First security setup
  • Password encryption. BCrypt and PasswordEncoder
  • Adding user roles (User, Admin, SuperAdmin)
  • Adding the Role entity and linking users to roles
  • Adding roles to DTO. Updating services and mapping
  • Implementing JWT for authentication and authorization
  • Spring Security + UserDetailsService. Working with users
  • Preparing an API for login. Request, validation, DTO
  • Implementing user authentication. JWT and login processing
  • Configuring Spring Security, closing endpoints and configuring API protection
  • Adding an AuthController, testing the login process in Postman
  • Adding a Refresh Token, a new table and entity
  • Creating a RefreshTokenRepository and a service for working with tokens
  • Validating and updating a Refresh Token, automatically extending a session
  • Adding a Refresh Token to an API response, updating the mapping and service
  • Creating an endpoint for updating tokens, testing in Postman
  • Creating a DTO for registering a new user
  • Implementing the registration process + password hashing and issuing tokens
  • Adding password validation. Complexity and match check
  • Registration error handling, improving validation and exceptions
  • Registration code optimization, moving checks to a separate class
  • Associating posts to an authorized user, using JWT
  • Restricting access to posts, method-level protection
  • Restricting access to endpoints via Security Config
  • Optimizing access rights protection
  • Restricting access to User Service
  • Module summary
  • Overview
  • Preparing the DB, creating the table and the Comment entity
  • Creating a DTO for the service
  • Implementing the repository and service layer
  • Creating a controller (@RestController)
  • Adding a new comment (@PostMapping)
  • Updating comments (@PutMapping)
  • Deleting comments (@DeleteMapping)
  • Getting a list of all comments (findAll)
  • Searching, sorting and filtering objects
  • Access restriction and service security
  • Overview
  • Preparing the environment and installing Docker
  • Creating a Dockerfile, packaging the IAM service into a container
  • Building and running the application in a Docker container
  • Managing Containers and Images, Useful Commands
  • Module summary
  • Overview
  • Basics of API documentation. OpenAPI vs Swagger.
  • Connecting Swagger to the project and setting up Security
  • Configuring OpenAPI. JWT and endpoint groups
  • Customizing Swagger UI, improving the interface
  • Exporting API documentation: JSON, YAML and integration with Postman
  • Module summary
  • Overview
  • Introduction to UserService Testing (Test Overview)
  • Setting up the test environment [UserService]
  • Testing getting a user by ID [UserService]
  • Testing creating a new user [UserService]
  • [Post service] Mock dependencies, prepare test data
  • [Post service] Testing getting a post by ID
  • [Post service] Testing creating a new post
  • [Comment service] Mock dependencies, prepare test data
  • [Comment service] Testing getting comments by ID
  • [Comment service] Testing creating a new comment
  • [Auth service] Mock dependencies, prepare test data
  • [Auth service] Testing the login method (valid test/invalid)
  • [Auth service] Testing user registration
  • Overview
  • Integration Tests Overview (Simple and Advanced)
  • Writing the first integration test [UserController]
  • Negative scenarios and testing access rights differentiation
  • Parse the JSON response and check the response content [advanced checks]
  • Integration tests for PostController, prepare data
  • Writing tests for PostController
  • Advanced checks of API responses [PostController]
  • Integration tests for CommentController
  • Overview
  • Basic project setup + GitLab and connection to the DB
  • Creating an action logs table via FlyWay minification (CREATE, INSERT INTO)
  • Creating an entity and ENUM classes (@Entity, @Converter, stream, lambda)
  • Creating DTO, Repository and Service Interface
  • Implementation of GET method, @Mapper, @RestController, testing in Postman
  • ExceptionHandler, findAll method + pagination(Page, Pageable)
  • Updating logs as "read" (PUT request, filtering by ID and userId)
  • Security settings, JWT and restricting access to logs
  • Starting a service in Docker, Configuration, Docker file and starting a container
  • Connecting Swagger UI, documentation, authorization and verification of requests
  • Overview
  • Demo Kafka How microservices exchange messages
  • Installing Kafka + Zookeeper. Useful commands
  • Connecting Kafka to the IAM service and configuring Producer
  • Connecting Kafka to the UTILS service and configuring Consumer
  • Overview
  • What is Consul. Demo of the Discovery service
  • Installing and connecting Consul to the IAM service
  • Connecting Consul to the UTILS service
  • Overview
  • Ready-made Gateway service. Demo of a new microservice
  • Refining OpenApiConfig in microservices
  • Overview
  • Creating a VPS on a hosting (virtual private server)
  • Configuring the VPS infrastructure (installing Docker, Kafka, Consul)
  • Registering and creating a repository on Docker Hub + how deployment will work
  • Creating a database on ScaleGrid
  • Configuring properties files, working with ScaleGrid data and variables in GitLab
  • Deploying an IAM service (build, push to Docker Hub, deploy to VPS, check)
  • Deploying a Utils service (build, push to Docker Hub, deploy to VPS, check)
  • Deploying a Gateway service (build, push to Docker Hub, deploy to VPS, check)
  • Overview of the frontend and backend integration process
  • Installing Nginx and configuring DNS for a domain
  • Installing an SSL certificate for HTTPS via Certbot
  • Configuring Nginx for proxying services
  • Demonstrating a website and connecting a custom domain
  • CORS. Setting up API access
  • [Email Confirmation] - Demo sending email confirmation after registration
  • Generating email token (Entity, Repository, Service)
  • New endpoint for email-confirm
  • UI: HTML page, custom mail name, additional checks
  • [Password Reset] - Updating password by authorized user
  • [Sign in with Google] Demo - How OAuth2-client works
  • Create a project in Google Cloud
  • Authorization via Google account [BE part]
  • Authorization via Google account [Web integration]
  • Google-One-Tap (login with one click)

How the course works

1/

Access to materials

All video lessons and additional materials are available immediately after the course starts.

2/

Flexible
schedule

Study at your own pace without strict deadlines.

3/

Practical
tasks

Each module ends with real tasks from microservices development.

4/

Expert
support

Closed chat with curators for prompt consultations.

5/

Additional resources

Code templates, cheat sheets and checklists for effective learning.

Your new resume after the course

Job Title

Backend Java Developer
(Spring Boot / Microservices)

Level

Middle-/Middle+

Tools:

✅ Spring Boot
✅ Spring Security
✅ PostgreSQL
✅ Hibernate
✅ Kafka
✅ Docker
✅ Swagger/OpenAPI
✅ MapStruct
✅ Nginx
✅ Git
✅ JUnit
✅ Consul

Skills:

✅ Spring Framework:

Spring Boot, Spring MVC, Spring Data JPA, Spring Security

Bean configuration, DI/IoC, AOP (AspectJ)

Working with profiles and configurations

✅ Security:

JWT authentication, OAuth2 (basic)

Role model (User/Admin/SuperAdmin)

Protection from major vulnerabilities (CSRF, SQLi)

✅ Microservice architecture:

Development and interaction of services (REST, Kafka)

Service Discovery (Consul), API Gateway

Monolith decomposition

✅ DevOps skills:

Docker (containerization, Docker Compose)

Server deployment (Nginx + SSL)

CI/CD basics (build and deploy)

✅ Databases and persistence:

PostgreSQL + Flyway (migrations)

Spring Data JPA, Hibernate, Criteria API

Query optimization, caching

✅ Testing:

Unit tests (JUnit, Mockito)

Integration tests

REST API testing

Who is the right person for the course?

  • Alexey Gvozdev

    Senior Java Developer (Spring Cloud, Microservices, scalable systems architect

  • Maria Semenova

    Lead Backend Engineer (Spring Boot, Kafka), specialist in distributed systems and event-driven architecture

  • Ivan Kokorin

    DevOps Engineer (Kubernetes, Docker), Expert in CI/CD and cloud deployments of Spring applications

  • Olga Sinitsa

    Java Tech Lead (Spring Security, JWT), author of security patterns for fintech solutions

  • Dmitry Dudar

    Senior Spring Developer (Data JPA, Hibernate), specialist in optimizing SQL queries and working with PostgreSQL

  • Anastasia Morozova

    Cloud Architect (AWS, Microservices), specialist in migrating monoliths to Spring Cloud

  • Artem Gil

    CTO (DDD, Clean Architecture), Expert in designing complex Spring systems

Certificate

Upon completion of the course, you will receive a personalized certificate confirming your skills in developing microservices on Spring Boot, working with Docker, Kafka and Spring Security, which will strengthen your resume for employers in the IT industry.

Select the desired plan

Our courses are loved by students

average rating is 4.75

89%

of students find their first orders one month after starting the course

32%

of graduates work remotely

62%

grow to middle level within a year after graduation

Feedback from
course graduates

Alexander
Maria
Dmitry
Elena

  • Alexander

    Middle Java Developer

    After the course, I literally grew to Middle+ in 2 months. At the interview, they especially noted my project with microservices on Spring Cloud - they hired me with a salary above the market. Kafka and Docker became my trump cards!

  • Ekaterina

    Backend Team Lead

    20 years in IT, but I learned Spring Boot from scratch here. The material is presented without fluff, only what is really used in production. Now I am implementing this course for juniors in our team.

  • Maxim

    freelancer

    Thanks to Docker and Nginx from the course, I was able to launch my SaaS startup. Chat with experts saved me more than once - in 3 days they helped fix the problem with JWT, which I had been struggling with for a week myself.

  • Anna

    Bootcamp graduate

    Switched from Python to Java and got a job at Booking.com in 4 months. The recruiter said that the project with Consul and Spring Security in my portfolio outweighed the lack of commercial experience.

  • Dmitry

    ex-1C developer

    At 35, I changed my profession: 2 months after the course, I received an offer from Sber for 180k. It was especially valuable that they taught me not just how to code, but how to design architecture as a senior.

  • Olga

    university teacher

    I use the course materials for my lectures - the best explanation of Spring DI and AOP on the market. Students who have completed this course immediately stand out from the crowd.

  • Artem

    Founder of an edtech startup

    I built an MVP on Spring Boot in 3 weeks (although I planned for 3 months). The templates from the course saved hundreds of hours. Now our platform processes 50k+ requests per day!

    Illustration

    We will refund your money in full if the course is not suitable

    Don't worry! We offer a 14-day refund policy, as mandated by law. Contact us within 14 days to request a refund—no questions asked.

    FAQ

    • Spring Boot is a standard for enterprise Java development used by 80% of companies. It speeds up application creation by 3-5 times due to built-in modules (Security, Data, Cloud) and automatic configuration.
    • Optimally 6-8 hours a week: 2-3 hours for video lessons and 4-5 hours for practice with the possibility of a flexible schedule.
    • Yes, the course is fully adapted for working professionals - materials are available 24/7, deadlines are flexible, and curators support even outside working hours.

    You will be able to work in:

    • FinTech (Tinkoff, Alfa-Bank) — Spring Security + JWT
    • E-commerce (Ozon, Wildberries) — microservices + Kafka
    • Startups — quick start of projects on Spring Boot
    • Outsourcing (EPAM, Luxoft) — a popular stack for customers from the EU/US
    • We offer a 14-day refund policy, as mandated by law. Contact us within 14 days to request a refund—no questions asked.