Inspiration

In many homes the TV is the one screen the whole family looks at. I wanted to turn it into a safety layer: when something happens (an unknown person at the door, an SOS), the TV shows it instantly and every guardian is alerted at the same time, without anyone opening an app.

What it does

Instant on-screen alerts: a red banner for SOS and a banner for "unknown person at the door", pushed live to the TV over WebSocket.
Multi-guardian alerts: one event emails all registered guardians at once, with severity levels (medium, emergency).
Hindi commands, including multi-part ones: "show the outside camera and play the next episode" is split into two actions and executed together. Commands can be spoken where the browser has a microphone, or typed where it does not.
Camera panel: opens the device camera when one exists, and falls back gracefully when it does not (a TV has no camera).
Admin dashboard: add and remove guardians and see an event log of every alert.

How we built it

8 AWS Lambda functions (Python): event handler, voice intent parser, media control, camera feed, admin API, WebSocket connect/disconnect, daily summary.
Amazon API Gateway (HTTP API and WebSocket API), Amazon DynamoDB (4 tables), Amazon SNS for guardian alerts, AWS IAM, region ap-south-1.
Plain HTML and JavaScript frontend on GitHub Pages: no install, runs in any TV browser.
Built entirely from a phone. I did not have a laptop or PC (mine is broken and I could not afford to repair it), so the whole system was built through the AWS console, GitHub and zip uploads in a phone browser.

Challenges we ran into

Pasting code into the Lambda console from a phone broke indentation, so I switched to uploading zip files.
CloudFront returned "account must be verified", so I hosted the frontend on GitHub Pages instead.
A basic smart TV has no microphone and no camera in its browser, so I built typed-command and no-camera fallbacks.
Typing a web address with a basic TV remote is painful, which pushed me to keep the address short and the page usable with arrow keys and OK.

Accomplishments that we're proud of

The full loop works on a real TV: an event happens, the TV shows it, and the guardians' emails arrive within seconds. I tested it on a Hyundai smart TV browser with a basic remote, and the system kept working even without a camera or a microphone.

What we learned

Design for the weakest device first: TVs often lack a microphone and camera, so fallbacks are not optional.
Serverless on AWS (Lambda, API Gateway WebSocket, DynamoDB, SNS) is enough to build a live, multi-device alert system with no servers to manage.
New alert recipients must confirm their SNS subscription before they get alerts, so the flow needs to explain that clearly.
Small constraints (a phone, a basic remote) force simpler, more robust design.

Honest notes

Ring and Bee events are simulated in this demo with buttons. No real Ring or Bee API is connected yet.
The voice parser is rule-based (keywords and sentence splitting), not machine learning.
Tested on a smart TV browser, not yet on Fire OS hardware. The app is plain web technology, so it is designed to run in a Fire TV browser, but I have not verified that.
This is the working core of the idea, not the finished market product.

What's next for Guardian Screen

Full-screen care reminders that take over the TV until someone answers yes or no, with a "no response" alert to guardians.
An escalation chain (first guardian, then the next).
Natural Hindi, English and mixed commands with a language model, keeping rule-based parsing as the fallback for safety-critical alerts.
Real Ring and Bee integrations, Alexa+ via an MCP server, and testing on Fire OS hardware.
An Android phone version on the same backend.

Guardian Screen is a family alert and reminder assistant. It is not a medical device or a monitoring service, and it gives no medical advice. In an emergency, contact emergency services directly.

Source code (MIT License): https://github.com/mooknayak/guardian-screen