CTI Software Is a Two-Way Contract With Your CRM

Updated 21 min read How we research

TL;DR: CTI software is the layer that lets a phone system and a business application act on the same call, and the standard behind it is ECMA-269, Services for Computer Supported Telecommunications Applications (CSTA) Phase III, 9th edition, December 2011, also published as ISO/IEC 18051 and ETSI TS 102 173. It runs in two directions. Outbound, the CRM hands a number to the phone system and a rep clicks once instead of retyping ten digits. Inbound and after the call, the phone system hands an event back and something has to write it to the right record. Most teams test the first direction in a demo and never test the second, which is why the activity timeline ends up thin and the manager’s report ends up wrong. The write path is explicit in real integration APIs: HubSpot’s Calling Extensions SDK moves through dial number, outbound call started, create engagement, engagement created, engagementId sent to app, call ended, call completed and update engagement, and it ships handlers named onEngagementCreatedFailed and onUpdateEngagementFailed, so a failed write is a documented state rather than an edge case. The screen pop fails for one boring reason, which is number matching: the dialed string and the stored string have to resolve to the same canonical form, and the ITU publishes that form as the international public telecommunication numbering plan. Browser based CTI adds a second owner, because Chrome’s Manifest V3 moved extension background work to service workers that run only when needed and removed remotely hosted code, so an extension can only execute JavaScript included in its own package and reviewed by the Chrome Web Store. Kixie’s bi-directional CRM integration logs calls, texts, outcomes and recordings into the CRM automatically, and the PowerDialer supplies the dial side with multi-line dialing and AI Human Voice Detection. Before you buy, pilot the write path on a missed call, a transfer, a wrong-number match and a duplicate record, then check whether the outcome landed as a reportable field or as free text.

A rep opens a lead, clicks a phone icon, and the call starts. Nobody buys CTI software for that. They buy it for what happens in the forty seconds after the rep hangs up.

That is the part most buying processes skip. The demo shows click to dial, because click to dial always works in a demo, on a clean record, with a number the vendor typed in themselves that morning. The write-back is where the money is, and the write-back is the part that quietly breaks in week three, when a real list turns up duplicate records, extensions glued onto the end of numbers, and the same prospect stored eight different ways by five different reps.

So let’s take the category apart. What is actually moving between the phone system and the CRM, who owns each hop, and what should you make the vendor prove before you sign?

What CTI software actually moves between the phone and the CRM

CTI stands for computer telephony integration. The label is old and the label is vague, so start with the standard instead of a vendor glossary.

Ecma International publishes ECMA-269, Services for Computer Supported Telecommunications Applications (CSTA) Phase III, 9th edition, December 2011. It is maintained by Technical Committee TC32 and is also published as ISO/IEC 18051 and ETSI TS 102 173. The standard describes an interface and services between two entities that request and provide communication services, and it names those entities directly: applications, middleware, PBX, IP-PBX, softswitch, phone, softphone, software devices. It says the services it defines allow functional integration between a computing network and a telecommunications network. It also says CSTA operates with existing interfaces so that differences among various existing interfaces are hidden.

Read that last line twice. Hiding the differences is the whole job.

A phone system speaks in channels, legs, and call states, because those are the things it has to manage to keep audio flowing. A CRM speaks in objects, fields, and owners, because those are the things a revenue team reports on. Neither one knows what the other means by “the call,” and nothing in either product is obligated to care. CTI software is the translator that sits between them and makes a single event legible to both sides at the same time.

Which means you can evaluate it the way you evaluate any translator. What did it carry across? What did it drop? And when it dropped something, did anybody find out?

The two directions CTI software has to get right

There are only two directions, and teams test one of them.

Frosted white glass objects on a pale lavender gradient. A tall upright glass block holds a clear sphere in a curved hollow on its top face. A slender glass arc rises from that block and stops in mid air, short of a lower wide glass block whose matching curved hollow is empty.

Direction one is the read. The CRM holds a record, the record holds a number, and the rep triggers a call without copying anything. Click to call, a dial button on a list view, a queue the dialer pulls from. All of it is the application telling the phone system what to do next.

Direction two is the write. A call happened. Now something has to decide which record it belongs to, create an activity on that record, and fill in duration, direction, outcome, recording link, and notes. Then it has to do the same thing for the inbound call nobody initiated from the CRM at all.

Those two directions are not symmetrical, and the asymmetry is the whole reason this category is confusing. The read direction has a human standing at the start of it, so a human notices immediately when it breaks. The write direction runs after the interesting part is over, with nobody watching, which means it can be broken for a month before anyone can prove it.

There is also a third case that hides inside the second, and most evaluations never surface it. The inbound call that nobody initiated from the CRM at all. A buyer calls your main line back three days after a voicemail, reaches whoever is available, and has a four-minute conversation that decides the deal. Nothing about that call started from a record. If your CTI software only writes activities for calls it dialed, that conversation is invisible, and the rep who owns the account will never know it happened.

Ask that question specifically. Does the integration log inbound calls to records, or only outbound ones? Does it log an inbound call that rang a group rather than an individual? And when it cannot identify the caller, does it still write something somewhere, or does it discard the event entirely?

Direction one is easy to demo and easy to verify. You click, the phone rings, everyone nods.

Direction two is where CTI software earns its line item, and it is almost never the thing a pilot actually measures, because measuring it takes two weeks and watching a click-to-dial demo takes ninety seconds. Here is the test that separates them. Have a rep place a call from a CRM record, let it go to voicemail, hang up without touching the CTI window at all, and then go look at the record an hour later. Is there an activity? Does it have a duration? Does it have an outcome, or does it have a blank field somebody is supposed to fill in later?

Nobody fills it in later. That is not a knock on reps, and treating it as a discipline problem is how teams end up buying training to fix a software gap. It is simply what happens when a system asks a human to do the system’s job at the exact moment that human wants to start the next call.

Kixie’s bi-directional CRM integration is built around that second direction, logging calls, texts, outcomes and recordings into the CRM automatically rather than asking the rep to retype them. Whichever vendor you look at, the question is the same. Does the write happen because the system did it, or because the rep remembered?

What the write path looks like inside a real CTI software API

You do not have to take the two-direction model on faith. The integration APIs are public, and they are specific.

Frosted white glass render on a pale lavender gradient. Eight rectangular glass slabs climb from lower left to upper right like steps. A small clear glass capsule rests on the fifth slab. The sixth slab sits far below the line of the others, leaving an open break, and the last two slabs continue at the correct height beyond it.

HubSpot’s Calling Extensions SDK documents three components: a JavaScript SDK that passes messages between the calling app and HubSpot, a set of calling settings endpoints that configure the app per connected account, and a calling iframe where the app actually renders inside the CRM. HubSpot’s own description of the flow is that when a user makes a call using the app, HubSpot creates an engagement on the activity timeline of the CRM record and then exchanges data with the app to fill in the details.

The documented event chain runs in this order.

  1. Dial number. The CRM sends the number to the calling app.
  2. Outbound call started. The app tells the CRM the call is live.
  3. Create engagement. The CRM creates a call engagement with minimal information when the app asks for one.
  4. Engagement created. The CRM confirms it exists.
  5. EngagementId sent to app. The app now holds the handle it needs to write to that activity.
  6. Call ended. The app reports the call is over.
  7. Call completed. The app reports the user is done with the app experience, which is a separate moment.
  8. Update engagement. The app fetches the engagement by its id, then merges and updates it with the call details.

Eight hops. Count the places that can fail.

And the API agrees with you, which is the part worth sitting with. The SDK exposes event handlers named onCreateEngagementSucceeded and onEngagementCreatedFailed, plus onUpdateEngagementSucceeded and onUpdateEngagementFailed, which means the platform treats a failed engagement write as a first-class outcome with its own callback rather than as an exception nobody planned for. A platform does not ship a named failure handler for a thing that rarely fails. Those handlers exist because the write does not always land, and because somebody building the calling app has to decide what the rep sees when it does not.

So ask your vendor a plain question. When the engagement write fails, what happens? Does the rep see it, does the call get queued for retry, or does it vanish and show up three weeks later as a gap in a manager’s activity report?

Notice also that the call ending and the rep finishing with the window are two different events. That gap is where disposition lives. If your CTI software writes the activity at “call ended” and never comes back, the outcome the rep picks a few seconds later has nowhere to go.

Why CTI software misses the screen pop

The screen pop is the feature everybody wants and the feature that disappoints first. Inbound call arrives, the right record opens, the rep answers already knowing who it is. When it works it is genuinely great. When it misses, it misses for one boring reason.

The number that arrived and the number you stored do not match as strings.

A caller ID arrives in the carrier’s format, which nobody on your team chose. Your CRM holds whatever the last person to touch that field happened to type. One of them has a country code, one has parentheses, one has a leading 1, one has an extension glued onto the end, and one was pasted out of a spreadsheet with a trailing space that is still sitting there. They are the same human being and they are not the same string, and a string comparison does not care about your intentions.

There is a canonical answer to what a phone number is, and it is not a matter of opinion: the ITU maintains the international public telecommunication numbering plan, the recommendation that defines the international form of a number and supersedes the older plan it replaced. CTI software that normalizes both the arriving caller ID and the stored CRM field to that form before it compares them will match reliably, because it is comparing two canonical strings rather than two typing habits. CTI software that does a loose substring comparison will match some of the time, miss the records that were entered differently, and report nothing at all about the ones it missed.

Then there is the second failure, which is worse because it looks like success. The number matches more than one record.

A shared office line. A spouse on two leads. The same prospect entered by two reps in March, once as a lead and once as a contact. A main number sitting on the account record and on four contacts underneath it. What does the integration do with a multiple match? Open the newest? Open the one with an open deal attached? Open a picker and make the rep choose while the phone is still ringing and the buyer is listening to it ring? There is no universally correct answer to that question, but there is a correct answer for your data and your stage model, and you should find out which rule the vendor implements before the first week of production rather than during it.

The Kixie blog has a working walkthrough of CTI screen pops on a specific CRM if you want to see the mechanics end to end.

There is a governance question hiding under all of this, and it is worth naming before the pilot rather than after. Who owns the match rule? In most teams the answer is nobody. The CRM admin owns the records, the telephony admin owns the numbers, the CTI vendor owns the matching logic, and the rule that decides which record opens on an inbound call was set by a default that nobody read. Pick an owner, write the rule down in plain language, and make the vendor confirm in writing that their implementation matches what you wrote. That is a ten-minute conversation that prevents a quarter of arguing about whether the tool works.

One more thing on matching. Clean the data before you blame the integration. If forty percent of your records hold a number no dialer could parse, a better CTI vendor will not save you. Fix the field, enforce a format on entry, and then judge the match rate.

Where browser based CTI software lives and who controls the rules

Most modern CTI software for sales teams shows up as a browser extension or an embedded iframe, not as desktop software with an installer. That is a real convenience and it adds a third party to your dependency chain. The browser vendor now has a vote.

Chrome’s Manifest V3 is the current version of its extension platform, and two of its changes land directly on anything that dials.

First, background context moved to service workers. Chrome’s documentation is blunt about why: extensions under the previous manifest kept a long-lived background page that consumed resources even when the extension was not running, and the replacement runs only when needed. “Only when needed” is a performance win for the browser and a state problem for anything that has to remember what it was doing. Anything your extension was holding in memory between one call and the next now has to be written somewhere that survives the worker being shut down, which is an implementation detail right up until a disposition goes missing.

Second, remotely hosted code is gone. Chrome removed the ability for an extension to execute code it pulls from a server at runtime, and states that an extension can only execute JavaScript that is included within its package and subject to review by the Chrome Web Store. Chrome’s stated reason is the security risk of unreviewed code running inside extensions.

What does that mean for a buyer? It means your CTI vendor cannot hot-patch the dialer sitting in your reps’ browsers the way a web application gets patched on the server at four in the afternoon. A fix to the extension is a new package and a store review, and that review sits between the bug report and the fix no matter how fast the vendor writes code. So ask how long that loop actually takes them, and ask what their rollback looks like when a release breaks dialing on a Monday morning with the quarter closing on Friday.

None of this is a reason to avoid a browser based tool. It is a reason to know where your CTI software actually runs. If you are working through what to check in that form factor, the softphone Chrome extension breakdown covers the same ground from the rep’s side of the glass.

CTI software is not VoIP and it is not your phone system

Category confusion is not an accident here. Vendors bundle, and the bundle gets a single name on the invoice. Separate the parts anyway, because each one has a different owner and a different failure mode.

  • VoIP is how the audio travels. It answers one question: does the voice get there, and does it sound acceptable? A VoIP problem sounds like a VoIP problem. Choppy audio, one-way audio, dropped legs.
  • A PBX or cloud phone system owns numbers, extensions, routing, hunt groups, and voicemail. It decides where a call goes. It does not care what your pipeline looks like.
  • A CRM owns records, fields, ownership, and reporting. It is the system of record for the relationship and knows nothing about a call until something tells it.
  • A contact center platform adds queueing, agent state, service levels, and supervisor tooling. Heavier, more inbound-shaped, priced accordingly.
  • CTI software is the connective layer. It converts a call event into a CRM object and a CRM object into a dial instruction.

Why does the distinction matter on a Tuesday? Because it tells you who to call when something breaks.

Audio is bad, so that is the carrier or the network, not the integration. Calls go to the wrong rep, so that is routing, and routing lives in the phone system. The call happened and the record is empty, so that is CTI, and no amount of better audio or smarter routing will put a row on that timeline. Teams lose days to this. The integration vendor and the phone vendor each point calmly at the other, both of them are describing their own box accurately, and the activity log stays blank the entire time.

One practical consequence. When a single vendor owns the telephony and the integration, there is nobody to point at. That is worth something, and it is a fair thing to weigh against buying best-of-breed in each box.

What CTI software changes on an outbound floor

Everything above is architecture. Here is what it does to the day.

Start with the rep. Without the integration, a single dial is a sequence of steps that nobody designed on purpose: find the record, read the number off the screen, switch windows, type the number into a phone app, call, talk, switch back, find the record again because the tab moved, type a note from memory, and set a follow-up task. Ten steps, and three of them are a human retyping something the computer already knew.

Cut the retyping and you do not just save seconds on a stopwatch. You remove the pause between calls, which is the moment where a rep quietly decides whether to make the next one or to go tidy up a note instead. That pause is real, it is expensive, and it gets noticeably longer right after a call that went badly.

Kixie’s PowerDialer sits on the dial side of that loop, using multi-line dialing and AI Human Voice Detection so reps spend less time dialing manually and more time in live conversations. ConnectionBoost combines local presence, number monitoring, and progressive caller ID to help teams manage outbound number reputation and pickup rates. Those are dial-side levers. They move connect rate.

The write side moves something else: what a manager can see on Friday.

A deal marked closed lost tells you nothing by itself. How many attempts preceded it? Over how many days? Were they calls, or were two of them texts sent four minutes apart on the same afternoon? Did anyone leave a voicemail, and did the next attempt come that same day or nine days later once the buyer had already moved on? Every one of those questions is answerable only if the activity landed on the record automatically, with a timestamp and a structured outcome that nobody typed by hand and nobody could forget to type.

That is the actual return on CTI software, and it is a management return as much as a rep return. The rep gets their minutes back. The manager gets something to coach.

One caution worth stating plainly, because the opposite gets sold hard. More dials are not automatically more pipeline. If the list is stale or the targeting is wrong, a faster dialer just reaches the wrong people sooner. Dial volume is an input, not an outcome.

How to test CTI software before you buy it

Pilots fail because they test the happy path. The happy path always works. Build the pilot out of the ugly cases instead, and run every one of them against your own data rather than the vendor’s sandbox.

Run these eight scenarios.

  • The voicemail. Outbound call from a record, no answer, rep hangs up and immediately dials the next lead. Check the first record for an activity with a duration and an outcome.
  • The unknown inbound. A call from a number that is in no record at all. Does the rep get a usable screen, and can they create and attach a record without leaving the call?
  • The duplicate. Deliberately create two records with the same number, then call in. Watch what the screen pop chooses and whether the activity lands on both, one, or neither.
  • The reformatted number. Store the same number four ways, with a country code, without, with punctuation, with an extension. Call each one. Count the matches.
  • The transfer. Rep A answers, transfers to rep B, rep B talks for six minutes. Now ask the record who talked to the customer and for how long.
  • The outcome field. Set a disposition after the call ends. Confirm it wrote to a reportable field and not into the body of a note, because a note is not a report.
  • The offline rep. Close the browser tab mid-call. Reopen it. Did the activity survive, or did the write die with the tab?
  • The report. After two weeks, pull a manager-level activity report. Compare its totals against the phone system’s own call log. If those two numbers disagree, you have found your real integration defect.

The report comparison is the single best check on that list, and almost nobody runs it. The phone system knows how many calls happened. The CRM knows how many it heard about. The gap between those two numbers is exactly the amount of CTI software you are not getting.

A few contract questions belong in the same conversation. Who installs it, and which side is responsible when the CRM ships a platform update? What is the named support path when dialing stops, and what is the response commitment in writing? Which edition of the CRM does the integration require, because integration tiers and CRM tiers rarely line up. And what happens to historical call records, recordings and transcripts if you leave?

On that last point, recordings carry their own retention and consent obligations, and the integration is what decides where they are stored and for how long. Treat recording and transcribing calls into a CRM as a separate design decision rather than a checkbox on the CTI order form.

What CTI software will not fix

Be honest about the boundary, because an oversold integration gets ripped out in a year.

CTI software does not fix a bad list, and a faster path to a bad number is still a bad number. It does not fix a territory map nobody agreed to. It does not fix a comp plan that quietly pushes reps toward the easiest accounts in the book, and it does not fix a discovery process where reps open with a pitch before they have found a problem worth solving. It will not make a weak script land.

What it does is remove the excuse that the data is not there. Once every call, outcome and next step is written automatically, the conversation about performance stops being a debate about whether the activity happened and starts being a conversation about what happened on the call.

That is a smaller claim than most vendors make. It is also the one that holds up.

CTI software questions buyers ask

What does CTI software actually do

It connects a phone system to a business application so a call and a record act on each other. Outbound, it turns a record into a dial instruction. Inbound and after the call, it turns a call event into an activity on the right record, with direction, duration, outcome and a link to the recording where one exists.

Is CTI software the same thing as VoIP

No. VoIP is how the audio gets from one end to the other. CTI is how the call gets into your CRM. You can run excellent VoIP and have an activity timeline with nothing in it, which is a common and frustrating place to be.

Does CTI software work with any CRM

Not automatically. Depth of integration varies by CRM, and often by edition within the same CRM. Confirm the exact edition, the custom objects you call from, and whether the integration can write to the custom fields your reporting depends on. A generic answer of “yes, we integrate” is not an answer.

Why does the screen pop open the wrong record

Usually duplicates, sometimes number formatting. If two records hold the same number, the integration has to pick one, and its rule may not be your rule. Deduplicate the records, normalize the number field, then retest before changing vendors.

What should a CTI software pilot measure

Write-back completeness first. Take the phone system’s call count for the pilot period and the CRM’s logged activity count for the same period, and compare them. After that, measure screen pop match rate, how many outcomes landed as structured fields rather than free text, and how much manual cleanup an admin did per week.

Do you still need CTI software if your dialer already lives in the CRM

If the dialing and the logging already happen inside the CRM without a rep retyping anything, you already have CTI. The term describes the capability rather than a separate product you must buy. The useful question is not whether you own a thing called CTI software. It is whether both directions work.

Sources

Sources verified and content reviewed by the Kixie Research Team on November 11, 2026.

Ready to close more deals with Kixie?

See how Kixie's AI-powered tools can transform your sales and support operations.

Start Free Trial