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.
348 articles filed under this topic.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
DShop.Common is the shared library nine microservices were built on - and the rough draft of a framework its authors later shipped as Convey.
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.
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.
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.
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.
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.
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.
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.
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.
FastEndpoints.A2A publishes an agent card at a well-known URL and answers agent-to-agent calls through a JSON-RPC 2.0 dispatcher written entirely by hand - implementing exactly the slice of the A2A protocol it can do honestly. The final missing chapter, and the close of both series. Part 12 of FastEndpoints — The Missing Chapters.
FastEndpoints.Mcp exposes opt-in endpoints as Model Context Protocol tools - schemas generated from your DTOs and enriched from your validators, a synthetic HttpContext that runs the real pipeline, and a visibility model that deliberately ignores your REST auth. Part 11 of FastEndpoints — The Missing Chapters.
FastEndpoints.CommandRules sounds like a Roslyn analyzer and is nothing of the sort - it is a small rules engine that turns an input into planned commands and dispatches each one now or onto a job queue. A close read of the newest package in the repo, capability matrix and all. Part 10 of FastEndpoints — The Missing Chapters.
FastEndpoints will hand you a typed client four different ways - NSwag-generated C# or TypeScript, or Kiota clients built over either OpenAPI stack - served as a download endpoint or produced by a run-then-exit build mode. The lineages, the seams, and one version pin that tells a story. Part 9 of FastEndpoints — The Missing Chapters.
Buried in the FastEndpoints package props is a comment marking NSwag for deprecation - and a whole second OpenAPI stack built on Microsoft.AspNetCore.OpenApi already ships beside it. Transformers instead of processors, AOT export via MSBuild tricks, and a golden-master test suite. Part 8 of FastEndpoints — The Missing Chapters.
FastEndpoints.OData is ninety lines that bolt Microsoft's OData query engine onto a REPR endpoint - a sealed Configure(), a fake ParameterInfo, and an endpoint filter that fishes the response out of HttpContext.Items. Reading it is a masterclass in integrating with a framework through its narrowest seam. Part 7 of FastEndpoints — The Missing Chapters.
FastEndpoints.HealthChecks is the strangest package in the repository - it never references FastEndpoints. One extension method, an IStartupFilter, an always-healthy self check, and two probes Kubernetes understands. Part 6 of FastEndpoints — The Missing Chapters.
Mappers, validators, processors, even the Resolve<T>() you call in a handler - almost none of it goes through your DI container the way you assume. A static ServiceResolver with two caches sits behind everything, and reading it explains both the speed and the sharp edges. Part 5 of FastEndpoints — The Missing Chapters.
The Config object you lambda into UseFastEndpoints is a thin view over nine process-wide static option singletons - and its properties hide the most useful hooks in the library: endpoint filters, a global configurator, warm-up, serializer swaps and custom value parsers. Part 4 of FastEndpoints — The Missing Chapters.
FastEndpoints ships a CSRF middleware that is opt-in per endpoint, only inspects form posts, and refuses to start your app if you wired it up wrong. It earned a single clause in seventeen parts - here is the whole story. Part 3 of FastEndpoints — The Missing Chapters.
The Send facade is a struct, its methods return a fake Void, and every sender secretly marks the response started before writing a byte. A tour of the response surface the deep dive skipped - files, ranges, redirects, interceptors and all. Part 2 of 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.
A Christmas Day commit on an unfinished feature, three years of unactioned dependabot, a final fix by a stranger - and the estate's real lesson, which is about re-reading rather than writing.
A product whose entire interface is a YAML document, shipped in an image that document cannot enter - plus the resilience inventory of a gateway with retries and nothing else.
CI builds Release, where six extensions compile against NuGet instead of your working tree - and the only thing that notices is a project with no tests in it.
One commit reclaimed a clean package id and deleted the version prefix in the same breath - leaving two identities on the public feed with inverted version ordering and a csproj that cannot build the package it consumes.
A caller-identity feature added at 21:10, disabled at 22:31 and deleted four days later - and the residue is a gateway that carries no caller identity into a message at all.
Of eight JWT keys in the README's flagship example, four bind to nothing, three restate defaults and one has any effect - and the last edit to that README came ten minutes before the commit that invalidated it.
One YAML key turns an HTTP route into a message publisher - and between BasicPublish returning and the gateway writing 202 there is nothing at all.
Nothing in either host references an extension type, so nothing should load one - and the reason six packages are found anyway is a call five steps earlier in a fluent chain.
An int? sorted into a HashSet, no shipped config that sets it, and two middlewares whose relative position determines whether your production failures appear in Jaeger at all.
Two strings and two void methods buy you six shipping packages - and the list of things the interface never asks for is the more instructive half.
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.
The retrospective - configuration stays mutable, ordering stays emergent, one method absorbs every concern, and the only outside contributor correctly chose to duplicate sixteen lines rather than refactor.
Every downstream response is buffered into a UTF-16 string and re-encoded on the way out, so binary bodies corrupt silently behind a plausible status code and a recomputed Content-Length.