Jumilton Dala — Founder & Developer

01 about_me

Founder.
Developer.
Both, by necessity.

/* Not because I chose two careers.
Because I needed to build what didn't exist. */

Founder Dev

I'm a software engineer and entrepreneur based in Cape Town — born in Angola, shaped by two economies. I understand what it means to have an idea with no infrastructure to support it.

That's why I build the infrastructure myself. telu started as a WhatsApp group and a spreadsheet because that's all that existed. Today it's a full-stack fintech platform — because I built it.

When a client brings me a project, they get someone who has been on both sides of the table — the founder who felt the problem and the engineer who solved it from the ground up.

I study software development while operating a live business. Every architectural decision I make is tested by the next real transaction that goes through the system.

Jumilton Dala Cape Town, South Africa · From Luanda, Angola

02 featured_work

From WhatsApp
to production system.

origin

The problem lived first

As an Angolan in South Africa, I needed to move money between AOA and ZAR. The existing systems were unreliable or didn't exist for people like me. So I started doing it myself — manually, via WhatsApp.

A spreadsheet and a WhatsApp group

I was the system. I tracked suppliers, clients, rates, and margins in Google Sheets. It worked — but it couldn't scale and couldn't be trusted by someone who didn't know me personally.

v1→v2

Built the technology around the business I already understood

Because I lived every edge case and failure mode, the architecture I designed wasn't theoretical — state machines, audit logs, trust scoring, automated timeouts.

From a counter to a network of routes

Restructured the platform around published routes: verified operators declare their own rate, limits and available liquidity, and the sender compares what's open and chooses. Role-based worlds for client and operator, over a transaction state machine with instant local rails — Multicaixa Express on the AOA side, instant payment on the ZAR side.

now

telu — live and operational

A production-grade P2P cross-border FX platform with real partners and real rails. Built from scratch, by one person, because no one else was going to build it for the problem I actually had.

LIVE IN PRODUCTION · 2023 — Present

teluFinancial Systems

● operationalv3.0.0

P2P cross-border money routing — AOA ↔ ZAR. Verified operators publish routes with their own rate, limits and declared liquidity; the sender compares what's open and picks. Underneath: a transaction state machine, KYC gates, collateral that caps what an operator can carry in flight, trust scoring, a commission settlement ledger and full audit logging.

Java 17Spring Boot 3PostgreSQL 15FlywayJWT AuthNext.jsTypeScript

MatchService.java

1public MatchResult match(ExchangeRequest req) {

2  // instant rail ↔ instant rail, or no deal

3  var rails = findActiveAccounts(req.method());

4  if (rails.isEmpty()) return MatchResult.unmatched();

5  enforceDailyCaps(req, referenceRate());

6  auditLog.record(req, AuditEvent.MATCHED);

7  return MatchResult.of(pick(rails), req);

8}

source files

188 Java classes

database

19 tables · 19 migrations

test suite

306 tests · all passing

corridor

AOA ↔ ZAR

status

Live & Operational

Not a mockup. The system running.

captured from the live build · demonstration account

app.telu / home

telu home screen: the route network promise, live routes between Angola and South Africa.

The money finds the right route

telu is a network of routes, not a counter. Verified operators publish their own rate; the sender compares what's open and picks. The promise on the front page is the one the system has to keep.

/login

You choose your side of the route

Client and operator don't share a dashboard with hidden buttons. Each enters its own world, with its own narrative, permissions and obligations.

/registar

telu account creation screen with identity document requirements for KYC.

Compliance is a gate, not a badge

Identity is asked for at the door — ID or passport, validated by format before it's stored. No verified identity, no operation: enforced in the backend, not hidden in the UI.

/market

Public routes, public trust

Rate, limits, available liquidity and the operator's trust score are visible before anyone commits money. An operator can't promise more than they declared — and trust is a number the system earns, not a favour.

build_journey

From blank schema
to the screen you can use.

The overview above is the result. This is the path to it — each phase of building telu, one commit at a time, scroll until you reach the live screen.

phase_00 · discovery

The problem, mapped before a line of code

Every edge case came from running the operation by hand — suppliers, clients, rates, margins, failure modes. The blueprint wasn't theoretical; it was the real business written down.

domain modelingflowsedge cases

phase_01 · architecture

The data model that holds the money

The schema came first: transaction state machine, audit logs, trust scoring and a settlement ledger — designed so no record can lie about what happened.

PostgreSQL 1519 tablesFlyway migrations

phase_02 · backend

The routing engine at the core

The heart of the platform: only route an order to an operator who is verified, has an instant rail and has the liquidity to honour it — or refuse it. KYC gates, collateral limits and full audit logging enforced in the backend, not the UI.

Java 17Spring Boot 3188 classes306 tests

phase_03 · frontend

The network given a face

Client and operator each got their own world — separate narratives and permissions, not one dashboard with hidden buttons. Rebranded end to end as telu: the route glyph, the warm paper, the orange that runs through every screen.

Next.jsReactTypeScript

phase_04 · live in production

app.telu · /market operational

telu market screen: verified routes with rate, limits, available liquidity, trust score and estimated time.

This is where the scroll ends — and the real one begins.

Everything above becomes this: real routes, open right now, with the rate, the limits, the liquidity actually available and the operator's trust score. Not a mockup — the network running.

03 endila_studio

The infrastructure
where ideas
become systems.

Endila is not an agency. It's the operational layer I built to take an idea through its full journey — from problem discovery to working product. Every project follows the same discipline: understand the problem, design the structure, execute with precision.

/* Technology has real impact
only when it is well structured
and executed with competence. */

telu

P2P cross-border money routing — AOA ↔ ZAR. Built from a WhatsApp operation into a formal fintech product: a public route network with verified operators, KYC and full audit infrastructure.

FINTECH · LIVE

Lucas — African Liquidity Operator

B2B operational infrastructure for FX liquidity routing in Africa. Human operators, WhatsApp flow, KYC, real-time state machine, and fraud prevention.

FINTECH · IN DEVELOPMENT

Elyra Studio

Client intake and project qualification system — turning the discovery process into a structured, repeatable workflow for founders and builders.

TOOLING · INTERNAL

[ Your Project ]

The next system built under Endila starts with your problem. Not your idea — your problem. That's where real products begin.

OPEN

04 how_i_work

fn_01()

The problembefore the idea

Most clients arrive with a solution already formed in their head. My first job is to get behind that solution and find the actual problem — because that's where the right architecture begins. A system that solves the wrong problem is just expensive noise.

fn_02()

Structurebefore features

I invest in getting the foundation right. A system built on solid architecture scales without chaos. One built fast to impress breaks at the worst moment — when real users and real money are involved.

fn_03()

Ownershipnot just delivery

I bring a founder's mindset to every project. I don't just write what was asked — I question what doesn't make sense, flag what will fail at scale, and treat your product like I built it for myself.

Jumilton Dala.

Founder.
Developer.
Both, by necessity.