Inspiration
Twitch raids are one of the platform’s most social features, but the interactive experience usually ends when viewers reach the next channel. I wanted to make a raid feel like a baton pass—viewers should arrive carrying the story, progress, and achievements they created together.
That idea became RaidQuest: a persistent cooperative adventure that travels from streamer to streamer.
What it does
RaidQuest turns Twitch chat, raids, Shared Chat, and Polls into one continuous cooperative quest.
Viewers control the adventure through simple chat commands such as !strike, !guard, and !charge. Incoming raids trigger a timed Raid Rush encounter, while outgoing raids transfer the current campaign to another connected channel without resetting the boss health, route, history, or collected relics.
Shared Chat activates Fusion mode and combines participating communities. Route decisions use native Twitch Polls when available, with an automatic chat-voting fallback. Each departing channel also creates a relic based on its community’s play style.
The experience uses a transparent OBS overlay, requires no viewer installation, and concludes with a public-safe Victory Card summarizing the entire journey.
How I built it
I built RaidQuest as a Node.js 22 and TypeScript service with a deterministic quest engine.
Twitch OAuth connects streamers securely, while encrypted token storage and automatic refresh keep credentials on the server. A resilient EventSub WebSocket client receives chat messages, raids, Shared Chat events, notifications, and Poll results. I translate those Twitch payloads into domain commands before applying them to the game state.
The dashboard and OBS overlay receive live updates through Server-Sent Events. Campaign state is stored in an atomic JSON persistence layer, allowing the application to recover after a restart without introducing unnecessary infrastructure.
I also added chat-vote fallbacks, reconnect handling, event deduplication, read-only overlay keys, public-state filtering, automated tests, Docker support, and deterministic demo scenarios. I used OpenAI Codex as my primary engineering partner for implementation, architecture reviews, security hardening, regression testing, and interface iteration.
Challenges I ran into
The largest challenge was making cross-channel continuity reliable. A Twitch raid identifies the destination, but RaidQuest also has to determine whether that streamer is connected, available, and eligible to receive the active campaign. I designed both an automatic handoff and a relay-code fallback so the quest remains recoverable in every case.
EventSub reliability was another major challenge. Twitch-managed reconnects must preserve subscriptions, while a completely lost connection requires a fresh session and re-subscription. I also had to handle duplicate events, keepalive timeouts, token refresh races, and partial subscription failures without interrupting the overlay.
Poll availability introduced another complication because not every channel can create native Twitch Polls. I made Poll creation an enhancement rather than a dependency by automatically switching to chat voting when necessary.
Finally, I had to make complex state changes understandable on stream. The handoff receipt, Raid Rush meter, Fusion indicator, relic trail, and Victory Card were designed so viewers can understand important events within seconds.
Accomplishments that I’m proud of
I’m most proud that RaidQuest makes a Twitch raid affect persistent gameplay instead of functioning as a temporary alert.
The same campaign can move between channels while preserving its boss health, selected route, event history, relay progress, and relic trail. A continuity receipt visibly proves that the state reached the destination unchanged.
I’m also proud of the project’s reliability and security boundaries. Real Twitch chat changes the overlay through EventSub, OAuth tokens remain encrypted and server-side, public overlay responses exclude viewer identities, and all game mechanics are deterministic and independently testable.
The final project includes a polished stream overlay, a creator dashboard, graceful fallbacks, Docker deployment, documented architecture, and 58 passing automated tests.
What I learned
I learned that a Twitch-native experience becomes more compelling when platform events are treated as game mechanics rather than notifications.
I also learned that live integrations require recovery paths from the beginning. Reconnection, token refresh, duplicate delivery, API eligibility, and disconnected destinations are normal operating conditions—not unusual edge cases.
On the design side, I learned that an interactive stream product must communicate state much faster than a traditional application. Viewers may join at any moment, so boss health, available commands, raid events, and campaign continuity must be understandable without documentation.
Working with Codex also reinforced the value of explicit engineering constraints. By documenting architecture boundaries, security requirements, and verification steps, I could use Codex as a focused development partner while keeping the implementation consistent.
What’s next for RaidQuest — One adventure. Every channel.
My next step is to turn RaidQuest into a hosted creator-relay network where streamers can discover active campaigns, schedule collaborations, and join themed community events.
I would also like to add creator-defined quest packs, additional bosses, seasonal encounters, campaign analytics, accessibility controls, and deeper relic customization. For production scale, I would replace local JSON persistence with a managed database and encrypted key-management infrastructure while preserving the deterministic engine.
The long-term goal is to make raids feel like the beginning of a shared experience rather than the end of one: one adventure, every channel.
