Santosh Kumar Singh

Santosh Kumar Singh

Principal Software Engineer with 17+ years of experience architecting scalable systems and leading high-performing engineering teams. I specialize in translating complex business requirements into robust, maintainable software solutions that drive measurable impact.

Blog posts

2026

Engineering AI Agents in .NET: Agent Framework, MCP Tools, Evaluation, and Guardrails

6 minute read

Published:

AI agents combine a model with instructions, tools, state, and an execution loop. Microsoft Agent Framework provides agent and workflow abstractions for .NET, while the Model Context Protocol standardizes how an AI host discovers and invokes external tools and data sources. These technologies evolve quickly, so production adoption should pin tested package versions, isolate preview APIs, and place deterministic controls around every side effect.

Building AI Features in .NET: Microsoft.Extensions.AI, Chat, Embeddings, RAG, and Telemetry

5 minute read

Published:

Microsoft.Extensions.AI provides common .NET abstractions for generative AI services. IChatClient represents chat and streaming interactions, while IEmbeddingGenerator represents embedding generation. The abstractions support familiar dependency injection and middleware patterns for telemetry, caching, function invocation, and testing. They let application code depend on capabilities instead of spreading one provider’s SDK types through every layer.

Aspire for Distributed .NET Apps: AppHost, Service Discovery, Telemetry, and Kubernetes Deployment

5 minute read

Published:

Aspire is a code-first orchestration and observability layer for distributed applications. It lets a team describe APIs, workers, databases, caches, queues, containers, and their relationships in one AppHost. During development, the same model starts the system, supplies connection information, and exposes logs and traces through a dashboard. The application services remain ordinary .NET projects and can still be deployed through established platform pipelines.

Native AOT for ASP.NET Core APIs: Trimming, Source Generation, Containers, and Trade-offs

5 minute read

Published:

Native Ahead-of-Time compilation publishes a .NET application as a platform-specific native executable. For suitable ASP.NET Core APIs, it can reduce startup time, memory use, and deployment size. Those benefits come with constraints: runtime code generation and unbounded reflection do not fit the model, some ASP.NET Core features are unsupported, and every dependency must be compatible with trimming and AOT analysis.

Modern Resilience in .NET: Resilience Pipelines, Standard HTTP Handlers, Hedging, and Telemetry

5 minute read

Published:

The modern .NET resilience stack is built around Microsoft.Extensions.Resilience and Microsoft.Extensions.Http.Resilience, both powered by Polly. These packages replace older integrations that attached individual Polly policies to HttpClient. The newer model composes strategies into observable pipelines with safer defaults for timeouts, retries, circuit breakers, and hedging.

Modern Caching in .NET: HybridCache, Output Caching, Stampede Protection, and Invalidation

5 minute read

Published:

Modern .NET applications can use HybridCache to coordinate in-process and distributed caching through one API. It adds stampede protection, configurable serialization, and tag-based invalidation while retaining the low latency of a local cache. ASP.NET Core output caching solves a different problem by caching complete HTTP responses. A production design should choose the right layer, define acceptable staleness, and make invalidation observable.

EF Core 10 Advanced Data Patterns: Named Query Filters, JSON, Complex Types, and Vector Search

5 minute read

Published:

EF Core 10 is an LTS data-access release aligned with .NET 10. It extends familiar relational modeling with named query filters, richer complex types and JSON support, and vector operations for AI-assisted search. These capabilities are useful when they make domain and query intent clearer. They do not remove the need to inspect generated SQL, design indexes, and test migrations against production-sized data.

Modern ASP.NET Core 10 APIs: OpenAPI 3.1, Validation, ProblemDetails, and Server-Sent Events

5 minute read

Published:

ASP.NET Core 10 modernizes several API fundamentals that previously required more third-party setup. Built-in OpenAPI generation produces OpenAPI 3.1 documents, Minimal APIs can validate inputs automatically, ProblemDetails can shape consistent failures, and Server-Sent Events provide a simple option for one-way real-time updates. These features work best when they are treated as parts of one stable API contract.

Upgrading from .NET 8 to .NET 10 LTS: C# 14, Breaking Changes, and a Safe Migration Plan

5 minute read

Published:

.NET 10 is the current Long Term Support release, while .NET 8 reaches the end of support in November 2026. An upgrade should be treated as an engineering change, not a search-and-replace operation. The safest approach separates framework migration, package updates, language adoption, and production rollout so that each source of risk can be verified independently.

Building Production-Ready .NET Systems: A Practical Roadmap

5 minute read

Published:

The previous articles built the individual skills needed for modern .NET services: APIs, data access, testing, security, messaging, observability, performance, deployment, and maintainable architecture. Production readiness is where those capabilities become one operating system for the application. A service is not production-ready because it runs in a container. It is ready when the team can deploy it safely, detect failure quickly, protect its data, and restore normal service predictably.