Building the Web that moves money: inside Web engineering at Revolut

Introduction

In today’s digital-first economy, the web is the critical touchpoint between people and their money. At Revolut, we embrace this reality in our approach to web engineering: focusing on not just building interfaces, but on creating seamless, secure, and future-proof financial experiences.

Our mission at Revolut is to redefine the global standard for digital finance. Every line of code, design decision, and feature we release serves this goal: to make finance more accessible and beautifully engineered.

These principles shape our culture, set a high standard for excellence, and require constant attention to detail. They also drive us to rethink modern web development tools and practices.

This article focuses on the principles that help us deliver secure, beautiful financial products worldwide, and explains how engineers are building their careers along the way.

The scope of Revolut web products

Two independent but complementary pillars represent the current stage of the Revolut web ecosystem.

Customer-facing applications These are the digital gateways through which our customers and partners experience Revolut directly:

Main website and brand hub

Revolut Business platform

Revolut crypto exchange platform

Human Resources Management Systems (HRMS) by Revolut

Each of these touchpoints is an individual part of a unified ecosystem offering a consistent product experience that is closely aligned with our mobile platform.

Internal web products Alongside our external platforms, Revolut operates around a hundred internal web applications. These provide our employees, operations, and partners with tools for:

• Back-office management
• Compliance and risk monitoring
• Customer support services
• Data and reporting systems
• Operational efficiency at scale

These internal tools are the driving force behind Revolut, ensuring customer-facing products remain fast, secure, and globally scalable

Core principles of web engineering in Revolut

Principles set the direction. Practices deliver the results.

Revolut’s web ecosystem is built on scale — nearly a hundred independent applications, all evolving to meet the demands of a fast-growing business. To keep pace, we run on small, empowered teams that take ownership of entire services, driving speed and accountability.

Our approach is guided by clear **engineering principles and shaped by modern agile practices, inspired by eXtreme Programming (XP). However, principles alone aren’t enough. We amplify them with critical practices** that turn vision into execution and impact.

Together, these principles and practices form the framework that lets us ship fast, adapt to hyper-growth, and never compromise on quality.

Now, let’s look at how these ideas translate into real-world solutions.

Adapting to hyper-growth

Build systems that can explain their own evolution.

As the business grows rapidly, so must our codebases and teams. Designing for change means designing for the future as well as the present. It’s structure that promotes scaling, not the other way around. In practice, this means:

• Code should explicitly reflect current business needs — no more, no less. Domain-Driven Design (DDD) helps us organise the code on the frontend in a way that keeps it aligned with the domain. While there are many books on this topic, almost all of them focus on backend implementation when it comes to ‌tactical patterns. We adapt these ideas for the frontend, applying bounded contexts, clear models, and explicit contracts to ensure that our codebase mirrors the business as it evolves. This way, the system itself becomes the most reliable source of truth, guiding both engineers and stakeholders.
• Treat types as executable documentation — every type in your codebase is a specification that guides developers, prevents errors, and accurately documents intent. Your types are not just safety nets. They’re the clearest, most reliable form of communication between engineers, designers, product owners, and machines. Design your types so that only correct, meaningful states are possible. We love to use type NEVER a lot, as it makes the invalid states unrepresentable. These “type guards” turn runtime errors into compile-time guarantees, ensuring that every path the code can take is intentional, safe, and self-documenting.
• Systems must fail loudly and clearly when new, unsupported states appear — unexpected inputs and impossible branches should trigger explicit, actionable errors rather than silent degradation. We enforce this by validating every external boundary (APIs, configs, feature flags) at runtime (we’ve bet on Zod), aligning schemas with our TypeScript types. Hence, the same contract guards both compile time and production;
• The system itself should guide its future evolution — the architecture, components, designs, and type system of our web platform act as a map for growth. By embedding conventions, designing tokens, and sharing libraries that strictly rely on the centric UI-kit library, we ensure that every new feature aligns with established patterns, marking the path of least resistance for growth and evolution.

Never compromise on quality

Build trust through correctness and clarity.

In financial products, quality is the foundation of customer trust. A bug, security gap, or broken flow can impact people’s money directly, leading to reputational and regulatory risks.

• Make quality everyone’s responsibility. At Revolut, we don’t have dedicated QA engineers. Instead, we see this as a strength. Engineers design, build, test, and monitor their products themselves. They provide engineering expertise in writing code, and also in testing it. This tight ownership creates a direct feedback loop, fosters a culture of accountability, and ensures that quality is built in from the first line of code — not inspected at the end.
• Ensuring stability on components, features and product levels. Our testing approach is built around Playwright and Jest, including unit, functional and production e2e types of tests. It allows us to automate end-to-end scenarios confidently, ensuring that key user flows work as expected across browsers and platforms. This helps us catch regressions early and maintain stability without slowing down delivery;
• Sensitive production monitoring is a part of the quality loop. We complement the automated testing approach with a continuous production monitoring system, ensuring quality doesn’t stop at release. We identify, debug, and resolve production issues with **Sentry. **Sensitive alerts notify our engineers of every issue occurring in production, enabling early detection and rapid response. They help us catch edge cases that slip past automated tests and manual validation, often before users notice or report them to customer support. This proactive approach is essential for maintaining trust and minimising impact, particularly in an environment where the engineering team is responsible for quality from start to finish.
• Fixing a bug is just the first step. Outstanding quality means using every issue as an opportunity to improve the system. We treat each bug as a chance to uncover gaps, strengthen our architecture, and prevent similar problems from happening again.

Quality concerns are always the top priority. They’re non-negotiable in code reviews, routine planning, and the shaping of engineering strategy. No matter the pressure, we never trade quality.

Built to ship fast

Speed comes from clarity, not shortcuts.

Velocity doesn’t mean skipping steps. It means eliminating friction and building systems that facilitate safe and rapid execution.

• Types as the first line of testing. When the types mirror the business rules they become the immediate quality guards with the instant feedback, catching issues before tests even run. This accelerates development times and shortens the feedback loop. This makes iterations faster, reduces wasted cycles, and helps teams ship with confidence.
• Standards are the foundation of a true ecosystem. We simply don’t do custom styling in our projects. Together with the central design system team, we develop robust, resilient UI patterns. The patterns are translated into ready-to-use components stored inside a centralised rich Uikit library. This means that every new design decision becomes a standard available for every project.
• Developers should solve business needs, not fight code complexity. We reduce cognitive overhead, automate the boring parts, and let engineers focus on what matters. The frontend platform team builds technical solutions that simplify product development across Revolut. Our internal frameworks and tooling provide a ready-made foundation, so new services launch with everything needed for growth and maintenance. In other words, we’ve built an orbital launch station for projects — allowing teams to start from orbit, not from the ground, and accelerating delivery and innovation across the company

These principles are a shared compass for engineers. Revolut is all about innovations, but everything we build must support clarity, resilience, and confidence.

🌟 Excellence through people

World-class products can only be built by world-class people

Engineering principles are like cookbooks: they provide the instructions for creating reliable, scalable, and innovative products. But it’s people who bring those recipes to life.

• Hire A-Players. A-Players are more than technically skilled. They’re impact-driven, adaptable to change, and raise the performance bar for everyone around them. At Revolut, our interviews place candidates in real-world scenarios, asking them to implement features standard to web engineers, the solutions they probably did this week in their current job. We don’t focus on cracking obscure JavaScript puzzles (like figuring out how 0.1 + 0.2 !== 0.3), we don’t ask “How many golf balls fit in a school bus?”, we value the way of solving the practical tasks (think deeper), the ability to deliver solutions end-to-end (get it done), and the sense of perfection that drives excellence (deliver wow).
• Grow A-Players. Impact creates leaders. We foster engineers at Revolut who make an impact and empower their strengths. At any seniority.
• Empower A-Players. High performers need trust and ownership. With autonomy, they move faster, take responsibility, and lift the whole team.

When put into practice, our principles shape a culture of clarity, ownership, and innovation. Company-wide patterns enable developers to move fast with confidence, collaborate seamlessly, and continuously raise the standard of web products. This culture isn’t accidental — it’s the natural result of aligning philosophy with execution. It enables Revolut to scale web engineering to hundreds of people, hundreds of products, dozens of teams, and millions of customers moving billions of dollars.

Tech stack

Legacy is valued. Progress is mandatory.

Revolut is now a well-established company with a history spanning more than 10 years. It was founded in 2015, just a year after React 0.12 was released. Over this time, we’ve accumulated a wide range of solutions, approaches, tools, experiments, and lessons learned.

We treat legacy with respect and don’t rush to rewrite entire products every time a new library version is released. Instead, we follow a structured process to ensure that dependencies are updated in a timely manner across all systems. When a new version of a core or widely used library is issued, we first upgrade it in a specific project. Once stability is proven, automation triggers update requests across all dependent products.

This layered approach keeps our stack unified, up to date, and — most importantly — adaptable to change.

Our tech stack is well known in the web engineering community, and we work to keep it clean, light, and modern. We run on the latest stable releases — never more than one major version behind — ensuring consistency and adaptability across all products.

• Typescript — latest stable (within 1 major version)
• React, React Query — latest stable (within 1 major version)
• Bitbucket for code storage
• TeamCity for build management (CI/CD)
• Rush and NX for monorepo management
• Sentry platform for error tracking
• Kubernetes for automated app deployment, scaling, and management

For testing we use:

• Jest
• Playwright
• Storybook
• React testing library

Engineering with purpose

Our philosophy is to let the code reflect the business, let the system empower the team, and let mistakes guide the future. We believe in people, and their ability to grow to shape the future. But we also believe in balance — respecting the past, while building for what’s to come. These principles encapsulate the essence of web engineering at Revolut: confident, flexible, and driven to set new standards.

Join Revolut

Make an impact at a global scale

At Revolut, there’s always room for talent. We don’t define your journey for you. Bring curiosity, drive, and ownership, and you’ll shape your own path while making an impact on a global scale.

Our ecosystem is a unique opportunity for web technology — built for massive scale, the highest quality standards, and the ambition to keep pace with a fast-growing business.

Want to shape what’s next in finance?

See where you can make your impact at — Revolut Careers.