About this course

This is the advanced course on designing and building enterprise-grade backend systems with C# and modern .NET. Students move beyond isolated programming exercises into the engineering discipline of domain modelling, use-case design, quality attributes, API contracts, persistence boundaries, integration patterns, security architecture, architecture documentation, and maintainable code. The emphasis is on building systems whose design can be explained, reviewed, extended, and defended.

No prior .NET experience is assumed. Students arrive with programming, basic OOP, database, web, Git, and basic DevOps foundations. The course builds the .NET foundations early, then uses one running project to introduce architecture styles, architectural decision making, enterprise design patterns, robust API design, security, enterprise integration, and AI API integration through explicit application boundaries.

Rationale. Enterprise software is not only about making endpoints respond. It is about aligning business use cases, domain rules, persistence, external integrations, quality attributes, security constraints, and team-readable code. This course provides a shared engineering base for students who will build backend systems, distributed applications, AI-enabled services, and capstone projects in realistic organizational settings.

Course format

Each week is 4 contact hours: a 2-hour lecture for concepts, architecture, and design reasoning, and a 2-hour practice session at the keyboard. Git and basic DevOps workflow are assumed. The practice session focuses on architecture increments, .NET implementation depth, and design review. The thirteen weeks form six parts: .NET Foundations for Enterprise Systems (weeks 1 to 2), API Contracts and Persistence (3 to 4), Enterprise Architecture and Design Tradeoffs (5 to 8), Domain Logic and Security Architecture (9 to 10), Integration and AI-Enabled Systems (11 to 12), and Final Architectural Defense (13). The running project is presented to the class three times, in the Student Project Presentations: a proposal (week 5), an interim review (week 8), and a final project defense (week 13).

Expected outcomes

By the end of the course, students will be able to:

Industry alignment

Current .NET backend roles consistently ask for C#, ASP.NET Core, REST APIs, Entity Framework Core, SQL, secure API development, third-party integration, Azure or cloud familiarity, scalable service design, and maintainable architecture. Senior roles add design patterns, microservice or modular boundaries, caching, background processing, messaging, observability, and architecture tradeoff reasoning.

Academic foundations

The course adds theory where it deepens design judgement. Students learn the principle, apply it in .NET, and defend it through their project architecture.

Prerequisites: review and self-check

The course assumes prior programming and basic software-development experience. Each row lists the background students should review before Week 1.

Subject	Background topics	Material
🔧Programming & workflow	C-style syntax or Java/C# familiarity, basic OOP, Git, pull requests, code review, reading a stack trace	ReviewSelf-check
⚙️Web & databases	HTTP and REST, JSON, relational tables, keys, joins, transactions, basic SQL	ReviewSelf-check
🏗️Software engineering	Object-oriented design, interfaces, separation of concerns, basic UML or C4-style diagrams	ReviewSelf-check

Weekly materials

Each week combines the in-class plan with its study trail: lesson plan, practice brief, videos, official docs, tutorial, and reading or book chapters. In the highlighted weeks the practice slot is a Student Project Presentation: fully student-run, no instructor material.

Weekly plan and study resources
Part I · .NET Foundations for Enterprise Systems
Week 1 Introduction to Enterprise Software Engineering with .NET Lecture Enterprise systems, quality attributes, .NET ecosystem, solution structure, business domains, use cases. Practice Create the initial solution architecture; choose a domain; draft use cases and quality-attribute scenarios. Tools .NET SDK · Visual Studio / Rider / VS Code · C4 sketches · ADR template Lesson planPracticeWatch: ASP.NET CoreWatch Hebrew: C# .NET Docs .NET overview; ASP.NET Core fundamentalsTutorial Create a .NET appReading Software Architecture: The Hard Parts, ch. 1.
Week 2 Modern C# for Enterprise Domain Models Lecture Records, nullable reference types, generics, LINQ, exceptions, async and await, value objects, invariants. Practice Model initial domain entities and value objects; write first domain services and executable examples. Tools C# 12+ · nullable reference types · LINQPad optional Lesson planPracticeWatch: C# idiomsWatch Hebrew: C# refresher Docs C# documentation; Records; Nullable reference typesTutorial C# tutorialsReading C# in Depth, language evolution chapters.
Part II · API Contracts and Persistence
Week 3 API Contracts, SOLID, and Maintainable Services Lecture SOLID, API contracts, DTOs, ProblemDetails, dependency inversion, cohesion, coupling, maintainability. Practice Refine service boundaries; define request and response contracts; refactor toward clear boundaries. Tools code analyzers · ProblemDetails · architecture sketches Lesson planPracticeWatch: SOLIDWatch Hebrew: Dependency Injection Docs API error handling; Dependency injectionTutorial Create a minimal APIReading Clean Architecture, SOLID and component principles.
Week 4 ASP.NET Core Web API Lecture Controllers, Minimal APIs, routing, middleware, DI lifetimes, options, configuration, Swagger, OpenAPI. Practice Build first working endpoints; define DTOs; add validation, options, and consistent API responses. Tools ASP.NET Core · Swagger / OpenAPI · FluentValidation · options pattern Lesson planPracticeWatch: Web APIWatch Hebrew: Web API Docs ASP.NET Core Web API; OpenAPI; MiddlewareTutorial Create a web APIReading HTTP Semantics, RFC 9110.
Part III · Enterprise Architecture and Design Tradeoffs
Week 5 Proposal Presentations, EF Core, and Persistence Tradeoffs Lecture DbContext, relationships, migrations, transactions, concurrency, query shape, persistence boundaries. 🎤 Student Project Presentation 1 · Proposal Tools Entity Framework Core · SQL Server / PostgreSQL · migrations Lesson planPresentation briefWatch: EF CoreWatch Hebrew: EF Core Docs EF Core; modelling; concurrencyTutorial EF Core getting startedReading Patterns of Enterprise Application Architecture catalog: Data Mapper, Unit of Work, Repository.
Week 6 Architecture Styles and Quality Attributes Lecture Layered, Clean Architecture, vertical slice, modular monolith, quality attributes, fitness functions. Practice Reorganize the project around chosen architecture; write ADRs and quality-attribute scenarios. Tools C4 diagrams · ADRs · dependency rules · architecture checks Lesson planPracticeWatch: Clean ArchitectureWatch Hebrew: MVC architecture Docs Common web architectures; .NET microservices guideTutorial eShopOnWeb reference appReading Fundamentals of Software Architecture, characteristics and styles.
Week 7 Enterprise Design Patterns and Integration Patterns Lecture Repository, Unit of Work, Factory, Strategy, Adapter, Decorator, Mediator, CQRS, Outbox, idempotency. Practice Implement patterns with executable examples; document why each pattern fits the use case and quality goals. Tools DI container · MediatR · interfaces · pattern notes Lesson planPracticeWatch: Strategy PatternWatch Hebrew: Factory Pattern Docs DDD and CQRS patterns; DI guidelinesTutorial MediatR documentationReading Design Patterns: Factory Method, Strategy, Adapter, Decorator, Mediator.
Week 8 Midterm Presentations and Clean Architecture Lecture Dependency rules, use cases, ports and adapters, modular monoliths, package boundaries. 🎤 Student Project Presentation 2 · Interim Tools Clean Architecture · C4 diagrams · ADRs Lesson planPresentation briefWatch: ArchitectureWatch Hebrew: .NET Conf Israel Docs Clean and layered architecture; Architecture Decision RecordsTutorial Trace dependencies in eShopOnWebReading Clean Architecture, boundaries, policy, and details.
Part IV · Domain Logic and Security Architecture
Week 9 Domain-Driven Design and Business Logic Lecture Entities, value objects, aggregates, domain services, domain events, invariants, business rules. Practice Strengthen workflows and domain rules; add use-case scenarios around business behavior. Tools domain model · use-case services · event sketches Lesson planPracticeWatch: DDD and EFWatch Hebrew: Pattern vocabulary Docs Domain model validations; Domain model designTutorial Implement a domain modelReading Domain-Driven Design, entities, value objects, services, modules, aggregates.
Week 10 Security, Validation, and Robust API Design Lecture Threat modelling, authentication, authorization, JWT, roles, claims, audit trails, validation, global error handling. Practice Secure selected endpoints; add authorization policies, validation filters, audit notes, and error response contracts. Tools ASP.NET Core Identity / JWT · authorization policies · ProblemDetails · OWASP API Security Lesson planPracticeWatch: AuthWatch Hebrew: ASP.NET Core Docs authentication; authorization; Data ProtectionTutorial Identity API authorizationReading OWASP API Security.
Part V · Integration and AI-Enabled Systems
Week 11 Azure Cloud Services and Enterprise Integration Lecture Azure App Service, Azure SQL, Storage, Key Vault, Entra ID, Managed Identity, Service Bus, Functions, Application Insights. Practice Design the Azure deployment and integration map; add cloud-aware configuration, secrets, logging, and failure handling. Tools Azure App Service · Azure SQL · Key Vault · Managed Identity · Service Bus · Functions · Application Insights Lesson planPracticeWatch: Azure FunctionsWatch Hebrew: Azure Docs App Service; Key Vault; Service Bus; FunctionsTutorial Deploy ASP.NET Core to Azure App ServiceReading Architecting Cloud Native .NET Applications for Azure, resiliency chapters.
Week 12 .NET Integration Depth and AI-Enabled Systems Lecture HttpClientFactory, resilience, hosted services, caching, AI clients, streaming, embeddings, tool calling, evaluation. Practice Add an integration boundary, background workflow, or optional AI-backed use case with clear failure handling. Tools HttpClientFactory · Polly · IHostedService · IMemoryCache · Microsoft.Extensions.AI · Semantic Kernel Lesson planPracticeWatch: Semantic KernelWatch Hebrew: Microsoft Learn videos Docs IHttpClientFactory; Microsoft.Extensions.AI; Semantic KernelTutorial Semantic Kernel quick startReading Designing Data-Intensive Applications, reliability and dataflow.
Part VI · Final Architectural Defense
Week 13 Final Student Presentations Lecture Final demo, architecture review, code quality, integration design, design decisions, lessons learned. 🎤 Student Project Presentation 3 · Final (with oral defense) Tools architecture document · ADRs · quality evidence · final slides Lesson planPresentation briefWatch: ReviewWatch Hebrew: final project Docs Azure Well-Architected Framework; Azure Architecture FrameworkTutorial Azure architecture review assessmentReading Fundamentals of Software Architecture, decisions and presentation.

AI usage

Using an AI assistant is encouraged in this course; it reflects how modern software engineering is increasingly done. Two conditions keep the learning genuine: students keep full ownership of, and responsibility for, everything they submit, and must be able to explain and defend any part of it.

Every weekly project increment follows a three-part model:

Assessment and grading

Grading is project-based, with weight on architecture, reasoning, maintainability, use-case coverage, integration design, and the ability to defend design decisions. The running project is the single deliverable, built up in weekly increments and graded at the three Student Project Presentations. There are no written exams and no separate lab submissions.

Component	What it covers	Weight
Project · Proposal	Student Project Presentation 1: problem, domain, use cases, architecture plan, data model, technical risks (week 5).	20%
Project · Interim	Student Project Presentation 2: working API, persistence, architecture, design patterns, business workflows, code structure (week 8).	30%
Project · Final	Student Project Presentation 3: complete system, final architecture, integration design, security, documentation, optional AI integration, oral defense (week 13).	50%

The running project

100% of the grade · teams of three or four · presented three times

Teams carry a single enterprise application across the semester, integrating most of the covered material into one coherent system: a business domain, use cases, REST API, persistent data model, layered or Clean Architecture structure, enterprise design patterns, security, validation, integration boundaries, documentation, and an optional AI-backed use case. Teams choose one of the course domains, order management, course registration, clinic appointments, helpdesk ticketing, inventory management, booking and reservation, portfolio management, or insurance claims, or propose another domain of comparable scope for approval. Whatever the domain, teams must demonstrate architectural maturity, not endpoint count alone. Each presentation is 12 to 15 minutes plus questions, with a short written report and a tagged release of the repository.

Example project ideas

Each idea below exercises the course architecture stack; teams may take one as-is or propose a variant of comparable scope.

Video references

Free video material that aligns with the course. Microsoft Learn and .NET team videos are preferred because they are official and stable; Coursera links are included as optional structured supplements.

Hebrew video support

Hebrew-language videos are included as support material for review, vocabulary, and local context. They supplement the official English sources rather than replacing them.

References

A curated reading list spanning enterprise architecture, .NET backend engineering, domain modelling, and AI-enabled application design.

Tools and resources

The toolchain mirrors the weekly schedule and keeps attention on .NET, enterprise architecture, and defensible engineering decisions.

• C# and .NET: .NET SDK, ASP.NET Core, modern C# language features, dependency injection, configuration.
• Data access: Entity Framework Core, SQL Server or PostgreSQL, migrations, repositories, query design.
• API design: REST, DTOs, validation, Swagger and OpenAPI, global error handling, problem details.
• Architecture: layered architecture, Clean Architecture, modular monoliths, C4 diagrams, ADRs.
• Design patterns: Repository, Unit of Work, Factory, Strategy, Adapter, Decorator, Mediator, CQRS, Specification.
• Azure enterprise integration: Azure App Service, Azure SQL, Storage, Key Vault, Entra ID, Managed Identity, Service Bus, Functions, Application Insights, plus HttpClientFactory and resilience.
• AI APIs and libraries: Microsoft.Extensions.AI, Semantic Kernel, OpenAI .NET SDK, Azure.AI.OpenAI, Azure AI Search, evaluation libraries.
• AI assistant: part of the toolkit, expected for exploration and review, with full student responsibility for submitted work.