Trainer

Revised Curriculum

Week / Skill

Activity / JD Statement

Learning Objectives

Week 1 – SQL Server / PostgreSQL Essentials

Design relational databases and write SQL queries (both T-SQL and PostgreSQL dialects) for CRUD and reporting.

• Understand the fundamentals of SQL and MySQL, including RDBMS concepts, schemas, tables, and SQL data types
• Apply data modeling principles using ERDs and define databases effectively
• Differentiate between SQL sub-languages (DDL, DML, DQL, DCL, TCL) and use them appropriately
• Design and manage database schemas using primary, foreign, composite, and unique keys
• Enforce data integrity and consistency through constraints, normalization, and referential integrity
• Perform CRUD operations using INSERT, UPDATE, DELETE, and SELECT statements
• Use aggregate and scalar functions, clauses, and aliases to analyze data
• Write subqueries and joins (inner, outer, cross, left/right, equi, theta) to retrieve relational data
• Understand ACID properties, transactions, commit/rollback, and isolation levels
• Implement advanced SQL features such as indexes, views, triggers, and stored procedures
• Create, execute, and manage stored procedures, including use cases and best practices
• Apply security and governance concepts, including user defined functions and access control

Week 2 – SDLC, GitLab, Jira

Participate in all phases of SDLC within Agile/Scrum; use Git, pull requests, code reviews, and work items.

• Describe SDLC stages and Agile practices
• Use Git + Jira DevOps Boards effectively
• Apply coding standards and naming conventions
• Participate confidently in Agile ceremonies
• Perform code reviews with constructive feedback
• Understand CI/CD fundamentals

Week 3 – C# with Entity Framework Core (integrated with GitLab, Jira above) & Unit Testing (xUnit, Moq)

Work with EF Core for ORM operations using code-first or DB-first approaches. Create unit tests and mock dependencies for controllers, services, and data layers.

• Create C# entities and design schemas
• Track entity states and lifecycle
• Define relationships using Fluent API
• Build efficient LINQ queries
• Manage migrations and environment differences
• Use repository patterns effectively
• Structure tests using Arrange/Act/Assert
• Mock repositories, services, and APIs.
• Use test collections and fixtures
• Test exceptions, edge cases, and null paths
• Measure and improve code coverage
• Integrate unit tests in CI pipelines

Week 4 – ASP.NET Core MVC / Web API (.Net 6+) & Microservices + Cloud Deployment

Build RESTful APIs with proper routing, validation, exception handling, and documentation. Begin microservices concepts and architecture.

• Build MVC applications
• Implement model binding and validation
• Use configuration and logging
• Implement dependency injection properly
• Handle errors with middleware and filters
• Apply SOLID principles in controllers and services
• Build REST endpoints with proper verbs
• Implement DTOs and AutoMapper
• Add global exception handling
• Apply validation filters and FluentValidation
• Secure APIs with JWT authentication
• Document endpoints with Swagger/OpenAPI
• Understand microservice boundaries
• Build minimal APIs for lightweight services

Week 5 – Microservices + Cloud Deployment (cont.) & Interim Check-In

Build and containerize microservices. Present Client Readiness Project progress to L&D and BU SMEs.

• Containerize apps with Dockerfiles
• Implement logging and distributed tracing
• Test microservices with Postman and integration tests
• Demonstrate working software increment
• Communicate architectural decisions
• Incorporate structured feedback
• Prioritize backlog items effectively
• Present professionally to stakeholders
• Identify final sprint tasks

Week 6 – Azure Fundamentals for Developers

Deploy .NET applications to Azure and use commonly required services.

• Deploy apps to Azure App Service
• Store secrets in Azure Key Vault
• Integrate Azure SQL with EF Core migrations
• Use Blob Storage for file handling
• Configure CI/CD with GitHub Actions
• Monitor performance with Application Insights

Week 7 – Client Readiness Project: Milestone 1 – Database Foundation & Data Access Layer

Database Setup, Schema Design & Core Data Access. Install and configure SQL Server and PostgreSQL. Design and implement core schemas. Build the data access layer using EF Core and Repository pattern.

• Install and configure SQL Server and PostgreSQL locally and provision Azure SQL + PostgreSQL Flexible Server
• Configure Azure Key Vault and store database connection strings
• Design SQL Server schema: TAXPAYERS, TAX_RETURNS, PAYMENTS, TAX_CALCULATIONS, TAX_BRACKETS
• Design PostgreSQL schema: AUDIT_LOG, COMPLIANCE_EVENTS
• Create core tables with constraints, indexes, and relationships
• Implement essential T-SQL stored procedures: SP_SUBMIT_RETURN, SP_PROCESS_PAYMENT
• Implement PL/pgSQL procedure: sp_log_audit_event
• Create sequence objects and views
• Implement Clean Architecture project structure (API, Application, Domain, Infrastructure)
• Configure Entity Framework Core with SQL Server and PostgreSQL DbContexts
• Implement Repository pattern for Taxpayers, Returns, Payments
• Configure Azure Key Vault integration via Managed Identity
• Write unit tests for data access layer

Week 8 – Client Readiness Project: Milestone 2 – Service Layer & REST API Development

Business Logic, Tax Calculation Engine & REST APIs. Implement service layer and tax calculation engine. Build and deploy REST API endpoints. Add JWT authentication and Swagger documentation.

• Implement TaxpayerService (CRUD with validation)
• Implement TaxReturnService (filing workflow, status transitions)
• Implement TaxCalculationEngine (bracket lookup, deduction/credit processing)
• Implement PaymentService (process, allocate, void)
• Apply FluentValidation for all input models
• Implement ASP.NET Core Web API controllers: TaxpayerController, TaxReturnController, PaymentController, CalculationController
• Add proper status codes, problem details (RFC 7807), and error middleware
• Implement API versioning (/api/v1/)
• Implement JWT Bearer token authentication
• Add role-based authorization
• Configure Swagger/OpenAPI with JWT security scheme
• Create Postman collection for all endpoints
• Deploy API to Azure App Service (dev slot)

Week 9 – Client Readiness Project: Milestone 3 – Azure Integration, Audit Service & Security

Cloud Services Integration, Compliance & Security Hardening. Integrate Azure services. Implement audit and compliance service. Harden security and conduct full integration testing.

• Integrate Azure Service Bus for payment confirmation notifications
• Integrate Azure Blob Storage for taxpayer document uploads
• Configure Application Insights SDK and structured Serilog logging
• Implement AuditController and AuditService (PostgreSQL integration)
• Wire sp_log_audit_event to trigger from SQL Server transaction completion events
• Implement PII masking for SSN/EIN in API responses
• Add rate limiting middleware to protect high-volume endpoints
• Implement Cross-Origin Resource Sharing (CORS) policy
• Implement compliance report generation endpoint
• End-to-end test: Taxpayer registration → Return submission → Tax calculation → Payment → Audit event
• Verify Azure Service Bus message delivery
• Test role-based access restrictions
• Verify PII masking in responses and test Blob Storage upload and SAS URL retrieval

Week 10 – Client Readiness Project: Milestone 4 – Final Build & Delivery

Quality Assurance, DevOps & Production Readiness. Complete testing, containerization, CI/CD pipeline, and final demo delivery.

• Complete unit test coverage (target: 60%+ with Coverlet reporting)
• Integration tests using WebApplicationFactory and TestContainers (SQL Server + PostgreSQL)
• API testing via Postman Newman automated runner
• Test negative scenarios: duplicate return, invalid taxpayer, failed payment, unauthorized access
• Write Dockerfile for .NET API (multi-stage build)
• Configure Docker Compose for local multi-container development
• Push Docker image to Azure Container Registry (ACR)
• Build Azure DevOps YAML pipeline: Build → Test → Dockerize → Deploy → Approve → Swap
• Complete all technical documentation: architecture diagram, API documentation, database ERD diagrams, deployment and runbook guide
• Deploy final application to Azure (production slot)
• Conduct end-to-end demo: Taxpayer registration, tax return submission, payment processing, audit log verification, Azure Application Insights live monitoring
• Final code review and cleanup
• Retrospective and lessons learned

Week 11 – Python

Python training.

• Understand Python fundamentals, including syntax, comments, variables, operators, and basic input/output
• Explain why Python is used, its core features, and common use cases
• Work with Python data types such as strings, numbers, booleans, lists, tuples, sets, dictionaries, and datetime
• Apply type casting, namespaces, and ranges to manage data effectively
• Implement control flow logic using if else conditions, loops (for, while), and iteration
• Define and use functions, including lambda functions and arrays
• Apply object-oriented programming concepts, including classes, objects, inheritance, abstraction, polymorphism, and encapsulation
• Use iterators and scope to manage data and execution flow
• Leverage Python modules and libraries such as math, logging, JSON, and regex
• Handle runtime issues using error and exception handling with try except blocks
• Perform file handling operations, including reading, writing, creating, and deleting files
• Use collections module features such as counters, named tuples, and ordered dictionaries
• Understand testing fundamentals, including unit testing and PyTest
• Apply data handling and visualization basics using NumPy, pandas, and matplotlib
• Use Python tooling such as pip, pylint, and package installation best practices
• Reinforce learning through reviews and recap sessions

Week 12 – Databricks

Databricks.

• Resolve Databricks-related tickets involving data validation, data issues, and notebook failures
• Develop and maintain Databricks notebooks using Python and Scala
• Perform Databricks cluster administration, including configuration, scaling, updates, and optimization
• Collaborate with data teams to ensure reliable data pipelines and processing