Aegis: Personal Privacy Intelligence Shield

Inspiration

I have always been interested in cybersecurity. After experiencing firsthand how easily public data can be weaponized to track my routines, I realized exactly how vulnerable our digital footprints are to Open-Source Intelligence (OSINT). Most people do not know how their scattered data points connect. I built Aegis to map out this digital exhaust and visualize exposure risks before they can be exploited.

How I Built It

The architecture is split between a frontend dashboard, a local AI parsing engine, and a data visualization backend.

To manage the entire stack efficiently as a solo developer, I wrote everything using Zed. As a high performance code editor, its speed and seamless workflow kept me focused while jumping constantly between React components and Python scripts.

The Dashboard (Frontend): I built the main user interface with React and Tailwind CSS, sticking to a dark hacker aesthetic. I used Recharts for the real time telemetry, specifically the Risk Score History line graphs and the Grade Distribution donut charts.

The Intelligence Hub (Backend/Data): For the actual threat simulation, I needed a way to parse unstructured OSINT data safely without sending sensitive information to a public API. I integrated Hermes to run locally as the intelligence engine. It analyzes the raw digital exhaust and extracts the key nodes, like usernames, locations, and linked accounts, to build out the Stalker's Web.

Once the data is structured, I used Python and Plotly to generate the network graphs. To connect this to the frontend, I utilized the Hex API. Instead of just embedding a static iframe, the Hex API allowed me to programmatically trigger the Python data pipelines and pull the interactive visualizations directly into the web app.

To calculate the overall threat level, I wrote a custom weighted risk algorithm. The core logic calculates total risk by factoring in the severity of an exposure and its recency, modeled as:

$$R_{total}=\sum_{i=1}^{n}\left(S_i\cdot W_i\cdot e^{-\lambda t_i}\right)$$

Where $S_i$ is the severity of the exposed data point, $W_i$ is the node weight (like a home address weighing more than a music playlist), and $e^{-\lambda t_i}$ applies a time decay factor so older posts impact the score less than recent ones.

Challenges I Faced

The hardest part was building the entire system solo. In a team setting, you would typically have one person on the React UI, someone else writing the Python clustering logic, and another wiring the APIs.

I had to handle all of it. Figuring out how to connect a React frontend to a local Hermes instance and then pass that data through the Hex API took a lot of trial and error. Because I had to own every part of the stack and fix my own bugs, I ended up learning the architecture inside and out.

What I Learned

Building Aegis forced me to get comfortable integrating completely different tech stacks. I learned how to bridge modern web frameworks with local LLMs and dynamic data workspaces.

It also gave me a much better grasp on practical threat modeling. Building this required me to look at data exactly the way an adversary parsing through OSINT would, which gave me a solid foundation in digital privacy and security.

Built With

• fastapi
• hermes
• hexapi
• instaloader
• next.js
• numpy
• pillow
• pytesseract
• python
• scikit-learn
• tailwindcss
• typescript
• uvicorn
• zed