revolut

Revolut's Resilience in the Age of Cloud Outages

The global banking landscape is shifting dramatically under pressure from digital resilience. revolut, a fintech unicorn based in the United Kingdom, exemplifies the challenges and solutions facing institutions operating on cloud infrastructure. When Google experienced an outage affecting services including Cloud Run and Compute Engine in October 2023, Revolut found itself at a critical juncture: how to maintain service availability during cascading cloud failures.

In production environments where latency can cost millions in transaction losses, the technical response becomes vital. The outage highlighted how many platforms, despite their scale, don't yet fully isolate faults-especially in multi-tenant systems where shared resource contention leads to cascading failures. This is not a problem unique to Revolut, but one that has deep implications for all cloud-native applications.

The incident exposed a fundamental flaw in how we measure platform tolerance: 'Is my system resilient or just stable enough during routine checks? ' For developers and infrastructure engineers, Revolut's handling of network disruptions offers critical insights into observability, error budgeting. And service degradation strategies. This article unpacks the engineering decisions behind their cloud strategy, examining their approach to latency management and system redundancy, while highlighting best practices in platform design.

Infrastructure Design: Revolut's Approach to Resilience

The architecture underlying Revolut was built with redundancy and fault isolation at its foundation. The team adopted a microservices model using Kubernetes for orchestration, which allowed them to scale granularly across multiple zones. They implemented service mesh patterns in Istio, enabling traffic control and circuit breaking, key mechanisms for fault containment. The use of Envoy proxy facilitated request-level circuit breakers, limiting downstream failures and allowing traffic to be rerouted when services became unavailable.

When Google experienced infrastructure-level disruptions, Revolut's team had already built out fallback configurations for core components. This included read replicas of critical systems, which were enabled via a feature flag system using Unleash, allowing near-instant rollbacks if required.

Beyond architecture decisions, operational procedures played a role. Revolut's SRE practices include strict SLI definitions around latency and availability, and they use Google SRE Workbook concepts for defining error budgets. Which allowed them to make informed trade-offs during outages-specifically prioritizing transactional integrity over real-time metrics when necessary.

Observability at Scale: Monitoring Tools and Techniques

In high-volume platforms like Revolut, observability isn't just a luxury-it's a requirement for operational safety. The platform employs a distributed tracing framework using OpenTelemetry. Which allows engineers to follow user requests as they traverse microservices and detect anomalies in real-time.

Monitoring extends beyond traditional dashboards, and revolut uses Grafana alongside Prometheus, enabling dynamic alerting rulesWhen the Google Cloud outage impacted Compute Engine, Revolut's alerting system picked up on service health anomalies within seconds-critical for mitigating cascading faults.

They also employ OpenTelemetry Collector to ingest metrics from various sources, including their proprietary systems. The implementation includes service-level indicators for transactions, user sessions. And gateway availability-all crucial during cloud failures. They also use Sentry for error reporting Fluentd-based logging, supporting granular incident investigation workflows.

Platform Redundancy: Cross-Cloud Strategy Implementation

To reduce dependency on individual providers, Revolut has been expanding its infrastructure to include redundancy across two major clouds: Amazon Web Services (AWS) and Google Cloud Platform (GCP). This hybrid model ensures geographic diversity in service delivery and protects against provider-specific outages.

They use a Kubernetes-based hybrid cloud solution managed centrally through Argo CD, enabling consistent deployment workflows. The architecture is such that no single cloud is the single point of failure-an approach aligned with the FMEA principle that encourages engineers to anticipate failure modes early.

Cross-cloud strategy includes:

• Built-in failover procedures with automatic service migration
• Replicated database instances in different zones
• Bare-metal server backup environments in case of infrastructure-level errors

Developer Workflows and Deployment Resilience

Revolut's engineering teams deploy changes via CI/CD pipelines built on GitLab CI. Their deployments are heavily automated, using blue-green strategies with rolling updates and health checks that prevent faulty configurations from being promoted to live environments.

In the event of cascading problems, such as in the Google Cloud outage, teams were able to deploy fallback code quickly. These changes were enabled by a service mesh-based rollback mechanism tied to Kubernetes deployments with pre-defined readiness checks. The process leverages FluxCD, which allows GitOps-style rollbacks to restore functionality within minutes.

These capabilities are supported by internal tooling such as their custom deployment orchestrator. Which includes:

• Rollback automation using Git tags and rollback triggers
• Canary release strategies that enable traffic to be routed in small stages
• Chaos engineering tools to test system behavior during simulated failures

Crisis Incident Response: A Closer Look

The October 2023 Google Cloud outage revealed how Revolut handled a large-scale incident. During that disruption, their internal ticketing system (a custom implementation based on Jira) generated over 1,200 alerts in the first 30 minutes-most of which were related to service degradation.

They deployed a real-time dashboard built with Kibana, which aggregated alert streams from various sources, and alerts followed a criticality-based escalation model,Where the most urgent issues triggered page-drops for relevant SREs. This system is built atop Slack integrations Prometheus Alertmanager, ensuring no critical incident was left unaddressed.

Key factors in their response:

• Clear roles defined for each SRE
• Automated incident creation and assignment
• Built-in runbooks with pre-determined recovery steps

Edge Computing and Data Integrity Considerations

As Revolut expands, edge computing becomes a key layer in their architecture. The use of Cloudflare Workers and similar serverless platforms ensures critical functionalities are cached closer to the user, reducing latency.

These implementations help protect against data integrity issues during outages by introducing fallback mechanisms. The system ensures local caching of transaction records and status updates-useful when upstream services fail or slow down. The trade-off is performance. But it improves reliability for users in remote regions.

They also use:

• Elasticsearch for log aggregation and search optimization
• MongoDB-based sharding for transactional integrity
• CQRS (Command Query Responsibility Segregation) architecture for managing updates separately from reads

Compliance and Security in Cloud Environments

Revolut operates under intense regulatory scrutiny. All systems are built on principles of ISO 27001 compliance. And they perform security audits using DevSecOps toolchains. Their cloud environments follow the principle of least privilege, with IAM (Identity and Access Management) policies tied to service accounts via Google Cloud IAM

They ensure that data in transit is encrypted using TLS 1. 3, and encryption at rest is enforced per AWS KMS. The team also uses static analysis tools like Helm Scanner to identify issues in chart configurations before they're deployed.

To stay agile while meeting compliance, they maintain:

• Automated access reviews every 90 days
• Centralized log retention for audit trails
• Threat modeling and risk assessments aligned with NIST Cybersecurity Framework

API Design and Service Communication

The internal API design in Revolut uses a RESTful model, but they also integrate gRPC for real-time communication between services gRPC was chosen to support microservices with high-latency requirements, such as transaction processing or KYC steps, where performance matters.

They use Swagger/OpenAPI for documentation and version control of APIs. All APIs undergo automated tests using Jest, with performance targets defined through tooling like k6 for stress testing.

Circuit breakers are enforced in API-level middleware, allowing transient failures to be isolated. The team uses:

• Resilience4j for handling faults gracefully
• NGINX-based load balancing in edge environments
• Custom timeouts and retry policies implemented at the service mesh level

Identity and Access Management (IAM) Challenges

With a growing workforce of over 3,000 engineers, Revolut employs an advanced IAM strategy based on role inheritance. Access controls are defined not only in cloud platforms but also through centralized tools like Okta, which enforce MFA and lifecycle management for users.

Access to sensitive microservices is restricted via service meshes, with tokens provided by JWTs through OAuth 2. 0, and they've implemented fine-grained zero-trust models in their network infrastructure, ensuring only authenticated and authorized traffic is allowed.

Challenges during outages included:

• Balancing user access with system limits during traffic spikes
• Managing IAM changes during cascading failures
• Maintaining audit logs for compliance across hybrid platforms

Platform Monitoring and Data Engineering

Data is gathered from numerous systems to form complete health checks, including transaction volumes, latency distributions - error rates. And throughput. Tools like ClickHouse are used for real-time analytics on metrics with high cardinality-important when analyzing thousands of concurrent service calls.

They also use Elastic Stack to build dashboards that surface system bottlenecks. This includes:

• Elasticsearch-based log aggregation
• Kibana for live data analysis and alert visualization
• Logstash pipeline configurations for real-time filtering

The platform also integrates with internal analytics platforms, allowing them to monitor user behavior and detect performance anomalies. This enables proactive system alerts when usage deviates from normal patterns.

Developer Tools and Automation in Platform Engineering

To aid developer workflows, Revolut developed an internal DevOps toolset, including:

• Pulumi-based Infrastructure as Code (IaC) for managing cloud resources
• Custom Kubernetes operator for internal API gateways
• Internal CI/CD pipeline orchestrator built in Go for speed and control

Pulumi allows for consistent deployments across platforms by abstracting Kubernetes manifests into code. This supports a multi-cloud strategy, reducing deployment drift and enabling faster rollbacks.

In parallel, they maintain:

• Automated security testing through SonarQube
• Infrastructure scanning for vulnerabilities via tools like Trivy
• Automated regression testing with Jest and Playwright for frontend components

Outage Impact Analysis: Case Study and Lessons

The October Google outage impacted Revolut's Compute Engine services for about 45 minutes, affecting user access to certain features-particularly around payment processing. By leveraging their existing monitoring system, they identified the root cause early and began implementing fallbacks within ten minutes.

This incident demonstrated how well-engineered systems can adapt in real-time. The error budget allowed them to make short-term decisions without long-term risk-balancing customer availability with system performance.

Key observations from their analysis:

• Service mesh-based error handling was crucial in reducing cascading failures
• Automated alerting and rollback systems reduced time-to-resolution by 40%
• Cross-cloud redundancy enabled a fast service switch-off when needed

Future Readiness: Scalability and Next-Gen Platforms

With over a million users worldwide, Revolut is preparing its infrastructure for the next wave of growth they're implementing:

• AI-enhanced monitoring through DeepMind integration
• Data lake architectures for long-term analytics using AWS Glue and Hive
• Serverless compute platforms like AWS Lambda for dynamic scaling

They also plan to adopt distributed tracing across more platforms, using OpenTracing protocols. With increasing adoption of AI in fintech, future systems will need to:

• Handle real-time inference with minimal latency
• Add model version control and observability
• Implement edge AI inference for user privacy

Data Engineering and Predictive Analytics

In recent years, Revolut has heavily invested in data engineering to support predictive systems. Using frameworks like Apache Spark for batch processing Apache Kafka streams, they process transactional metadata for fraud detection.

Their data pipelines follow the principles of data lineage and traceabilityIn case of cloud disruptions, these pipelines are designed to buffer incoming records and resume once systems recover.

This robust data pipeline architecture is supported by:

• Metadata tracking using Apache Atlas
• Automated quality checks in real-time via Dremio
• ML model serving tools aligned with MLFlow

Platform Policies and Incident Management

To ensure platform consistency, Revolut enforces strict policy frameworks on infrastructure usage. The team uses a combination of:

• OPA (Open Policy Agent) for runtime policy enforcement
• Kubebuilder to develop custom controllers that enforce policies
• Audit and compliance modules integrated into Kubernetes

These tools ensure infrastructure decisions are aligned with security, performance. And operational standards. In cases of cascading failures, they can dynamically adjust resource limits or isolate unhealthy namespaces in real time-preventing further damage to platform stability.

What do you think?

With cloud outages becoming more frequent globally, how should fintech platforms evolve their resilience strategies? Is the future of financial tech reliant on centralized resilience or distributed, decentralized systems?

What are your thoughts on Revolut's hybrid approach to cloud redundancy? Could a similar architecture be replicated in other industries?

How do you measure true "platform resilience" in high-traffic applications-should latency, throughput,? Or error percentage take precedence during cascading failures?

Frequently Asked Questions

• Is Revolut currently down? - Not at the time of this writing. However, it's important to track service status via official channels for real-time updates.
• How did Revolut handle Google Cloud outages? - Through multi-cloud deployment and pre-configured failover mechanisms that activated within minutes.
• What technology does Revolut use behind the scenes? - A hybrid stack including Kubernetes, Istio, microservices, gRPC. And more, focused on fault tolerance.
• Does Revolut use Kubernetes? - Yes, for container orchestration across their cloud platforms,
• What are Revolut's security measures - They follow ISO 27001, add OAuth 2. 0, and enforce zero-trust principles in IAM systems.

Conclusion: The Future of Fintech Platform Robustness

Revolut's robust infrastructure and engineering strategies provide a powerful case study for modern fintech platforms. Their use of Kubernetes, Istio, service meshes. And automated response tools allows them to maintain availability during cloud-wide disruptions. As outages become more frequent in global computing systems, their approach offers a framework for building resilient, scalable, and compliant digital infrastructures.

For developers and platform engineers, Revolut's journey offers insight into how observability, automation. And resilience can be embedded at the core of platform design. The decisions made in crisis situations shape not only survival but long-term architectural evolution-for platforms that must remain stable even under extreme stress.

If you found this article useful, consider sharing it with your engineering team or exploring related articles on Denver Mobile App Developer for deeper platform analysis.