Duration 12 days – 84 hrs
Overview
Full-Stack Web Application Development and Software Architecture Security is a hands-on, end-to-end program where participants build a modern web application from UI to API using React (JavaScript) and Spring Boot (Java). The bootcamp goes beyond coding by embedding software architecture best practices and web application security fundamentals—helping teams design scalable solutions, integrate cleanly across layers, and apply secure-by-design principles. By the end, participants will have a working full-stack project and a practical toolkit for building production-ready web applications.
1) Frontend Bootcamp: React + JavaScript (3 Days)
Course overview
A hands-on bootcamp that equips participants to build modern web user interfaces using JavaScript 2022 and React, covering component-based development, state management, API integration, routing, forms, and basic testing. Participants finish with a working front-end app connected to a backend API (mock or real).
Objectives
By the end of the course, participants can:
- Write clean, modern JavaScript 2022
- Build reusable React components and manage state effectively
- Implement routing, forms, and validation
- Integrate with REST APIs (fetch/axios), handle loading/errors
- Apply basic front-end performance and code organization practices
Target delegates
- Junior to mid-level developers
- Web developers transitioning to React
- Full-stack aspirants needing strong UI foundations
- QA/automation engineers who need React familiarity (optional)
Prerequisites
- Basic programming fundamentals (variables, loops, functions)
- Familiarity with HTML/CSS basics
- Laptop with Node.js installed (or company-provided dev environment)
Course outline (3 days)
Day 1 — Modern JavaScript + React fundamentals
- JavaScript 2022 let/const, arrow functions, destructuring, modules
- Tooling: npm, Vite/CRA, project structure
- React basics: JSX, components, props, rendering lists, keys
- Events and conditional rendering
- Practice lab: build a UI with reusable components
Day 2 — State, effects, and API integration
- useState / useEffect patterns
- Working with REST APIs: GET/POST, headers, error handling
- Loading states, empty states, notifications
- Forms + validation basics
- Practice lab: CRUD UI with API integration (or mock server)
Day 3 — Routing, patterns, and production readiness
- React Router: routes, nested routes, params
- State management approaches (lifting state, context intro)
- Component design patterns, folder structure, reusable hooks (intro)
- Basic testing overview (React Testing Library concept)
- Build mini-capstone: front-end app consuming a backend API
2) Backend Bootcamp: Java + Spring Boot (3 Days)
Course overview
A practical backend bootcamp focused on building RESTful services using Java and Spring Boot, including controllers, service layers, persistence, validation, exception handling, logging, and basic testing. Participants deliver a working API suitable for a web app.
Objectives
By the end of the course, participants can:
- Build REST APIs using Spring Boot (controllers, services, repositories)
- Apply clean layering and dependency injection
- Implement input validation, error responses, and API standards
- Integrate a database using JPA/Hibernate and migrations (intro)
- Write basic unit/integration tests and document APIs
Target delegates
- Java developers new to Spring Boot
- Backend developers needing a structured Spring Boot foundation
- Full-stack developers who will maintain APIs
Prerequisites
- Java fundamentals (OOP, collections, exceptions)
- Basic HTTP concepts (methods, status codes)
- Familiarity with SQL is helpful but not required
Course outline (3 days)
Day 1 — Spring Boot foundations + REST
- Spring Boot project setup, configuration, profiles
- Controllers, request mapping, DTOs
- Service layer design, DI (Autowired/constructor injection)
- REST conventions: status codes, idempotency, pagination (intro)
- Lab: build basic endpoints (CRUD skeleton)
Day 2 — Persistence + validation + exception handling
- JPA/Hibernate basics: entities, repositories, relationships
- Transactions, lazy/eager loading (concepts)
- Validation: Bean Validation annotations, custom validators (intro)
- Global exception handling (ControllerAdvice), consistent error format
Day 3 — Quality, documentation, and integration readiness
- Logging and monitoring basics, structured logs (intro)
- Security baseline overview (auth concepts, not deep yet)
- Testing: unit tests (service), integration tests (controller)
- Mini-capstone: backend API for a sample app used by React frontend
3) Software Architecture Best Practices (3 Days)
Course overview
A best-practices course focused on designing maintainable, scalable web applications. Covers architectural styles (layered, modular monolith, microservices considerations), domain-driven thinking, API design, integration patterns, observability, reliability, and practical decision-making (tradeoffs).
Objectives
By the end of the course, participants can:
- Choose an appropriate architecture (and justify tradeoffs)
- Design modular boundaries and clean interfaces
- Apply key patterns: layered architecture, hexagonal (intro), CQRS (intro)
- Improve reliability with resilience patterns and observability
- Produce key architecture deliverables (C4 diagrams, ADRs)
Target delegates
- Mid-level to senior developers
- Tech leads / engineering leads
- Solution architects / aspiring architects
- Product/engineering managers who want architecture literacy (optional)
Prerequisites
- Experience building web apps (frontend or backend)
- Basic understanding of REST APIs and databases
- Helpful: familiarity with distributed systems concepts (not required)
Course outline (3 days)
Day 1 — Foundations + structure
- Architecture goals: maintainability, scalability, security, cost
- Architecture styles: layered, modular monolith, microservices (when/when not)
- Domain modeling basics and bounded contexts (practical intro)
- C4 model diagrams (Context/Container/Component)
- Workshop: map a sample system + define boundaries
Day 2 — API, integration, and data
- API design best practices: resources, versioning, pagination, error formats
- Integration patterns: sync vs async, events, queues (conceptual)
- Data ownership, consistency tradeoffs, transactions
- Non-functional requirements and architecture checklists
- Workshop: design an API + integration plan for a sample product
Day 3 — Operability + governance
- Observability: logs, metrics, traces; what to instrument
- Resilience patterns: retries, circuit breakers, bulkheads (intro)
- Release strategies: feature flags, blue/green (conceptual)
- Architecture Decision Records (ADRs), quality gates, review process
- Capstone: produce a lightweight architecture pack (C4 + ADRs + NFR plan)
4) Web Application Security (3 Days)
Course overview
A hands-on security course that teaches developers and technical teams how to identify and prevent common web application risks (OWASP-aligned), apply secure coding practices across frontend and backend, and integrate security into SDLC (DevSecOps mindset).
Objectives
By the end of the course, participants can:
- Recognize common web threats and real attack paths
- Implement secure authentication/session handling patterns (conceptual + practical)
- Prevent injection flaws, XSS, CSRF, and insecure access control
- Secure APIs (validation, rate limiting concepts, secure headers)
- Improve app security posture with secure SDLC practices and testing approaches
Target delegates
- Frontend and backend developers
- Tech leads and QA engineers
- DevOps/SRE involved in deployment and security controls
- Security champions / appsec focal points
Prerequisites
- Basic web fundamentals (HTTP, browser-client-server)
- Some coding experience (JS and/or Java preferred)
- Helpful: familiarity with REST APIs and authentication concepts
Course outline (3 days)
Day 1 — Threats, Top 10 OWASP mindset, and baseline controls
- Threat modeling basics (assets, actors, attack surfaces)
- Top 10 OWASP Risks overview (practical examples)
- Secure auth concepts: password handling, MFA, session basics
- Secure configuration: secrets handling, environment separation (intro)
- Lab: identify vulnerabilities in sample flows + quick fixes checklist
Day 2 — Secure coding for frontend + backend
- Input validation & output encoding
- XSS prevention, CSP concepts, secure headers
- CSRF basics and mitigation
- Injection prevention (SQL/NoSQL concepts), ORM pitfalls
- Access control design: role vs permission, object-level authorization
- Lab: fix vulnerable endpoints + front-end handling patterns
Day 3 — API security + secure SDLC
- API security: authn/authz, token basics, rate limiting concepts
- Logging for security (audit trails), monitoring suspicious behavior
- Dependency risks (SCA concepts), patching discipline
- Security testing overview: SAST/DAST concepts + test planning
- Capstone: security review of the bootcamp app + remediation plan
