SentinelGrid

Making public spaces safer by turning unusual events into clear, timely alerts that help people respond when it matters.

Comment

Inspiration

Public spaces can generate many safety-related signals at the same time, but monitoring them manually can make it difficult to know what deserves attention first.

SentinelGrid was inspired by a simple idea: instead of giving monitoring personnel another stream of raw information, create a single interface that turns potentially concerning events into structured incidents that can be reviewed and verified by a human.

The goal was not to build a system that automatically decides whether a crime has occurred. The goal was to build an assistant that helps a human operator understand what happened, inspect the available evidence, and make the final decision.

What I Built

SentinelGrid is an AI-assisted public-space safety monitoring prototype built as a full-stack web application.

The dashboard provides a centralized control room for monitoring predefined safety-related events such as unusual movement, possible distress situations, perimeter proximity, loitering patterns, restricted-area access, unattended objects, crowd formation, and possible confrontations.

When an event is flagged, SentinelGrid turns it into a structured incident containing information such as:

  • Event classification
  • Severity
  • Camera information
  • Timestamp
  • Location
  • Available evidence
  • Verification status

The operator can open an incident, inspect its details, review the location and evidence, and explicitly verify or dismiss it.

Every important action is also recorded in an Activity Log, creating an auditable trail of what was created, reviewed, verified, or dismissed.

Human Verification

Human verification is a core design principle of SentinelGrid.

The system does not automatically declare that a crime has occurred, make a final accusation, or dispatch emergency services.

Instead, it flags potentially concerning events and keeps the human operator responsible for the final verification decision.

This makes the prototype focused on decision support rather than replacing human judgment.

Ring Integration

For the Amazon Ring track, I implemented Ring integration directly into the SentinelGrid backend.

The project includes:

  • Ring authentication handling
  • Account-linking flow support
  • Ring integration status handling
  • Ring device API integration
  • Device information retrieval
  • Ring Developer Playground testing
  • Ring Appstore Knowledge MCP integration during development

I verified the Ring device API using the official Ring Developer Playground and successfully retrieved a Ring device response through the Ring API.

The SentinelGrid dashboard also exposes the Ring integration state separately from the simulated incident workflow, so the integration status is visible to the operator without exposing credentials or tokens.

Where live Ring data is unavailable in the demo environment, the video clearly uses simulated events and simulated evidence rather than presenting them as live data.

How It Works

The frontend is built with React, Vite, and Tailwind CSS.

A Node.js and Express backend manages the incident workflow and Ring integration.

The application connects the operator-facing dashboard with incident creation, review, verification, activity logging, and Ring integration functionality.

The prototype can also generate simulated safety-related events and send them through the same incident workflow used by the dashboard.

This allowed me to demonstrate the complete flow from:

Event → Incident → Review → Evidence → Human Verification → Activity Log

Challenges

One of the biggest challenges was building the project as a solo developer while keeping the system realistic enough to demonstrate an actual monitoring workflow.

Another challenge was integrating Ring functionality while working with the available developer tooling and without relying on a physical Ring device.

I used the official Ring Developer Playground and Ring's developer documentation and MCP knowledge server to understand the API structure, test device retrieval, and build the integration into the backend.

I also had to clearly separate real integration evidence from simulated prototype functionality so that the demo would remain transparent.

What I Learned

This project taught me that building a useful AI-assisted system is not only about detecting events.

The harder part is designing what happens after something is detected: how it is structured, how evidence is presented, how a human reviews it, and how the final decision is recorded.

I also gained practical experience building and deploying a full-stack application, integrating an external platform API, working with developer tooling, and designing a complete operator workflow.

What's Next

SentinelGrid could be extended with real-time event ingestion, richer evidence analysis, additional Ring device capabilities, persistent incident storage, stronger event correlation, and more advanced AI-assisted analysis.

The long-term goal would be to make SentinelGrid a reliable decision-support layer for monitoring personnel while keeping human verification at the center of the system.

Share this project:

Updates

Submission history