Challenge of Scaling: Information Entropy
Every company that scales fast runs into the same enemy: information entropy — the gradual loss of clarity and context as information spreads across more people, tools, and processes.
At Zamp, velocity and transparency are our DNA. That meant every person needed real-time visibility into customer status and the ability to self-serve any data without waiting, pinging, or depending on someone else.
In the early days, we duct-taped this together with Excel sheets and scattered Slack updates. It worked, until it didn’t. As customer volumes grew and more stakeholders got involved, the cracks started showing. Data was duplicated, conversations were buried, and no single source of truth existed. We were chasing context instead of moving work forward.
Why Traditional CRMs Failed Us
Like most teams, we turned to SaaS CRMs such as HubSpot, Attio, and others.
On paper, they promised to solve exactly this problem. In practice, they created new ones:
- It had to be manually updated - No automatic pull from email conversations or slack threads
- No resource tracking for bandwidth across our team
- Endless configuration, unused fields, and a process that forced us to adapt to the tool instead of the other way around
All systems had the same flaw: they added overhead. More forms to fill, more steps to follow, more time feeding the tool rather than getting value from it.
Decision to Build: Tools and Technology Choices
So we made the non-obvious choice: build our own.
Not because we’re engineers. But because we needed something closer to a nervous system — a living, evolving layer that captured context, generated insight, and scaled with us.
We pieced it together using:
- Supabase for an extensible, relational data backend with real-time capabilities
- Lovable for frontend interaction, focusing on customizable, just-in-time dashboards
- Slack and Gmail integrations via APIs and webhooks to automate data ingestion
The architecture was modular, explicitly separating ingestion, processing, storage, and UI layers to isolate complexity and enhance scalability.
- Data Layer: One schema for customers, projects, updates, and messages. Views that tracked health, velocity, and blockers in real time.
- Ingestion Layer: Slack/Gmail triggers that captured decisions and blockers automatically, cutting noise with signal-detection filters.
- Reasoning Layer: Agentic AI that turned unstructured inputs (threads, emails) into structured records, auto-tagging and nudging with audit logs for trust.
- UI Layer: Dashboards that adapt as our workflows change, not the other way around.
What We Built from Scratch
We built exactly what we needed:
- A Slack bot that pushes updates and automates workflows, streaming updates to the right project
- Personalized task sheets showing “last connect” and “next connect” dates, updated automatically
- Emails classified and mapped automatically, updating stakeholders in the background
- Projects and resources tracked according to our real team structure and allocated accordingly
This functionality didn’t just fill gaps — it fundamentally reversed the chaos of information entropy, restoring clarity, accelerating decision-making, and creating a resilient, adaptive system that grows in step with our business demands.
The Bigger Realization
That’s when it clicked: the future isn’t in renting SaaS tools that lock you into someone else’s workflow.
Traditional SaaS is bloated, rigid, and opinionated. It makes you work for it.
The future is self-built systems: lightweight, adaptive, intelligence-first. Software that embeds into how your company operates and evolves as you do.
Our “CRM” started as an answer to spreadsheets and HubSpot. Today, it’s the operating system of our company. And the craziest part? It was vibe-coded into existence, by sheer necessity.
