Bitcoin broker backend for Relai

The project: highly available Bitcoin brokerage

Relai AG needed a fast, secure API and backend service to handle the buying and selling of Bitcoin for their investment app. The central challenge was building a robust system from nothing that ties together complex financial integrations (banks, exchanges, credit cards), scales, and serves the in-house frontend team through a dedicated REST API.

The solution: a microservice architecture in Go and Python

devs group was engaged to build the technical foundation for the Bitcoin broker. With a clear focus on scalability and integration, we moved the project decisively forward.

Microservice architecture: we built the system as 17 dockerised microservices, 11 of them in Golang and 6 in Python.

Central communication: to keep communication between services reliable and fast, we introduced a central message broker (RabbitMQ) and used PostgreSQL as the persistent database.

Comprehensive integrations: we integrated the interfaces that financial traffic depends on, including the APIs of three large crypto exchanges (Kraken, Bitfinex), the API of Swiss banks, and a credit card gateway (checkout.com).

Internal API: the whole system is driven through a dedicated internal REST API. It serves Relai AG’s frontend team as a secure, stable endpoint through which end users can buy and sell Bitcoin.

The result: a scalable, secure foundation

With this microservice backend and API built by devs group, Relai AG has a modern, scalable and future-proof system. It is the technical basis for safe, frictionless Bitcoin trading, and it delivers both maximum reliability and fast transactions.

Frequently asked about this project

Why microservices rather than a monolith?

Because the integrations dictate the system: exchanges, banks and the credit card gateway each have their own failure patterns and their own cadence. Seventeen dockerised services with RabbitMQ between them isolate those failure sources. When an exchange API goes down, work backs up in a queue instead of stopping trading altogether.

How long did development take?

Nine months from zero to a production broker, with two devs group engineers. The backend was fully functional after six months; the remaining time went into integrations, hardening and the go-live.

Why mix Go and Python?

Go carries the eleven services where reliability and concurrency decide the outcome: order handling, exchange connectivity, account management. Python takes the six services where library depth matters more than latency. The choice follows the problem, not a preference.