At Altify, we’ve always known that the real magic in financial technology happens behind the scenes. What you see in the app is deliberately simple: choose an asset, enter an amount, and confirm your trade.

Under the hood, however, there’s a lot going on to make that moment feel effortless — especially when you’re dealing with crypto, tokenised stocks, and real-world assets from an emerging market like South Africa.

At the centre of this is our Smart Trade Order Routing System (STORS).

STORS is our proprietary execution engine. It aggregates prices, finds liquidity, and decides how and where to route every order placed on Altify — across crypto, tokenised stocks, and tokenised real-world assets (RWAs). It already powers 50+ digital assets, handles hundreds of millions of dollars in volume, and is live for 80,000+ users across our web and mobile apps.

This piece is our attempt to open the black box a little. We want prospective investors, partners, curious Altify users and even regulators to understand what STORS is, why we built it, and where it’s going.

Why Order Routing Matters More in Alternatives Than in Stocks

If you’ve traded traditional stocks, you’re probably used to a fairly standard playbook. A stock trades on a small number of main exchanges. Your broker’s order router looks for the best price across those venues and sends your order there. Clearing and settlement are fairly predictable.

In crypto and tokenised assets, the playing field looks very different.

There’s often no single “home” exchange for an asset. 

Liquidity is scattered across centralised exchanges, institutional Over-The-Counter (OTC) desks, and, increasingly, on-chain decentralised protocols and tokenisation platforms. Many assets don’t trade in size at all times, prices are inconsistent from one venue to another, and as an emerging market platform, we’re also dealing with currency pairs like ZAR–USDT or ZAR–BTC, which are rarely supported natively in a deep, liquid way.

So trade and order routing in this world is not just about asking, “Where is the best price?” It’s also about asking:

• “Where is there actual liquidity?”

• “Which venue can we safely use for this asset?”

• “How do we move between ZAR, USD, stablecoins and tokens in a way that’s efficient and compliant?”

• “How do we respect our own risk, treasury and policy constraints while doing all of this in real time?”

That is the problem space STORS was built to operate in.

A Quick Primer: What is Smart Order Routing?

Before we get into Altify’s specific implementation, it’s worth briefly defining smart order routing.

Smart order routing (SOR) is an automated process that looks across multiple trading venues and decides how to execute a trade to achieve the best overall outcome. That outcome might mean the best price, the lowest total cost (including fees and spreads), the fastest execution, or the best way to fill a large order without moving the market.

In more sophisticated systems, routing isn’t just “all or nothing” to one place. It can:

• Compare bid/ask prices, fee structures, and depth at several venues.

• Split a single order into smaller pieces.

• Send those pieces to different exchanges or liquidity providers.

• Time the execution to minimise slippage or track an average price.

• Increase liquidity in low liquidity assets by splitting up the order.

Traditional equity markets have had smart order routing for years. But those systems are optimising within a fairly standardised universe of trading venues and rules. In the digital asset space, especially in crypto and tokenised RWAs, the environment is much more fragmented and far less mature.

This is where we felt we needed to build something purpose-built, not just repurpose an equities playbook.

What STORS is (and Who it Serves)

STORS is Altify’s Smart Trade Order Routing System. It’s a proprietary engine that:

• Aggregates and normalises prices from multiple exchanges and institutional counterparties.

• Builds internal “virtual” collated order books for hundreds of pairs.

• Vastly increases available liquidity on assets via its “virtual” collated order books, especially in ZAR-paired assets.

• Determines the best path to execute each client order.

• Routes those trades across crypto venues, tokenisation platforms, and fiat/FX rails.

• Integrates with our policy engine, risk engine, and treasury management system so that every route respects more than just price.

Today, STORS handles:

• Crypto trades for our users (for example, ZAR → BTC, USDT → SOL).

• Emerging market FX-to-crypto pairs, with a special focus on ZAR/USDT and ZAR/USDC.

• Tokenised public equities and indices, such as Robinhood, Coinbase, S&P 500, and more.

Looking Forward

STORS is being extended to become the common routing execution for all tokenised assets and markets, where liquidity may sit with a small number of specialised platforms rather than a central exchange — assets such as:

• Tokenised Treasuries and other fixed income RWAs.

• Tokenised private credit and alternative yield products.

• Prediction markets and event contracts.

You can think of it as Altify’s execution nervous system: every trade, every asset, every venue, all coordinated from one place.

How STORS Sees the Market

The first thing STORS does is build a live picture of the market that is better than any single exchange.

We maintain connections to multiple venues — exchanges, OTC desks, and, in the future, tokenisation platforms and on-chain protocols. From those connections, we continuously collect:

• Order book data (bids, offers, and sizes)

• Trade prints and price ticks

• Fee schedules

• Latency and reliability information

• Asset Balances
  

This data is fed into a set of internal order books that are denominated in different base currencies and, when necessary, synthetically constructed.

For example, if we want to offer our users a SOL/ZAR market and there is no deep, native SOL/ZAR pair anywhere, STORS will build it from components such as:

• SOL/USDT

• BTC/USDT

• BTC/ZAR

A simplified price relationship might look like this:

SOL/ZAR = (SOL/USDT ÷ BTC/USDT) × BTC/ZAR

The same principle applies when we price tokenised stocks or RWAs for a client:

• Underlying might be USD-denominated, trading on a specific platform.

• We may route via USDT or another stablecoin.

• The client is looking at the end result in ZAR, EUR or GBP.

STORS takes care of all these conversions so the user sees a coherent, local currency price, even when the actual execution path is multi-step and multi-venue.

From Quote to Execution: What Happens When You Trade

When you open the Altify app and request a quote — say, “Buy R20,000,000 of SOL” — a lot happens in a few hundred milliseconds.

1. We interpret your intent.
   You’ve told us the asset, direction (buy/sell), and the notional amount in your local currency.
   
   
2. STORS builds or updates a synthetic market.
   It calculates the current fair price of R20,000,000 SOL in ZAR based on:
   
   • The latest prices and liquidity from the relevant platforms.
   • The relevant FX rate path.
   • Fees and spreads along the execution chain.
     
     
3. The routing engine explores possible paths.
   STORS doesn’t just look at one venue. It considers:
   
   • Whether we already have access to inventory (through other client orders).
   • Which external counterparties have the best price and available liquidity.
   • What the effective all-in cost would be for each route.
     
     
4. Policy and risk rules are applied.
   Before we commit to a route, the system checks:
   
   • Whether the chosen venue is allowed for that asset and jurisdiction.
   • Whether we’re within our exposure limits for that counterparty.
   • Whether there are any size or concentration constraints we need to respect.
     
     
5. You see a live, executable quote.
   On your side, this is a simple number: a price in ZAR and the amount of the asset you would receive. We hold that quote firm for a short window — typically around 10 seconds — while you decide whether to accept it.
   
   
6. If you accept, STORS executes the route.
   At this point, the engine sends the required orders to the external venues or matches you with internal inventory, performs any FX conversions or on-chain transactions required, and confirms execution.
   
   
7. Treasury and settlement are updated.
   Our treasury management layer then ensures that:
   
   • Fiat balances across banks and currencies are updated
   • Token balances across custodians, users, exchanges, and platforms reflect the new state
   • Any residual exposures are reconciled and aligned with our internal targets

The end result for you is simple: your portfolio updates, and you hold the new asset. But behind that smooth experience was a small flurry of routing, risk checks and treasury adjustments.

The Policy Engine: Embedding Rules Into Routing

One of the key design decisions we made with STORS was to make it policy-aware by design.

In traditional smart order routers, the main objective is usually best price and speed. In our world, those are necessary but not sufficient. We also need to encode:

• Which venues are allowed for specific asset classes.

• Which platforms can be used for particular RWAs (e.g. regulated tokenised Treasury platforms).

• Maximum per-venue exposures.

• Jurisdictional rules around where client orders can be executed.

Rather than manage these rules manually, we built a policy engine that sits alongside the router. This engine expresses our business, regulatory, and risk constraints in machine-readable form.

Over time, the policy engine will help guide STORS in considering routes — it doesn’t just ask, “Is this cheaper?” It also asks, “Is this allowed?” and “Does this keep us within our risk and compliance boundaries?”

This is particularly important as we expand into:

• Tokenised government bonds and Treasuries.

• Tokenised private credit and other yield-bearing RWAs.

• Partnerships where banks or wealth platforms rely on us to execute on their behalf.

In those contexts, it’s not enough to find a good price, we have to be able to demonstrate that every route we take is consistent with the agreed policies.

The Risk Engine: Managing Counterparties and Stress

Routing across multiple venues brings obvious benefits: better prices, more liquidity, and redundancy if one exchange goes down. But it also introduces counterparty and operational risk.

Our risk engine is responsible for monitoring and managing these risks in real time. It tracks:

• How much exposure we have to each exchange, OTC desk or RWA platform.

• Show when internal limits are exceeded on each counterparty at an overall value level and single asset level.

 Over time, the risk engine will begin to track:

• How those venues behave during volatile periods.

• How often they experience downtime, delayed settlements or pricing anomalies.
  

If a particular venue starts to look risky — for example, it behaves erratically during market stress — the risk engine can signal the policy and routing layers to deprioritise or temporarily avoid that venue. That way, STORS becomes not just a way to optimise price, but also a mechanism for actively steering around emerging risks.

This becomes even more crucial in the RWA world. When assets represent claims on off-chain collateral — such as real estate, private credit or government bonds — you’re not only relying on a trading platform, but also on an issuer, a custodian, and a legal structure. Being able to encode and respond to risk information about those layers is a key part of the system’s evolution.

Treasury Management: Closing the Loop Between Routing and Balance Sheet

Every trade routed by STORS has a treasury footprint.

If we’re regularly routing ZAR into USD stablecoins and then into tokenised assets, we need to manage:

• How much ZAR sits in our segregated client bank accounts.

• How much USDT or USDC sits in our segregated digital wallets (hot and cold wallets).

• How much inventory we hold in specific tokens or RWAs. 

• How much of each asset is stored where.

• How our currency and asset exposures line up with our internal limits.

STORS connects directly into a treasury management system that tracks these balances and sets targets. Over time, this will allow us to do things like:

• Prefer routes that move us closer to desired treasury allocations.

• Take advantage of natural internal matching (for example, one client selling what another is buying).

• Reduce unnecessary FX conversion when liquidity allows.

• Automatic rebalancing of liquidity and counterparty exposures.

For large partners and institutional clients, this integrated view of execution and treasury is a big part of the value proposition. They don’t just want us to find good prices; they want to know that the whole stack — from routing to settlement to on-chain custody — is being managed coherently.

Extending STORS to Tokenised Stocks & RWAs

While STORS was initially born in the crypto market, it is deliberately being extended to tokenised stocks and tokenised real-world assets.

The pattern is similar:

• Tokenised stocks might trade on one or more specialised platforms rather than a central exchange. Liquidity is fragmented, and pricing needs to be constructed from underlying equity markets plus the tokenisation layer.

• Tokenised RWAs — such as money market funds, Treasuries or private credit — often have even more complex structures. There may be subscription and redemption cycles, daily or weekly liquidity windows, and platform-specific rules.
  

In both cases, STORS provides three core services:

1. Price discovery in local currency
   We combine underlying asset prices, FX, and platform terms into a live, client-facing price in ZAR, EUR, GBP or USD.
   
   
2. Route selection and execution
   We decide whether to fulfil the trade from inventory, from a particular platform, or by combining multiple sources of liquidity, all within the constraints of policy and risk.
   
   
3. Ongoing management
   We reconcile positions across chains, platforms and custodians, and feed the results back into our pricing, risk and treasury systems.
   

This is where we see STORS growing in importance over the coming years. As more assets become tokenised, and more platforms emerge, having a single, intelligent routing and pricing layer becomes essential.

Why We’re Sharing This

Most users never need to think about STORS. They shouldn’t have to. If we do our job well, they simply see clear prices, tight spreads and fast settlement.

But for curious users, prospective investors, institutional partners, and regulators, the engine matters. It’s the difference between a simple front-end on top of a single exchange, and a genuine piece of financial infrastructure that:

• Normalises access to multiple venues.

• Embeds policy and risk into every execution decision.

• Bridges emerging market currencies into global crypto and tokenised asset markets.

• Scales from a retail app to bank-grade integrations.

STORS is an evolving system, built to handle complexity that doesn’t exist in traditional equities, and we’re continuing to invest in it as tokenisation broadens into more asset classes.