Although we had to implement a self-healing cache mechanism directly within our application, switching to Memcached saves us $5,000 per month.
In cloud architecture, we often prioritize performance, scale, and security, but they can come with surprising costs. In one of our Azure-based deployments, our team discovered that a seemingly simple caching solution—designed only to support basic key-value storage—was costing us more than $5,000 per month.
At the heart of this cost was our use of Azure Cache for Redis (Premium), which we had adopted to meet Virtual Network (VNet) isolation requirements across a multi-region, multi-environment setup (production, development, staging, etc.). Each region and environment required its own Redis instance to comply with security and infrastructure separation standards. Although our caching needs were minimal—less than 200 MB of data that refreshed only once per hour—we had no choice but to use Redis Premium for VNet support.
Why Redis Premium wasn’t the right fit
Originally, we used Azure Redis Standard, which was cost-effective and suitable for our use case. However, we soon faced a compliance requirement: All services needed to be isolated via VNet integration. Redis Standard, unfortunately, does not support VNets. The only option was to move to the Premium tier, which starts at a significantly higher price point.
Moreover, our architecture required separate Redis instances per region and per environment, multiplying our Redis footprint. Though we were only using Redis for basic key-value caching with infrequent refresh intervals, we ended up paying a massive premium for features we didn’t use, such as clustering, persistence, and pub/sub.
The challenge with Azure App Service and cache reloading
We evaluated alternatives like Memcached, which is fast, lightweight, and ideal for simple caching use cases. However, we quickly ran into a technical challenge: Azure App Service runs multiple isolated instances behind a load balancer and does not allow instance-specific external requests. We also explored Azure App Service APIs, hoping to trigger per-instance cache reloads externally, but found that such functionality was not supported.
This was problematic because Memcached is in-memory only and its data is lost whenever an instance restarts or scales. Without a reliable way to repopulate each instance’s cache, switching to Memcached could have introduced cold start delays and inconsistent behavior.
The solution: Timer-based self-healing cache reload
To overcome this, we implemented a self-healing cache mechanism directly within our .NET application:
- On startup, each App Service instance spins up a background timer.
- Every 60 minutes, the timer checks whether the cache is empty or stale.
- If the cache is uninitialized, the instance rebuilds it independently using application logic.
- This mechanism runs silently and autonomously across all instances and regions, ensuring high availability and consistency.
We also included a mutex-based locking mechanism to avoid redundant reloads and integrated New Relic logging to track cache health across environments.
The result: 95% to 100% cost reduction
By transitioning to Memcached running in-process within our existing App Service plans, without any additional infrastructure, we eliminated the need for Redis Premium entirely.
Considering our multi-region, multi-environment deployment model, the Redis Premium bill had grown to over $5,000 per month. After the switch, our caching cost was effectively reduced to zero, as Memcached incurred no additional fees. Our application maintained consistent performance while giving us greater control over caching behavior and startup logic.
When this pattern works, and when it doesn’t
This solution is ideal if:
- Your caching needs are simple and ephemeral.
- You’re using Azure App Service and you want to avoid Redis costs.
- You require VNet isolation, but Redis Premium is overkill.
However, this solution may not be suitable if:
- You need cross-instance shared caching.
- You require persistence, clustering, or advanced data types.
- Your cache plays a mission-critical role in system state.
Optimize for what you actually use
Our experience replacing Redis Premium with Memcached highlights a critical architectural truth: Complexity isn’t always necessary. Sometimes, the tools we default to—because they’re robust and feature-rich—introduce cost and operational overhead that simply isn’t needed.
By leveraging a lightweight, self-healing caching layer inside our application, we achieved significant cost savings, simplified our infrastructure, and retained performance—all without compromising on security or scalability. In the cloud, optimization isn’t just about scaling up. Sometimes, it’s about scaling smart.
Sachin Suryawanshi is a software architect with the Harbinger Group.
—
New Tech Forum provides a venue for technology leaders—including vendors and other outside contributors—to explore and discuss emerging enterprise technology in unprecedented depth and breadth. The selection is subjective, based on our pick of the technologies we believe to be important and of greatest interest to InfoWorld readers. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Send all inquiries to doug_dineley@foundryco.com.
This article is published as part of the Foundry Expert Contributor Network.
Want to join?
