Top 10 system design use cases in .NET

22.1 Flash-sale order & inventory without overselling Added

Thousands of people press "Buy" in the same second for a few thousand items. Take the stock in one atomic step, answer fast, and do the slow work (payment, order rows) in the background.

Problem statement

A retailer (or a bank's rewards store) sells 5,000 limited items at 12:00 sharp. About 200,000 shoppers arrive in the first minute. A normal "read stock, then write stock" flow sells the same last item to many people, and the database melts under the spike.

Constraints & assumptions: one Azure region; SQL Server holds the real stock and orders; Redis is available; the payment provider is external and slow (1–3 s); the sale time is known in advance, so you can pre-scale.

Solution

Steps to implement in .NET 10

1. Set up: dotnet new webapi (minimal APIs) plus an Aspire 13 AppHost with Aspire.Hosting.Redis, Aspire.Hosting.SqlServer and Aspire.Hosting.Azure.ServiceBus, so Redis, SQL and the Service Bus emulator start locally with one command.
2. Model: EF Core 10 (Microsoft.EntityFrameworkCore.SqlServer) with Product (Id, Stock, [Timestamp] byte[] RowVersion), Order (PK = orderId) and an outbox table. RowVersion makes admin edits (price, stock top-ups) fail with DbUpdateConcurrencyException instead of silently overwriting.
3. Load stock into Redis before the sale: StringSetAsync("stock:{sku}", 5000) with StackExchange.Redis.
4. Reserve endpoint: run the Lua script with IDatabase.ScriptEvaluateAsync (core trick 1). It also adds the order to a sorted set scored by its expiry time, so the sweeper can find unpaid reservations.
5. Idempotency: require an Idempotency-Key header (an IETF draft name, widely used). Check it inside the same Lua script, so "seen before?" and "take stock" can't race.
6. Publish OrderReserved with Azure.Messaging.ServiceBus. Set MessageId = orderId and turn on duplicate detection on the queue.
7. Order worker: a BackgroundService with ServiceBusProcessor writes the order using the SQL guard (core trick 2), in one transaction with the outbox row.
8. Admission control: built-in Microsoft.AspNetCore.RateLimiting (AddRateLimiter, token bucket per client, 429 + Retry-After), plus Azure Front Door WAF rate rules at the edge.
9. Release expired reservations: a BackgroundService using new PeriodicTimer(TimeSpan.FromSeconds(15), timeProvider) reads expired entries (SortedSetRangeByScoreAsync up to "now"), returns their stock and removes them. Inject TimeProvider so tests can fake time.
10. Deploy & observe: Azure Container Apps with min replicas raised before the sale, Azure Managed Redis, Azure.Monitor.OpenTelemetry.AspNetCore for traces and metrics (reserved, sold out, released). Run the load test a day before.

Core trick 1: atomic reserve + idempotency in one Lua script

const string ReserveLua = """
    -- KEYS: 1 stock, 2 customer count, 3 idempotency key, 4 reservations (sorted set)
    if redis.call('EXISTS', KEYS[3]) == 1 then return -2 end            -- seen before
    local qty, limit = tonumber(ARGV[1]), tonumber(ARGV[2])
    local stock = tonumber(redis.call('GET', KEYS[1]) or '0')
    if stock < qty then return -1 end                                     -- sold out
    if tonumber(redis.call('GET', KEYS[2]) or '0') + qty > limit then return -3 end
    redis.call('DECRBY', KEYS[1], qty)
    redis.call('INCRBY', KEYS[2], qty)
    redis.call('SET', KEYS[3], ARGV[3], 'EX', 86400)                      -- remember orderId 24 h
    redis.call('ZADD', KEYS[4], ARGV[4], ARGV[3])                        -- score = expiry time
    return stock - qty
    """;

var tag = "{sku-123}";            // hash tag: all keys land on the same cluster slot
var left = (long)await db.ScriptEvaluateAsync(ReserveLua,
    [$"stock:{tag}", $"cust:{tag}:{customerId}", $"idem:{tag}:{idemKey}", $"resv:{tag}"],
    [qty, 2, orderId.ToString(), clock.GetUtcNow().AddMinutes(10).ToUnixTimeSeconds()]);
return left switch
{
    -1 => Results.Conflict("Sold out"),
    -2 => Results.Accepted($"/orders/{await db.StringGetAsync($"idem:{tag}:{idemKey}")}"),
    -3 => Results.UnprocessableEntity("Limit is 2 per customer"),
    _  => Results.Accepted($"/orders/{orderId}")
};

Core trick 2: the SQL guard in the worker (EF Core ExecuteUpdateAsync)

await using var tx = await db.Database.BeginTransactionAsync(ct);
if (await db.Orders.AnyAsync(o => o.Id == msg.OrderId, ct)) return;       // redelivered message

var rows = await db.Products
    .Where(p => p.Id == msg.ProductId && p.Stock >= msg.Qty)              // final guard
    .ExecuteUpdateAsync(s => s.SetProperty(p => p.Stock, p => p.Stock - msg.Qty), ct);

if (rows == 0)                                                           // Redis and SQL disagreed
{
    await tx.RollbackAsync(ct);
    await ReleaseInRedisAsync(msg, ct);
    return;
}
db.Orders.Add(Order.AwaitingPayment(msg.OrderId, msg.CustomerId, msg.ProductId, msg.Qty));
await db.SaveChangesAsync(ct);                                           // order + outbox row together
await tx.CommitAsync(ct);

Testing scenarios

Sample test: no overselling under concurrency (the factory starts new RedisBuilder("redis:7.4").Build() and points the app at it)

public sealed class FlashSaleTests(SaleApiFactory factory) : IClassFixture<SaleApiFactory>
{
    [Fact]
    public async Task Never_sells_more_than_the_stock()
    {
        var ct = TestContext.Current.CancellationToken;
        await factory.SeedStockAsync("sku-123", 100);

        var calls = Enumerable.Range(0, 500).Select(async i =>
        {
            using var client = factory.CreateClient();
            var req = new HttpRequestMessage(HttpMethod.Post, "/orders")
            { Content = JsonContent.Create(new { sku = "sku-123", qty = 1, customerId = $"c{i}" }) };
            req.Headers.Add("Idempotency-Key", Guid.NewGuid().ToString());
            return (await client.SendAsync(req, ct)).StatusCode;
        });
        var results = await Task.WhenAll(calls);

        Assert.Equal(100, results.Count(s => s == HttpStatusCode.Accepted));
        Assert.Equal(400, results.Count(s => s == HttpStatusCode.Conflict));
        Assert.Equal(0, await factory.GetRedisStockAsync("sku-123"));
    }
}

22.2 Seat / appointment booking with temporary holds Added

Let a user hold a seat or time slot for a few minutes while they pay, block everyone else, and release it automatically if they walk away.

Problem statement

Concert tickets, flight seats and branch appointments all have the same shape: a limited set of named slots. Users need a short, exclusive hold while they fill in details or pay. Without holds, two people pay for the same seat; with holds that never expire, seats look "sold out" when they are not.

Constraints & assumptions: SQL Server is the source of truth; up to 60,000 seats per event; app servers are NTP-synced (seconds of skew don't matter for a 10-minute hold); all times are stored in UTC (DateTimeOffset).

Solution

Steps to implement in .NET 10

1. Set up: minimal API + Aspire AppHost (Aspire.Hosting.SqlServer); EF Core 10 with Microsoft.EntityFrameworkCore.SqlServer.
2. Model: Seat (Id, EventId, HeldBy, HoldExpiresAt as DateTimeOffset?, BookedBy, [Timestamp] RowVersion), index on (EventId, Id). A Booking row per confirmed payment with a unique PaymentId.
3. Time: register builder.Services.AddSingleton(TimeProvider.System) and never call DateTime.UtcNow directly. Tests swap in FakeTimeProvider.
4. Hold endpoint: one ExecuteUpdateAsync inside a transaction; if fewer rows changed than seats asked for, roll back (core trick 1). Reject duplicate seat IDs and more than 6 seats up front (400).
5. Confirm endpoint: UPDATE ... SET BookedBy = @me WHERE HeldBy = @me AND HoldExpiresAt > @now, idempotent on PaymentId. If the hold expired but the seat is still free, book it; if someone else has it, trigger an automatic refund.
6. Seat map reads: HybridCache (Microsoft.Extensions.Caching.Hybrid) with a 2 s expiry and a tag per event; call RemoveByTagAsync after holds change.
7. Live updates: ASP.NET Core SignalR (built-in), one group per event: push "held", "booked", "free again". Use Azure SignalR Service (Microsoft.Azure.SignalR) to scale out.
8. Sweeper: BackgroundService with new PeriodicTimer(TimeSpan.FromSeconds(30), timeProvider) clears expired holds and pushes "free again" events.
9. Big on-sale mode: Redis hold first with StringSetAsync(key, user, TimeSpan.FromMinutes(10), When.NotExists) (core trick 2), plus a queue-based waiting room; SQL confirm stays the final check.
10. Deploy: App Service or Container Apps, Azure SQL (read replica for seat-map reads if needed), OpenTelemetry metrics for holds created, expired and confirmed.

Core trick 1: all-or-nothing hold with a conditional UPDATE

app.MapPost("/events/{eventId:int}/holds", async (int eventId, HoldRequest req, BookingDb db,
    TimeProvider clock, ClaimsPrincipal user, CancellationToken ct) =>
{
    var now = clock.GetUtcNow();
    var me = user.FindFirstValue(ClaimTypes.NameIdentifier)!;
    await using var tx = await db.Database.BeginTransactionAsync(ct);

    var held = await db.Seats
        .Where(s => s.EventId == eventId && req.SeatIds.Contains(s.Id) && s.BookedBy == null
                 && (s.HoldExpiresAt == null || s.HoldExpiresAt <= now))      // free or expired
        .ExecuteUpdateAsync(s => s
            .SetProperty(x => x.HeldBy, me)
            .SetProperty(x => x.HoldExpiresAt, now.AddMinutes(10)), ct);

    if (held != req.SeatIds.Length)                    // someone else got at least one seat
    {
        await tx.RollbackAsync(ct);                    // all or nothing
        return Results.Conflict("One or more seats are no longer free");
    }
    await tx.CommitAsync(ct);
    return Results.Ok(new { expiresAt = now.AddMinutes(10) });
});

Core trick 2: Redis hold with expiry, and a safe release

// SET hold:7:A3 alice NX PX 600000  -> only the first caller wins
bool got = await redis.StringSetAsync($"hold:{eventId}:{seatId}", userId,
                                      TimeSpan.FromMinutes(10), When.NotExists);
if (!got) return Results.Conflict("Seat is held by someone else");

// Release only if the hold is still yours (compare-and-delete in one step)
await redis.ScriptEvaluateAsync(
    "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) end return 0",
    [$"hold:{eventId}:{seatId}"], [userId]);

Testing scenarios

Sample test: expiry without real waiting (Microsoft.Extensions.TimeProvider.Testing)

[Fact]
public async Task Hold_expires_after_ten_minutes()
{
    var ct = TestContext.Current.CancellationToken;
    var clock = new FakeTimeProvider(DateTimeOffset.Parse("2026-10-16T09:00:00Z"));
    await using var app = factory.WithWebHostBuilder(b =>
        b.ConfigureTestServices(s => s.AddSingleton<TimeProvider>(clock)));
    var alice = app.CreateClientFor("alice");          // helper: test auth handler sets the user
    var bob = app.CreateClientFor("bob");
    var seat12 = new { seatIds = new[] { 12 } };

    var first = await alice.PostAsJsonAsync("/events/7/holds", seat12, ct);
    Assert.Equal(HttpStatusCode.OK, first.StatusCode);

    var tooEarly = await bob.PostAsJsonAsync("/events/7/holds", seat12, ct);
    Assert.Equal(HttpStatusCode.Conflict, tooEarly.StatusCode);

    clock.Advance(TimeSpan.FromMinutes(10));           // ten minutes pass instantly
    var later = await bob.PostAsJsonAsync("/events/7/holds", seat12, ct);
    Assert.Equal(HttpStatusCode.OK, later.StatusCode);
}

22.3 Search autocomplete (typeahead) Added

Suggest the best 5–10 completions while the user types. Precompute the answers per prefix, cache hard, and send fewer requests from the client.

Problem statement

A large store or banking app has a search box: products, merchants, help articles. Every keystroke could be a request, so a naive "LIKE 'hom%'" query on the main database is slow and expensive. Users expect suggestions to appear as fast as they type.

Constraints & assumptions: ~5M distinct terms from search logs; English first; prefixes capped at 10 characters for the precomputed lists; Azure hosting with a CDN in front.

Solution

Steps to implement in .NET 10

1. Set up: minimal API; Redis via Aspire.StackExchange.Redis (client integration) or plain StackExchange.Redis.
2. Log searches: send each final query as an event to Event Hubs (Azure.Messaging.EventHubs). Never log personal data in the term.
3. Aggregate: a timer job (Azure Functions timer trigger, or a BackgroundService) counts term frequency with time decay, and drops blocked terms.
4. Build the index: for each term and each prefix up to 10 chars, SortedSetAddAsync then trim with SortedSetRemoveRangeByRankAsync(key, 0, -11) to keep the top 10 (core trick 1). Use batching/pipelining; write to ac:v43:*, then set ac:current = v43.
5. Normalise once, everywhere: Trim(), ToLowerInvariant(), remove accents (string.Normalize(NormalizationForm.FormD) and drop non-spacing marks). Same function in the indexer and the API.
6. Suggest endpoint: validate 1–50 chars, read SortedSetRangeByRankAsync(key, 0, 9, Order.Descending). For prefixes longer than 10 chars, read the 10-char list and filter with StartsWith.
7. Cache: built-in output caching (AddOutputCache, .CacheOutput(p => p.Expire(...).SetVaryByQuery("q"))) and a Cache-Control: public, max-age=60 header for the CDN (Azure Front Door).
8. Protect: built-in rate limiter per IP; if Redis fails, return an empty list (200), not an error.
9. Client: debounce 250 ms and cancel the previous request (AbortController in JS, a new CancellationTokenSource per keystroke in Blazor/MAUI).
10. Optional managed option: Azure AI Search (Azure.Search.Documents) with a SearchSuggester on the index and SearchClient.AutocompleteAsync / SuggestAsync with UseFuzzyMatching = true (core trick 2).

Core trick 1: top 10 per prefix in Redis sorted sets

// Indexer: put a term into the top-10 list of each of its prefixes
async Task IndexTermAsync(IDatabase db, string version, string term, double score)
{
    var t = Normalise(term);
    for (int len = 1; len <= Math.Min(10, t.Length); len++)
    {
        var key = $"ac:{version}:{t[..len]}";
        await db.SortedSetAddAsync(key, t, score);
        await db.SortedSetRemoveRangeByRankAsync(key, 0, -11);      // keep only the top 10
    }
}

// API: one Redis call per uncached keystroke
app.MapGet("/suggest", async (string q, IConnectionMultiplexer mux) =>
{
    var norm = Normalise(q);
    if (norm.Length is 0 or > 50) return Results.BadRequest();
    var db = mux.GetDatabase();
    var version = await db.StringGetAsync("ac:current");             // switched after each rebuild
    var hits = await db.SortedSetRangeByRankAsync($"ac:{version}:{norm[..Math.Min(10, norm.Length)]}",
                                                  0, 9, Order.Descending);
    return Results.Ok(hits.Select(h => h.ToString()).Where(h => h.StartsWith(norm)));
}).CacheOutput(p => p.Expire(TimeSpan.FromSeconds(60)).SetVaryByQuery("q"));

Core trick 2: Azure AI Search with typo tolerance

// Index definition includes: Suggesters = { new SearchSuggester("sg", "name") }
var response = await searchClient.AutocompleteAsync("hom", "sg", new AutocompleteOptions
{
    Mode = AutocompleteMode.OneTermWithContext,
    UseFuzzyMatching = true,          // "hmoe" still finds "home"
    Size = 8
});
var suggestions = response.Value.Results.Select(r => r.Text);

Testing scenarios

Sample test: ranking snapshot with Verify (Verify.XunitV3)

public sealed class SuggestTests(SuggestApiFactory factory) : IClassFixture<SuggestApiFactory>
{
    [Fact]
    public async Task Returns_top_terms_by_popularity()
    {
        var ct = TestContext.Current.CancellationToken;
        await factory.IndexAsync(("home loan", 900), ("home insurance", 700),
                                 ("homepage", 50), ("holiday", 400));     // runs the real indexer

        var client = factory.CreateClient();
        var result = await client.GetFromJsonAsync<string[]>("/suggest?q=HOM", ct);

        await Verify(result);   // snapshot: ["home loan", "home insurance", "homepage"]
    }
}

22.4 Proximity service: find nearby ATMs, branches or drivers Added

"What is near me?" Static places (ATMs, branches) live in a spatial database; fast-moving things (drivers, couriers) live in an in-memory geo index that is updated every few seconds.

Problem statement

A banking app needs "nearest ATM or branch" with filters. A delivery or ride app needs "available drivers within 3 km", where every driver moves and reports a new location every few seconds. Scanning every row and computing distances is too slow, and moving objects create a heavy write load.

Constraints & assumptions: WGS84 latitude/longitude (SRID 4326); distances in metres; the customer's location is never stored or logged in full; driver history is not kept in the hot store.

Solution

Steps to implement in .NET 10

1. Set up: minimal API; Microsoft.EntityFrameworkCore.SqlServer.NetTopologySuite (or Npgsql.EntityFrameworkCore.PostgreSQL.NetTopologySuite for PostGIS); StackExchange.Redis.
2. Model places: Atm with NetTopologySuite.Geometries.Point Location mapped to SQL Server geography; register with UseSqlServer(cs, x => x.UseNetTopologySuite()).
3. Spatial index: add CREATE SPATIAL INDEX with migrationBuilder.Sql(...) in a migration (create it in SQL; don't rely on HasIndex for spatial indexes).
4. Nearest places query: IsWithinDistance + OrderBy(Distance) + Take(10) (core trick 1). Validate lat −90..90, lon −180..180, radius capped at 50 km.
5. Driver updates: GeoAddAsync("drivers:{city}", lon, lat, driverId) plus StringSetAsync($"hb:{driverId}", 1, TimeSpan.FromSeconds(15)).
6. Nearby drivers: GeoSearchAsync(key, lon, lat, new GeoSearchCircle(3, GeoUnit.Kilometers), count: 20, order: Order.Ascending, options: GeoRadiusOptions.WithDistance), then drop members with no heartbeat (core trick 2).
7. Cleanup: BackgroundService removes stale members with GeoRemoveAsync every 30 s.
8. Live tracking: after a match, stream the driver's position to the rider through a SignalR group (Azure SignalR Service to scale).
9. Cache place results: HybridCache keyed by rounded lat/lon + filters, 5-minute expiry (places rarely change).
10. Deploy & protect privacy: Container Apps autoscaling on HTTP load; round coordinates in logs and traces; OpenTelemetry for write rate and search latency.

Core trick 1: nearest ATMs with EF Core + NetTopologySuite

builder.Services.AddDbContext<PlacesDb>(o =>
    o.UseSqlServer(cs, sql => sql.UseNetTopologySuite()));

// Nearest 10 ATMs within 2 km that accept deposits
var here = new Point(lon, lat) { SRID = 4326 };            // x = longitude, y = latitude!
var atms = await db.Atms
    .Where(a => a.AcceptsDeposits && a.Location.IsWithinDistance(here, 2_000))  // metres on geography
    .OrderBy(a => a.Location.Distance(here))
    .Take(10)
    .Select(a => new { a.Id, a.Name, Metres = a.Location.Distance(here) })
    .ToListAsync(ct);

Core trick 2: moving drivers with Redis GEO + heartbeat

// Driver app, every ~4 s
await db.GeoAddAsync("drivers:syd", lon, lat, driverId);
await db.StringSetAsync($"hb:{driverId}", 1, TimeSpan.FromSeconds(15));      // "still online"

// Rider: 20 closest drivers within 3 km, nearest first
var near = await db.GeoSearchAsync("drivers:syd", lon, lat,
    new GeoSearchCircle(3, GeoUnit.Kilometers),
    count: 20, order: Order.Ascending, options: GeoRadiusOptions.WithDistance);

var alive = await db.StringGetAsync(near.Select(n => (RedisKey)$"hb:{n.Member}").ToArray());
var result = near.Zip(alive)
    .Where(x => x.Second.HasValue)                                           // skip stale drivers
    .Select(x => new { id = x.First.Member.ToString(), km = x.First.Distance })
    .Take(5);

Testing scenarios

Sample test: real distances, real order (SQL Server container supports geography)

[Fact]
public async Task Nearest_atms_are_sorted_by_real_distance()
{
    var ct = TestContext.Current.CancellationToken;
    await factory.SeedAtmsAsync(
        ("Town Hall",     151.2070, -33.8731),       // ~0.3 km from the user
        ("Circular Quay", 151.2108, -33.8615),       // ~1.6 km
        ("Parramatta",    151.0036, -33.8150));      // ~20 km: outside the radius

    var client = factory.CreateClient();
    var atms = await client.GetFromJsonAsync<AtmDto[]>(
        "/atms/near?lat=-33.8757&lon=151.2069&radiusM=2000", ct);

    Assert.Equal(new[] { "Town Hall", "Circular Quay" }, atms!.Select(a => a.Name));
    Assert.True(atms[0].Metres < atms[1].Metres);
}

22.5 Large file upload & processing (chunked, resumable, scanned) Added

Let clients upload big files straight to blob storage in chunks they can resume, keep the bytes away from your API servers, and process a file only after a malware scan says it is clean.

Problem statement

Customers upload loan documents, statements, photos and videos, some of them several GB, often from a phone on a weak network. A single HTTP POST through the API ties up servers, fails at 90% and starts again from zero, and lets untrusted files reach back-office systems.

Constraints & assumptions: Azure Blob Storage; browser and mobile clients; files are untrusted until scanned; managed identities everywhere (no storage keys in code); retention rules apply to stored documents.

Solution

Steps to implement in .NET 10

1. Storage: containers incoming (untrusted) and clean. Enable Defender for Storage on-upload malware scanning and send results to an Event Grid custom topic. Add a lifecycle rule that deletes old blobs in incoming.
2. Packages: Azure.Storage.Blobs, Azure.Identity (DefaultAzureCredential / managed identity), Microsoft.Extensions.Azure (AddAzureClients).
3. Start an upload: validate name, declared size (≤ 5 GB) and allowed types; save an Upload row as Pending; return a user delegation SAS for one blob with Create + Write only, valid 1 hour (core trick 1).
4. Client upload: browsers use @azure/storage-blob; .NET clients (MAUI, desktop, workers) use BlockBlobClient.StageBlockAsync per 8 MiB block and CommitBlockListAsync at the end, saving progress after each block (core trick 2).
5. Alternative: tusdotnet with app.MapTus("/files", ...) and the community Azure store Xtensible.TusDotNet.Azure; raise Kestrel's MaxRequestBodySize (default ~30 MB) for the tus route.
6. Scan result handler: Azure Functions isolated worker with Microsoft.Azure.Functions.Worker.Extensions.EventGrid ([EventGridTrigger]). Read scanResultType: clean → server-side copy to clean (StartCopyFromUriAsync) and mark Ready; malicious → delete or quarantine and alert; not scanned → keep blocked for review.
7. Validate content: check the real size and the file's magic bytes (a renamed .exe is not a PDF) before processing.
8. Process: send a Service Bus message (Azure.Messaging.ServiceBus) per clean file; the worker does OCR (Azure AI Document Intelligence) or thumbnails, idempotent by upload id, with a dead-letter queue.
9. Notify & status: GET /uploads/{id} plus a SignalR or push notification when Ready or Rejected.
10. Clean up & observe: a nightly job expires Pending uploads older than 24 h; alerts on "Malicious" results and dead-letter count; OpenTelemetry across API, Function and worker.

Core trick 1: a write-only, one-blob, 1-hour user delegation SAS

app.MapPost("/uploads", async (NewUpload req, BlobServiceClient blobs, TimeProvider clock, UploadsDb db) =>
{
    if (req.Size is <= 0 or > 5L * 1024 * 1024 * 1024) return Results.BadRequest("Max 5 GB");
    if (!AllowedTypes.Contains(req.ContentType)) return Results.BadRequest("File type not allowed");

    var id = Guid.CreateVersion7();
    var blob = blobs.GetBlobContainerClient("incoming").GetBlobClient(id.ToString());
    var now = clock.GetUtcNow();
    UserDelegationKey key = await blobs.GetUserDelegationKeyAsync(now.AddMinutes(-5), now.AddHours(1));

    var sas = new BlobSasBuilder
    {
        BlobContainerName = "incoming", BlobName = blob.Name, Resource = "b",
        StartsOn = now.AddMinutes(-5), ExpiresOn = now.AddHours(1)
    };
    sas.SetPermissions(BlobSasPermissions.Create | BlobSasPermissions.Write);    // no read, no list

    var url = new BlobUriBuilder(blob.Uri) { Sas = sas.ToSasQueryParameters(key, blobs.AccountName) }.ToUri();
    db.Uploads.Add(new Upload(id, req.FileName, req.Size, UploadStatus.Pending));
    await db.SaveChangesAsync();
    return Results.Ok(new { id, uploadUrl = url });
});

Core trick 2: resumable upload in 8 MiB blocks (.NET client)

var blob = new BlockBlobClient(uploadUrl);                       // SAS URL from the API
const int BlockSize = 8 * 1024 * 1024;
var ids = Enumerable.Range(0, progress.BlocksSent).Select(BlockId).ToList();
file.Position = (long)progress.BlocksSent * BlockSize;           // resume: skip blocks already sent
var buffer = new byte[BlockSize];

int n;
while ((n = await file.ReadAtLeastAsync(buffer, BlockSize, throwOnEndOfStream: false)) > 0)
{
    var id = BlockId(ids.Count);
    await blob.StageBlockAsync(id, new MemoryStream(buffer, 0, n));   // SDK retries transient errors
    ids.Add(id);
    await progress.SaveAsync(ids.Count);                         // remember after every block
}
await blob.CommitBlockListAsync(ids);                            // the blob appears only now

static string BlockId(int i) => Convert.ToBase64String(BitConverter.GetBytes(i));  // same length

Testing scenarios

Sample test: a resumed upload gives the identical file (Testcontainers.Azurite)

public sealed class UploadTests : IAsyncLifetime
{
    private readonly AzuriteContainer _azurite =
        new AzuriteBuilder("mcr.microsoft.com/azure-storage/azurite:3.37.0").Build();
    public async ValueTask InitializeAsync() => await _azurite.StartAsync();
    public ValueTask DisposeAsync() => _azurite.DisposeAsync();

    [Fact]
    public async Task Resumed_upload_produces_the_identical_file()
    {
        var ct = TestContext.Current.CancellationToken;
        var container = new BlobContainerClient(_azurite.GetConnectionString(), "incoming");
        await container.CreateIfNotExistsAsync(cancellationToken: ct);
        var blob = container.GetBlockBlobClient("big.bin");
        var data = RandomNumberGenerator.GetBytes(20 * 1024 * 1024);          // 20 MiB = 3 blocks

        var uploader = new ResumableUploader(blob, blockSize: 8 * 1024 * 1024);  // code under test
        await Assert.ThrowsAsync<IOException>(() =>
            uploader.UploadAsync(new FlakyStream(data, failAfterBytes: 9_000_000), ct));
        await uploader.UploadAsync(new MemoryStream(data), ct);               // resume

        var stored = (await blob.DownloadContentAsync(ct)).Value.Content.ToArray();
        Assert.Equal(SHA256.HashData(data), SHA256.HashData(stored));
    }
}

22.6 Distributed job scheduler Added

"Design a service that runs thousands of scheduled jobs (cron and one-off) across several nodes, on time, and never with a double effect." The hard parts: only one node fires each job, and nothing is lost when a node dies.

Problem statement

A bank runs thousands of scheduled tasks: monthly statements, direct-debit files, reminder emails, data exports. Today they're Task Scheduler entries on one VM. If that VM dies, jobs silently don't run, and nobody can see what ran when.

Constraints & assumptions:

• Jobs are short (under 15 minutes). Long work is handed to a queue.
• Azure SQL is available; the app runs as containers (AKS or Container Apps).
• Delivery is at-least-once. Exactly-once firing isn't realistic, so jobs must be idempotent.

Solution

Steps to implement in .NET 10

1. Create a Worker Service (dotnet new worker) and add Quartz 4.x plus Microsoft.Data.SqlClient. From 4.0, DI and hosting live in the core package; Quartz.Extensions.Hosting is now an empty forwarding package.
2. Create the Quartz tables in Azure SQL from the scripts in the Quartz repo, run as a migration step in the pipeline.
3. Configure AddQuartz with UsePersistentStore(s => { s.UseSqlServer(...); s.UseClustering(); }). Every node uses the same InstanceName and a unique instance id (GenerateInstanceId = true).
4. Write each job as an IJob with [DisallowConcurrentExecution]. Build a run key from ScheduledFireTimeUtc and insert it into a JobRuns table with a unique index.
5. Hand long work to Azure.Messaging.ServiceBus with MessageId = run key, so duplicate detection drops repeats.
6. Add an admin API (minimal APIs + Entra ID roles) that calls IScheduler: ScheduleJob, PauseJob, TriggerJob.
7. Wire OpenTelemetry (Quartz 4 emits spans and metrics) and health checks; alert on misfires and failed runs.
8. Deploy 3+ replicas. Set WaitForJobsToComplete and HostOptions.ShutdownTimeout so a rolling deploy drains running jobs.

builder.AddQuartz(q =>
{
    q.ConfigureScheduler(o => { o.InstanceName = "bank-jobs"; o.GenerateInstanceId = true; });
    q.UsePersistentStore(store =>
    {
        store.UseSqlServer(builder.Configuration.GetConnectionString("Quartz")!);
        store.UseClustering();                      // DB row locks: one node per firing
    });
    q.ScheduleJob<StatementJob>(t => t
        .WithIdentity("monthly-statements")
        .WithCronSchedule("0 0 2 1 * ?", c => c.InTimeZone(
            TimeZoneInfo.FindSystemTimeZoneById("Australia/Sydney"))));
});
builder.AddQuartzHostedService(o => o.WaitForJobsToComplete = true);

[DisallowConcurrentExecution]
public sealed class StatementJob(JobRunStore runs, ServiceBusSender sender, TimeProvider clock) : IJob
{
    public async ValueTask Execute(IJobExecutionContext context, CancellationToken ct = default)
    {
        // A retried or recovered firing has the same key, so the effect happens once
        string runKey = $"{context.JobDetail.Key}:{context.ScheduledFireTimeUtc:O}";
        if (!await runs.TryStartAsync(runKey, clock.GetUtcNow(), ct)) return;   // unique index on RunKey

        await sender.SendMessageAsync(new ServiceBusMessage(runKey) { MessageId = runKey }, ct);
        await runs.CompleteAsync(runKey, clock.GetUtcNow(), ct);
    }
}

Testing scenarios

public class StatementJobTests
{
    [Fact]
    public async Task Same_firing_twice_sends_one_message()
    {
        var clock = new FakeTimeProvider(new DateTimeOffset(2026, 11, 1, 2, 0, 0, TimeSpan.FromHours(11)));
        var runs = new InMemoryJobRunStore();               // unique RunKey, like the SQL index
        var sender = new FakeServiceBusSender();             // subclass of ServiceBusSender that records messages
        var job = new StatementJob(runs, sender, clock);
        var context = TestContexts.ForFiring("monthly-statements", clock.GetUtcNow());   // your helper

        await job.Execute(context, TestContext.Current.CancellationToken);
        await job.Execute(context, TestContext.Current.CancellationToken);   // retry or recovery

        Assert.Single(sender.Sent);
    }
}

22.7 Web crawler Added

"Design a crawler that fetches a billion public pages a month, politely, without fetching the same page twice." A giant queue (the frontier) plus three rules: obey robots.txt, limit each host, remember what you've seen.

Problem statement

A search or knowledge product needs fresh copies of public web pages. The crawler starts from seed URLs, follows links, and keeps pages up to date, without overloading any website or getting stuck in endless link loops.

Constraints & assumptions:

• Public pages only, no logins. Identify the bot with a User-Agent and a contact URL.
• robots.txt follows RFC 9309. Cache it per host for up to 24 hours.
• No JavaScript rendering in v1 (a headless browser only for an allow-list of sites).

Solution

Steps to implement in .NET 10

1. Create a Worker Service. Register a named HttpClient with IHttpClientFactory, AddStandardResilienceHandler() (Microsoft.Extensions.Http.Resilience), automatic decompression, a 10 s timeout and a User-Agent with a contact URL.
2. Build the frontier: a Kafka topic urls keyed by host (Confluent.Kafka); inside each worker, bounded System.Threading.Channels per host.
3. robots.txt: fetch once per host, cache with HybridCache, and parse with TurnerSoftware.RobotsExclusionTools (or a small RFC 9309 parser of your own).
4. Politeness: a PartitionedRateLimiter<Uri> keyed by host, plus a cap of 1–2 concurrent requests per host.
5. Parse with AngleSharp: a[href] links, canonical link, meta robots (noindex, nofollow) and body text. Resolve relative links with new Uri(baseUri, href) and normalise them.
6. Seen set: StackExchange.Redis sending BF.ADD / BF.EXISTS (Redis 8 includes Bloom filters; on managed Redis, check your tier supports them).
7. Store compressed HTML in Blob Storage (Azure.Storage.Blobs) keyed by URL hash, and per-URL metadata (ETag, last crawl, content hash, next due) in Cosmos DB or Table Storage.
8. Emit OpenTelemetry metrics (pages/s, errors per host, queue depth). Run N workers on AKS with KEDA scaling on Kafka consumer lag.

// One token bucket per host: 1 request per second, the rest wait in a queue
PartitionedRateLimiter<Uri> perHost = PartitionedRateLimiter.Create<Uri, string>(uri =>
    RateLimitPartition.GetTokenBucketLimiter(uri.Host, _ => new TokenBucketRateLimiterOptions
    {
        TokenLimit = 1, TokensPerPeriod = 1, ReplenishmentPeriod = TimeSpan.FromSeconds(1),
        QueueLimit = 1_000, QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
        AutoReplenishment = true
    }));

async Task CrawlAsync(Uri url, HttpClient http, CancellationToken ct)
{
    using RateLimitLease lease = await perHost.AcquireAsync(url, 1, ct);
    if (!lease.IsAcquired) { await frontier.RequeueLaterAsync(url, ct); return; }

    using var response = await http.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, ct);
    if (!response.IsSuccessStatusCode || response.Content.Headers.ContentType?.MediaType != "text/html") return;

    var doc = await new HtmlParser().ParseDocumentAsync(await response.Content.ReadAsStreamAsync(ct), ct);
    foreach (var href in doc.QuerySelectorAll("a[href]").Select(a => a.GetAttribute("href")))
        if (Uri.TryCreate(url, href, out var link) && link.Scheme is "http" or "https")
            await frontier.OfferAsync(Normalise(link), ct);      // Bloom filter check inside
}

Testing scenarios

[Fact]
public async Task Disallowed_paths_are_never_fetched()
{
    using var site = WireMockServer.Start();
    site.Given(Request.Create().WithPath("/robots.txt"))
        .RespondWith(Response.Create().WithBody("User-agent: *\nDisallow: /private"));
    site.Given(Request.Create().WithPath("/"))
        .RespondWith(Response.Create().WithHeader("Content-Type", "text/html")
            .WithBody("<a href='/private/a'>x</a> <a href='/public/b'>y</a>"));
    site.Given(Request.Create().WithPath("/public/b")).RespondWith(Response.Create().WithStatusCode(200));

    var crawler = TestCrawler.Create();                      // real pipeline, in-memory frontier
    await crawler.RunAsync(new Uri(site.Url! + "/"), maxPages: 10, TestContext.Current.CancellationToken);

    Assert.DoesNotContain(site.LogEntries, e => e.RequestMessage.Path.StartsWith("/private"));
    Assert.Contains(site.LogEntries, e => e.RequestMessage.Path == "/public/b");
}

22.8 Real-time fraud detection Added

"Score every payment for fraud in under 100 ms, block the obvious ones, and send the doubtful ones to analysts." A fast inline decision, backed by a payment stream that keeps the features fresh.

Problem statement

A bank processes card and real-time account-to-account payments. Real-time payments can't be pulled back once they settle, so the fraud decision must happen before the money moves, without making checkout feel slow.

Constraints & assumptions:

• PCI DSS: the fraud store holds card tokens, never full card numbers.
• The model is trained offline (ML.NET, or Python exported to ONNX) and served in .NET.
• The payment switch calls the fraud service synchronously; everything else can be async.

Solution

Steps to implement in .NET 10

1. Create an ASP.NET Core gRPC service (Grpc.AspNetCore) with a Score(PaymentRequest) contract agreed with the payment switch.
2. Features with StackExchange.Redis: velocity counters via StringIncrementAsync + KeyExpireAsync in one transaction; sliding windows via SortedSetAddAsync, SortedSetRemoveRangeByScoreAsync, SortedSetLengthAsync.
3. Rules as plain C# classes, with thresholds in IOptionsMonitor<FraudRules> fed by Azure App Configuration, so changes apply without a deploy.
4. Train offline (ML.NET with Microsoft.ML.LightGbm, or Python to ONNX). Serve with Microsoft.Extensions.ML: AddPredictionEnginePool<TxnFeatures, FraudScore>().FromFile("fraud", path, watchForChanges: true), or Microsoft.ML.OnnxRuntime.
5. Publish every decision to Event Hubs (Azure.Messaging.EventHubs) or Kafka, partition key = card token. An EventProcessorClient consumer updates long-window features and opens cases.
6. Case management: review-band decisions create a case; the analyst's outcome (fraud / genuine) is stored as a label for retraining.
7. Wrap scoring in a Microsoft.Extensions.Resilience pipeline: 80 ms timeout + fallback to rules-only. Record latency histograms, decision mix and model version with OpenTelemetry.
8. Deploy across zones (min 3 replicas, zone-redundant Redis). Run a new model in shadow mode (score, don't act) before switching it on.

public sealed class FraudScorer(
    IDatabase redis, PredictionEnginePool<TxnFeatures, FraudScore> model, RuleSet rules)
{
    public async Task<Decision> ScoreAsync(Payment p)
    {
        string key = $"vel:{p.CardToken}:10m";
        ITransaction tx = redis.CreateTransaction();
        Task<long> count10m = tx.StringIncrementAsync(key);
        _ = tx.KeyExpireAsync(key, TimeSpan.FromMinutes(10), ExpireWhen.HasNoExpiry);
        await tx.ExecuteAsync();

        var f = new TxnFeatures { Amount = (float)p.Amount, Count10m = await count10m,
                                  NewPayee = p.IsNewPayee, MerchantRisk = p.MerchantRisk };

        if (rules.HardBlock(p, f) is { } reason) return Decision.Decline(reason);   // e.g. known mule account

        float score = model.Predict("fraud", f).Probability;
        return score switch
        {
            >= 0.90f => Decision.Decline("model"),
            >= 0.60f => Decision.ApproveAndReview(score),     // async case for an analyst
            _        => Decision.Approve(score)
        };
    }
}

Testing scenarios

public sealed class VelocityTests : IAsyncLifetime
{
    private readonly RedisContainer _redis = new RedisBuilder().WithImage("redis:8").Build();
    public async ValueTask InitializeAsync() => await _redis.StartAsync();
    public async ValueTask DisposeAsync() => await _redis.DisposeAsync();

    [Fact]
    public async Task Sixth_payment_in_ten_minutes_is_stepped_up()
    {
        var mux = await ConnectionMultiplexer.ConnectAsync(_redis.GetConnectionString());
        var scorer = TestScorers.RulesOnly(mux.GetDatabase());     // real Redis, stub model
        var card = $"tok_{Guid.NewGuid():N}";

        Decision last = null!;
        for (int i = 0; i < 6; i++)
            last = await scorer.ScoreAsync(TestPayments.For(card, amount: 49.95m));

        Assert.Equal(Outcome.StepUp, last.Outcome);
    }
}

22.9 Customer onboarding (KYC) workflow Added

"Design digital onboarding: verify a new customer's identity, screen them, ask a human when needed, open the account, and prove every step later." A long-running workflow that may take three minutes or three weeks.

Problem statement

Customers open an account in the app. Under Australia's AML/CTF Act (reformed obligations from 31 March 2026), a bank must complete initial customer due diligence before it provides the service, and keep the records for 7 years after the relationship ends. Most applicants should be done in minutes; a few need an analyst.

Constraints & assumptions:

• Identity, liveness and screening are external vendor APIs with rate limits and outages.
• Analysts work business hours; every decision must be explainable.
• You record what you verified (document type, number, result), not necessarily a copy of the document.

Solution

Steps to implement in .NET 10

1. Create an isolated-worker Azure Functions app with Microsoft.Azure.Functions.Worker.Extensions.DurableTask, backed by the Durable Task Scheduler. (In containers, use Microsoft.DurableTask.Worker.AzureManaged instead.)
2. API: POST /applications saves the application, uploads images to private Blob Storage (Australian region), and calls ScheduleNewOrchestrationInstanceAsync with instance id = application id.
3. Activities: extract fields with Azure.AI.DocumentIntelligence (prebuilt-idDocument covers passports and US licences; use a custom model or your identity provider for Australian licences); verify, screen and rate risk through typed HttpClients with AddStandardResilienceHandler().
4. Orchestrator: chain the activities with TaskOptions.FromRetryPolicy; for review, race WaitForExternalEvent<ReviewDecision> against CreateTimer.
5. Analyst UI/API calls RaiseEventAsync(instanceId, "ReviewDecision", decision), protected by an Entra ID app role; require a second approver for high risk.
6. Saga: OpenAccount then IssueCard; on failure, run CloseAccount in the catch. Each activity is idempotent (key = application id + step).
7. Audit: every activity appends to an Azure SQL table created with LEDGER = ON (APPEND_ONLY = ON). Never update or delete rows.
8. Deploy; show stuck instances on a dashboard (custom status); purge old workflow history once the audit trail holds what you need.

public sealed class KycOrchestrator : TaskOrchestrator<Application, KycOutcome>
{
    public override async Task<KycOutcome> RunAsync(TaskOrchestrationContext ctx, Application app)
    {
        var retry = TaskOptions.FromRetryPolicy(new RetryPolicy(5, TimeSpan.FromSeconds(10), backoffCoefficient: 2));
        IdResult id = await ctx.CallActivityAsync<IdResult>("VerifyIdentity", app, retry);
        Risk risk   = await ctx.CallActivityAsync<Risk>("ScreenAndRate", new ScreenInput(app, id), retry);
        if (risk.Level != RiskLevel.Low)
        {
            using var cts = new CancellationTokenSource();
            Task timeout = ctx.CreateTimer(ctx.CurrentUtcDateTime.AddDays(5), cts.Token);
            Task<ReviewDecision> review = ctx.WaitForExternalEvent<ReviewDecision>("ReviewDecision");
            if (await Task.WhenAny(review, timeout) == timeout) return KycOutcome.Expired();
            cts.Cancel();   if (!review.Result.Approved) return KycOutcome.Declined(review.Result.Reason);
        }
        string accountId = await ctx.CallActivityAsync<string>("OpenAccount", app, retry);
        try { await ctx.CallActivityAsync("IssueCard", accountId, retry); }
        catch (TaskFailedException)
        {
            await ctx.CallActivityAsync("CloseAccount", accountId, retry);      // compensate
            return KycOutcome.Failed("card");
        }
        return KycOutcome.Approved(accountId);
    }
}

Testing scenarios

[Fact]
public async Task Medium_risk_waits_for_analyst_then_opens_account()
{
    await using var host = await DurableTaskTestHost.StartAsync(tasks =>
    {
        tasks.AddOrchestrator<KycOrchestrator>();
        tasks.AddActivityFunc<Application, IdResult>("VerifyIdentity", (_, app) => IdResult.Verified(app.Name));
        tasks.AddActivityFunc<ScreenInput, Risk>("ScreenAndRate", (_, _) => new Risk(RiskLevel.Medium));
        tasks.AddActivityFunc<Application, string>("OpenAccount", (_, _) => "ACC-001");
        tasks.AddActivityFunc<string, bool>("IssueCard", (_, _) => true);
    });

    string id = await host.Client.ScheduleNewOrchestrationInstanceAsync(nameof(KycOrchestrator), TestApps.Medium());
    await host.Client.RaiseEventAsync(id, "ReviewDecision", new ReviewDecision(Approved: true, Reason: null));

    var result = await host.Client.WaitForInstanceCompletionAsync(id, getInputsAndOutputs: true);
    Assert.Equal(OrchestrationRuntimeStatus.Completed, result.RuntimeStatus);
    Assert.Equal("ACC-001", result.ReadOutputAs<KycOutcome>()!.AccountId);
}

22.10 Enterprise RAG assistant Added

"Let staff ask questions over policies, procedures and wikis, get grounded answers with citations, and never see a document they aren't allowed to open." RAG at enterprise scale: the hard parts are permissions, freshness and proving quality.

Problem statement

A company has 2 million documents across SharePoint, Confluence and file shares, and 20,000 staff. People waste time hunting for the right policy. The assistant must answer from these documents only, show its sources, and respect each document's permissions.

Constraints & assumptions:

• Models run in an Azure region you approve; staff sign in with Microsoft Entra ID.
• Documents can contain prompt-injection text; treat retrieved text as data, never as instructions.
• Restricted-label content is excluded at ingestion (see 7.2).

Solution

Steps to implement in .NET 10

1. Create an ASP.NET Core API with Entra ID auth (Microsoft.Identity.Web). Register IChatClient and IEmbeddingGenerator from Microsoft.Extensions.AI, using Azure.AI.OpenAI + Microsoft.Extensions.AI.OpenAI (AsIChatClient()).
2. Design the Azure AI Search index (Azure.Search.Documents): content, contentVector (HNSW), title, url, headingPath, lastModified, and group_ids as a filterable, non-retrievable string collection; add a semantic configuration and a vectorizer.
3. Build the ingestion worker: source change feeds (e.g. Microsoft Graph delta for SharePoint); Azure.AI.DocumentIntelligence layout to Markdown; chunk with Microsoft.Extensions.DataIngestion preview or your own splitter; embed; MergeOrUpload and delete.
4. Query path: read the user's group ids from the token (use Microsoft Graph when the token has too many groups), build the search.in filter, run hybrid + semantic search.
5. Prompt: system rules ("answer only from the sources, cite [n], say you don't know"), numbered sources; stream with GetStreamingResponseAsync; validate citations before showing them.
6. Guardrails: Azure.AI.ContentSafety on output, Prompt Shields (REST) on the question and documents, per-user rate limits (Microsoft.AspNetCore.RateLimiting), no prompts or PII in logs.
7. Evaluation: a golden Q&A set run as xUnit tests with Microsoft.Extensions.AI.Evaluation.Quality, cached and reported with Microsoft.Extensions.AI.Evaluation.Reporting; fail the PR if scores drop.
8. Deploy with private endpoints for Search and the model; trace tokens, latency and "I don't know" rate with OpenTelemetry; review low-rated answers weekly.

app.MapPost("/ask", async (AskRequest req, ClaimsPrincipal user, SearchClient search,
                           IChatClient chat, CancellationToken ct) =>
{
    string groups = string.Join(",", user.FindAll("groups").Select(c => c.Value));   // Graph on overage
    var options = new SearchOptions
    {
        Size = 8,
        Filter = $"group_ids/any(g: search.in(g, '{groups}', ','))",            // security trimming
        QueryType = SearchQueryType.Semantic,
        SemanticSearch = new() { SemanticConfigurationName = "default" },
        VectorSearch = new() { Queries = { new VectorizableTextQuery(req.Question)
            { KNearestNeighborsCount = 50, Fields = { "contentVector" } } } }
    };
    var hits = new List<Chunk>();
    await foreach (var r in (await search.SearchAsync<Chunk>(req.Question, options, ct)).Value.GetResultsAsync())
        hits.Add(r.Document);
    if (hits.Count == 0) return Results.Ok(Answer.DontKnow);
    string sources = string.Join("\n", hits.Select((h, i) => $"[{i + 1}] {h.Title}: {h.Content}"));
    ChatResponse reply = await chat.GetResponseAsync(
        [new(ChatRole.System, Prompts.GroundedAnswer),
         new(ChatRole.User, $"Sources:\n{sources}\n\nQuestion: {req.Question}")],
        cancellationToken: ct);
    return Results.Ok(Answer.WithValidatedCitations(reply.Text, hits));   // drop or retry unknown [n]
});

Testing scenarios

[Theory]
[MemberData(nameof(GoldenSet.Questions), MemberType = typeof(GoldenSet))]
public async Task Answers_are_grounded_in_retrieved_sources(string question)
{
    var (answer, sources, judge) = await RagTestHarness.AskAsync(question);   // real pipeline, test index

    IEvaluator evaluator = new GroundednessEvaluator();
    EvaluationResult result = await evaluator.EvaluateAsync(
        [new ChatMessage(ChatRole.User, question)], answer,
        new ChatConfiguration(judge),
        additionalContext: [new GroundednessEvaluatorContext(sources)]);

    NumericMetric groundedness = result.Get<NumericMetric>(GroundednessEvaluator.GroundednessMetricName);
    Assert.True(groundedness.Value >= 4, $"Groundedness {groundedness.Value} for: {question}");
}