A public reference application for order and inventory workflows, not a customer deployment or client case study. The useful question is how it handles conflicting requests and repeated messages.
- Two buyers request the last unit: inspect concurrency tests and the assertions for one successful hold and one rejected reservation.
- A message is delivered again: the same test file covers duplicate delivery and repeated stock release; outbox batch tests cover relay behavior.
- A reviewer needs to reproduce the result: use the setup and test sections below, and inspect CI runs for the tested revision, database integration checks and browser tests.
Tests cover defined scenarios; they do not establish a universal no-overselling guarantee or production readiness for another business. The architecture, operational assumptions and local-only credentials are documented below.
Work with Josué on backend features and integrations
Stock by SKU and the orders that draw it down. The scarce number is the on-hand units of a SKU, and the Inventory module is its only writer: it holds units with a single conditional UPDATE that matches only while the on-hand units still cover the order, so when two orders fight for the last unit, one commits a hold and the other is short and writes none. An order reference that contains the poison token POISON is committed as rejected by the Dispatch module, the message is dead-lettered, and a compensating command gives the units back. A later cancellation also gives the units back, but it does not roll back the pick slip that was already issued.
One ASP.NET Core process, one Postgres database. An HTTP write saves the order and an outbox row in one local transaction; a BackgroundService relay publishes outbox rows to RabbitMQ (the work queue) and Kafka (the event log); the next module consumes from RabbitMQ, claims an inbox key in the same transaction as its own write, and writes its own row and outbox row. Saga steps never call each other in-process. Delivery is at-least-once: the relay can publish and crash before it marks a row sent, so the row goes out again, and every consumer dedupes with its inbox key. Each saga step only moves an order forward from the status it expects.
Everything behind the saga is signed in: ASP.NET Core Identity with JWT access tokens and rotating refresh tokens (see Authentication and authorization). Customers see and cancel only their own orders; staff see everything and open skus.
The demo credentials in
compose.yamlandappsettings.Development.jsonare for local use only. SetJWT_KEYandADMIN_PASSWORD(see.env.example) before putting this anywhere shared. Compose binds every port to127.0.0.1.
The UI reads everything from the API; shown signed in as the seeded administrator, on the sku where two orders fought for the last units: one order was dispatched, the other was told it is short.
flowchart LR
Requested -->|units held| Held
Requested -->|short: no hold written| Rejected
Held -->|pick slip issued| Dispatched
Held -->|poison reference: slip rejected| Rejected
Held -->|cancellation| Cancelled
Dispatched -->|cancellation| Cancelled
Cancelled and Rejected (after a hold) give the units back through a ReleaseStock command, and Inventory releases a hold at most once. The pick slip has its own status (Issued or Rejected) and a cancellation never changes it. If the cancellation gets there before the final mark, the late mark finds the order is no longer Held and does nothing.
sequenceDiagram
participant C as Client
participant O as Orders
participant I as Inventory
participant D as Dispatch
C->>O: POST /api/orders
Note over O: order + outbox row, one transaction
O-->>C: 202 Requested
O->>I: stock.reserve (relay → RabbitMQ, copy to Kafka)
Note over I: inbox claim, conditional UPDATE, hold, outbox row
alt on-hand units cover the order
I->>D: stock.held
I->>O: stock.held (Requested → Held)
alt reference is clean
Note over D: pick slip, outbox row
D->>O: slip.issued (Held → Dispatched)
else reference contains POISON
Note over D: committed Rejected, then the message is dead-lettered
D->>I: stock.release (compensating command)
D->>O: slip.rejected (Held → Rejected)
I->>O: stock.released
end
else short
I->>O: stock.short (Requested → Rejected, no hold)
end
C->>O: POST /api/orders/{id}/cancellation
O->>I: stock.release (Held or Dispatched → Cancelled)
I->>O: stock.released
| Module | Owns | Consumes | Emits |
|---|---|---|---|
Identity (libs/identity) |
identity schema: users, roles, refresh tokens. |
||
Orders (libs/orders) |
Orders: status, units, fee, reference. Validation, the poison rule, the fee. |
stock.held, stock.short, slip.issued, slip.rejected, stock.released |
stock.reserve, stock.release (cancellation) |
Inventory (libs/inventory) |
Skus.OnHandUnits (sole writer after the SKU is added) and StockHolds. |
stock.reserve, stock.release (prefetch 1) |
stock.held, stock.short, stock.released |
Dispatch (libs/dispatch) |
PickSlips. |
stock.held |
slip.issued, slip.rejected, stock.release (poison) |
Shared (libs/shared) |
The relay, the consumer loop with retry and dead-letter, the Kafka log, auth primitives, middleware. Each module owns its own OutboxMessages and InboxMessages tables. |
RabbitMQ topology is declared in code (libs/shared/Messaging/Topology.cs): exchange warehouse.work, one queue per module (inventory.commands, dispatch.work, orders.events), a .retry queue per module (2 s TTL, then back to the main queue, 3 attempts), and a .dlq per module behind warehouse.dlx. A transient failure retries; a poison message goes straight to the dead-letter queue after its rejection is committed. Kafka has one topic, warehouse.events, one partition, replication factor 1, keyed by order id.
One deployable (apps/api), several libraries. Each business module is its own class library with its own DbContext, its own Postgres schema (identity, orders, stock, dispatch), its own migrations and its own outbox and inbox tables. No module references another; the only shared code is Warehouse.Shared, and the one cross-module read (a SKU's existence and pricing inputs) goes through an interface, ISkuCatalog, that Inventory implements and Orders consumes.
flowchart TB
api["apps/api: composition root, middleware, endpoints"]
api --> identity & orders & stock & dispatch
identity["libs/identity: users, roles, JWT, refresh tokens"]
orders["libs/orders: schema orders"]
stock["libs/inventory: schema stock"]
dispatch["libs/dispatch: schema dispatch"]
identity & orders & stock & dispatch --> shared["libs/shared: messaging, outbox/inbox, auth primitives, middleware"]
orders -. "ISkuCatalog" .-> stock
Modules still talk only through messages: RabbitMQ carries the commands, Kafka keeps the event log, and the outbox and inbox make delivery at-least-once and consumption idempotent.
| Piece | How it works |
|---|---|
| Accounts | ASP.NET Core Identity. Passwords need 10+ characters with upper case, lower case and a digit, and 4 distinct characters. Five wrong passwords (or codes) lock the account for 15 minutes (429). A wrong password and an unknown email give the same 401. |
Registration mails a confirmation link; with Auth:RequireConfirmedEmail on (the default) sign-in is refused (403) until it is opened. "Forgot password" mails a one-time reset link and answers 202 for every address, known or not. Messages go through IAuthMailer: SMTP when Mail:Host is set, the log otherwise. The demo stack also keeps them in a dev mailbox at /api/dev/mailbox (off by default). Link tokens are protected with data-protection keys stored in Postgres, so every instance and every restart can read them. |
|
| Two-factor | TOTP (any authenticator app): POST /api/auth/mfa/setup returns the key and an otpauth:// URI, enable proves it with a code and returns eight one-time recovery codes, disable needs the password and a code. Once on, sign-in needs a code (401 A verification code is required.). |
| Access token | JWT, 15 minutes, held in memory by the Angular app and sent as Authorization: Bearer. HS256 with a key of at least 32 bytes, or RS256 when Jwt:RsaPrivateKeyPem is set, in which case the public key is served at /.well-known/jwks.json so other services can verify tokens without a secret. The API refuses to start without an usable key. |
| Revocation | Each token carries the user's session version. A password change, a reset, turning two-factor off and "sign out everywhere" bump it (one atomic UPDATE), and every token dispatched earlier stops working on every instance within Jwt:RevocationCacheSeconds (default 5). |
| Refresh token | 256 random bits in an HttpOnly, SameSite=Strict, Path=/api/auth cookie (Secure over HTTPS). Only its SHA-256 is stored. Every refresh rotates it with a conditional UPDATE, so two concurrent refreshes with the same token cannot both win. Presenting a token that was already used revokes the whole family. Refresh and logout also need an X-Requested-With: warehouse-web header, so another site cannot trigger them. |
| Roles | Customer (default at registration), Staff, Admin. An administrator is seeded from configuration on first start. |
| Rules | Anonymous: /api/health, /api/auth/*. Any signed-in user: read skus, book, read and cancel their own orders and dispatch. Staff and Admin: open skus, read everything, read the event log. Another user's order or slip is 404, not 403, so ids do not leak. The owner of an order is the caller; a body field cannot set it. |
| Messaging | The outbox is drained by any number of relays at once (FOR UPDATE SKIP LOCKED, so no row is published twice at the same time) and trimmed on a schedule. Staff can look inside the dead-letter queues and replay them from the API. |
| Hardening | A rate limit on /api/auth/* per client (RateLimit:AuthPerMinute), counted in Postgres so every API instance shares one count, security headers on every response (nosniff, DENY, strict CSP, no-referrer), a correlation id echoed in X-Correlation-Id and in every problem response, JSON logs (Logging:Json), forwarded headers only when ForwardedHeaders:Enabled, a fallback policy that makes every endpoint authenticated unless it opts out, and a readiness endpoint that checks every module schema. |
Needs Node 22 (npm 10), .NET SDK 10.0.401 (global.json), Docker (arm64 is fine) and python3 for the smoke script.
npm ci
dotnet test tests/Warehouse.UnitTests # 124 tests, no Docker
docker compose up -d --wait db # the integration tests use Postgres on 5473 (database warehouse_test)
docker compose exec db createdb -U warehouse warehouse_test # once
dotnet test tests/Warehouse.IntegrationTests
docker compose up --build --wait # db, kafka, rabbitmq, api, web
./scripts/smoke.sh # last line: warehouse smoke passed
npx playwright install chromium # once
npx playwright test # the browser specs against http://127.0.0.1:8093
docker compose down # keeps the Postgres volume; `down -v` drops it| Service | Host port |
|---|---|
Web (nginx, proxies /api/) |
8093 |
API (/scalar/v1, /api/health) |
5213 |
| Postgres 17 | 5473 |
| Kafka 3.8.1 (KRaft, one broker) | 9123 |
RabbitMQ 3.13 / management UI (platform / platform) |
5703 / 15703 |
Inside the Compose network the API and nginx listen on 8080 and Kafka's internal listener is 9092.
The web app is at http://127.0.0.1:8093 (admin@warehouse.local / WarehouseAdmin2026 in the demo stack, or register a customer). From the shell:
API=http://127.0.0.1:5213
login() { curl -s -X POST $API/api/auth/login -H 'content-type: application/json' -d "{\"email\":\"$1\",\"password\":\"$2\"}" | python3 -c 'import sys,json; print(json.load(sys.stdin)["accessToken"])'; }
ADMIN="Authorization: Bearer $(login admin@warehouse.local WarehouseAdmin2026)"
curl -s -X POST $API/api/auth/register -H 'content-type: application/json' \
-d '{"email":"ana@example.com","password":"Passw0rd-Demo1"}' # 201; its accessToken goes in $ANA below
ANA="Authorization: Bearer <accessToken>"
curl -s -H "$ADMIN" -X POST $API/api/skus \
-H 'content-type: application/json' \
-d '{"code":"WIDGET-BLUE-1","name":"Blue Widget","category":"Hardware","bin":"Bin A-01","receivedUnits":40}'
curl -s -H "$ANA" -X POST $API/api/orders \
-H 'content-type: application/json' \
-d '{"skuCode":"WIDGET-BLUE-1","reference":"ORD-1001","units":12}'
# 202, status Requested, feeCents 2200. Use the returned id:
curl -s -H "$ANA" $API/api/orders/<id> # Dispatched after a few seconds, with a pick slip number
curl -s -H "$ANA" $API/api/slips/<id>
curl -s -H "$ANA" $API/api/skus/WIDGET-BLUE-1 # onHandUnits 28
curl -s -H "$ADMIN" $API/api/orders/<id>/events # the Kafka log for this order
curl -s -H "$ANA" -X POST $API/api/orders/<id>/cancellation \
-H 'content-type: application/json' # units come back; the pick slip staysAn order is validated at the door: reference required (at most 40 characters), 1 to 50 units. The shipping fee is 400 cents plus 150 cents per unit. The poison match is a case-sensitive substring: ORD-POISON-7 and any longer token containing POISON match.
The repository is an Nx workspace (nx.json, plugin @nx/dotnet). npx nx show projects lists api, web, the four libraries and both test projects.
docker compose up -d --wait db kafka rabbitmq # the brokers and Postgres, not the app
npx nx serve api # http://localhost:5213 (Development: seeded admin, public docs)
npx nx serve web # http://localhost:4290, proxies /api to the API
WEB_URL=http://localhost:4293 npx playwright test # the same browser specs, against the dev servers
npx nx run-many -t typecheck lint -p web # tsc --noEmit and ESLint (angular-eslint)
npx nx build web && npx nx build api # what CI builds- Unit tests (
tests/Warehouse.UnitTests, 124 tests, no Docker, about 3 seconds): the order rules and fee, the poison rule including integer overflow, token creation and validation, password and lockout behaviour of the auth service on an in-memory store, owner-or-staff access, the retry policy and topology, message serialization, the outboxDbContextconventions, and the HTTP middleware (problem details areapplication/problem+json, security headers, correlation ids). - Integration tests (
tests/Warehouse.IntegrationTests, 67 tests, real Postgres): the stock race (two tasks, twoDbContexts, one unit: oneHeld, oneShort, no hold for the loser) and the check constraint behind it; the saga handlers against the real schema (duplicate delivery claimed once, a release returns the units once, the poison rejection committed before the dead-letter, cancellation then late final mark); and the whole HTTP pipeline throughWebApplicationFactory: register, login, wrong password, lockout, expired and tampered tokens, refresh rotation, replay revoking the family, two concurrent refreshes (exactly one wins), logout, the same-category header, the auth rate limit, and 401/403/404 for every route and ownership case. The race test was run against a read-then-write version of the hold, where it failed, and against the conditional update, where it passes. scripts/smoke.shdrives the composed stack: authentication and ownership first (401, 403, 404), then validation, the happy path (fee, pick slip, Kafka log), the last unit with three concurrent orders, the poison reference (rejected,dispatch.work.dlqgains one message, units restored), and a cancellation that lands between the pick slip and the final mark. To make that last window wide enough to hit on purpose, Compose setsOrders__FinalMarkDelayMs=1500; it is a latency knob and defaults to 0.- Playwright (
e2e/specs, 14 tests, Chromium):auth.spec.ts(anonymous sees only the form, wrong password, password policy, a customer books and sees only their own orders with no staff controls, sign-out, the session surviving a reload through the cookie whiledocument.cookiestays empty);place-order.spec.ts(open a SKU, book, pick slip, reload, cancel);ui-flows.spec.ts(refusal messages, the poison rejection, the loser of a race, the Kafka event log). They run against the composed web port and against the Nx dev servers. - CI (
.github/workflows/ci.yml) has two jobs.verify:npm ci, Prettier check,dotnet format whitespace --verify-no-changes, unit tests, integration tests (Postgres 17 service) with coverage uploaded, a NuGet vulnerability check,npm audit,nx typecheckandnx lintfor web (zero warnings allowed) andnx build.e2e: builds the Compose stack, runs the smoke and every Playwright spec, and uploads traces and prints logs on failure. Dependabot watches NuGet, npm, Actions and Docker.
This repository runs on Compose. Nothing in it calls a cloud account.
| Here | On AWS |
|---|---|
| Postgres 17 | RDS for PostgreSQL |
| Kafka 3.8 | MSK |
| RabbitMQ 3.13 | Amazon MQ, or SQS with a dead-letter queue |
| The API and the web app | ECS or App Service |
JSON over HTTP. Everything except health and /api/auth/register|login|refresh|logout needs a bearer token. Interactive docs are at http://127.0.0.1:5213/scalar/v1 (OpenAPI at /openapi/v1.json) when Docs:Public is true, which Compose and Development set; otherwise they need a staff token.
| Method and path | What it does | Responses |
|---|---|---|
GET /api/health, GET /api/health/ready |
Liveness; readiness (every module schema reachable). | 200, 503 |
POST /api/auth/register |
Creates a customer and mails a confirmation link. Signs them in unless confirmation is required. | 201 signed in, 202 check your inbox, 400 policy, 409 email taken, 429 |
POST /api/auth/login |
Signs in (with code when two-factor is on); sets the refresh cookie. |
200, 401, 403 unconfirmed, 429 locked or rate limited |
POST /api/auth/refresh, POST /api/auth/logout |
Rotate or revoke the refresh cookie. Need X-Requested-With: warehouse-web. |
200/204, 400 header missing, 401 |
POST /api/auth/confirm-email, resend-confirmation |
Confirm an address with the emailed token; ask for a new link (always 202). |
204/202, 400 |
POST /api/auth/forgot-password, reset-password |
Mail a reset link (always 202); set a new password with it (ends every session). |
202/204, 400 |
POST /api/auth/change-password, logout-everywhere |
Signed in: change the password (ends the other sessions and returns a fresh one); end every session on every device. | 200/204, 400, 401 |
GET /api/auth/mfa, POST /api/auth/mfa/setup, enable, disable |
Two-factor status and lifecycle (see above). | 200/204, 400, 409 |
GET /.well-known/jwks.json |
The public key set when RS256 is on. | 200, 404 |
GET /api/auth/me |
The caller. | 200, 401 |
POST /api/skus |
Adds a SKU with the units received. Staff. | 201, 400 invalid, 403, 409 code exists |
GET /api/skus, GET /api/skus/{code} |
Skus with the live on-hand units. | 200, 404 |
POST /api/orders |
Accepts an order (1 to 50 units) for the caller and starts the saga. | 202 Requested, 400 invalid, 404 unknown SKU, 409 duplicate reference |
GET /api/orders?skuCode=&page=&pageSize= |
The caller's orders, newest first, a page at a time (pageSize at most 100, default 100). Staff: everyone's. The total is in X-Total-Count. |
200 |
GET /api/orders/{id} |
One order and its status. Owner or staff. | 200, 404 |
POST /api/orders/{id}/cancellation |
Moves a held or dispatched order to Cancelled and gives the units back. The pick slip is not touched. Owner or staff. |
202, 404, 409 wrong status |
GET /api/orders/{id}/events |
The Kafka event log for one order. Staff. | 200, 403 |
GET /api/admin/dead-letters, POST /api/admin/dead-letters/{queue}/replay |
What waits in each dead-letter queue, with the first messages; publish them again. Staff. A message that still fails for the same reason is dead-lettered again. | 200, 403, 503 brokers off |
GET /api/slips/{orderId} |
The pick slip row. Owner or staff. | 200, 404 |
Errors come back as application/problem+json with a title and the correlationId.
Compose sets these on the API container. Defaults in apps/api/appsettings.json point at the published host ports, so nx serve api works against docker compose up -d --wait db kafka rabbitmq.
| Setting | Compose value | Meaning |
|---|---|---|
ConnectionStrings__Warehouse |
Host=db;Port=5432;Database=warehouse;Username=warehouse;Password=warehouse |
The one Postgres database. Migrations run on startup. |
RabbitMq__Host / __Port / __User / __Password |
rabbitmq / 5672 / platform / platform |
Work queue. Virtual host /. |
Kafka__BootstrapServers |
kafka:9092 |
Event log. |
Jwt__Key |
${JWT_KEY} or a demo key |
HS256 signing key, at least 32 bytes. Required; startup fails without it. |
Jwt__AccessMinutes / __RefreshDays / __SecureCookies |
15 / 14 / false |
Token lifetimes; set SecureCookies when TLS ends in front of the API. |
Identity__SeedAdmin__Email / __Password |
${ADMIN_EMAIL} / ${ADMIN_PASSWORD} |
Administrator created on first start. |
Auth__RequireConfirmedEmail / Auth__PublicUrl |
false (demo) / http://127.0.0.1:8093 |
Sign-in waits for email confirmation (code default true); the address links in emails point to. |
Mail__Host / __Port / __User / __Password / __From / __StartTls |
unset | SMTP for confirmation and reset emails. Unset means the log only. |
Mail__DevMailbox |
true (demo) |
Serve the last messages at /api/dev/mailbox. Never on in production. |
Jwt__RsaPrivateKeyPem / Jwt__KeyId |
unset | Sign with RS256 and publish the public key at /.well-known/jwks.json. |
Jwt__RevocationCacheSeconds |
2 (code default 5) |
How long an instance trusts a cached session version before re-reading it. |
RateLimit__AuthPerMinute |
120 (code default 20) |
Requests a minute per client to /api/auth/*. |
ForwardedHeaders__Enabled |
true |
Trust X-Forwarded-* from the reverse proxy (nginx here). Leave off when the API is reached directly. |
Docs__Public |
true |
Serve Scalar and OpenAPI without a token. |
Logging__Json |
true |
Structured JSON console logs. |
Messaging__OutboxRetentionDays / Messaging__InboxRetentionDays |
7 / 30 |
Sent outbox rows and old inbox claims are deleted after this long. The inbox is kept longer because it must outlive any redelivery. |
Orders__FinalMarkDelayMs |
1500 |
Milliseconds the final mark waits. A latency knob so the smoke can land a cancellation inside the window. 0 outside Compose. |
WAREHOUSE_TEST_DB (tests only) |
Postgres connection for dotnet test. Defaults to localhost:5473, database warehouse_test. CI points it at its service container. |
docker compose ps # five services, all healthy
docker compose logs -f api # relay, consumers, poison and retry lines
docker compose exec db psql -U warehouse -d warehouse -c 'select "RoutingKey","SentAt" from "OutboxMessages" order by "Id" desc limit 10'
open http://127.0.0.1:15703 # RabbitMQ management, platform / platform- Dead-lettered messages sit in
dispatch.work.dlq. Staff can list and replay them from/api/admin/dead-letters, or inspect them in the management UI. Retries wait in<queue>.retryfor 2 seconds. - A port is already in use:
lsof -nP -i :5213shows who holds it. Compose publishes only on127.0.0.1. dotnet testcannot connect: start Postgres first withdocker compose up -d --wait db.- The smoke cannot reach the API: run
docker compose up --build --waitfirst; override the target withAPI=... RABBIT=... ./scripts/smoke.sh. - Start clean:
docker compose down -vdrops Postgres, Kafka and RabbitMQ data. Plaindownkeeps them, and the smoke is safe on kept data because every code carries a run id. - The Kafka log looks empty right after an order: the relay publishes within a second or so; reload the event log.
- Sign-in is email and password plus optional TOTP. There are no external identity providers (Google, Microsoft) and no WebAuthn passkeys.
- Revocation is eventual by design: an instance may honour a revoked access token for up to
Jwt:RevocationCacheSecondsseconds. Set it to0to check the database on every request. - Delivery is at-least-once, not exactly-once. The inbox makes repeats harmless for the saga; the Kafka log can hold a duplicate event after a relay crash.
- Compose runs one of each broker (one Kafka partition, replication factor 1) and one API instance. The code itself is built for several API instances: the relay claims outbox rows with
FOR UPDATE SKIP LOCKED, and the rate limit and revocation live in Postgres. A production Kafka and RabbitMQ would be clustered; that is configuration, not code. GET .../eventsreads the Kafka topic for one key and gives up after ten seconds, so it scans the topic. Fine here, not something to expose at scale.- Replaying a dead letter only helps when the cause was fixed: the poison reference fails again by design.
- The browser specs drive Chromium at a desktop size only, and the
e2eCI job needs Docker and takes a few minutes.
apps/api thin host: composition root, middleware, endpoints
apps/web Angular 21, styled with Tailwind 4 utilities only (sign-in, role-aware workspace)
libs/shared messaging (outbox, inbox, relay, consumers), auth primitives, middleware
libs/identity users, roles, JWT, refresh tokens (schema identity)
libs/orders order rules and the saga's first step (schema orders)
libs/inventory the only writer of the on-hand units (schema stock)
libs/dispatch pick slips (schema dispatch)
tests/ Warehouse.UnitTests, Warehouse.IntegrationTests
e2e/ Playwright
scripts/ smoke.sh
compose.yaml Postgres, Kafka, RabbitMQ, API, web
Nx 23.2.1 orchestrates nx build web and nx build api; Each module's EF Core migrations are committed under its library and the API applies them on startup. Packages are pinned centrally in Directory.Packages.props, and warnings are errors (Directory.Build.props).
- golang-warehouse: this system in Go on Kubernetes, with the same API and UI.
- dotnet-freight: container space on ocean sailings.
- dotnet-clinic: appointment slots in a provider session.
- dotnet-ledger: outgoing payments from an account balance.
- dotnet-academy: course cohort seats and enrollments.
- dotnet-compute: GPU-hour reservations in a pool.
- dotnet-hotel: hotel room-nights.
- dotnet-tickets: event ticket tiers and orders.
- dotnet-carbon: carbon credit batches and purchases.
- dotnet-charging: EV charger slot reservations.
- dotnet-promo: limited-use promo codes and redemptions.
- dotnet-mint: limited-edition drops with a per-collector limit.
- dotnet-pledge: matched donations from a sponsor's matching pool.
- dotnet-bistro: table reservations with a first-come waitlist.
- dotnet-flash: flash-sale deals with holds that expire.
- dotnet-encore: gig seats with price steps as the gig sells.
- dotnet-atelier: workshop seats with an all-or-nothing laptop kit bundle.
- dotnet-sole: sneaker raffles with a draw anyone can verify.
