ArrivalOps

Inspiration

The order is ready. The customer is outside. But nobody checked in.

For restaurants offering curbside pickup, this is a frustratingly simple problem. The ordering system knows the food is ready, but it may have no way of knowing that the customer has arrived unless they actively check in.

Meanwhile, a security camera might already be watching the parking area. It can see what the ordering system cannot, but that information rarely reaches the people responsible for preparing and handing over orders.

That disconnect inspired ArrivalOps.

I wanted to explore whether an existing Ring camera could serve a more practical purpose, helping a business recognize when something needs attention rather than simply recording that something happened.

What it does

ArrivalOps is a pickup exception management system that connects camera observations with restaurant operations.

A restaurant owner begins by marking the designated pickup area on the camera view. ArrivalOps uses computer vision to detect vehicles within that area and determine whether they appear to be waiting.

When a vehicle remains in the pickup zone beyond a configured threshold, the system checks for relevant orders without a recorded customer check-in.

If there is a possible match, ArrivalOps creates an exception for staff to review. Instead of sending another generic motion notification, it presents useful information: the observed vehicle, how long it has been waiting, and a shortlist of possible orders.

The system may prioritize an order using a vehicle description provided by the customer, but it never treats that information as proof of identity. Staff must confirm the customer and the correct order before completing the handoff.

ArrivalOps also includes audible reminders, configurable pickup zones, reversible staff actions, and operational reporting. If a vehicle leaves before the situation is resolved, staff can investigate and confirm whether a pickup was actually missed.

The goal is straightforward: help staff notice customers who might otherwise be overlooked.

How I built it

ArrivalOps started with Amazon's Ring Hello World developer sample, which provided the foundation for connecting to the Ring Partner API.

Using the Ring Developer Playground, I implemented camera discovery and live video streaming through WebRTC and WHEP.

For vehicle detection, I integrated TensorFlow.js and COCO-SSD. The detector runs locally in the browser, examining the designated pickup area and comparing observations over time.

Rather than raising an alert from a single image, ArrivalOps looks for repeated, recent observations of a stationary vehicle. A reconciliation engine then considers the available pickup orders, check-in status, and timing before creating a case for staff.

I also integrated Amazon Bedrock to provide a second assessment of camera images. Bedrock uses an image-capable model to examine the pickup area, and its results are compared with those of the local detector. Because AI models can make mistakes, the on-device detector remains responsible for the primary observation, while Bedrock acts as an additional source of information.

The application is built with Next.js, React, and TypeScript. Its public demonstration runs entirely in the visitor's browser, allowing judges to explore the workflow without an account, credentials, or access to a physical Ring camera.

Challenges I ran into

One of the biggest challenges was working with the Ring Developer Playground.

Although the Playground provided genuine video streams, its simulated vehicle footage appeared in event history as on-demand viewing sessions rather than vehicle-motion events. This required a different approach. Instead of depending on motion webhooks, I developed a process that samples and analyzes frames from the live video stream.

Another challenge was stream reliability. During testing, video would occasionally stop advancing while the connection appeared to remain active. I added detection for frozen streams and a way to reconnect without restarting the application.

That improvement was useful beyond ArrivalOps, so I contributed it back to Amazon's Ring Hello World sample:

https://github.com/AmazonAppDev/ring-api-helloworld/pull/49

Amazon Bedrock also presented difficulties. Initial inference requests were blocked by account-level restrictions, and switching to a supported API-key integration required further testing. Even after successful inference, some model responses incorrectly classified vehicles.

Those results influenced an important design decision: ArrivalOps should use AI to assist operational decisions, not make unsupported claims about what the camera has seen.

Accomplishments

The most satisfying part of this project was bringing several separate pieces together into one working experience.

ArrivalOps does more than recognize a vehicle. It considers whether the observation is relevant, connects it to an outstanding business task, alerts the appropriate person, and provides a way to record the outcome.

The application now includes vehicle detection, configurable monitoring areas, exception handling, candidate-order suggestions, staff verification, handoff tracking, and operational metrics.

I also developed a reproducible demonstration using recorded Ring Playground footage, automated tests for the reconciliation logic, and documentation that clearly distinguishes real integrations from simulated data.

What I learned

Building ArrivalOps reinforced something important: recognizing an object is often the easiest part of making computer vision useful.

The harder questions come afterward.

Is the observation reliable? Does it relate to an actual problem? Is there enough information to take action? And what happens when the model is wrong?

These questions shaped the application. Camera observations remain separate from customer identity, uncertain results are handled cautiously, and staff retain control over decisions that affect real orders.

A useful system should not simply generate more alerts. It should help people understand what needs attention and make the next step easier.

What's next

The next step is connecting ArrivalOps to real restaurant ordering systems so that order readiness, check-ins, and handoff updates can be synchronized automatically.

I also want to explore production Ring event integrations, improve vehicle tracking across changing camera conditions, and test the system with restaurant operators.

The longer-term opportunity is to help businesses make better use of the cameras they already own, connecting physical activity with the workflows that keep their operations running.

About the demonstration

The demo uses genuine footage captured through the Ring Developer Playground, presented in a staged sequence to illustrate a customer arrival.

Restaurant orders, customer details, and check-ins are simulated. Vehicle detection, reconciliation rules, staff actions, and exception handling are implemented application functionality.

The distinction is intentional. The demonstration is designed to show what ArrivalOps does today without presenting simulated activity as a live customer transaction.

Built With

• amazon-bedrock
• coco-ssd
• next.js
• react
• ring-partner-api
• tensorflow.js
• typescript
• vercel
• webrtc