Grid reduced CI/CD costs by 90% with RWX
Grid switched from a fragmented CI/CD stack to RWX, slashing costs by 10x while unlocking faster pipeline times and feedback loops across its consumer finance products.
“RWX is super fast. It executes jobs quickly, caching works incredibly well, and it's all very hands-off. But most importantly, the cost savings have held as our usage has scaled.”
About
Grid is a high-growth fintech founded to democratize access to financial services through low-lift cash advance, credit, and tax-focused solutions. Since its founding in 2022, Grid has grown to over 40k daily users across Apple and Android and ranks among the most cost-efficient cash advance apps on both platforms.
Challenge
Grid's existing CI/CD stack was slow, fragmented, and expensive to maintain
As a fast-moving fintech operating with a lean but mighty team, Grid relies heavily on CI/CD to accelerate development velocity and reduce time-to-market for new releases. But as the company continued to expand its product suite, the limitations of its fragmented CI/CD stack became increasingly apparent.
At the time, Grid's CI/CD stack included Azure DevOps, Google Cloud Build, a fleet of Google Compute Engine instances, and several homegrown shell scripts. Because each system required its own configuration model and operational overhead, even simple pipeline changes were difficult to test, debug, and trust. Azure DevOps, specifically, required manual Docker layer caching, full Git pushes for testing pipeline changes, and cross-system tweaks, leading to time-consuming config management and slow debugging.
This level of fragmentation also carried real costs as parts of the stack were effectively “always on,” with compute running even when it wasn't doing useful work. “From a cost perspective, our setup was incredibly expensive,” shares Mickey Reiss, Head of Engineering at Grid. “We knew as we scaled that we needed to get away from this homegrown hodgepodge and unify our CI/CD workflows.”
After vetting several solutions in his search for a scalable CI/CD stack, Mickey discovered RWX through colleagues within his network. Following a quick demo and some hands-on work with the RWX team, Mickey had all the conviction needed to move forward.
“We had CI/CD spread across several systems, which was inefficient and frustrating to maintain. RWX helped us unify our workflows and reclaim the time we previously lost staring at very slow build logs.”
Solution
An end-to-end CI/CD platform built for high velocity teams
Implementing RWX enabled Grid to unify its CI/CD workflows, accelerate development velocity, and slash overhead costs without committing to a drawn-out cutover.
Within one month, the RWX team had migrated Grid off its prior systems, a process that required minimal internal lift and drove immediate impact. “RWX assisted with all our configs and even visited our office to ship our first integration,” Mickey shares. “We had no operational hiccups along the way, and within a month, we were seeing 10x reductions in costs.”
On top of a seamless onboarding, Mickey attributes this early success to three core benefits of the platform:
Defining pipelines as code
With RWX, Grid shifted CI/CD definitions into a single YAML-based workflow, replacing a mix of UI-driven settings, scripts, and provider-specific build definitions. That shift reduced Grid's configuration area by moving pipeline logic into a single source of truth, making changes easier to review, safer to roll out, and easier to keep consistent as the team built new financial solutions.
“We've been able to shift completely toward infrastructure as code; it's a simple YAML format that covers everything,” Mickey explains. “Docker files and custom UI configurations aren't important anymore.”
Faster builds without manual caching upkeep
Grid eliminated manual cache management in their monorepo by transitioning to content-based caching with RWX, which detects code and filesystem changes and automatically reuses prior outputs. Instead of maintaining Docker build layers and cache logic that “didn't really work,” as Mickey puts it, the team relies on RWX to “only run what's really needed for a new job,” reducing redundant work and keeping the feedback loop fast.
The increased parallelism ensures independent work runs concurrently instead of queuing behind limited shared resources. For Grid's engineers, that meant PR checks and build steps progressed in parallel, shortening the feedback loop when a build failed or a pipeline change needed validation.
Debugging pipeline changes without reruns
Pipeline changes are where many CI systems slow teams down, because validating a config edit often requires a push, a remote run, and another round of waiting. RWX helped Grid shorten that loop with a local CLI for testing pipeline changes and a remote debugger that can connect to the running job.
That breakpoint workflow has a major impact on day-to-day iteration. Instead of rerunning a job to reproduce a failure and iterating by trial and error, Grid's engineers set a breakpoint inside the job, jump directly to the failing step, and debug in one pass.
When edge cases came up, such as an external dependency outage, Grid didn't need a support-heavy workflow to keep pipelines moving. The team owned its YAML configuration, and RWX's engineers would share vetted snippets and best-practice adjustments to keep builds optimized as dependencies evolved. “The RWX team will just reach out to us proactively to give us a snippet of YAML, and we're able to self-service easily,” Mickey shares. “Everything is hands-off, easy to maintain, and our developers love using it.”
“RWX enables us to ship fast, without babysitting cache keys or build layers. If a pipeline change fails, breakpoints help us debug the exact step in one shot instead of iterating through reruns.”
Results
Reduced CI/CD costs and an accelerated pathway from pull request to production
With RWX, Grid swapped a fragmented, multi-vendor stack for a unified CI/CD solution that eliminates infrastructure waste and drives pipeline times, while meeting their security and compliance standards.
Since implementation, Grid has cut CI/CD costs by 90%, moves from pull request to production in 10 minutes, and completed its full integration within one month.
Looking ahead, Mickey sees RWX as a crucial partner that will continue to support Grid's development velocity as it expands both in platform depth and user count.
“RWX has strong product judgment. Their platform solves hard CI/CD problems in a novel way so our engineers don't have to think about it; they just know that it works fast.”
More customer stories
“Our CI was slow, and with that long execution time came some noticeable shifts in developer willingness to innovate. RWX’s ability to reuse prior results when the underlying inputs had not changed gave us a way to break that trend.”
“We needed to reliably get our code shipped to production quickly, every time. RWX made that possible by giving our engineers a feedback loop they could actually rely on.”
“The CLI and other features built into RWX continue to be some of the best parts of the platform. It is designed in a way that really enables fast feedback loops with agentic help.”