← Back to projects
Summary

The verification problem behind DoorDroppr is: given only a phone, can you tell a genuine on-foot route from someone who drove it, biked it, or faked GPS from home? We're building the answer as a sensor-fusion classifier that turns the phone's signals into a single score for P(genuine on-foot activity). What makes it tractable is the data strategy: we generate labeled training data by running real routes. It's already working: the step-count-vs-distance and gait signals reliably separate genuine walking from driving. The model is engineered features feeding gradient-boosted trees, deliberately not deep learning. We prototyped running it on-device with Core ML, but continuous inference was too power-hungry (the phones were overheating in testing), so scoring and the final verdict run server-side while the phone handles cheap capture and feature extraction. Current work is the learned model plus hardening against biking and GPS spoofing.

Stack

What it's built with.

Modeling

  • Heuristic Guardrails
  • Gradient-Boosted Trees (GBT)
  • Feature Engineering
  • Adversarial / Anti-Fraud Framing

Signals

  • GPS + Dead Reckoning
  • Pedometer / Gait (IMU)
  • Barometric Elevation

Data & Serving

  • Self-Generated Labels
  • Active-Learning Loop
  • Server-Side Scoring
  • Core ML (prototyped)
Details

How it works.

Why verification is the core problem

The whole platform hinges on one question: did this activity really happen on foot? It's a hard question because the obvious signal, a GPS track, is the easiest one to fake. Location alone can't tell a walk from a slow drive or a replayed trace.

The verification model turns 'did this person really walk these stops?' from an unanswerable trust question into a number the system computes. That score is the precondition for trusting field activity you didn't directly witness.

The training data

The model is only as good as its labels, and good labels for this problem are nearly impossible to buy, there's no public dataset of 'genuine vs. spoofed on-foot traces.' We generate them as a byproduct of operating: walking real routes yields positive labels, and deliberately driving, biking, or spoofing the same routes yields matched negatives.

A two-person 'developer mode' makes the capture clean: within a training organization, two people join a single session on a real route, one delivers flyers while the second timestamps each delivery, so two people effectively label one shift, and every drop becomes ground truth aligned to the live sensor stream. It's a self-improving pipeline: do the work, capture the outcome, feed it back as training data. The further the platform runs, the more labeled data it accumulates, a compounding data advantage, not a one-time training run.

Highlights

The things I'm proudest of.

  • ▹Sensor fusion: combines GPS, the pedometer (step count + cadence), the accelerometer/gyroscope (gait + heading), and the barometer (elevation) into one feature stream, so the model sees far more than a GPS track that's trivial to fake.
  • ▹Genuine-activity signature: walking 1 km logs ~1,300 steps while a car logs ~0, the hardest-to-fake tell; a human gait waveform in the accelerometer (vs. an engine's vibration or a phone resting on a seat) and a stop-and-resume dwell cadence further separate real on-foot activity from impostors.
  • ▹Self-generated labels (the data flywheel): we walk real routes for genuine positive labels, then deliberately drive, bike, and spoof the same routes to generate negatives, a clean supervised training set for a problem with no public dataset.
  • ▹Two-person developer mode for labeled capture: inside a training organization, two people join one session on a real route, one delivers flyers while the other timestamps each delivery, so every drop lands as ground truth aligned to the live sensor stream, turning an ordinary shift into a labeled training run.
  • ▹Early results: the step-vs-distance and gait signals already separate genuine on-foot activity from driving reliably, the core discriminator works, with the learned tree model and adversarial hardening (biking, spoofing) next.
  • ▹Model choice, GBT, not deep learning: engineered features feed gradient-boosted trees (scikit-learn now, XGBoost/LightGBM planned). On windowed sensor features, tree ensembles match or beat CNN/LSTM at a fraction of the size, no neural net required.
  • ▹Compute placement: we prototyped on-device inference with Core ML, but continuous scoring was too battery-intensive (phones overheating in the field), so the trained scorer, map-matching, and the final verdict run server-side; the phone only does cheap sensor capture + feature extraction.
  • ▹Staged build: Phase A ships heuristic guardrails (step-count-vs-distance thresholds) that also auto-label data for the Phase B gradient-boosted-tree model; Phase C is continuous adversarial hardening as new spoofing methods appear.
  • ▹Per-stop detection: a companion 'slow → turn → pause → resume' micro-pattern detector gives per-stop confidence, trained on logged ground truth captured while walking.