I Used to Write Every Pixel

In October 2021 I wrote the first line of code for WeWire.

Nobody else was in the repo. Nobody else was in the company Slack, because there was no company Slack. It was just me, a laptop, and an idea about moving money across Africa that I couldn’t put down.

Today there are about twenty people on our engineering team. Twenty people who open the same codebase every morning and argue in the same pull requests. Some days I look around and still don’t fully understand how we got here.

So I want to write it down before I forget what the beginning felt like.

The boy and the computer

I started writing code when I was eight.

I didn’t know it was called that. I just knew computers did exactly what you told them, and that felt like magic. I was deeply impressed by them. Not the games. The fact that you could type something and the machine would obey. I’d sit there for hours, breaking things and fixing them, with nobody to show it to.

Somewhere in those years, Bitcoin started becoming a thing.

I didn’t care. I really didn’t. It was some strange internet money that people argued about online, and to a young boy it meant nothing. Then, slowly, I watched it start to matter. The thing I’d ignored kept coming back bigger, until it was impossible to ignore at all.

Funnily enough, my own door into it wasn’t a whitepaper. It was a TV show. I was watching Silicon Valley, the HBO show about a small startup trying not to die, and in one of the later seasons the company starts thinking about its own coin. It was played for laughs, like everything on that show. But something stuck. The idea that a coin could be designed for a purpose, not just for speculation. That pulled me back to Bitcoin, and down the road to stablecoins: digital money that holds its value, moves like a message, and doesn’t care which country you’re in.

I didn’t know it then, but that’s the work I’d end up doing.

A final-year project

By university I was building anything I could get my hands on. A little ATM simulator in C++. A CRM. A warehouse system. My final-year project was a payment gateway.

It was rough. It was mine. I look at it now and smile, because I was already obsessed with the same problem I work on today: how money moves, and why it moves so badly for people like us.

Around that time I tweeted, “I’ve developed a habit of admiring my code before I sleep.” I meant it as a joke. Looking back, it was the truest thing I said that year. I loved this work long before it paid me anything.

I didn’t know I was about to spend the next five years in fintech, straight out of college. I just kept building.

When I wrote every pixel

The early days of WeWire were very manual.

I wrote every button. Every pixel. Every API route, every database migration, every deploy. If something broke at night, there was no one to call, because the person who wrote it was the person reading the error.

I remember July 2022. I was up overnight trying to get our production API working and it just wouldn’t come up. The next morning I sent a message to the team that said, “been trying to get the production API up overnight, been facing issues, still working on it. Apologies on the delay.” Reading that message now, I notice the apology. I’d been working on it all night, but the thing the team needed still wasn’t ready. That was the difficult part of doing so much of it myself: being exhausted didn’t mean the work was finished.

And then there were the Postman days.

In the very early days, before we had dashboards, approval flows, or any of the checks we have now, I regularly sent payments of over seven figures through Postman. Not once, as a story to tell later. Regularly. A request body, a few headers, a click on Send. Then you’d sit there, staring at the response, waiting for the status to change.

I can’t fully explain how surreal that felt. The boy who sat in front of a computer at eight because it obeyed him was now sending more money than he had ever imagined, from the same kind of screen, with one click. I’d refresh and refresh until it said it had landed. Then I’d breathe.

We don’t do it that way anymore, and we shouldn’t. But I never want to forget that feeling.

Paul Graham has an essay called Do Things That Don’t Scale. His point is that in the beginning, founders should do things by hand that would never work at size, because that’s how you learn what to build and how you earn the right to build it. I didn’t read it as advice. I lived it. We didn’t have a product good enough to hide behind yet, so we did the work ourselves, carefully, one payment at a time. It wasn’t elegant. It was how we earned the right to build the elegant version.

Those days are also how I learned about API idempotency: a request failed halfway, after part of the code had already changed the database. When you’re moving real money, you never forget a lesson like that.

Why the team grew

Every hire was something I couldn’t do alone anymore, or couldn’t keep up with. That’s the honest version. Each one meant letting go of a piece of the work I used to hold by myself, and trusting someone else to care about it the way I did.

First, a designer. I could make things work, but I couldn’t make them feel right.

Then help on the frontend, so I could stay on the backend, where the money actually moved. In April 2022 I welcomed a teammate onto the frontend, and we started our component library one Figma component at a time. The first one we picked up was a pill. A tiny rounded label. That’s where our design system started. It sounds small. It didn’t feel small. Someone else was finally shaping the product with me.

Then more hands for bank and telco integrations, where every partner has their own idea of what a “successful” transaction means.

Then our deployments got shaky, and a QA person joined. That same person later grew into a product role. Watching someone grow inside the thing you built is a feeling I didn’t expect when I started. It still gets me.

Mobile brought another QA and another product manager. Licensing brought more engineers and more integration people, because a regulator doesn’t care how clever your code is. They care whether it’s correct, and whether you can prove it.

And we brought people in straight from university. It still moves me that they bet their first jobs on us. I remember being where they are, a final-year project behind me and no idea what was next.

None of it came from an org chart. It came from more product lines, more experiments, more to ship. Looking back, the growth was a long string of quiet admissions: I can’t hold this alone anymore. Come build with me.

The day I realised how human I am

There’s a moment I keep coming back to.

You build something. You’re confident. You’ve tested it in your head a hundred times. Then you hand it to someone else, and the bugs just keep coming.

In May 2024 we started QA on a big release. By the end of that first week I wrote, “QA started this week. 50 issues discovered so far, we’re working during the weekend to fix them.”

Fifty.

I’d written a lot of that code. I was sure it was good. And there it was, fifty times over, proof that I’m human. It humbled me in a way I needed. It also taught me that the person who finds your bugs isn’t your critic. They’re the reason your customers never see them.

How our culture actually formed

I’d love to tell you we designed our engineering culture. We didn’t. It came from scarcity. Almost every practice we have arrived the day something broke.

In October 2023 we had no QA and no project manager, so I told the team we’d rotate the job amongst ourselves every week. That wasn’t a process. It was us covering for each other because nobody else was coming. Years later, AI made code come out faster than anyone could read it, and reviewing pull requests by hand became overwhelming. So every PR now gets a risk level, the checks go where the risk actually is, and whoever opens one has to explain what they did before it merges. Same story. Something broke, and we grew a habit around the wound.

The Postman days taught me the part I care about most. On a payments team, carefulness isn’t a value you write on a wall. It is the culture. Every number on a screen is somebody’s business, somebody’s salary, somebody’s container of goods. A bug isn’t an abstract defect. It’s a person waiting for money that hasn’t arrived.

Holding on to that gets harder now. Our designers write code and ship it themselves. Tiny things that used to mean pinging engineering for weeks take five minutes with AI. The line between designer and engineer has gone blurry, and I love it. But it makes me ask what owning quality even means when anyone can ship. I don’t think the answer is fewer people shipping. I think it’s everyone carrying a little of that Postman feeling. Refresh until it lands. Then breathe.

And when you hire straight from university, you can’t hire the culture. You have to teach it. That’s a responsibility I didn’t understand when I wrote that first line. The way we review, the way we test, the way we talk about failure: someone is learning what “normal” looks like from us, for the first time.

A few things I’ve learned along the way, mostly by getting them wrong first.

See quickly what’s working and what isn’t. The longer you wait to admit something isn’t working, the more it costs everyone, including the person or the idea you’re trying to protect.

Let it exist first, and improve it later. Back in 2020 I tweeted, “Writing unclean code is a prerequisite for writing clean code in some cases.” I had no idea how much I’d end up living by that. The rough version is what teaches you what the good version needs to be.

And with outages, stay open-minded. Don’t be hard-headed. Your system can fail you at any time, and so can your providers. The worst thing you can do in an incident is insist it can’t be your code. Sometimes it is.

Where we are

We’ve now moved nearly $4 billion in cross-border payments for more than 4,000 businesses. I say that number out loud and I still think about one request, one click, one long wait for a response.

All that volume taught us that payments are the last mile of trade. Our merchants had customers, suppliers and goods with real value. What they didn’t have was the capital to move them.

So we started building for trade, not just payments. WeWire Ghana was one of nine companies the SEC Ghana picked for its Virtual Asset Sandbox to pilot tokenising assets for trade finance. And this month, our first trade product went live. Real goods, real deals, real oversight. We started out moving money. What we actually want to move is trade.

The boy who didn’t care what Bitcoin meant is now helping traders turn real goods into real deals. I don’t take that lightly.

To the team

I don’t write every pixel anymore. That used to scare me. Now I think it’s the point.

Every bug you caught, every outage you sat through, every weekend you gave up so a release could go out on Monday: that’s in the code too. You can’t see it in the diff. But it’s there.

If you’d told that eight-year-old staring at a screen that one day twenty people would build on top of something he started, he wouldn’t have believed you. He’d have just asked if he could get back to the computer.

I still admire the code before I sleep sometimes. It just isn’t mine alone anymore, and that’s the best part.