Modern Software Development with TDD.
Master the art of building modern, high-quality, maintainable software using Test-Driven Development (TDD) and Pragmatic Architecture, specifically tailored for developers building large-scale projects with the .NET stack.
Introduction
This training will guide you through the foundational practices of Test-Driven Development (TDD) – from its core principles to advanced concepts, common pitfalls, and applying it effectively to large-scale projects.
Through practical examples and hands-on lab work, you'll master real-world TDD to write cleaner code, better tests, move fast w/o breaking things, reduce technical debt, and foster a culture of technical excellence on your team.
Additionally, you'll explore how architectural best practices, like Vertical Slice Architecture, boost your TDD game, enabling even faster, safer, and more enjoyable software development.
What's under the hood?
(1/5) Master TDD Fundamentals
Understand the economics of TDD and how it enables faster and safer software development.- Learn the essence of the Red-Green-Refactor cycle and the three laws of TDD.
- Overcome common obstacles to the Test-First approach and TDD flow.
- Design clear, simple, and testable code you and your teammates enjoy to read and use.
- Leverage Evolutionary Design to prevent big up-front designs.
- Reduce technical debt without big rewrites through Continuous Refactoring.
- Change complex code safely using Baby Steps and Microcommits.
- Eliminate manual debugging with short Feedback Loops.
(2/5) Write better tests
- Learn the 7 most common test smells (and how to fix them).
- Write maintainable, domain-driven, and self-documenting tests.
- Identify the most suitable test types (e.g. unit vs. integration) using Testing Pyramid and Testing Diamond.
- Learn the five Test Doubles (Mock, Stub, Fake, Spy, Dummy) and when to apply each.
- Skillfully switch between Classical and Mockist test/TDD styles.
- Write fast and robust tests for repositories, file system, time and async code.
- Build and evolve fluent Test APIs for functional and acceptance testing.
- Measure the quality of your tests with Mutation Testing (and see why Code Coverage is a flawed metric).
(3/5) Build .NET backend services with TDD
- Implement clean and maintainable Web APIs with a test-first approach.
- Apply SOLID principles to design modular and testable apps.
- Utilize the best .NET libraries and tools.
- Design Solitary and Sociable unit tests.
- Write Mocks and Stubs using the Moq library.
- Use Fluent Assertions to make clean test assertions.
- Leverage Docker to write reliable integration tests.
- Master the best practices of .NET Web API design.
(4/5) Implement Pragmatic Architecture with .NET
- Understand the difference between centralized and Vertical Slice Architecture.
- Learn how Vertical Slice Architecture supports TDD.
- Discover the best design patterns to achieve clean .NET apps.
- Apply DDD with rich romain models.
- Utilize CQRS for clean separation of concerns.
- Optimize data operations with EntityFramework and Dapper.
- Apply the Mediator pattern with the famous MediatR .NET library.
- Learn how to write Architecture Tests.
- Learn how to improve your architecture incrementally, w/o revolutions and risky rewrites.
(5/5) Advanced TDD Techniques
- Apply TDD effectively to legacy projects.
- Resolve the dilemma: "I need tests to refactor safely, but I need to refactor to write tests."
- Use Characterization and Approval testing to understand how legacy code works.
- Reproduce and fix production bugs using bug-driven TDD.
- Integrate TDD, ATDD, and BDD practices into QA teams.
- Understand the contextual trade-offs and when TDD may not be the best fit.
- Learn how to effectively explain, teach, and adopt TDD within your team.
By the end of this course, you’ll be able to confidently apply TDD on both brownfield (legacy) and greenfield (new) software projects. You'll have a firm understanding of deep synergy between testability and good design, and how TDD improves both. Finally, the course will shift your perspective on traditional software development, teaching you to deliver high-quality code quickly and sustainably, even under high-pressure conditions.
FAQ
For whom is this course?
This course is perfect for .NET developers, architects, and tech leads who want to master the art of quality software craftsmanship with TDD.
What are the prerequisites for this course?
You should have at least a few years of hands-on experience in enterprise software development with .NET. If you're passionate about clean code, refactoring, design patterns, testing, software architecture, and alike, you'll do great in this course.
How is the learning process organized?
The course is a mix of slides, demos, discussions, and exercises. Since the best way to learn any coding skill is to build real projects, the course is heavily focused on hands-on coding materials.
What tech will be used for demos/exercises?
C# with .NET.
Do I need to prepare for this course?
You'll need the latest .NET, a decent IDE, and access to GitHub.
Will I receive a certificate upon completion of the course?
Yes, you’ll receive a digitally verifiable certificate of accomplishment.
What is the language of instruction?
The course is taught in English.
Which timezone does the course run?
Central European / CET / Berlin time.
What are the exact times of the course?
9:00 – 18:00 (max).
How would I develop my knowledge after the course?
You will receive a list of books, blogs, videos, and GitHub repos for self-development. After the course, Daniel will remain available in group chat after the session for any questions, clarifications, and advice.
How do I convince my manager to send me to this course?
To make it easy to ask for company funding, download this template.
Questions?
Send an email to [email protected]
Upcoming workshops
Superskills Private training inquiries: [email protected]
Instructor
Daniel is a software craftsman and coach, helping teams and individuals produce quality software. With a network of over 100,000 followers, he is on a mission to raise the software quality standards worldwide by using the best engineering practices. He is the founder of the TDD Manifesto, the main organizer of the first International TDD Conference, and he also co-organizes regular meetups for the Tech Excellence software community, having over 4,500 members.
"Over the last 10 years, I’ve successfully applied TDD across diverse industries, including healthcare, oil & gas, robotics, blockchain, digital mapping, warehousing and ERP systems. In every domain, TDD has enabled me and my teams to produce clean, maintainable, and well-tested software that delivered significant value to our customers. TDD has proven to be a universal tool with the greatest impact on software quality. In this course, I’ll equip you with all the knowledge you need to succeed with TDD with the ultimate goal of making your customers happy." 