Learn software engineering by building one real system.

The problem first

Each lesson opens with a problem the shop has right now: prices that round wrong, orders that vanish on restart. Then it explains the idea behind the fix, how it works underneath, and when it's the wrong tool.

Your code, real tests

You write the code in a real editor, against the same tests the reference solution passes. If you get stuck, open the reference solution next to your own.

Bugs on purpose

Some lessons hand you a bug instead of a feature: a wrong refund, a report that got slow, an import that silently changed nothing. You find the cause, fix it, and prove the fix with a test.

Decisions explained

Every big decision comes with its reasoning and the alternatives, and some are exercises: pick an approach for the shop, give your reasons, and see how they hold up.

1. 1

   Problem and context

   What the shop needs and why it needs it now.

2. 2

   Theory

   How it works inside, when to use it, common mistakes.

3. 3

   Syntax and code

   Small examples you can run before touching the project.

4. 4

   Architecture

   Where the change sits in the system, with a diagram.

5. 5

   Implementation

   Step by step, in your editor.

6. 6

   Testing

   The tests that define done, and how to write the next one.

7. 7

   Debugging

   A real failure, the real error output, and how to trace it.

8. 8

   Decisions

   Why the reference does it this way, and what else would work.

9. 9

   Practice

   Tasks with no instructions, to check it stuck.

10. 10

    Summary

    Concepts, files and techniques, as revision notes.

org.springframework.dao.IncorrectResultSizeDataAccessException:
  Incorrect result size: expected 1, actual 2

 id | payment_reference |  region  |       placed_at
----+-------------------+----------+------------------------
  1 | PAY-1             | DOMESTIC | 2026-11-09 09:00:00+00
  2 | PAY-1             | EU       | 2026-11-10 09:00:00+00

1. The missing item
2. The stock that moved
3. The wrong refund
4. Reservations that vanish
5. Everything half price
6. The silent import
7. The slow report
8. The shop that wouldn't start
9. The deal that never applied
10. Someone else's keyboard
11. When the pager is down
12. The search that found everything
13. Two orders, one payment

1. 1

   Programming foundations

   A product catalogue in plain Java: classes, records, collections, exceptions.

   Written

2. 2

   Spring Boot foundations

   The catalogue becomes a Spring application, with configuration, tests and events.

   Written

3. 3

   Database engineering

   Products and orders move into PostgreSQL, with migrations, transactions and indexes.

   Being written

4. 4

   Backend development

   A REST API with validation, error handling, JWT authentication and API docs.

   Planned

5. 5

   Software architecture

   A modular monolith with boundaries you can explain and defend.

   Planned

6. 6

   Advanced backend engineering

   Caching, concurrency, and order processing through a message broker.

   Planned

7. 7

   Distributed systems

   A few modules become services, with a gateway, sagas and circuit breakers.

   Planned

8. 8

   Production engineering

   Docker, Kubernetes, CI/CD, and the metrics, logs and traces to run it.

   Planned

A stage opens when every lesson in it is written and every test passes. Not before.

1. Software Engineering

   Java and Spring Boot first; C#, Go, Rust, Python and Node.js after

   In development

2. AI and Machine Learning

   Data science, deep learning, LLM engineering, MLOps

   Planned

3. DevOps and Cloud

   Linux and networking, Docker and Kubernetes, CI/CD, infrastructure as code

   Planned

4. System Design

   Caching and scaling, messaging, replication and consistency

   Planned