Pamplesneak
Passive party game. Full-stack real-time multiplayer web application
Tech Stack
Frontend
Backend
Infrastructure
Pamplesneak
A passive party game for groups of friends, or a playful icebreaker for strangers. Built as a full-stack real-time multiplayer web application.
Overview
Pamplesneak is a multiplayer word game that runs quietly in the background of a gathering. Players are given phrases they must sneak into conversation without getting caught. Each attempt shows up on a shared timeline, and a live leaderboard keeps score.
This was the first game I ever built. What began as a playful attempt to bring Jimmy Fallon’s Word Sneak into living rooms grew into a long-running sandbox where I explored different frameworks, real-time systems, and deployment strategies. Over the years I rebuilt it multiple times, each version teaching me something new about both technology and human behavior. The result works as both a party game for close friends and a conversation starter for groups of strangers.
Game Flow
- Players join from their phones with a code or QR scan
- Each round distributes phrases submitted by the group
- Sneaks can be silly, self-deprecating, politically incorrect, or completely out of character
- After use, phrases appear on a shared timeline where others validate or reject them
- A live leaderboard tracks progress until the session ends
- Push notifications keep everyone on track with round transitions and new assignments
The fun comes from sending a phrase that you know will put someone in a compromising position. Watching them find a way to slip it naturally into conversation is often hilarious.
Why I Built It
I wanted to see if a lighthearted social concept could actually work in real gatherings. The project became a way to learn by doing, guided by feedback from friends at parties. I was also curious whether it could work as an icebreaker, giving strangers something to play off of in conversation.
Evolution
-
Version 1: Django Web App
Built quickly for a university party with jQuery AJAX and RabbitMQ. It worked, but players had to constantly check their phones. -
Version 2: Ionic Mobile App
An experiment with running the game logic entirely on-device. Distribution was frustrating since installing builds at parties was impractical. -
Version 3: React + MongoDB Web App
Returned to web for smoother async handling and MongoDB persistence. Improved responsiveness but still lacked notifications. -
Version 4: React Native
Explored native push notifications, but the project stalled as parties became less frequent. -
Version 5: Django/PWA Build
Revived at a friend’s house party. By this time PWAs supported push notifications, so I returned to web for easier distribution and faster development. Built with Django Channels, Celery, Redis, and Fly.io, this version introduced structured rounds, timers, and an actual win condition. The Django admin made testing seamless, and the game finally felt complete.
What I Built
- Real-time game engine that synchronizes state across connected players with sub-second latency
- Automated round and scoring system with background workers
- Installable PWA with offline support and push notifications
- Cloud deployment prepared for distributed workers and scaling
Tech Behind the Scenes
Frontend
JavaScript (ES6+), WebSocket API, Tailwind CSS, PWA features including service worker and manifest
Backend
Django with Django Channels for WebSockets, Celery for task orchestration, Redis for pub/sub and caching, SQLite in development and PostgreSQL in production
Deployment
Dockerized services on Fly.io with Daphne ASGI handling concurrent connections
What I Learned
- First game build: This was my first experience designing and building a game. I learned how game loops differ from apps, especially when balancing timing, rules, and psychology.
- Asynchronous systems: I gained practical experience managing shared game state, using background workers and WebSockets to synchronize devices in real time. Early versions even introduced me to AJAX before modern frameworks made async handling easier.
- Progressive Web Apps: I built PWAs with offline support, service workers, and push notifications, which made the game easier to distribute and kept the flow smooth during play.
- Game design and iteration: Rebuilding Pamplesneak across frameworks taught me how round structures, timers, and mechanics affect the player experience. Adding features like QR code joining also showed me the value of small quality-of-life improvements.
- Security and scaling: I saw the tradeoffs of using Firebase and how insecure it can become if misconfigured. I also learned that while Pamplesneak will never need Fly.io’s scale, deploying it forced me to think about SSL, HTTPS/WSS, database choices, and preparing background workers for production.
- Technology exposure: Along the way I worked with React, Django, Ionic, React Native, Firebase, MongoDB, SQLite, PostgreSQL, pgAdmin, Redis, and many smaller libraries. Each rebuild deepened my understanding of different approaches to the same problems.
- Social experiment: The most surprising lesson was about people. Sending someone a phrase that forces them to say something silly, self-deprecating, politically incorrect, or completely out of character is half the fun. I was surprised by how often these phrases slipped by unchallenged, even when everyone was on the lookout. As someone who tends to overthink what I say, it was eye-opening to see how rarely people actually critique or call out what is said in conversation.
Takeaway
Pamplesneak started as a silly idea and became my first deep dive into real-time multiplayer systems. It taught me about synchronization, distributed workers, browser quirks, and PWA deployment. More importantly, it revealed how games can reshape social dynamics. At its best it was the perfect icebreaker, loosening up groups and sparking laughter. At its worst it derailed entire parties by making every conversation feel like a trick. That tension between technical design and human behavior is what makes this project unforgettable.
Gallery
