A practical workshop about transforming requirements into a working backend application.
Writing code is only one part of software development.
Before a developer opens the IDE, someone needs to identify a problem, understand the business requirements, design the solution, define the architecture, and transform everything into technical tasks.
This was the main idea behind my workshop about building a REST API with Java and Spring Boot.
Instead of starting directly with controllers and annotations, I wanted to answer a question I also had when I was beginning my career:
How does a real problem become a software project and finally reach the developer?
During the presentation, I introduced the path from a business need to requirements, domain modeling, architecture, and implementation. After that, we moved to the practical part and created the foundation of an API together.
The project
For the workshop, I created a simplified online learning platform.
The example represents a system where instructors can create courses, organize modules, and manage information such as course name, description, level, status, modules, and creation date.
The objective was not to build an entire educational platform during a single presentation. The project was designed to help students understand how the main parts of a Java backend application work together.
What we built
During the hands-on session, we created a Spring Boot project and explored concepts such as project creation with Spring Initializr, layered architecture, entities, domain modeling, controllers, services, repositories, DTOs, data persistence, HTTP requests and responses, and testing API endpoints with Postman.
The application uses Java 21, Spring Boot, Maven, Spring Web, Spring Data JPA, H2 Database, and Lombok.
We also discussed how the same system could evolve with concepts such as authentication and authorization, API Gateway, microservices, asynchronous communication, RabbitMQ, Docker, pagination, filtering, and external integrations.
More than a CRUD
The purpose of the workshop was not only to show how to create a POST, PUT, or GET endpoint.
I wanted participants to understand that backend development begins before the code.
A developer needs to understand what problem is being solved, who will use the system, which information the application needs, how the domain should be modeled, which responsibilities belong to each part of the application, and how the solution may integrate with other systems.
Understanding this process makes it easier to make technical decisions and build software that delivers real value.
From requirement to implementation
One of the most important points of the workshop was showing that an API is not born from annotations alone.
Before creating a controller, a service, or a repository, we need to understand the business scenario behind the system. In this case, the domain involved courses, modules, instructors, levels, status, and the basic structure of an online learning platform.
That discussion helped connect business language with technical implementation.
When developers understand the domain, they stop thinking only about endpoints and start thinking about responsibilities, rules, data flow, and system behavior.
Why this matters
Many beginners start learning backend development by copying ready-made examples. That can be useful at the beginning, but it is not enough to understand how real software is built.
In real projects, developers need to read requirements, understand constraints, make decisions, communicate trade-offs, and write code that reflects the problem being solved.
This is why the workshop was structured to connect three layers: business understanding, software architecture, and implementation.
Java and Spring Boot were the tools used to build the API, but the main lesson was broader: good backend development depends on clarity before code.
Continue exploring the project
The complete source code is available on GitHub.
The repository includes the project presented during the workshop, instructions for running it locally, API examples, and suggestions for continuing the implementation.
Developers who want to continue the project can implement course listing, course deletion, pagination, filters by course level and status, Bean Validation, global exception handling, unit and integration tests, Swagger/OpenAPI documentation, Docker support, and module management.
Final thoughts
Teaching this workshop was also an opportunity to revisit one of the most important lessons in software development:
A good solution does not begin with code. It begins with understanding the problem.
Java and Spring Boot provide powerful tools for building enterprise applications, but the real value comes from knowing how to connect business needs, architecture, and implementation.
This repository is a starting point for anyone who wants to understand that journey and build their first backend API with Java.
Feel free to explore the code, continue the implementation, and share your improvements.