📚 Full-Stack Java + Cloud Developer Program

Complete Course Syllabus

9 topics, 3 sections, 2 months of live instruction — everything you need to go from fresh graduate to job-ready developer.

9
Topics
3
Sections
2
Months
Section 1

Core Backend Development

Weeks 1–3
01

Client-Server Architecture

How the Web Actually Works

  • What happens when you type a URL — from DNS lookup to the server response landing in your browser
  • The difference between a client and a server, and why that separation matters in every app you'll ever build
  • HTTP and HTTPS explained simply — requests, responses, headers, and status codes like 200, 404, and 500
  • REST principles: how modern web APIs are designed so different apps can talk to each other reliably

APIs and JSON

  • What an API is and why companies expose them — the "contract" between a frontend and a backend
  • JSON format deep-dive: objects, arrays, nesting, and why it became the universal language of data exchange
  • Making API calls with tools like Postman so you can test your own backend before connecting any frontend
  • Understanding HTTP methods: GET to read data, POST to create, PUT/PATCH to update, DELETE to remove

Thinking Like a Backend Developer

  • How to model real-world problems as software entities — users, orders, products, and the relationships between them
  • Stateless vs. stateful communication — why REST is stateless and what that means for your server design
  • Authentication basics: tokens, sessions, and why you should never store passwords in plain text
  • Common architecture patterns used in real companies: monolith vs. microservices at a practical level
02

Core Java & Object-Oriented Programming

Java Fundamentals You'll Actually Use

  • Data types, variables, and operators in Java — with a focus on what trips beginners up most often
  • Control flow: if/else, switch, for/while loops, and when to use each one without overthinking it
  • Methods, parameters, and return types — building small reusable blocks that form the backbone of your code
  • The Java Collections Framework: ArrayList, HashMap, and HashSet — the three you'll reach for on every project

Object-Oriented Programming in Plain English

  • Classes and objects — think of a class as a blueprint and an object as the actual house you build from it
  • Encapsulation: keeping your data safe with private fields and getters/setters so other parts of the code can't break it
  • Inheritance and polymorphism: reusing code intelligently and writing methods that work on many types at once
  • Interfaces and abstract classes — how Java uses them to define "contracts" that different classes must fulfill

Modern Java Features

  • Lambda expressions and streams: writing concise, readable code for filtering, mapping, and processing lists
  • Optional — the right way to handle missing data without crashing your application with NullPointerException
  • Exception handling: try/catch/finally, creating custom exceptions, and deciding what to catch vs. let propagate
  • Java records and other Java 17+ features you'll encounter in modern codebases at real companies
03

Spring Boot & JPA

Building Your First Spring Boot App

  • What Spring Boot is and why it's the most popular Java framework in enterprise software today
  • Project structure, dependency injection, and the magic of annotations like @Component, @Service, and @RestController
  • Creating REST endpoints with @GetMapping, @PostMapping, and friends — your first working API in under an hour
  • Application properties, profiles, and how to configure your app for local development vs. production

Spring Boot Best Practices

  • Layered architecture: separating your app into Controller, Service, and Repository layers so it stays maintainable
  • Request validation with @Valid and Bean Validation — rejecting bad data before it ever touches your business logic
  • Global exception handling with @ControllerAdvice so your API always returns consistent, user-friendly error messages
  • Logging with SLF4J and Logback — the right way to add visibility into what your application is doing at runtime

JPA and Database Integration

  • JPA and Hibernate explained: how Java objects get mapped to database rows without writing raw SQL everywhere
  • Spring Data JPA repositories — getting full CRUD operations and custom queries with almost no boilerplate code
  • Entity relationships: @OneToMany, @ManyToOne, and @ManyToMany with real-world examples like users and orders
  • Pagination, sorting, and JPQL queries for when the built-in repository methods don't quite cover your needs
04

SQL & Database Design

Relational Database Fundamentals

  • Tables, rows, columns, and primary keys — the building blocks of every relational database you'll ever touch
  • Foreign keys and relationships: one-to-one, one-to-many, and many-to-many with real schema examples
  • Normalisation in plain English: why you split data across multiple tables and when to stop splitting
  • Indexes: what they are, why queries slow down without them, and how to add them in the right places

Writing SQL Queries

  • SELECT, FROM, WHERE, ORDER BY, and LIMIT — the essential query building blocks you'll use every single day
  • JOINs demystified: INNER, LEFT, RIGHT, and when each one is the right tool for the data you're pulling
  • Aggregation: GROUP BY with COUNT, SUM, AVG, MIN, MAX for summarising large datasets into useful reports
  • Subqueries and CTEs (WITH clauses) for breaking complex queries into readable, step-by-step logic

Practical Database Skills

  • Database transactions: COMMIT, ROLLBACK, and why they exist to prevent corrupted data in multi-step operations
  • Working with PostgreSQL locally and understanding how it maps to cloud-managed databases in production
  • Schema migrations with Flyway: managing database changes safely across development, staging, and production
  • Writing and optimising the kinds of queries you'll encounter during technical interviews at product companies
Section 2

Cloud & DevOps

Weeks 4–6
05

Azure Cloud Services

Understanding the Cloud

  • Why companies moved to the cloud — the real business reasons beyond the buzzwords: cost, scale, and reliability
  • Azure's core services explained without jargon: compute (VMs, App Service), storage (Blob, Files), and networking
  • The Azure portal and CLI: creating and managing resources the way a developer actually does it on the job
  • Regions, availability zones, and why geography matters when you're deploying a global application

Deploying Applications on Azure

  • Azure App Service: the simplest way to deploy a Spring Boot app with a single command and zero server management
  • Azure SQL Database and Azure Cosmos DB: managed database services that handle backups, scaling, and patches for you
  • Azure Blob Storage: storing and serving files, images, and documents at scale in your application
  • Environment variables and Azure Key Vault: keeping your database passwords and API keys out of your source code

Monitoring and Cost Management

  • Azure Monitor and Application Insights: seeing exactly what your deployed application is doing in real time
  • Setting up alerts so you get notified before users discover something has gone wrong with your application
  • Azure pricing basics: understanding on-demand vs. reserved pricing and avoiding surprise bills as a beginner
  • Azure DevOps Pipelines: automating the build, test, and deployment of your app every time you push new code
06

Docker & Kubernetes

Containers with Docker

  • The "it works on my machine" problem — why containers were invented and how they solve it permanently
  • Writing a Dockerfile for your Spring Boot application so it runs identically everywhere, every time
  • Building, tagging, and pushing Docker images to Docker Hub or Azure Container Registry
  • Docker Compose for local development: running your app, database, and other services together with one command

Orchestration with Kubernetes

  • What Kubernetes is and why it exists: managing many containers across many servers without losing your mind
  • Pods, Deployments, and Services — the three Kubernetes building blocks you need to understand to get started
  • Scaling your application up and down in Kubernetes: handling more traffic by adding replicas with a single command
  • ConfigMaps and Secrets in Kubernetes: the right way to inject configuration and credentials into your containers

Running on Azure Kubernetes Service (AKS)

  • Setting up a real AKS cluster: the managed Kubernetes service on Azure that handles the control plane for you
  • Deploying your Spring Boot app to AKS and exposing it to the internet with an Azure Load Balancer
  • Rolling deployments: updating your app in production with zero downtime so users never see a maintenance page
  • Kubernetes resource limits: setting CPU and memory boundaries so one bad deployment can't take down your whole cluster
07

Git & Version Control

Git Foundations

  • Why version control exists: the history of how developers stopped overwriting each other's work with email attachments
  • The three areas of Git: your working directory, the staging area, and the repository — and how changes flow between them
  • Core commands you'll use every day: git add, git commit, git push, git pull, git status, and git log
  • Writing good commit messages: a skill that separates professional developers from beginners on any team

Branching and Collaboration

  • Branches explained: why you never commit directly to main and how feature branches keep your codebase stable
  • Pull requests on GitHub: the code review workflow used by every professional software team in the industry
  • Handling merge conflicts: the skill that intimidates beginners but becomes routine once you understand what Git is doing
  • Git rebase vs. merge: when to use each one and the cleaner commit history that rebase gives you

Professional Git Workflows

  • GitHub Flow: the lightweight branching strategy used by most startups and product teams you'll join
  • .gitignore files: what to exclude from your repository and why your secrets and build output should never be committed
  • GitHub Actions for CI: automatically running tests every time someone opens a pull request to catch bugs early
  • Maintaining a professional GitHub profile: how recruiters evaluate your repositories and what makes a good README
Section 3

AI & Frontend Technologies

Weeks 7–8
08

AI & LLM Integration

Understanding AI and Large Language Models

  • What LLMs actually are at a practical level — prediction engines, not thinking machines — and why that matters for developers
  • The OpenAI API and Azure OpenAI Service: accessing powerful language models with a simple REST call from your Java app
  • Prompt engineering basics: how you phrase your input dramatically changes what the model outputs — and how to use this deliberately
  • Tokens, context windows, and model selection: the practical constraints that determine what you can and can't ask an LLM to do

Building AI-Powered Features

  • Adding an AI chat endpoint to your Spring Boot API: a real endpoint that accepts a user message and returns an LLM response
  • Retrieval-Augmented Generation (RAG) in plain English: giving the AI access to your own data so it doesn't hallucinate answers
  • Streaming responses: returning AI output word-by-word for a ChatGPT-like experience instead of making users wait
  • LangChain4j: the Java library that makes building complex AI workflows much simpler than calling raw APIs directly

Production AI Considerations

  • Cost management: how to estimate and control your API spend so an AI feature doesn't become an unexpectedly expensive mistake
  • Rate limiting and caching AI responses: patterns for building AI features that stay fast and affordable at scale
  • Content moderation and safety: handling inappropriate inputs gracefully so your app can't be easily misused
  • What AI can't do well: hallucinations, reasoning limits, and when to reach for traditional code instead of an LLM
09

Front-End Technologies

TypeScript Foundations

  • Why TypeScript exists: catching bugs before they run by adding types to JavaScript — and why every serious frontend team uses it
  • Types, interfaces, and generics: the TypeScript features you'll encounter daily and how to read type errors without panic
  • Async/await and Promises: the modern way to handle API calls in JavaScript without falling into "callback hell"
  • Modules and imports: how modern JavaScript applications are structured so code stays organised and easy to navigate

React Development

  • Components and JSX: the mental model of building a UI as a tree of small, independent, reusable pieces
  • Props and state: how data flows through a React app, and why understanding this prevents most beginner bugs
  • The useEffect hook: syncing your UI with external data sources like your Spring Boot API without infinite loops
  • React Query for data fetching: handling loading states, errors, and caching in a way that feels professional and clean

Connecting Frontend to Backend

  • Making API calls from React to your Spring Boot backend: fetch, Axios, and handling errors the right way
  • CORS explained: why your browser blocks certain API calls by default and how to configure your Spring Boot app to allow them
  • Authentication flows in React: storing tokens, protecting routes, and logging users out when their session expires
  • Deploying your React app to Azure Static Web Apps and wiring it to your Spring Boot backend running on AKS
Capstone

What You'll Build

By the end of this programme, you'll have a complete, deployed, production-grade project in your GitHub portfolio.

🏗️
REST API with Spring Boot

A fully documented, layered Java backend with authentication, validation, and a real database.

⚛️
React + TypeScript Frontend

A responsive, component-based UI that consumes your API and handles auth, loading, and error states.

🤖
AI-Powered Feature

An integrated LLM feature — chat, summarisation, or smart search — using Azure OpenAI in your app.

🐳
Containerised Deployment

Your entire stack running in Docker containers, orchestrated by Kubernetes on Azure AKS.

🔄
CI/CD Pipeline

Automated build and deployment via Azure DevOps or GitHub Actions — push code, it deploys itself.

📊
Monitoring & Observability

Application Insights integration with dashboards and alerts for your live, production deployment.

Enroll in the Next Batch →