en

How it works

Need Any Help For Business?

Contact us for a personal offer on FinMV that is customized to your needs.

Modular by default. Services when justified.

Architecture is usually argued as a matter of taste — monolith against microservices, with one side treated as obviously correct. That framing costs money. The useful question is not which style wins, but which structure keeps your domain boundaries clear at the size you are actually operating at.

Start with the simplest architecture that keeps boundaries clear

A new investment platform has one team, one deployment and one database, and the cost of a distributed system at that stage is paid entirely in overhead: network calls where a function call would do, eventual consistency where a transaction would do, and an operations burden nobody has staff for.

So the default is a modular implementation: onboarding, offerings, investments, payments, documents, servicing and reporting live behind explicit boundaries inside one deployable system. What makes it modular is not the folder layout — it is that each module has a contract, owns its data and is covered by its own tests.

Extract a service when something justifies it

A module becomes a separate service when there is a concrete reason, and the reasons are business ones rather than architectural fashion:

  • scale — one part of the system needs to grow or fail independently of the rest
  • security — a boundary needs stronger isolation than a module inside one process gives
  • compliance — a regulator or an audit requirement demands separation of duties or of data
  • deployment — a part must be released on a different cadence or by a different team
  • integration — an external system imposes its own availability and throughput profile
  • organisation — separate teams need to own separate things without coordinating every release

Because the boundaries and contracts already exist, extraction is a planned operation rather than a rewrite. That is the point of building this way: the option stays open and stays cheap.

Asynchronous where it earns its place

Work that does not need to block a user — settlement reconciliation, document generation, provider callbacks, reporting — runs through queues. Message brokers such as RabbitMQ or Kafka enter the picture when throughput or integration topology justifies them, not as a default. PostgreSQL stays the system of record; Redis is used where low-latency caching or coordination is genuinely required.

What we do not do

We do not sell a monolith, and we do not sell microservices. Both are answers to questions nobody asked yet. We also do not build a distributed system in order to make a platform look serious — architecture theater is expensive to run and hard to hand over.

Your architecture is chosen from your scale, your regulatory obligations, your integrations and the size of the team that will operate it — and it is designed so it can change when those change.