Unified Messaging Intelligence: Intent-Based Delivery

Most messaging platforms expose separate APIs for SMS, WhatsApp, and other channels. That means developers end up writing routing code, handling edge cases, and debugging delivery problems across multiple providers. Sent takes a different approach: instead of giving you channel-specific APIs, we give you a single interface that understands your intent (what you want to send, to whom, and why) and figures out the best way to deliver it.

The Intelligent Architecture

When you integrate directly with channel APIs, you run into the same problems every time:

• Integration Sprawl: Each channel has different auth, payload formats, error codes, and quirks.
• Business Logic Scattered Everywhere: Your app logic gets littered with “if WhatsApp, do this; if SMS, do that,” making the code harder to maintain.
• You Own the Routing Logic: You’re responsible for retries, fallbacks, and figuring out what channels are available for a given phone number as well as which channel is fastest, cheapest, and most reliable.

Sent flips that around: you implement messaging into your app once, and the platform handles channel selection, routing, retries, and compliance.

Imperative Messaging

You’re responsible for retries, fallbacks, and figuring out what channels are available for a given phone number as well as which channel is fastest, cheapest, and most reliable.

Declarative Messaging

You implement messaging into your app once, and the platform handles channel selection, routing, retries, and compliance, all handled transparently by Sent.

Imperative vs. Declarative Messaging

As a developer, you can choose to implement messaging into your app in a declarative or imperative way. Here is the stark contrast in code quality and maintainability:

Imperative Messaging:

if (user.hasWhatsApp && templateApproved) {
  await whatsappAPI.send(whatsappTemplate, user.whatsappId);
} else if (user.hasSMS) {
  await smsAPI.send(smsMessage, user.phoneNumber);
}

✅ Declarative Messaging with Sent:

await sent.sendMessage({
  phoneNumber: "+1234567890",
  templateId: "order_confirmation",
  templateVariables: {
    orderId: "12345",
    total: "$99.99"
  }
});

Messaging complexity shouldn’t live in your codebase. Sent centralizes it as infrastructure:

• Absorbed Complexity: Multi-channel routing, compliance, and optimization handled once, not by every app.
• Centralized Expertise: Industry rules, carrier quirks, and provider management baked in.
• Faster Innovation: New features and integrations roll out at the platform level.

The Decision Engine

Real-Time Routing

Every message that you send through Sent runs through a decision engine, which in less than 100ms, checks:

• Channel availability
  • WhatsApp registration, SMS support, regional rules, carrier status
• Cost and performance
  • Real-time pricing, success rates, contract terms, engagement metrics
• Context
  • Message type, urgency, recipient behavior, time of day, geography, content type

Fallbacks That Actually Work

When something fails, Sent automatically applies context-aware fallback logic:

Failure Handling Strategy:

• Temporary failures (network timeouts, rate limits) → Retry same channel with exponential backoff
• Channel unavailable (WhatsApp not registered, carrier issues) → Switch to fallback channel
• Permanent failures (invalid number, blocked contact) → Stop and report error

Multi-Provider Orchestration

Sent plugs into multiple carriers and APIs, normalizing the differences:

• Provider Abstraction: One interface to Telnyx, WhatsApp Business API, and others.
• Health Monitoring: Real-time checks on provider reliability and limits.
• Load Balancing: Spreads traffic across providers for cost, capacity, and performance.

Regulatory Compliance

Built-In Regulatory Compliance Logic:

• Global Rules: Keeps track of country-specific restrictions so you don’t have to.
• Consent Enforcement: Opt-ins/outs applied consistently across all channels.
• Content Validation: Automatic checks against carrier and platform rules.

Template Approvals (WhatsApp, etc.):

• Submission Automation: Templates formatted and sent through Meta's approval flows automatically.
• Status Tracking: Approval state synced back into your system.
• Retry Logic: Failed approvals reworked and resubmitted.

Always Learning

The routing engine learns from real delivery data:

• Pattern recognition → what works best by region, channel, time
• Anomaly detection → auto-adapts to outages and disruptions
• Continuous optimization → balances cost, reliability, and engagement

Network Effects

Because all apps share the same intelligence layer, everyone benefits:

• Shared learnings → improve delivery everywhere
• Regional insights → drive smarter defaults
• Carrier relationships → are leveraged at platform scale

Template-Driven Intelligence

Templates as Config, Not Hardcoded Messages

Templates let you describe intent (“confirm order,” “welcome user”) without worrying about formatting differences between SMS and WhatsApp. Sent adapts them automatically:

• Built-in compliance (WhatsApp approval, SMS opt-in, regional rules)
• Progressive enhancement (rich formats where supported, fall back to plain text otherwise)

Variables for Dynamic Content

• Type-safe: Variables know their types and adapt across channels
• Context-preserving: Business meaning stays intact while formatting adjusts
• Fallback values: Missing/invalid variables degrade gracefully

Built for Change

Messaging isn’t static. New channels, new compliance rules, new algorithms. Sent’s architecture is designed to absorb this without you rewriting your code:

• Plug-in new channels without changing your app
• Routing algorithms auto-upgrade behind the scenes
• Compliance handled at the platform level, so you stay safe without extra work

Sent’s unified messaging intelligence takes the pain out of multi-channel messaging by abstracting away provider APIs and routing logic. You express intent, we handle delivery. As the messaging ecosystem shifts, Sent evolves with it—so your app doesn’t need constant rewrites.

Think of it like what Stripe did for payments or Kubernetes did for infra: one consistent interface that hides complexity, optimizes under the hood, and gets better the more it’s used.