Over the course of four intense months, I built a fully functional Bitcoin wallet from the ground up—completely solo. I live-streamed every stage, from initial wireframes to final deployment, to a modest audience of three. The result? A rough-around-the-edges, testnet-only application that works. More importantly, it taught me more about engineering, systems thinking, and personal resilience than any course or tutorial ever could.
This is the story of that journey—and the hard-won lessons learned along the way.
⚠️ Disclaimer: This wallet is for educational purposes only. It runs on testnet and is in ALPHA. Do not use real Bitcoin. This is not production-ready software.
👉 Discover powerful tools to explore blockchain development further.
The Origin of a Solo Build
My path to building a Bitcoin wallet began after the winding down of my previous venture, BitEscrow—a non-custodial Bitcoin escrow service I co-founded. After three grueling years of bootstrapping, I faced a sobering truth: people don’t want to spend their Bitcoin. With that realization, I stepped away.
Like many developers in burnout mode, I dove into Factorio—a game centered around automation, systems optimization, and engineering efficiency. In just one month, I logged over 270 hours. Under the mentorship of a computer science PhD who’d mastered the game, I didn’t just play—I absorbed its core philosophy.
And that’s when it hit me: Factorio is systems engineering disguised as entertainment. The game trained me to think in flows, dependencies, and feedback loops—skills that directly translated to software architecture. Once I emerged from that deep dive, I was ready to build again.
Rested and recharged, I spent two weeks learning mobile development and launched into building a Bitcoin wallet as an MVP for a larger infrastructure idea.
Why Build Yet Another Wallet?
Short answer: To deepen my technical mastery before diving into the next big project.
Longer answer: I initially envisioned this wallet as a stepping stone—a way to validate a product idea by building a minimal version, growing a waitlist, and pitching to investors. Classic startup playbook. But after four months of relentless solo development, my perspective shifted.
I realized:
- The original idea was too niche (a repeat of past mistakes)
- Market demand was underwhelming
- I missed building foundational infrastructure more than consumer-facing apps
- Well-executed infrastructure creates long-term value
A conversation at Bitcoin Las Vegas helped reframe my entire approach. By month three, I accepted this wallet wouldn’t be my destination—it would be my graduation project.
The Reality of Solo Development
I set a strict deadline: four months from first commit to final build. I used a Kanban board to track progress. "Ship or die" was the mantra.
By month two, I nearly quit. The board was overflowing. Features were half-broken. The early wins—small UI tweaks, basic screens—no longer fueled motivation. I seriously considered writing a post-mortem on failure instead.
Then came the pivot: perfection is optional. Momentum is not.
I started cutting scope aggressively.
The Power of Saying No
Feature creep nearly killed this project. My Kanban board was packed with "nice-to-haves": live Bitcoin price tracking, USD/sats converters, animated transitions—features that sounded good but added complexity without value.
Take the price display feature: I hit API rate limits with CoinGecko, so I built fallbacks, then price averaging logic, then centralized state management—just to show a number. Then I asked: Does this actually matter?
No. So I deleted it.
Removing USD conversion simplified the entire codebase:
- No conversion logic in
SendAmountScreen,SendConfirmScreen, orReceiveScreen - No need to store historical prices
- Cleaner state management
I applied this ruthless prioritization across the board:
- Skipped UI smoke tests (tested manually)
- Avoided branding, custom fonts, and animations
- Deferred security hardening beyond basics
- Cut CI/CD pipelines and full test coverage
- Removed App Store readiness tasks
- Eliminated polished error handling
- Postponed refactors
One feature I really wanted? Jibberlink for air-gapped signing. Cool idea—but time-consuming. Cut.
👉 Explore secure blockchain platforms to test your own wallet concepts.
What Truly Matters in a Bitcoin Wallet
After stripping everything down, I landed on a core truth: a Bitcoin wallet only needs two things—send and receive functionality.
When I finally constructed a raw transaction that passed full UTXO validation, saw the success screen, and watched it confirm on the mempool—that was euphoric. I had built it from scratch: key derivation, signing, broadcasting—all working.
That moment wasn’t about aesthetics. It was about understanding.
Systems Thinking Meets AI Collaboration
By month three, my mindset shifted. I stopped thinking in files and functions and started seeing the wallet as a system—a network of flows, rules, and state transitions.
AI became my silent co-founder. Not just for code generation, but for architectural feedback. I learned to think in prompts—structuring problems so AI could help implement solutions. Tools like Claude and Cursor accelerated development when energy dipped.
This wasn’t lazy coding—it was amplified engineering. Prompting became a form of software design, and thanks to Factorio, I already had the systems-thinking muscle memory.
The Final Week: Triage and Triumph
The last week was chaos. Debugging bled into UI tweaks, which gave way to fighting Expo polyfills. Context-switching became my primary skill.
I kept wanting to refactor—reorganize folders, clean up files—but that was procrastination disguised as progress.
I wore every hat: developer, tester, UX designer, DevOps. And when I pushed that final bugfix and watched a transaction go from signed to confirmed—I let it stay ugly.
Because shipping beats perfection.
Tech Stack & Architecture
Inspired by wallets like Blue Wallet, I chose each library with intent:
Core Libraries
- BitcoinJS-lib v6.1.7: The foundation for raw transaction handling
- React Native + Expo: Cross-platform mobile development
- TypeScript: Type safety for complex logic
- Zustand v5.0.4: Lightweight, reliable state management
Bitcoin Standards
- BIP-32: Hierarchical Deterministic (HD) wallets
- BIP-39: Mnemonic seed phrases
- @scure/bip39 & secp256k1: Cryptographic operations
APIs & Infrastructure
- Mempool API (primary), Esplora (fallback)
- Axios with rate limiting
- Zod for schema validation
- MMKV for fast local storage
- React Query for data fetching
Key Features Implemented
- Full send/receive flow with custom hooks (
useSendBitcoin,useReceiveHandlers) - Transaction history with UTXO validation
- Multi-network support (testnet, mainnet, regtest)
- HD wallet generation and import
- QR code scanning
- Mempool.space integration
Frequently Asked Questions
Q: Can I use this wallet with real Bitcoin?
A: No. This is a testnet-only project for educational purposes. Never use it with real funds.
Q: Is the source code available?
A: Yes—the full repository is open source and designed for learning.
Q: Why use BitcoinJS instead of BDK or LDK?
A: BitcoinJS is great for learning core concepts. For production, BDK + LDK offer better security and abstraction.
Q: How long did it take to learn mobile development?
A: About two weeks of focused study before starting the wallet build.
Q: Did AI write most of the code?
A: AI assisted with implementation and debugging, but architecture and decisions were mine.
Q: Would you build it solo again?
A: Technically—yes. Personally—no. Solo builds accelerate learning but take a mental toll.
👉 Access developer resources to start your own blockchain project today.
Technical Lessons Learned
- Building a wallet solo is brutally hard—but unmatched for skill growth.
- Key derivation, signing, and address generation will humble you fast.
- UTXO management is where theory crashes into reality.
- BitcoinJS is powerful but low-level; consider BDK for production.
- State management in financial apps demands extreme care.
- Secure key storage is far more complex than memes suggest.
- Xcode remains one of the most frustrating dev environments.
- AI pair programming boosts productivity—but amplifies bad habits if unchecked.
- Running Bitcoin Core locally deepens respect for full nodes.
- SegWit makes sense only when you implement it yourself.
Personal Insights Gained
After months of coding in isolation:
- Perfection kills momentum. Ship ugly.
- Execution separates dreamers from builders.
- You can do hard things alone—but support helps.
- Persistence outlasts talent and tools.
The deepest insight? I’m an infrastructure engineer at heart. Tweaking UI pixels confirmed it: I belong in the backend, designing systems—not styling buttons.
What’s Next?
This wallet works—but it’s messy, under-tested, and needs refactoring. Could I perfect it? Yes. Will I? No.
Bigger projects are calling. This wallet achieved its purpose: deepening my Bitcoin expertise, sharpening engineering discipline, and clarifying my path forward.
If this story helps one person understand how wallets work under the hood—mission accomplished.
The architecture is clean. The code is organized. It’s all there for you to explore, break, and learn from.