AI Transformation Solutions For Technology Leaders
Intertech Clean Architecture with .NET
(3 days)
Intertech’s Clean Architecture training is led by senior consultants who have spent decades designing, modernizing, and rescuing enterprise software systems across a wide range of industries.
The architectural principles taught in this course are not simply textbook concepts—they are the same practices our consultants apply when helping organizations reduce technical debt, modernize legacy applications, improve maintainability, and deliver software that can evolve with changing business needs. Students benefit from practical guidance, real-world examples, and lessons learned from production environments, giving them the confidence to apply Clean Architecture principles effectively long after the course has ended.
Planning
Intertech’s software planning & requirement analysis process sets the foundation for the entire software development process.
Architecture & Design
Our software architecture and system design stage lays the groundwork for successful software implementation by providing a clear roadmap for building the system.
Custom Development
Intertech experts help you select languages and implement coding standards and development practices that are well-informed & collaborative when updating or creating new web -based and desktop applications.
Quality Assurance
Intertech brings a comprehensive and integrated approach to software quality assurance (QA) and testing that fosters a commitment to delivering software of the highest quality.
Testing
Each type of test serves a specific purpose in the software development process, contributing to the overall quality and reliability of the software. The choice of tests depends on the project’s requirements, goals, and the nature of the software being developed.
Cloud Migration & Integration
Work with a team that understands cloud migration and cloud integration, as well as application architecture and development, so you get the “cloud full stack” experience from your dev-team.
Course Outline and Curriculum
Course Overview
Modern software systems are expected to evolve rapidly, scale efficiently, and remain maintainable for years after their initial release.
Built around real-world architectural challenges, this course helps developers move beyond tightly coupled applications and toward systems that are easier to understand, test, extend, and modernize. Decision makers will gain confidence that their teams are learning architectural practices that reduce technical debt, improve long-term agility, and create software that can evolve with the business, while developers leave with practical patterns they can immediately apply to both new and existing .NET applications.
Course Curriculum
PART I — The Holy Grail of Modularity
Build a strong architectural foundation by learning the principles of modular design, Domain-Driven Design (DDD), and Clean Architecture, enabling you to create maintainable, testable, and scalable .NET applications from the ground up.
Module 1 — Why Modular Architecture Matters (Chapter 1)
Key Themes:
- Evolution from three‑tier systems
- – The book notes: “In the beginning, it was three‑tier…” — use this to introduce legacy layering.
- Core facts of a three‑tier system
- Layers vs tiers vs modularization
- DDD canonical architecture
- Supporting architecture proposed by Dino
- Additional architectural “flavors”:
- – Hexagonal
– Clean Architecture
– Feature‑driven architecture
Learning Outcomes:
- Understand why modularity is the foundation of modern .NET architecture
- Compare traditional layered systems with modern modular approaches
- Recognize architectural patterns that influence Clean Architecture
Module 1 — Lab
- Create a simple Minimal API endpoint
- Move the logic into a small domain class
- Inject the class to show modular structure
Module 2 — Domain‑Driven Design Essentials (Chapter 2)
Key Themes:
- “Design driven by the domain” — the book’s central DDD mantra
- Strategic analysis
- Tactical design
- DDD misconceptions
- Tools for strategic design:
- – Ubiquitous language
– Domain‑specific vocabulary
– Glossary building - Bounded contexts
- Context maps (upstream/downstream relationships)
- Deployment maps
Learning Outcomes:
- Understand how DDD shapes Clean Architecture
- Learn how to define bounded contexts and ubiquitous language
- Map business domains into software boundaries
- Identify upstream/downstream relationships in a system
Module 2 — Lab
- Define one domain entity
- Create one value object
- Return the entity from an API endpoint
Module 3 — Principles of Modularity (Chapter 3)
Key Themes:
- Separation of concerns
- Loose coupling
- Reusability
- Dependency management
- Documentation
- Testability
- Applying modularization across layers:
-
– Presentation
– Application
– Domain
– Infrastructure - Modular monoliths vs microservices
- Maintainability and testability
- “The simplest solution ever” — Dino’s emphasis on avoiding over‑engineering
Learning Outcomes:
- Apply modularity principles to .NET applications
- Understand when to use monoliths vs microservices
- Design for maintainability and testability
Module 3 — Lab
- Start with a single “God Method”
- Split logic into two separate classes
- Call both from an endpoint to show separation of concerns
Course Curriculum
PART II — Architecture Cleanup
Put Clean Architecture into practice by designing and implementing each architectural layer—from presentation and application to domain and infrastructure—using modern .NET patterns, hands-on labs, and real-world architectural techniques that produce scalable, maintainable, and testable enterprise applications.
Module 4 — The Presentation Layer (Chapter 4)
Key Themes:
- Project Renoir overview
- Abstract and physical context maps
- Business requirements engineering
- Event‑based storyboards
- Presentation layer boundaries and deployment
- ASP.NET endpoints
- Front‑end technologies
- API‑only presentation models
Learning Outcomes:
- Understand the role of the presentation layer in Clean Architecture
- Learn how ASP.NET endpoints connect to business workflows
- Explore UI vs API‑only presentation strategies
Module 4 — Lab
- Create three Minimal API endpoints
- Store data in an in‑memory list
- View endpoints in Endpoint Explorer
Module 5 — The Application Layer (Chapter 5)
Key Themes:
- Architectural view of Project Renoir
- Access control subsystem
- Document‑management subsystem
- Task orchestration
- – The book asks: “What is a task, anyway?” — use this as a teaching anchor
- Distributed tasks
- Data transfer between layers
- Application layer outline
- Settings propagation
- Logging
- Exception handling
- Caching patterns
- SignalR hubs
- Deployment boundaries
Learning Outcomes:
- Understand how the application layer coordinates workflows
- Learn how tasks, commands, and orchestration work
- Implement cross‑cutting concerns (logging, caching, exceptions)
Module 5 — Lab
- Create a simple Task Handler class
- Inject it into an endpoint
- Add logging to show orchestration
Module 6 — The Domain Layer (Chapter 6)
Key Themes:
- Decomposition of the domain layer
- Business domain model
- Helper domain services
- Shifting focus from data to behavior
- Entities, value objects, aggregates
- “Treating software anemia” — Dino’s critique of anemic models
- Rules of etiquette for entity classes
- Style conventions
- Writing readable domain code
Learning Outcomes:
- Build rich domain models that encapsulate behavior
- Apply DDD tactical patterns
- Write clean, readable domain code
Module 6 — Lab
- Add behavior to a domain entity
- Enforce one domain rule
- Return the updated entity from an endpoint
Module 7 — Domain Services (Chapter 7)
Key Themes:
- What domain services are
- Stateless nature of domain services
- Ubiquitous language alignment
- Data access and injection
- Common scenarios:
- – Loyalty status
– Domain events
– Business emails
– Password hashing - REPR pattern
- Additional scenarios and open questions
Learning Outcomes:
- Understand when logic belongs in a domain service
- Implement stateless domain services
- Integrate domain services with domain events and infrastructure
Module 7 — Lab
- Create a stateless domain service
- Inject it into an endpoint
- Call the service using a query parameter
Module 8 — The Infrastructure Layer (Chapter 8)
Key Themes:
- Responsibilities of the infrastructure layer
- Persistence and storage
- External and internal service communication
- Repository classes
- EF Core
- Dapper
- Hosting business logic in the database
- Data storage architecture
- Command/query separation
- Event sourcing (executive summary)
Learning Outcomes:
- Implement persistence using EF Core or Dapper
- Understand repository patterns in Clean Architecture
- Learn CQRS fundamentals
- Explore event sourcing at a conceptual level
Module 8 — Lab
- Use SQLite in‑memory
- Run one EF Core query
- Run one Dapper query
- Return results from an endpoint
Take a few minutes to complete the assessment and gain a clear, practical view of your organization’s AI readiness—and what to do next.
“Intertech has been an invaluable partner for our business. They have enabled us to implement automation in our finance business that is seldom present in organizations 10 times our size. They are responsive, innovative and absolutely committed to their customer’s success. You can frequently find vendors that meet your needs, but with Intertech, we have found a strategic partner who is just as committed to our success as we are.“
Chief Technology Officer | Microf