Duration 5 days – 35 Hours 

 

Overview

 

This Back-End Development training course equips participants with practical, job-ready skills to build modern, secure, and scalable backend services using Java with Spring Boot and Node.js with NestJS or Express.

 

Participants will learn how to design and implement RESTful and GraphQL APIs, apply industry-standard authentication and authorization mechanisms, and build reliable services using data validation, error handling, logging, and clean architecture practices. Hands-on labs and a capstone project ensure learners can develop backend systems that are maintainable, production-ready, and scalable.

 

Objectives

 

• Build backend applications using Spring Boot and Node.js (NestJS/Express)
• Design clean RESTful APIs using best practices and proper HTTP semantics
• Create GraphQL APIs with queries, mutations, and schema design
• Implement secure authentication and authorization (JWT, RBAC, OAuth concepts)
• Apply validation, error handling, and consistent API responses
• Structure backend services using scalable architecture patterns (layers, modules, clean architecture)
• Integrate databases and external services using safe and maintainable patterns
• Build a backend capstone project with security, validation, and API documentation

 

Target Audience

 

• Junior to mid-level Backend Developers
• Full-Stack Developers strengthening backend specialization
• Java Developers transitioning to modern Spring Boot APIs
• JavaScript Developers building server-side applications using Node.js
• Software Engineers working on microservices and API-based systems
• Application Support / DevOps Engineers needing backend fundamentals for troubleshooting

 

Prerequisites 

• Basic programming knowledge (variables, loops, functions, OOP basics)

• Familiarity with HTTP fundamentals and JSON

• Basic understanding of databases is helpful (SQL or NoSQL)

• Laptop with development tools ready (IDE, Node.js, Java, Git)

 

Course Outline 

Day 1:  Back-End Fundamentals + REST API Design Standards 

• Backend Essentials

• What a backend service does (APIs, business logic, persistence)
• Client-server architecture and API-first systems
• Environment setup (Java, Spring Boot, Node.js, NestJS/Express, Postman)

• RESTful API Design Best Practices

• HTTP methods and correct usage (GET, POST, PUT, PATCH, DELETE)
• Status codes, request/response structure, pagination
• Naming conventions and resource design
• API versioning and response consistency

• Lab: Design a REST API spec for a mini system (e.g., Orders / Users)

 

Day 2:  Java Spring Boot: Building Production APIs

• Spring Boot Fundamentals

• Project structure and dependencies
• Controllers, Services, Repositories (layered architecture)
• DTOs and mapping
• Connecting to database (JPA/Hibernate intro)

• Validation & Error Handling

• Input validation (Bean Validation)
• Global exception handling best practices
• Standardized error responses (API error format)

• Lab: Build a CRUD REST API in Spring Boot with validation and error handling

 

Day 3:  Node.js Backend: NestJS or Express (Trainer Choice / Client Preference)

• Node.js Backend Concepts

• Event loop basics, async patterns
• Environment config, folder structures
• Controllers/routes, services, middleware

• NestJS (Recommended for Scalable Structure)

• Modules, controllers, providers (dependency injection)
• Pipes for validation
• Interceptors for consistent responses
  (Alternative: Express for lightweight APIs)

• Lab: Build a REST API service in Node.js with validation and structured routing

 

Day 4:  GraphQL API Design + Integration

• GraphQL Fundamentals

• GraphQL vs REST: when to use each
• Schema design: types, queries, mutations
• Resolvers and data fetching patterns
• Error handling and validation in GraphQL

• Hands-on Lab:

• Build a GraphQL API (Users + Transactions example)
• Connect to database / mock data
• Add basic security control

 

Day 5:  Authentication, Authorization + Scalable Architecture + Capstone

• Authentication & Authorization

• Auth fundamentals: authentication vs authorization
• Token-based security (JWT)
• Role-based access control (RBAC)
• OAuth2 concepts and SSO overview (high level)
• Refresh tokens and session safety

• Scalable Service Architecture

• Layered architecture vs clean architecture
• Separation of concerns and modular design
• Logging + monitoring basics
• API documentation (OpenAPI/Swagger)
• Performance considerations (caching, pagination)

• Capstone Project (End-to-End Build)

Build a backend service such as:

• Billing + Invoice Service
• Simple User + Order Management System

Must include:

• REST API endpoints
• GraphQL module (optional integration)
• JWT authentication + role-based permissions
• Validation + global error handling
• API documentation (Swagger)
• Clean project structure (scalable modules)

• Final Output: A deployable backend service ready for integration