How I gamified your next event
— — — In this post I talk about the app I built. 🔗 Here is the GitHub repo
Back in April, I organized the first ever Nx Summit in the EU. It took place in Amsterdam, and it involved quite a lot of planning.
Here are the main things I handled:
- Venue selection
- Date and format planning
- Budget management: I had to keep everything under a specific budget
- Attendee targeting: We wanted 100 European customers and prospects, so I reached out individually to invite them
- Hotel arrangements: I picked a conference hotel right next to the venue and secured a group price and discount codes (which, to be honest, didn’t work great)
- Registration system: Just a Google Form
- Schedule development: A full agenda with meals, presentations, roundtables, and space for networking
- Speaker coordination: Worked with our team and invited external speakers
- Swag: Actually useful stuff : rain ponchos (luckily unused), inkless pens (aka pencils?), and scrunchies
- Gift bags: Paper bags for each attendee with goodies and a handwritten thank-you postcard
- Badges: Amsterdam-themed name tags for attendees and the Nx team
- Team travel coordination: Took note of arrivals, booked rooms, and planned social activities
- Social activities: Planned a group outing to Keukenhof in full bloom the day after the event
- Attendee tracking
- Cost tracking: We wrapped things up using just 80% of the budget
- Market research: Avoided date conflicts with other conferences and arranged for us to sponsor one that took place the day before
- Partner coordination: Talked to partners about inviting their customers
All that wasn’t enough for me.
I decided we needed a virtual ticketing and check-in system. There are a million solutions for this, but none were good enough for me. So naturally, I reinvented the wheel and built an app.
At first, I just wanted a ticket and check-in app. But with a blank slate, I thought why not make it fun?
I asked myself: What’s the point of this event? The answer: for our team to talk to as many attendees as possible, gather feedback, and collect stories.
So I gamified it.
The Idea: Collect Points
- Scan someone’s QR code, earn points
- Trade points for a prize
But I didn’t want just one winner who talked to the most people — not everyone has the same time or comfort levels. So I made it a weighted raffle:
The more points you have, the more chances you get.
How It Worked
- Every attendee had a personal QR code (UUID-based, no emails)
- Scan another attendee: +1 point
- Scan an Nx team member: +4 points
- Check in at the event: +1 point
Bonus points:
- Participate in a round table: +5 points
- Ask a question during Q&A: +5 points
- Get interviewed: +8 points
- Show me a picture of your cat: +3 points (UUID-based, no emails)
Admin Mode
Admins could:
- View and manage the attendee list
- Scan attendees to check them in
- Sign people in/out manually
- Track points and participation
- Run the raffle (with a spinning wheel animation, naturally)
- View schedule and game rules
I spec’d everything out with GPT, then pasted the prompt into bolt.new, and tada! Website.
Of course, I made it harder for myself by overengineering it.
Challenges
- Getting the QR scanner to behave and not go into infinite scan mode
- Deciding what controls admins should have
- Setting up role-based access (attendee, staff, super_admin)
- Ensuring anonymity (UUIDs instead of emails)
- Printing QR code stickers for team members — bonus points if they had their Calendly links too
Authentication was handled by an Edge Function. All staff shared a password. Was it Fort Knox? No. Was it enough? Yes.
RLS was enforced for access control, while game-related reads (like scanning) were available under public-read constraints that respected RLS.
Using GPT
Before I even opened a code editor, I pitched my idea to GPT. We talked it through a bit — what I wanted the app to do, how it might work, what the edge cases were. Then I asked GPT to spec it out in detail, so I could feed it directly into bolt.
We went back and forth tweaking the spec until it left no room for ambiguity. I wanted something clean and executable — no guessing. Once we nailed it, I dropped it into bolt and the app was ready.
I like GPT, it’s good for pitching and discussing ideas.
Using Bolt.new
I used bolt.new to build the entire app, and it made everything faster and smoother. The UI that bolt created was clean, mobile-friendly, and, honestly, fresh and fun.
What really stood out was the Supabase integration: I could connect my project, run migrations, deploy Edge Functions, and query data — all from the same place. It worked like a charm.
Bolt let me take an idea from a GPT-generated spec to a live working app in no time. And then I had plenty of time left over to overengineer it, of course.
And once everything was ready, I 1-click-deployed it to Netlify straight from bolt. It just worked.
Using Supabase
Supabase made things surprisingly easy. I used it for the entire backend — the database, serverless functions, role-based access, and real-time updates were all handled in one place.
Before anything could work, I uploaded the list of registered attendees to the Supabase attendees table. Each record had a name and email — this allowed the system to verify identities when someone “signed in” with their email, and to generate their unique QR code.
Here’s how it worked:
- Attendees didn’t need to sign in. They simply entered their email. If their email existed in the attendees table, they were in. No account creation, no password, no magic link — just a soft lookup. If the email didn’t exist in the database, the Edge Function returned a failure response, and the frontend blocked them from proceeding. So while the app felt lightweight with no login, identity verification was still enforced securely on the backend.
- QR codes were anonymized. Each attendee’s QR code used a UUID from the database — not their email or any personal info. That way, if someone scanned you, they couldn’t see who you were or get access to your data — they just got points.
- Game functionality (like scanning or checking a leaderboard) was available without authentication. Public reads were allowed via Supabase’s anon key, thanks to carefully scoped RLS (Row-Level Security) policies. This meant the app could run smoothly client-side, with no login required — but still respect access controls.
- Mutations (like awarding points, checking in attendees, or running raffles) were locked behind Supabase Edge Functions. These functions used the service_role key, which gave them full privileges. I wrote RLS policies so that only the service_role could perform updates. So even if someone tried to call the same APIs from their browser, nothing would work unless it was coming from the server.
- Role-based logic was layered in. Attendees had the default attendee role. Staff (and me, the super_admin) had elevated roles stored in the same attendees table. Edge Functions validated roles before running sensitive actions, like toggling the game state or drawing raffle winners. Staff authenticated with a shared password (via an Edge Function), and once verified, they had access to the admin panel.
In short, Supabase let me build something fast, fun, and secure — without needing a separate auth system, backend framework, or deployment flow. It was all right there. Just enough abstraction to move quickly, and just enough control to make it feel solid.
Measuring Engagement
At most conferences, you talk to a dozen people, have great conversations and then later realize you don’t remember their name, or never got their email. That’s a problem.
For our team, it was critical to track who we interacted with, who had questions, who shared feedback . Not just for follow-up, but to understand our impact.
Instead of asking the team to manually jot down names or hand out stickers, I gamified it.
Every time someone scanned a badge, it left a digital footprint of that interaction. Attendees were incentivized to scan team members (worth more points), which in turn meant we could easily tell who had talked to whom.
It made it easier for attendees to start conversations, and for us to track real, valuable engagement automatically.
The game wasn’t just fun. It helped us track real engagement in a lightweight and meaningful way.
Because each interaction (like scanning someone or participating in a session) generated a point and left a record, we could:
- See who connected with whom — every scan was a touchpoint
- Understand which attendees were most active and involved
- Identify the most talked-to team members
- Spot high-interest moments, like Q&A spikes or interview participation
This gave us a unique way to measure the impact of the event beyond just attendance. We didn’t need forms or follow-up surveys — the game was the engagement tracker.
Data Insights
After the conference, we downloaded all the interaction data as a CSV. This gave us a clean record of who showed up, who scanned whom, and how points were distributed.
We could import everything into a Google Sheet, track metrics, visualize participation, and segment attendees based on engagement — without needing extra tooling.
- Downloaded attendee list to see who showed up, who scanned who
- Retroactive conversation tracking: if someone scanned your badge, you spoke to them
- Vanity stats! We knew who was most engaged, who participated in Q&A, who got interviewed
Raffle Time
I customized the raffle logic. Bolt generated the page, but I wanted the chances to be more fair. I weighted heavily based on points and added a spinning animation. It was slightly off visually, but still fun.
Why I Loved Building This
I love building things, especially games. (Come to one of my birthday parties. My last one had a murder mystery game for 75 people.)
Using tools like GPT and Bolt made the process so much smoother. I wasn’t stuck Googling how to make QR scanners work. I could just build, tweak, and keep going.
Did I spend 5 days perfecting it? Yes. Am I picky? Yes. Did I enjoy every second? Absolutely.
We live in a time where it’s easier than ever to build something cool, useful, and delightful. You just have to start.
Fork it, clone it, and use it at your next event.
🎮 Nx Summit Game Rules
Overview This is a gamified check-in and networking app for the Nx Summit that encourages attendee interaction through QR code scanning and point collection.
How to Play
- Getting Started
- Check-in is required before playing
- Each attendee gets a unique, private QR code (UUID-based)
- Everyone starts with 0 points
2. Earning Points
QR Code Scanning:
- Regular Attendees: +1 point
- Nx Team Members: +4 points
- You can only scan each person once
Engagement Rewards:
- Participate in roundtables or Q&A: bonus points
- Staff can manually award points
Hidden Bonuses:
- Show Katerina a cat photo: +3 points
3. Privacy & Security
- Only name and invite email are stored
- No emails exposed during scanning
- No tracking or third-party data sharing
4. Winning Prizes
Weighted Raffle:
- Your chances = your points / total points
- Everyone has a shot, but activity helps!
Game Strategy Tips
- Prioritize scanning Nx team (they’re worth more!)
- Engage in sessions and Q&A
- Scan lots of unique attendees
- Stay involved and earn those bonus points
Technical Highlights
- Real-time updates and leaderboard
- Admin panel with controls and raffle logic
- Mobile-friendly
- Resilient to network hiccups
The game made networking more fun, interactive, and rewarding — without sacrificing privacy or creating friction.
Make it yours and add it to your next event!
I’d love to hear what you ended up doing. Feel free to tag me or reach out!
Reach out
GitHub repo: https://github.com/mandarini/nxsummit-game
Find me: https://psyber.city
Follow me:
