Revenue operations, rebuilt by hand · B2B companies of 20–200
Nobody hired them for it. It isn’t in their title. They’re just the one who remembers why the routing works, which account the invoice sits under, and what the person who left three months ago wired into that zap. We take that job off a person and rebuild it as workflows that run inside the CRM, the ticketing system and the chat your team already uses — data hygiene, lead routing, attribution, pipeline reporting, and the automations underneath.
Nothing migrates. Your team learns no new tool. Clients pay from month one — we don’t run free pilots.
The state of things
Companies your size don’t decide to build a go-to-market stack. They accumulate one — a CRM, a form, a few dozen automations, a chat channel where things get escalated, each added by someone solving a real problem on a real Tuesday. None of it was designed. All of it is load-bearing.
Then the person who built the automations leaves, and the automations stay. A field gets renamed and a workflow fails silently. Sales stops filling in the one property attribution depends on, so the pipeline number in the deck and the pipeline number in the CRM stop agreeing and nobody can say which one is wrong. Everything technical routes to the one person who can read a zap — usually the person who was hired to do something else entirely.
That person is not short on skill. They’re short on a mandate. Keeping the things that already exist from falling over eats the hours that were supposed to go into growth. And it never rises to the level of an emergency, so it never gets fixed. It just quietly sets the ceiling on how fast you can sell.
The argument, part one
Roughly 300,000 B2B companies between 20 and 200 people in the US and EU run a live go-to-market stack — a CRM with real deals in it, automations wired between tools, someone sending sequences. That’s our estimate, built from the public install base of the major CRMs and business-count data from the US Census and Eurostat.
In a year, that same market makes on the order of 6,000 dedicated RevOps hires.
Hold those two next to each other. The work exists in three hundred thousand companies. The role exists in a few thousand. Everywhere else the work doesn’t disappear — it gets handed to whoever is standing closest. Usually one person in marketing or ops who is good with tools and can’t say no. That’s not a hiring gap. That’s a market where almost nobody’s demand is shaped like a job posting.
The demand for the work is two orders of magnitude larger than the demand for the job title.
The argument, part two
Rule-based automation — the zaps, the workflows, the if-this-then-that layer every company of this size has — takes something like ten percent of what a revenue person actually does. Not because the tools are bad. Because everything above that line needs a judgment call: is this lead real, is this ticket a bug or an upsell, does this account belong to the same company under a different spelling.
So the ten percent gets automated and the ninety percent stays with people. And then the ten percent quietly becomes its own job. Someone has to watch it. A field arrives in the wrong format and the automation silently stops. The person who built it leaves and the automation stays, doing something nobody can explain. The stack grows another animal, and the only map of it lives in one person’s head.
What changed is the ceiling, not the tooling. With AI in the loop, our estimate is that somewhere between sixty and eighty percent of that work is now reachable — two to three times the old line. Treat that as our read on where the technology is, not as a measured result from a client engagement.
And none of that reach lands on routing that misfires, data nobody trusts, or an attribution model three systems disagree about. Agents amplify the operation you actually have. On a clean one that’s leverage. On yours it’s faster mess.
At ten percent, you buy tools. At sixty, you rebuild the operation. That’s the whole difference, and it’s why the answer to this stopped being “add another integration.”
How this gets bought
Every founder we talk to has already priced the obvious version of this: hire a RevOps person. Loaded cost sits around $120K a year, and the search runs six months or more before anyone good says yes — for work that arrives in bursts. Most companies look at that, decide it isn’t this quarter’s problem, and hand the work back to the person who’s been absorbing it all along.
We’re the other option in that comparison. Not a subscription your team has to adopt, and not a dev shop that builds what you spec — a small senior team that takes the operation apart inside your own systems and puts it back together as workflows. You’re comparing us to a hire, which is the right comparison, because that’s the shape of the thing being replaced.
What a hire gives you
One person’s throughput. One person’s memory. Six months to find, longer to ramp, and the whole thing walks out the door if they leave.
What we give you
Written architecture, codified workflows, tests and monitoring — all of it in your accounts. Two senior operators working inside your stack, and everything they build stays after they stop.
We don’t publish prices. Scope and cost are written down before anything is touched, and you’ll get real numbers on the first call — on the call, not in a proposal two weeks later.
The unit of delivery
A live workflow is one named piece of your operation, written down as explicit steps, moved off a person and onto an engine: a trigger, the steps in between, a place it writes to, and a human checkpoint wherever the call is genuinely a judgment call. It runs in your accounts, on your data, inside the tools your team already has open.
The second half is the part this category usually skips. Every workflow ships with an eval — a set of cases with known right answers that we run against it — and a failure alarm. Named, so you can point at it. Written, so it survives whoever built it. Alarmed, so when it breaks your team hears it before your customer does. Evaluated, so you find out it’s drifting without a customer having to tell you. Anyone can demo a workflow. The eval is what makes it maintainable after we leave.
That’s the unit. Not “AI transformation,” not a platform, not a number of hours. When a cycle ends you can list what now runs without a person in it, and what still doesn’t.
What we build
These are the functions a RevOps hire would own. We build them as working systems inside your tools — not as a deck describing how they should work.
Most of this market builds at the top: signals, outbound, ads, content. The bottom is where the companies we’ve worked with were actually drowning. Email, chat and messenger traffic normalized into one structured layer. Every message matched to an account with its history attached. Genuine noise filtered before a human opens the queue. Requests routed to the person who owns that account and answerable from the chat tool your team already lives in. And then the same stream read for what it also is — a signal feed for sales and product, instead of a queue somebody empties.
Where GTM data is involved, we work alongside Extruct AI — an independent, agent-driven company-research platform. They’re a partner, not a part of what we sell, and every answer their agents return comes with its source.
Field notes
We publish client names only with explicit permission and we don’t have it, so these are written without them — and without any of the clients’ own numbers. What’s here is what was actually broken, what was actually built, and what actually changed. On a call we’ll walk you through the architectures in full.
Anonymized by choice, not by convenience: we publish names only with explicit permission, and numbers from these engagements belong to the clients, not to us. If that costs us credibility with you, ask for the walkthrough on the call — that’s the version with the architecture diagrams in it.
How we hold ourselves to it
Consulting has a structural problem: the more indispensable the consultant becomes, the better the consultancy does. We built delivery against that incentive on purpose.
Every engagement is instrumented from the start. We track what portion of delivery still runs through us — the steps someone on our team performs by hand, because they haven’t been codified yet or because the judgment involved isn’t safely automatable. That share is a number we keep, and it goes into the read-out at the end of every cycle whether it moved in the right direction or not.
Then the loop: every manual step we find ourselves repeating gets written down, turned into a workflow, given an eval, and moved off our hands. That’s the actual engine of this business. Not a model, not a platform — a discipline of noticing what we keep doing twice.
The honest part: on the first deployment that share is high. Most of the work is still ours. Anyone in this category telling you their agents are running a revenue operation unattended today is selling you a roadmap and calling it a product. We’d rather show you the number and where it’s heading.
How it runs
We pick one sharp axis to start: one channel, one segment, or one class of breakage. Not “a pilot across the business.” Scope, sequence and cost are written down and agreed before anyone touches a production system.
Admin access to the core systems: CRM, ticketing, email, calendar, the automation layer. Then the inventory — every existing workflow written down with what it does, what depends on it, and what it would cost to move, plus which services are sitting on somebody’s personal account. This is usually the first time anyone has seen the whole map on one page, and the map is yours whatever happens next.
Building, in cycles with a fixed scope and a fixed price agreed in writing before each one starts. A weekly rhythm you can set a calendar by: a planning call, a mid-week sync, an async retro, and a plan-versus-done tracker anyone on your side can open. Every decision lands in a running log, so the reasoning survives the people.
At the end of each cycle, a scheduled checkpoint with three outcomes that are all genuinely available. Continue into the next cycle, re-scoped on what the data now says. Pivot — same budget, different target, because the first axis turned out to be the wrong one. Exit — you keep everything and we stop, with no penalty.
It’s tool-agnostic by construction. The data layer doesn’t care whether your CRM is the one you have today — swap the tool, keep the model. You’re buying architecture, which is the opposite of buying lock-in.
The alternatives
This is the shortlist the companies we work with had open when they found us. Two of these are genuinely better choices in some situations, and we’ll say which on the call.
| RevFactory | A senior RevOps hire | A GTM / RevOps agency | An AI SaaS subscription | Build it internally | |
|---|---|---|---|---|---|
| What you’re buying | The function, delivered as working systems | A person, and the function eventually | Output on one surface of the funnel | A product, plus the job of running it | Your own team’s next quarter |
| Where the work lives | Inside your existing stack | Inside your existing stack | Often partly in theirs | In their product | Inside your existing stack |
| Who builds it | The people you talk to on the call | One person, alone | An account team you meet after signing | You do | The person already doing three jobs |
| What’s left if it ends | Architecture, workflows, evals, code, decisions log | Whatever they wrote down | Usually the results, rarely the system | Nothing — it leaves with the subscription | Yours, if it ever ships |
| Honest failure mode | Wrong scope on cycle one — that’s what the read-out is for | A great hire with no leverage, burning out on hygiene | Wins at the top of the funnel on a broken foundation | Another animal in the zoo | It never gets prioritised |
Look at the second column first. If you have the budget approved, the patience for the search and a mandate wide enough to keep them, hire — genuinely. We’re the answer for the far more common case: the work is real, it’s bursty, and $120K plus a six-month search cannot be justified against it.
Before you book anything
Who does the work
RevFactory is Greg Orlov and Georgy M., working out of Tbilisi. There’s no account layer between you and the build, no junior team you meet after signing, and no discovery theatre — the person who scopes the cycle is the person whose name is on the commits.
We’re small on purpose, which means we’re capacity-constrained and we say no fairly often. It also means we’ve run these functions ourselves rather than advised on them, and we build the systems we wanted back when we were the ones being escalated to.
Our clients come from RevGuild, the community of around fifty revenue and go-to-market operators across Europe and the US that we run. We’re not buying attention. People watch us work first and hire us afterwards.
The long game
The reason a customer churned is in a support thread. The objection that kills your deals is in call recordings nobody re-listens to. The feature that would unlock your next tier of revenue has been asked for repeatedly, across three channels, matched to zero accounts. Every company your size runs on knowledge like this, and almost none of them can query it.
Each workflow is useful by itself. What happens over several cycles is less obvious: the support stream, the deal history, the enrichment records and the campaign results end up in one structured layer instead of four disconnected ones. Questions that used to require a person who remembers become questions you can ask the system.
We’re deliberately not selling that as the deliverable. Programs that start by promising a company-wide brain are exactly the ones that die in month four. It’s where this goes if you keep going — one workflow at a time, each one paying for itself before the next one starts.
Fit
Fixed scope and fixed price per cycle, agreed in writing before any work starts — which is why there’s no number on this page: the answer depends on scope, and we’d rather scope it properly than post a figure that’s wrong for you. The useful comparison isn’t a software line item, it’s the hire: a senior RevOps person costs around $120K loaded before you count the six-plus months of searching, and this work arrives in bursts that are hard to justify a salary against. You’ll get real numbers for your scope on the first call, on the call itself.
No. There’s no RevFactory interface, nothing to migrate and nothing new for your team to learn. They keep working in the CRM, the ticketing system and the chat they already use. What we build sits behind those tools, in your accounts, on your data. If we disappeared tomorrow, it would keep running.
A hire is one person’s throughput and it takes half a year to acquire. We’re two senior operators who have done this inside more than one stack, we start in weeks, and what we leave behind is written down: architecture, workflows, evals, code, decisions. If you make the hire later, they inherit a documented operation instead of an archaeology project. Some of our clients will make that hire eventually. That’s a good outcome, not a lost one.
An agency is usually paid to produce output on one surface — campaigns, sequences, ads. A freelancer builds the automation you ask for, and it works until something upstream changes. We work the other direction: inventory first, then a data model that doesn’t depend on any single vendor, then workflows on top of it, each one written down, alarmed and evaluated. The difference shows up the third time you change a tool.
Not the irreversible ones. Deterministic rules handle the cases that are actually obvious, because they’re faster and cheaper and don’t hallucinate. AI handles the ambiguous middle. Anything high-stakes routes to a person with the context already attached. That isn’t a safety disclaimer — it’s the cheapest architecture that works.
Because it ships with an eval: a set of cases with known correct answers that runs against it. Combined with failure alerts on every pipeline, drift and breakage surface to your team rather than to your customer. This is the part most of this category skips, and it’s why handovers usually decay.
You exit at the end of any paid cycle without penalty and keep everything: architecture doc, pipelines, code, evals, decisions log, workflow inventory. Every cycle ends with a scheduled read-out where exit is one of three named options, not an awkward conversation you have to start yourself.
The two people you meet on the call. No delivery team behind a curtain and no handoff to someone you’ve never spoken to — which is also the honest limit on how many engagements we run at once. From your side: about an hour a day from one person, plus admin access to the core systems in week one. We’re blunt about the hour because it’s the strongest predictor of whether an engagement ships.
We can’t name one: we publish names only with explicit permission and we don’t have it, and we’d rather say that plainly than dress up a case with a fake descriptor. On a call we’ll walk you through real architectures in detail, which turns out to be more convincing than a logo wall anyway. As for where to start — whatever is bleeding, and it’s usually obvious in the first ten minutes. Support drowning across channels. A CRM whose data nobody trusts. Automations that fail quietly. Leads sitting unrouted. If it isn’t obvious, that’s what the inventory is for.
Thirty minutes with Greg. No deck and no discovery theatre — we’ll go through what’s running today, tell you what we’d build first and roughly what it takes, and say plainly if this isn’t work we should be doing for you.
One call, one person, no follow-up funnel. If we’re not the right answer, we’ll tell you what is.