By creating a shared platform, we removed barriers between the two groups. Both could collaborate, test ideas faster, and deliver results that directly support trade analysts, who rely on accurate, timely insights for decision-making.
The application facilitates faster and more reliable insight generation by improving data quality and optimizing the workflow efficiency of traders and analysts at Equinor
The existing solution, built on Next.js, was already mature and integrated with external data services via GraphQL. However, as queries and algorithms grew more complex, new challenges emerged:
Developers and data scientists often speak very different technical languages. This leads to siloed workflows, miscommunication, and slow iteration cycles.
We saw this as an opportunity not just to fix a bottleneck, but to future-proof the entire stack.
Our challenge wasn’t just technical - it was strategic: how do we enable data scientists and developers to collaborate on a unified platform without rewriting the existing solution or slowing down delivery?
How can we scale our platform and decouple business logic without rewriting the current solution- while enabling data scientists to create and test APIs independently, without needing backend expertise?
Enable data scientists to define, test, and deploy business logic directly via Python
We didn’t want to just patch the architecture; we wanted to future-proof it.
If you're only building a backend, you're solving today’s problems. If you're building a platform, you're investing in tomorrow’s success.
Rather than treat the backend as a hidden layer, we turned it into an open, extensible platform. One that:
1. Async Performance by Default
2. Python-First Logic for Data Scientists
Business logic is now written in Python—enabling data teams to:
3. Secure, Scalable Foundation
Built-in auth handling, token validation, container orchestration, and API standardization - all aligned for scale.
While async enables efficient handling of many I/O-bound tasks within a single process, using uvicorn --workers allows the application to scale across multiple CPU cores, significantly improving performance under high load.
Radix provides the underlying infrastructure to horizontally scale these worker processes across multiple containers or nodes, enabling the application to handle even greater concurrency and throughput.
Radix’s orchestration delivers scalable, low-latency performance for both I/O-bound and CPU-bound scenarios.
Backend
Python, FastAPI, Uvicorn, Pydantic, Redis, Pandas
Frontend
React, Next.js, TypeScript
Data Layer
SQLAlchemy, SQLModel
Infrastructure & Cloud
Radix, Azure
The middleware is designed following a service-based architecture and adheres to modular design principles. Each component—such as token-based authorization, request routing - is implemented as an independent service with a clearly defined responsibility. This ensures separation of concerns and single responsibility across the system.
The modularity allows different data services and business logic layers to be developed, maintained, and scaled independently. Business logic is completely decoupled from the middleware, making the system easier to test, extend, and integrate with new services without impacting the core middleware functionalities.
The central middleware handles:
New services can be deployed without disrupting the existing app—no coupling, no regressions
Every engineering decision impacts delivery speed, quality, and long-term maintainability. A core part of our platform philosophy was making developer experience (DX) a first-class citizen.
That’s why we built this platform with developer experience at its core - so that teams can focus on delivering value, not wrestling with infrastructure.
The middleware is fully hot-reloadable, allowing for real-time debugging and iteration without restarting containers.
Developers can inspect and test routing logic in isolation, drastically reducing turnaround time.
The Pydantic models not only enforce data integrity on the backend—they automatically generate TypeScript types for the frontend.
We delivered more than a solution. we built a secure, async-first platform that bridges developers and data scientists, and enables rapid, confident growth.
No costly rewrites
Faster delivery cycles
A scalable foundation for future products