About

Self-taught (Docs don't count)

I was writing code before I ever got to university. I started in 2019 with C# and Unity, building games, because I loved playing them and wanted to understand how they worked. Technology fascinated me generally: software came easily to me, and I spent a lot of that time reading through hardware and software topics on Wikipedia and Wikiversity, just because I wanted to know more.

Like a lot of Nigerian kids, what I studied at university wasn't really my choice. My parents wouldn't let me study computer science, so I studied something else instead. That never stopped me though. I spent those years jumping between whatever I was curious about: Figma, Canva, other online design tools, then building sites for clients with low-code tools like WordPress, Framer, and Shopify.

Towards my final year, I decided to stop treating it as a side interest and actually learn TypeScript/JavaScript properly, along with the rest of the stack. It didn't take long after that before I was working on real projects, and that's how I got here. I choose to learn TypeScript/JavaScript because of its versatility and the vast ecosystem around it. Jeff Atwood put it best: Any application that can be written in JavaScript will eventually be written in JavaScript.

I build softwares fast with AI agents doing a lot of the heavy lifting. That's genuinely how I hit 10x speed, and I don't try to hide it. But the decision and judgment stays mine: I review every diff, debugging is where I actually earn my keep and security for me isn't an afterthought but the first thing I doubt about anything I'm about to ship.

Outside of code, I play a lot of chess. My rating on Lichess is between 1780 and 1850, which puts me ahead of roughly 80 percent of online players, and I still love the game as much as I did when I started.

I'm currently looking for a full-time remote role.

Stack

  • The default for everything I write. Strict types catch the mistakes an AI agent, or I, might otherwise ship straight to production.

  • My go-to for APIs. Fast by default, and its schema validation is the first line of defense against bad input before it touches business logic.

  • My default for frontend work. App Router and RSC keep data fetching close to the server, which cuts down on the client-side bugs.

  • EAS build makes it easy for me to compile app binaries into installable Android and iOS apps without needing local native tools.

  • How I keep styling consistent without a design system team. Utility classes make it obvious what a component looks like just from reading the JSX.

  • My database of choice, and where I put real security work: row-level security and SECURITY DEFINER functions (not just application-layer checks).

  • For caching and anything that needs to be fast and short-lived. Also the backbone for queues once BullMQ is in the picture.

  • How I handle background jobs and retries: payment webhooks, notifications, anything that shouldn't block a request.

  • Where I run things when I want full control and a predictable bill, for the parts of a product that don't need to scale elastically yet.

  • I use this to store Docker images for my self-hosted deploy layer, Dokploy, keeping images close to the source code and CI/CD pipeline.

  • My self-hosted deploy layer on top of Hetzner box. Gives me Vercel-style deploys without the price lock-in or the cost at scale.

  • For managed services when they're the right fit, so I use it deliberately and not by default.

  • Same reasoning as GCP: used where its specific services fit the problem, not because it's the industry default.

  • How I keep local environments and deployments consistent, so it works on my machine' stops being an excuse.

  • My CI. Tests and checks run before code reaches production, including a second look at anything an AI agent wrote.

  • This is where frontend projects live when I don't need the full infra overhead setup Dokploy gives me.

  • My test runner. It's fast enough that I actually run it locally instead of waiting for CI, and it works with both frontend and backend.

  • This includes language-specific formats like Markdown, YAML, JSON, TOML (supabase config)... Others tools like Figma, Wordpress, Framer, etc.