Skip to content
ExponaBLOG
Series · Day 100 of 100

.NET & ASP.NET Core

  1. 01
    Why I still choose .NET for backends: a practical guide
    After 5+ years across Node, .NET and Go, here is why .NET keeps winning my backend decisions.
  2. 02
    Minimal APIs: a production-ready setup, explained simply
    Minimal APIs are not just for demos. This is how I structure them for real services.
  3. 03
    Program.cs, line by line: a hands-on guide for engineers
    The file every .NET dev touches — and few can explain fully.
  4. 04
    DI lifetimes: Singleton, Scoped, Transient — a deep dive
    The bug I see most in code reviews is a lifetime mismatch.
  5. 05
    The Options pattern, properly: best practices explained
    Stop reading IConfiguration strings all over your codebase.
  6. 06
    The middleware pipeline: order matters, explained simply
    Most auth and CORS bugs I debug are simply middleware in the wrong order.
  7. 07
    Endpoint filters in minimal APIs: a practical .NET guide
    The minimal API answer to action filters — reusable logic around endpoints.
  8. 08
    Organize minimal APIs with route groups, explained simply
    How I keep 80+ endpoints clean without controllers.
  9. 09
    Validation with FluentValidation: a practical .NET guide
    Data annotations get messy fast. FluentValidation keeps rules readable and testable.
  10. 10
    Global error handling with ProblemDetails for production
    One consistent error format for every failure — the RFC 9457 way.
  11. 11
    Use records for DTOs: a practical guide for developers
    Records make API contracts concise, immutable and comparable.
  12. 12
    EF Core from zero to production: lessons from production
    The setup I use on every new .NET project.
  13. 13
    AsNoTracking: free performance — lessons from production
    Most of your queries do not need change tracking.
  14. 14
    Configuring EF Core relationships in .NET & ASP.NET Core
    One-to-many, many-to-many and owned types without surprises.
  15. 15
    Project to DTOs with Select: a .NET guide for developers
    Fetch the columns you need — not the whole entity graph.
  16. 16
    EF Core migrations in a team: a .NET guide for developers
    Migrations are code. Treat them like code.
  17. 17
    Compiled queries for hot paths: best practices explained
    When a query runs thousands of times per minute, skip the translation step.
  18. 18
    Bulk updates with ExecuteUpdate: lessons from production
    Stop loading 10,000 entities just to change one column.
  19. 19
    Global query filters: a practical guide for developers
    Soft delete and multi-tenancy without touching every query.
  20. 20
    Handling concurrency in EF Core: lessons from production
    Two admins edit the same order. Who wins?
  21. 21
    When I reach for Dapper: real-world lessons and examples
    EF Core is my default. Dapper is my scalpel.
  22. 22
    Clean Architecture: the .NET project layout in practice
    The structure I use for medium-to-large .NET solutions.
  23. 23
    Vertical slice architecture: a .NET guide for developers
    Organize by feature, not by technical layer.
  24. 24
    CQRS with MediatR in practice: best practices explained
    Separate commands from queries without building two databases.
  25. 25
    MediatR pipeline behaviors: .NET lessons from production
    Validation, logging and transactions — written once.
  26. 26
    Result pattern vs exceptions: a .NET guide for developers
    Exceptions for the exceptional. Results for expected failures.
  27. 27
    Domain events in .NET: a practical guide for developers
    Let your domain announce what happened instead of calling everything directly.
  28. 28
    JWT authentication in ASP.NET Core: a step-by-step guide
    The minimal correct setup for a stateless API.
  29. 29
    Refresh token rotation in .NET: best practices explained
    Stay logged in safely without long-lived access tokens.
  30. 30
    Policy-based authorization: .NET lessons from production
    Roles are a start. Policies scale with real business rules.
  31. 31
    Permission-based authorization: best practices explained
    How I implemented fine-grained access control in a CRM.
  32. 32
    ASP.NET Core Identity: when to use it, explained simply
    Build, buy, or Identity? An honest breakdown.
  33. 33
    Built-in rate limiting: a practical guide for developers
    Protect your API with zero extra packages since .NET 7.
  34. 34
    Output caching in ASP.NET Core: best practices explained
    Cache whole responses on the server — with tags you can invalidate.
  35. 35
    HybridCache in .NET 9+: a practical guide for developers
    The cache API we always wanted: L1 memory + L2 distributed + stampede protection.
  36. 36
    Distributed caching with Redis: best practices explained
    The patterns that kept a high-traffic e-commerce API fast.
  37. 37
    Response compression: easy wins — a practical .NET guide
    Smaller payloads, faster APIs — often a two-line change.
  38. 38
    async/await pitfalls in .NET: what developers should know
    Async code that looks right but quietly hurts your API.
  39. 39
    ConfigureAwait(false) in ASP.NET Core: a practical guide
    Do you still need it? Short answer: in app code, no.
  40. 40
    Pass CancellationToken everywhere in .NET & ASP.NET Core
    Users close tabs. Your server should stop working too.
  41. 41
    ValueTask vs Task: what every .NET developer should know
    A performance tool, not a default.
  42. 42
    Use IHttpClientFactory, always: best practices explained
    new HttpClient() in a loop is a production incident waiting to happen.
  43. 43
    Resilience with Microsoft.Extensions.Http.Resilience
    Retries, timeouts and circuit breakers in one line.
  44. 44
    Background services in .NET: what developers should know
    Long-running work without a separate worker project.
  45. 45
    System.Threading.Channels: .NET best practices explained
    A fast in-process queue for producer/consumer work.
  46. 46
    Scheduled jobs: Hangfire vs Quartz in .NET & ASP.NET Core
    Cron in .NET without reinventing it.
  47. 47
    Health checks that mean something in .NET & ASP.NET Core
    A 200 OK from /health does not prove your app works.
  48. 48
    Structured logging with Serilog: lessons from production
    Logs you can query instead of grep.
  49. 49
    Tracing with OpenTelemetry: .NET lessons from production
    See one request across your API, database and message broker.
  50. 50
    OpenAPI in .NET 9+: a practical guide for developers
    Swashbuckle left the template. Here is the new setup.