Planned course

Java Backend Engineering

Build a backend you can explain, test and operate. Work through API design, persistence and reliable service behavior.

JavaSpring BootPostgreSQLMicroservicesKafka

Join the waitlist ↓

Start date: To be announced
Duration: 6 months · 24 weeks
Format: Live online

240 AZN / month

Monthly tuition

Interest list only for now. Course enrollment is not open yet.

Start date and instructor will be announced before enrollment opens.

Who this is for

Learners with basic programming logic, aspiring backend developers and junior engineers who want stronger foundations.

CURRICULUM

From Java foundations to production-style systems

6 months, 24 weeks. Expand a month and week to explore topics, practical work and outcomes.

24weeks216topics5 + 1projects and capstone

Proposed weekly commitment

Three live sessions of two hours each, plus 8-12 hours of independent practice: 14-18 hours per week. The proposed plan includes 144 live teaching hours across 24 weeks; exact session dates will be announced separately.

Before you start: Basic computer skills and introductory programming logic are required. Complete beginners should finish preparation before Week 1.

01Month 1 · Weeks 1-4Java engineering foundations

Write maintainable Java code, model business rules and solve problems independently.

Week 1Programming fundamentals and Java essentials

Java toolchain

JDK, JRE and JVM
Compilation and bytecode
IDE setup and Git fundamentals

Language fundamentals

Variables, primitives and operators
Conditionals and loops
Methods and arrays

Problem solving

Computational thinking and decomposition
Debugger breakpoints and variable inspection
Stack traces and input validation

Practical lab: Build a command-line expense tracker with input validation and meaningful Git commits.
Outcome: Explain how a Java program runs and debug a small application independently.

Week 2Object-oriented programming and clean design

Object model

Classes, objects and constructors
Encapsulation and access modifiers
Immutability, records and enums

Relationships and behavior

Inheritance and polymorphism
Abstraction and interfaces
Composition versus inheritance

Design fundamentals

SOLID principles
UML class diagrams
Business rules and object responsibilities

Practical lab: Model simulated bank accounts with explicit business rules and extensible account types.
Outcome: Assign responsibilities to classes and justify composition, interfaces and immutable values.

Week 3Collections, generics and modern Java

Collections

List, Set, Map and Queue
HashMap internals and equals/hashCode
Comparable, Comparator and ordering

Types and failures

Generics and type erasure
Exceptions and error handling
Optional and absent values

Data processing

Lambdas and functional interfaces
Stream API transformations and aggregation
Date/Time API and file I/O

Practical lab: Implement customer search, transaction filtering and reports using synthetic financial records.
Outcome: Choose collections and use typed transformations to process application data.

Week 4Data structures, algorithms and craftsmanship

Data structures

Arrays and linked lists
Stacks, queues and hash tables
Big O time and space complexity

Algorithms

Binary search
Sorting algorithms
Recursion and problem decomposition

Development workflow

Maven project structure and builds
JUnit unit tests and debugging
Clean code, refactoring and peer review

Practical lab: Analyze algorithmic complexity and refactor the Personal Finance CLI with focused unit tests.
Outcome: Compare algorithm costs and improve code structure without changing expected behavior.

MONTHLY PROJECT

Personal Finance CLI

Build a modular expense tracker with categories, transaction history, input validation and reports.

02Month 2 · Weeks 5-8Advanced Java and backend fundamentals

Investigate Java execution, concurrency, relational data and network communication.

Week 5JVM internals and memory management

Execution model

Class loading and bytecode
JVM runtime data areas
JIT compilation

Memory model

Stack, heap and object allocation
References and garbage collection
Java Memory Model fundamentals

Diagnostics

Heap inspection and profiling
GC log analysis
Memory leak investigation

Practical lab: Inspect bytecode, heap usage and GC logs in an application with a deliberate memory leak.
Outcome: Connect runtime observations to object lifetimes and JVM memory behavior.

Week 6Multithreading and concurrency

Task execution

Platform and virtual threads
ExecutorService and task submission
CompletableFuture composition

Shared state

Synchronization, locks and volatile
Atomic types and concurrent collections
Happens-before and visibility

Concurrency failures

Race conditions
Deadlock diagnosis
Thread safety and concurrent tests

Practical lab: Build a concurrent processor for simulated transactions and reproduce race conditions in tests.
Outcome: Protect shared state and explain the trade-offs of the chosen concurrency mechanism.

Week 7Relational databases and SQL engineering

Relational modeling

PostgreSQL schemas and primary/foreign keys
Normalization and relationships
Joins, aggregations and subqueries

Query performance

Indexes and B-tree fundamentals
Query plans and slow queries
Pagination strategies

Transactions

ACID properties
Isolation levels and anomalies
Database locking and conflicts

Practical lab: Design a banking schema with synthetic data and investigate slow queries and concurrent updates.
Outcome: Explain schema, index and isolation choices using query plans and concurrency tests.

Week 8Networking, HTTP and API fundamentals

Network fundamentals

TCP/IP and DNS
TLS and secure transport
HTTP/1.1, HTTP/2 and request lifecycle

API contracts

REST principles and JSON
Status codes and error responses
Idempotency and API versioning

Backend tools

Authentication concepts
curl and Postman requests
Linux CLI fundamentals

Practical lab: Design and document a REST API contract, including status codes and error responses.
Outcome: Trace an HTTP request and explain the contract exposed to API consumers.

MONTHLY PROJECT

Concurrent Transaction Engine

Build a thread-safe transaction simulation with PostgreSQL, isolation tests, performance analysis and structured errors.

03Month 3 · Weeks 9-12Spring Boot and API engineering

Implement and secure a Spring Boot service with PostgreSQL and explicit transaction boundaries.

Week 9Spring Framework and dependency injection

Spring container

IoC and dependency injection
Bean lifecycle and component scanning
Java-based configuration

Spring Boot configuration

Auto-configuration
Profiles and externalized properties
Typed configuration properties

Service structure

Layered architecture
Feature-based organization
Actuator and health endpoints

Practical lab: Create a Spring Boot service with typed configuration and health endpoints.
Outcome: Explain bean wiring and organize a service around explicit application responsibilities.

Week 10REST API design and validation

Request handling

Spring MVC and controllers
DTOs and Jackson serialization
Bean Validation

Response contracts

Exception handling and Problem Details
HTTP semantics and idempotent requests
Pagination, sorting and filtering

API maintenance

OpenAPI documentation
API evolution and compatibility
Validation and error contract review

Practical lab: Implement inventory and order endpoints with validation and accurate HTTP semantics.
Outcome: Expose a documented API with predictable validation, errors and collection responses.

Week 11Spring Data JPA and transactions

Persistence model

JPA/Hibernate and entity states
Persistence context and relationships
Lazy/eager loading and N+1 queries

Queries and consistency

JPQL and native queries
Optimistic and pessimistic locking
@Transactional and transaction boundaries

Database operations

Connection pools
Flyway and Liquibase migrations
Query and concurrency diagnostics

Practical lab: Diagnose N+1 queries, concurrent update conflicts and incorrect transaction boundaries.
Outcome: Choose loading, locking and transaction boundaries for consistent persistence behavior.

Week 12Authentication and application security

Access control

Spring Security and authentication/authorization
Password hashing and RBAC
Sessions and JWT

Identity protocols

OAuth 2.0
OpenID Connect and provider integration
Access control tests

API protection

CORS and CSRF
Input validation and OWASP API Security risks
Secret management

Practical lab: Secure endpoints, test role-based access and integrate with an OIDC provider using synthetic accounts.
Outcome: Distinguish identity from permissions and verify that unauthorized requests are rejected.

MONTHLY PROJECT

Secure Digital Wallet API

Implement synthetic user accounts, simulated balances, transfers, transaction history, RBAC, migrations and idempotency.

04Month 4 · Weeks 13-16Production engineering

Build services that can be tested, deployed, monitored and maintained with clear operational procedures.

Week 13Clean architecture and design patterns

Architecture boundaries

SOLID in practice
Separation of concerns and dependency direction
Domain modeling

Application structures

Modular monoliths
Hexagonal architecture
Business and infrastructure boundaries

Patterns and refactoring

Strategy and Factory
Adapter and Decorator
Anti-patterns and incremental refactoring

Practical lab: Refactor a tightly coupled service into business and infrastructure components with explicit boundaries.
Outcome: Justify a design pattern through the dependency or behavior it simplifies.

Week 14Testing engineering

Test levels

Unit, integration and contract tests
Spring Boot integration tests
Coverage versus test quality

Testing tools

JUnit, Mockito and AssertJ
Testcontainers with PostgreSQL
WireMock for external dependencies

Reliable test suites

Test data design
Deterministic tests
CI test pipelines

Practical lab: Build a deterministic test suite using PostgreSQL in Testcontainers and controlled external responses.
Outcome: Select test boundaries and verify failures as well as successful business flows.

Week 15Redis, caching and performance

Cache behavior

Cache-aside and write-through
TTL and invalidation
Eviction policies and stale data

Redis use cases

Redis data structures
Distributed locking caveats
Rate limiting

Performance investigation

Connection pool tuning
Load testing and p95/p99 latency
Bottleneck analysis

Practical lab: Benchmark a cached endpoint against its uncached baseline, including stale-data and cache-failure cases.
Outcome: Measure whether caching helps and explain its consistency and failure trade-offs.

Week 16Docker, CI/CD and deployment

Runtime environment

Linux processes and environment variables
Docker images and multi-stage builds
Compose and container networking

Delivery pipeline

GitHub Actions build pipelines
Deployment migrations and secrets
Automated staging deployment

Operational checks

Health checks
Reverse proxies
Rollback strategies

Practical lab: Containerize the service and deploy it to staging through an automated pipeline.
Outcome: Explain the build, migration, health-check and rollback steps of a release.

MONTHLY PROJECT

Production-Ready Order Management API

Deliver a documented, secured order service with PostgreSQL, Redis, tests, Docker, CI/CD and measured performance.

05Month 5 · Weeks 17-20Microservices and distributed systems

Choose service boundaries and investigate communication, consistency and failure recovery across services.

Week 17Microservices architecture and communication

Architecture choices

Monolith, modular monolith and microservices
Service boundaries and bounded contexts
Deployment complexity

Communication

API Gateway responsibilities
Synchronous communication and REST clients
Service discovery

Service ownership

Database-per-service
Service configuration
Boundary and dependency trade-offs

Practical lab: Decompose an application domain into services and document the cost of each boundary.
Outcome: Justify when service separation is useful and when a modular monolith is sufficient.

Week 18Apache Kafka and event-driven systems

Kafka model

Brokers, topics, partitions and offsets
Consumer groups and ordering
Replication and acknowledgments

Producer and consumer behavior

Producer reliability and consumer commits
Serialization and schemas
Retries and dead-letter topics

Delivery correctness

Idempotent consumers
Transactional outbox
Duplicate event handling

Practical lab: Implement asynchronous order events with retries, outbox and safe duplicate handling.
Outcome: Explain event ordering and recovery without assuming that consumers receive each event only once.

Week 19Distributed consistency and resilience

Failure handling

Partial failures and timeouts
Retries and exponential backoff
Circuit breakers and bulkheads

Cross-service workflows

Distributed transactions
Saga choreography and orchestration
Compensation and recovery

Consistency and tracking

Eventual consistency
Change data capture (CDC)
Correlation IDs

Practical lab: Simulate a failed payment with test funds and implement recovery without duplicate simulated charges.
Outcome: Choose retry and compensation boundaries while accounting for partial completion.

Week 20Observability, reliability and operations

Telemetry

Structured logging and correlation
Metrics and distributed tracing
OpenTelemetry, Prometheus and Grafana

Reliability signals

SLI/SLO and alerting
Saturation and latency
Thread pools and JVM monitoring

Service lifecycle

Graceful shutdown
Readiness and liveness
Incident diagnosis

Practical lab: Trace a failing distributed request and diagnose a simulated incident caused by load.
Outcome: Use logs, metrics and traces to connect a user-visible failure to its service-level cause.

MONTHLY PROJECT

Event-Driven E-Commerce Backend

Implement orders, inventory and notifications with Spring Boot, Kafka, PostgreSQL, outbox, idempotent consumers and tracing.

06Month 6 · Weeks 21-24Capstone, system design and career preparation

Integrate the course topics in a documented backend project and defend its engineering decisions.

Week 21System design and architecture planning

Requirements

Functional and non-functional requirements
Capacity estimates
Delivery milestones

Design artifacts

Architecture diagrams
API contracts and data models
Architectural decision records

Risk and trade-offs

Consistency trade-offs
Threat modeling
RFC proposal review

Practical lab: Write an RFC-style proposal for the Digital Banking Platform using synthetic identities and simulated funds.
Outcome: Define project boundaries, risks and measurable requirements before implementation.

Week 22Capstone implementation sprint

Collaboration

Git workflow and branch strategy
Pull requests and code review
Tickets and implementation milestones

Backend implementation

Spring Boot modules and services
PostgreSQL data ownership
Redis and Kafka responsibilities

Business flows

REST contracts and authentication
Simulated wallet and transfer workflows
Asynchronous notifications

Practical lab: Deliver the core end-to-end banking simulation flows through reviewed pull requests.
Outcome: Demonstrate an integrated workflow and explain data ownership across its components.

Week 23Hardening and deployment

Correctness and security

Integration tests
Security checks
Failure injection and recovery

Performance validation

Load test scenarios
Performance optimization
p95 latency under stated load

Release operations

CI/CD and staging deployment
Logs, metrics and traces
Troubleshooting and runbooks

Practical lab: Demonstrate recovery from injected outages and report p95 latency for a documented workload.
Outcome: Support release readiness with test evidence, performance measurements and recovery instructions.

Week 24Engineering defense and career preparation

Project defense

Final architecture review
Live project demonstration
Engineering trade-off discussion

Technical practice

Debugging challenge
Java, Spring and SQL interview questions
System design discussion

Professional communication

Technical explanation and documentation
CV and GitHub portfolio review
Individual learning and career roadmap

Practical lab: Present the completed project, reproduce a failure scenario and defend the major design decisions.
Outcome: Explain project strengths, remaining limitations and the next steps in your development.

MONTHLY PROJECT

Digital Banking Platform

Build an educational banking backend using synthetic identities and simulated funds, with wallets, transfers and asynchronous notifications.

FINAL CAPSTONE

Digital Banking Platform

Build an educational banking backend using synthetic identities and simulated funds, with wallets, transfers and asynchronous notifications.

Use synthetic identities and simulated funds for all banking workflows.
Implement authentication, role-based access and validated API contracts.
Keep wallet transfers consistent with explicit transaction boundaries and idempotency.
Deliver asynchronous notifications with outbox, retries and duplicate handling.
Document service data ownership and justify Kafka, Redis and communication choices.
Verify access control, concurrent transfers and failure recovery with automated tests.
Deploy to staging through CI/CD and collect logs, metrics and traces.
Present load-test results, recovery runbooks and documented architecture decisions.

Proposed assessment

Weekly assignments and labs: 20%
Five practical projects: 25%
Knowledge assessments: 15%
Capstone and architecture defense: 30%
Code reviews and collaboration: 10%

Proposed certificate criteria: at least 70% overall, a passing capstone, successful security and correctness tests, and participation in the architecture defense. Attendance may be tracked separately. Final rules will be announced when enrollment opens.

Engineering practice

Engineering clinics: investigate bugs, slow SQL, race conditions, logs and architecture flaws.
Architecture decision reviews: compare storage, messaging, communication and transaction choices.
Team simulation: work with tickets, pull requests, reviews, releases, incidents and documentation.

By the end of the program

Build maintainable Java and Spring Boot applications with explicit security boundaries.
Design PostgreSQL schemas and investigate database performance.
Implement automated tests, authentication, validation, caching and CI/CD.
Build introductory distributed and event-driven workflows with Kafka.
Investigate concurrency, reliability and performance problems with evidence.
Deploy, monitor and troubleshoot backend services.
Present a GitHub portfolio with documented projects and defensible technical decisions.

The program targets strong junior-level foundations and practical skills. It does not guarantee employment or a mid-level or senior role.

Planned format

Live online sessions and project practice