Case Study: Technology / eSignature
Speed at Scale:
DocuSign API Performance
with DynamoDB, DAX & SQS
Overview
How TGH Transformed DocuSign's API Performance from Seconds to Milliseconds
DocuSign is the world's leading provider of electronic agreement solutions, enabling secure, efficient, and legally binding transactions for millions of users and enterprises globally. As the platform scaled, a critical performance bottleneck emerged: data retrieval operations from backend systems (Oracle and Zuora) were taking 4-5 seconds per request through the existing MuleSoft integration layer, delivering a poor user experience at high traffic volumes.
TGH redesigned the integration architecture, implementing a persistent caching layer using DynamoDB and DynamoDB DAX, combined with asynchronous processing via Amazon SQS, transforming API response times from seconds to milliseconds while maintaining data consistency and protecting backend systems from peak load.
TGH's caching and async architecture was exactly what we needed. DynamoDB DAX cut our read latency to microseconds for cached data, and the SQS-based async processing eliminated the bottleneck of sequential backend calls. Our users now experience instant responses even during peak load.
Problem Statement
A 4-5 Second API Latency Degrading User Experience at Scale
🐌
DocuSign's existing integration layer was taking 4-5 seconds to fetch data from Oracle and Zuora backend systems on every API request. At enterprise scale with high concurrent GET traffic, this latency was directly degrading the user experience, every interaction felt slow, and backend systems were under unnecessary repeated load from identical requests.
Unacceptable API response times from backend systems, The existing MuleSoft integration layer made synchronous calls to Oracle and Zuora on every request, with each round-trip adding 4-5 seconds of latency. There was no caching layer to serve repeat requests without hitting the backend, meaning every GET request, regardless of whether the data had just been fetched, triggered a full backend call.
Need for a high-performance, data-consistent solution at scale, DocuSign required a solution that didn't just cache aggressively but did so while maintaining data consistency, ensuring users always received accurate, up-to-date information even when data was being served from cache. The solution also needed to handle high-volume GET operations without degrading under increased load.
Backend system overload under peak concurrent traffic, Without caching, every spike in user traffic translated directly into a spike in backend queries to Oracle and Zuora. This created a cascading load problem, high user demand causing backend slowdown, which further increased response times, worsening the very latency problem users were experiencing.
Our Solution
A Three-Layer Performance Architecture: Cache, Async & RAML-Governed APIs
TGH rebuilt DocuSign's data retrieval architecture on three complementary pillars: a DynamoDB persistent cache serving high-frequency GET requests without touching backend systems; DynamoDB DAX (DynamoDB Accelerator) as an in-memory cache layer for microsecond read latency; and Amazon SQS for asynchronous processing of cache refresh and data sync operations, ensuring consistency without blocking API responses.
👤
API Request
User/agent GET request hits MuleSoft endpoint
Incoming
⚡
DAX Cache
In-memory DynamoDB DAX checked first, microsecond hit
Cache Hit
🔀
SQS Async
Cache miss triggers async SQS message for background refresh
Async
🗄️
Oracle / Zuora
Backend called only on cache miss, response stored in DynamoDB
Backend
Integrated with Oracle and Zuora backend systems to enable efficient data access, MuleSoft System APIs were built for both platforms, with all calls routed through the caching layer to minimise direct backend hits
Implemented a persistent caching solution using DynamoDB to significantly reduce API response times, frequently accessed data is stored in DynamoDB and served directly to the API layer, bypassing Oracle and Zuora entirely for repeat requests
Utilised DynamoDB DAX for in-memory cache retrieval and improved read performance, DAX sits in front of DynamoDB and delivers microsecond read latency for the hottest data, reducing even DynamoDB read times by a further order of magnitude
Implemented asynchronous processing using Amazon SQS to enhance system efficiency and scalability, cache invalidation, refresh triggers, and data sync operations are processed asynchronously via SQS queues, eliminating any synchronous blocking of API response paths
Designed APIs using RAML, incorporating resource types, data types, libraries, and security schemes, ensuring all APIs are contract-first, consistently documented, and reusable across MuleSoft projects
Enforced API security and traffic management policies, including basic authentication and rate limiting, protecting DocuSign's backend systems from abuse while ensuring reliable, fair access for all clients
Implemented comprehensive error-handling mechanisms to provide clear visibility into failures, all errors are captured, categorised, and surfaced with actionable messages, enabling rapid diagnosis and resolution
MuleSoft Anypoint Platform
API Integration Engine
Amazon DynamoDB
Persistent Cache Storage
DynamoDB DAX
In-Memory Accelerator
Amazon SQS
Async Messaging & Queue
Oracle
Backend System of Record
Zuora
Subscription & Billing System
💡
The DAX + SQS combination was the architectural key to DocuSign's performance transformation. DAX delivers in-memory reads in microseconds for hot data, while SQS ensures cache invalidation and refreshes happen asynchronously in the background, keeping data consistent without ever adding latency to the user-facing API response path.
Implementation
A Structured Four-Phase Delivery from Performance Audit to Production
Phase 1
Audit & Cache Design
Phase 2
DynamoDB & DAX Build
Phase 3
SQS Async & RAML APIs
Phase 4
Security & Go-Live
01
Performance Audit & Caching Architecture Design
TGH conducted a deep performance audit of the existing MuleSoft integration layer, profiling every GET operation, identifying the highest-frequency request patterns, and measuring Oracle/Zuora backend response times. The audit confirmed that 4-5 second latency was driven entirely by synchronous backend calls with no caching. The cache-first architecture was designed: DynamoDB as persistent store, DAX as in-memory accelerator, and SQS for asynchronous cache management.
02
DynamoDB Persistent Cache Implementation
DynamoDB tables were designed and deployed for caching DocuSign's high-frequency data payloads, with appropriate TTL (time-to-live) settings per data type to balance freshness and performance. MuleSoft processes were updated to check the DynamoDB cache before any backend call, serving cache hits directly and only proceeding to Oracle/Zuora on confirmed cache misses, eliminating unnecessary backend traffic for repeat requests.
03
DynamoDB DAX Configuration: Microsecond Read Latency
DynamoDB Accelerator (DAX) was configured as an in-memory cache layer in front of DynamoDB, reducing read latency from single-digit milliseconds to microseconds for the hottest data patterns. DAX operates transparently through the standard DynamoDB API, requiring no code changes in MuleSoft beyond directing read requests through the DAX endpoint, ensuring the performance improvement was achieved with minimal implementation risk.
04
Amazon SQS Asynchronous Processing Integration
Amazon SQS queues were implemented for all cache management operations, cache invalidation triggers, scheduled refresh events, and data sync confirmations. By moving these operations to asynchronous SQS processing, the API response path was completely decoupled from cache management overhead. Cache refreshes happen in the background without blocking any user-facing API call, ensuring consistent performance even during high cache churn periods.
05
RAML API Design, Security Policies & Production Go-Live
All APIs were designed contract-first using RAML, incorporating resource types, data type libraries, and security schemes for consistent, well-documented interfaces. API security policies were enforced via MuleSoft Anypoint API Manager: basic authentication, rate limiting, and traffic management. Comprehensive error handling was implemented across all integration processes. Production go-live was executed with a phased traffic migration, routing increasing percentages of live traffic through the new cache-first architecture, with full monitoring confirming performance improvements at each stage.
Results & Business Outcomes
Response Times Cut from Seconds to Milliseconds at Enterprise Scale
The DynamoDB/DAX/SQS caching architecture delivered transformational performance improvements, directly solving the user experience problem that triggered the engagement, while simultaneously improving system resilience and reducing backend load for sustainable long-term scale.
⚡
Seconds → ms
API response times reduced from 4-5 seconds to milliseconds, a 50× improvement in user-facing performance
✅
Consistent
Data consistency maintained while efficiently handling high-volume GET operations, cache served with TTL-governed freshness
📈
Scalable
Improved scalability and system resilience through caching and async processing, the platform now handles increased load without degradation
🛡️
Protected
Backend Oracle and Zuora systems shielded from repeat load, frequent requests served directly from cache without touching backend systems
Technology Stack
Platforms & Tools Used in This Engagement
TGH combined MuleSoft's enterprise API management capabilities with AWS's fully managed caching and messaging services, delivering a cloud-native, auto-scaling performance architecture for DocuSign's high-traffic data retrieval operations.
MuleSoft Anypoint Platform
Amazon DynamoDB
DynamoDB DAX (Accelerator)
Amazon SQS
Oracle Backend System
Zuora Billing System
MuleSoft RAML API Design
API Manager Policies
Rate Limiting / Auth Policies
MuleSoft Error Handling Framework
Business Benefits
Four Strategic Benefits Delivered to DocuSign
The caching and async architecture delivered four business outcomes that directly addressed DocuSign's scale, performance, and reliability requirements, giving the platform the technical foundation to serve high customer traffic with enterprise-grade reliability.
🤖
100% Automation
Fully automated data retrieval, the cache-first architecture serves and refreshes data without any manual intervention, completely eliminating the manual steps that previously added to operational overhead
⚡
Quick Data Availability
DynamoDB DAX delivers in-memory responses in microseconds, making DocuSign's data instantly available to the API layer for the vast majority of high-frequency GET requests
📈
Scalable Solution
DynamoDB and SQS are fully managed AWS services that scale horizontally without infrastructure management, the architecture handles any traffic spike DocuSign's growth requires
👥
Serves High Customer Traffic
Cache-first architecture absorbs peak concurrent GET traffic without it reaching Oracle or Zuora, protecting backend systems and ensuring consistent performance for all users regardless of concurrent load
🗄️
Cache-first before backend calls, Checking DynamoDB before every backend request eliminated the root cause of latency without requiring changes to Oracle or Zuora, the fastest fix was adding a layer, not modifying the existing ones
⚡
DAX is a zero-code accelerator, DynamoDB DAX operates transparently through the standard API, delivering microsecond reads with no application code changes, one of the highest return-on-investment architectural additions possible
🔀
Async is the key to consistent UX, Moving cache management to SQS async queues ensured that cache invalidation and refresh operations never added latency to user-facing requests, the response path and the cache management path are completely decoupled
📐
RAML contract-first pays forward, Designing all APIs in RAML before implementation ensured consistent security schemes, reusable type libraries, and clear documentation from day one, reducing future integration effort significantly
Ready to Get Started?
Ready to Transform Your
API Performance?
Partner with TGH to redesign your integration architecture with caching and async patterns, cutting API latency from seconds to milliseconds and building a scalable foundation for high-traffic enterprise operations.
150+ Enterprise Clients
10+ Years Expertise
5 Platforms Certified
24/7 Support