BoundaryFlow

BoundaryFlow transforms a paper restraining order into a live, cross-device safety boundary that can alert, record, and escalate before a violation becomes harm.

Comment

Inspiration

A restraining order creates a legal boundary, but that boundary is often invisible in the physical world.

The protected person may not know that a restricted individual is approaching until the situation has already become dangerous. The restricted person may understand that a court order exists, yet feel very little immediate friction while moving closer. Evidence is often reconstructed only after the event.

BoundaryFlow began with a simple question:

What if the boundary could react before the violation became harm?

BoundaryFlow transforms a silent restraining order into a dynamic, perceivable safety boundary across three coordinated product surfaces:

  1. a protected-person mobile app
  2. a restricted-person wearable device
  3. an authorized management console

The goal is not punishment, surveillance, or private tracking.

The goal is to make a legally authorized protection boundary visible, responsive, traceable, and harder to ignore.

What it does

BoundaryFlow is an app-and-wearable safety system demonstrated through an interactive cross-device web simulator.

The simulator shows how a future protected-person app, restricted wearable, authorized console, and boundary engine could react together as distance changes.

The system uses four boundary levels:

  • Awareness
  • Caution
  • Restricted
  • Critical

As the restricted wearable approaches the protected boundary, all system surfaces update together:

  • the protected-person app receives a graded safety alert
  • the wearable escalates vibration and warning states
  • the live boundary field changes level
  • the authorized console records the event
  • the notification relay updates
  • the evidence timeline preserves the sequence

BoundaryFlow also simulates:

  • device offline events
  • suspected or confirmed tampering
  • retreat and incident resolution
  • event logging
  • notification escalation
  • cross-device synchronization

A critical safety principle is built into the interaction model:

The restricted device receives boundary warnings without revealing the protected person’s precise location.

How we built it

The Build Week prototype was implemented as a browser-based cross-device system simulator.

The project uses:

  • Next.js
  • React
  • TypeScript
  • Tailwind CSS
  • SVG-driven boundary visualization
  • local simulated device and event data
  • Vercel deployment

The live boundary field is generated through reusable SVG and React components rather than a static image.

A shared simulator state synchronizes:

  • distance
  • current boundary level
  • protected-person app alerts
  • wearable warning states
  • vibration and indicator behavior
  • event timeline entries
  • notification relay states
  • offline and tamper scenarios

The web experience is the demonstration layer, not the final product form.

The represented product is a future system composed of:

  • a mobile safety app
  • a restricted-person wearable
  • an authorized management console
  • boundary, friction, event-trace, relay, and configuration engines

Challenges we ran into

The biggest challenge was avoiding the common failure mode of turning the project into a conventional dashboard.

BoundaryFlow only works conceptually if the protected-person app, wearable, boundary field, and authorized console feel like parts of one living system.

That required us to solve several interaction and implementation challenges:

  • synchronizing multiple product surfaces through one state model
  • mapping distance correctly so moving closer to the center means greater risk
  • making the boundary field responsive without allowing its geometry to drift
  • preventing the mobile app surface from collapsing at narrower desktop widths
  • preserving privacy while still communicating proximity risk
  • making the wearable function as a real system surface rather than a decorative product image
  • fixing server/client hydration differences caused by runtime timestamps
  • creating a critical-to-retreat-to-resolved sequence that feels clear without becoming theatrical or militarized

Accomplishments that we're proud of

We are proud that the final prototype does not feel like a generic map or administrative dashboard.

It demonstrates a complete cross-device safety sequence:

Normal → Awareness → Caution → Restricted → Critical → Retreat → Resolved

Every major transition affects the entire simulated system:

  • app
  • wearable
  • boundary engine
  • console
  • event trace
  • notification relay

We are also proud of the project’s ethical boundaries:

  • no reverse location exposure
  • no private tracking mode
  • no vigilante functionality
  • no punitive hardware
  • judicial authorization only
  • auditable event records
  • simulated data only

The prototype communicates the product’s core idea clearly:

Let the boundary alert first.

What we learned

We learned that safety technology should not be designed only around what happens after an incident.

A legal boundary becomes more meaningful when it can also become:

  • perceivable
  • responsive
  • traceable
  • difficult to ignore

We also learned that cross-device product design is not simply placing several interfaces on one screen.

Each surface needs a distinct role:

  • the protected-person app provides awareness and safety actions
  • the restricted wearable provides friction and compliance feedback
  • the authorized console provides oversight, traceability, and evidence handling
  • the boundary engine keeps all three synchronized

The system became much stronger when we stopped thinking of it as a website and started treating the web prototype as a digital test chamber for a future safety infrastructure.

What's next for BoundaryFlow

Future development could include:

  • manufactured wearable prototypes
  • real device communication testing
  • higher-accuracy positioning models
  • offline resilience
  • secure event-chain storage
  • authorized-role access control
  • court-order rule mapping
  • protected-place configuration
  • accessibility and trauma-informed UX research
  • collaboration with legal, social-work, domestic-violence prevention, and public-safety experts

Before any real-world deployment, BoundaryFlow would require extensive legal review, privacy review, security validation, hardware testing, and collaboration with authorized public institutions.

The current prototype does not use live GPS, does not connect to law enforcement or court systems, and does not send real emergency notifications.

It is an interactive concept simulator showing how such a future system could operate.

Built With

Share this project:

Updates