DLDevLadder📒 My Notebook

Roadmap & full syllabus

Track → Course → Module → Lesson, in the order to study them. Each lesson is graded Basic, Intermediate or Advanced and tagged with how often it comes up in interviews.

Interview priority:★ Must know High priority — asked in almost every interview, learn firstMedium asked regularlyLow good to know

0. Fundamentals

Start here: how computers and memory work, data structures and algorithms, how the web works (networking and hosting), and system design — high-level and low-level design.

1. How Computers Work — CPU, Memory, OS, Processes and Threads11 lessons · 16 Q&A

What happens inside a computer when your program runs — bits and bytes, the CPU and instruction cycle, the memory hierarchy (registers, cache, RAM, disk), stack vs heap, virtual memory and paging, the operating system, processes and threads, scheduling, concurrency problems, compilation vs interpretation, and how all of it shows up in .NET and SQL Server. Open course →

1.1 Data and the CPU

1.2 Memory

1.3 Operating System, Processes and Threads

1.4 From Code to Execution

2. Data Structures & Algorithms — How They Work Inside10 lessons · 16 Q&A

Big-O and how to measure algorithms, arrays and dynamic arrays, linked lists, stacks and queues, hash tables (how hashing and collisions work), trees, binary search trees, heaps, tries, graphs, searching, sorting algorithms step by step, recursion, two pointers and sliding window, greedy, dynamic programming and backtracking — with C# code and where .NET and SQL Server use each one. Open course →

2.1 Measuring Algorithms

2.2 Linear Data Structures

2.3 Trees, Heaps and Graphs

2.4 Searching and Sorting

2.5 Problem-Solving Patterns

3. Coding Round Practice (DSA in C#)14 lessons · 23 Q&A

Big-O, arrays, strings, hashing, two pointers, sliding window, stacks, linked lists, trees, sorting, searching, recursion and the most-asked C# coding programs with solutions. Open course →

3.1 Foundations

3.2 Arrays and Hashing

3.3 Stacks, Queues and Linked Lists

3.4 Sorting, Searching and Recursion

3.5 Trees and Graphs

4. Networking & Hosting — How a Website Works, End to End12 lessons · 18 Q&A

The complete life cycle of a web request — OSI and TCP/IP models, IP addresses, subnets and ports, DNS, TCP vs UDP, TLS/HTTPS, HTTP/1.1, HTTP/2 and HTTP/3, browser rendering, cookies and sessions, proxies, load balancers and CDNs, web servers (IIS, Kestrel, Nginx), hosting options from shared hosting to cloud and containers, domains and SSL certificates, deploying an ASP.NET site to IIS and Azure, and troubleshooting network problems. Open course →

4.1 Network Foundations

4.2 HTTP and the Browser

4.3 Infrastructure Between the User and the App

4.4 Putting a Site Live

5. System Design — High-Level Design (HLD) from Basics to Case Studies14 lessons · 17 Q&A

How to design large systems — requirements and estimation, scalability and availability, latency vs throughput, CAP and consistency models, load balancing, caching strategies, database choice, replication, partitioning and sharding, consistent hashing, queues and event streaming, rate limiting, search, storage and CDNs, observability, and full case studies (URL shortener, news feed, chat, notification service, e-commerce checkout, file storage, ride booking) with the HLD interview framework. Open course →

5.1 Fundamentals

5.2 Building Blocks

5.3 Case Studies

5.4 Operating Large Systems

6. Low-Level Design (LLD) — Object Design, UML and Classic Problems in C#8 lessons · 16 Q&A

How to turn requirements into classes — the LLD interview approach, identifying entities and responsibilities, UML class and sequence diagrams, applying SOLID and design patterns, designing APIs and database tables, concurrency in object design, and complete C# designs for parking lot, library management, elevator, vending machine, LRU cache, rate limiter, splitwise/expense sharing and movie ticket booking. Open course →

6.1 Foundations of Object Design

6.2 Classic LLD Problems

1. .NET

The whole .NET ecosystem in learning order: C#, VB.NET and .NET internals (CLR, memory, GC); OOP, SOLID and patterns; ADO.NET, LINQ, Entity Framework and Dapper; Web Forms and MVC 5; ASP.NET Core MVC and Web API; exception handling, logging and custom controls; then architecture, clean code and microservices.

7. C# Language — Basics to Advanced38 lessons · 48 Q&A

Types, control flow, collections, generics, delegates, async/await, memory and modern C# features up to C# 14. Open course →

7.1 Getting Started

7.2 Arrays and Collections

7.3 Types in Depth

7.4 Methods and Functional C#

7.5 Errors, Resources and Memory

7.6 Files and Streams

7.7 Asynchronous and Parallel Programming

7.8 Modern C# and Reflection

8. VB.NET — Visual Basic .NET from Basics to Advanced (with C# Comparison)12 lessons · 16 Q&A

VB.NET syntax and program structure, data types and Option Strict/Explicit/Infer, operators and control flow, procedures (Sub vs Function, ByVal/ByRef, Optional, ParamArray), arrays and collections, classes and OOP keywords (Inherits, Implements, Overridable, MustInherit, Shadows), properties, modules and Shared members, events and delegates (WithEvents/Handles/AddHandler), error handling (Try/Catch and legacy On Error), LINQ and XML literals, async, WinForms and Web Forms code-behind, and converting VB.NET to C#. Open course →

8.1 VB.NET Basics

8.2 Procedures and Collections

8.3 Object-Oriented VB.NET

8.4 Errors, LINQ and Modern Features

9. .NET Internals — CLR, CTS, CLS, IL, JIT, Memory Management & Garbage Collection11 lessons · 19 Q&A

Every .NET version from .NET Framework 1.0 to .NET 10, the .NET architecture (CLR, BCL, CTS, CLS), compilation from C#/VB.NET to IL to machine code (Roslyn, JIT, tiered compilation, ReadyToRun, Native AOT), assemblies, manifests, metadata, GAC and strong names, AppDomains vs AssemblyLoadContext, type loading and method tables, stack and heap, value vs reference type layout, the garbage collector in depth (generations, LOH, POH, workstation/server, background GC), finalization, IDisposable, memory leaks and diagnostics, threading and the thread pool, async internals and exceptions inside the CLR. Open course →

9.1 Platform and Compilation

9.2 Memory Management

9.3 Execution Internals

10. OOP Concepts in C#15 lessons · 22 Q&A

Classes and objects, the four pillars (encapsulation, abstraction, inheritance, polymorphism), interfaces vs abstract classes, composition and object relationships. Open course →

10.1 Classes and Objects

10.2 The Four Pillars

10.3 Interfaces and Abstract Classes

10.4 Relationships and Design

11. SOLID Principles with Examples8 lessons · 15 Q&A

The five SOLID principles with bad-vs-good C# code, plus DRY, KISS, YAGNI, dependency injection and how SOLID shows up in ASP.NET Core. Open course →

11.1 S and O

11.2 L, I and D

11.3 Related Principles

12. Design Patterns (GoF + Enterprise) in C#18 lessons · 21 Q&A

Creational, structural and behavioural Gang-of-Four patterns with C# code, plus Repository, Unit of Work, CQRS, Mediator, Options and microservice patterns. Open course →

12.1 Creational Patterns

12.2 Structural Patterns

12.3 Behavioural Patterns

12.4 Enterprise and Cloud Patterns

13. ADO.NET — Connected & Disconnected Data Access9 lessons · 18 Q&A

Connected vs disconnected architecture, SqlConnection, SqlCommand, DataReader, DataSet/DataAdapter, parameters, stored procedures, transactions, connection pooling, bulk copy, async and Dapper micro-ORM. Open course →

13.1 Connected Architecture

13.2 Disconnected Architecture

13.3 Transactions, Pooling and Performance

14. LINQ — Language Integrated Query12 lessons · 21 Q&A

Query vs method syntax, deferred execution, filtering, projection, ordering, grouping, joins, aggregation, set and element operators, IEnumerable vs IQueryable, expression trees, performance and the classic LINQ interview programs. Open course →

14.1 LINQ Basics

14.2 Grouping, Joins and Aggregation

14.3 LINQ Internals and EF Core

15. Entity Framework (EF6 & EF Core)15 lessons · 23 Q&A

DbContext, code-first and database-first, conventions and Fluent API, relationships, migrations, querying and loading strategies, change tracking, concurrency, transactions, performance tuning and EF6 vs EF Core. Open course →

15.1 Getting Started

15.2 Relationships and Modelling

15.3 Querying

15.4 Saving Data

15.5 Performance and Advanced

16. Dapper — The Micro-ORM from Basics to Advanced8 lessons · 15 Q&A

What Dapper is and how it works inside, Query/QueryFirst/QuerySingle/Execute, parameters and SQL injection safety, stored procedures and output parameters, multi-mapping joins, QueryMultiple, transactions, bulk inserts and table-valued parameters, async and buffering, custom type handlers, DynamicParameters, repository and unit-of-work patterns, Dapper vs EF Core vs ADO.NET, performance and testing. Open course →

16.1 Dapper Basics

16.2 Advanced Queries

16.3 Dapper in Real Applications

17. ASP.NET Web Forms — Page Life Cycle, ViewState, Controls and State Management10 lessons · 17 Q&A

How ASP.NET Web Forms works inside IIS (application and page life cycle), folder structure (App_Code, App_Data, App_Start, Bin, App_Themes), Web Site vs Web Application projects, .aspx/.aspx.cs code-behind, server controls and events, PostBack and ViewState, state management (ViewState, ControlState, Session, Application, Cache, cookies, query strings, hidden fields), validation controls, master pages, user controls and custom controls, data binding with GridView/Repeater and SqlDataSource vs ObjectDataSource, Global.asax and web.config, Forms authentication, custom errors, performance and migrating Web Forms to ASP.NET Core. Open course →

17.1 Getting Started

17.2 PostBack and State

17.3 Building Pages

17.4 Application Configuration, Security and Errors

18. ASP.NET MVC 5 (.NET Framework) — Folder Structure, Request Life Cycle and Features10 lessons · 16 Q&A

The MVC pattern, the classic MVC 5 project and folder structure (App_Start, Controllers, Models, Views, Areas, Global.asax, Views/web.config), the full request life cycle from UrlRoutingModule to MvcHandler, controller factory, action invoker, filters, model binding, action results and the Razor view engine, routing (convention and attribute), controllers and action results, Razor views, HTML helpers, partial views and child actions, model binding and validation, filters (authorization, action, result, exception), ViewBag/ViewData/TempData, bundling, dependency injection with Unity/Autofac, OWIN and ASP.NET Identity, Web API 2 side by side, error handling and migrating MVC 5 to ASP.NET Core. Open course →

18.1 Project Structure and Routing

18.2 Controllers and Views

18.3 Model Binding, Validation and Filters

18.4 Application Concerns

19. Modern .NET — Hosting, Configuration, DI & Deployment9 lessons · 17 Q&A

.NET Framework vs .NET Core vs modern .NET, CLR, JIT/AOT, GC, assemblies, NuGet, the generic host, configuration, DI, logging, support lifecycle and deployment models. Open course →

19.1 Platform Fundamentals

19.2 Hosting, Configuration, DI and Logging

19.3 Deployment and Performance

20. ASP.NET Core MVC (and Razor Pages)15 lessons · 23 Q&A

The MVC pattern, request lifecycle, routing, controllers, model binding and validation, Razor views, layouts, tag helpers, view components, filters, state management, Identity and security. Open course →

20.1 MVC Basics

20.2 Models, Binding and Validation

20.3 Razor Views

20.4 Filters, State and Security

21. ASP.NET Core Web API & REST15 lessons · 25 Q&A

REST principles, controllers vs Minimal APIs, middleware, status codes, validation and ProblemDetails, JWT authentication, versioning, OpenAPI, caching, rate limiting, CORS, gRPC/SignalR and microservices basics. Open course →

21.1 REST Fundamentals

21.2 Building Robust APIs

21.3 Security

21.4 Performance, Versioning and Docs

22. Exception Handling & Custom Error Handling in .NET — Every Way, Every App Type9 lessons · 16 Q&A

Exceptions from first principles to production — try/catch/finally, filters, rethrowing, custom exception hierarchies, exceptions vs Result pattern, async and parallel exceptions, global handlers (AppDomain, TaskScheduler, Application_Error), every way to handle errors in Web Forms, MVC 5, Web API 2, ASP.NET Core MVC and Web API (middleware, exception filters, IExceptionHandler, ProblemDetails, UseStatusCodePages), Blazor error boundaries, background services, SQL and HTTP error handling, retries with Polly, custom error pages, error codes and correlation ids. Open course →

22.1 Exceptions in C#

22.2 Error Handling by Application Type

22.3 Infrastructure Errors and Resilience

23. Logging & Custom Logging in .NET — ILogger, Serilog, NLog, log4net and Your Own Logger8 lessons · 16 Q&A

Why and what to log, log levels, structured vs plain-text logging, Microsoft.Extensions.Logging (ILogger, providers, categories, filtering, scopes, high-performance LoggerMessage source generators), Serilog (sinks, enrichers, request logging), NLog and log4net (including .NET Framework apps), Trace and Windows Event Log, writing a custom logger provider (file and database), audit logging, correlation ids and distributed tracing with OpenTelemetry and Application Insights, log storage and querying (Seq, ELK, Azure Monitor/KQL), security (PII, secrets) and performance. Open course →

23.1 Logging Fundamentals

23.2 Logging Libraries

23.3 Custom and Production Logging

24. Custom Controls & Reusable UI Components in .NET — Web Forms to Blazor9 lessons · 16 Q&A

Building reusable UI in every .NET UI technology — Web Forms user controls and custom server controls (Control, WebControl, CompositeControl, rendering, ViewState-backed properties, events, postback data, templated controls, design-time attributes), MVC 5 custom HTML helpers, display/editor templates and child actions, ASP.NET Core partial views, custom tag helpers, view components and Razor Class Libraries, Blazor components (parameters, EventCallback, RenderFragment, cascading values, generic components) and WinForms/WPF custom controls. Open course →

24.1 Web Forms Controls

24.2 MVC and ASP.NET Core Components

24.3 Blazor and Desktop Components

25. .NET Project Architectures & Folder Structures — Layered, Clean, Onion, Vertical Slice8 lessons · 15 Q&A

How real .NET solutions are organised — solution and project structure, 3-tier and N-layer architecture, Onion, Hexagonal (ports and adapters) and Clean Architecture, Vertical Slice architecture, modular monolith, DDD building blocks, CQRS, the folder structure of each style with naming conventions, shared build settings (Directory.Build.props, central package management), test projects, where cross-cutting concerns live, and how to choose an architecture. Open course →

25.1 Solution Basics

25.2 Architecture Styles

26. Clean Code, Testing & Best Practices12 lessons · 18 Q&A

Naming, functions, error handling, code smells and refactoring, unit testing with xUnit and Moq, TDD, code review, Git workflow, security and logging best practices for .NET teams. Open course →

26.1 Readable Code

26.2 Code Smells and Refactoring

26.3 Testing

26.4 Team Practices

27. Microservices & System Design with .NET9 lessons · 20 Q&A

Monolith vs modular monolith vs microservices, service boundaries (DDD), REST/gRPC and messaging, API gateways, data per service, sagas and the outbox pattern, resilience, observability, caching, scaling and the system-design interview round. Open course →

27.1 Architecture Styles

27.2 Communication

27.3 Data and Consistency

27.4 Running Microservices in Production

2. Database, ETL & BI

SQL Server and T-SQL from SELECT to tuning, SQL Server internals (storage, indexes, optimizer, transactions, locking), then ETL design, SSIS packages and SSRS reports.

28. SQL Server & T-SQL19 lessons · 30 Q&A

Database design and normalisation, data types, constraints, joins, subqueries, CTEs, window functions, stored procedures, functions, views, triggers, indexes, execution plans, transactions, isolation levels, locking, error handling and performance tuning. Open course →

28.1 Database Design

28.2 Querying

28.3 Programmability

28.4 Indexes and Performance

28.5 Connecting Applications to SQL Server

29. SQL Server Internals — How the Database Engine Really Works11 lessons · 18 Q&A

The SQL Server architecture (protocol layer, relational engine, storage engine, SQLOS), the life of a query from TDS packet to result, pages, extents and allocation maps, heaps vs clustered tables and B+ tree index structure, row layout, statistics and cardinality estimation, the query optimizer and plan cache, parameter sniffing, execution plan operators and join algorithms, buffer pool and memory grants, the transaction log, write-ahead logging, checkpoints and recovery, locking, latches, isolation levels, row versioning and tempdb, deadlocks, waits and DMVs, columnstore and In-Memory OLTP. Open course →

29.1 Architecture and Storage

29.2 Query Processing

29.3 Transactions, Logging and Concurrency

30. ETL & Data Warehousing Concepts12 lessons · 19 Q&A

ETL vs ELT, staging, full vs incremental loads, change data capture, slowly changing dimensions, star and snowflake schemas, fact and dimension tables, data quality, error handling, orchestration and modern cloud data platforms. Open course →

30.1 Fundamentals

30.2 Dimensional Modelling

30.3 Building Reliable Pipelines

31. SSIS — SQL Server Integration Services13 lessons · 21 Q&A

Packages, control flow and data flow, connection managers, variables and parameters, containers, transformations, lookups, SCD, error handling, logging, checkpoints, deployment models, SSISDB catalog, scheduling and performance tuning. Open course →

31.1 Package Basics

31.2 Data Flow

31.3 Error Handling, Logging and Restartability

31.4 Deployment, Scheduling and Performance

32. SSRS — SQL Server Reporting Services10 lessons · 18 Q&A

Report server architecture, data sources and datasets, tablix (table/matrix/list), parameters and cascading parameters, expressions, grouping, drill-down and drill-through, subreports, charts, subscriptions, security, performance and Power BI Report Server. Open course →

32.1 Building Reports

32.2 Parameters and Interactivity

32.3 Server Features and Administration

3. Cloud & DevOps

Git first, then Docker and Kubernetes, Azure DevOps CI/CD pipelines and the Azure services a .NET developer uses.

33. IIS — Internet Information Services and Hosting .NET Applications9 lessons · 16 Q&A

How IIS works inside (HTTP.sys, WAS, W3SVC, worker processes), sites, bindings, applications and virtual directories, application pools (identity, pipeline mode, recycling, idle timeout), hosting ASP.NET Web Forms/MVC 5 and ASP.NET Core (in-process vs out-of-process, ASP.NET Core Module, Hosting Bundle), web.config, HTTPS certificates and SNI, authentication modes, URL Rewrite and ARR reverse proxy, compression and caching, logging and Failed Request Tracing, troubleshooting 500.x/502.5/503 errors, web farms and deployment with Web Deploy and PowerShell, security hardening, and IIS interview questions. Open course →

33.1 IIS Architecture

33.2 Hosting .NET Applications

33.3 Operations

34. Git & GitHub — Version Control from Basics to Advanced10 lessons · 19 Q&A

How Git stores history, the daily commands, branching and merging, rebase, resolving conflicts, remotes and pull requests, branching strategies (GitFlow, trunk-based), undoing mistakes, tags and releases, hooks and the Git questions asked in every developer interview. Open course →

34.1 Git Basics

34.2 Working in a Team

34.3 Undo, Inspect and Advanced Git

35. Docker & Containers8 lessons · 18 Q&A

Containers vs VMs, images and layers, Dockerfile for .NET, multi-stage builds, volumes, networks, Docker Compose, registries, security, debugging and production best practices. Open course →

35.1 Core Concepts

35.2 Docker Compose

35.3 Production Practices

36. Kubernetes (K8s) & AKS15 lessons · 21 Q&A

Cluster architecture, pods, deployments, services, ingress, ConfigMaps and Secrets, probes, resources and autoscaling, storage, StatefulSets, namespaces, RBAC, Helm, rolling updates, troubleshooting and Azure Kubernetes Service. Open course →

36.1 Architecture and Core Objects

36.2 Running Workloads Well

36.3 Deploying and Operating

37. Azure DevOps & CI/CD10 lessons · 18 Q&A

Boards, Repos, Pipelines, Test Plans and Artifacts; YAML pipelines (stages, jobs, steps, templates, variables, environments, approvals), agents, service connections, branching and release strategies, and DevOps practices. Open course →

37.1 Boards and Repos

37.2 Azure Pipelines

38. Microsoft Azure for .NET Developers14 lessons · 20 Q&A

Cloud models, Azure hierarchy and regions, App Service, Functions, Container Apps, AKS, Storage, Azure SQL, Cosmos DB, Service Bus, Event Grid, Event Hubs, Key Vault, Entra ID, managed identities, API Management, networking, monitoring, cost, security and architecture. Open course →

38.1 Fundamentals

38.2 Compute

38.3 Data and Storage

38.4 Integration and Messaging

38.5 Security, Networking and Operations

39. Azure Databases — Azure SQL, Managed Instance, Cosmos DB, PostgreSQL and Migration9 lessons · 15 Q&A

Choosing a database on Azure; Azure SQL Database (single database, elastic pools, DTU vs vCore, General Purpose / Business Critical / Hyperscale, serverless), Azure SQL Managed Instance and SQL Server on Azure VMs; security (firewall, private endpoints, Microsoft Entra authentication, managed identity, TDE, Always Encrypted, auditing), high availability, geo-replication, failover groups and backups/point-in-time restore; performance (Query Store, automatic tuning, Intelligent Insights); Cosmos DB (APIs, partition keys, RU/s, consistency levels), Azure Database for PostgreSQL/MySQL, Azure Cache for Redis; migrating on-premises SQL Server (DMA, Azure Database Migration Service) and cost optimisation. Open course →

39.1 Azure SQL

39.2 Other Azure Data Services

39.3 Migration and Cost

40. Amazon Web Services (AWS) for .NET and Full Stack Developers9 lessons · 16 Q&A

AWS fundamentals — regions and AZs, IAM, the shared responsibility model; compute (EC2, Elastic Beanstalk, ECS/Fargate, EKS, Lambda, App Runner), storage (S3, EBS, EFS), databases (RDS for SQL Server, Aurora, DynamoDB, ElastiCache), networking (VPC, subnets, security groups, Route 53, CloudFront, ALB/NLB, API Gateway), messaging (SQS, SNS, EventBridge, Kinesis), security (KMS, Secrets Manager, Cognito, WAF), monitoring (CloudWatch, X-Ray, CloudTrail), infrastructure as code (CloudFormation, CDK, Terraform), CI/CD (CodePipeline, GitHub Actions), deploying .NET apps, cost management, the Azure ↔ AWS service map and AWS interview questions. Open course →

40.1 Foundations

40.2 Compute

40.3 Storage and Databases

40.4 Networking, Integration and Security

40.5 Delivery and Architecture

41. Google Cloud Platform (GCP) for .NET and Full Stack Developers9 lessons · 15 Q&A

GCP fundamentals — resource hierarchy (organisation, folders, projects), regions and zones, Cloud IAM and service accounts; compute (Compute Engine, Cloud Run, GKE, App Engine, Cloud Functions), storage (Cloud Storage), databases (Cloud SQL for SQL Server/PostgreSQL/MySQL, AlloyDB, Spanner, Firestore, Bigtable, Memorystore), analytics (BigQuery, Pub/Sub, Dataflow), networking (VPC, Cloud Load Balancing, Cloud CDN, Cloud DNS), security (Secret Manager, Cloud KMS, Identity Platform), operations (Cloud Logging, Monitoring, Trace), CI/CD (Cloud Build, Artifact Registry, Cloud Deploy), deploying ASP.NET Core to Cloud Run, Vertex AI, cost management and GCP interview questions. Open course →

41.1 Foundations

41.2 Compute

41.3 Storage and Databases

41.4 Integration, Networking and Security

41.5 Delivery and Cost

4. Frontend

HTML and CSS, JavaScript and TypeScript first, then jQuery, AngularJS (legacy), Angular, React and Vue.

42. HTML5 & CSS3 — Semantic Markup to Responsive Layouts11 lessons · 18 Q&A

Document structure, semantic HTML, forms and accessibility, the CSS cascade and specificity, the box model, Flexbox and Grid, responsive design with media and container queries, CSS variables, Bootstrap/Tailwind and the HTML/CSS interview questions. Open course →

42.1 HTML Foundations

42.2 CSS Fundamentals

42.3 Layout and Responsive Design

42.4 Modern CSS and Frameworks

43. JavaScript (ES5 → ES2025) & TypeScript Basics16 lessons · 24 Q&A

Types, scope, hoisting, closures, this, prototypes, classes, the event loop, promises and async/await, modules, DOM and events, fetch, ES6+ features, error handling, performance, security and TypeScript essentials. Open course →

43.1 Language Basics

43.2 Core Concepts

43.3 Browser and DOM

43.4 Advanced and TypeScript

44. TypeScript — Types, Generics and Real-World Patterns9 lessons · 16 Q&A

Why TypeScript, basic and object types, interfaces vs type aliases, unions and narrowing, functions, classes, generics, utility types, mapped and conditional types, modules, tsconfig and strict mode, typing API calls for Angular/React, and the TypeScript interview questions. Open course →

44.1 TypeScript Basics

44.2 Classes and Generics

44.3 Advanced Types

45. Node.js — Runtime Internals, Express, APIs and SQL Server11 lessons · 17 Q&A

What Node.js is and how it works inside (V8, libuv, the event loop phases, thread pool, non-blocking I/O), modules (CommonJS vs ES modules), npm and package.json, the core modules (fs, path, http, events, streams, buffer), asynchronous patterns (callbacks, promises, async/await), Express.js REST APIs with middleware and error handling, project folder structure, connecting to SQL Server (mssql, Prisma, Sequelize), authentication with JWT, worker threads and clustering, testing, security, performance, deployment and the Node.js interview questions. Open course →

45.1 Node.js Fundamentals

45.2 Building APIs

45.3 Performance and Production

46. jQuery10 lessons · 16 Q&A

Selectors, traversal, DOM manipulation, events and delegation, effects, AJAX, deferreds, plugins, jQuery with ASP.NET MVC validation, performance and migrating from jQuery to modern JavaScript. Open course →

46.1 Basics

46.2 AJAX and Effects

46.3 jQuery in .NET Apps and Modernisation

47. AngularJS (1.x) — Legacy13 lessons · 16 Q&A

Modules, controllers, $scope, two-way data binding, directives, filters, services/factories/providers, dependency injection, digest cycle, routing, $http and promises, custom directives, components, performance and migration to Angular. Open course →

47.1 Fundamentals

47.2 Services and Dependency Injection

47.3 Scope, Digest and Directives

48. Angular (2 → 21)16 lessons · 24 Q&A

Angular CLI, standalone components, templates and new control flow, data binding, directives and pipes, signals, services and DI, routing and guards, forms, HttpClient and interceptors, RxJS, change detection and zoneless, lifecycle hooks, state management, testing and performance. Open course →

48.1 Getting Started

48.2 Services, DI and HTTP

48.3 Signals, Change Detection and State

48.4 Routing and Forms

48.5 Quality and Performance

49. React (with Hooks, React 19 & Next.js basics)17 lessons · 22 Q&A

JSX, components and props, state, events, conditional rendering and lists, hooks in depth, effects and data fetching, forms, context, reducers, refs, performance (memo, useMemo, useCallback, React Compiler), routing, state libraries, React 19 actions and Server Components, testing and Next.js. Open course →

49.1 Fundamentals

49.2 Hooks in Depth

49.3 React 19 and Server Components

49.4 Building Real Apps

50. Next.js — App Router, Folder Structure, Rendering and Full Stack with SQL Server8 lessons · 15 Q&A

What Next.js adds to React, the App Router folder structure with sample files for every special file (layout, page, loading, error, not-found, route handlers, middleware/proxy), Server vs Client Components, rendering strategies (static, dynamic, streaming, ISR, partial prerendering), data fetching and caching, Server Actions and forms, metadata and SEO, connecting to SQL Server from server code (mssql, Prisma), authentication, deployment to Vercel/Azure/IIS, the Pages Router for legacy apps, and Next.js interview questions. Open course →

50.1 Getting Started

50.2 Rendering, Data and Caching

50.3 Production

51. Vue.js 3 (with Pinia, Vue Router & Nuxt basics)17 lessons · 21 Q&A

Vue instance and SFCs, template syntax and directives, reactivity (ref, reactive, computed, watch), Options vs Composition API, components, props, emits, slots, provide/inject, lifecycle hooks, composables, Vue Router, Pinia, forms, performance, testing and Nuxt. Open course →

51.1 Basics

51.2 Reactivity

51.3 Components

51.4 Router, State and Forms

51.5 Quality and Performance

5. Automation & Industry 4.0

Test automation with Selenium and Playwright, industrial automation (PLC, SCADA, Modbus, OPC UA) and Industry 4.0 (IIoT, MQTT, MES, OEE, digital twins).

52. Test Automation — Selenium, Playwright, API and BDD with C#10 lessons · 19 Q&A

Testing fundamentals and the test pyramid, NUnit/xUnit, Selenium WebDriver and locators, waits, Page Object Model, Playwright for .NET, API testing with HttpClient/RestSharp/Postman, BDD with Reqnroll (SpecFlow), data-driven tests, CI pipelines, flaky tests and the SDET interview questions. Open course →

52.1 Testing Fundamentals

52.2 UI Automation

52.3 API, BDD and CI

53. Industrial Automation — PLC, SCADA, Modbus and OPC UA10 lessons · 18 Q&A

Automation pyramid and Purdue model, sensors and actuators, signals (digital, 4–20 mA), PLC hardware and scan cycle, IEC 61131-3 ladder logic and structured text, timers and counters, PID control, HMI/SCADA/DCS, historians, fieldbuses and industrial Ethernet, Modbus RTU/TCP, OPC UA, connecting plant data to .NET, safety and OT security (IEC 62443), with interview questions. Open course →

53.1 Field Devices and Signals

53.2 PLC Programming

53.3 Supervisory Systems and Communication

53.4 Safety and Security

54. Industry 4.0 & IIoT — Smart Manufacturing Software10 lessons · 19 Q&A

The four industrial revolutions and Industry 4.0 pillars, IIoT architecture (edge, gateway, cloud), MQTT and Sparkplug B, the unified namespace, ISA-95 and MES functions, OEE and downtime analytics, traceability and genealogy, time-series data, digital twins, predictive maintenance and AI, Azure/AWS IoT platforms, building it with .NET, and the Industry 4.0 interview questions. Open course →

54.1 Foundations

54.2 IIoT Architecture and Protocols

54.3 Manufacturing KPIs and Data

54.4 Advanced Use Cases

6. Web3 & Blockchain

Blockchain fundamentals, Ethereum, wallets, Solidity smart contracts and dApp integration from .NET and JavaScript.

55. Blockchain & Web3 Fundamentals15 lessons · 19 Q&A

Web1/Web2/Web3, blockchain data structures, hashing and cryptography, consensus (PoW, PoS), Bitcoin and Ethereum, accounts, transactions and gas, wallets and keys, tokens (ERC-20, ERC-721, ERC-1155), DeFi, NFTs, DAOs, layer 2s, oracles, dApp architecture with .NET and JavaScript, and security. Open course →

55.1 Blockchain Fundamentals

55.2 Ethereum in Depth

55.3 Building dApps

56. Solidity & Smart Contract Development11 lessons · 19 Q&A

Solidity syntax, data types and data locations, functions, visibility and modifiers, events, errors, inheritance and interfaces, ERC-20/721 with OpenZeppelin, payable and Ether transfers, upgradeable contracts, gas optimisation, testing with Hardhat/Foundry, deployment and security vulnerabilities. Open course →

56.1 Language Basics

56.2 Object-Oriented Solidity

56.3 Advanced Topics

7. Interview Questions & Career

Role-based interview preparation (.NET full stack first), HR and behavioural rounds, team-lead rounds, career gaps, salary negotiation and company-wise preparation.

57. .NET Full Stack Developer Interview — End to End10 lessons · 26 Q&A

How .NET full stack interviews run, the end-to-end request flow (Angular/React → ASP.NET Core → EF Core → SQL Server), authentication, a feature built across every layer, performance, deployment, architecture and system design — with the questions interviewers ask most. Open course →

57.1 How .NET Full Stack Interviews Run

57.2 End-to-End Request Flow

57.3 Building a Feature Full Stack

57.4 Design and Architecture Round

58. HR & Behavioural Interview9 lessons · 25 Q&A

How HR and behavioural rounds work, the STAR method, "tell me about yourself", strengths and weaknesses, why this company, why leaving, conflict, failure, pressure, teamwork, culture fit, questions to ask, body language, online interview etiquette and model answers. Open course →

58.1 Foundations

58.2 Common HR Questions

59. Team Lead, Managerial & Agile Interview13 lessons · 24 Q&A

The tech lead vs engineering manager role, SDLC and Agile/Scrum/Kanban, estimation and planning, delegation, mentoring, performance management, conflict resolution, stakeholder management, risk and incident management, hiring, technical decision-making and model answers for managerial rounds. Open course →

59.1 The Role

59.2 Delivery and Stakeholders

60. Career Gaps, Job Changes & Salary Negotiation11 lessons · 15 Q&A

Explaining career gaps, layoffs, frequent job changes, domain/tech switches and freelancing; understanding CTC and offers (India and Taiwan), researching market pay, answering expected-salary questions, negotiating, counter-offers, offer comparison and resignation etiquette. Open course →

60.1 Career Gaps and Job Changes

60.2 Salary and Offers

61. Company-wise Interview Preparation9 lessons · 16 Q&A

How interviews typically run at Indian IT services companies (TCS, Infosys, Wipro, HCLTech, Cognizant, Accenture, Capgemini, Tech Mahindra, LTIMindtree), global product companies (Microsoft, Amazon, Google, Oracle), consulting firms, GCCs, startups and Taiwan employers — with the most important questions and model answers. Open course →

61.1 Indian IT Services Companies

61.2 Global Product Companies

61.3 Consulting, GCCs, Startups and Taiwan