Published:
This post covers observability in .NET using traces, metrics, logs, and OpenTelemetry. Logging tells you what happened. Observability helps you understand how a system behaves across services, dependencies, and time.
Published:
This post covers the outbox pattern, one of the most important patterns for reliable messaging. The problem is simple: your application needs to save data and publish a message, but the database and message broker do not share one transaction. The outbox pattern solves this by storing messages in the database first and publishing them later.
Published:
This post covers the basics of messaging and event-driven design in .NET. When systems grow, not every operation should be a direct HTTP call. Messaging lets services communicate through commands, events, queues, topics, and streams so work can happen asynchronously and systems can be less tightly coupled.
Published:
This post covers practical domain modeling in .NET using aggregates, value objects, and invariants. The goal is not to turn every app into a textbook DDD system. The goal is to put important business rules in places where they are hard to bypass.
Published:
This post compares two popular ways to structure .NET applications: Clean Architecture and Vertical Slice Architecture. Both can produce maintainable systems, and both can become over-engineered if applied mechanically. The useful question is not “which one is best?” The useful question is “which structure reduces change friction for this codebase?”
Published:
This post covers how .NET applications should call external services safely using HttpClientFactory, timeouts, retries, and resilience policies. Distributed systems fail in ordinary ways: networks pause, DNS changes, services restart, and dependencies return temporary errors. Resilience design assumes those failures will happen.
Published:
This post covers how to document ASP.NET Core APIs using OpenAPI, Swagger UI, examples, and version-aware contracts. Good API documentation is not decoration. It is how frontend developers, mobile teams, integration partners, and future maintainers understand what your API promises.
Published:
This post covers the main caching options in .NET applications: in-memory cache, distributed cache, Redis, and HTTP response caching. Caching can reduce latency and database load, but it also introduces correctness questions. The hard part is not storing data. The hard part is knowing when cached data is valid.
Published:
This post covers the background processing options built into modern .NET applications. Web APIs handle request/response work, but real systems also need jobs that run outside a single HTTP request: queue consumers, scheduled cleanup, report generation, synchronization, and long-running workers.
Published:
This post covers the two testing layers most .NET teams rely on heavily: unit tests with xUnit and integration tests with WebApplicationFactory. Unit tests give you fast feedback on isolated logic. Integration tests prove that your application actually boots, routes requests, resolves dependencies, and returns the expected HTTP responses.