Java with Spring Boot Framework — Full Stack LaunchPad

This is the Full Stack LaunchPad track syllabus — 4 months · 16 weeks.View the full program

What you'll be able to do

Build responsive, multi-page websites with HTML, CSS, JavaScript, and Bootstrap
Write solid Core Java: OOP, collections, exceptions, multithreading, file I/O, and JDBC
Build production-style REST APIs with Spring Boot, JPA/Hibernate, and a relational database
Secure APIs with Spring Security and JWT
Design, build, and deploy a microservices-based application

Tools & technologies

HTMLCSSJavaScriptBootstrapGitJavaOOPJDBCSpring BootRESTJPAHibernate

The syllabus

120 days · 120 modules · 360 lessons

Web Technologies

HTML Foundations and Page ContentDays 1-5

Day 1: Web Foundations and ToolsUnderstand websites, browsers, clients and servers · Create a project folder and organize web files · Use a code editor, browser and developer toolsBuild: Create a first project folder and open a Hello Web page in the browser.
Day 2: HTML Document StructureLearn tags, elements, attributes and nesting · Use doctype, html, head, title and body · Follow indentation and naming conventionsBuild: Build a correctly structured About Me page.
Day 3: Text and Semantic ContentAdd headings, paragraphs and line breaks · Use strong, emphasis, quotations and code text · Choose meaningful elements instead of visual tagsBuild: Create a short biography with well-structured text.
Day 4: Links, Images and PathsCreate internal and external hyperlinks · Add images with useful alternative text · Understand relative and absolute file pathsBuild: Build a two-page travel guide with navigation and images.
Day 5: Lists and TablesCreate ordered, unordered and description lists · Build tables with rows, headers and captions · Use tables only for tabular informationBuild: Create a restaurant menu and weekly timetable.

Semantic HTML and CSS FoundationsDays 6-10

Day 1: HTML FormsUse form, label, input, textarea and button · Explore common input types and attributes · Group related controls and make forms accessibleBuild: Build a student registration form without processing it.
Day 2: Semantic HTML and AccessibilityUse header, nav, main, section, article and footer · Connect labels and write helpful alternative text · Check heading order and keyboard usabilityBuild: Convert an unstructured page into an accessible semantic page.
Day 3: CSS Introduction and SelectorsLink an external stylesheet · Use element, class and ID selectors · Write declarations with properties and valuesBuild: Style the biography page with reusable CSS classes.
Day 4: Cascade, Specificity and InheritanceUnderstand how competing rules are resolved · Compare selector specificity · Use inheritance and developer tools to debug stylesBuild: Fix a deliberately conflicting stylesheet.
Day 5: CSS Box ModelWork with content, padding, border and margin · Use width, height and box-sizing · Control overflow and spacing consistentlyBuild: Create three neatly spaced profile cards.

CSS Layout and Responsive DesignDays 11-15

Day 1: Colors, Backgrounds and TypographyUse color formats and readable contrast · Style fonts, size, weight, line height and alignment · Add backgrounds, borders and simple shadowsBuild: Design a professional article page.
Day 2: Display and PositioningCompare block, inline, inline-block and none · Use relative, absolute, fixed and sticky positioning · Understand document flow and z-indexBuild: Build a sticky header and positioned notification badge.
Day 3: Flexbox LayoutIdentify flex containers, axes and items · Align, justify, wrap and space items · Build flexible navigation and card rowsBuild: Create a responsive navigation bar and card section.
Day 4: CSS Grid LayoutDefine grid columns and rows · Use gaps, spanning and named areas · Choose Grid or Flexbox for the layoutBuild: Build a dashboard-style page layout.
Day 5: Responsive Web DesignApply mobile-first design · Write media queries and flexible measurements · Make images, navigation and grids responsiveBuild: Adapt the dashboard for phone, tablet and desktop widths.

JavaScript Programming and the DOMDays 16-20

Day 1: JavaScript IntroductionAdd JavaScript with a script file · Use the console and simple statements · Declare variables and inspect primitive data typesBuild: Create a console-based personal profile program.
Day 2: Operators and ExpressionsUse arithmetic and assignment operators · Compare values with strict equality · Combine conditions with logical operatorsBuild: Build a bill, discount and final-total calculator.
Day 3: Decision ControlWrite if, else if and else branches · Use truthy and falsy values carefully · Apply switch and conditional expressionsBuild: Create a grade and eligibility checker.
Day 4: LoopsRepeat work with for and while loops · Use counters, accumulators, break and continue · Avoid common infinite-loop mistakesBuild: Generate multiplication tables and summary totals.
Day 5: Functions and ScopeDefine functions with parameters and return values · Compare function declarations and arrow functions · Understand local and global scopeBuild: Turn calculator operations into reusable functions.

Browser Data and Web Technologies CapstoneDays 21-25

Day 1: Arrays and ObjectsCreate, read and update arrays · Model records with object properties and methods · Combine arrays and objects for structured dataBuild: Store and display a small product catalogue in JavaScript.
Day 2: DOM Selection and UpdatesSelect elements with DOM methods · Read and change text, attributes and classes · Create and remove elements safelyBuild: Render product cards from JavaScript data.
Day 3: Events and Form ValidationHandle click, input, submit and change events · Read form values and prevent default submission · Show clear validation messagesBuild: Add client-side validation to the registration form.
Day 4: Browser Data and Fetch BasicsStore JSON data with localStorage · Understand promises and async operations · Fetch public JSON and handle loading or errorsBuild: Build a persistent reading list or load sample API data.
Day 5: Web Technologies CapstonePlan a multi-section responsive website · Combine semantic HTML, CSS layouts and JavaScript · Test links, forms, responsiveness and accessibilityBuild: Complete and present a responsive interactive business website.

React Development

Setup, Components, JSX, Props and StateDays 1-5

Day 1: React Introduction and SetupUnderstand components and single-page applications · Create a React project with Vite · Explore the project files and development serverBuild: Create a React project and replace the starter screen.
Day 2: JSX and ComponentsWrite JSX with correct syntax · Create and export function components · Compose small components into a pageBuild: Build Header, MainContent and Footer components.
Day 3: Props and Reusable ComponentsPass data from parent to child · Use props to customize repeated UI · Keep component responsibilities clearBuild: Create reusable hotel feature and room cards.
Day 4: Styling React ComponentsApply class names and external CSS · Organize styles for components · Build responsive layouts for React pagesBuild: Style a responsive hotel landing section.
Day 5: Events and StateHandle clicks and input events · Create state with useState · Update state without changing existing values directlyBuild: Build an interactive room counter or favourite button.

Lists, Forms, Shared State, Effects and RoutingDays 6-10

Day 1: Conditional Rendering and ListsRender different content from state · Display arrays with map · Assign stable keys and handle empty listsBuild: Render a filterable list of hotel amenities.
Day 2: Controlled FormsConnect form inputs to state · Handle changes and submission · Display beginner-friendly validation messagesBuild: Build a controlled guest enquiry form.
Day 3: Sharing StateLift shared state to a common parent · Pass values and callbacks through props · Keep one reliable source of truthBuild: Synchronize a room selector with a booking summary.
Day 4: Effects and Component LifecycleUnderstand when effects run · Use useEffect with dependencies · Clean up timers or subscriptionsBuild: Create an automatic promotional banner or clock.
Day 5: Fetching DataRequest JSON data asynchronously · Show loading, success and error states · Render fetched records safelyBuild: Load and display sample room data from JSON.

Plan, Build, Test and Present the Hotel ProjectDays 11-15

Day 1: React RouterConfigure browser routing · Create links and route components · Use route parameters for detail pagesBuild: Add Home, Rooms, Dining and Contact routes.
Day 2: Hooks and Reusable LogicReview useState and useEffect rules · Extract repeated logic into a custom hook · Organize components, pages and data filesBuild: Create a small custom hook for saved favourites.
Day 3: React Hotel Capstone PlanningDefine pages, sections and visitor journeys · Create a component and routing plan · Prepare responsive wireframes and sample dataBuild: Produce the hotel site plan and reusable component list.
Day 4: React Hotel Pages and ReservationBuild shared navigation and page layouts · Create rooms, dining and experiences sections · Add a validated reservation enquiry formBuild: Complete the core hotel pages and booking form.
Day 5: React Hotel Testing and Final BuildTest navigation, forms and responsive layouts · Fix console warnings and accessibility issues · Create an optimized production build and presentationBuild: Finish and present the React hotel capstone website.

Core Java Programming

Introduction, Syntax, Types and CollectionsDays 1-6

Day 1: Java and the JVMCompare compiled Java applications with browser JavaScript · Install a JDK, IDE and verify Java version · Compile and run a first Java programBuild: Display a dynamic welcome message and current date from a Java program.
Day 2: Java Syntax and VariablesUnderstand classes, main method, statements and comments · Create variables and constants with clear names · Use console input and outputBuild: Create a console-based student profile program.
Day 3: Data Types and Type ConversionWork with primitives, strings and wrapper classes · Convert values safely and inspect results · Recognize type ranges and precisionBuild: Build a type-inspection and conversion practice program.
Day 4: Java OperatorsUse arithmetic, assignment, comparison and logical operators · Understand precedence and parentheses · Apply increment and compound assignment carefullyBuild: Create a salary, tax and net-pay calculator.
Day 5: Strings and Text ProcessingCreate, compare and combine strings correctly · Use common String methods and StringBuilder · Format output with printf or formatted stringsBuild: Build a username and message formatter.
Day 6: ArraysCreate, access and update one-dimensional arrays · Use array length and bounds safely · Sort and inspect values while debuggingBuild: Create a simple course-list manager.

Control Flow, Methods, Packages and FilesDays 7-12

Day 1: Collections and MapsUse ArrayList, HashSet and HashMap · Store named fields and structured records · Choose a collection suited to the requirementBuild: Build an in-memory product catalogue.
Day 2: Decision ControlWrite if, else if and else statements · Use switch expressions when appropriate · Validate decisions with clear Boolean logicBuild: Create admission and discount eligibility rules.
Day 3: Loops and IterationUse for, while and do-while loops · Traverse arrays and collections safely · Use break and continue deliberatelyBuild: Generate a marks report from a collection.
Day 4: Methods and ScopeDefine parameters, return types and method overloads · Use local variables and class-level fields · Extract reusable calculation logicBuild: Create reusable invoice calculation methods.
Day 5: Packages and Utility APIsOrganize code using packages and imports · Use Math, LocalDate and formatting APIs · Read Java API documentation and test resultsBuild: Build a utility program for text, dates and totals.
Day 6: Files and Project StructureSeparate model, service and application classes · Read and write text files with NIO · Use paths safely and close resources automaticallyBuild: Convert a one-file program into a structured Java project.

OOP, Exceptions, Streams and TestingDays 13-18

Day 1: Object-Oriented DesignDefine classes, fields, constructors and methods · Model data and behaviour together · Use encapsulation with getters and settersBuild: Create Product and CartItem classes.
Day 2: Inheritance and PolymorphismApply inheritance only where it models an is-a relationship · Override methods and use polymorphic references · Prefer composition where it is clearerBuild: Model users and roles with classes and interfaces.
Day 3: Interfaces, Abstract Classes and EnumsCreate contracts with interfaces · Use abstract base classes and enums appropriately · Program to an interface where usefulBuild: Build a payment or notification strategy simulation.
Day 4: Exceptions and DebuggingDistinguish checked and unchecked exceptions · Use try, catch, finally and try-with-resources · Debug with breakpoints and useful messagesBuild: Add safe error handling to the course-list manager.
Day 5: Streams and LambdasUse lambda expressions and method references · Filter, map, sort and collect data with streams · Recognize when a simple loop is clearerBuild: Create a filtered sales and product report.
Day 6: Testing with JUnitWrite Arrange-Act-Assert unit tests · Use assertions and test edge cases · Keep testable business logic separate from input/outputBuild: Test invoice calculations and validation rules.

HTTP, Maven, Clean Code and Type-Safe DesignDays 19-24

Day 1: JSON and HTTP BasicsRepresent Java objects as JSON · Understand HTTP methods, status codes and REST concepts · Call a public API with Java HTTP client basicsBuild: Load and display data from a public JSON API.
Day 2: Maven and Dependency ManagementCreate a Maven project and understand pom.xml · Add and update dependencies responsibly · Run builds and tests from the command lineBuild: Build and test a Maven console application.
Day 3: Clean Code and SOLID BasicsUse descriptive names and small focused methods · Identify single responsibility and dependency inversion · Refactor duplication without changing behaviorBuild: Refactor the product catalogue for readability and testability.
Day 4: Java Security BasicsValidate inputs and avoid exposing sensitive details · Store secrets outside source code · Recognize common injection and deserialization risksBuild: Harden a console application configuration and input flow.
Day 5: Core Java Mini ProjectCombine OOP, collections, files, exceptions and tests · Plan a small domain model and user flows · Prepare setup notes and a demonstrationBuild: Complete and present a tested library, task or inventory manager.
Day 6: Generics and Type-Safe CodeCreate generic classes and methods · Use parameterized collections safely · Recognize raw types and type inferenceBuild: Create a type-safe reusable result or repository helper.

Modern Java APIs, Concurrency and Programming CapstoneDays 25-30

Day 1: Records and Immutable DataCreate records for simple data carriers · Understand immutability and value-based modeling · Compare records with traditional classesBuild: Model read-only product and customer data with records.
Day 2: Comparators and Advanced CollectionsSort objects with Comparable and Comparator · Use queues, stacks and maps for suitable problems · Choose collection implementations deliberatelyBuild: Create a ranked product and priority-task organiser.
Day 3: Date, Time and LocalizationUse LocalDate, LocalDateTime and Duration · Parse and format user-facing dates · Avoid legacy date APIs in new codeBuild: Build an appointment and due-date calculator.
Day 4: Concurrency BasicsUnderstand threads, tasks and shared state · Run background work with ExecutorService · Identify common thread-safety concernsBuild: Create a concurrent batch-processing simulation.
Day 5: Java HTTP ClientSend HTTP requests with the Java HTTP Client · Handle JSON responses and failure status codes · Keep network code separate from domain logicBuild: Build a public API client with clear error messages.
Day 6: Java Programming CapstonePlan, build and test a complete console application · Use OOP, collections, files and external data · Write setup notes and present the programBuild: Complete and present a tested Java inventory or task manager.

Spring Boot and REST API

Relational Data, Schema Design and QueriesDays 1-6

Day 1: Relational Database ConceptsUnderstand databases, tables, rows and columns · Identify primary and foreign keys · Turn simple requirements into entitiesBuild: Draw a database diagram for a library system.
Day 2: MySQL Setup and SchemaCreate a database and tables · Choose practical data types · Add keys, defaults and constraintsBuild: Create the library database schema.
Day 3: INSERT and SELECTAdd single and multiple records · Retrieve chosen columns and aliases · Read query results systematicallyBuild: Populate and list books, members and authors.
Day 4: Filtering and AggregationFilter with WHERE and logical operators · Sort and limit results · Use count, sum, average and groupingBuild: Produce a filtered stock and category report.
Day 5: UPDATE, DELETE and Data IntegrityUpdate targeted rows safely · Delete only after checking conditions · Use unique, not-null and referential constraintsBuild: Correct sample records and safely remove one record.
Day 6: Relationships and JOINsModel one-to-one, one-to-many and many-to-many data · Query related tables with joins · Use aliases for readable resultsBuild: Create a report joining books, authors and loans.

JDBC CRUD, Spring Boot Setup and ConfigurationDays 7-12

Day 1: Normalization and IndexesReduce repeated data through normalization · Choose indexes for common lookups · Recognize the cost of unnecessary indexesBuild: Improve a deliberately duplicated product schema.
Day 2: JDBC Connections and Prepared StatementsConnect Java to MySQL with JDBC · Use environment configuration and connection handling · Bind parameters with prepared statementsBuild: Build a reusable database connection and safe lookup.
Day 3: JDBC Create and ReadInsert validated data from Java · Fetch lists and single records · Handle missing records clearlyBuild: Create product add, list and detail commands.
Day 4: JDBC Update, Delete and TransactionsEdit existing records · Confirm and delete records safely · Use transactions for related changesBuild: Complete product CRUD with a transactional stock update.
Day 5: Spring Boot Introduction and SetupUnderstand Spring Boot conventions and starter dependencies · Create a project with Spring Initializr · Run the application and inspect the development serverBuild: Create a Spring Boot project and expose a custom home endpoint.
Day 6: Project Structure and ConfigurationLocate controllers, services, repositories and resources · Use application properties and environment variables · Configure application settings safelyBuild: Document key folders and add a local profile.

Controllers, Services, DTOs, Errors and JPADays 13-18

Day 1: Controllers and RoutingMap HTTP methods and path variables · Use request parameters and request bodies · Return JSON responses with clear status codesBuild: Create REST routes for a small catalogue.
Day 2: Dependency Injection and ServicesUnderstand inversion of control and bean lifecycle · Inject dependencies through constructors · Move business rules into servicesBuild: Move catalogue logic into a service-backed controller.
Day 3: DTOs and API DesignSeparate API contracts from entities · Use request and response DTOs · Map data deliberately and document response shapesBuild: Return product lists and empty states using response DTOs.
Day 4: Global Error HandlingCreate exception handlers with ControllerAdvice · Return consistent error formats · Handle validation and not-found errors clearlyBuild: Create a reusable API error response and handler.
Day 5: Spring Data JPA and EntitiesCreate entities and configure the datasource · Map columns, identifiers and relationships · Use schema migrations or controlled generationBuild: Create categories and products tables from JPA entities.
Day 6: Repositories and CRUDUse JpaRepository for common persistence operations · Insert, retrieve, update and delete records · Handle missing data explicitlyBuild: Build product create, list, edit and delete API features.

Repositories, Queries, Validation, REST and SecurityDays 19-24

Day 1: JPA RelationshipsDefine common entity relationships · Load and return related data safely · Avoid N+1 query problems at a beginner levelBuild: Connect products to categories and include category data.
Day 2: Queries, Specifications and PaginationBuild derived and custom repository queries · Add filters and sorting safely · Use Pageable for paginationBuild: Add active-product search, filtering and pagination.
Day 3: Bean ValidationAdd validation annotations to request DTOs · Display field-level validation errors · Create reusable custom validation when neededBuild: Add robust validation to product create and update requests.
Day 4: RESTful Resource DesignOrganize resource endpoints consistently · Apply PUT, PATCH and DELETE intentionally · Keep controller actions small and predictableBuild: Refactor product CRUD into a clean REST resource.
Day 5: Spring Security and JWTUnderstand authentication filters and security context · Protect routes with Spring Security · Issue and validate JWTs at an introductory levelBuild: Protect a dashboard endpoint and verify unauthorized responses.
Day 6: Authorization and RolesDefine roles and permission checks · Secure methods or endpoints appropriately · Enforce ownership rules in service logicBuild: Allow owners or administrators to edit products.

File Storage, Observability, Tests, Documentation and DeploymentDays 25-30

Day 1: File Storage and UploadsConfigure multipart file handling · Validate and store uploaded files · Serve or reference files safelyBuild: Add product-image upload and replacement.
Day 2: Logging, Profiles and ObservabilityUse structured application logs · Separate development and production configuration · Expose health information safely with ActuatorBuild: Add clear logs and health checks to CRUD operations.
Day 3: Testing Spring Boot ApplicationsWrite unit tests for services · Use MockMvc or WebTestClient for controllers · Test repository behavior with isolated dataBuild: Test product routes, validation, authorization and database results.
Day 4: API DocumentationDocument endpoints with OpenAPI / Swagger · Describe request, response and error examples · Keep documentation aligned with implementationBuild: Publish interactive documentation for the catalogue API.
Day 5: Integration and Deployment BasicsBuild an executable JAR and use environment variables · Prepare database, CORS and production configuration · Understand containerization and cloud deployment conceptsBuild: Package the API and prepare a deployment checklist.
Day 6: Spring Boot Mini ProjectIntegrate REST, JPA, validation, security and tests · Complete an API for a realistic domain · Present features, architecture and limitationsBuild: Finish and present a tested content manager or mini CRM API.

Spring Boot + React Major Project

Architecture, Catalogue, Accounts and StorefrontDays 1-5

Day 1: Capstone Scope and Data DesignDefine customers, administrators and user stories · Plan products, categories, carts, orders and order items · Create API contracts and acceptance criteriaBuild: Produce the e-commerce brief, schema and endpoint plan.
Day 2: Project Foundation and Admin CatalogueConfigure the project, database and shared API conventions · Build category and product entities · Add protected catalogue managementBuild: Create administrator CRUD for categories and products.
Day 3: Storefront Catalogue APIBuild catalogue and product-detail endpoints · Add search, category filters and pagination · Return prices, images and stock status clearlyBuild: Complete the public browsing API for the React storefront.
Day 4: Customer AccountsAdd registration, login and logout endpoints · Build profile and address management · Protect account routes and validate ownershipBuild: Complete customer account and address API features.
Day 5: Shopping CartAdd, update and remove cart items · Calculate quantities, subtotals and totals · Validate stock and persist the cartBuild: Build a working database-backed cart API.

React API Data, Routing, Search, Filters and Cart StateDays 6-10

Day 1: React Storefront SetupPlan React pages, routes, components and API services · Build a shared header, navigation, footer and page shell · Add responsive CSS and accessible navigationBuild: Create the connected storefront layout.
Day 2: Live Product CatalogueFetch products from the Spring Boot API · Render reusable product cards from returned data · Display loading, empty and error statesBuild: Build a live product catalogue.
Day 3: Product Details and RoutingAdd product routes and route parameters · Build detail pages with price, stock and images · Handle invalid products and missing images safelyBuild: Create the product-detail experience.
Day 4: Search and Product FilteringConnect category, search, price and ordering controls · Keep filter values in controlled React state · Reset filters and explain no-result statesBuild: Build the search and filter interface.
Day 5: Persistent Cart StateDesign cart items and cart-summary state · Share cart data with Context and a reducer · Persist and reconcile cart values safelyBuild: Create a persistent shopping cart UI.

Checkout, Accounts, Orders and AdministrationDays 11-15

Day 1: Checkout and Order SchemaDesign checkout requests and validation · Create orders and order-item records · Copy product and address snapshots into ordersBuild: Build checkout review and address selection endpoints.
Day 2: Order Creation and StockCreate orders inside a database transaction · Recheck and decrement stock safely · Clear the cart and return confirmationBuild: Place a complete test order and verify database results.
Day 3: Order ManagementShow customer order history and details · Build administrator order lists and status updates · Enforce permissions for every order actionBuild: Complete customer and administrator order workflows.
Day 4: Quality, Security and DeploymentTest catalogue, accounts, cart and checkout · Review validation, authorization, CORS and secrets · Prepare database and deployment checklistBuild: Run the test plan and resolve all critical defects.
Day 5: React CheckoutBuild shipping and contact forms with validation · Review server-calculated totals and cart items · Submit an order and show confirmation feedbackBuild: Complete the React checkout flow.

Testing, Security, Deployment and Final PresentationDays 16-20

Day 1: Customer Accounts and Order HistoryConnect login and registration forms to the API · Protect account, checkout and order-history routes · Display a customer profile and owned ordersBuild: Build the customer account area.
Day 2: Admin WorkflowsCreate administrator product, stock and order workflows · Add order-status updates with permission checks · Provide clear success and error feedbackBuild: Build the order-management workflow.
Day 3: Full-Stack TestingTest services, repositories, permissions and API endpoints · Test React pages, cart actions and form validation · Record and fix integration failures systematicallyBuild: Create the automated test suite.
Day 4: Production DeploymentPrepare production configuration, database and file storage · Build the React application and connect production URLs · Write setup, seed-data and API documentationBuild: Prepare a deployment-ready release.
Day 5: Final Integration and PresentationConnect the React storefront to the Spring Boot API · Seed realistic demonstration data · Demonstrate customer and administrator journeysBuild: Submit and present the completed Java Spring Boot e-commerce application.