Reverse-Engineer-Then-Formalize at Scale
Do one instance deep by hand, reverse-engineer the best process, then codify it into a scalable algorithm
- Difficulty
- Advanced
- Time to result
- ~months to results
- Steps
- 4
- Confidence
- 88%
A method for turning a complex, repeatable operation into a scalable process. You execute one or two real instances end-to-end going as deep as needed, then reverse-engineer what the best process actually was, then zoom out and formalize it into an algorithmic process with explicit steps, quality gates, hiring needs, and timing — so a lean team can run it at scale.
Origin
Described by Dmitry Zlokazov as how Revolut scales operationally complex work (like launching regulated bank branches) across ~50 countries with a very lean team.
Core principles
- 01Understand the root cause deeply — in a complex domain there are no obvious things
- 02Build the process from a real completed instance, not a whiteboard theory
- 03The value is in the zoom: dive deep, then rise to helicopter view to simplify
- 04Formalize into steps, quality gates, roles, and timing so it becomes robust and scalable
How to run it
- 1
Execute one real instance deeply
Do a single complete case end-to-end, going as deep as required to understand every nested project and root cause.
Watch out Don't skip the deep manual instance — in complex domains, obvious-looking assumptions are usually wrong until you hit root cause.
- 2
Reverse-engineer the best process
After completing the instance, work backwards to determine what the ideal process actually was.
Pro tip Run two instances (e.g. two different countries) so you can separate what's essential from what was incidental to one case.
- 3
Zoom out to the ideal scalable framework
Raise to a helicopter view and ask: what's the ideal framework for doing this at scale? Simplify the complexity you saw in the details into a robust, repeatable shape.
- 4
Formalize into an algorithmic process
Codify it into explicit steps, quality gates, sequencing, which roles to hire, and how far in advance to start before each new launch.
In the wild
Revolut needed local bank branches (France, Germany, Italy, etc.) each requiring full regulatory compliance, data reporting, and payment-system registration. They launched branches in Ireland and the Netherlands, reverse-engineered the best process, then formalized it into an algorithmic process with steps and quality gates for a lean team.
→ A few-person team can scope and run branch launches at the scale of ~50 countries.
Common mistakes
Trying to design the scalable process before doing one for real
Without executing a deep real instance first, you miss the non-obvious root causes and build a process that breaks in practice.
Is it for you?
Best for
Operations and product leaders industrializing a complex, regulation-heavy, or multi-market process with a small team
Not ideal for
One-off projects that will never repeat, where the cost of formalization outweighs the benefit
From the transcript
“we go very deep on example of each of these project”
“Then we reverse engineered what was the the best process to do it and then we went back up on top level and we said…”
“doing this switch between zooming in very deep and then raising on the on the level of of helicopter view”
From the episode
How Revolut trains world-class product managers: The “local CEO” model, raw intellect over experience, and a cultural obsession with building wow products
Dmitry Zlokazov (Head of Product)