Ticketing for a 300,000-place event
In the Ticketmaster walkthrough, we sold out a 70,000-seat stadium. Here we quadruple the inventory, and you might expect the database to take the hit. It does not. Most of the stadium design still holds, just in different places: the sale drags on longer, your payment provider becomes a bottleneck, active holds mask a huge chunk of the stock, and event day turns into its own logistics problem.
We will walk through the interview using one worked example, with every figure computed by code: the throughput gates, a second-by-second inventory simulation, the waiting room, quota buckets, a payment replay and the entry lanes. You can tweak the numbers yourself in the calculator.
The question
“Design the ticketing for an event with 300,000 places. Most of them go on sale at once.”
At first glance, this sounds like the classic Ticketmaster problem on a bigger stadium. Except no such stadium exists: the largest seated venues hold roughly 100,000 to 130,000 people. So the first thing to put on the table is that 300,000 is not a seat map.
1. What “300,000” means, and the requirements
Events of this size are real, and they look nothing like a concert hall. Take the 2025 Indianapolis 500, which expected about 350,000 spectators: every reserved grandstand seat sold out while infield general admission stayed open. Major festivals are mostly general admission — day tickets, multi-day passes and a few premium zones. A stadium tour spreads demand across many 50,000-to-70,000-seat dates. Each shape gives you a different inventory model.
And 300,000 is rarely a single performance. A festival sells three days and several stages, a tour sells a dozen dates, a race sells one day. For the system, the performance is the unit of inventory: each has its own capacity, its own zones and its own gates on the day. The event is the unit of the on-sale: its performances often open at the same moment, and then one queue can serve them all while fans pick a date inside. Whether it should is a choice we come back to in section 4.
Questions to ask out loud
| Ask | Why the answer changes the design |
|---|---|
| Does 300,000 mean people on site at once, unique visitors, or the sum across several days? | Decides what you are counting: people inside the grounds, passes sold, or daily entries. |
| Reserved seats, general admission, or both? | Reserved seats need one owner per seat; general admission needs an exact count per zone. |
| How many tickets go on public sale? | Guest, partner and staff allocations shrink the public pool, and third-party sellers need their own ring-fenced share. |
| How many people will be in the queue, and how fast must it sell? | Capacity tells you nothing about demand. Selling out in fifteen minutes or over three days calls for very different infrastructure. |
| Tickets per order, and must a group sit together? | Sets total order volume and whether a single claim has to grab multiple items together. |
| How long is a hold, and how do people pay? | Tells you how much stock gets tied up in holds, and how you must handle slow payments. |
| What does fair mean: first come, a ballot, priority groups? | A product rule your queue has to enforce — and prove it enforced. |
| What is at the gates: network, power, staff? | Decides whether scanners can check tickets online, locally, or not at all. |
For our worked example, take the toughest common case: one on-sale of 300,000 general-admission tickets in total, 2 per order, with 5 million fans waiting in the queue at launch. The queue and the payment path barely care whether those places belong to one performance or several; inventory does, so we start with a single pool and split it into days in the multi-day section. Reserved seats work just as in the Ticketmaster walkthrough.
Functional
- Show the event, ticket types, full pricing and approximate availability.
- Place fans in a queue, preserve their spot across reconnects, and admit them at a controlled rate.
- Claim an entire order together (all tickets or none) and hold it with a clear deadline.
- Process payment cleanly through timeouts, retries and late confirmations.
- Issue tickets buyers can re-fetch without hunting for an email, and validate each one once at the gate.
- Support refunds, full-event cancellations, and an operator switch to pause or throttle admission.
- Flag and park for later: resale and transfers, parking and camping, dynamic pricing.
Non-functional, in order
- Never sell past the licensed capacity. Festival capacity is a safety licence, enforced per zone and per day. Overselling is not a customer-support headache — it is a crowd-safety risk.
- Every charge has an explainable state. No double charges, and no payment left hanging without either a ticket or a refund.
- Entry keeps working when the internet drops. Agree up front on which guarantee survives a lost connection.
- Your core only sees the load you choose, no matter what hits the edge.
- Fairness: everyone who joins on time gets a random spot in the queue, one entry per verified account. One entry per person needs identity checks, and that is a product decision.
- Availability counts during the sale and at the gates, not as a comfortable yearly average.
2. Capacity is not demand, and demand is not throughput
People mix up three very different numbers here. Capacity is 300,000 tickets. Demand is 5 million fans in the queue. Throughput is how many shoppers per second your system can actually serve — and neither of the first two determines it. Throughput is bounded by three gates, and the slowest one sets the pace for the whole sale.
Try your own sale
Tweak the inputs below. The table runs the exact same code — simulation included — behind every figure in this article, and highlights whichever gate sets the pace.
| Quantity | Working | Result |
|---|---|---|
| Gate 1: sessions | 100k ÷ 5 min | 333/s |
| Gate 2: payment provider | min(250 ÷ 1.2, 1k ÷ 2.4) ÷ 60% | 347/s |
| Gate 3: inventory core | 32 × 100/s ÷ 3 | 1.07k/s |
| Admission rate | the lowest gate: sessions | 333/s |
| Chance for a fan who would buy | 150k ÷ (5M × 50%) | 6% |
| Site first looks sold out | simulated, second by second | 9.98 min |
| 99% actually sold | simulated, second by second | 37.4 min |
| Tickets in holds at the peak | 140k ÷ 300k | 47% |
| Burst with no queue | 5M ÷ 1 min | 83.3k/s |
| Queue-page polling | 5M ÷ 10 s | 500k/s |
For the payment row, we assume 60% of admitted shoppers start paying, making 2 provider calls per attempt plus 20% for retries; the account-wide cap is four times the per-endpoint limit, matching the provider’s defaults. For the core row, each claim holds its quota lock for 10 ms, with 3 claim attempts per shopper. Each session lasts 5 min, and 50% of admitted shoppers finish buying.
Sessions. Serving 100,000 shoppers at once for 5 min each lets you admit 333 people a second, straight from Little’s law. Same maths as the stadium.
The payment provider. Almost nobody mentions this gate in an interview. At our example’s pace, 167 orders finish every second, and even more start: roughly 200 payment attempts a second, each firing a couple of API calls. Out of the box, Stripe caps you at 100 requests a second per account, 25 a second per endpoint, and 50 requests in flight. Leave those defaults alone and you can only admit 34.7 shoppers a second, stretching the time to sell 99% of tickets from 37.4 min to 2.5 h. You can get the limits raised, but Stripe asks for at least 6 weeks’ notice for a big bump — which puts your payment provider on the project timeline, not just as a box on the architecture diagram.
The inventory core. Anything serialised can finish only one claim per lock cycle. If each claim locks a counter for 10 ms, that counter tops out at 100 claims a second. Split the stock across 32 quotas and your ceiling jumps to 3,200 claims a second — well ahead of the other two gates. Stick with a single counter, though, and it chokes the sale at 33.3 admissions a second.
| Scenario | Sessions | Payment provider | Inventory core | Sale runs at | 99% sold after |
|---|---|---|---|---|---|
| Provider defaults (25/s per endpoint) | 333/s | 34.7/s | 1.07k/s | 34.7/s | 2.5 h |
| Limits negotiated (250/s) | 333/s | 347/s | 1.07k/s | 333/s | 37.4 min |
| Negotiated, but one inventory counter | 333/s | 347/s | 33.3/s | 33.3/s | 2.6 h |
Notice what did not budge: quadrupling the inventory added zero load to the core. Only trying to sell faster does that. At this pace, a ready buyer has a 6% shot at tickets, while your edge still has to soak up 83,333 arrivals a second and 500,000 queue polls a second, which stay off your origin only if they all poll one shared, cached answer (section 4).
3. The phantom sell-out
A ticket does not jump straight from available to sold. In between, it sits in a hold while someone hunts for their card, and then waits on an in-flight payment. Those four states always sum to total capacity, and mistaking “nothing available” for “sold out” is the most public blunder a big sale can make.
- Sold
- Payment in progress
- Held
- Available
- Looks sold out, is not
Watch the simulation play out second by second. Just 9.98 min in, available stock hits zero — a naive site flashes “sold out”. Yet at that exact moment, up to 140,000 tickets (47% of the entire event) are only sitting in holds and active payments. Half of all admitted shoppers abandon checkout, so their tickets come back a few minutes later, wave after wave. We do not hit 99% sold until 37.4 min, and the final ticket goes at 1.51 h. In fact, 33% of all tickets went to fans admitted after the site first looked empty.
| Admission policy | Told “sold out” while tickets were only held | 99% sold after |
|---|---|---|
| Admit at the gate rate, whatever is left | 1,509,001 | 37.4 min |
| Admit only while tickets are available | 0 | 37.4 min |
Two design calls fall straight out of this. First, your admission controller needs a fourth signal alongside the three gates: real available stock. Wave people into a shop with bare shelves and you turn away 1.5 million of them while tickets are merely held. Instead, admit only as many shoppers as there is stock for, nobody at all while the shelves are empty, and tell fans the truth right on the queue page: “Everything is in holds right now; tickets are coming back.” Second, hold duration is a product call with a visible trade-off. A 5 min hold gives slow payers breathing room but stretches the tail; a shorter hold recycles abandoned tickets faster. Either way, show held tickets as held, never as gone.
4. A waiting room for five million
The Ticketmaster walkthrough explains why a big sale needs a waiting room. With 5 million people in it, the waiting room becomes a distributed system in its own right, with three hard parts: an order nobody can rig, a status millions can read without touching your servers, and an admission step that survives retries, no-shows and its own failures.
Before the start: a lobby, then one draw
The 83,333 arrivals a second from section 2 happen because everyone rushes in during the last minute, and they rush because the last minute is when places are handed out. Take that reason away. Open a lobby 30 minutes before the sale and promise that everyone inside at the start gets the same odds. The same 5 million joins now average 2,778 a second, and refreshing at 9:59:59 buys nothing.
Joining returns a signed queue token: one entry per account, and a refresh or a second tab gets the same entry back. At the start the list of entries freezes, and you publish its hash before the next value of a public randomness beacon exists. Each entry’s place is then hash(beacon value, entry id), read as a number between 0 and 1. You cannot reshuffle the list after seeing the value, and nobody can predict the value in advance. With a secret seed of your own you could, and that is the first thing an auditor will ask about. A useful side effect: the beacon value goes into the shared status, so every browser works out its own place from the entry id in its token, and nobody has to deliver five million personal positions the moment sales open.
People who arrive after the start get sequence numbers above 1, so they queue behind the drawn group in arrival order. Strict order needs a single sequencer. Handing out numbers in blocks per server removes the hot counter but makes the order approximate within a fraction of a second, and that is worth saying aloud. Either way, a place is a fixed number, not an index in a list: when someone ahead leaves, nobody’s number changes; the cursor just reaches you sooner. And a draw only evens the odds between valid entries. Against someone holding a thousand accounts you need verified presales, accounts created before the sale, a challenge or proof of work at the door, and per-card limits at checkout.
Five million people reading one number
If every browser asks “am I in yet?” with its own cookie, that is 500,000 uncacheable requests a second against your origin. Split the question in two. The private half, your entry id, lives in your signed token, and your place follows from it. The public half is one small object, identical for everyone: the cursor (“every place below this number may come in”), the size of the drawn group, so the page can say “about N people ahead”, the state (waiting, running, paused, sold out), the current pace and what is left of each performance. It carries no cookies and no per-user parameters, and the CDN caches it for 2 s. The browser compares the two halves itself.
| Request | Per second | Who answers |
|---|---|---|
| Joins, if everyone comes in the last minute | 83,333 | Queue service |
| Joins, spread over the lobby | 2,778 | Queue service |
| Status polls, everyone every 10 s | 500,000 | Edge (CDN) |
| Status polls, less frequent at the back of the queue | 169,333 | Edge (CDN) |
| Status reads that reach the origin | 10 | Queue service |
| Turns traded for a pass | 333 | Queue service |
| Hold attempts | 1,000 | Shop and inventory |
| Payment attempts started | 200 | Payment provider |
The edge still answers 500,000 requests a second, about 250 MB/s of traffic. But with 20 shield caches refreshing every 2 s, the origin sees around 10 requests a second. Polling does not have to be uniform either: only the 40,000 people within 2 min of the front need to check every 10 s, and everyone else can check every 30 s, which brings even the edge down to 169,333 a second. Add jitter so the polls do not arrive in waves. Pushing over SSE or WebSockets would mean five million open connections to deliver a value that lets in another 3,333 people between two polls. Push suits the shoppers already inside, not the queue.
Base the wait estimate on how fast the cursor actually moved over the last minute, not on the nominal pace: pauses and slowdowns stretch real waits. Even then, do not promise the back of the queue a turn in 4.17 h when 99% of the tickets are gone after 37.4 min: expect only about 6% of the queue to reach the shop. Say so early, and the moment the last ticket sells, flip the shared state to “sold out” so millions of tabs stop polling within one interval.
Admission: trade your place for a pass
The admission controller is the only writer of the cursor. Every second it advances the cursor by as many people as the slowest gate currently allows (at most 333), and never further than there is stock for. That is the stock-aware policy from section 3: with it, the simulation turns away nobody instead of 1.5 million. While everything left is in holds, the state reads “paused”, not “sold out”. Sold out comes only from the inventory itself, and only when every performance is gone.
A browser that sees the cursor pass its place calls the origin once. That is 333 calls a second instead of 500,000, 1,500 times fewer. The server checks the queue token’s signature, that the place really is below the cursor and the offer has not expired, and marks the entry as used in one atomic step; a retry gets the same answer back. In return it issues a short-lived admission pass bound to the account, the session and the event. The reservation API checks that pass on every new hold: signature, expiry, binding. The signature check is local, while one use per entry (in the queue store) and per-buyer limits (in the shop) need real state. The pass gates new holds, not paying for a hold you already own; otherwise a slow payment dies when the pass expires.
Some people never come back for their turn. Give each offer 2 min; when it lapses, free its slot and move the cursor on. Count unclaimed offers against the sessions gate: over 2 min at 333 a second, that is up to 40,000 people who could all walk in at once.
One queue, or one per performance
When several performances go on sale together, this is a choice. One queue for the whole event is simpler and fairer: one draw, one place, and fans pick a date inside. The price is that the status object must carry what is left of each performance, so people waiting for a sold-out Saturday can leave instead of spending a turn. A queue per performance spreads the load and lets each date sell at its own pace, but it invites everyone to join every queue, so you then need a rule such as one active turn per account.
When parts of it fail
- The queue store goes down. The edge keeps serving the last status, shoppers already inside carry on (their passes verify locally), and new admissions pause. Never fail open: that lets 5 million people into your core at once. A degraded trickle is safe only with a budget allocated globally in advance; “every edge node lets a few through” adds up to a rate nobody chose.
- The controller crashes. The cursor freezes, which is safe. A standby takes over through a lease with a fencing token, and the cursor only moves forward through a conditional write, so two controllers can never both advance it.
- The cache serves a stale or forged cursor. A stale one only delays admission by one cache interval, and a forged one cannot mint a pass, because the exchange checks the real cursor on the server. Sign the status anyway, so a broken cache cannot send millions of browsers to the exchange at once.
- Clocks drift. Start time, deadlines and countdowns come from server time in the status object, never from the visitor’s clock.
The invariant underneath it all: the waiting room protects availability and fairness, not correctness. If a bot slips past it, the conditional update in the inventory and the idempotent payment still never sell a ticket twice.
Answers that lose points
- “Put everyone in Kafka or a Redis list and pop 333 a second.” A broker cannot shuffle a lobby or hand a popped entry back to a browser that reconnected, and popping an entry does not prove the person is still there.
- “Keep a WebSocket open to every fan.” Five million connections to announce one number.
- “Rate-limit by IP.” A university or a mobile carrier puts thousands of real fans behind one address, while bots rotate through residential proxies. Limit per account and per pass.
- “Advance the cursor by 333 every second.” A fixed pace ignores empty shelves, no-shows and a slowing payment provider.
5. General admission: a counter, split into quotas
Once you drop seat numbers, a ticket type is just a counter, and claiming from it is a single conditional update:
UPDATE quotas
SET remaining = remaining - :n
WHERE zone = :zone AND quota_id = :q AND remaining >= :n
One row updated means the tickets are yours; zero means this quota cannot fill the order. Because a single counter caps the whole sale at 100 claims a second, you split the stock into multiple quotas. The word that matters here is own: each quota owns a separate slice of inventory, and together they add up to the exact capacity. Spreading a single counter’s value randomly across shards does not work, because no shard would know how much it is allowed to sell.
| Quotas | Claims a second, ceiling | Sold when the first quota ran dry | Tickets elsewhere at that moment | Transfers to finish |
|---|---|---|---|---|
| 1 | 100 | 100% | 0 | 0 |
| 8 | 800 | 99% | 4,294 | 19 |
| 32 | 3,200 | 96% | 10,702 | 83 |
| 128 | 12,800 | 93% | 22,126 | 392 |
The catch shows up near the end of the sale. Traffic never spreads perfectly evenly, so one quota runs dry while others still have stock left. With 32 quotas, the first one empties once 96% of tickets are sold, leaving 10,702 tickets sitting elsewhere. If that empty quota simply replies “sold out”, everyone routed there gets a false rejection. Instead, it pulls stock from the fullest quota — safely, inside one transaction or via a transfer record both sides agree on, so a timeout can never leave two quotas claiming the same tickets. Finishing our sale takes just 83 transfers, barely a blip. More quotas raise both your throughput ceiling and your transfer count, so pick the smallest number that comfortably clears the other gates.
A multi-day pass
Now suppose it is a three-day festival with 100,000 places a day — 300,000 day-entries in all. A single-day ticket takes one spot on its day, while a three-day pass claims one spot on all three counters at once, all or nothing. Always lock the days in the same order (Friday, Saturday, Sunday) so concurrent claims can never deadlock.
| Day | Used per order in the mix | Left when the first day sells out |
|---|---|---|
| Friday | 0.55 | 21,429 |
| Saturday | 0.70 | 0 |
| Sunday | 0.55 | 21,429 |
Everyone wants Saturday, so Saturday sells out first. The moment it does, every three-day pass request fails — even with 21,429 places still open on both Friday and Sunday. Day-ticket buyers can still take those spots, but pass buyers are out of luck. Whether you live with that is a product call: if multi-day passes are a priority, carve out a dedicated pass quota across all three days before launch and sell day tickets from what remains.
6. 300,000 places do not help a 3,000-place zone
Looking at total capacity hides the real hot spots. Fans pile into a few favourite zones, and each zone sits behind its own counter with its own ceiling.
| Zone | Places | Share of demand | Claims a second | Load on one counter | Quotas for ≤ 50% | Sold out after |
|---|---|---|---|---|---|---|
| Field | 252,000 | 55% | 550 | 550% | 11 | 22.9 min |
| Front of stage | 45,000 | 30% | 300 | 300% | 6 | 7.5 min |
| VIP deck | 3,000 | 15% | 150 | 150% | 3 | 1 min |
Take the 3,000-place VIP deck: it gets hit with 150 claims a second — 150% of a single counter’s limit — so it needs at least 3 quotas of its own even while the rest of the festival is cruising. It sells out in 1 min, and all that demand immediately spills into the next zone: hot spots move around mid-sale. Size your quotas zone by zone, keep an eye on the hottest one, and steer the queue towards zones that still have stock. For reserved grandstands, the same contention hits individual seats, and the Ticketmaster rule still applies: let the server assign the best available seats rather than letting thousands of people fight over the same click.
7. The payment that outlives its hold
Your inventory database and your payment provider do not share a transaction. They will disagree sooner or later — the only question is what happens next. Watch one order play out three ways:
No payment state: the hold expires on time
| Second | Who | Event | Ticket | Money |
|---|---|---|---|---|
| 0 | Fan A | holds one ticket | held by Fan A | — |
| 240 | Fan A | starts paying | held by Fan A | authorising |
| 300 | Fan B | A’s hold expires; B takes the ticket | held by Fan B | authorising |
| 330 | Provider | webhook: payment succeeded, but the ticket is B’s | held by Fan B | refund owed |
| 335 | Provider | the same webhook again: ignored by event id | held by Fan B | refund owed |
Two people end up paying for — or being promised — the same ticket. Either someone gets an unexpected refund, or you have sold one ticket twice.
A pending state with a deadline
| Second | Who | Event | Ticket | Money |
|---|---|---|---|---|
| 0 | Fan A | holds one ticket | held by Fan A | — |
| 240 | Fan A | starts paying | pending, Fan A | authorising |
| 330 | Provider | webhook: payment succeeded | sold to Fan A | captured |
| 335 | Provider | the same webhook again: ignored by event id | sold to Fan A | captured |
One owner, and the money matches the ticket.
The same, but the provider answers after the deadline
| Second | Who | Event | Ticket | Money |
|---|---|---|---|---|
| 0 | Fan A | holds one ticket | held by Fan A | — |
| 240 | Fan A | starts paying | pending, Fan A | authorising |
| 360 | System | pending deadline passes, result unknown: release the ticket, mark “refund if captured” | available | authorising |
| 420 | Provider | webhook: payment succeeded after release: refund automatically | available | refund owed |
| 425 | Provider | the same webhook again: ignored by event id | available | refund owed |
No one gets an unpaid ticket, and no one is left hanging. Fan A gets an automatic refund and a clear explanation.
Five rules get you to that third outcome:
- Move the ticket to
pendingthe moment payment starts, with a bounded deadline, so an ordinary slow payment never loses its ticket to the hold timer. - When the deadline hits, check with the provider. If the outcome is still unknown, release the ticket and flag the order “refund if captured”. Never retry a timed-out charge on a second provider — the first one may already have taken the money.
- Attach an idempotency key to every call, and deduplicate webhooks by event id. Payment webhooks can arrive twice and out of order.
- Save the state change and an outbox record in the same transaction, then let a relay worker issue tickets and refunds so a crash never strands a paid order.
- Reconcile against the provider once the dust settles. Any charge without a matching ticket or refund is a bug — your report should catch it before an angry fan does.
Your admission controller needs to watch this gate as well. Whenever payments slow down, pending orders pile up and freeze stock, so cap admission by in-flight payments as well as active sessions.
8. The day itself: gates and offline checks
For 70,000 people, gate entry is usually an afterthought. At 300,000, it becomes a system in its own right — and the bottleneck is human movement, not QR decoding.
| Seconds to check one person | One lane, people a second | Lanes, even arrivals | Lanes, peak |
|---|---|---|---|
| 6 | 0.117 | 239 | 858 |
| 10 | 0.070 | 397 | 1,429 |
Even if the crowd trickled in evenly over 3 hours, a 6-second check still takes 239 lanes. Crowds never arrive evenly: pack 60% of them into the last 30 minutes and you need 858 lanes — jumping to 1,429 if a bag check stretches each scan to 10 seconds. Every lane means staff, scanners and barriers, so the cheapest way to shrink that number is to smooth out arrivals with timed entry windows and assigned entrances on the ticket.
Then comes the network. A signed QR code only proves a ticket is genuine — not that it is still unused. To know that, a scanner has to check with a shared source of truth, which breaks down the moment gates lose contact with each other. No architecture can let two disconnected gates keep admitting crowds while guaranteeing a copied ticket only works once. You have to pick your trade-off for each failure mode:
| How the gate checks | Still works when | Single use is guaranteed | Price |
|---|---|---|---|
| Online, against the central database | The site has internet | Everywhere | No internet, no entry |
| A local server on site shared by all scanners | The site has its own network | Across the whole site | A local network to build, power and duplicate |
| Each scanner alone, a signed QR code | Anything short of a dead battery | Per scanner only: a copy works at another gate | Screenshots and copies get in once per gate |
| A ticket tied to one entrance | That entrance has its local network | Within that entrance | Less freedom for visitors, more signage |
In practice, teams usually run a local server on site shared by every scanner (with the central system as backup), rotating codes in the app to defeat screenshots, and named tickets backed by spot checks. Add a version number to each ticket so that when someone transfers it, the previous holder’s code is revoked before gates open.
9. The alternative that removes the spike
Even with a fair waiting room, a live sale makes the whole platform, payment provider included, carry its peak for 37.4 min, and millions of people spend that time watching a queue most of them will never leave. A registration window plus a ballot moves the luck to the days before and spreads the payments over the days after.
| Live sale with a waiting room | Registration and ballot | |
|---|---|---|
| Joins a second at the peak | 2.78k/s | 8.27/s |
| Time until tickets are allocated | 37.4 min | 13 d |
| Payments a second | 167/s | 0.868/s |
| Offer rounds | 1 | 3 |
Spread registrations across 7 days and joins drop from 2,778 a second in a lobby to roughly 8.27. Winners get 48 hours to pay, trickling in at about 0.868 payments a second — your payment provider will barely notice. Run 3 rounds to re-offer unpaid orders and almost nothing goes unsold. The trade-off is patience and communication: fans wait days for results, and keeping it to one entry per person brings identity checks back onto the table. Raising this option in an interview shows you can question the product rules, not just draw boxes around them.
The last two minutes
- 300,000 is not a seat map. Start by asking what the number counts, how fast it must sell, and what the gates look like.
- Throughput has three gates: sessions, your payment provider and the inventory core. On default provider limits, you crawl at 34.7 admissions a second — negotiate 6 weeks ahead.
- More tickets do not stress the core; selling faster does.
- The site looks sold out after 9.98 min while 47% of stock is merely held. Admit only as fast as there is stock, and show held tickets as held.
- Five million people poll one cached cursor; only those whose turn has come reach your servers, at 333 a second.
- Split general admission into quotas that own their stock, and transfer remaining stock safely when one runs dry.
- A multi-day pass claims every day it covers, all or nothing, in a fixed lock order.
- Give every payment a pending state with a hard deadline; turn any late success into an automatic refund.
- Plan for 858 entry lanes at peak, and agree up front on your offline guarantee.
- When demand completely dwarfs supply, pitch a ballot.