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

AskWhy 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.

QuantityWorkingResult
Gate 1: sessions100k ÷ 5 min333/s
Gate 2: payment providermin(250 ÷ 1.2, 1k ÷ 2.4) ÷ 60%347/s
Gate 3: inventory core32 × 100/s ÷ 31.07k/s
Admission ratethe lowest gate: sessions333/s
Chance for a fan who would buy150k ÷ (5M × 50%)6%
Site first looks sold outsimulated, second by second9.98 min
99% actually soldsimulated, second by second37.4 min
Tickets in holds at the peak140k ÷ 300k47%
Burst with no queue5M ÷ 1 min83.3k/s
Queue-page polling5M ÷ 10 s500k/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.

ScenarioSessionsPayment providerInventory coreSale runs at99% sold after
Provider defaults (25/s per endpoint)333/s34.7/s1.07k/s34.7/s2.5 h
Limits negotiated (250/s)333/s347/s1.07k/s333/s37.4 min
Negotiated, but one inventory counter333/s347/s33.3/s33.3/s2.6 h
How many admissions per second each gate allows. The lowest one (highlighted) sets the pace. The “99% sold” column comes from the second-by-second simulation, not a formula.

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.

looks sold out99% sold 01020304050minutes after sales open0150k300k looks sold out99% sold 02040minutes after sales open0150k300k
  • Sold
  • Payment in progress
  • Held
  • Available
  • Looks sold out, is not
Our worked example simulated second by second at 333 admissions a second. In the shaded window, the site looks empty even though held tickets keep coming back.

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 policyTold “sold out” while tickets were only held99% sold after
Admit at the gate rate, whatever is left1,509,00137.4 min
Admit only while tickets are available037.4 min
Same sale, same holds. The second policy pauses the queue instead of letting people into an empty shop.

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.

RequestPer secondWho answers
Joins, if everyone comes in the last minute83,333Queue service
Joins, spread over the lobby2,778Queue service
Status polls, everyone every 10 s500,000Edge (CDN)
Status polls, less frequent at the back of the queue169,333Edge (CDN)
Status reads that reach the origin10Queue service
Turns traded for a pass333Queue service
Hold attempts1,000Shop and inventory
Payment attempts started200Payment provider
Two planes: millions of cheap reads stay at the edge, and only people whose turn has come reach your servers. Design choices behind these numbers: a 30-minute lobby, 20 shield caches, status cached for 2 s.

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.

QuotasClaims a second, ceilingSold when the first quota ran dryTickets elsewhere at that momentTransfers to finish
1100100%00
880099%4,29419
323,20096%10,70283
12812,80093%22,126392
150,000 orders of 2, each sent to a random quota (using a fixed seed so you can reproduce the numbers). Without transfers, an empty quota tells everyone routed to it “sold out”, even while other quotas still have tickets.

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.

DayUsed per order in the mixLeft when the first day sells out
Friday0.5521,429
Saturday0.700
Sunday0.5521,429
100,000 places a day, with orders arriving in a passes 40%, Friday 15%, Saturday 30%, Sunday 15% mix: every three-day pass claims one place on all three days.

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.

ZonePlacesShare of demandClaims a secondLoad on one counterQuotas for ≤ 50%Sold out after
Field252,00055%550550%1122.9 min
Front of stage45,00030%300300%67.5 min
VIP deck3,00015%150150%31 min
Running at 333 admissions a second with 3 claim attempts per shopper. Holding a lock for 10 ms caps a single counter at 100 claims a second.

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

SecondWhoEventTicketMoney
0Fan Aholds one ticketheld by Fan A—
240Fan Astarts payingheld by Fan Aauthorising
300Fan BA’s hold expires; B takes the ticketheld by Fan Bauthorising
330Providerwebhook: payment succeeded, but the ticket is B’sheld by Fan Brefund owed
335Providerthe same webhook again: ignored by event idheld by Fan Brefund 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

SecondWhoEventTicketMoney
0Fan Aholds one ticketheld by Fan A—
240Fan Astarts payingpending, Fan Aauthorising
330Providerwebhook: payment succeededsold to Fan Acaptured
335Providerthe same webhook again: ignored by event idsold to Fan Acaptured

One owner, and the money matches the ticket.

The same, but the provider answers after the deadline

SecondWhoEventTicketMoney
0Fan Aholds one ticketheld by Fan A—
240Fan Astarts payingpending, Fan Aauthorising
360Systempending deadline passes, result unknown: release the ticket, mark “refund if captured”availableauthorising
420Providerwebhook: payment succeeded after release: refund automaticallyavailablerefund owed
425Providerthe same webhook again: ignored by event idavailablerefund owed

No one gets an unpaid ticket, and no one is left hanging. Fan A gets an automatic refund and a clear explanation.

Each trace is replayed by code: a 5 min hold, payment kicked off at second 240, and a 2 min pending deadline.

Five rules get you to that third outcome:

  1. Move the ticket to pending the moment payment starts, with a bounded deadline, so an ordinary slow payment never loses its ticket to the hold timer.
  2. 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.
  3. Attach an idempotency key to every call, and deduplicate webhooks by event id. Payment webhooks can arrive twice and out of order.
  4. 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.
  5. 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 personOne lane, people a secondLanes, even arrivalsLanes, peak
60.117239858
100.0703971,429
300,000 attendees. Even arrivals spread over 3 hours (27.8 a second); peak puts 60% of them into the last 30 minutes (100 a second). Lanes run at 70% utilisation.

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 checksStill works whenSingle use is guaranteedPrice
Online, against the central databaseThe site has internetEverywhereNo internet, no entry
A local server on site shared by all scannersThe site has its own networkAcross the whole siteA local network to build, power and duplicate
Each scanner alone, a signed QR codeAnything short of a dead batteryPer scanner only: a copy works at another gateScreenshots and copies get in once per gate
A ticket tied to one entranceThat entrance has its local networkWithin that entranceLess 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 roomRegistration and ballot
Joins a second at the peak2.78k/s8.27/s
Time until tickets are allocated37.4 min13 d
Payments a second167/s0.868/s
Offer rounds13
How the ballot runs: 7 days to register, 48 hours for winners to pay (85% actually do), and unpaid spots roll into the next round until fewer than 1% remain.

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

  1. 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.
  2. 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.
  3. More tickets do not stress the core; selling faster does.
  4. 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.
  5. Five million people poll one cached cursor; only those whose turn has come reach your servers, at 333 a second.
  6. Split general admission into quotas that own their stock, and transfer remaining stock safely when one runs dry.
  7. A multi-day pass claims every day it covers, all or nothing, in a fixed lock order.
  8. Give every payment a pending state with a hard deadline; turn any late success into an automatic refund.
  9. Plan for 858 entry lanes at peak, and agree up front on your offline guarantee.
  10. When demand completely dwarfs supply, pitch a ballot.

Where this comes from