The clip that saved someone's claim, and why we hash everything
A week after Hawk launched, I got an email from a driver in Manchester. He'd been hit by another car at a junction. The other driver's insurer said his video was doctored. He sent me a ZIP file he'd exported from Hawk: 47 seconds of footage, a GPS track, a timestamp, and a hash. He told me the police had confirmed the hash matched the original. That was the moment I understood we'd made the right call with SHA-256.
The problem nobody talks about until they need it
Video evidence has a credibility problem. If you film an incident on your phone and send it to an insurer or police, someone will eventually ask: is this the original? Have you edited it? Did you cut out the part where you ran the red light? These questions aren't paranoid. Dashcam footage gets manipulated. Insurance companies know this. Police know this. Courts know this.
When we started building Hawk, we knew the core promise had to be simple: your evidence stands up. But simply filming wasn't enough. Anyone can record a video. What matters is proof that the video you're submitting is the exact same video you captured, untouched.
That's where the hash comes in. Every clip Hawk records gets a SHA-256 cryptographic hash written to it. Think of it like a fingerprint, except instead of being unique to a person, it's unique to that exact video file. Change one pixel, and the hash changes. You can't alter the clip and keep the hash. The two are mathematically inseparable.
What we learned from building this into the app
The decision to hash every clip wasn't trivial. Most dashcam apps don't do it because it adds complexity. You have to calculate the hash while the video is recording, store it securely, and make sure it survives export. We spent weeks testing edge cases: what happens if the app crashes mid-record? What if someone pulls the phone out of the mount? What if the video file gets corrupted?
The answer was to write the hash to the clip's metadata the moment recording stops, then verify it every time the clip is accessed. Our Evidence Locker does this automatically. When you lock a clip with biometric security, we also calculate a manifest hash of the entire export. That manifest goes into your ZIP file alongside the video, so when you send it to an insurer or police, they can independently verify that nothing has been tampered with.
I've talked to police officers who deal with dashcam evidence. They told us that hash verification is becoming standard in prosecutions. Insurance adjusters are starting to ask for it. Small-claims judges have seen enough doctored videos that they want proof of integrity.
Why this matters more than the footage itself
Here's what I didn't expect: the hash isn't really about honesty. Most people who record dashcam footage aren't editing it. The hash is about proof. It's about closing the gap between what you filmed and what a third party believes you filmed.
A few months in, another driver reached out. She'd been in a minor collision at traffic lights. The other driver claimed she'd caused it. She exported her clip from Hawk, sent the ZIP with the manifest, and submitted it to her insurer. The insurer ran the hash verification. Twenty-four hours later, the other driver's claim was rejected. No court date needed. No argument about whether the video was real. The mathematics settled it.
This is the actual value of SHA-256 in a dashcam app. It's not about catching criminals or proving fault in dramatic ways. It's about making evidence so credible that disputes don't escalate. Insurance companies move faster when they trust the video. Police take reports more seriously. And if you do end up in court, you walk in with something most people don't have: cryptographic proof that your evidence is genuine.
The feature nobody notices until they need it
One of the strangest parts of building Hawk has been watching how users respond to features. People get excited about optical flow stabilisation. They like the biometric lock. They use the GPS overlay for map replay. But the hash? It's invisible. You never think about it until the moment you're filling out an insurance claim and you realise you have something that actually proves the video is real.
That's by design. We didn't want to make a big show of SHA-256 cryptography in the UI because most people shouldn't need to understand how it works. You export a clip. You send the ZIP. If someone questions the footage, the hash is there. If nobody questions it, you never think about it again.
The only time it shows up is in the export and in our help documentation. We wanted it to be background infrastructure, not a feature to brag about. But we also wanted anyone who does need it to know it's there and to understand what it means.
What happens on the other end
I spent time talking to a loss adjuster at a mid-size insurance firm. She told me that most dashcam videos she receives are either MP4 files sent via email or links to cloud storage. She has no way to verify them. She has to make a judgment call based on the story, the other evidence, and her experience. It's a guessing game.
But when someone sends a Hawk ZIP with a manifest and hashes, it changes the conversation. She can verify the integrity of the clip independently. She can check that the GPS data matches the timestamp. She can see exactly when the video was recorded and from where. It doesn't solve every dispute, but it closes a lot of doors that bad actors try to slip through.
We've also started working with police forces through the NDSP scheme on iOS, which lets drivers submit evidence directly to their local force. Those departments are increasingly asking for hash verification because it speeds up their intake process. A video with a verified hash is evidence. A video without one is just a file someone sent.
The question Hawk exists to answer isn't really about technology. It's this: when something happens on the road, how do you prove it? Not just film it. Prove it. If you've ever wondered whether a dashcam would actually help, you've probably been thinking about the hash without knowing it.