Skip to content
WirebirdTalk to sales

How to add SMS and calling to your SaaS product

Your customers already text and call their clients. The question is whether that happens inside your product or somewhere you can't see it. There are three ways to bring it in, and they differ far more in ongoing work than in the first demo. This guide walks through what each path actually involves, how long it tends to take, and a checklist for choosing.

Updated

Why platforms add communications at all

A business running on your software already keeps its clients, appointments and invoices there. Then it texts those clients from a personal phone, or from a separate texting app that knows nothing about the schedule. Every reminder, confirmation and missed call happens outside the system of record.

Bringing texting and calling into the product fixes that. Messages attach to the client record, reminders fire from the real schedule, and the business stops paying a second vendor for something your product could do. For you, it is a stickier product and, done well, a new revenue line.

The demo is easy on every path. A text sent from a test number takes an afternoon. The real differences show up in registration, multi-tenant plumbing, interface work and support load once hundreds of businesses are live.

The three paths

  • Build on a carrier or CPaaS API. You buy numbers and send traffic through a provider's raw API, and you build everything else: registration flows, tenant isolation, the inbox, the phone, opt-out handling and billing.
  • Embed a communications platform built for software companies. You call a tenant-aware API and drop in prebuilt screens styled like your product. The provider handles registration and carrier rules per business.
  • Hand customers a third-party app. You partner with or recommend a standalone texting or phone product, perhaps with a light integration. Your customers sign up and pay separately.

Path one: building on a carrier API

This gives you the most control and the most work. Sending a message is one API call. Running texting for many separate businesses is a product of its own.

Registration comes first. In the US, each business that texts from a local number needs its own brand and campaign registered with The Campaign Registry, filed with that business's legal details. As a platform you are registering on behalf of customers, which providers handle through an ISV flow with a separate profile per customer. You build the form that collects legal name, EIN and address, the status tracking, the resubmission flow when a campaign is rejected, and the messaging to your customer while they wait. Campaign vetting is manual and commonly takes days.

Tenant isolation is next. Each business needs its own numbers, registrations, opt-out list and usage, usually through subaccounts or per-customer profiles at the provider. You map those to your own tenant model and clean them up when a customer leaves.

Then the interface: an inbox with threads, assignment and unread state, a composer that respects opt-outs and quiet hours, a contact timeline, and number selection. Voice adds a softphone, call routing, hold and transfer, voicemail, recording with consent announcements and call signing so calls aren't flagged as spam.

None of this is exotic. It is simply a lot, and it never stops needing changes, because carrier rules and customer expectations keep moving.

Path two: embedding a platform

An embedded platform takes the same raw capability and packages the parts every software company ends up rebuilding. You create a tenant when a business signs up, and everything after that is scoped to it.

Registration becomes a form inside your product that the provider files, tracks and corrects. The inbox, softphone and settings screens arrive as components you theme with your own design tokens. Usage is reported per tenant so you can bill for it.

The trade-off is dependency. You rely on the provider's roadmap for screens you didn't build, and you pay a margin over raw carrier rates. Check that you can drop to headless APIs for any screen you'd rather own, and that nothing in the customer experience shows the provider's name.

Path three: a third-party app

Recommending a separate app is the fastest way to say yes to a customer request. It costs you almost no engineering time.

It also gives away most of the value. The app can't see your schedule or client records without an integration, which usually means a sync that drifts. Your customer pays someone else, and when texting is central to their day, the other app starts to look like the product they actually work in. This path makes sense as a stopgap, or when communications are genuinely peripheral to your customers' work.

Realistic timelines and ongoing load

Teams consistently underestimate the build path because the first message goes out on day one. A fair way to plan is to list every item below and estimate each one honestly, including the support process around it.

  • Registration intake, filing, status tracking and resubmission for every business.
  • Number search, purchase, porting and hosted SMS for businesses keeping their existing number.
  • Tenant isolation, credentials and offboarding.
  • Inbox, composer, contact timeline and notifications, on web and possibly mobile.
  • Opt-out and consent handling enforced on every send, from every feature.
  • Voice routing, softphone, voicemail, recording consent, and call signing per business.
  • Usage metering per tenant and the billing that goes with it.
  • A support playbook for undelivered texts, rejected campaigns and calls labeled as spam.

The support load nobody plans for

Once customers are live, communications generate a distinct kind of ticket. A campaign is rejected and the owner doesn't understand why. A text didn't arrive. Calls ring once and drop. A number port stalls because the account details don't match the losing carrier's records.

Each of these needs someone who understands carrier rules. If you build, that expertise has to live on your team. If you embed, check how much of it the provider takes on, and whether rejected registrations are fixed and resubmitted for you or simply reported back.

A decision checklist

Answer these before committing to a path:

  1. Are communications central to how your customers run their day, or an occasional convenience?
  2. Do you have engineers who can own carrier registration and its edge cases for years, not months?
  3. Do you need voice, or is texting enough for the first release?
  4. How many businesses will you turn on in the first year, and can your support team handle registration questions at that volume?
  5. Do you want to charge for communications, and do you need per-customer usage to do it?
  6. Will an AI receptionist or text agent be on your roadmap, and will it need to act inside your product?
  7. What would your team build instead with the same quarters of engineering time?

How Wirebird handles this

Wirebird is the embedded path. Each business on your platform is an isolated tenant with its own numbers, registrations and opt-out list. Registration runs through a white-label form in your product; Wirebird files the brand and campaign, fixes rejections and sends a webhook when the business can text.

The inbox, softphone, AI settings and setup screens ship as React components or a script-tag embed, themed with your tokens and showing no Wirebird branding. Headless APIs are there for any screen you'd rather build, and usage is metered per tenant so you can bundle or bill it.

Sources

Rather not run this yourself?

Wirebird files, tracks and fixes registrations for every business on your platform.