01
The camera dots were already on a map. I wanted the route to care about them.
The idea started about a year before the Alpha existed. While working for a cybersecurity client, I started following the criticism around Flock cameras and other automated license plate reader networks. Then I found DeFlock, a crowdsourced map of known camera locations, and started adding two and two.
At the time, DeFlock did not offer navigation. Google Maps could get me from Orlando to Miami, but it could not treat a layer of known camera locations as something I might want to avoid while calculating the route.
Showing camera dots was not the part I was interested in. I wanted the routing system to treat privacy itself as part of the routing decision, starting with known camera exposure instead of assuming the fastest route was automatically the best route.
The product thesis
Kite is an OK navigation tool that puts privacy first.02
A fast route and a private route are not always the same thing.
Most navigation products optimize for getting there efficiently. Kite adds another question: how much privacy is the driver willing to trade for time?
The first version of that idea focused almost entirely on known automated license plate reader locations. Late in Alpha development, I realized that was too narrow. A route could avoid mapped cameras and still lean heavily on toll roads, creating another privacy tradeoff. Kite now minimizes toll-road use as part of the privacy-oriented routing logic without treating tolls as an absolute ban.
Optimize the trip.
Time, distance, traffic and road conditions decide what "good" looks like.
Fastest usually wins.
Show the privacy cost too.
Time and distance stay visible while privacy-oriented routing weighs known camera exposure and toll-road use.
The driver decides what the difference is worth.
Sometimes the most private route is absurd. Kite still shows it.
On one Miami to Orlando test, the normal trip was roughly three to four hours. An extreme lower-camera option approached nine. I did not want the product quietly deciding that was too inconvenient to show. Kite can make the cost unmistakable. The choice still belongs to the driver.
03
This was for drivers who care about privacy enough to make their own tradeoff.
I designed Kite for privacy-conscious drivers, people familiar with projects like DeFlock, and people who simply do not like the growth of automated license plate reader networks.
That led to two product principles that stayed intact from the beginning.
Do not store route history.
No accounts, saved trips or behavioral profiles. Privacy was part of the architecture from day one, not copy added later.
Do not make the tradeoff for the user.
Kite can warn that a route adds hours. It should not hide the option because I personally would never take it.
Kite does not keep route history, but route, geocoding and camera-data requests still rely on outside services. Before Beta, that third-party request model needs to be more explicitly discoverable.
04
The product depended on data I could verify, but not control.
Crowdsourced does not mean complete.
Listings can be incomplete, duplicated, moved, outdated or simply wrong. Kite can verify what a source says. It cannot make that source perfect.
This had to stay cheap.
The bulk of the project was built between jobs. Open-source tools, permissively licensed GitHub work and low-cost services were practical constraints, not nice-to-haves.
This is browser-based navigation.
Kite is a static HTML/CSS/vanilla JavaScript app designed to run from a normal HTTPS host. Foreground Drive mode, mobile browser viewport behavior, GPS accuracy and wake-lock limitations all shaped what I could responsibly promise in Alpha.
I knew navigation as a user, not a builder.
I have used route planners since MapQuest. That turned out to be very different from understanding what has to happen underneath one.
The stack stayed simple. The behavior did not.
I selected the core resources, defined how they needed to work together, and handled the HTML/CSS and visual interface. My freelance developer implemented the JavaScript, integrations and routing behavior from my wireframes, notes and technical specifications. The details below reflect that collaborative implementation.
HTML/CSS + browser-native behavior
I handled the HTML/CSS and responsive interface. The developer implemented the vanilla JavaScript and browser APIs behind live location, watchPosition(), Wake Lock, device heading and Drive-mode interaction.
Leaflet + OpenStreetMap + OSRM
I sourced and selected the mapping and routing resources. The developer integrated them so Kite could render maps, build route alternatives, process geometry and maneuvers, and segment or stitch longer privacy-oriented routes.
More than one geocoder
I identified the search resources and defined the expected behavior. Photon handles search-as-you-type, Nominatim provides submit-time and reverse-geocoding fallback, and U.S. Census geocoding supplements residential addresses that may be missing from OSM-based indexes.
Multiple sources, conservative merging
I sourced the privacy-data inputs and defined the trust rules around them. DeFlock/FlockHopper anchors U.S. camera coverage, Panopti.ca anchors Canada, and OSM ALPR/ANPR and toll data add supplemental signals. The developer implemented the aggregation and deduplication behavior from those requirements.
Technical implementation details in this section are based on the developer's build notes, combined with the interface code, resources, UX requirements and product decisions I owned directly.
05
The first version was basically a little text box sitting on top of a map.
The visible interface was never the hard part. Most changes were behavioral. Logic changed less often, but when it changed, it usually reshaped the product.
There were dozens of numbered builds, but many were a one-line fix or a few changed characters. For the design story, I think about the work as seven meaningful product shifts rather than 80-plus "iterations."
Prove the comparison.
Get an origin, destination and camera-aware alternatives working well enough to compare Fastest, Balanced and lower-exposure routes.
Stop trusting a route count blindly.
Independently check route geometry against camera data and fail closed when verification is unavailable.
Make long trips and borders real product problems.
Segment long routes, separate covered regions and handle same-country trips that naturally cross another country.
Stop manufacturing route choices.
Collapse duplicates, use more conservative camera language and show the actual cost of a lower-exposure option.
Make privacy broader than the camera count.
Minimize toll-road use too, so a route does not reduce one kind of exposure by quietly introducing another privacy cost.
Add Drive mode.
Turn route comparison into foreground navigation with GPS progress, missed-turn handling, rerouting and camera reverification.
Try to make it lie.
Move from ordinary usability testing to adversarial QA: stale state, bad data, service failures, mobile interaction bugs and destructive reroutes.
06
An international trip is not one trip just because the user typed it that way.
Cross-border behavior consumed a disproportionate share of the build. The early mental model was simple: identify the country, load the right camera data and calculate the route.
That breaks almost immediately.
Both sides have to be checked.
A route cannot be called verified if the system only loaded the dataset for the country where the trip started.
Partial coverage has to look partial.
Covered portions can use camera-aware routing. Uncovered portions stay ordinary routing without pretending the whole trip was checked.
The road can still cross another country.
A US-to-US route can naturally pass through Canada. The visible endpoints do not tell the whole routing story.
The "edge case" is the actual road.
Alaska-to-mainland US routing makes Canada unavoidable. Treating borders as a special exception no longer worked.
For Alpha, I bounded continuous road routing to the connected network from Alaska and Canada through Panama, with the Darién Gap as the practical southern end. Remote U.S. road networks such as Puerto Rico and Hawaii are treated as local networks instead of letting the system invent a road across an ocean.
07
Key product decisions
Trust
Missing camera data can never look like zero cameras.
If a source cannot be verified, Kite falls back to ordinary routing or clearly degrades the privacy claim. A broken feed should not create the cleanest-looking route on the screen.
Language
Say "known camera listings," not "no cameras."
People take absolute language literally. The underlying data cannot support that certainty, so the product language became more conservative as the Alpha matured.
Comparison
Show minutes and cameras. Do not invent a privacy score.
The useful question is concrete: how much extra time buys how much lower known exposure? A score would hide that tradeoff behind another abstraction.
Privacy model
Minimize toll roads too. Do not turn them into a hard ban.
Late in Alpha development, I realized camera avoidance was only part of the privacy problem. A lower-camera route could still lean on toll roads. Kite now treats toll-road use as another cost to minimize, while preserving the same product principle: show the tradeoff and let the driver decide.
Choice
Do not pretend three cards mean three different roads.
Balanced can legitimately be the same path as Fastest or Fewest Known Cameras. When that happens, Kite says so instead of manufacturing variety.
Scope
Multiple destinations did not make the Alpha better.
I explored adding stops and multi-destination routing. It made an already complicated interaction too wonky, so I cut it and kept the Alpha focused on one origin and one destination.
08
Adding Start drive changed what users thought Kite was.
Drive mode was not essential to the first concept. Leaving it out started to feel dishonest about how people actually use map products.
Before pressing Start drive, people judged Kite as a route-comparison tool. The moment the button appeared, the expectation changed. The most common question became: What happens if I miss the turn?
Drive mode eventually gained live location tracking, maneuver progress, ETA and remaining distance, weak-GPS handling, sustained off-route detection, rerouting from the current location, arrival states and best-effort wake lock.
More importantly, a reroute has to preserve the user's Fastest, Balanced or Fewest Known Cameras preference where possible, and it has to re-run the camera verification before making another lower-exposure claim.
09
By the end, the testing question was not "do you get it?" It was "can I make it lie?"
I used a 15-person remote focus group to pressure-test comprehension and expected behavior, then paired that with QC, code review and manual mobile testing. The focus group was useful for gathering different perspectives, but it was not a substitute for real road use.
Once comprehension stopped being the main problem, the test plan got uglier on purpose.
I built a separate qc.html regression harness that hits live services instead of mocked routing. It mixes permanent known-route cases with randomized stress tests for long routes, borders, stale state, camera provenance, duplicate merging, mobile layouts, active Drive mode and failed-reroute preservation.
Repeat the same route until the data contradicts itself.
Run known routes repeatedly and look for camera counts or verification states that change without a source change.
Make the privacy route pay attention to more than cameras.
Compare routes with and without toll-heavy alternatives and make sure Kite does not reduce camera exposure by blindly increasing another privacy cost.
Search A, then B, then C without refreshing.
Old routes, camera markers, country state, maneuver state and verification badges all need to disappear completely.
Break the network during a missed-turn reroute.
The previous working route must stay on screen until a replacement actually succeeds.
Rotate the phone during active Drive mode.
Responsive layout testing is not the same as state testing. The real navigation state has to survive portrait, landscape and back again.
Tap the autocomplete suggestion on an actual phone.
A late Alpha bug selected the destination correctly, then let the same tap hit the map underneath. It looked fine in static mobile QC and failed in the physical interaction.
One mobile QC suite checked normal results layouts at phone sizes but never entered active Drive mode. The results screen passed while the maneuver UI was completely hidden. That changed the test strategy: responsive testing also had to become state testing.
10
The Alpha exists. The original market gap does not.
Kite reached a working Alpha after roughly a year of part-time work and several concentrated sprints over the final two months.
I then used it to guide a morning and afternoon of errands, about 50 miles of driving in total. Some of the privacy-oriented routes were scenic and indirect, but Kite got me to every destination I asked it to reach.
During that time, DeFlock added native navigation of its own. That means Kite no longer needs to exist because "nobody else does this." Timing solved that part of the problem for me.
I decided to finish anyway. I did not want to leave a year of work half-done, and by then the value of the project had shifted from launching a unique product to learning how to design one.
Can I trust it for a longer drive?
The first 50 miles worked. The next evidence is deliberately less exciting: roughly 100-mile and 200-mile drives where I can keep sanity-checking route behavior, privacy tradeoffs and known camera locations.
The route-comparison experience is mature enough for Alpha. The first real-world drive was successful, but live navigation, external-service resilience and route/camera validation still need more miles before I would make a stronger claim.
11
What I learned
A familiar interface can hide an absurd amount of systems work.
I knew how to use navigation software. I did not know how many invisible decisions had to agree before a route could feel trustworthy. A static web app can still become a systems problem very quickly.
Trust language is product behavior.
"No cameras" and "no known camera listings" are not stylistic variations. One makes a promise the data cannot support.
Edge cases stop being edge cases when the road actually goes there.
Borders, Alaska, islands and same-country routes through another country forced the internal model to catch up with real geography.
A new button can change the entire product contract.
Start drive looked like one feature. It changed what users expected from routing, GPS, rerouting, failure handling and mobile state.
Responsive testing and state testing are not the same thing.
A phone-sized page can look perfect while the actual Drive state is broken or a touch event is hitting the map behind the control.
Sometimes the product outcome is the lesson.
DeFlock shipped navigation before Kite was finished. Completing the Alpha still gave me a year of systems, UX and technical-direction lessons I can carry into the next idea.
Would I build Kite again?
Probably not. 😂
It was a lot of work. At some point it probably would have been easier to copy DeFlock camera locations into Google Maps and call it a day. Except that still would not solve the problem I was interested in. A map can show me where privacy-sensitive infrastructure is. Kite changes what the route considers a cost, including known camera exposure and toll-road use.
Kite did not need to become a startup to be worth finishing.
I wanted to know whether privacy could become part of the routing decision instead of just another layer on a map. The Alpha works on the road. Now I want to see how it holds up over longer drives.
Want to test Kite?
Kite is live as an Alpha. It works, but it is still experimental, the underlying privacy data can be incomplete, and I would not treat it as a replacement for your usual navigation app yet. Set up routes while parked, and if you use Drive mode, keep your normal navigation option available as a backup.
Test the Alpha