Campaigns end. Infrastructure compounds. These are the things I built that kept generating pipeline, trust, and clean data on their own: a public lead magnet, an attribution portal leadership actually believed, the data scaffolding underneath everything, and the Claude Code operating system that runs it all.
What it is: a public "get your free scorecard" product. A prospect enters their domain; the engine digests their homepage positioning, picks a competitor set, fans out across data APIs (Moz and other SEO/authority sources, live search context), and produces a personalized AI search readiness scorecard. Same run feeds a public page for the prospect and a deeper handoff view for the rep.
What it did: it generated $700K in pipeline in just a few weeks after launch. Prospects got a real analysis instead of a gated PDF; reps walked into calls already oriented. My job was productizing the unfinished engine into something client-ready, wiring both frontends, and building the connector so thousands of signups couldn't crash or double-bill the expensive part.
flowchart TD DOM[Company domain] --> SITE[Digest homepage
positioning] SITE --> COMP[Select competitor set] SITE --> ENG[Analysis engine] COMP --> ENG subgraph DATA["Data APIs the engine calls"] MOZ[Moz + SEO / authority APIs] WEB[Live search context] end DATA --> ENG ENG --> PUB[Personalized public scorecard] ENG --> REP[Rep-ready handoff view] style ENG stroke:#10b981,stroke-width:2px style PUB stroke:#8b5cf6 style REP stroke:#8b5cf6
The engineering that let thousands of signups hit an expensive engine without crashing or double-billing it: the scorecard connector.
The MVP: I started with a portal that pulled the outbound tools and CRM into one place, matched campaign recipients to deal contacts by email address, and required a human to approve or deny each match before it counted. It gave us a fast, auditable answer to whether outbound influenced a deal while approved historical numbers stayed fixed.
The company model: when the whole company moved from last touch to linear multi-touch attribution, outbound activity had to become structured HubSpot history. OutboundSync recorded EmailBison email events and Lemlist email and LinkedIn sequence touches on the contact timeline so GTM engineering work could participate in the same attribution model as every other channel.
flowchart TD
subgraph SRC["Every outbound tool + the CRM"]
direction LR
AP[Apollo]
EB[EmailBison]
LL[Lemlist]
HS[CRM deals]
end
SRC --> N[Match campaigns to deals
by email address]
N --> EDGE[Possible matches:
campaign touched this deal?]
EDGE --> Q{Human review queue}
Q -->|Approve| ROLL[Counted in
the dashboards]
Q -->|Deny| X[Excluded]
ROLL --> AI[AI writes the story of
where each deal came from]
style Q stroke:#10b981,stroke-width:2px
The full evolution from the human-reviewed dashboard to company-wide linear multi-touch: how we made outbound visible in HubSpot.
What got built: most of the warm signals (replies, lifecycle stages, closed-lost ICP, etc.) piped into a Clay audience for LinkedIn/Meta retargeting — not every MQL, and not a stale CSV.
What didn't: the second layer. If they were a CMO or VP of Marketing, membership in the ad audience should have also resequenced them into a human-activated sequence and put them in front of a rep. Full writeup ?
What it was supposed to be: escape an overbuilt Clay scoring model into a simple Supabase mirror — rank accounts from engagement + firmographics (ads, headcount, funding) with weights you can slide (or eventually auto-adjust) when a startup's product and persona move, instead of editing Clay tables by hand.
What we had instead: channel-specific triggers like Fibbler ad engagement → HubSpot task. Useful. Not a holistic priority queue. Full draft writeup ?
What it is: conventions built into every workflow so the database compounds instead of decaying. Email verification results get written back to the CRM as standardized statuses. Every enrichment result is stamped with when it was fetched and from where, so no lookup is ever paid for twice. Competing legacy fields got consolidated to one source of truth. Every bulk write snapshots the current values to a rollback file first.
What it did: across tens of thousands of accounts and hundreds of thousands of contacts, data quality improved as a side effect of normal work. New campaigns started smarter than the last one, and nobody ever had to run a "data cleanup quarter."
flowchart TD RUN[Run a campaign] --> LEARN[Campaign produces data:
verified emails, bounces,
enriched profiles, replies] LEARN --> WRITE[Write it back:
validation status, timestamps,
enrichment source + date] WRITE --> CRM[(CRM + sales database
a little cleaner than before)] CRM --> NEXT[Next campaign starts smarter:
skips verified, excludes bounced,
uses cached profiles] NEXT --> RUN style CRM stroke:#10b981,stroke-width:2px
What it is: my Claude Code environment, built up over thousands of hours into something closer to an operating system than a chat window. It is the working layer across coding, CRM operations, research, writing, project management, personal admin, and the production systems on this site. A small referential index routes each task to the right business context, tool notes, procedures, and atomic memory files instead of loading everything at once. When something fails, the relevant reference gets corrected so the same mistake does not happen twice.
What it did: it's the reason one person could build and operate everything on this site. It also travels: the company-specific parts swap out, and the whole system can be installed at a new org in days.
flowchart TD
T[Task arrives] --> Q{Is there a checklist for this?}
Q -->|building an email list| P1[Run the safety checklist first]
Q -->|new tool| P2[Test it live before trusting the docs]
Q -->|no| L{What kind of task?}
L -->|CRM work| HS[Load the CRM knowledge]
L -->|outreach| OR[Load who we sell to + what works]
L -->|specific tool| AD[Read the tool notes first]
L -->|unclear| ASK[Ask before guessing]
AD --> RUN[Use a proven tool or build new]
RUN --> FAIL{Did it fail?}
FAIL -->|yes| HEAL[Fix it AND correct the notes]
FAIL -->|no| MEM[Save any lesson learned]
The actual architecture behind the rules, routed context, tool docs, commands, and referential memory: the Claude Code operating system.