From Interfaces to Open Source Bitcoin

My journey as a software engineer wasn’t entirely a straight road. For me, it started with curiosity, a laptop, and the belief that, if I keep learning long enough, I could build things that would be useful to people.

My first doorway into software was the interface. Before thinking about Bitcoin protocols, open-source repositories, or financial infrastructure, I was thinking about design and users. I wanted to understand why one flow felt simple, and another felt frustrating, and how a product could make technology feel less distant. That early interest in frontend engineering and design still shapes the way I build today. It taught me that software is not only about code, but also about the user interacting with the interface.

Learning by Building

I studied Agricultural and Bioresource Engineering at the Federal University of Technology, Owerri, but most of my growth as a developer happened through constant practice. I learned JavaScript, TypeScript, React, Next.js, and React Native by building, breaking things, reading other people's code, asking questions, and trying again.

The early days were not glamorous. They were full of late nights, confusing errors, and small wins that felt much bigger than they looked from the outside. But each bug I fixed gave me a little more confidence, and every project reinforced the same lesson: confusion wasn't a sign to stop, it was part of getting better.

My first professional roles gave that learning structure. At Beacon, I worked as a frontend engineer, building reusable components, connecting interfaces to APIs, and learning how teams maintained production software. While at Etnowe, I worked across web and mobile products, migrated legacy projects, redesigned user experiences, and helped redesign product flows for merchants, customers, and admins.

Those years taught me discipline. I learned to care about performance, accessibility, maintainability, and the small details that make software feel trustworthy. They also pulled me toward the systems underneath the products I was building.

Finding Bitcoin

I first encountered Bitcoin through a multi level marketing scheme which brandished bitcoin as a trading instrument and urged us to invest in it. I and a good number of my colleagues unfortunately lost our money to that investment but the lessons always remained with me. Learning about software and building on that curiosity led me to Qala, which was a turning point in my career.

Through Qala, now Btrust Builders, I found a clearer path into Bitcoin open source. The program gave structure to my interest and put me among engineers who were also on the knowledge path to open source contribution. I began to understand the culture of open source: reading before writing, asking better questions, accepting review, and improving through feedback.

My early contributions to projects like Fedimint and Galoy taught me that open source rewards patience. You learn in public, move carefully and come to the realization that small contributions matter when they make a tool clearer, safer, or easier for the next person to use.

Building Around the Ecosystem

My time at Chaincode Labs as part of the Special Projects team deepened that lesson. I contributed to tools around the Bitcoin developer ecosystem, including Bitcoin TLDR, the Bitcoin Transcription Registry, Good First Issues, GH Stats, Fresheyes, ChatBTC, Bitcoin Search, and the Bitcoin Dev Project.

That season taught me to value the parts of open source that are sometimes easy to overlook such as documentation, search, onboarding, contributor discovery, and tools that help people understand complex systems. Protocol work is important, but so is the infrastructure that helps new builders find their way in.

From Chaincode, I moved to Mavapay, back on the product side building financial-service. I worked on dashboards, mobile experiences involving transactions, analytics, multi-currency flows, and Bitcoin-to-fiat conversion. Mavapay brought me close to the everyday reality of payments and reminded me why user experience around financial tools matters so much.

That chapter also clarified something: I enjoyed building products, and I was also drawn to open infrastructure, tools and systems other developers could inspect, build on, extend, and carry into places I'd never see myself.

The Coco Chapter

Today, my full-time open-source work is focused on Coco, a TypeScript-first toolkit for building Cashu wallets and applications. Cashu is a Chaumian ecash protocol for Bitcoin, and Coco gives developers a modular foundation for building wallet experiences across environments like the browser, Node.js, Bun, and React Native.

At first, Coco felt close to the parts of software I already knew: TypeScript, APIs, adapters, React hooks, and application architecture. But the deeper I went, the more it pushed me into harder protocol questions: persistence, recovery, concurrency, quote lifecycles, payment ambiguity, and what happens when software crashes halfway through moving value.

My contributions on Coco have grown, from product-facing improvements into deeper reliability and protocol work. The mint-swap work in particular has changed how I think as an engineer. The happy path is not enough when solving a problem. You have to think about two mints, Lightning settlement, fees, retries, restarts, ambiguous outcomes, and users who should not need to understand any of that for their wallet to behave correctly.

That is what I love about open-source infrastructure. The work is quiet, but it matters. A good API should be honest. A good system should recover. A good tool should make the next builder more confident.

Still Becoming

Looking back, the journey makes more sense now than it did while I was living it. Frontend work taught me empathy for users while Product work taught me how software survives real requirements. Bitcoin taught me to care about open systems but Btrust gave me a doorway into open source. Chaincode showed me the importance of developer infrastructure and Mavapay brought me close to real payment problems. Coco is where many of those threads now meet.

I am still learning, and I hope I never outgrow that. Open source keeps you honest. Your work is public, your assumptions are tested and your code has to make sense to people who were not in the room when you wrote it.

If my journey has taught me anything, it’s this; you do not need to arrive fully formed. You start with curiosity, keep showing up, learn in public, accept feedback and you build small things until they become bigger things. At some point without noticing exactly when, you become part of the open-source story you once admired from a distance.