Series · 15 parts
An Attendance Platform in ASP.NET Core
Badge gates, WFH timers and shift allowances - the shape of a seven-project intranet attendance platform, the onion it almost is, and the roadmap for fourteen more parts.
Topic
.NET
348 articles filed under this topic.
Series in .NET
Series · 4 parts
An Attendance Platform — The Frontend Chapters
A 6.23 MB JavaScript bundle loaded on every page, a manifest that minifies CSS but concatenates JS, and two copies of jQuery - the first of four frontend chapters the attendance series skipped.
Series · 9 parts
Archive-on-Delete with ArchiveKit
Hard deletes destroy the audit trail; soft deletes clutter live tables forever. Introducing ArchiveKit, a .NET library that intercepts deletions and stores immutable archive snapshots with TTL policies and cascade archiving.
Series · 8 parts
Contract Testing with Pactify
Unit tests mock what you assume, end-to-end tests tell you too late - consumer-driven contract testing closes the gap, and a small open-source .NET library called Pactify is the clearest way I know to learn how it works. Part 1 of a series.
Series · 8 parts
Convey — The Missing Chapters
The 22-part Convey series read the packages; it never once walked the sample system that ships with them. Opening the missing chapters with the trip an order takes through Orders, Pricing and Deliveries — and what the samples quietly teach that no package README does.
Series · 10 parts
Entity Versioning with VersionKit
Rename a property, change a type, ship the release - and every payload you stored last year stops deserialising. Introducing VersionKit, a .NET library that declares schema history as attributes and migrates old data on read.
Series · 17 parts
FastEndpoints in Depth
Controllers grow sideways and Minimal APIs grow into soup. FastEndpoints bets on a third shape - one class per endpoint - and this series reads its source to see how the bet is implemented. Part 1 of FastEndpoints in Depth.
Series · 12 parts
FastEndpoints — The Missing Chapters
Seventeen parts of reading FastEndpoints and the series never once mentioned mappers - the entity-translation layer half the endpoint base classes exist to serve. The Missing Chapters opens with the biggest gap: where mappers live, how they are found, and why they are secretly singletons. Part 1 of FastEndpoints — The Missing Chapters.
Series · 15 parts
Five Modules, One Database Each
Inflow is a modular monolith whose modules agree on their boundaries and disagree about everything inside them - a four-project onion next to a single feature-sliced assembly. Part 1 of a series reading the money-moving half of the estate.
Series · 18 parts
GroupFlights — Tactics in Three Dialects
A teaching repo that implements one airline-charter domain three ways on purpose - CRUD, CRUD-plus-rich, and Clean Architecture - and persists it three ways to match. Part 1 of a source-reading series.
Series · 22 parts
Microservices with Convey
Every team's fifth microservice ships with the same four hundred lines of bootstrap code as the first four. Opening a deep-dive series on Convey, the open-source .NET toolkit that turned that boilerplate into thirty composable packages.
Series · 10 parts
Multi-Tenancy in .NET with EF Core
Database-per-tenant, schema-per-tenant, or packed into a shared database? Kicking off a series on building a multi-tenant platform where one EF Core codebase supports all three isolation strategies behind a single control plane.
Series · 15 parts
Nine Services and a Message Bus
DShop is one e-commerce shop stamped out as nine microservices over RabbitMQ - this series reads the real source to see how the topology holds together and where it drifts. Part 1 of Nine Services and a Message Bus.
Series · 13 parts
No Coding Whatsoever
A 2018 API gateway promises that routing, auth, validation and messaging need no code at all - this series reads the source that makes the promise true, and the places where it is not.
Series · 14 parts
One Process, Three Modules
DevMentors' ModularMonolith sample packs three conference-system modules, a mini-framework and one deliberately broken contract into eighty-four C# files - opening a series that reads all of it, defects included.
Series · 11 parts
Real-Time Feeds with FeedR
A guided tour of FeedR, DevMentors' open-source .NET microservices sample for real-time data feeds - six services, Redis pub/sub, Apache Pulsar and a gRPC stream, and the two-tier eventing model that makes it worth reading. Part 1 of a source-level deep dive.
Series · 9 parts
Sagas with Chronicle
Split one database into five services and the transaction you deleted does not disappear - it goes feral. On sagas, compensation, process managers, and Chronicle, the small open-source .NET library this series reads line by line.
Series · 8 parts
Service Discovery Without a Service Mesh
Dozens of Azure Functions and Logic Apps need each other's URLs and keys, and there is no Kubernetes, no sidecar, no mesh to hand them out. How a small .NET library turned one Key Vault and a naming convention into a working discovery layer - the consumer side of a registry made of secrets. Part 1 of a new series.
Series · 11 parts
Six Packages and an Empty Test Project
Reading a repository one project at a time hides everything that lives in the edges between them - and in this estate the edges are where the interesting failures are.
Series · 13 parts
The Convey Consumer Tax
Convey sells a microservice in thirty lines, and Pacco builds ten of them - this series reads the whole estate to price what the framework compresses and what every consumer pays for by hand. Part 1 of The Convey Consumer Tax.
Series · 18 parts
The Database Is the Message Bus
Five executables, zero queues - how an attendance platform coordinated a web app, three Azure Functions and a console job through one SQL database, and what that choice bought and cost. Part 1 of the series.
Series · 16 parts
The Framework Before the Framework
DShop.Common is the shared library nine microservices were built on - and the rough draft of a framework its authors later shipped as Convey.
Series · 15 parts
The Framework Underneath
Every modular monolith claims its modules are decoupled. Inflow proves it the only way that counts - by having no project reference between any two of them - and then has to build a whole mini-framework to make that survivable. Part 1 of a source-read through the shared layer.
Series · 15 parts
The Order That Choreographs Itself
Nobody in Pacco approves an order - a vehicle reservation does. A tour of DevMentors' parcel-delivery estate, the domain it models, and the fifteen-part series it earns.
Series · 11 parts
The Repo Is the Lesson
Inflow ships an executable request collection - five .rest files, thirty-seven requests. On a fresh clone nine of them return a 2xx, and eight of those nine are in one file. This series reads the repository itself as the artefact.
Series · 15 parts
Trill — Reading the Services
Trill's Stories service is four projects with a dependency-free domain at the bottom. Its Users service is two projects with everything in one assembly - same author, same week, same estate, opposite answers to what a layer is.
Series · 15 parts
Trill — The Microservices Spine
The DevMentors Trill estate is a nine-service microservices sample spread over eleven sibling repositories with no README, no clone script and no bootstrap tooling - and the only artefact that names the whole system is a Visual Studio solution file.
Coming soon · 1 part
Aspire in Production
What .NET Aspire actually does for a real multi-service system - the AppHost model, service defaults, the dashboard, and the road from F5 to deployment.
Coming soon in .NET
The Dashboard You Get for Free
Wire four services into a .NET Aspire AppHost and run it once - traces, logs, health and environment variables for the whole system, before you have written a single line of observability code. Part 1 of a series on Aspire in production.
Standalone articles
26 Apr 2025
Getting Transactions Right with EF Core
SaveChanges is already a transaction, until it isn't enough. A tour of explicit transactions, TransactionScope, execution strategies and the failure modes that only show up in production.
Everything in .NET
The Token Becomes a Body Field
Trill's gateway authenticates the caller, parses the subject claim out of the JWT and writes it into the request body as a userId - a Content Enricher at the edge that explains the whole estate's API shape, and carries four defects in fifty lines.
The Route Values It Throws Away
Trill's gateway parses the story id out of the URL, boxes it into a route-value dictionary, and uses the result as a boolean - so the synchronous and asynchronous versions of the same operation have different contracts and only one of them honours the URL.
A Gateway That Publishes What It Cannot Name
Trill's API gateway turns HTTP posts into AMQP messages using eighty lines of middleware, a route template and a raw JSON blob - it publishes onto the estate's bus with zero compile-time knowledge of any contract, which is the exact inverse of what every other repo does.
Durable Queues on an Ephemeral Disk
Every exchange and queue in the Trill estate is declared durable, and the RabbitMQ container that holds them has its volume commented out - Guaranteed Delivery configured at the broker and cancelled one file away.
The Config Is a Promise the Code Never Made
Trill's appsettings files and package references describe caching, service discovery, health checks, dynamic secret leases and API documentation - and reading the source shows how much of that is never wired up at all.
Nine Repos and No Map
The DevMentors Trill estate is a nine-service microservices sample spread over eleven sibling repositories with no README, no clone script and no bootstrap tooling - and the only artefact that names the whole system is a Visual Studio solution file.
Three Runners, Four Inventories
Trill ships a PM2 ecosystem file, a Tye manifest and a Docker Compose file - three ways to start the estate that disagree about which services exist, plus a Prometheus config that scrapes a service two of them never launch.
What Teaching Code Owes Its Reader
The retrospective - nine declared omissions that are all defensible, a set of undeclared ones that all turned out to be live bugs, and the rule that falls out of the difference.
Endpoints Declared as Data
A four-field record that makes it impossible to register a route without stating who may call it - the best idea in the mini-framework - and the one line it did not write, which costs every 404 in the estate.
Sixteen Concepts, Copied Once
When Postsale was carved out of Sales, sixteen types came with it - and every place the twins differ marks a decision the extraction forced, including one base class that stopped draining and a repository that silently depends on it.
The ADR Said UTC and One Switch Unsaid It
A decision record mandates UTC everywhere and an IClock abstraction, and thirty files honour it - then one process-global AppContext switch in shared plumbing makes every timestamp column forget it was UTC.
Five Seconds Is a Teaching Decision
The tick that makes eventual consistency watchable in a console, the four-hop chain that takes twenty seconds because of it, and the DI-scope trap the estate is one refactor away from firing.
Publish Then Save, Save Then Publish
One estate showing the safe ordering five times and the unsafe one once, with the phantom-event failure traceable end to end through a webhook that never retries.
At Most Once, and Sometimes Not at All
What an in-process event dispatcher actually guarantees when there is no outbox, no dead letter, no correlation id and no drain on shutdown - and the one static field the whole thing depends on.
A Specification That Never Specifies Anything
A textbook Specification base class whose one clever feature has zero usages, whose combinators have none either, and whose only used method recompiles an expression tree on every call - inside loops.
CQRS Arrived as a Consequence
Because the write model exposes nothing, the read side could not go through the aggregate - so a second POCO maps the same physical table through a second DbContext. CQRS as an outcome rather than a choice.
The Model the Scheduler Can Query
The third persistence strategy is the plainest one, and the only one a background poller can interrogate - plus what that poller costs when it has no watermark, no paging and no index.
When Private Fields Become Column Names
Mapping a fully encapsulated aggregate to relational tables with Property of T of a string - eight tables for one aggregate, eighteen columns, seventeen of them named after private C# fields.
The Aggregate as One Column
Sales stores four aggregate roots and twenty-five value objects in three tables, by serialising whole aggregates into jsonb - and the reflection resolver that makes reconstitution work bypasses every invariant on the way in.
The Queries You Cannot Write
What the document strategy really costs - a promoted column, a side table, an in-memory dictionary with a TODO on it, and six update methods that look the row up without its id.
Asserting on Events When There Are No Getters
Two test files, one estate, one deliberate contrast - and the answer to the question a fully encapsulated aggregate forces on you. Six test methods in 14,559 lines, by design.
Make the Draft a Different Class
An offer draft and a published offer are not one entity with a status flag - they are two classes, and the transition is a method that returns the second one. What that buys, and what it silently drops.
One Public Member, Sixteen Consequences
Postsale's aggregate has ten private fields and exactly one public member. Reservation, in the same estate, has eighteen. Following that difference all the way down to the database.
CRUD, Rich, Clean — And Who Actually Got Which
Testing a README's three-tier architecture claim against the source, and finding that the module nobody mentions holds the only real aggregate in the estate.
One Domain, Three Dialects
A teaching repo that implements one airline-charter domain three ways on purpose - CRUD, CRUD-plus-rich, and Clean Architecture - and persists it three ways to match. Part 1 of a source-reading series.