Skip to content

Our Tech Stack - we do our own way

Curious to know how we work?

Backend:  For our backend, we use PHP! This may lead to some raised eyebrows, as PHP has been known as a hacky, scripty language. But, over the past 10 years, PHP has grown into a full-grown programming language.

We write PHP like it is Java: everything is an object, and it has strict types everywhere.

PHP is perfect because:

  • It fits nicely into our Unix stack;

  • Every request runs in a separate process, meaning it’s practically impossible to mix state between requests;

  • It’s an interpreted language, so you don’t have any compile time.


The perfect database companion for PHP is still good ol’ MySQL. In addition to this, we use AWS’s OpenSearch for searching and performing aggregated queries.

For caching and queuing, we use Redis: a high-performance, in-memory data store that is incredibly fast.


Because we wanted to build a bank from scratch in PHP, with security naturally being one of the most important aspects, we’ve chosen to build a custom framework.

This framework uses a standard Model–View–Controller structure. Besides treating everything as an object, what makes it unique is the leverage of code generators. Developers write definition files for the models, views, and controllers, and a code generator writes all the standard boilerplate code. That way, the developer can focus fully on the business logic — the interesting part!

Continuous Integration and Continuous Deployment

All the things we build, go to production - so to our users - as fast as possible. When coding is done, the pipelines are successful, the code is reviewed, and it’s tested by our Quality Assurance team, we immediately deploy the code. All of this is done with the help of GitLab pipelines, and AWS EC2 instances.


For our frontend, we use React. Huge in the frontend world, meaning it’s familiar to many enthusiastic developers looking to join the team.


A couple of years ago, all frontend projects were completely re-written, from the ground up. We took the lessons learned from the backend and applied them to the frontend. It leverages code generators, too, allowing the developers to focus on writing business logic.

Aside from this, it forces a unified way of working: once you understand the structure, you can read any part of the code with ease. This is great, because it makes our developers very versatile, allowing them to work on any part of the product.


Our iOS app uses native UIKit through and through. This means we can code the best iOS app possible, in the way that Apple originally intended. No weird cross-platform abstractions, no extra API overhead.


By leveraging the Model-View-Controller structure throughout the vast majority of the app, we make it easy to have an app that is modular and still keep the code structure easy to understand. Every feature feels like its own little branch of the app, while still being able to leverage all our common View layouts and API structures.

We also have plenty of common API, business logic, and flow coordination structures to help users build features and their respective configuration flows easily. You can pretty much follow the existing structure like a recipe and end up with a new feature very quickly.


Our Android app is mainly written in Kotlin, with some Java classes left from before Kotlin was a thing. Most of the app is written in MVP architecture, with XML layouts for activities and fragments. However, we have recently started adopting Jetpack Compose, and are writing all new activities and custom Views using that. With the switch to Compose, we have also started adopting an MVVM architecture to allow for even better separation between view and business logic.


We use a powerful custom-built architecture for flows using fragments and a viewModel / router combo for control and data management. This is used throughout the app in flows from creating an account to ordering a card. Because of the extensive set of existing architecture, common views and a strong adherence to style consistency, our Android developers can iterate very quickly and build new features at blazing speed.

Additionally, we built an extensive CI/CD system that manages and automates most administrative tasks based on git hooks and pipelines, keeping your status and progress up to date without requiring manual input.

The result is that, as a developer, you can focus on what you do best by taking data and managing UI states, with as little boilerplate code needed as possible.

Wanna join this journey to making Eva's life easy?