Notes on caching, scale, and engineering economics.
Field-tested opinions on what it takes to build a fast backend without a 20-engineer platform team. Written by the people who built redfly.
What is redfly?
A short overview of what redfly is and the problem it solves.
How to centralize warehouse data from every site without replacing what runs the warehouse
A small service beside each warehouse database sends changes outward to one central copy. The head office gets one view of every site; the warehouse floor keeps the system it already trusts.
September 25, 2026Why reports should never run on the warehouse database
The operational database exists to run the floor. Every report that queries it competes with picking, packing and shipping. A central copy takes that load away and leaves headroom for peak.
September 25, 2026What offline support really means when a warehouse loses its link
Changes queue on site, compressed and encrypted, and resume table by table when the link returns. Delivery is at-least-once and reconciled on arrival. Here is exactly what is and is not promised.
September 25, 2026One report across time zones: getting the clocks to agree
Sites in Eastern, Central and Pacific time each keep their own clock. A central copy, stamped by site and current within minutes, gives head office one consistent day, shift or peak.
September 25, 2026The true cost of a cloud copy of your warehouse data, and the cheaper shape
A cloud relational database sized for every site is the expensive shape. Low-cost document storage, fed only with changes over ordinary internet links, is the cheaper one. Here is why the shapes differ.
September 25, 2026What a design partnership looks like for a logistics company: one site first
Who qualifies, what the first site involves, who drives the rollout, how sites and tables are added, and how the subscription works. A plain account of partnering with redfly.
September 25, 2026Outbound only, encrypted per site: how warehouse data leaves the building safely
The sync service opens outbound connections only, compresses and encrypts each site's changes with that site's own key, and keeps each site in its own central space. What a security reviewer will ask.
September 25, 2026Peak season for warehouses: why headroom matters more than horsepower
On Black Friday the warehouse server has no room to spare. Moving reports off it, with a sync service that holds back when the site is busy, buys the headroom that keeps the floor steady.
September 25, 2026Transparent 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, 2026SQL Server change tracking: why we read changes on a short interval
SQL Server offers two ways to learn which rows changed. redfly uses the lighter one, change tracking, and reads it on a short interval. Here is why, and what it means for freshness.
September 25, 2026PostgreSQL logical replication as a cache feed
PostgreSQL can publish every row change as a stream. redfly subscribes to that stream to keep Redis in step. What publications and replication slots are, and what to watch in operation.
September 25, 2026MongoDB change streams as a sync source
MongoDB change streams deliver inserts, updates and deletes as they happen. redfly uses them to keep Redis, or a central store for remote sync, in step, and to resume cleanly after an interruption.
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, 2026Ten billion rows over the public internet: what we learned
We have kept more than ten billion rows in step across ordinary public internet links, not dedicated lines. Here is what held up, what did not, and what surprised us.
September 25, 2026IoT and fleet telemetry: high writes, flaky links, millisecond reads
Devices and vehicles write constantly over links that come and go, while the operations screen needs the latest state in milliseconds. How we split the two jobs.
September 25, 2026Drift, backfill and recovery: the unglamorous parts of sync
Copies of data quietly disagree, restarts lose their place, and schemas change under you. What drift is, how it happens, and how an honest sync service detects and repairs it.
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, 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 it is a subscription rather than a project
A plain account of the design-partner relationship at redfly: what is included, why the term is twelve months at minimum, 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, 2025Want this in your inbox?
Send us a note and we will add you to a low-volume list of long-form pieces; no marketing automation.
redfly API + Sync Service · Licensed directly from redfly