DEV Community: Evan S

The Invisible Digital Footprint: Finding Your Face Without Scraping the Web

Evan S — Fri, 29 May 2026 18:11:32 +0000

Every time you walk through a crowded tourist spot or attend a stadium concert, you become an extra in someone else's digital memory.

There is a massive, invisible digital footprint of your face scattered across the internet. There are likely thousands of photos of you sitting on servers right now that you will never know about. It begs a fascinating question: How cool would it be to find them?

Imagine being able to query the entire internet for your own face to find that random background shot of yourself in New York from 2018. But to build a tool that searches the open web for your face, a company has to relentlessly scrape billions of images without permission. It requires strip-mining personal data and violating privacy just to satisfy a curiosity.

I wanted to explore the technical side of facial matching without the shady data practices. That is why I built DopplGrid.

DopplGrid is a closed-loop, 100% private facial recognition network. Instead of scraping the open web, it operates as a secure vault. Our database only grows when real people explicitly choose to opt-in and lock their faces into the grid.

The Architecture Behind the Vault

To make this work securely, the app relies heavily on isolated backend microservices. The heavy lifting—like processing biometric vector embeddings and triggering real-time notifications—is handled securely via Firebase Cloud Functions.

For example, our onboarding flow utilizes a standalone, event-driven microservice. When a user joins the grid, a background function uses the Firebase Admin SDK to securely bypass frontend rules, provision a secure chat room, and inject a personalized welcome message along with real-time UI notification badges directly into the database. By keeping these services entirely isolated, the heavy backend processing never bottlenecks the user's onboarding flow and is completely abstracted away from the client side.

Because the network is entirely opt-in, you might not find a global doppelganger on day one. But the moment your face is in the vault, the engine is active. As more users join globally, your chances of an automated match increase.

Test the Engine

In the meantime, the matching engine is fully live. You can invite a friend, run your faces through the engine, and calculate your exact mathematical similarity percentage to see how closely you actually resemble each other.

We can build and explore the coolest parts of facial AI, but we have to do it on an architecture built on trust and consent.

Check out DopplGrid here and let me know what you think of the onboarding flow and the underlying architecture!

Note: Add the following tags in the Dev.to editor settings: webdev, programming, firebase, privacy

Why I Refused to Build a Web Scraper for My AI Facial Matching App

Evan S — Tue, 19 May 2026 17:55:44 +0000

Building an AI facial matching app right now presents a massive ethical dilemma for developers.

If you want to build a "find your doppelganger" tool, the easiest, fastest architectural route is obvious: spin up a Python script, hook into some open-source reverse-image APIs, and scrape the open web for massive datasets. It’s cheap, it’s fast, and it’s what almost everyone else is doing.

But it is also a massive privacy nightmare.

Every day, thousands of automated bots are crawling the web, quietly cataloging biometric data from background faces in tourist photos, public forums, and event galleries. They log facial structures into unregulated databases without user consent.

As a developer, I realized I couldn't ethically contribute to that ecosystem. So, when I started building DopplGrid, I set a hard constraint: Zero open-web scraping. Here is how I approached the architecture instead.

The Closed-Network Solution

I decided to build the antithesis of an open-web scraper: a 100% closed, opt-in biometric network.

Instead of searching the internet, the app acts as a private photo radar. It only scans and matches photos uploaded within its own secure Firebase ecosystem. If you aren't explicitly opted-in and mapped in the database, the engine cannot see you.

Mapping Geometry, Not Pixels

Most lazy scrapers use basic pixel-matching, which is terribly inaccurate and leads to false flags. To make the closed network actually valuable, I had to ensure the matching was mathematically precise.

The DopplGrid engine maps 128 unique points of a user's facial geometry (similar to how FaceID operates) and stores that map in a secure personal vault.

This allows for two completely private use cases:

Global Matching: Users can scan the opted-in network to securely find their exact biometric doppelganger.
Similarity Testing: Two users can scan their faces and the algorithm will calculate their exact mathematical similarity percentage (great for settling family debates about who the baby looks like).

The Developer Responsibility

We can't rewind the clock on the internet, but we can change how we build biometric tools moving forward. We need to stop relying on platforms that scrape data indiscriminately and start building platforms rooted in absolute consent.

The reality is that user facial data is already floating around the internet. Our job should be giving them tools to take active ownership of it, rather than harvesting it from them.

I just pushed the React build live. If you are interested in privacy-first architecture, ethical AI, or just want to test out the matching engine, I’d love for the dev community to tear it apart and give me feedback on the UI.

Check out the secure vault at DopplGrid.

How I Built a Privacy-First Facial Similarity Network using React & Firebase

Evan S — Thu, 14 May 2026 22:40:14 +0000

Building a consumer AI app right now is wild. Building one that relies on biometric data? That adds a massive layer of complexity, especially when you want to ensure total user privacy.

Most "lookalike" apps out there rely on creepy web scrapers or basic reverse image searches. I wanted to build something entirely different: a 100% closed, opt-in biometric network where the user owns their face data.

So, I built DopplGrid. Here is a look at the stack and the architecture behind it.

The Stack & Architecture

I wanted to get the web application running flawlessly before wrapping it for the native iOS and Android releases. The frontend is built in React and heavily styled with Tailwind CSS to keep the UI clean, fast, and responsive across devices.

For the backend and secure data vault, I am relying on Firebase. The core of the app is a biometric matching engine. Instead of scanning colors or pixels, it maps 128 unique points of a user's facial geometry.

The Privacy Constraint (No Web Scraping)

The biggest architectural rule I set was zero open-web scraping. The app acts as a personal photo radar, but it only tracks photos uploaded within the DopplGrid network. It only starts working after a user explicitly chooses to securely enroll their face. This ensures users can safely track their digital footprint without their data being aggregated from external sources.

The Features (The Fun Part)

Once the secure vault was operational, the matching algorithm opened up some really fun use cases.

Global Matching: Users can scan the network to find your doppelganger globally based on exact geometric similarity.
Family & Friends: I added a similarity tool so users can compare their facial features directly with friends or relatives to see the exact percentage of how much they look alike.

Looking for Feedback

We just pushed the initial React web build live. If you are interested in AI tools, privacy-first architecture, or just want to see how accurate the matching engine is to find people who look like you, I would love for the dev community to test it out.

Check out the onboarding flow at DopplGrid and let me know what you think of the UI/UX!