ProjectsIntegration
Call center intake routing that outgrew initial Lambda concurrency
Integration
A straightforward call-center intake routing integration looked like a clean serverless fit—until test throughputs hit Lambda’s initial concurrency ceiling and forced a different deployment strategy.
- Call center intake
- Event routing
- Serverless
- Throughput testing
01 · Story
The engagement
Call center intake events need to land in the right place quickly and reliably. On paper this was a direct integration: receive the event, apply routing rules, hand off to the next system. Serverless was the natural first cut—fast to ship, pay for use, no fleet to babysit.
Load testing told a different story. At the throughputs the client needed to prove, we ran into Lambda’s initial concurrency limits hard enough that the “simple” path stopped being simple. Spikes, queuing behavior, and cold capacity made it clear the first deployment shape would not hold under real intake volume without a rethink.
We treated that as a design input, not a failure: kept the integration model, changed the deployment strategy so routing could absorb the concurrency the tests demanded—without pretending the first architecture was sacred.
02 · Constraints
Challenges
- 01
Straightforward logic, hard limits
The business rules were not exotic. The constraint was platform capacity: initial concurrency on Lambda capped how many intake events we could process in parallel during realistic test loads.
- 02
Test throughputs that look like production pain
Lab numbers that “should be fine” on a demo account are not the same as call-center intake peaks. Tests had to reflect the rate the floor would actually throw at the system.
- 03
Rethink without a rewrite of the domain
We needed a deployment path that could scale with intake—not a brand-new product. Routing semantics stayed; how and where the work ran had to change.
03 · Delivery
What we did
- Built the intake routing integration in a serverless-first shape to move quickly on the happy path
- Ran throughput tests that stressed concurrency the way call-center intake actually arrives
- Diagnosed failures and queueing against Lambda’s initial concurrency limits rather than blaming application logic alone
- Shifted deployment strategy so the same routing work could meet the required parallel load without living forever under that ceiling
04 · Results
Outcomes
- A clear lesson: simple integrations still need to be proven at intake scale, not only in unit tests
- A revised deployment approach after serverless concurrency became the bottleneck
- Routing behavior preserved while the runtime path adapted to real throughput needs
Stack
Next
Need work like this?
Integrations, infrastructure, and marketing systems are part of how we deliver—not side projects. Tell us what you are trying to connect or scale.