Notes on caching and engineering economics.
Field-tested notes on serving reads from memory, cutting the database line of the cloud bill, and the engineering behind it.
Transparent caching: why your codebase should not know a cache exists
A cache your application code can see is a cache your team must maintain. We explain why reads should come from memory without the codebase ever knowing, and what that changes.
September 25, 2026Joins on Redis: serving multi-field queries from memory
Most teams cache single keys in Redis and send every filtered or joined query back to the database. We explain how those queries can be served from memory too, and what that changes.
September 25, 2026Cache invalidation with no invalidation code
Stale-data bugs live in the invalidation calls scattered through a codebase. We explain how a sync service that watches the database removes the need to write them at all.
September 25, 2026Automatic database fallback: reads that survive a cache outage
A cache that is down should make an application slower, not broken. We explain how reads fall back to the database automatically and why that matters more than hit rate.
September 25, 2026Surviving Black Friday with the database at 99% CPU
What a retailer's database does on its worst day, why product and account pages fail before orders do, and how reads served from memory keep the site up without a bigger database.
September 25, 2026Checkout-path caching: catalog, inventory deltas and customer state
The path to checkout reads three kinds of data with three different freshness needs. Here is how a memory cache kept in step with the database handles each, and where the limits are.
September 25, 2026The database is the biggest line on your cloud bill: a breakdown
Where a read-heavy application's cloud spend actually goes, why the managed database line grows fastest, and what moving reads into memory changes on the bill.
September 25, 2026Vertical scaling is a step-function bill
Managed databases are bought in tiers that roughly double at each step. Most teams pay for that headroom around the clock and use it for a few hours a month.
September 25, 2026The 95/5 rule: what read-heavy really means for spend
Most applications read roughly 95 rows for every 5 they change. A database tier is sized for the reads, which is why moving them into memory changes the bill so much.
September 25, 2026Running in your own cloud account: why there is no hosting markup
redfly runs inside the customer's own cloud account by preference. That means no resold compute, no lost cloud discounts, and data that never leaves your own boundary.
September 25, 2026Scaling a legacy .NET application without a rewrite
A ten-year-old C# application on SQL Server can serve its reads from memory without a rewrite. Put an API in front of the database and move screens over one at a time.
September 25, 2026Multi-tenant freemium: keeping the free tier off the database
Free users generate most of the reads and almost none of the revenue. Serving those reads from memory keeps free-tier traffic off the shared database that paying tenants depend on.
September 25, 2026Microservices without per-service data scaffolding
Every new service normally brings its own data access code, its own cache and its own invalidation bugs. One shared API in front of the data removes that scaffolding for small teams.
September 25, 2026Making dashboards feel instant without a bigger database
Dashboards ask the database the same questions every few seconds. Serving those reads from memory kept in step with the database makes the screen fast and takes the load off, with no bigger database.
September 25, 2026Pre-computed results: when to cache aggregates
Totals, counts and summaries are expensive to compute and cheap to store. When an aggregate belongs in memory, when it should be computed on demand, and what changes when the lag is short.
September 25, 2026Millisecond authorization: caching permissions safely
Every request checks permissions, and a database round trip per check is slow. Serving permission rows from memory kept in sync makes the check fast; here are the safety questions and honest answers.
September 25, 2026Why we generate the data access layer
Inside redfly, the code that talks to the database and to Redis is generated from the schema. Here is why we chose that over writing it by hand.
September 25, 2026Testing a sync pipeline that must never lose a row
How we test the redfly Sync Service, whose job is to carry every added, changed and deleted row from a source database to a copy, through crashes and dropped links.
September 25, 2026The warehouse comes first: rate limiting and priority lanes in a sync service
The redfly sync service runs on the same machines that run the warehouse. How it decides when to slow down, what to send first, and why the operational database always wins.
September 25, 2026Database change notifications as a first step before adopting an API
You can subscribe to changes in chosen tables from the redfly Sync Service before moving any code to the redfly API. What that gives you, and the path from there.
September 25, 2026What a design partner gets, and why a subscription follows the contract
A plain account of the design-partner relationship at redfly: what is included, why a contract is followed by a subscription, and what we ask of a partner in return.
September 25, 2026Cloud, managed or onsite: choosing where your data platform runs
redfly runs in your own cloud account, as a service we manage, or on your own servers. Here is who each shape suits and why the choice is not permanent.
September 25, 2026Manual cache management is a 1990s tax you do not have to pay
Every engineering team building a fast app independently re-invents cache invalidation. It has been twenty years. It is time to stop.
October 14, 2025Redis is not slow. Your integration is.
A senior architect at one of our advisory sessions told us "Redis is slow." It was a great moment, because the rest of the call was about why that was not true.
September 22, 2025The 70%-cheaper backend: how Redis-fronted databases change cloud economics
The cloud database is the most expensive part of most B2B SaaS stacks. It does not have to be.
September 8, 2025Cache more, optimize less: a primer on read-heavy data access patterns
You can spend a year tuning queries, or you can cache the right things and move on with your life.
August 19, 2025Why code generation beats hand-written DAL for any team under 20 engineers
Hand-written data access code feels like control. It is actually a tax.
July 30, 2025Designing for the freemium user model without crashing your database
The freemium business model is great for growth and terrible for backends. Here is how to keep both.
July 11, 2025Sub-200ms is not a stretch goal; it is a default
Most product teams treat 200ms page loads as ambitious. They should be the floor.
June 25, 2025Backend-as-a-service for the post-PMF SMB
The most under-served buyer in B2B infrastructure today is the small company with real customers and no time to build platform.
May 30, 2025Talk to us about one deployment.
Tell us about one site, its database and its link. We will confirm fit and what a first site involves.
redfly API + Sync Service · Licensed directly from redfly