Backend Syllabus
Java Fundamentals (24 Lessons)
- Introduction to Java
- History, JVM, JDK, and Hello World.
- Primitive Data Types and Variables
int, double, boolean, variable declaration, and scope.
- Operators and Expressions
- Arithmetic, relational, logical, and bitwise operators.
- Control Flow Statements
if-else, switch-case, and ternary operator.
- Loops and Iteration
for, while, do-while, and loop control (break, continue).
- Arrays and Array Manipulation
- 1D/2D arrays,
Arrays utility class, and varargs.
- String Handling
String, StringBuilder, StringBuffer, and immutability.
- OOP Basics: Classes, Objects, and Records
- Class syntax, object creation,
record types (immutable data carriers).
- Methods, Constructors, and Initialization
- Method overloading, constructors, static/instance initializer blocks.
- Inheritance and Polymorphism
extends, method overriding, super, and runtime polymorphism.
- Abstraction classes
abstract classes and sealed classes.
- Encapsulation and Access Control
- Packages,
import, access modifiers (public, private, protected).
- Interface
Iterface default/static methods,
- Exception Handling
- Exception Handling
- Custom exceptions and
try-with-resources.
- Generics: Basics and Type Parameters
- Generic classes, methods, and bounded types.
- Advanced Generics
- Wildcards (
?, ? extends T, ? super T), type erasure, and limitations.
- Collections Framework: Lists and Sets
ArrayList, LinkedList, HashSet, LinkedHashSet, and iteration.
- Collections Framework: Maps and Ordering
HashMap, LinkedHashMap, TreeMap, and Comparator vs. Comparable.
- Collections Utilities
- Sorting, searching,
Collections class, and iterator patterns.
- Multithreading Fundamentals
Thread class, Runnable, thread lifecycle, and basic synchronization.
- File I/O: Basics
File, FileReader, FileWriter, and exception handling.
- File I/O: Streams and Advanced Handling
- Byte streams (
InputStream, OutputStream), character streams (Reader, Writer).
- Functional Programming with Lambdas
- Lambda syntax,
@FunctionalInterface, and method references.
- Streams API: Foundations
Stream creation, map, filter, collect, and terminal operations.
- Advanced Streams and Parallel Processing
reduce, groupingBy, parallel streams, and performance considerations.
SQL with PostgreSQL (4 Lessons)
- Introduction to PostgreSQL and Basic SQL
- PostgreSQL installation,
psql CLI, and GUI tools (pgAdmin).
- CRUD Operations:
SELECT, INSERT, UPDATE, DELETE.
- Data types (
VARCHAR, INT, DATE), and table creation (CREATE TABLE).
- Advanced Querying: Joins and Aggregation
- Joins:
INNER JOIN, LEFT/RIGHT JOIN, FULL OUTER JOIN.
- Aggregation:
GROUP BY, HAVING, and functions (SUM, AVG, COUNT).
- Subqueries: Nested queries,
EXISTS, and IN clauses.
- Database Design and Optimization
- Normalization: 1NF, 2NF, 3NF, and denormalization trade-offs.
- Indexes:
CREATE INDEX, B-tree vs. Hash indexes, query optimization.
- Transactions:
BEGIN, COMMIT, ROLLBACK, and ACID properties.
- JDBC: Connecting Java to PostgreSQL
- JDBC architecture,
DriverManager, and connection strings.
- Executing queries (
Statement, PreparedStatement), handling ResultSet.
- Connection pooling basics (HikariCP) and best practices.
Git & Version Control (2 Lessons)
- Git Fundamentals and Local Workflow
- Core Concepts: Repositories, commits, staging (
git add), and .gitignore.
- Branching:
git branch, git checkout, and branch lifecycle.
- Remote Repositories:
git remote, git push/pull, GitHub/GitLab setup.
- Tools: VS Code Git integration, CLI basics, and GUIs (Sourcetree).
- Team Collaboration with Git
- Merge Conflicts: Identification, resolution, and
git mergetool.
- Pull Requests: Creating, reviewing, and merging PRs on GitHub.
- Workflows: Centralized vs. Feature Branch vs. GitHub Flow.
- Best Practices: Atomic commits, meaningful messages, and rebasing vs. merging.
Spring Framework (4 Lessons)
- Spring Core: IoC, DI, and Annotations
- Inversion of Control (IoC), Dependency Injection (DI).
- Stereotype annotations:
@Component, @Service, @Repository, @Autowired.
- Spring Configuration and Profiles
- Java-based configuration (
@Configuration, @Bean).
- Property files (
@PropertySource), environment profiles (@Profile).
- Bean Lifecycle and Scopes
@PostConstruct, @PreDestroy, bean scopes (singleton, prototype).BeanFactory vs. ApplicationContext.
- Spring AOP Basics
- Aspect-Oriented Programming concepts (logging, transactions).
@Aspect, @Before, @After, @Around advice.
HTTP & Web Fundamentals (1 Lesson)
(Added as a bridge between Spring Framework and Spring Boot)
- How the Web Works
- HTTP protocol, request-response cycle, IP, and ports.
- HTTP methods (
GET, POST, PUT, DELETE), status codes (200, 404, 500).
- Headers, cookies, and statelessness.\
Spring Boot (4 Lessons)
- Spring Boot Fundamentals
- Starters, auto-configuration,
@SpringBootApplication, embedded servers.
- Configuration with
application.properties/YAML, profiles (dev, prod).
- Actuator basics: Health checks, metrics, and custom endpoints.
- RESTful APIs with Validation & Database Integration
@RestController, @GetMapping/@PostMapping, JSON serialization.- Input validation (
@Valid, @Size), exception handling (@ControllerAdvice).
- PostgreSQL setup with Spring Data JPA, HikariCP connection pooling.
- API Consumption with RestTemplate
- HTTP client fundamentals,
GET/POST requests.
- Error handling, retries, headers, and authentication.
- Declarative REST Clients with Feign
- Feign setup, interface-based API definitions.
- Customization (logging, error decoders), basic request/response handling.
Spring Data JPA (5 Lessons)
- JPA Entities & Mapping
@Entity, @Table, @Id, @GeneratedValue, @Column.
- Repositories & Query Methods
CrudRepository, JpaRepository, derived queries (e.g., findByEmail).
- Custom Queries
- JPQL (
@Query), native SQL queries, and parameter binding.
- Entity Relationships
@OneToMany, @ManyToOne, @JoinColumn, bidirectional mappings.
- Transactions & Optimizations
@Transactional, isolation levels, read-only transactions.
Spring Security (3 Lessons)
- Authentication & Authorization Basics
- Security filters, in-memory/user-details authentication.
- Role-based access control (
hasRole, hasAuthority).
- JWT Integration
- Token generation/validation,
JwtFilter, signing keys.
- Securing REST APIs
- CSRF/CORS configuration, method-level security (
@PreAuthorize).
Testing (2 Lessons)
- Unit Testing Basics with JUnit 5
- Writing tests for services, repositories, and controllers.
- Assertions (
assertEquals, assertThrows), test lifecycle (@BeforeEach, @AfterEach).
- Basic mocking with Mockito (
@Mock, @InjectMocks).
- Advanced Unit Testing & Coverage
- Mocking complex dependencies (e.g., REST clients, databases).
- Parameterized tests (
@ParameterizedTest).
- Test coverage with JaCoCo, edge case testing.
Docker (2 Lessons)
- Docker Fundamentals
- Containers vs. images, Docker CLI (
build, run, logs).
- Dockerfile for Spring Boot apps, multi-stage builds.
- Docker Compose & Networking
- Defining services in
docker-compose.yml.
- Running Spring Boot + PostgreSQL together.
- Environment variables and volume mounts.
Cloud Deployment (1 Lesson)
- Deploying to AWS/Heroku
- Deploying Dockerized apps to AWS EC2/Heroku.
- Configuring production databases (RDS/Heroku Postgres).
- Monitoring with Actuator and logging.
Final Project (2 Lessons)
- Project Setup & Core Implementation
- Requirements, architecture design, Git setup.
- Building REST APIs with Spring Boot, JPA, and security.
- Deployment & Final Demo
- Dockerizing the app, deploying to the cloud.
- Demo with Postman/Swagger documentation.
