Available — backend roles, remote Lagos, Nigeria

Daniel Ude

Backend engineer. I build the systems that stay up when it matters.

4+ Years shipping backends
248 Tests, largest system
40 Developers trained
15 Client projects delivered
01Position

Async Python, built test-first

Four-plus years building APIs in Python and FastAPI — a crash-detection pipeline for a live game, multi-tenant clinical and document-processing backends, and APIs for 15 freelance clients. I design the schema and the API, write the tests first, and set up the CI that runs them.

My largest system carries 248 passing tests, run by GitHub Actions CI against PostgreSQL 16 and Redis 7 service containers. I care about the part most portfolios skip: what the system does on the bad path — when the model times out, when the token expires mid-socket, when a user asks for another hospital's patient.

I came to engineering from a law degree, retrained, and in 2026 led a backend cohort of 40 developers — writing the curriculum, reviewing code, explaining why an architecture holds rather than just how to type it. That route is also why picking up something unfamiliar fast is the normal case for me. Most recently that meant writing the backend for a Web3 hackathon project, having never written one before.

02Experience

Software Developer & Technical Facilitator SBTS Technology Limited, Enugu

Jun 2026 — Oct 2026 · Contract

Led a backend engineering cohort of 40 developers in Python, REST APIs, FastAPI, PostgreSQL and Git — 30–35 in-person sessions and 40+ live online sessions; 34 of the 40 completed. Wrote the curriculum and did 20+ code reviews.

Guided the teams through two projects whose APIs the frontend cohort integrated: a job-recruitment platform and Vendora, a multi-vendor marketplace. Co-built the backend of a QR-code attendance system used by about 120 students.

Backend Engineer Tenece Services Ltd

Feb 2025 — Feb 2026 · Contract

Overhauled the crash-detection pipeline for Nautical Fury, an in-house game with 4,000+ installations: a FastAPI endpoint queues 2,000–4,000 crash and error events a day to Celery workers. Worked with the lead developer to attach diagnostic context to each event, so the team could reproduce and investigate failures.

Introduced CI/CD where none existed: tests, type checking and linting gated every push and passing builds deployed automatically, so failures were caught before release. Moved the pipeline to test-first development, set up Sentry for crash and error monitoring, and load-tested it with k6.

Freelance Backend Developer

Dec 2021 — Mar 2025

Built and maintained REST APIs and backend services for 15 clients across software and technology projects — data modelling, business logic and third-party integrations in Flask, FastAPI, SQLAlchemy and PostgreSQL — plus database and automation scripting, and debugging inside existing client codebases.

Education

2016 — 2025

Diploma in Backend Engineering, AltSchool Africa (2024–2025). Bachelor of Laws (LL.B.), Enugu State University of Science and Technology (2016–2021).

03Systems

Puente

Web3 · Live

A peer-to-peer naira ↔ USDC exchange on the Africa ↔ Bolivia corridor: local agents handle add-money and cash-out for Pollar wallets, and a Stellar escrow holds the USDC between the two legs. Either side can send first, because whoever moves first is never the side carrying the risk.

The whole design turns on one awkward fact: the other leg is a bank transfer the server will never see. So the escrow moves on evidence only — USDC is locked up front and released when the counterparty confirms, and a disputed order freezes on purpose. No timer advances it and no action is offered to either party, because whether naira actually arrived is not something the system can know. An operator settles it against the receipt.

The backend is functional core, imperative shell. Every rule — who may act on an order and when, what it costs, what an agent's float allows, whether a Stellar payment really funds a cash-out — is a pure function over immutable records in domain/, with no await, no I/O and no clock; now is passed in. Postgres, Stellar and Pollar sit at the edges and are handed to services explicitly. Enforcement and the actions the UI offers read the same state-machine table, so the buttons a user sees cannot drift from the rules the server applies.

I wrote the backend, and wired a teammate's Next.js UI to the real API, by directing AI coding subagents in a test-first loop: I defined the behaviours and approved every test list before code was written. 64 tests cover failed, short and duplicate payments, expired orders and refund windows.

Paying the same person twice is the failure that costs real money, so it gets its own decision layer: the Stellar gateway reports what the chain shows, a pure function judges it, and a second payout is reachable only by an operator marking the first one bounced — never by either party claiming a transfer failed. A public, sign-in-free proof page shows live escrow reserves against every agent's liabilities, each settled order linked to its on-chain transaction.

CustomerPollar wallet Puente APIFastAPI · pure domain Agentfloat in escrow Stellar escrowUSDC · server-signed /api/proofpublic · sign-in free order queue lock / release naira · bank transfer · off-system
The escrow is the only leg the server controls — which is exactly why the bank transfer is the only thing left to dispute.
0 I/O in the domain layerStellar · USDC escrowPostgreSQLNext.jsLive demo

Intentra

Web3 · ETHOnline 2026 hackathon

I owned the backend for a four-person ETHOnline 2026 submission — my first Web3 project. Teammates built the frontend.

Intentra ties every payment to what a person actually authorised and what was actually delivered: the AI proposes, the human signs an EIP-712 mandate, USDC sits in a Solidity escrow on the Arc testnet, delivery photos are hashed and anchored on-chain, and a disputed job settles only on a split both parties signed. I built the FastAPI modular monolith that orchestrates it — the trusted coordinator that never holds funds.

The engineering discipline is the part I'd point at. Transaction state changes only through a state machine with a transition table, a row lock (SELECT … FOR UPDATE), a version counter and an audit log; the tests refuse every transition not in the table. EIP-712 signature checks and idempotency keys cover the rest.

WalletPrivy · EIP-712 FastAPIorchestrator IntentraEscrowArc · USDC transactions.state event watcher signs mandate createIntent fundIntent emits IntentFunded IntentResolved applies money state is never written here
Money states commit on chain events only — the API requests, the watcher applies.
150 testsEIP-712 · Solidity · The GraphFastAPI · PostgreSQL

PatStat

Healthcare · Real-time

A multi-tenant patient status platform. Clinical staff update patient state; families get push notifications when it changes. Each hospital is a tenant: every route scopes its queries to the user's hospital, and tests check that one hospital can't read another's patients.

Ships with role-based access control, WebSocket live updates behind a token watchdog, shift-handover workflows, emergency flags, a super-admin backoffice, and five dedicated documents covering architecture, security and operations.

clinical staff APItenant guard ward dashboards Celery family phones update WebSocket · live FCM every path re-checks hospital_id
One status change, two delivery paths — both scoped to its hospital.
248 tests31 test files12 migrationsFastAPI · Celery · Redis · FCM

DocFlow API

Multi-tenant · LLM

An LLM document-extraction API for multiple tenants. Upload a PDF, image or DOCX; get structured JSON back by async polling or webhook callback.

Schema-driven extraction runs through an LLM map-reduce pipeline with layered reliability, so a single model outage never permanently blocks a job. Redis Bloom filters catch duplicate uploads before they cost anything. API keys are stored as SHA-256 hashes and job queries are tenant-scoped.

uploadPDF · DOCX chunker LLM extract LLM extract LLM extract merge JSONstructured splits past the context window circuit breaker · 3 retries, exponential backoff · JSON repair
One model timeout cannot strand a job — each chunk fails and recovers on its own.
24 testsCelery workersMinIO (S3-compatible)Webhook callbacks

MediReminder API

Security-first

An asynchronous medication-adherence API with nightly reminder scheduling and multi-channel notifications (Firebase push, SMS fallback, email) — but the security model is the point: refresh-token rotation with reuse detection (a replayed token revokes every session), Redis-backed rate limiting, and Google OAuth.

Adds an adherence report, medication logging, cron-triggered reminder dispatch protected by a shared secret, and Docker packaging.

73 testsSQLAlchemy 2.0OAuth2 · JWT rotationDockerised

ICBM Bootcamp — Cohort Two

Curriculum I wrote

The backend curriculum I wrote for the cohort I led in 2026, from pure-Python fundamentals through SQLAlchemy ORM modelling to a full FastAPI REST API with routers, schemas and auth.

Written to be read: each project stands alone, with worked solutions and the reasoning behind every design choice. If you want to know how I think about code, this is the fastest way to find out.

3 progressive projectsWorked solutions40-developer cohort
04Practice
Architecture
Per-feature modules — models / schemas / service / routers — so a codebase stays navigable at 50 files and at 500. Tenant scoping and role checks on every route, with tests that try to cross tenants.
Data
Async SQLAlchemy 2.0 on PostgreSQL. Schema changes through Alembic migrations. Trigram indexes and real constraints where the query plan calls for them.
Reliability
Celery workers for anything slow. Redis for rate limits, circuit breakers and deduplication. Retry-and-fallback layers around third-party calls, health endpoints, and persisted job state so nothing dies silently.
Security
JWT with rotation, RBAC, hashed API keys, rate limiting, Pydantic v2 settings. Secrets live in the environment, never in the repository.
Proof
Pytest suites that cover edge cases and failure paths, not just the happy one. CI on GitHub Actions against real PostgreSQL and Redis.
05Stack
PythonFastAPIFlaskSQLAlchemy 2.0Pydantic v2PostgreSQLRedisCelery
DockerDocker ComposeAlembicGitHub ActionsMinIOSentry
PytestJWT / OAuth2RBACWebSocketsREST API designMulti-tenant architectureLLM integrationEIP-712Stellar SDK
06CV

Daniel Ude — Curriculum Vitae

Everything on this page on one page: experience, selected projects, writing, skills and education.

PDF · 91 KB 1 page Updated November 2026