Modern Banking Microservices with Clean Architecture, DDD, TDD, .NET 10, and Angular 21 (nx Monorepo)

$19.00

Minimum price

$29.00

Suggested price

Modern Banking Microservices with Clean Architecture, DDD, TDD, .NET 10, and Angular 21 (nx Monorepo)

A Complete Engineering Guide to Building Production-Grade Banking Systems Using Microservices, Docker, CI/CD, Testing, and Angular Nx Monorepos

About the Book

This book is a complete, end-to-end engineering guide for building a modern digital banking platform using .NET 10, Clean Architecture, Domain-Driven Design (DDD), Angular 21 (Nx Monorepo), Docker, PostgreSQL, and GitHub Actions CI/CD.

Unlike typical programming books, this guide teaches how real financial software is built:

• Microservices in .NET 9 with clean boundaries
• Domain-driven modeling of banking products
• Building a scalable Angular monorepo with Nx
• Containerization from day one
• Automated testing (unit, integration, E2E)
• Secure APIs and IAM
• Event-driven workflows
• GitHub Actions pipelines (build, test, lint, security scans)
• Modern engineering practices used in fintech companies

You will build two full applications:

1. Branch/Cashier App (Open accounts, deposits, withdrawals, customer KYC)
2. Customer Internet Banking App (Transfers, airtime/electricity purchases, statements)

The platform includes:

• AccountService
• CustomerService
• TransactionService
• NotificationService
• IAM / IdentityService
• API Gateway using YARP
• Observability stack
• Automated pipeline integration
• And more

This is a practical, real-world guide with extensive code, diagrams, testing, and DevOps workflows. Ideal for full-stack developers who want to master enterprise systems, microservices, and modern software engineering.

Who This Book Is For

This book is for full-stack developers, backend engineers, and architects who want to build modern, production-grade systems using .NET for the backend and Angular for the frontend. It is especially valuable if you want to learn full-stack microservices, API-driven development, and shared monorepo workflows using Nx.

You will benefit from this book if you:

• Build full-stack applications using .NET + Angular
• Want to adopt a monorepo architecture using Nx
• Need real-world, enterprise-grade clean architecture examples
• Want to design consistent front-end & back-end boundaries
• Prefer practical, hands-on implementation over theory
• Work in teams maintaining large codebases with modular design

No previous experience with microservices or Nx is required — everything is explained step-by-step.

What You Will Learn

By the end of this book, you will have built a complete full-stack banking platform using .NET, Angular, Nx, and modern cloud-native architecture. You will learn:

🔹

Backend (.NET 10)

• Clean Architecture, DDD, CQRS, MediatR
• Event-driven microservices with domain events
• Minimal APIs and strongly typed endpoints
• PostgreSQL integration with EF Core
• Docker containers and local orchestration
• Integration tests, unit tests, and API tests
• YARP API Gateway with per-service Swagger
• Authentication & authorization patterns
• Observability: logs, metrics, tracing

🔹

Frontend (Angular + Nx Monorepo)

• Setting up an Nx-powered enterprise Angular monorepo
• Designing reusable Angular libraries and feature modules
• Building clean service layers for API consumption
• Strong typing with OpenAPI-generated Angular clients
• State management best practices (NgRx or Signals Stores)
• Building an admin dashboard, customer portal, and shared UI
• Route guards, interceptors, and front-end security
• High-quality UI/UX patterns for enterprise apps

🔹

Full-Stack Architecture

• Designing front-end/back-end boundaries
• Integrating front-end apps with microservices
• Consistent domain modeling across layers
• Versioning shared contracts (DTOs, API models)
• Avoiding tight coupling between UI and backend services
• Real-world CI/CD pipelines for monorepos and microservices

Every concept is explained while building a real working system end-to-end.

Keywords: .NET 10, Angular 21, C# 14, Microservices, Docker, Fintech, Clean Architecture, Banking, Nx Monorepo, CI/CD, GitHub Actions, TDD, DDD

About the Author

Gustavo Felix

Gustavo Felix is a Senior .NET & Azure Software Engineer with extensive experience designing and building enterprise systems using microservices architectures, Clean Architecture, and modern cloud-native technologies.

He has led engineering initiatives across fintech, logistics, and SaaS platforms, specializing in scalable backend systems, distributed event-driven workflows, and secure API development. Gustavo is passionate about teaching, mentoring, and helping developers grow into confident, high-level engineers through practical, real-world examples.

With this book, he brings together years of professional experience to teach full-stack developers how to build production-grade banking systems the way modern engineering teams operate today.

Table of Contents

• Preface

• Why this book now?

• What this book is (and isn’t)

• Who this book is for

• What you’ll build: Alvor Bank – Banking Suite

• Repositories and source code layout

• How the project and chapters are structured

• Tooling you’ll need

• How to read and work through this book

• Conventions used in the book

• A note about versions (2026 and beyond)

• Final word before we start

• Introduction

• The core idea: learn by building a bank

• The tech stack at a glance

• The microservices you’ll build

• Repositories and how to follow along

• How the chapters are organised

• How to work through this book

• What you need before starting

• A note on versions and real-world use

• Let’s begin

• Chapter 01 — The Vision: Building a Real Digital Bank

• 1.1 What we’re building: Alvor Bank – Banking Suite

• 1.2 The domains and bounded contexts

• 1.3 Why microservices, Clean Architecture, DDD and TDD?

• 1.4 Backend + Frontend + Messaging + DevOps blueprint

• 1.5 How we will work through the book

• 1.6 What you’ll achieve by the end of the book

• 1.7 Next steps

• Chapter 02 — Domain Architecture of a Digital Bank

• 2.1 Why domain architecture first?

• 2.2 The core domains revisited

• 2.3 Bounded contexts and microservices

• 2.4 Ubiquitous language

• 2.5 C4-style view of the system

• 2.6 Key workflows

• 2.7 Where RabbitMQ + MassTransit fit in

• 2.8 How this shapes the code structure

• 2.9 Looking ahead

• Chapter 03 — Development Environment, Repository Setup & Branch Strategy

• 3.1 Tools you need

• 3.2 Repository strategy

• 3.3 Creating the main source-code repository

• 3.4 Initial folder structure

• 3.5 Basic repo housekeeping (.gitignore, README)

• 3.6 Branch strategy

• 3.7 Connecting to GitHub

• 3.8 Workflow per chapter

• 3.9 Tagging the chapter

• 3.10 Sanity checks

• 3.11 What’s next

• Chapter 04 — Docker from Day Zero: Local Infrastructure with PostgreSQL & RabbitMQ

• 4.1 Why containers now?

• 4.2 Open the repository in Visual Studio 2026

• 4.3 Creating docker-compose.dev.yml

• 4.4 Starting the infrastructure

• 4.5 Verifying PostgreSQL

• 4.6 Verifying RabbitMQ

• 4.7 Stopping and cleaning up containers

• 4.8 Committing and tagging Chapter 04

• 4.9 Sanity checklist

• 4.10 What’s next

• Chapter 05 — Backend Solution & Clean Architecture Template (.NET 10)

• 5.1 Creating the backend solution

• 5.2 Creating BuildingBlocks projects

• 5.3 Adding minimal shared types to BuildingBlocks

• 5.4 Creating the IAM service skeleton

• 5.5 Wiring a minimal IAM API with a health endpoint

• 5.6 Building and running the IAM API

• 5.7 Solution structure recap

• 5.8 Committing and tagging Chapter 05

• 5.9 What’s next

• Chapter 06 — Backend Tests & CI with Code Coverage

• 6.1 Create test projects for IAM

• 6.2 Make Program test-friendly

• 6.3 Add a sample unit test (Result type)

• 6.4 Add an integration test for /health

• 6.5 Run tests from Visual Studio 2026

• 6.6 Install ReportGenerator tool

• 6.7 Run tests with coverage locally

• 6.8 Add backend tests workflow in GitHub Actions

• 6.9 Commit and tag Chapter 06

• 6.10 Sanity checklist

• 6.11 What’s next

• Chapter 07 — IAM Service Core: Identity, EF Core, JWT & CQRS

• 7.1 Goals for this chapter

• 7.2 Quick recap of the backend structure

• 7.3 Introduce CQRS & MediatR

• 7.4 IAM Domain: ApplicationUser & ApplicationRole

• 7.5 IAM Infrastructure: DbContext, JWT options & DI

• 7.6 JWT options & token generator (Application + Infrastructure)

• 7.7 Infrastructure dependency injection (+ MediatR registration)

• 7.8 IAM Application layer: commands & handlers (CQRS + Result)

• 7.9 API project: Program.cs + endpoints using MediatR

• 7.10 Configuration: appsettings.Development.json

• 7.11 EF Core migrations for IAM

• 7.12 Manual sanity check

• 7.13 Tests & CI still green

• 7.14 Commit & tag Chapter 07

• 7.15 What’s next

• 8.1 Admin Employee Management (List/Get/Update/Activate/Deactivate)

• 8.2 Email Confirmation & Password Flows

• 8.2 Email Confirmation & Resend

• 8.3 Password Flows (Forgot / Reset / Change)

• 8.4 Two-Factor Authentication (2FA) with Email Codes

• 8.5 Security Hardening & Tests

• 8.5 Integration Tests to Push IAM Coverage Toward 80%+

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

Now, this is technically risky for us, since you’ll have the book or course files either way. But we’re so confident in our products and services, and in our authors and readers, that we’re happy to offer a full money back guarantee for everything we sell.

You can only find out how good something is by trying it, and because of our 100% money back guarantee there’s literally no risk to do so!

So, there’s no reason not to click the Add to Cart button, is there?

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you’ll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earnedover $14 millionwriting, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don’t have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub’s ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub