When healthcare marketing needs to move fast
Sending 100 SMS messages is an API call. Sending 400,000 in under 10 minutes is an architecture problem.
A healthcare marketing company came to us with a specific challenge: they needed to send massive SMS campaigns for major US healthcare clients. Not batch emails that arrive eventually. Time-sensitive health communications that need to land in minutes — with multi-provider delivery, phone number rotation, and carrier compliance built-in.
Their initial system could handle 90K messages in about 5 minutes. They needed to scale to 400K without adding complexity or breaking the bank. See the full mass messaging case study for the complete technical solution.
The architecture we built
The system has three layers. Simple, scalable, and cheap to run.
Ingestion layer
Every message enters through a REST API and immediately lands in an SQS queue. The moment it's in SQS, it's durable — even if every downstream worker crashes, the message survives.
We chose SQS over more complex systems because it's managed, infinitely scalable, and costs almost nothing. No servers to maintain. No scaling to plan. Amazon handles it.
Processing layer
Golang workers consume from SQS queues and handle:
- Deduplication — DynamoDB tracks message IDs. Same message won't send twice, even during retries
- Rate limiting — Carrier limits enforced per phone number. We rotate through multiple numbers to stay under limits
- Multi-provider routing — Primary carrier down? Secondary takes over automatically
- Load balancing — Phone numbers distributed across providers to maximize throughput
DynamoDB handles all state tracking. Fast, scalable, and dirt cheap for this workload.
Delivery layer
Multi-provider SMS delivery with intelligent load balancing. We don't just failover when a provider is down — we actively distribute load across providers to maximize speed and stay under carrier rate limits.
The entire infrastructure runs for ~$800/month (excluding SMS costs). The platform it powered? $4MM+ in annual recurring revenue.
The scaling story
Phase 1: 90K in 5 minutes
The initial system worked. SQS queue, Golang workers, multi-provider SMS delivery. Clean, simple, fast. 90K messages in about 5 minutes was solid performance.
Phase 2: Hitting carrier limits
As volume increased, we hit a new constraint: carrier rate limits per phone number. Each number could only send X messages per minute before carriers started throttling or blocking.
The solution wasn't more infrastructure — it was smarter routing. We implemented phone number rotation and load balancing across multiple providers.
Phase 3: 400K in under 10 minutes
With multi-provider load balancing and intelligent phone number rotation, we scaled to 400K messages in under 10 minutes. No architectural rewrites. No complex distributed systems. Just better utilization of the tools we already had.
What makes this system work
The architecture isn't fancy. That's the point. Here's why it works:
SQS for durability. Every message lands in SQS before anything else happens. SQS is managed, infinitely scalable, and guarantees at-least-once delivery. We don't lose messages.
Golang for performance. Fast startup, low memory footprint, excellent concurrency primitives. We can spin up dozens of workers in seconds and they consume minimal resources.
DynamoDB for state. Deduplication, message tracking, phone number rotation state — all in DynamoDB. Scalable, fast, and cheap for this access pattern.
Multi-provider for reliability. No single point of failure. Primary carrier down? Secondary takes over. Hitting rate limits on one provider? Load balances to the next.
This system powered a platform that generated $4MM+ in annual recurring revenue. The entire infrastructure ran for ~$800/month (excluding SMS costs). That's the power of choosing simple, managed services over building everything yourself.
The healthcare platform success story
In mid-2021, we built a COVID-19 testing platform that evolved from providing free tests via SMS into a comprehensive healthcare marketing tool. From July 2021 through 2023, it became a critical piece of healthcare infrastructure.
The numbers:
- 10M+ messages sent
- 150K+ patients reached
- Conversion rate increased from 2.2% to 3.7%
- Up to 4 tests per patient per month
The same simple infrastructure — Golang, AWS SQS, DynamoDB — powered this entire operation. When you need to reach people fast during a public health crisis, you don't have time for overcomplicated systems. You need infrastructure that just works.
Lessons learned
Simple beats complex. We could have built this with Kafka, Redis, complex microservices, and Kubernetes. Instead we chose AWS SQS, DynamoDB, and Golang. Infrastructure costs stayed at ~$800/month. The platform generated $4MM+ ARR during its operational period (July 2021-2023).
Managed services are your friend. AWS SQS and DynamoDB mean zero servers to maintain, zero scaling to plan, zero 3 AM pages because something crashed. Amazon handles it. We focus on business logic.
Multi-provider is non-negotiable. A single SMS provider is a single point of failure. We use multiple providers with intelligent load balancing. One goes down? Traffic shifts automatically.
Phone number rotation matters. Carriers rate-limit per phone number. We rotate through dozens of numbers to stay under limits and maximize throughput.
Building SMS infrastructure that handles hundreds of thousands of messages in minutes doesn't require complex distributed systems. It requires choosing the right managed services and using them well. Explore our mass communication solutions or read more case studies of systems we've built. If you need infrastructure that scales without breaking the bank, let's talk.