Deract

Your group chat, on your game clock. Friends react live; you watch on Fire TV hours later and every reaction lands on the frame.

Comment

Inspiration

Watching a match late should not mean watching it alone.

Normal group chats run on real-world time. Your friend sees a goal, sends a reaction, and spoils it before your stream catches up. You either mute the conversation or accept the spoilers.

I built Deract, short for “delayed reaction”, around a different idea: what if the conversation followed your playback instead of the clock on the wall?

What it does

Deract is a Fire TV experience built for Vega OS, with a browser-based phone companion. It attaches reactions to moments in the video and shows them when each viewer reaches that point.

If a friend reacts while you are behind, their reaction waits. When you reach that moment, it appears alongside the action. The goal is to preserve the feeling of watching together without requiring everyone to press play at the same time.

Viewers can pair a phone through a QR code or use the TV remote’s reaction tray. The social layer follows playback, including pauses and seeks, rather than running on a separate chat timer. A recap brings the shared moments together afterward.

How I built it

I built a shared TypeScript core and synchronization engine, with React Native for the TV interface and Next.js for the web experience and phone companion.

On Vega, the player uses Amazon’s W3C Media APIs and native video surface, with media-control integration. The backend uses Hono, AWS Lambda, Amazon API Gateway and DynamoDB, with S3 and CloudFront for media delivery. Infrastructure is defined through AWS CDK.

The synchronization design combines playback-aware fetching with local release of reactions. The client can prepare upcoming reactions, but their display is controlled by the viewer’s actual playhead.

Challenges I ran into

The hardest problem was not sending a message quickly. It was deciding what “now” means when two people are watching different moments.

Pausing, seeking and receiving a late reply all affect which reactions should appear. I had to make playback position part of the data model and account for both a reaction’s position and its arrival order.

Native playback also taught me an important lesson. A component-instance lookup returned a new object on each render. Using it as a React effect dependency repeatedly destroyed and recreated the player, preventing playback in the Vega Virtual Device. Retaining the instance in a ref fixed that lifecycle problem.

I also worked through navigation-library compatibility and Metro package-resolution issues. I documented those problems and their fixes so the feedback is useful beyond this project.

What I learned

A synchronized experience is not just a chat app with timestamps. Playback controls, network behaviour and interface timing have to work together.

I also learned that a working browser preview is not proof that the native TV experience works. Testing on the intended platform exposed issues the web version did not reveal.

What I’m proud of

Deract makes an unusual technical idea easy to understand: a reaction can arrive later and still feel right on time.

I’m proud of connecting the TV player, phone companion and backend around that interaction, while keeping the TV experience usable with a remote rather than treating it like a desktop screen.

What’s next

The current demonstration uses controlled video content inside Deract’s own player. It is not an overlay for other streaming apps and does not claim automatic synchronization across every broadcaster.

Next, I want to refine the experience with real viewers and develop an integration path for sports and streaming applications, so their audiences can share reactions without sharing spoilers.

Watch later. React together.

Built With

Share this project:

Updates

Submission history