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
Everything Is a Singleton
Twenty-two registrations, zero scoped, zero transient - a lifetime decision that buys a genuinely fast request path and enables exactly three bugs, all of them the same mistake.
Building a Second Container to Read One Value
services.BuildServiceProvider() inside ConfigureServices - what it actually costs, why it does not leak here, and how a zero-parameter extension method signature forced it.
The Claims Map That Does Not Exist
The README and the sample both configure an auth claims alias map, the configuration class has no such property, and the binder's ignore-unknown-keys behaviour is what makes the omission silent.
Three Predicates, One Flag
Three components decide independently whether a route needs authentication, only one of them consults auth.enabled - and the combination that turns a public route into a 403.
Five Parses to Reject One Request
A validated POST is parsed, re-serialised and parsed again on its way to a schema compiled fresh per request - and when it fails validation the caller gets HTTP 200.
The Parser That Works Because Its Bug Is Harmless
Two mini-languages share one parser that runs both resolvers unconditionally and strips the first and last character from every token - and it is correct only by coincidence.
The Payload Template That Could Never Load
Two notions of module identity, a silent continue on a missing file - and a live bug the unreachable code was hiding.
Match All and the Reserved Word Nobody Documented
Forty lines build every upstream path Ntrada can express, and thirty more build the downstream URL - where named segments substitute, one key appends, and one config flag runs backwards.
Thirteen Lines Are the Whole Pipeline
Ntrada's request pipeline is a gate and a dictionary lookup - and four extension hooks around it, one of which lost the thing it existed to see when a disposal bug was fixed.
The Route Table Is a Compiler Output
Ntrada writes no middleware - it compiles YAML into ASP.NET Core endpoints and lets the framework's matcher do the work. Then you try to declare a PATCH route.
Four Years Cold
Inflow's last commit landed on 23 July 2022 and nothing in the repository says so. The retrospective on eleven parts of reading a teaching repo as an artefact - what it gets right, what it costs, and what four passes over one estate add up to.
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.
Seven Choices and One Comment
Inflow is full of deliberate, defensible simplifications. One of them is explained in a code comment, and it is instantly legible as a teaching decision. The other seven are indistinguishable, on the evidence in the repository, from bugs.
A Guard for the Drift, None for the Rule
Inflow throws at startup if a module's local copy of another module's event has changed shape. The rule the whole repository exists to demonstrate - that no module may reference another - is protected by nothing at all.
The Upgrade That Only Moved Braces
Inflow's .NET 6 upgrade touches 519 files. Run the diff with whitespace ignored and almost all of it is one Rider refactoring - and the three real changes, plus two design rewrites nobody announced, are hiding underneath it.
Two Workshops That Forked
Inflow ships the same exercise twice, on two branches prepared eleven days apart from the same commit. They do not start from the same place, neither converges on master, and both carry a README describing components they have deleted.
An Afternoon in March
One branch in Inflow carries five commits timestamped 11:56, 13:49, 14:11, 14:49 and 16:08 on a single Saturday. That is not a development history - it is a live teaching session committed as it happened, and it explains a defect on master.
Eleven Claims, and Most of Them True
Four articles of defects earn an audit. Inflow's README makes fifteen checkable claims and eleven of them hold - including the strongest one, checked edge by edge across all twenty project files. Here is the ledger, and why a short README is so hard to falsify.
Register as the Admin User
Inflow's request collection contains a captioned request that grants full administrative permissions to an anonymous caller. The mechanism is four lines long, the documented happy path requires it, and the repository nowhere says it is on purpose - here is all of that, and the case for the defence.
The Route That Never Existed
GET /payments returns a 404 in Inflow's own root request file. The reason is not a typo - it is the Payments module exercising exactly the architectural freedom the README advertises, which makes this 404 the best evidence in the repository that the claim is true.
Fourteen Steps and Nine of Them Invisible
Getting money into a wallet in Inflow takes five HTTP requests and nine in-process reactions nobody documents. Reconstructing that path from source is the only way to get it - and every failure along it returns 204 No Content.
Nine Requests of Thirty-Seven
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.
Boot Loudly, Fail Quietly
One sentence describes every failure convention in Inflow's shared framework - startup misconfiguration throws, runtime message failure is logged and dropped. The retrospective on fourteen parts of source-reading, including what to steal, what to avoid, and where this design should not go.
The Container You Build to Read a Setting
Inflow reads every configuration section by building and disposing an entire service provider - twenty-two of them during startup. Two of those calls do not read anything; they mutate a registry, and they only work because of how three singletons were registered.
An Inbox That Is Really a Ledger
Inflow's inbox writes a row only after the handler succeeds, which makes its own duplicate-check predicate dead code and its name wrong. It is a good Idempotent Receiver with a one-hour memory, a decorator that resolves from the wrong provider, and an orphaned brace pair.