NCompas engineers build ASP.NET Core APIs, Semantic Kernel AI agents, ML.NET + ONNX model serving, .NET Aspire cloud-native microservices, and Blazor/.NET MAUI frontends — with ML inference inside the .NET process at sub-millisecond latency, not routed to a Python sidecar.
Why NCompas
Most teams have .NET developers or ML engineers. Rarely both — and almost never engineers who can design the architecture where they work together at production latency.
We don't deliver .NET 6 because it's "LTS". Every new project starts on .NET 9 with C# 13 features — primary constructors, collection expressions, inline arrays, interceptors, and native AOT where the cold-start profile justifies it. Legacy upgrade projects follow a structured migration to the current LTS or STS release.
Separate Python model servers add latency, failure modes, authentication complexity, and operational overhead. We run ML.NET and ONNX Runtime inside the ASP.NET Core process — classification, regression, NER, anomaly detection — at sub-millisecond inference. When Python is genuinely needed (PyTorch training), the trained model is exported to ONNX and served from .NET.
Semantic Kernel is Microsoft's official .NET AI SDK — and NCompas engineers are among its earliest enterprise adopters. We've built Semantic Kernel RAG pipelines, multi-step planners, function-calling plugins, and Copilot extensions across financial services, healthcare, and manufacturing — not experimental PoCs, but production systems handling real load.
.NET applications written in 2010 are still running in production today — often as a liability. We design for the 10-year horizon: clean architecture with bounded contexts, CQRS where the write/read model complexity justifies it, proper abstractions that make the next version of .NET an upgrade rather than a rewrite. No clever tricks that future engineers can't understand.
Model accuracy on the training set is the starting line, not the finish line. We build Azure ML pipelines that handle retraining schedules, evaluation gates, model registry versioning, canary deployment, and drift detection — so ML models stay accurate as production data distribution shifts. ML engineering, not just ML development.
The strangler fig pattern for .NET Framework → .NET 9 migration: new capability in .NET 9, legacy endpoints facade-wrapped in ASP.NET Core, traffic routing at the reverse proxy layer. Teams stay productive throughout. No multi-year dark room rewrite that ships nothing to users. This is how you modernise without the big-bang risk.
Six .NET & ML capability domains
Six interconnected practices from high-performance APIs through AI-integrated .NET to production ML pipelines — designed to run together, not in isolated silos.
High-performance APIs built on .NET 9's minimal API pattern or traditional controller-based architecture — whichever fits the team and product shape. Native AOT compilation for cold-start-sensitive workloads, built-in OpenTelemetry, HybridCache for L1/L2 cache strategies, and full integration with Azure API Management. We write C# 13 from day one: primary constructors, collection expressions, interceptors, and source generators for zero-overhead serialisation.
High-performance APIs built on .NET 9's minimal API pattern or traditional controller-based architecture — whichever fits the team and product shape. Native AOT compilation for cold-start-sensitive workloads, built-in OpenTelemetry, HybridCache for L1/L2 cache strategies, and full integration with Azure API Management. We write C# 13 from day one: primary constructors, collection expressions, interceptors, and source generators for zero-overhead serialisation.
Semantic Kernel is Microsoft's official .NET SDK for building AI-powered applications — providing plugins, planners, memory, and RAG pipelines that connect Azure OpenAI (GPT-4o, o3) to your .NET business logic. We build AI agents, document processing pipelines, enterprise copilots, and LLM-orchestrated workflows directly in C# — no Python wrapper, no separate microservice, full type safety across the entire AI call chain.
.NET Aspire is Microsoft's opinionated cloud-native application framework — bringing service discovery, health checks, distributed tracing, and local development orchestration into the .NET project model. We architect microservice solutions with .NET Aspire + Azure Container Apps + AKS, using gRPC for internal service communication, Azure Service Bus for event-driven patterns, and Dapr for portable microservice building blocks.
Blazor Render Modes in .NET 9 — Static SSR, Interactive Server, Interactive WebAssembly, and Auto — let a single Razor component codebase deliver the right rendering strategy for each route. .NET MAUI delivers native iOS, Android, macOS, and Windows applications from a single C# project. Both approaches mean one language, one framework, one team — no JavaScript required for C# shops that want rich UI.
ML.NET brings machine learning inside the .NET process — classification, regression, anomaly detection, time-series forecasting, recommendation, object detection, and text classification — all running in C# with sub-millisecond inference. For models trained elsewhere (Python, Azure ML), ONNX Runtime provides the same in-process inference. MLOps pipelines in Azure ML handle training, evaluation, versioning, A/B deployment, and drift monitoring.
Building production-grade RAG systems, multi-agent workflows, and LLM-orchestrated business processes in .NET: chunking and embedding pipelines for enterprise document corpora, vector stores (Azure AI Search, Qdrant, pgvector via EF Core), retrieval-augmented generation with citation grounding, and multi-step AI agents using Semantic Kernel's agent framework. Evaluation harnesses to measure retrieval accuracy, answer relevance, and groundedness at scale.
.NET full-stack architecture
Every layer of the .NET + ML stack designed to work together — shared domain models, consistent telemetry, and ML inference running in-process rather than across network boundaries.
Delivery approach
Five stages from architecture review through to production ML pipelines — structured so ML model integration doesn't block API delivery, and vice versa.
Week 1: if modernising legacy, we map the existing .NET Framework surface area — WCF services, Web Forms, synchronous patterns, framework-specific APIs — and identify migration complexity, strangler-fig seam candidates, and the upgrade path to .NET 9. For greenfield, we define the bounded contexts, API patterns, and AI integration points before code is written.
Week 1–2: domain model with value objects, aggregates, and domain events. gRPC Protobuf contracts for internal services. OpenAPI schemas for external APIs generated from .NET source code, not maintained separately. Database schema with EF Core migrations. Semantic Kernel plugin contracts for AI-integrated capabilities.
Weeks 2–8: ASP.NET Core API development, Semantic Kernel plugin implementation, ML.NET model integration, Blazor or MAUI UI development where in scope. .NET Aspire local development environment for all services. Test-first where domain complexity warrants it — not cargo-cult TDD for CRUD, genuine TDD for business-rule-heavy code.
Weeks 4–10: Azure ML training pipeline, model evaluation gates, registry versioning, and canary deployment wired to ASP.NET Core feature flags. ONNX export from Python training (where applicable) and ONNX Runtime integration in the .NET process. A/B testing framework for comparing model versions on production traffic without full traffic commitment.
Final 2 weeks: load testing (k6 + Azure Load Testing), Native AOT build evaluation, HybridCache tuning, OpenTelemetry dashboard configuration, Azure API Management policy setup, and GitHub Actions CD pipeline with deployment gates. Penetration testing for public APIs. Documentation delivered as living OpenAPI spec and Architecture Decision Records — not Word documents that go stale.
Client outcomes
Four organisations where .NET performance, in-process ML inference, and Semantic Kernel AI integration delivered measurable business results — not proof-of-concept demos.
The Challenge
UK Tier-1 bank with a 14-year-old .NET Framework 4.6 trading platform processing £3.8B in daily transactions — 23 CRUD-heavy WCF services, no observability, 4-week deployment cycles, and a regulatory requirement to modernise the authentication stack to meet PSD2 open banking mandates within 18 months.
What We Delivered
.NET 9 migration programme: strangler-fig pattern wrapping legacy WCF services with ASP.NET Core facades, gRPC contracts between microservices, Azure Service Bus replacing synchronous inter-service calls, .NET Aspire for local development, full OpenTelemetry tracing to Azure Monitor, and Semantic Kernel AI agent for real-time fraud pattern analysis running inside the transaction pipeline at < 2ms added latency.
UK Tier-1 bank with a 14-year-old .NET Framework 4.6 trading platform processing £3.8B in daily transactions — 23 CRUD-heavy WCF services, no observability, 4-week deployment cycles, and a regulatory requirement to modernise the authentication stack to meet PSD2 open banking mandates within 18 months.
NHS diagnostics provider needing to process radiology report text (120,000 reports/month) to extract structured findings for a national clinical database — previously 4 FTE clinical coders doing manual extraction, with a 6-week backlog building during COVID surges. Required HL7 FHIR compliance and NHS Spine integration.
Multi-channel retailer with a .NET monolith handling 2.8M daily API calls — single-database architecture collapsing under Black Friday load (200× baseline), 2-second average product search latency, and a 15-engineer team unable to deploy independently due to shared deployment pipeline. Product recommendation engine was a batch-updated static rules file.
Automotive parts manufacturer with 14 production lines generating 2.4 million sensor readings per hour — a .NET Framework Windows service batch-processing data every 15 minutes, missing anomalies that led to £280K/year in downstream scrap and warranty claims. No real-time alerting, no ML-based predictive maintenance.
ranks #1 in TechEmpower plaintext and Fortune benchmarks — faster than Go's Gin, faster than Node.js, faster than Java Spring Boot on the same hardware. Performance is no longer the reason to choose another stack over .NET.
ML.NET + ONNX Runtime classification inference running inside ASP.NET Core — eliminating the network round-trip to a Python model server and cutting per-request AI latency by 8–25ms on typical enterprise classification workloads.
reduction in cloud-native .NET bootstrap time with .NET Aspire — service discovery, health checks, distributed tracing, and local orchestration configured out of the box without manual YAML files or Docker Compose complexity.
monthly downloads for ML.NET and Semantic Kernel combined — confirming that .NET AI is a production-grade ecosystem, not an experimental side project, with real enterprise workloads running on both libraries at scale.
Insights from real-world engineering, cloud, and AI leaders - helping you make better decisions, faster.
We're putting the finishing touches on this. Check back soon for in-depth insights.
Start with a free .NET Architecture Review — we'll assess your current stack, identify performance and ML integration opportunities, and map a roadmap from where you are to where .NET 9 and Semantic Kernel can take you.