SMS template management for a SaaS platform means giving each tenant its own message library, with variables, an approval step and version history, while keeping every text inside the use case that tenant registered with carriers. Get it right and your customers send faster and your support queue stays quiet. Get it wrong and one tenant's off-topic text can get a whole campaign filtered.
This guide is for the developers and product owners building that layer. It covers the data model, variables, approval, versioning and the registration rule that most template systems forget. Ready doesn't ship a template API you'd call from your product today, so the design below is what you build on your side, on top of sub-accounts and registration that Ready does provide.
Start with the tenant boundary
Every template belongs to exactly one tenant. That sounds obvious, but the common mistake is a shared "starter library" table that tenants edit in place. One edit then changes everyone's messages.
Split it into two layers:
- Platform templates. Read-only starters you write and maintain. They're the examples a new tenant sees on day one.
- Tenant templates. Copies a tenant owns and edits. Copy on first use, never reference live.
On Ready, each of your customers gets a sub-account with its own numbers and its own carrier registration. Mirror that in your schema: a template row carries the tenant id, and the send path looks up the tenant's sub-account from that id, never from a field the browser supplies. Our multi-tenant SMS architecture guide covers the isolation rules in more depth.
Variables: allow a short list and validate hard
A variable is a placeholder like first name or appointment time that your code fills in at send time. Keep the list short and typed.
- Define the allowed variables per template type. A reminder gets name, date and time. A receipt gets name and amount.
- Reject a template at save time if it uses a variable that isn't on the list. Don't discover it at send time.
- Define a fallback for each variable. A missing first name should become a neutral greeting, not the literal braces.
- Cap the length of each filled value so one long business name can't push a text into a second segment.
That last point costs real money. A segment is 160 characters in GSM-7, and 153 per segment once a message splits into several. An emoji or other non-GSM character drops the limit to 70 (67 multipart). Ready swaps curly quotes, long dashes and ellipses for plain ones before sending, so those don't change the count, but an emoji still does. Ready also adds "Reply STOP to opt out" and the business name to the first text to each contact unless the account turns that off, so budget those characters too. Our post on template variables and segment drift shows how a short template quietly becomes a three-segment one.
A cheap safety net: render each template with a worst-case sample (longest name, longest value, an emoji) and show the tenant the segment count before they save.
The use case rule: templates must match the registered campaign
This is the part that separates SMS from email. When a tenant registers for 10DLC, the registration describes what the campaign sends: a use case, a description and sample messages. Carriers expect real traffic to look like that description. A tenant who registered for appointment reminders and then sends a promotion is outside what they described, and that kind of mismatch is a common reason traffic gets filtered or a campaign gets flagged.
So bind each template to a campaign, not just a tenant:
- Store the tenant's registered use case and sample messages next to their templates.
- Tag every template with a category that maps to a use case (reminder, account notice, marketing).
- At save time, compare the template category to the tenant's registered campaigns. If there's no match, block the save and say why in plain words.
- If the tenant wants a new kind of message, send them to register another campaign first.
Ready's registration is a single charge per customer: $25 a month covers the brand and its first campaign, and each extra campaign is $20 a month. Most approvals take 2 to 7 days. You can drive it from your product through the registration endpoints, documented in the registration API docs. Our use case picking guide helps tenants choose the right one the first time.
An approval flow that people will actually use
Not every template needs a human. Match the gate to the risk:
| Template change | Suggested gate |
|---|---|
| Tenant edits wording inside its registered use case | Automatic checks only |
| Tenant adds a link or a new variable | Automatic checks plus a warning |
| Tenant creates a marketing template when only account notices are registered | Blocked until a campaign is registered |
| Template mentions health details, payments or other sensitive content | Manual review by your team |
The automatic checks can be simple: allowed variables only, a segment-count estimate, no all-caps shouting, and an opt-out line present on marketing text. Keep the review queue for the rows that need judgment, and show the tenant a clear status: draft, in review, approved, rejected with a reason.
One compliance note. Ready isn't HIPAA compliant and doesn't sign BAAs, so a template system on Ready should reject protected health details (diagnoses, medications, test results). A PHI-free reminder such as "Your results are ready, please log in" is fine.
Versioning so you can answer what was sent
Templates change, and a support ticket six weeks later will ask what a customer actually received. Make versions immutable.
- Every save creates a new version row. Never update in place.
- A send stores the template id, the version number and the rendered text. The rendered text matters because variables change.
- "Roll back" creates a new version that copies an old one, so history only moves forward.
- Keep the approver and a timestamp on each version.
Storing the rendered body also helps when you match delivery webhooks to messages later, and it gives you a clean answer for any dispute about wording. Pair it with the metering ideas in our post on metering SMS usage per customer so each tenant's volume lines up with the templates they use.
Opt-out wording and STOP stay out of tenant control
Don't let a tenant template remove the opt-out path. Ready honors inbound STOP and UNSUBSCRIBE and propagates the opt-out so the contact isn't messaged again across campaigns, and it also catches clear phrases such as "do not text me". Your template editor shouldn't offer a way around that, and it shouldn't tell the tenant they can text a number that has opted out. Read about the mechanics in the opt-outs docs.
Frequently asked questions
Should templates be shared across tenants?
Share starters, not live templates. Platform templates should be read-only examples that a tenant copies. A shared editable template means one tenant's change rewrites everyone else's messages.
Do I need approval on every template edit?
No. Use automatic checks for edits inside a tenant's registered use case and keep human review for risky changes. Reviewing everything slows tenants down and trains your team to click approve.
What happens if a tenant sends outside its registered use case?
Carriers may filter the traffic, and the campaign can be flagged. Block the mismatch in your editor instead of relying on the carrier to catch it. This is risk reduction, not a guarantee, and each sender stays responsible for its own compliance.
Where to go next
Build in this order: tenant-owned templates, a short variable list, a use case check, then versions. The approval flow can start as a status field and grow later. If you're comparing providers for this kind of platform, read the Ready docs on sub-accounts, then create an account and walk one tenant through registration before you design the screens around it.