At Altify, our goal is simple: to help everyday people grow their wealth through investments in alternative asset classes and emerging sectors. To achieve this, our platform needs to be reliable, fast, and adaptable. As we grew, it became clear that our original system wasn’t keeping up with the demands of more users, new features, and the fast pace of the financial world. To address this, we made a big change — we moved from a monolithic system to a microservices architecture.

But what does that mean? Let’s break it down and walk you through our journey.

The Early Days: Why the Old System Fell Short

Initially, Altify's platform was monolithic, where all components — from user logins to investment processing — operated within one unified structure. Although this setup worked well in the beginning, it became increasingly inefficient as the platform expanded.

Here’s what we encountered:

1. Hard to Scale

Imagine a car with a single engine that powers everything — from the wheels to the radio. If one part needs more power, you’d have to boost the engine for the whole car. Similarly, when one part of our platform needed more resources, we had to scale the entire system, even if only a small part was busy. This wasn’t efficient.

2. Slow Updates

In a monolithic system, updating one small part means updating the entire thing. If we wanted to add a feature or fix a bug, we had to test everything, which took time. This slowed our ability to introduce new features quickly.

3. Limited Flexibility

Minor changes often involved reworking several unrelated parts of the system, making innovation a slow process.

4. Complexity

Because all the logic was bundled into one big project and pieces of code, there was massive interdependency between code which would result in undesired errors or breaks in other sections of the project that were not intended.

Why We Switched to Microservices

We needed a system that could grow with us — a platform capable of independent scaling, faster updates, and reduced complexity. That’s where microservices came in. Instead of having one big system doing everything, microservices allowed us to break the platform into smaller, independent services, each with its own job.

Here’s how microservices helped us solve our problems:

1. Independent Scaling

In a microservices setup, each service is like its own mini-engine. If one service, like user login, gets more traffic, we can scale just that service instead of the whole system. This makes it much more efficient.

2. Faster Updates

With microservices, our development teams can work on different parts of the platform separately. This means we can release updates and new features faster because we don’t have to update the whole system every time. If there’s a new feature for the mobile app, for example, we can update just the mobile service.

3. More Resilient

Problems in one area no longer bring down the entire system. Each microservice is insulated from the others, meaning fewer interruptions.

4. Independent Risk

By breaking the systems down into core business rules, the undesired impacts are limited. Due to our ability to focus on a specific set of features or code related to business logic or a feature, the risk of breaking something down the line, unintentionally was mitigated.

How We Made the Switch

Switching to microservices required thoughtful planning. We needed to divide our monolithic platform into smaller, independent services while ensuring they worked seamlessly together.

Here’s how we tackled it:

1. Public Sites: This includes everything users interact with, like our web dashboard and mobile app. These are built using modern technology that allows us to update them independently.

2. Core Services: These handle the important business functions, such as user authentication and processing transactions. Each of these services can be updated separately, making them easier to manage.

3. Utility Services: These handle things like logging, tracking errors, and caching data. These services support the entire platform but are kept separate, so they can be updated or fixed without affecting other parts.

4. Integrations Services: These handle any external integrations into providers, things like KYC providers or rates providers. These services enable us to have an agnostic system meaning we are not at risk of any of our providers changing their systems, as we mutate the incoming and outgoing responses.

The Technology Behind It

We also adopted several new technologies to make sure our microservices system worked efficiently. For example, we used .NET Core to build our back-end services and RabbitMQ to help the different services talk to each other. This allowed us to make sure that our platform remained fast and responsive.

Challenges We Faced

Switching to microservices was a big improvement, but it wasn’t without its challenges:

1. Data Consistency

In our old system, keeping data in sync was easy because everything was connected. In microservices, each service has its own database, so we had to make sure that data stayed consistent across all services. To solve this, we used a system where services could send messages to each other in real-time to keep everything in sync.

2. Communication Between Services

Since microservices are separate, we had to make sure they could communicate effectively. We set up systems for them to send messages and data back and forth without delays.

3. Security

Security is always a top priority, especially when dealing with people’s money. In a microservices setup, each service needs to be secured independently. We used JWT-based authentication, which is a system that ensures that only authorised services can communicate with each other, keeping user data safe. We also have robust firewalls and detailed tracking, logging and alerts for any incoming or outgoing traffic to our services.

The Benefits: A Platform Built for the Future

Now that we’ve fully transitioned to microservices, Altify’s platform is stronger and more flexible than ever. Here’s what we’ve gained:

1. Scalability

Our platform is now better prepared for future growth. As more people join and we add new features, we can scale individual services based on their needs. This means we’re ready for whatever comes next.

2. Faster Innovation

Microservices have sped up our development process. We can now develop and release new features faster, keeping up with the fast pace of the financial markets and meeting our users’ needs more quickly.

3. Improved User Experience

Because microservices operate independently, platform updates cause fewer disruptions. We can roll out updates or fixes without affecting the rest of the system, ensuring a smooth experience for our users.

Looking Ahead

At Altify, we’re always looking for ways to improve. Moving from a monolithic system to microservices was a huge step forward in building a future-proof platform. This change allows us to innovate faster, provide a better user experience, and handle growth more efficiently.

But we’re not stopping here. As technology evolves, so will Altify. We’ll continue to refine our systems, ensuring that our platform empowers everyday investors to grow their wealth now and in the future.