Update: 5 October 2026
Lead Compass is on hold in the 12 September repository assessment. It is an internal tool, and the May engineering notes below are historical. A running public product and paying contracts have not been demonstrated; restarting depends on a concrete commercial use case.
Original engineering notes from May 2026
Lead Compass is an internal SaaS for software and web agencies that automates the whole top of the sales funnel: it discovers prospect businesses, scrapes and audits their websites, scores them with AI, and then drafts the outreach. The problem it goes after is the one every agency founder knows by heart. Prospecting is manual, proving value to a stranger takes effort, and the outreach ends up scattered across spreadsheets, tabs, and half-finished email drafts. Lead Compass turns that into a single pipeline: discover, audit, score, demo, outreach.
The part I find most interesting to build, and the part this post spends the most time on, is the audit. A cold email that says "your site could be faster" is noise. A cold email that says "your Largest Contentful Paint is 4.2 seconds on mobile, your SSL config scores a B on Qualys, and you're missing security headers Mozilla Observatory flags" is a conversation. The whole platform is built around generating that second kind of message at scale.
Discover, then actually look at the site
Discovery starts with meta-search. Lead Compass runs queries through a self-hosted SearXNG instance, dedups the results, and turns raw hits into lead records you can filter and drill into. SearXNG matters here for a boring but real reason: it aggregates many search engines without me holding API keys for each, and without my prospecting traffic being someone else's training data.
Once a prospect exists as a lead, the interesting work begins. Lead Compass doesn't just store a URL. It pulls the site apart.
The 15-point audit, and why it calls real APIs
The audit is a 15-point website analysis covering performance, SEO, security, accessibility, tech-stack detection, SSL, and Core Web Vitals, among others. The decision that shaped the architecture: these checks call real external APIs, not mocked or hand-rolled approximations.
That means the audit pulls field data from the Google CrUX API (real Chrome User Experience data, not a synthetic Lighthouse run), grades TLS configuration through Qualys SSL Labs, checks security headers and policy against Mozilla Observatory, and even reports whether the host runs on green energy via the Green Web Foundation. Tech-stack fingerprinting and link-checking run through a Node service wrapping Lighthouse, Wappalyzer, and a link checker.
Calling real APIs is the right call and the annoying one. Right, because the numbers are defensible — when an audit lands in a prospect's inbox, every figure traces back to a recognized third party rather than a score I invented. Annoying, because every one of those services has its own rate limits, latencies, and failure modes, and SSL Labs in particular can take minutes per scan. So the audit runs as a fan-out of parallel Celery tasks: fifteen checks fire concurrently, each one is independently retryable, and the run reports progress over WebSockets so the dashboard shows a live status instead of a spinner that lies.
A polyglot mesh, on purpose
Lead Compass is a polyglot microservice mesh, which is a deliberate choice rather than accidental sprawl. Each language is doing the thing it's best at.
- Django 5.1 + DRF is the core: multi-tenant workspaces, roles, JWT auth, the lead models, and the orchestration. Django owns the durable state and the API.
- Celery + Beat with Redis runs the parallel audit fan-out and scheduled work.
- A FastAPI crawler handles the async, high-throughput job of fetching pages — exactly the I/O-bound workload FastAPI is good at.
- A Node "node-tools" service wraps the JavaScript-native tooling: Lighthouse, Wappalyzer, link-check. These tools live in the Node ecosystem; fighting that is pointless.
- Elasticsearch 8.17 handles search and aggregation across leads and audit results.
- PostgreSQL 16 with pgvector stores the relational data plus embeddings for the AI layer.
On top of that sit two AI layers, which is the second thing I want to be precise about. Agent Zero does enrichment and analysis — turning a raw audit into something a salesperson can read. An OpenClaw multi-provider AI gateway sits in front of Anthropic and OpenAI, so model routing and provider failover live in one place instead of being smeared across every call site. I reuse that same gateway-and-grounding discipline across products; the abstention and grounding philosophy behind it is something I wrote up separately in RAG that refuses to hallucinate, because an AI that invents a problem with a prospect's site is worse than useless — it's a credibility risk in front of someone you're trying to win.
There are two frontends, both TypeScript/React 18 on Vite with shadcn/ui, Tailwind, and TanStack Query: an internal lead-management dashboard for the team, and a public-facing marketing and audit site with its own blog CMS (categories, tags, JSON-LD SEO) and client auth so prospects can see their own audit history. The whole thing is wired together with Docker Compose and Nginx.
Eating its own dog food
The angle I like most: Lead Compass is meant to eat its own dog food. The pipeline audits a prospect's site, finds the concrete weaknesses, and then — this is the part still being built — auto-generates a tailored Next.js demo site that does the same job better, complete with screenshots and the audit report attached. The pitch isn't "we could build you a better site." It's "we already did, here it is, and here's the data on what was wrong with the old one."
The platform's own marketing site is built to the same standard it judges prospects by. A self-audit doc grades the pages it ships at B-/B+ — honest, not a vanity A+. If the tool is going to email strangers about their performance scores, the tool's own front door had better hold up.
Where it's at, and what's next
Honest status: Lead Compass is an MVP / advanced prototype. It runs, and a lot of it works.
What's working: an extensive backend with WebSocket consumers for live run status, multi-tenant models with roles, JWT auth, outreach and tracking models, and a test suite. The discovery, the 15-point parallel audit hitting real external APIs, the scoring, the Elasticsearch layer, and the polished Docker Compose stack are real and exercised.
What's not done, and I won't pretend otherwise: demo-generation and outreach are flagged "coming soon" in the README — partially built, not finished. Everything currently targets localhost ports. There's no root production or deploy manifest yet, so I can't claim it's deployed, that it has real users, or that the demo-builder and outreach flows are shipped end-to-end. Those are exactly the load-bearing pieces of the "auto-build a better demo and pitch it" promise, so until they're done and deployed, the dog-food story is a design goal, not a finished feature.
The next work is unglamorous: finish the demo generator so the audit-to-demo handoff is real, wire outreach end-to-end, and write an actual production deploy instead of a localhost-only Compose file. The hard architecture — the polyglot mesh, the real-API audit, the AI gateway — is the part that's already standing.
Lead Compass is one of 11 products I'm building as a solo founder. If you run an agency and want to see the audit-to-demo pipeline once it's finished, the other things I'm shipping live on the projects page.