Your CRM doesn't need to be filled in. It needs a janitor.

Open any sales team’s CRM and count the same person three times. Once as “Maria S.” with a personal Gmail, once as “Maria Silva” with a work address, once as a lonely company record with no contact at all. The deal is attached to one of them. Nobody knows which. The pipeline report sums all three.

That isn’t a bug in the software. It’s the software working exactly as designed, a set of empty fields waiting for a human to fill them in, perfectly, forever, by hand.

Here’s the thing nobody wants to say out loud: a CRM is a database that rots unless someone cleans it, and you never hired the someone. The cure isn’t a better form. Your CRM doesn’t need to be filled in. It needs a janitor, an agent whose whole job is to keep the records clean while you do the selling. This post is about what that janitor actually does.

Why the CRM rots, and why no feature has ever fixed it

The naive fix for a dirty CRM is the one every vendor ships: make the form better. Required fields. Dropdowns instead of free text. A little red asterisk that won’t let you save until you pick an industry. Validation rules. A nag email on Friday: 12 records missing a phone number.

It feels like hygiene. It’s actually friction. Every required field is a small toll the salesperson pays at the worst possible moment, mid-call, mid-deal, when the only thing that matters is the human on the other end of the line. So they do what any rational person does under a toll: they pay the minimum. They type “asdf” into the required field. They pick the first dropdown option. They skip the record entirely and keep the real notes in their head, where the report can’t reach them.

The form was never the problem. The problem is that data hygiene is a chore, and chores that depend on a busy human’s discipline don’t get done. You can’t fix a discipline problem with a stricter form. You just move the rot somewhere the form can’t see it.

Think about how this actually accumulates. Suppose a typical sales team adds, say, a few hundred records a quarter. A handful are duplicates, same person, new email. A bunch arrive half-empty because the form was filled in a hurry. And every one of them starts decaying the moment it’s saved: the contact changes jobs, the company gets acquired, the phone number disconnects. Industry surveys have long pegged B2B data decay at roughly 30% a year (Gartner, via Validity), which means a third of your CRM is quietly wrong twelve months from now even if nobody touches it.

The naive answer is a quarterly cleanup project. Block a Friday. Export to a spreadsheet. Squint at it. Merge what you can stand to merge. It helps for a week. Then the rot resumes, because the cleanup was an event and the rot is a process. You can’t beat a continuous problem with an occasional solution.

The whole mistake is treating hygiene as a thing you do instead of a role someone holds.

The janitor’s four jobs

If hygiene is a role, the role has a job description. A steward agent watching your CRM does four concrete things, none of which depends on a human remembering to do them.

Job one: dedup before the duplicate is born

The naive way to deduplicate is after the fact: run a fuzzy-match report, find the pairs that look alike, ask a human to confirm each merge. It’s slow, it’s manual, and it runs late, by the time the report flags “Maria S.” and “Maria Silva,” the deal is already split across both and the merge is a surgery.

The steward’s way is to catch the collision at the door. When a new contact is about to be created, the agent checks it against what’s already there, not just exact email matches, but the same human wearing a different address, the same company spelled three ways. If it’s confident, it merges and keeps both email addresses on the one record. If it’s unsure, it doesn’t guess; it flags the pair and asks. The duplicate that’s never created is cheaper than the duplicate you merge later, and infinitely cheaper than the one you never catch.

Job two: enrich the half-empty record

A record arrives with a name and an email and nothing else. The naive fix is to make the salesperson go find the rest, the company, the title, the industry, the headcount band. Or to buy a data-enrichment vendor and bolt it on, paying per lookup whether the field was empty or not.

The steward fills the gaps it can fill, from the sources you already have. The email signature in the thread says “VP of Operations.” The company appears in three other deals. The domain tells you the firm. None of this is exotic intelligence, it’s assembly. It’s the same fact, scattered across mail and the existing CRM, that no one had bothered to collect onto the one record. The agent collects it, and marks where each value came from, so a human can trust it or correct it.

Job three: backfill from the email trail

This is the job that pays for the whole thing, and it’s the one a form can never do.

The real history of a relationship doesn’t live in the CRM. It lives in the inbox, the thread where the price was agreed, the message where the contact mentioned they were leaving, the reply where the deal slipped a quarter. The naive CRM asks the salesperson to copy all of that in by hand, which means it never happens, which means the CRM and the truth drift apart until the CRM is fiction.

The steward reads the trail and writes the record forward. A meeting happened; the next step gets logged. The contact replied from a new address; that address joins the record. The thread went quiet for three weeks; the agent notes the stall instead of letting the deal sit green and lying. The CRM stops being a thing you update about the work and becomes a thing that updates itself from the work, because the work already left a trail, and the trail was always machine-readable.

Job four: never let a record rot

The first three jobs are about getting a record clean. The fourth is about keeping it clean after you stop looking.

Decay is silent. The contact changes jobs and the email starts bouncing, but nothing in the CRM turns red, so the record sits there looking healthy while it’s already dead. The naive system waits for a human to notice, usually when a campaign bounces or a call goes nowhere. The steward watches for the signals decay leaves behind, the bounce, the auto-reply that says someone’s gone, the quarter of total silence on what’s marked an active deal, and surfaces them while there’s still time to act. A record doesn’t rot all at once. It rots one unwatched signal at a time, and a system that never stops watching catches each one.

Why an agent, and not just more automation

There’s a softer version of this idea, and it’s worth naming because it’s the one most teams reach for first. We’ll automate it. Write a rule: if a field is empty, look it up. If two records share an email, merge them. A workflow builder, a few if-thens, done.

It works until the input has a wrinkle, which is always. The rule that merges on matching email can’t see that “Maria S.” and “Maria Silva” are the same person with two addresses, there’s no shared key to trigger on. The rule that fills the title from a signature breaks the moment the signature is a logo image instead of text. The rule that flags a stalled deal fires on a deal that’s stalled for a good reason, and now it’s noise. Rigid automation handles the case you anticipated and falls over on the one you didn’t, and CRM data is nothing but the cases you didn’t anticipate.

The difference is judgment. A rule executes; an agent decides. When the steward isn’t sure two records are the same person, it doesn’t merge and hope, it flags the pair with its reasoning and asks. When it can’t read the title off a signature, it tries the other threads, the company page, the existing deals, the way a person would. When a deal’s gone quiet, it weighs whether quiet means dead or means the customer’s on holiday. A rule can only do the thing you described. An agent can do the thing you meant.

And, this is the part that matters for a system that touches your real customer data, the agent works inside a boundary. It proposes a merge; it doesn’t silently rewrite your pipeline behind your back. The destructive moves stay gated. Apollo is built so the steward can clean continuously but can’t quietly corrupt: the small, safe fixes flow, and anything that could lose data waits for a human nod. Trust in an autonomous janitor isn’t a switch you flip. It’s a ladder you climb, let it dedup and enrich first, watch it be right, then widen what it’s allowed to touch.

What a clean CRM is actually worth

It’s tempting to measure this in fields filled and duplicates merged. That’s the wrong unit. The thing a dirty CRM costs you isn’t tidiness, it’s decisions made on fiction.

The forecast that’s wrong because three records are one deal counted thrice. The campaign that burns goodwill on a contact who left a year ago. The salesperson who walks into a call cold because the history that would’ve warmed them up was sitting in an inbox nobody copied over. The new hire who inherits a territory and inherits, with it, a database they can’t trust, so they rebuild the picture from scratch, in their head, where it’ll rot again the day they leave. Every one of those is a real loss, and not one of them shows up in a “data completeness” score.

A clean CRM is worth exactly what an honest map is worth to someone navigating in the dark. You don’t notice it when it’s right. You only notice the cliff when it’s wrong.

The turn: stop being your own janitor

Here’s the part that isn’t about software.

Right now, in most companies, the data hygiene gets done, badly, late, resentfully, by the people you least want doing it. The salesperson logging notes after hours instead of selling. The ops lead running the quarterly cleanup that undoes itself by spring. The founder who, deep down, doesn’t trust the pipeline number and so re-counts it by hand before every board call, because they’ve been burned by the rot before.

That work feels like diligence. It’s a tax. Every hour spent grooming the database is an hour not spent on the relationship the database was supposed to serve. You became your own janitor because no system would hold the role, so the role fell, as these roles always do, on whoever cared enough to notice the mess.

The promise isn’t a CRM with fewer empty fields. It’s that the record is already clean when you open it, deduped, enriched, current, backfilled from the trail you were going to leave anyway, so the most capable people on the team stop maintaining the map and get back to walking the territory.

---

That’s what we’re building at Apollo: not a stricter form, but a steward that holds the role no one wanted, keeping the company’s memory of its customers clean while everyone else gets to use it. If you’ve ever counted the same person three times in your own pipeline, you already know the CRM was never going to clean itself. Now something can.