Description

By the end of this week, learners will build a solid foundation in C# programming and object-oriented software development. The focus is on C# syntax, program flow, functions, and the four fundamental principles of Object-Oriented Programming (OOP): encapsulation, inheritance, polymorphism, and abstraction. Learners will apply these concepts by designing and implementing a real-world domain model using clean, reusable, and maintainable code.

Topics Covered

C# Programming Fundamentals

  1. Understand the syntax and structure of C# applications.
  2. Work with variables, data types, operators, and expressions.
  3. Implement conditional statements using if, else, and switch.
  4. Use loops such as for, while, do-while, and foreach.
  5. Create reusable methods with parameters and return values.
  6. Write clean, readable, and maintainable C# code following industry standards.

Classes, Objects & Encapsulation

  1. Understand the principles of Object-Oriented Programming.
  2. Create classes and instantiate objects.
  3. Define constructors for object initialization.
  4. Apply encapsulation using properties and access modifiers.
  5. Protect object data through controlled access.
  6. Organize application logic using reusable object-oriented components.

Inheritance & Polymorphism

  1. Create inheritance hierarchies using base and derived classes.
  2. Reuse common functionality through inheritance.
  3. Override inherited methods to customize behavior.
  4. Understand runtime polymorphism using virtual and overridden methods.
  5. Differentiate between method overloading and method overriding.
  6. Build flexible and extensible applications using object-oriented design.

Object-Oriented Design Principles

  1. Understand abstraction and its role in simplifying complex systems.
  2. Compare abstract classes and interfaces.
  3. Model real-world business entities using object-oriented concepts.
  4. Organize code using modular and reusable classes.
  5. Follow object-oriented design best practices for maintainability.
  6. Develop scalable applications using clean architecture principles.

Hands-on Practice

  1. Build an Inventory Tracker Domain Model using Object-Oriented Programming.
  2. Create classes for products, categories, suppliers, and inventory records.
  3. Implement constructors, properties, and methods.
  4. Apply encapsulation, inheritance, and polymorphism where appropriate.
  5. Organize the project using clean coding standards and object-oriented design principles.
  6. Test application functionality using sample inventory operations.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Write C# programs using variables, control flow, and reusable methods.
  2. Design applications using classes, objects, and constructors.
  3. Apply encapsulation to improve data security and maintainability.
  4. Build inheritance hierarchies and implement polymorphic behavior.
  5. Differentiate between abstract classes and interfaces for software design.
  6. Model real-world business scenarios using object-oriented programming principles.
  7. Write modular, reusable, and maintainable C# applications following industry best practices.
  8. Develop a functional object-oriented domain model that serves as the foundation for larger software applications.


Description

By the end of this week, learners will understand how to organize and manage data efficiently using C# collections while building responsive web interfaces with HTML5 and CSS3. The focus is on using Lists and Dictionaries to store and manipulate data, creating semantic web pages, and designing responsive layouts with Flexbox. Learners will combine backend data structures with frontend development by rendering collection data into a responsive web page.

Topics Covered

C# Collections & Data Structures

  1. Understand the purpose of data structures in software development.
  2. Work with List<T> for storing and managing collections of objects.
  3. Use Dictionary<TKey, TValue> for key-value data storage and retrieval.
  4. Add, update, remove, and search collection elements efficiently.
  5. Iterate through collections using loops and LINQ basics.
  6. Choose the appropriate collection based on application requirements.

HTML5 Fundamentals

  1. Understand the structure of modern HTML5 documents.
  2. Use semantic HTML elements for accessible web pages.
  3. Create headings, paragraphs, lists, tables, links, and images.
  4. Build forms using common HTML input elements.
  5. Organize page content with meaningful semantic tags.
  6. Follow HTML best practices for maintainable web development.

CSS3 & Flexbox Essentials

  1. Apply CSS selectors, properties, and reusable styles.
  2. Understand the CSS Box Model and element positioning.
  3. Style typography, colors, spacing, and layouts.
  4. Build responsive layouts using Flexbox.
  5. Align and distribute page elements efficiently.
  6. Create mobile-friendly interfaces using responsive design principles.

Rendering Dynamic Data

  1. Understand how application data can be displayed in web pages.
  2. Bind collection data to HTML elements.
  3. Display lists of objects using loops in Razor Views or JavaScript.
  4. Separate presentation from business logic.
  5. Organize reusable UI components for maintainability.
  6. Follow clean frontend development practices for scalable applications.

Hands-on Practice

  1. Create a responsive web page using HTML5 and CSS3.
  2. Design the layout using Flexbox for different screen sizes.
  3. Create a sample List or Dictionary containing product or inventory data.
  4. Render the collection dynamically in the webpage.
  5. Display data as responsive cards or a product list.
  6. Apply clean UI design and responsive layout best practices.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Use List<T> and Dictionary<TKey, TValue> to manage application data.
  2. Perform common collection operations such as adding, updating, searching, and removing data.
  3. Build semantic web pages using HTML5.
  4. Style responsive user interfaces using CSS3 and Flexbox.
  5. Display dynamic collection data in a structured web interface.
  6. Apply responsive design principles for desktop and mobile devices.
  7. Organize frontend code using clean and maintainable development practices.
  8. Build a responsive webpage that renders data from C# collections, demonstrating the integration of backend data structures with modern frontend development.


Description

By the end of this week, learners will understand the fundamentals of JavaScript and build interactive user interfaces using Bootstrap 5. The focus is on manipulating the Document Object Model (DOM), handling user events, validating form inputs, and creating responsive interfaces with Bootstrap components. Learners will apply these concepts by developing a static interactive web application featuring forms and client-side validation without a backend.

Topics Covered

JavaScript Fundamentals

  1. Understand JavaScript syntax, variables, and data types.
  2. Work with operators, conditional statements, and loops.
  3. Create reusable functions using function declarations and arrow functions.
  4. Understand arrays and objects for data management.
  5. Use modern JavaScript (ES6+) features such as template literals and let/const.
  6. Write clean, modular, and maintainable JavaScript code.

DOM Manipulation & Events

  1. Understand the Document Object Model (DOM).
  2. Select and modify HTML elements using JavaScript.
  3. Handle user interactions through event listeners.
  4. Dynamically update page content and styles.
  5. Read and process user input from forms.
  6. Build responsive user experiences using DOM manipulation.

Bootstrap 5 Essentials

  1. Understand the Bootstrap 5 grid system and responsive layout.
  2. Use Bootstrap components such as Navbar, Cards, Buttons, Forms, and Alerts.
  3. Build responsive layouts using containers, rows, and columns.
  4. Customize Bootstrap utility classes for spacing, colors, and typography.
  5. Create mobile-friendly user interfaces with minimal custom CSS.
  6. Follow modern UI design principles using Bootstrap components.

Client-Side Form Validation

  1. Validate user input using JavaScript.
  2. Display validation messages dynamically.
  3. Prevent invalid form submissions.
  4. Apply regular expressions for common input validation.
  5. Improve user experience with real-time validation feedback.
  6. Follow frontend validation best practices for usability and security.

Mini Project

  1. Build a Static Interactive Web Application using HTML5, CSS3, JavaScript, and Bootstrap 5.
  2. Create responsive forms with Bootstrap styling.
  3. Implement client-side form validation using JavaScript.
  4. Use DOM manipulation to display validation messages and interactive feedback.
  5. Design a clean, responsive user interface without backend integration.
  6. Organize the project following clean code and frontend development best practices.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Write JavaScript programs using variables, functions, arrays, and objects.
  2. Manipulate HTML elements dynamically through the DOM.
  3. Handle user interactions using JavaScript event listeners.
  4. Build responsive interfaces using Bootstrap 5 components and utility classes.
  5. Implement client-side form validation to improve user experience.
  6. Develop interactive web pages without requiring backend services.
  7. Follow clean coding and responsive frontend development best practices.
  8. Deliver a polished, interactive user interface with responsive forms and client-side validation that demonstrates modern frontend development skills.


Description

By the end of this week, learners will understand the fundamentals of building database-driven web applications using ASP.NET Core MVC and Entity Framework Core. The focus is on the MVC architecture, routing, controllers, views, SQL fundamentals, and implementing CRUD operations for a single entity. Learners will apply these concepts by developing a complete CRUD module connected to a SQL Server database.

Topics Covered

ASP.NET Core MVC Fundamentals

  1. Understand the Model-View-Controller (MVC) architecture.
  2. Learn the role of Models, Views, and Controllers in web applications.
  3. Configure application routing and request handling.
  4. Create controllers to process user requests and return responses.
  5. Build Razor Views for presenting dynamic content.
  6. Organize projects following clean MVC architecture and best practices.

Controllers, Views & Routing

  1. Create controller actions for handling HTTP requests.
  2. Pass data between controllers and views using models.
  3. Understand model binding and request processing.
  4. Implement GET and POST actions for user interactions.
  5. Configure attribute-based and conventional routing.
  6. Build maintainable and reusable application components.

SQL & Entity Framework Core Basics

  1. Understand relational database concepts and SQL fundamentals.
  2. Design a simple database table for application data.
  3. Configure Entity Framework Core with SQL Server.
  4. Create entity models and database context.
  5. Generate database schema using Code-First Migrations.
  6. Perform basic database operations using LINQ and EF Core.

Single-Entity CRUD Operations

  1. Implement Create, Read, Update, and Delete functionality.
  2. Retrieve and display records from the database.
  3. Validate user input before saving data.
  4. Edit and delete existing records safely.
  5. Handle common database exceptions and validation errors.
  6. Follow clean coding and data access best practices.

Hands-on Practice

  1. Build a Single-Entity CRUD Application (e.g., Tasks or Products).
  2. Create Razor Views for adding, viewing, editing, and deleting records.
  3. Connect the application to a SQL Server database using Entity Framework Core.
  4. Implement complete CRUD operations using MVC architecture.
  5. Validate user input and handle common application errors.
  6. Organize the project using clean architecture, proper folder structure, and version control best practices.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Explain the ASP.NET Core MVC architecture and request lifecycle.
  2. Build web applications using Controllers, Views, Models, and Routing.
  3. Connect ASP.NET Core applications to SQL Server using Entity Framework Core.
  4. Create and manage database entities using Code-First development.
  5. Implement complete CRUD functionality for a single database entity.
  6. Validate user input and manage application data securely.
  7. Apply clean architecture and industry-standard coding practices in MVC applications.
  8. Deliver a fully functional database-driven CRUD application that demonstrates foundational full-stack backend development skills.


Description

By the end of this week, learners will understand how to build, secure, and deploy modern RESTful Web APIs using ASP.NET Core. The focus is on creating API endpoints, implementing basic authentication, and deploying applications to Microsoft Azure App Service. Learners will complete the week by publishing a live API to the cloud and consuming it from a simple client application.

Topics Covered

Building RESTful Web APIs

  1. Understand the principles of REST architecture and HTTP methods.
  2. Create ASP.NET Core Web API projects.
  3. Build API controllers and define REST endpoints.
  4. Handle GET, POST, PUT, and DELETE requests.
  5. Return structured JSON responses using standard HTTP status codes.
  6. Follow REST API design and naming conventions.

API Authentication Basics

  1. Understand the importance of securing Web APIs.
  2. Implement basic API authentication using an API Key or JWT Authentication.
  3. Protect API endpoints from unauthorized access.
  4. Validate authentication credentials for incoming requests.
  5. Test secured endpoints using Postman or similar API tools.
  6. Apply security best practices for API development.

Cloud Deployment with Azure

  1. Understand the basics of cloud hosting and deployment.
  2. Publish ASP.NET Core Web APIs to Microsoft Azure App Service.
  3. Configure application settings and environment variables.
  4. Connect deployed applications to required services and databases.
  5. Verify successful deployment and application availability.
  6. Troubleshoot common deployment and configuration issues.

API Testing & Client Integration

  1. Test API endpoints using Postman.
  2. Consume REST APIs from a simple frontend client.
  3. Handle JSON requests and responses.
  4. Implement basic error handling for API communication.
  5. Verify authentication and API accessibility after deployment.
  6. Follow best practices for client-server communication.

Hands-on Practice

  1. Build a RESTful Web API using ASP.NET Core.
  2. Secure the API using an API Key or JWT Authentication.
  3. Deploy the API to Microsoft Azure App Service.
  4. Create a simple client application to consume the deployed API.
  5. Test API endpoints using Postman and browser-based clients.
  6. Document the API endpoints and deployment process following professional development standards.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Design and build RESTful Web APIs using ASP.NET Core.
  2. Implement secure API authentication using API Keys or JWT.
  3. Develop API endpoints that follow REST architecture and HTTP standards.
  4. Deploy ASP.NET Core Web APIs to Microsoft Azure App Service.
  5. Connect client applications to live cloud-hosted APIs.
  6. Test and troubleshoot API functionality using industry-standard tools.
  7. Apply security and deployment best practices for modern web applications.
  8. Deliver a live, cloud-hosted REST API that demonstrates professional backend development, authentication, and deployment skills.


Description

By the end of this week, learners will understand how to package and deploy machine learning or Python applications using FastAPI and Docker. The focus is on exposing application functionality through REST APIs, containerizing applications for consistent execution, and preparing projects for deployment across development and production environments. Learners will apply these concepts by serving an application with FastAPI inside a Docker container.

Topics Covered

FastAPI Fundamentals

  1. Understand the role of FastAPI in modern Python application development.
  2. Create a FastAPI project with a clean folder structure.
  3. Define API endpoints using HTTP methods.
  4. Handle request parameters and JSON responses.
  5. Implement basic input validation using Pydantic models.
  6. Build lightweight and high-performance REST APIs following best practices.

Building REST APIs with FastAPI

  1. Create GET and POST endpoints for application functionality.
  2. Process user input and return structured JSON responses.
  3. Handle exceptions and common API errors gracefully.
  4. Test APIs using FastAPI's interactive Swagger documentation.
  5. Organize API routes for scalability and maintainability.
  6. Follow REST API design principles for production-ready services.

Docker Fundamentals

  1. Understand containerization and its advantages over traditional deployment.
  2. Install and configure Docker for local development.
  3. Create a Dockerfile for Python applications.
  4. Build and run Docker images and containers.
  5. Manage application dependencies inside containers.
  6. Follow Docker best practices for lightweight and reproducible deployments.

Containerized Application Deployment

  1. Connect FastAPI applications with Docker containers.
  2. Configure application ports and runtime settings.
  3. Test APIs running inside Docker containers.
  4. Understand image versioning and container lifecycle management.
  5. Prepare applications for deployment to cloud platforms.
  6. Follow deployment best practices for portable applications.

Hands-on Practice

  1. Wrap a Python application using FastAPI.
  2. Create REST API endpoints to expose application functionality.
  3. Build a Docker image using a custom Dockerfile.
  4. Run the application inside a Docker container.
  5. Test the containerized API using Swagger UI or Postman.
  6. Verify the application runs consistently in a containerized environment.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Build REST APIs using FastAPI.
  2. Create API endpoints with request validation and JSON responses.
  3. Containerize Python applications using Docker.
  4. Build, run, and manage Docker images and containers.
  5. Test and verify containerized applications locally.
  6. Prepare applications for cloud deployment using containerization.
  7. Apply industry-standard practices for API development and Docker-based deployment.
  8. Deliver a FastAPI application running successfully inside a Docker container, demonstrating modern backend development and deployment skills.


Description

By the end of this week, learners will consolidate everything they have learned throughout the program by designing, developing, and deploying a complete full-stack application. The focus is on integrating the frontend, backend, database, and cloud deployment into a single production-ready solution while following industry-standard software engineering practices. Learners will complete a live capstone project and publish the source code to GitHub as a professional portfolio project.

Topics Covered

Full-Stack Application Development

  1. Define the scope and requirements of a complete web application.
  2. Integrate frontend, backend, and database into a unified solution.
  3. Organize the project using a clean and maintainable architecture.
  4. Implement complete CRUD functionality for application data.
  5. Apply responsive UI design and intuitive user navigation.
  6. Follow software engineering best practices throughout development.

Backend & Database Integration

  1. Connect the application to a relational database.
  2. Implement data access using Entity Framework Core or the appropriate ORM.
  3. Perform Create, Read, Update, and Delete (CRUD) operations.
  4. Validate user input and handle application errors gracefully.
  5. Maintain data consistency and application reliability.
  6. Organize business logic using clean coding principles.

Deployment & Version Control

  1. Prepare the application for production deployment.
  2. Deploy the complete application to a cloud platform such as Microsoft Azure App Service.
  3. Configure environment settings and database connections.
  4. Verify successful deployment and application functionality.
  5. Publish the complete project to GitHub with proper version control.
  6. Maintain a professional repository structure and commit history.

Project Documentation

  1. Create a clear and professional GitHub README.
  2. Document project features, technologies, and architecture.
  3. Provide installation, configuration, and deployment instructions.
  4. Include screenshots, application workflow, and project overview.
  5. Organize documentation for technical interviews and portfolio presentation.
  6. Follow documentation standards used by professional software teams.

Capstone Project

  1. Build a Live Mini Full-Stack Web Application.
  2. Develop a responsive frontend integrated with a backend service.
  3. Connect the application to a relational database with complete CRUD functionality.
  4. Deploy the application to a cloud platform with a publicly accessible URL.
  5. Publish the complete source code and documentation to GitHub.
  6. Demonstrate end-to-end software development following industry-standard architecture, clean code, and deployment practices.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Design and develop a complete full-stack web application.
  2. Integrate frontend, backend, database, and deployment into a single solution.
  3. Implement database-driven CRUD functionality using industry-standard practices.
  4. Deploy web applications to a cloud hosting platform.
  5. Manage source code professionally using Git and GitHub.
  6. Create comprehensive project documentation suitable for portfolios and technical interviews.
  7. Apply clean architecture, maintainable coding standards, and production-ready development workflows.
  8. Deliver a live, deployed mini full-stack application with a database, cloud hosting, and a well-documented GitHub repository that demonstrates professional full-stack development skills.


Please enroll in the Program to see calendar.

Please enroll in the Program to see recordings.