Hi, I’m Federico Stimpfl.

Output Caching in ASP.NET Core 8 is a lightweight and powerful way to boost performance by reusing full responses that don’t change frequently. Instead of recalculating a view or API response on every request, .NET 8 can store and serve it directly from cache — dramatically reducing CPU, DB, and I/O usage.

When to Use It

Output caching shines for endpoints where the response remains the same for multiple users — such as public pages, product listings, or slow reports. You can safely cache those responses for a short or long period and serve them instantly.

How It Works

.NET 8 introduces a modern middleware-based implementation that replaces the old [ResponseCache] attribute. You simply register it once in Program.cs and use the [OutputCache] attribute wherever needed.

// Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOutputCache();

var app = builder.Build();
app.UseOutputCache();

// Controller or Minimal API endpoint
app.MapGet("/products", async (MyDbContext db) =>
{
    return await db.Products.ToListAsync();
})
.WithName("GetProducts")
.CacheOutput(p => p.Expire(TimeSpan.FromSeconds(60))); // Cached for 1 min

Benefits

• 🔹 Easy to enable — minimal configuration.
• 🔹 Great performance boost for static or semi-dynamic endpoints.
• 🔹 Compatible with distributed caches (e.g., Redis).
• 🔹 Built directly into the ASP.NET Core middleware pipeline.

Real-World Tip

Combine Output Caching with IMemoryCache or IDistributedCache for layered performance. Keep it short-lived (e.g., 30–120 seconds) to ensure the data stays fresh while still reducing load on the DB.

Conclusion

Output Caching in .NET 8 is a simple yet powerful tool for boosting response times without adding infrastructure complexity. In high-traffic apps, it can easily reduce backend load by 50–70% with just a few lines of configuration.

5 min read • Published Nov 10, 2025

With Entity Framework Core 8, developers have more tools than ever to simplify data access while keeping their architecture clean, testable, and maintainable. But using EF efficiently requires discipline — especially in larger applications.

Clean Architecture Context

EF Core works best when separated from your domain logic. Instead of scattering queries inside controllers, move them into repositories or data services that your application layer can consume.

// Example: Generic Repository
public interface IRepository<T> where T : class
{
    Task<T> GetByIdAsync(int id);
    Task<IEnumerable<T>> GetAllAsync();
    Task AddAsync(T entity);
    void Update(T entity);
    void Delete(T entity);
    Task SaveAsync();
}

Common Pitfalls

• Mixing DbContext logic inside controllers.
• Querying too much data (no pagination or filtering).
• Forgetting to track entity states properly.

Recommended Pattern

Keep your DbContext short-lived and scoped per request. Use AsNoTracking() for read-only operations to improve performance.

// Example usage
var users = await _context.Users
    .AsNoTracking()
    .Where(u => u.IsActive)
    .ToListAsync();

Key Takeaway

EF Core 8 is powerful — but only when used cleanly. Separate concerns, use async patterns everywhere, and let EF handle what it does best: tracking and persistence.

4 min read • Published Oct 28, 2025

Modern APIs need to be resilient against network issues, transient errors, and external dependencies. Polly, integrated natively with ASP.NET Core, provides a powerful way to achieve this without cluttering your code.

What Is Polly?

Polly is a fault-handling library that helps you define retry, circuit-breaker, timeout, and fallback policies declaratively.

// Example: Register HttpClient with retry policy
builder.Services.AddHttpClient("WeatherClient")
    .AddTransientHttpErrorPolicy(p =>
        p.WaitAndRetryAsync(3, attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt))));

Circuit Breaker Example

p.CircuitBreakerAsync(
    handledEventsAllowedBeforeBreaking: 5,
    durationOfBreak: TimeSpan.FromSeconds(30)
);

Benefits

• Improved reliability of API-to-API communication.
• Reduced risk of cascading failures.
• Better user experience under transient network issues.

Real-World Use

Combine Polly with centralized logging (like Serilog) to monitor retries and circuit events. You’ll quickly identify unstable dependencies before they become outages.

6 min read • Published Sep 15, 2025

When a 500 appears in production, I follow a simple path:

• Scope the impact – single user, endpoint or system-wide?
• Grab the correlation ID – from X-Correlation-Id or logs.
• Check structured logs – endpoint, exception type, stack trace, key IDs.
• Reproduce safely – same payload in staging/local, aligned config and DB.
• Fix the root cause – unhandled exceptions, EF Core/SQL issues, misconfig, or failing external services.
• Deploy, monitor, document – watch logs/metrics and record cause + fix.

Over time, this turns 500s from panic into a repeatable, calm investigation process.

3 min read • Published Nov 30, 2025

Modern APIs need to be resilient against network issues, transient errors, and external dependencies. Polly, integrated natively with ASP.NET Core, provides a powerful way to achieve this without cluttering your code.

What Is Polly?

Polly is a fault-handling library that helps you define retry, circuit-breaker, timeout, and fallback policies declaratively.

// Example: Register HttpClient with retry policy
builder.Services.AddHttpClient("WeatherClient")
    .AddTransientHttpErrorPolicy(p =>
        p.WaitAndRetryAsync(3, attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt))));

Circuit Breaker Example

p.CircuitBreakerAsync(
    handledEventsAllowedBeforeBreaking: 5,
    durationOfBreak: TimeSpan.FromSeconds(30)
);

Benefits

• Improved reliability of API-to-API communication.
• Reduced risk of cascading failures.
• Better user experience under transient network issues.

Real-World Use

Combine Polly with centralized logging (like Serilog) to monitor retries and circuit events. You’ll quickly identify unstable dependencies before they become outages.

6 min read • Published Sep 15, 2025