The systems everything else stands on: payment rails, security, ticketing, infrastructure and AI. Mostly Go, with TypeScript, Python and Rust where they fit. Each one a human problem taken seriously.
Products real people use. Live today.
Each one is running in production. Open the live site, or read how it was built.
Cross-border payments infrastructure: one API across stablecoin, Lightning and traditional banking rails.
A safer way to rent property: verified listings, controlled access and legally backed agreements.
liveDigital health platform for seniors: care, volunteers and learning in one system.
Run an entire school from one platform: grading, enrolment, staff and communication.
liveOne tap, application sent. AI job matching that tailors every resume and cover letter.
liveSponsor a future, one fee at a time: anyone, anywhere, can fund an African child's education.
Backend systems first. Go for the parts that have to be right.
Backend-first systems carried all the way to production. Correctness under concurrency is the recurring theme, and I own the rest of the stack so the thing actually ships.
High-throughput worker pools, lockless channel coordination, and row-level pessimistic locking (SELECT FOR UPDATE). Zero double-spend tolerance, sub-millisecond p99 latencies, and distributed idempotency keys for financial-grade execution.
Strict transactional state machines, temporal event-sourcing, Redis Bloom filter deduplication, and append-only cryptographic audit logs. Engineered for banking regulatory scrutiny where discrepancies are mathematically intolerable.
Declarative multi-region Terraform IaC, container hardening, zero-downtime rolling cutovers, and Kubernetes orchestration. I design, provision, secure, and monitor production fleets myself, not just sketch whiteboards.
Next.js App Router, React 19, distributed WebSockets, and sub-100ms client interactions. While distributed backend systems are the engine, I build the full tactile product experience from data layer to the user's hands.
Models are a component. The system around them is the job.
I integrate LLMs into production backends the same way I build everything else: typed boundaries, retries, cost awareness and failure handling first, prompts second.
Autonomous agents that find, tailor and dispatch job applications.
Natural-language queries over live, versioned network scan data.
Whisper Large-v3 transcription running locally, no API round-trip.
A Go backend that calls the OpenAI API (GPT-4o) for portfolio analysis and risk scoring over on-chain data.
Models run on my own machine. qwen2.5-coder:7b for private, offline code assistance.
PyTorch and OpenAI Whisper installed for speech-to-text and model experiments in Python.
Everything else I've built, in Go, Rust, TypeScript and Python.
Client platforms, engines and tools. Filter by language.
Luxury bridal artistry showcase and high-definition video processing pipeline.
Creative arts training and youth empowerment platform for underserved communities.
Multi-tenant urban logistics dispatch and microsecond route optimization engine.
Zero-knowledge, cryptographic polling infrastructure combining a Go 1.25 Fiber engine, Signal Protocol client-side encryption, and autonomous self-healing production diagnostics.
Keeps students in class when they cannot afford the commute.
A network scanner that remembers.
Async bulk salary disbursement, built to fintech production standards.
Cloud-native ticketing where inventory cannot oversell.
Infrastructure as code with a memory-safe core and a live graph.
Rotating savings (Ajo/Esusu), multi-party bill-splitting, and automated Paystack DVA reconciliation.
Instant media compression, multi-platform media downloader, and local OpenAI Whisper Large-v3 transcription.
A Rust web framework I published to crates.io: FastAPI-style ergonomics with Actix-level performance.
Production-grade ASP.NET Core Web API with verified concurrency control to prevent inventory overselling.
Infrastructure as Code for real-time ESG calculation: sub-100ms carbon footprint telemetry on AWS.
Contributing to the ecosystem. Real fixes on real projects.
Security and correctness fixes to the Go libraries that half the internet's backends depend on.
A Rust web framework I wrote and published for anyone to use. Declare routes with #[get] and #[post], get OpenAPI docs, Swagger UI, typed state and middleware out of the box, on Tokio and hyper. It also powers my own Cowri and theflate.
#[get("/users/:id")]
async fn get_user(req: Request) -> Response {
let id: u32 = req.params["id"].parse().unwrap_or(0);
Json(User { id, name: format!("User {id}") }).into_response()
}
#[tokio::main]
async fn main() {
App::new()
.mount_routes() // auto-registers every route
.listen("0.0.0.0:3000")
.await;
}Patched a vulnerability where 15+ user-controlled tag functions (path, url, ua, body, headers, cookies…) wrote unsanitized input to the log buffer, letting attackers forge log entries with CRLF sequences. Also fixed sub-second expiration flooring in the fixed-window limiter and RFC 9110 HEAD handling.
LinearJitterBackoff reseeded a fresh rand.Source from the wall-clock nanosecond on every call, so concurrent callers in a thundering herd landed on identical seeds and synchronized backoffs. Replaced it with crypto/rand and a package-level generator, with concurrent regression tests.
Test coverage for the multipart parser's error branches, validating deterministic error bubbling and preventing silent parameter drops during malformed payload ingestion.
Fixed URL concatenation in SetBaseURL to preserve trailing slashes, keeping strict compatibility with REST endpoints that enforce trailing-slash semantics without triggering 301/308 redirects.