If you use Kommo CRM with WhatsApp (especially via official API) and want to prove ROI, the fastest way is not to “tweak the bot” or change the script: it is to calculate ROI by funnel stage (from first response to closing) and tackle the bottleneck that is really burning money. I do this in practice because without this insight, you just increase volume, inflate the team, and keep the same conversion.
This article covers an angle almost no one addresses: ROI by stage, using Kommo as the sales “measurement system.” This is not a post for curious beginners. It’s for those who already sell, already have traffic/prospecting, and need to optimize and scale without being hostage to guesswork.
What is ROI by funnel stage (and why it unlocks scaling)
When someone says “CRM ROI” or “WhatsApp ROI,” it usually becomes a shallow calculation: revenue minus tool cost. That doesn’t tell you where the money is leaking.
ROI by stage means measuring, stage by stage, what happens with the lead:
- Speed: how long it takes to move from one stage to another (actual SLA).
- conversion rate: % that advances to the next stage.
- Incremental cost: how much it costs to “push” the lead forward (human time, messages, calls, automations, media).
- Cash impact: how much each 1% improvement or each hour saved represents in revenue and margin.
In practice: you stop fighting for “more leads” and start printing money with what you already have coming in. This is engineering: measurement → hypothesis → adjustment → new baseline.
Who this is for (and who it’s NOT for)
Serves If you:
- You already have a steady flow of leads (traffic, referrals, inbound, outbound, partnerships).
- You sell via WhatsApp and feel the operation is “expensive” (too much service for too few closings).
- You want to justify investment in CRM/automation with numbers.
- You’re struggling with dying follow-ups, cold leads, and salespeople “forgetting” people in the funnel.
DOES NOT serve If you:
- You don’t have minimum volume (e.g., 20–30 new opportunities/month) and want a miracle.
- You don’t accept standardizing the process (wanting “each salesperson their own way”).
- You won’t record data in Kommo (without field/stage discipline, no reliable metrics exist).
The biggest mistake I see: measuring “final conversion” and ignoring the rest
The team looks at it as: “we close 8% of leads.” Then they try to improve with motivation, script, training… But the problem could be anywhere:
- Delay in first response (lead cools off and you still pay for the click).
- Loose qualification (you fill WhatsApp with curious people).
- Proposal without deadline (lead disappears, cycle blows up).
- Manual follow-up (salesperson does it when they feel like it; when pressured, they disappear).
Without separating by stage, you “optimize” the wrong place.
The practical model: 6 metrics I implement in Kommo to measure ROI by stage
I go straight to what works. You need 6 metrics to have an actionable view:
- ART (Average Response Time) at the “New lead” stage.
- Contact rate (lead responded/was truly attended).
- Qualification rate (became a real opportunity).
- Proposal rate (the lead received a proposal/quote).
- Closing rate (won).
- Cycle time (from new lead to won/lost).
These metrics, combined with cost (media + tools + human time), become ROI by stage.
How I structure the funnel in Kommo to measure without mess
Kommo is powerful when you design a funnel with governance (stages + fields + SLA + automations). If you leave it “free,” it becomes a pretty but useless board.
Structure I use in most WhatsApp operations (adjusted by niche):
- New lead (no service)
- In service
- Qualified
- Proposal sent
- Negotiation
- Gain / Lost
The trick is: each stage has entry criteria. E.g.: “Qualified” only enters if minimum fields are filled (pain, budget, deadline, decision maker). If not, it doesn’t move. Method > improvisation.
If you want to deepen implementation discipline (to avoid chaos), I offer two internal paths:
- Kommo CRM implementation: real step-by-step (and the 5 errors that block progress)
- Kommo CRM in 2026: how to design governance (SLA, fields, and audit)
Where WhatsApp API fits in (and what changes in ROI)
WhatsApp API is not a “technical detail.” It impacts cost and predictability. Why?
- You can operate with an official number, multiple agents, queues, and auditing.
- You get clearer rules for templates and conversation windows (this changes your follow-up playbook).
- You reduce operational ban risk when you leave unofficial solutions.
But here’s the truth without romanticizing: API alone doesn’t improve conversion. It improves control and scale. Conversion comes from funnel + SLA + well-designed follow-up.
If you’re at the API stage and want to avoid costly mistakes, I recommend this internal checklist:
ROI calculation by stage: the simple method I use (no endless spreadsheet)
You don’t need enterprise BI to start. You need an objective calculation.
I start with three numbers:
- Cost per lead (CPL): coming from traffic/outbound (if paid inbound, from the manager; if outbound, from tool cost + list + labor).
- Lead-to-win: final closing rate (in Kommo, wins / total leads).
- Average order value and Margin: because ROI without margin is fantasy.
Then I break it down by stage:
- How many drop from “New lead” to “In service”? (SLA and routing)
- How many drop from “In service” to “Qualified”? (qualification and screening)
- How many drop from “Qualified” to “Proposal sent”? (process and proposal speed)
- How many drop from “Proposal” to “Won”? (follow-up and negotiation)
Numerical example (with real tool price numbers, no miracles invented)
I will use a real and public data point to avoid guesswork: the GoHighLevel has an entry plan published in US$ (and the value varies by plan). You can find the details and conversion to reais here: How much does Go High Level cost? Plans and price in BRL (2026). Even if you use Kommo, this helps remind you of one thing: real cost is not just the subscription fee — there’s exchange rate/fees, integrations, API, labor.
Now, let’s go to the practical example of ROI by stage (generic, but the logic is real):
| Stage | Metric | What I observe | ROI Lever |
|---|---|---|---|
| New lead | TMR | Delay > 5 min usually drops contact in hot traffic | Queue + SLA + distribution automation |
| In service | Contact rate | Lead doesn't respond because message is weak or timing is bad | 1st message + cadence + automatic resumption |
| Qualified | % qualified | Customer service turns into aimless “chat” | Qualification checklist + mandatory fields |
| Proposal sent | time until proposal | Proposal takes 1 day and the lead cools off | Template + catalog/proposal + automation |
| Negotiation | Follow-up | Without cadence, cycle bursts | Automatic follow-up with rules and tasks |
| Gain | Final rate | Closing fluctuates due to lack of standard | Playbook + audit + data-driven training |
The point isn’t “what rate is good.” The point is: which stage is killing your ROI today and how much it’s worth to fix first.
How I turn this into actions in Kommo (without becoming an endless project)
This is execution. Instead of “let’s automate everything,” I implement in short cycles:
- Cycle 1 (7–14 days): SLA + routing + minimum fields + standardized stages.
- Cycle 2 (7–14 days): follow-up cadence (automatic tasks + messages) and team audit.
- Cycle 3 (14–30 days): proposal/budget integration and standardized loss reason (to generate real learning).
If you want to improve follow-up specifically (where much ROI dies), this internal post connects well with what I do in Kommo:
What usually gives the most ROI first (my order of attack)
When I enter an operation and need to unlock ROI quickly, the most efficient order usually is:
- 1) Service SLA: reduce response time and ensure every lead is served.
- 2) Screening/qualification: stop wasting human effort on bad leads (or at the wrong stage).
- 3) Automatic follow-up: recover sales “lost by forgetfulness.”
- 4) Proposal and next steps: every conversation needs to end with a clear next action.
- 5) Loss reason and audit: without this, you repeat the mistake forever.
This isn’t pretty, it’s profitable.
Traps that seem like “optimization” but only increase cost
- Automate before standardizing: bot on top of a bad process just scales chaos.
- Flood WhatsApp with messages: you increase operational cost and annoy the lead (and sometimes worsen response rate).
- Not separating funnels: sales and post-sales in the same flow become noise (and drain the team’s energy).
- Not measuring by channel: organic, paid, referral and outbound behave differently. Mixing kills diagnosis.
Quick checklist: the minimum for you to start tomorrow
- Define stages with criteria (what needs to happen to advance).
- Create 3 mandatory fields in qualification (e.g.: need, deadline, budget/fit).
- Activate First response SLA with automatic alert/task.
- Standardize reasons for loss (closed list, no chaotic free text).
- Do 1 weekly funnel review looking at: TMR, contact, qualification, proposal, closing.
If you do only this, you leave “feeling” mode and enter “data-driven management” mode. Then it makes sense to discuss AI, bot, n8n, more advanced integrations.
Conclusion: ROI isn’t opinion — it’s instrumentation
Kommo + WhatsApp can be a predictable sales engine, but only if you treat it like engineering: instrument, measure, adjust and standardize. ROI by stage is what gives you clarity to invest where it returns and cut where it only costs.
If you want me to design this in your operation (funnel, SLA, WhatsApp API, automations and ROI report by stage), the next step is simple: request a project.
FAQ
The questions below are the ones I answer most when a company wants to measure ROI of Kommo + WhatsApp without fooling themselves.