
Weekend Showcase Challenge: Global Event Platform
Global Event Platform is a serverless AWS build that turns high-demand event ticketing into a full fan journey: fair queues, atomic seat purchases, concessions, and leaderboards. This article walks through the architecture, DynamoDB modeling decisions, AWS services, and lessons behind taking the project from inspiration to a deployed showcase app.
Vision and What It Does
Global Event Platform is a serverless ticketing and fan-engagement platform for high-demand sporting events. The idea is simple: what happens when millions of fans try to buy tickets, enter a stadium experience, order food, and compete on engagement leaderboards at the same time?
Most demo apps stop at "show a seat map and click buy." I wanted to build the harder part: the pressure underneath the button. The project models a full event journey, from the first fan entering a waiting room to the final ticket purchase, then into in-stadium concessions and leaderboard activity.
The platform has four major modules:
- Virtual Waiting Room: Fans join a fair queue before ticket purchasing opens. The system assigns queue positions, tracks status, and issues admission tokens.
- Fair Seat Purchase: Once admitted, fans can create a purchase session, view seat availability, hold a seat, and confirm a ticket. Seat holds and purchases are protected with DynamoDB conditional writes and transactions.
- Stadium Concessions: Fans can place food and drink orders during the event. The backend routes orders to stands, tracks order status, and supports event-level concession stats.
- Infinite Leaderboard: Fans can submit engagement scores and view rankings. The design uses write sharding and scatter-gather reads to support high write volume.
The frontend gives the project a real product surface: authentication, profile management, event browsing, waiting room screens, ticket purchase flows, match details, concessions, leaderboards, and an admin portal for event setup.
Inspiration
The inspiration for this build came from Affan's submission to the DynamoDB football data modeling challenge series. I did not find out about the original challenge early enough to submit my own entry at the time, but after seeing Affan's work, I kept thinking about how much bigger the idea could become.
The original challenge series was : DynamoDB Football DataModelling Challenge Series by John Terhune
That series focused on real-world DynamoDB modeling problems around football scale, fairness, contention, and access patterns. Affan's submission made the problem feel concrete. It showed that DynamoDB single-table design was not just a diagramming exercise. It could be used to model fairness and concurrency in a system people immediately understand: fans trying to get into a massive event.
So for the Summer Builds Showcase, I treated that spark as the beginning rather than the finish line. I built Global Event Platform as a broader version of the same idea, combining waiting room fairness, atomic ticket purchases, concessions, and engagement rankings into one deployed application.
How I Built It
I built the backend as a group of independently deployable AWS SAM modules. Each module owns its own API Gateway routes, Lambda functions, tests, and DynamoDB table. The root SAM stack ties the modules together and provisions shared platform resources like Cognito and EventBridge.
The biggest architectural decision was to avoid one giant shared database table for everything. Instead, each bounded context has its own single-table DynamoDB design. The waiting room table is optimized for queue status, queue administration, admission tokens, and event metadata. The seat purchase table is optimized for seat state, holds, ticket lookup, and inventory views. Concessions and leaderboard each get their own table because their access patterns are different enough to deserve independent models.
That decision made the system easier to reason about. A queue entry, a seat hold, a concession order, and a leaderboard score are not the same kind of thing. They should not be forced into the same table just to make the architecture look clever. Each module still uses DynamoDB modeling techniques deeply, but the boundaries stay clean.
The frontend is a React and Vite application. It can run against the deployed AWS backend, or in a local mock mode using browser storage. That helped during development because I could keep improving the user experience even while backend routes were still being deployed or tested.
Some of the most important flows are:
- Admin creates an event.
- Fans browse available events.
- A fan joins the waiting room for an event.
- The admin admits a batch of users.
- The admitted fan receives a token.
- The fan creates a purchase session.
- The fan holds a seat.
- The fan confirms the purchase.
- The ticket appears in the fan's matches.
- The fan can later interact with concessions and leaderboards.
The tricky parts were not the screens. The tricky parts were the invariants.
A user should not join the same event queue twice. A seat should not be sold twice. A used admission token should not be reusable. Order state should move through valid transitions. Leaderboard writes should not overload one hot partition.
Those rules shaped the implementation more than the UI did.
AWS Services and Architecture Overview
The backend runs on AWS serverless services:
- AWS Lambda for backend compute
- Amazon API Gateway for REST APIs
- Amazon DynamoDB for persistence
- Amazon EventBridge for cross-module events
- Amazon Cognito for user authentication
- AWS SAM for infrastructure as code and nested stack deployment
The architecture looks like this at a high level:
Fan opens app -> Cognito handles authentication -> Waiting Room API accepts queue join -> DynamoDB records fair queue position -> Admin admits capacity-sized batches -> Admission token is issued -> Seat Purchase API validates token -> DynamoDB conditionally holds a seat -> DynamoDB transaction confirms ticket purchase -> EventBridge can fan out domain events -> Concessions and Leaderboard modules support the live event experience
The most important DynamoDB patterns in the project are:
- Conditional writes for correctness under concurrency
- Transactional writes for multi-item state changes
- TTL for cleanup of temporary records like holds and tokens
- Global secondary indexes for alternate access patterns
- Write sharding for hot paths like queues and leaderboards
- Scatter-gather reads where exact rank or top-N views need data across shards
This project is not trying to pretend that a weekend build is the same as a fully hardened enterprise ticketing platform. There are still production improvements I would add, including stronger idempotency keys, dead-letter queues, replay tooling, richer observability, and load tests at target scale. But the core modeling choices are designed around real platform concerns rather than just happy-path CRUD.
Key Challenges
The first challenge was fairness. A waiting room sounds simple until you ask what happens when thousands of people join at the same time. The design needed deterministic queue positions, duplicate-join protection, and capacity-aware admission.
The second challenge was seat correctness. Ticketing systems are brutal because one bug can sell the same seat twice. I used DynamoDB condition expressions so a seat can only move from available to held when it is actually available. Purchase confirmation uses a transaction so the seat, ticket, and related records move together.
The third challenge was keeping module boundaries clear. It is tempting to let modules call each other directly because it feels faster during development. I tried to keep the platform vocabulary event-driven instead. A module owns its state. Other modules learn about facts through events or explicit API contracts.
The fourth challenge was making the frontend feel like an actual product rather than a test harness. The admin portal, event cards, waiting room status, ticket screens, and match flows all needed enough polish for someone to understand the system without reading the backend code first.
What I Learned Across the Summer
This summer reinforced something I keep relearning: good cloud architecture is mostly about boundaries.
DynamoDB becomes much less mysterious when you stop thinking in generic tables and start thinking in access patterns. Lambda becomes easier to work with when each function has one clear job. EventBridge makes more sense when events are facts, not remote-control commands. A frontend becomes calmer when it reflects the actual state machine underneath it.
I also learned that a strong project does not need to be huge in every direction. It needs a crisp problem, a believable architecture, and a few places where the implementation proves the claim. For this build, those proof points are the queue model, the conditional seat purchase flow, the modular SAM backend, and the deployed frontend.
The DynamoDB challenge series helped me see data modeling as a creative act. It is not just storage. It is the shape of the product's promises. If the promise is fairness, the table design has to protect fairness. If the promise is "this seat is yours," the write path has to make that promise true under pressure.
Links
- Live app: Global Events Platform
- GitHub repository: Github Repo
- Inspiration Challenge Series: DynamoDB Football DataModelling Challenge Series by John Terhune
- Builder who inspired me: afffan16
Closing
Global Event Platform started as admiration for another builder's DynamoDB football challenge submission. It became my way of exploring how far that idea could stretch when turned into a broader event platform.
The result is a deployed serverless application with a real frontend, a modular AWS backend, and a data model built around fairness, contention, and scale. It is my Summer Builds Showcase entry, and also a reminder that sometimes the best builds begin with seeing someone else's work and thinking, quietly but stubbornly: I want to understand that deeply enough to build my own version.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article