Turning Community Event Downtime Into Interaction With a Live Heatmap App

This is a submission for the DEV Weekend Challenge: Community

I’m travelling this weekend, so this post is shorter than I would have liked.

To get this challenge on time, I leaned heavily on Codex 5.3 for the heavy lifting. Realistically, I would not have had enough time to complete it otherwise.

I am overall happy how this app landed (no pun intended).

Here is a photo of me building on the plane if you don't believe me!

The Community

This idea is inspired by the local tech communities I attend in Toronto.

At many events, there’s a window of time where people are arriving, getting seated, and waiting for things to begin.

Nothing is happening yet, but everyone is physically there.

I feel that is a missed opportunity.

I wanted to build something simple that gives event guests a reason to participate immediately. With this app, organizers can put a live prompt on screen and let attendees answer a short set of questions from their phones. The responses roll up into a live “heatmap” view for the room.

It gives people something lightweight and interactive to do while they wait, and it naturally creates conversation. If the room can see how other people are feeling about a topic, that often becomes an easy social entry point before the event even starts.

What I Built

The app is intentionally simple.

First, the organizer creates a session and adds a short title plus a few questions.

Those questions can be:

• yes/no


• a rating from 1 to 5


• a single-choice question with a few options

Once the session is created, the organizer gets a host screen with a QR code and a join link.

Attendees scan the QR code, answer the questions on their phones, and submit their responses.

As responses come in, the host screen shows the number of participants. When the organizer is ready, they hit Reveal, and the results appear as simple charts for everyone to see.

So the flow is:

1. Create a session.


2. Share the join link or QR code.


3. Collect responses.


4. Reveal the aggregate results live.

No accounts, no logins, no personal data collection. Just quick participation.

Demo

Code

The code can be found here

Instructions are provided on how to run the app locally to try it out.

How I Built It

I built this with Remix, Cloudflare Pages, a separate Cloudflare Worker, and a Durable Object.

On the UI side:

• Remix handles the pages and form actions


• Recharts renders the result charts


• 
  qrcode.react renders the QR code on the presenter screen

On the backend side:

• A Cloudflare Worker exposes the session API


• A Durable Object stores each live session’s state

This stack was chosen because of the following:

1. The product itself is event-oriented: short-lived sessions, lightweight state, and fast interaction. Durable Objects are a strong fit for that because each session can map cleanly to a single stateful object.




2. Cloudflare keeps the deployment model simple. Pages is a good fit for the frontend, Workers are a good fit for the API, and the integration between them is straightforward.




3. The app doesn’t need a traditional database or a complicated backend architecture. I only needed:




4. session creation




5. response counting




6. reveal state




7. aggregate results

That made a Worker + Durable Object model much more appealing than spinning up a heavier stack.

The app has two parts.

The first part is the Remix frontend:

• a page to create a session


• a page for attendees to join and answer


• a presenter page to monitor and reveal results

The second part is the backend Worker, which owns session state through a Durable Object.

Each session gets its own Durable Object instance.

That Durable Object stores:

• the session title


• the questions


• the participant count


• whether results have been revealed


• aggregate answer counts

A key design choice is that the app does not store raw individual submissions long-term. When someone submits answers, the backend validates them, increments the correct aggregate counters, increments the participant count, and discards the raw response payload.

That keeps the system intentionally lightweight and privacy-friendly.

The presenter screen uses polling every two seconds to refresh:

• participant count


• reveal status


• aggregate results (once revealed)

So there are no websockets here. The screen simply asks the backend for the latest snapshot on a fixed interval.

The backend routes are simple:

• create a session


• fetch session metadata


• submit answers


• reveal results


• fetch aggregate results

That’s enough to support the full experience without adding unnecessary complexity.

Closing thoughts

If I had more time, I’d probably add:

• better visualizations


• themed event templates


• question packs for different types of events


• smoother host controls


• a save function of the final heatmap snapshot for the presenter

But for a weekend build, especially one assembled while travelling, I’m happy with where it landed (this pun was too good not to be used twice)!