How Nubank refactors millions of lines of code to improve engineering efficiency with Devin
Overview
One of Nubank’s most critical, company-wide projects for 2023-2024 was a migration of their core ETL — an 8 year old, multi-million lines of code monolith — to sub-modules. To handle such a large refactor, their only option was a multi-year effort that distributed repetitive refactoring work across over one thousand of their engineers. With Devin, however, this changed: engineers were able to delegate Devin to handle their migrations and achieve a 12x efficiency improvement in terms of engineering hours saved, and over 20x cost savings. Among others, Data, Collections, and Risk business units verified and completed their migrations in weeks instead of months or years.
The Problem
Nubank was born into the tradition of centralized ETL FinServ architectures. To date, the monolith architecture had worked well for Nubank — it enabled the developer autonomy and flexibility that carried them through their hypergrowth phases. After 8 years, however, Nubank’s sheer volume of customer growth, as well as geographic and product expansion beyond their original credit card business, led to an entangled, behemoth ETL with countless cross-dependencies and no clear path to continuing to scale.
For Nubankers, business critical data transformations started taking increasingly long to run, with chains of dependencies as deep as 70 and insufficient formal agreements on who was responsible for maintaining what. As the company continued to grow, it became clear that the ETL would be a primary bottleneck to scale.
Nubank concluded that there was an urgent need to split up their monolithic ETL repository, amassing over 6 million lines of code, into smaller, more flexible sub-modules.
Nubank’s code migration was filled with the monotonous, repetitive work that engineers dread. Moving each data class implementation from one architecture to another while tracing imports correctly, performing multiple delicate refactoring steps, and accounting for any number of edge cases was highly tedious, even to do just once or twice. At Nubank’s scale, however, the total migration scope involved more than 1,000 engineers moving ~100,000 data class implementations over an expected timeline of 18 months.
In a world where engineering resources are scarce, such large-scale migrations and modernizations become massively expensive, time-consuming projects that distract from any engineering team’s core mission: building better products for customers. Unfortunately, this is the reality for many of the world’s largest organizations.
The Decision: an army of Devins to tackle subtasks in parallel
At project outset in 2023, Nubank had no choice but to rely on their engineers to perform code changes manually. Migrating one data class was a highly discretionary task, with multiple variations, edge cases, and ad hoc decision-making — far too complex to be scriptable, but high-volume enough to be a significant manual effort.
Within weeks of Devin’s launch, Nubank identified a clear opportunity to accelerate their refactor at a fraction of the engineering hours. Migration or large refactoring tasks are often fantastic projects for Devin: after investing a small, fixed cost to teach Devin how to approach sub-tasks, Devin can go and complete the migration autonomously. A human is kept in the loop just to manage the project and approve Devin’s changes.
The Solution: Custom ETL Migration Devin
A task of this magnitude, with the vast number of variations that it had, was a ripe opportunity for fine-tuning. The Nubank team helped to collect examples of previous migrations their engineers had done manually, some of which were fed to Devin for fine-tuning. The rest were used to create a benchmark evaluation set. Against this evaluation set, we observed a doubling of Devin’s task completion scores after fine-tuning, as well as a 4x improvement in task speed. Roughly 40 minutes per sub-task dropped to 10, which made the whole migration start to look much cheaper and less time-consuming, allowing the company to devote more energy to new business and new value creation instead.
Devin contributed to its own speed improvements by building itself classical tools and scripts it would later use on the most common, mechanical components of the migration. For instance, detecting the country extension of a data class (either ‘br’, ‘co’, or ‘mx’) based on its file path was a few-step process for each sub-task. Devin’s script automatically turned this into a single step executable — improvements from which added up immensely across all tens of thousands of sub-tasks.
There is also a compounding advantage on Devin’s learning. In the first weeks, it was common to see outstanding errors to fix, or small things Devin wasn’t sure how to solve. But as Devin saw more examples and gained familiarity with the task, it started to avoid rabbit holes more often and find faster solutions to previously-seen errors and edge cases. Much like a human engineer, we observed obvious speed and reliability improvements with every day Devin worked on the migration.
“Devin provided an easy way to reduce the number of engineering hours for the migration, in a way that was more stable and less prone to human error. Rather than engineers having to work across several files and complete an entire migration task 100%, they could just review Devin’s changes, make minor adjustments, then merge their PR”
Jose Carlos Castro, Senior Product Manager
From Writing Code to Designing Systems: How AHEAD Unlocked 8x–40x Faster Engineering with Devin
About the company
AHEAD is a technology services company that advises, implements, and manages cloud, data, and security solutions for enterprise clients across healthcare, finance, and manufacturing industries.
Client Zero
AHEAD ran a pilot with the company’s own internal engineering organization as client zero, with defined use cases, baselines, and success criteria. The pilot covered eight high-impact production use cases spanning Terraform, Snowflake, Go, Salesforce, MuleSoft, Azure, and dbt. Devin became fully productive within two business days, delivering 8x to 40x time savings measured against manual baselines.
During the pilot, two projects revealed something more fundamental about how engineers’ work itself was changing.
Salesforce unit test failure analysis
After AHEAD trained Devin on the workflow, it owned the task end to end. The team gave Devin its own Salesforce user with two-factor authentication and it logs in and clears the OTP prompt on its own. From there, Devin navigates to the administrative deployment page through the UI, finds a failed deployment, analyzes the error logs, goes into the codebase, fixes the code, and opens a pull request. Doing all these steps autonomously with no human in the loop proved just how much complexity Devin could take on. Engineers moved from executing the fix to defining what a good fix looks like.
MuleSoft API documentation and testing
A senior engineer used Devin to build three APIs in a single day, a process which previously took four weeks. When Devin encountered a connector integration issue it could not resolve directly, it navigated into the third-party connector’s packaged source code, diagnosed the problem, and fixed the implementation on its own. With Devin writing the APIs, engineers focused on reviewing and approving them.
In both cases, the pattern persisted: Devin handled the implementation while the human engineer handled the architecture and quality judgment.
The Shift
While the productivity gains were significant, the cultural shift was much larger. The real unlock came when engineers started treating Devin like a team member.
“As soon as we started provisioning it like we would a developer, training it like we would a developer, everything changed.”
Matt Mierzejewski
On a Sunday night, a CI pipeline failed. Instead of logging in to diagnose it, Matt sent Devin a Teams message:
“The pipeline’s failing in this repo. Can you go fix it? And by the way, I don’t want to get these on the weekend.”
By the next morning, Devin had opened two ready-to-merge pull requests — one that fixed the broken code, one that rescheduled the pipeline to stop firing on weekends.
At AHEAD, the engineer’s job is transforming from pure implementation to strategically architecting what the implementation should be. Across the team, the question has evolved from whether to use Devin to why they would not.
“I’m trying to turn our software engineers into product engineers. The machine is so much faster than we will ever be at entering code. I want people spending more time designing the software and giving the AI the guardrails it needs.”
Matt Mierzejewski
Going to Market
“Devin is the keystone of our AI Accelerated Development offering. Our customers are solving business problems, not just technical ones, and Devin lets us tackle both. The advisory, enablement, and customization we’ve built around it are what help the world’s biggest companies actually get there.”
Eric Kaplan, CTO, AHEAD
For AHEAD, the internal rollout was the blueprint for a client-facing practice. Devin sits inside a broader AI-accelerated development offering, where AHEAD advises clients on tool strategy and where to invest, trains their engineering organizations to adopt agentic development, delivers the work alongside them, and measures returns in terms a board can act on.
Each pilot use case equipped AHEAD with a library of reusable templates. AHEAD now has Devin playbooks for upgrading Terraform providers, evolving data models, provisioning Azure resources, Go services, and Salesforce and MuleSoft testing, each ready to run on client engagements.
That practice meets clients wherever they are. Some lean on AHEAD’s own engineers, who now run Devin daily across their codebases. Others bring AHEAD in to accelerate active engagements, compressing migrations and tech-debt work that used to define a project’s timeline. A growing number are turning to AHEAD to run Devin as an ongoing managed service. In every case, the methodology is the one AHEAD proved on itself, and the clients already in the field are seeing it hold up under real delivery.
What's Ahead?
AHEAD is continuing to rollout Devin across its engineering organization and expanding to additional teams and verticals. With a strong foundation laid down, every new team onboards faster than the last.
The team is also using Devin’s scheduling capabilities to automate recurring, time-consuming tasks: analyzing vendor release notes against the codebase and surfacing code-change recommendations, evaluating package management overrides, and benchmarking new AI models against cost and performance thresholds.
Having proved Devin on its own engineering organization, AHEAD now brings that expertise to clients through a full set of services built around the platform:
- AI Advisory: helping clients decide where to invest across an increasingly saturated AI tooling landscape.
- Change Management & Enablement: rolling agentic development out across large engineering teams through structured pods, training, and curated playbooks.
- Installation & Customization: standing Devin up inside a client’s own environment, tuning it to their codebases and standards.
- ROI Analytics: measuring the return in terms a board can act on.
Together, these help some of the world’s largest companies force-multiply their technology transformations, with Devin serving as the keystone of AHEAD’s AI Accelerated Development offering.
We’re excited to partner with AHEAD as they scale this new model of engineering across their vast client base. With existing deployments already driving meaningful results, AHEAD is refining its repeatable delivery playbook with every engagement. Organizations interested in deploying Devin at scale through a proven partner can connect with the AHEAD team directly.