UX case study Working alpha

I built a navigation tool that lets you trade time for increased privacy on the road.

Kite compares the fastest driving route with privacy-oriented alternatives. It minimizes known camera exposure and toll-road use, shows what that choice costs in time and distance, then lets the driver decide what the added privacy is worth.

Role
Product/UX Designer + Technical Creative Direction
Ownership
Concept, research, UX strategy, visual design, wireframes, interaction logic, routing behavior, copy, testing criteria and implementation specs
Collaboration
Freelance developer working asynchronously from my wireframes, notes and technical requirements
Timeline
About one year part time, with concentrated product sprints over the final two months
Status
Working Alpha, real-world road testing underway
Kite desktop route comparison from Orlando to Miami showing fastest, balanced and fewest-camera options with time, distance and known camera counts.
Kite does not hide a painful tradeoff. In this Alpha route comparison, the lower-camera option adds 52 minutes to avoid up to seven known camera listings.

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.

Typical navigation

Optimize the trip.

Time, distance, traffic and road conditions decide what "good" looks like.

Fastest usually wins.

Kite

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.

Principle 01

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.

Principle 02

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.

A privacy product still has dependencies

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.

Camera data

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.

Budget

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.

Platform

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.

Experience

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.

Under the hood

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.

Interface

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.

Maps + routing

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.

Search

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.

Privacy data

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.

No account system No stored route history No proprietary map API dependency Camera verification fails closed Tolls penalized, not banned No invented privacy score

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.

Kite desktop starting screen with a route form over an OpenStreetMap map.
The current Alpha still keeps the planning screen deliberately simple. Most of the complexity sits behind Show my options.

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."

Phase 01

Prove the comparison.

Get an origin, destination and camera-aware alternatives working well enough to compare Fastest, Balanced and lower-exposure routes.

Phase 02

Stop trusting a route count blindly.

Independently check route geometry against camera data and fail closed when verification is unavailable.

Phase 03

Make long trips and borders real product problems.

Segment long routes, separate covered regions and handle same-country trips that naturally cross another country.

Phase 04

Stop manufacturing route choices.

Collapse duplicates, use more conservative camera language and show the actual cost of a lower-exposure option.

Phase 05

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.

Phase 06

Add Drive mode.

Turn route comparison into foreground navigation with GPS progress, missed-turn handling, rerouting and camera reverification.

Phase 07

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.

US ↔ Canada

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.

US ↔ Mexico

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.

Same-country route

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.

Alaska

The "edge case" is the actual road.

Alaska-to-mainland US routing makes Canada unavoidable. Treating borders as a special exception no longer worked.

The model that finally held up The user sees one trip. The system can treat it as several covered legs with different rules.

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

01

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.

Unavailable ≠ zero.This rule stayed permanent.
02

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.

"Up to 10 camera listings"Less dramatic, more honest, and better received in testing.
03

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.

Adds 6 minutes. Avoids 8 known camera listings.That tested better than a made-up 83/100.
04

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.

Minimize, not eliminate.Privacy-first routing still needs to work as navigation.
05

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.

06

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?

Kite mobile route comparison showing Fewest Cameras, Balanced and Fastest route cards with a Start drive button.
Before Start drive, Kite is still a comparison tool.
Kite mobile Drive mode with a full-screen map, maneuver card, ETA, remaining distance and Stop drive control.
After Start drive, the route cards disappear. The map, maneuver and Stop control become the product.

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.

Kite Drive mode in landscape with full-screen map, maneuver overlay and Stop drive control.
The late-stage Drive architecture is intentionally simple: map + maneuver overlay + Stop drive.

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.

14 / 15understood the core product immediately in a late-stage evaluation
15 / 15understood it after seeing one route comparison
0people asking for a proprietary privacy score

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.

01

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.

02

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.

03

Search A, then B, then C without refreshing.

Old routes, camera markers, country state, maneuver state and verification badges all need to disappear completely.

04

Break the network during a missed-turn reroute.

The previous working route must stay on screen until a replacement actually succeeds.

05

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.

06

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.

Kite mobile destination search with autocomplete suggestions open above the map and iOS keyboard.
The autocomplete looked correct. Real touch testing found that the tap could leak through to the map underneath. v84 fixed it.
What the automated tests missed

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.

~50 milesof initial real-world driving across morning and afternoon errands
100%destination success in that first road test
Next road-test milestone

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.

Why this is Alpha, not Beta

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

01

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.

02

Trust language is product behavior.

"No cameras" and "no known camera listings" are not stylistic variations. One makes a promise the data cannot support.

03

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.

04

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.

05

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.

06

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.

Public Alpha

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