Innovative Use Cases for .NET in Cloud-Native Applications

"Cloud-native" usually conjures Kubernetes, service meshes, and a dozen YAML files. That framing buries the more practical question for most .NET teams: which cloud-native patterns are actually worth adopting, and which require infrastructure you don't have? .NET 10 LTS shipped meaningful cloud-native upgrades — Native AOT for tiny container images, first-class OpenTelemetry, Dapr integration — but the high-ROI patterns for most teams aren't the bleeding edge. They're the ones you can deploy this quarter on hosting you already have.

This is the use-case map we work from when sizing .NET cloud-native projects, with eight patterns ranked by deployability and which Adaptive plan tier fits each. Honest about where Adaptive's managed Windows hosting fits — and where you genuinely need container orchestration we don't provide.

.NET 10LTS — current for

5/8Deploy on managed Windows

$9.49+Starting plan

The deployability spectrum

Pattern works on managed Windows hosting + IIS + SQL Server. No additional infrastructure required.

🟡 Hybrid

App layer fits AWH; specific cloud-native primitives (queues, edge functions) live on a partner cloud.

🔴 Kubernetes-native

Requires container orchestration. Not in scope for managed Windows hosting — consider AKS, EKS, or GKE.

Quick reference: the eight patterns

• Cloud-Deployed ASP.NET Core APIs (the foundation)

Every other cloud-native pattern builds on a well-architected API. .NET 10 LTS ships meaningful upgrades — source-generated JSON serializers, faster Minimal APIs, hot reload in production-like environments — that compound over the application's lifetime.

The architecture pattern that scales gracefully:

// Program.cs — production-grade Minimal API baseline

var builder = WebApplication.CreateBuilder(args);

// Observability from day one

builder.Services.AddOpenTelemetry()

.WithMetrics(m => m.AddPrometheusExporter().AddAspNetCoreInstrumentation())

.WithTracing(t => t.AddOtlpExporter().AddSqlClientInstrumentation());

// Health checks for any orchestrator

builder.Services.AddHealthChecks()

.AddSqlServer(builder.Configuration.GetConnectionString("Default")!)

.AddDbContextCheck<AppDbContext>();

// Versioned, rate-limited, OpenAPI-documented endpoints

builder.Services.AddApiVersioning(o => o.ApiVersionReader = new HeaderApiVersionReader("X-Api-Version"));

builder.Services.AddRateLimiter(o => o.AddFixedWindowLimiter("default", w => { w.PermitLimit = 100; w.Window = TimeSpan.FromMinutes(1); }));

builder.Services.AddOpenApi();

var app = builder.Build();

app.MapHealthChecks("/health");

app.MapPrometheusScrapingEndpoint();

app.MapOpenApi();

The result fits any deployment target: Adaptive's managed Windows hosting, a Linux container in AKS, an AWS App Runner instance. Same code. For the security baseline that should ship alongside it, see our 10 ASP.NET Core API security strategies.

• Background Workers + Scheduled Jobs

Every cloud-native system needs work that doesn't fit the synchronous request/response shape: nightly aggregation, report generation, webhook retry queues, data syncs. The cloud-native way: a long-running IHostedService hosted alongside the API.

public class WebhookRetryWorker : BackgroundService

{

private readonly IWebhookQueue _queue;

private readonly ILogger<WebhookRetryWorker> _log;

protected override async Task ExecuteAsync(CancellationToken stoppingToken)

{

while (!stoppingToken.IsCancellationRequested)

{

try

{

var batch = await _queue.PopPendingAsync(50, stoppingToken);

if (batch.Count == 0)

{

await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);

continue;

}

await Parallel.ForEachAsync(batch, stoppingToken, async (wh, ct) =>

{

try { await DeliverAsync(wh, ct); await _queue.MarkDeliveredAsync(wh.Id); }

catch (Exception ex) { await _queue.IncrementAttemptAsync(wh.Id, ex.Message); }

});

}

catch (Exception ex) { _log.LogError(ex, "Worker tick failed"); await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken); }

}

}

}

// In Program.cs

builder.Services.AddSingleton<IWebhookQueue, SqlWebhookQueue>();

builder.Services.AddHostedService<WebhookRetryWorker>();

The Plesk control panel on every Adaptive plan ships a Windows Task Scheduler integration if you prefer cron-style triggers over a long-lived worker. Either pattern works — long-lived BackgroundService is more cloud-native; scheduled tasks are simpler when the work is genuinely periodic.

• Real-Time SignalR Fan-Out

Live trade tickers, IoT dashboards, multi-user collaboration, customer-support queue boards. SignalR is the .NET cloud-native answer to WebSockets — server push with automatic reconnection, transport negotiation, and connection management.

public class MarketHub : Hub

{

public async Task SubscribeToSymbol(string symbol)

{

await Groups.AddToGroupAsync(Context.ConnectionId, $"sym:{symbol}");

}

}

// Backend service pushes updates as they arrive

public class MarketDataPublisher : BackgroundService

{

private readonly IHubContext<MarketHub> _hub;

protected override async Task ExecuteAsync(CancellationToken ct)

{

await foreach (var tick in _exchangeStream.WithCancellation(ct))

{

await _hub.Clients.Group($"sym:{tick.Symbol}").SendAsync("Tick", tick, ct);

}

}

}

For multi-instance setups, swap the default backplane for Azure SignalR Service or a Redis backplane. Single-instance setups run beautifully on a single AWH app pool — for the connection-budget math, our Blazor Server RAM sizing guide applies (the SignalR memory model is similar). If your SignalR connections drop unexpectedly, see the SignalR connection-dropping diagnostic.

• CDN-Fronted API + Edge Caching

For most B2B APIs, putting a Cloudflare or Fastly tier in front of your origin gets you 70% of the cloud-native benefit (global edge presence, DDoS protection, sub-50ms response for cached GETs) with zero K8s YAML.

// Output caching — built into .NET 7+, faster path than ResponseCaching

builder.Services.AddOutputCache(o =>

{

o.AddPolicy("Public30s", b => b.Expire(TimeSpan.FromSeconds(30)).VaryByQuery("page", "size"));

});

app.UseOutputCache();

app.MapGet("/api/products", GetProducts).CacheOutput("Public30s");

// Response compression — Cloudflare can do this at the edge,

// but defense in depth doesn't hurt for direct hits.

builder.Services.AddResponseCompression();

app.UseResponseCompression();

Combined with proper Cache-Control and ETag headers, the edge tier serves the vast majority of read traffic. Origin sees only writes and cache misses — much smaller load profile than naive deployments.

• Embedded ML.NET Inference

The most overlooked cloud-native .NET pattern: don't call a separate ML serving cluster. Embed the model directly in your API process. ML.NET + ONNX runtime can load PyTorch and scikit-learn models and run inference in-process with single-millisecond latency.

// Load an ONNX model exported from PyTorch or scikit-learn

public class FraudDetectionService

{

private readonly InferenceSession _session;

public FraudDetectionService(IConfiguration config)

{

_session = new InferenceSession(config["Models:FraudDetectionPath"]!);

}

public float ScoreTransaction(TransactionFeatures features)

{

using var input = OrtValue.CreateTensorValueFromMemory(features.ToTensor(), new long[] { 1, 32 });

var inputs = new Dictionary<string, OrtValue> { ["input"] = input };

using var results = _session.Run(new RunOptions(), inputs, _session.OutputNames);

return results[0].GetTensorDataAsSpan<float>()[0];

}

}

builder.Services.AddSingleton<FraudDetectionService>();

No separate model-serving deployment, no network hop, no inter-service auth. Pre-trained models load in milliseconds on .NET 10 LTS; inference is faster than the SQL query you're enriching. Runs on any ASP.NET Core hosting tier — though Professional ($27.49) is sized right for the extra RAM overhead.

• Event-Driven with Message Queues (Hybrid)

.NET applications running on Adaptive can produce and consume messages on a managed broker (Azure Service Bus, AWS SQS, RabbitMQ on Confluent Cloud) — the broker just lives elsewhere. Adaptive doesn't host the broker itself, but the .NET consumer code runs perfectly on managed Windows hosting.

// MassTransit abstracts the broker — same code for RabbitMQ, Azure SB, AWS SQS

builder.Services.AddMassTransit(x =>

{

x.AddConsumer<OrderPlacedConsumer>();

x.UsingAzureServiceBus((ctx, cfg) =>

{

cfg.Host(builder.Configuration["ServiceBus:ConnectionString"]);

cfg.ReceiveEndpoint("orders.placed", e => e.ConfigureConsumer<OrderPlacedConsumer>(ctx));

});

});

// Producer

public class OrderService(IPublishEndpoint bus, AppDbContext db)

{

public async Task PlaceOrderAsync(CreateOrderRequest req)

{

var order = await db.Orders.AddAsync(req.ToEntity());

await db.SaveChangesAsync();

await bus.Publish(new OrderPlaced(order.Entity.Id, order.Entity.Total));

}

}

.NET 10 LTS Native AOT compiles consumer services into 15–25 MB self-contained binaries with sub-second cold starts — meaningful if you scale consumer count up and down on a serverless or container platform.

• Serverless Event Processors (Hybrid)

Azure Functions, AWS Lambda, Google Cloud Run — .NET 10 LTS is well-supported on all three. The isolated runtime separates Function code from host code, enabling faster cold starts and per-function dependency isolation.

Bursty, infrequent triggers (S3 uploads → resize image, daily 3am report) where paying per-invocation beats running an always-on app pool. Pair with Adaptive-hosted persistent APIs for the long-running portion of the architecture — different problems, different tools.

• Service Mesh with mTLS + Distributed Tracing (Kubernetes)

A full service mesh (Istio, Linkerd, Consul Connect) requires Kubernetes. We don't host K8s — for that, AKS, EKS, or GKE are the right targets. We mention it because it's where many .NET teams end up after outgrowing single-instance patterns, and it's useful to know what's on the other side.

The benefits the mesh provides — mTLS between services, distributed tracing, traffic shifting for canary deploys, circuit breakers — can be approximated in simpler architectures. .NET 10's first-class OpenTelemetry support means tracing works regardless of mesh; mTLS can be established between APIs without a mesh; circuit breakers ship in Polly. If you're not at the scale where the mesh's complexity pays for itself, you don't need it yet.

Three architectures, side-by-side

~$30/mo

ASP.NET Business plan + Cloudflare free tier + Azure Service Bus Standard. Handles ~1M req/day comfortably.

API + worker on AWH

SQL Server 2022 included

Edge cache via Cloudflare

Queue on Azure SB

Most teams

Multi-Region · AWH + Edge

~$80/mo

ASP.NET Professional + Cloudflare Pro + read-replica in second region. Handles ~10M req/day with sub-100ms global P95.

Origin failover via DNS

Edge functions for personalization

Read-only SQL replica

SignalR backplane on Redis

K8s · AKS / EKS

$500+/mo

Full container orchestration. Right answer when you have 5+ services with independent scaling, polyglot stacks, or mesh-level requirements.

Istio / Linkerd mesh

Horizontal pod autoscaling

Argo CD GitOps

Distributed tracing native

What Adaptive provides for cloud-deployed .NET

NeedWhat's Included

Real cloud infrastructureAWS US-East data center, 99.99% uptime SLA

Modern .NET runtimes.NET 8 LTS, .NET 10 LTS, plus older versions for legacy apps

Isolated workloadsDedicated IIS Application Pools per site (1–4 GB RAM by tier)

DatabaseReal SQL Server 2022 — Always Encrypted, ledger tables, Query Store

Edge securityWAF + DDoS protection on every plan

TLSFREE SSL on every site, TLS 1.3, post-quantum-ready on .NET 10 LTS

Background jobsPlesk task scheduler (cron-style) + IHostedService support

ObservabilityOpenTelemetry-friendly — point any exporter at your chosen backend

What we don't hostKubernetes, container orchestration, message brokers — bring your own (Azure SB, AWS SQS, RabbitMQ)

Frequently Asked Questions

Do I need Kubernetes to be "cloud-native"?

No. "Cloud-native" is a set of patterns — observability-first design, health checks, configuration externalization, graceful shutdown, horizontal scalability — not a specific platform. A well-architected ASP.NET Core API on Adaptive's managed Windows hosting can be more cloud-native than a sloppily deployed Kubernetes pod with no health checks.

What's the biggest .NET 10 LTS cloud-native win?

For most teams: Native AOT image size. A typical .NET 8 LTS API container is 150–200 MB; the .NET 10 LTS AOT equivalent is 15–25 MB. Cold start drops from 800 ms to under 100 ms. If you're paying per-second on Lambda or Azure Container Apps, that's real money. For the full .NET 10 LTS picture, see our .NET 10 vs .NET 8 LTS comparison.

Can I run microservices on Adaptive's plans?

Yes — up to a point. The ASP.NET Professional plan ($27.49/mo) supports 10 sites, which maps cleanly to 10 microservices on the same hardware with isolated IIS Application Pools. Past that, you're better served by a container platform. Most B2B teams comfortably run 3–8 microservices on Professional for years before needing K8s.

How does AWS Lambda compare to ASP.NET Core background workers on AWH?

Different tools, different jobs. Lambda is right for bursty, infrequent triggers (S3 uploads, scheduled aggregation) where paying per-invocation beats always-on cost. Background workers on AWH are right for continuous work (queue draining, real-time processing, long-running data sync) where Lambda's per-invocation cost would exceed always-on hosting. Many teams use both — for the high-leverage durable work, AWH; for the spiky event-driven work, Lambda.

What about edge functions like Cloudflare Workers?

Excellent complement to AWH-hosted APIs. Cloudflare Workers handles request normalization, A/B routing, header rewriting, geographic personalization — all the things that should live at the edge. Your AWH origin handles the auth-walled, database-bound business logic. Two-tier architecture, low operational complexity.

Does ML.NET embedded inference scale well?

For most model sizes (under ~100 MB), yes. ONNX runtime is highly optimized and shares the model across all requests in the process. Inference is single-millisecond for typical tabular models, single-digit milliseconds for small neural nets. The ceiling: very large LLM-class models (multi-GB) don't fit in a single application pool's RAM and need dedicated serving infrastructure. For everything else, embedded is the simpler architecture.

How do I run distributed tracing across AWH + serverless?

OpenTelemetry. .NET 10 LTS ships first-class OTel support; configure both the AWH-hosted API and your Lambda/Azure Function with the same OTLP collector endpoint, and traces span the boundary automatically. Datadog, Honeycomb, Grafana Tempo, and Application Insights all accept OTLP — pick one and point everything at it.

What's the right starter plan for a cloud-deployed .NET API?

For most teams, ASP.NET Business ($17.49/mo): 2 GB RAM, real SQL Server 2022, dedicated IIS Application Pool, WAF + DDoS protection. Move to Professional ($27.49) when you cross multiple services or 200 GB storage. Start small — every plan ships with a 30-day money-back guarantee.

Bottom line

Cloud-native .NET in 2026 is a wider tent than the Kubernetes-everywhere narrative suggests. Of the eight patterns above, five run on managed Windows hosting with no additional infrastructure; two are hybrid (app on AWH, broker / functions on a cloud partner); one truly requires container orchestration. For most B2B .NET teams, the high-leverage cloud-native moves are observability, health checks, edge caching, and embedded inference — all deployable today on existing hosting.

On Adaptive Web Hosting, the cloud-native primitives — modern .NET runtimes, real SQL Server 2022, dedicated IIS Application Pools, WAF + DDoS, FREE SSL, and post-quantum-ready TLS on .NET 10 LTS — are included on every tier. ASP.NET Developer ($9.49/mo) for development and smaller APIs, ASP.NET Business ($17.49/mo) for production services, ASP.NET Professional ($27.49/mo) for agencies running multiple microservices. Every plan ships with a 30-day money-back guarantee.

If you're scoping the API layer, see our ASP.NET Core API security best practices. If you're using Blazor for the customer-facing layer, our enterprise Blazor use cases covers the patterns. If you're still on .NET Framework, the ASP.NET 4.8 → .NET 10 LTS migration guide walks through getting onto the modern baseline. View all plans or talk to an engineer about a specific architecture.