The serverless dream is close. We have serverless functions such as AWS Lambda and Google Cloud Functions. We have serverless storage in Amazon S3 and Google Cloud Storage, along with serverless databases such as Amazon DynamoDB, Google Firestore, and MongoDB Atlas.
Then it’s time to accelerate the application with a cache. Cold starts, hot keys, capacity provisioning, and operational caveats dampen that momentum. The dream of a fully serverless stack falls apart at the caching layer.
It doesn’t have to. A new caching solution meets the same serverless standard as the rest of the stack.
A truly serverless cache should remove operational work
Capacity planning should not be your problem
Managed services for Redis and Memcached are the most popular caching solutions today. Yet they fail a fundamental serverless litmus test: customers must handle capacity planning, configuration, management, maintenance, fault tolerance, and scaling.
Customers often run overprovisioned cache clusters because scaling them up and down is labor-intensive and risky. Software updates and security patches also require planning to protect cache hit and miss rates. Services such as Amazon ElastiCache impose maintenance windows, forcing customers to plan for downtime or complicate their infrastructure with multiple clusters on different maintenance schedules.
A truly serverless cache supports high scale, maintains a high cache hit rate, and delivers high availability without work from the customer. It requires zero configuration and has zero planned downtime. It should just work, so customers can focus on application logic rather than spend cycles maintaining and tuning cache infrastructure.
Hot keys should not be your problem
A hot key receives more traffic than other keys. In Redis and Memcached clusters, the key determines where its data is stored. All requests for a hot key therefore reach one node and create a bottleneck, affecting cache hit rates and the application experience.
Customers can try to work around this by scaling vertically. That may not be possible if they already use the largest node. They can also refactor the data model, which may take weeks.
A truly serverless cache detects hot keys and spreads them across additional nodes or shards behind the scenes. Customers no longer need to write extra monitoring software or endure weeks of outages after discovering hot keys.
Traffic bursts should not be your problem
Caching clusters must be prescaled before a traffic burst arrives. Scaling typically affects cache hit rates because new nodes start cold. Prewarming those nodes adds work and complexity that customers do not have time to take on.
A truly serverless cache handles bursts without overprovisioning. It scales instantly under load without affecting cache hit rates.
Cloud portability should not be your problem
Many serverless technologies are specific to one cloud provider. AWS Fargate, for example, works in AWS but not in GCP, Azure, or other clouds.
A truly serverless service works across multiple cloud providers without requiring customers to change their application when they switch providers.
Continuous testing should not be your problem
Continuously testing an application integration with a serverless service is difficult without a testing environment in the pipeline. Setting up that environment creates extra work for application developers, including endpoint settings and SDK tuning. Even after that effort, environmental differences often cause unforeseen issues.
A truly serverless cache lets developers unit test their application code without setting up a special environment.
Momento fills the gap in the serverless stack
Momento Cache fills the gap in a fully serverless stack. It is built from the ground up to be serverless. Momento Cache requires zero configuration, supports high scale, maintains a high cache hit rate, and delivers high availability without the leaky abstractions of alternative solutions. It:
- Automatically detects hot keys and adds partitions to mitigate their impact.
- Warms cache nodes during scale-out, scale-in, and deployments to minimize the impact on cache hit rates.
- Has no maintenance windows. Planned downtime is so 2000.
- Supports AWS and GCP.
Engineers have spent too long dealing with half-baked serverless caching solutions. If you are ready for a fully serverless cache, explore Momento Cache (Serverless).
