Seventeen
Seventeen was a lot.
The easiest way to write about it would be to list everything I built, worked on or learned.
That would also be the worst way to write about it.
Because when I look back at that year, the biggest change wasn’t the number of projects.
My world just kept getting bigger.
Making the Phone Survive
By then, coding on my phone wasn’t an experiment anymore.
During the early months of MCL, there were days I’d start the development server in the morning and leave it running for hours. I’d code at home. I’d code in class. I’d come back to it later.
My phone just had to survive.
Next.js moving toward Turbopack helped a lot.
Webpack wanted to wound my phone.
As the things I built became heavier, the setup became harder to maintain.
node_modules ate storage. Compiling ate storage. Servers wanted RAM. Sometimes I needed two servers running at once.
For a long time, Acode had been incredible for me. But eventually even switching applications became a problem.
I’d leave Termux for Acode and Android might kill Termux.
I’d leave Acode for Chrome and something else might restart.
I could use wakelocks to keep things alive, but then there was the battery.
And the heat.
At some point my phone would basically be boiling while I was trying to convince Android not to kill the things I needed.
So eventually I moved more of my workflow into Termux.
Then I found another solution.
Instead of asking how much computation I could force onto my phone, I started asking why the computation needed to happen there at all.
I discovered environments like GitHub Codespaces and Google Cloud Shell.
They had the storage.
They had the RAM.
They could run the servers.
And I could SSH into them from my phone.
That changed the equation again.
My phone didn’t need to become a powerful computer.
It could become the doorway into one.
I started relying more on terminal tooling. The GitHub CLI meant I didn’t need to keep opening GitHub’s website for everything.
And because repeatedly typing the commands I needed for Google Cloud Shell became annoying, I did what I apparently do whenever something annoys me enough.
I made a tool.
I called it GShell.
It was a wrapper around Google Cloud Shell that made getting into my cloud environment much quicker.
Another tiny problem.
Another tool.
Too Young, Apparently
There was another limitation I kept running into that had nothing to do with my phone.
I was 17.
Trying to earn money and make a living while being underage was a headache.
I’d find jobs, programs, hackathons or platforms I wanted to use and then run into the same thing:
18+.
Banking and KYC were their own mess.
At different points, I had around five bank accounts in some form—some mine, some involving my parents—and sometimes I had to rely on family members who were old enough when verification became a barrier.
It was messy.
Then there was the phone itself.
Not having a working laptop genuinely limited what I could do. Sometimes I found a workaround immediately. Sometimes I spent hours finding one. Sometimes there simply wasn’t a good one.
But I kept working around things.
Not enough storage?
Find another machine.
Not enough RAM?
Move the computation to the cloud.
No laptop?
Use the phone.
At one point, my friend Diva told me she was tired.
Then she brought up me.
She’d seen me crash out on X before, and yet there I was, still coding.
I told her:
You see? I crashed out, but I’m still here.
And I think there’s something important in that.
I wasn’t endlessly motivated.
I got tired.
I got frustrated.
Sometimes I crashed out publicly.
Then, somehow, I would still find myself back in Termux.
When Other People Started Calling
Around March, I got a phone call.
Someone had recommended me.
They’d told this person that I could code.
That alone made me ridiculously happy.
Less than a year earlier, I had been asking what HTML was.
Now someone I didn’t know had heard from someone else that if he needed somebody who could build something, he should talk to me.
He was a 500-level student working on his final-year project.
A drone.
We talked about it and started planning how it could work.
Somewhere during those conversations, he saw one of the things I’d posted.
Then he told me about something else he was building.
Flowbonds.
It was a social marketplace for buyers and sellers, and he wanted me on the team.
I told him I couldn’t join without being paid.
He asked me to at least come in and use my expertise to guide them.
My expertise.
I’d been coding for about nine months.
Still, I looked at what they had.
Advising turned into helping with the code.
Helping with the code turned into rewriting parts of it.
I rebuilt the Reels section.
Eventually, I worked on moving the web platform from a pure Vite setup to React Router so we could have server-side rendering and better indexing.
Somewhere along the way, I became the lead developer—or essentially the person responsible for the web platform—as we also thought about eventually having a mobile application.
And I still wasn’t being paid.
That happened more than once at 17.
I was gaining titles, responsibility and experience much faster than I was gaining money.
Part of it was circumstance. I was still under 18. I’d see opportunities, jobs and hackathons only to find an age requirement sitting in front of me.
Part of it was also me.
I liked building things.
Sometimes too much.
Fildtek
In April, I made my portfolio.
I shared it on my WhatsApp status and in my department group.
Someone contacted me through it.
He said he liked my portfolio and wanted to meet me.
So we met.
He told me about an idea he had, and something older than my interest in programming kicked in.
I’ve always liked listening.
Thinking through people’s ideas.
Finding the holes.
Suggesting another way something could work.
I listened to him, helped shape the idea and even helped with the name.
That became Fildtek.
The idea was to help people verify land and properties before they committed to a bad deal.
And somehow, I became CTO.
Again, there wasn’t money attached to the title.
Looking back, I probably accepted too much responsibility for free that year.
But I also learned something from being allowed into other people’s ideas.
Building for yourself is one thing.
Building something other people are depending on is different.
Software Is Also People
I’d already been appointed Special Adviser on Media and Publicity for the National Association of Mechatronics Engineering Students (NAMTES).
I was also appointed Editor-in-Chief of the Nigerian Universities Engineering Students’ Association (NUESA).
Then, around February, there was discussion about creating a better platform for the Mechatronics department—something that could help new students understand the department and give the association a proper online home.
There had been a site before.
I found the developer behind it and eventually got access to the codebase.
Laravel.
Blade.
PHP.
Things I hadn’t worked with before.
So I installed PHP on my phone and started figuring it out.
Then I opened the frontend and found a CSS file with roughly 7,800 lines.
I closed Acode.
Eventually, I came back.
I didn’t immediately throw everything away. I tried working with what already existed.
I refactored the frontend toward Vite and Tailwind CSS while keeping the Laravel backend. I submitted the work as a pull request to the existing repository.
Then I learned another side of software development.
Who owns the server?
Who controls the domain?
Who can deploy?
Who has access?
And what happens when the people involved don’t agree?
The previous setup was heavily centralized around one developer. Getting clear information about the infrastructure became difficult.
Eventually we had a meeting.
He felt I was undermining the work he’d already done. Part of the way he spoke to me made it clear that he saw me as his junior.
I didn’t agree with how he saw the situation, but I stopped arguing.
I didn’t stop building.
I started again.
This time I moved away from Blade and built the frontend in Next.js. I spent roughly two months on it, day and night.
And I deliberately changed the structure around the project too.
I didn’t want another version of the platform where one person effectively held everything.
So I created a GitHub organization for the department.
The platform could live there. Other students could contribute their own projects. Access didn’t have to disappear when one person left office.
When a new executive team came in, the handover could be much simpler.
Change the owners.
Change the admins.
The platform stays.
By the time the site itself was ready, the domain situation still wasn’t.
Eventually I told the executives they should get another domain.
Months later, they did.
That whole experience taught me something I hadn’t needed to understand when all my projects belonged entirely to me:
You can finish the software and still not be able to ship it.
Code is only part of the system.
There are people, ownership, infrastructure, money and decisions around it.
In August, I was asked to build a voting platform for the association.
This time, I charged.
₦25,000.
It still wasn’t much compared with the work involved, but at least I had started learning.
I also built tools for the people who would actually run things, including an admin dashboard for the media team and executives.
And I made myself a promise:
I couldn’t keep building everything for free.
Then I Made Money With a 3D Model
Mechatronics itself hadn’t disappeared while I was drowning in software.
We had physical projects too.
I worked on a fire detection system.
I was involved in assembling a drone.
During second semester, we also got assignments involving 3D design.
The expected route was AutoCAD.
Again, I had a phone.
So I researched.
That’s how I found Onshape.
It had a mobile app, and much of the heavy processing happened in the cloud instead of asking my phone to do everything locally.
Perfect.
I started learning it and made my first 3D design: a keychain tag.
Later I modelled things like a NEMA 17 stepper motor and a servo motor.
I even wrote a blog showing other students how they could do it themselves.
Then I found out some people were getting paid to do the assignments for other students.
Wait.
I could do that.
So I started telling friends to tell their friends that somebody was available.
₦500.
₦1,000.
Small payments.
For one of the projects, I practically ended up doing it free for everybody who came to me.
But the little payments accumulated.
Eventually I’d made more than ₦20,000 from 3D modelling.
I was happy.
Not because ₦500 or ₦1,000 was suddenly a huge amount of money.
But because this was different.
Years earlier, I’d been putting money into schemes trying to figure out how people made money online.
Now somebody could give me money simply because I knew how to do something they needed.
I had to keep reminding myself that knowing how to do something had value, and that I couldn’t keep doing everything for free just because I enjoyed doing it.
Especially because I still had a bad habit of doing exactly that.
From Using Open Source to Contributing to It
My own repositories weren’t the only codebases I touched that year.
I started contributing to other people’s open-source projects too.
One of them was ExplainThisRepo. There was a Python tool, and I created a JavaScript version of it.
Later came other projects, including Replex, an open-source video automation project.
Working inside somebody else’s codebase was different.
When I build something myself, even the bad decisions make some sense to me because I remember why I made them.
In somebody else’s project, I have to understand their decisions first.
And the stacks kept getting heavier.
Playwright.
Redis.
MongoDB.
Workers.
Browser automation.
Docker.
Once again, my phone had absolutely no business being at the centre of this setup.
And once again, I found a way.
By then, cloud environments, SSH and port forwarding had changed what “building from a phone” even meant for me.
Sometimes my phone was doing the work.
Sometimes it was controlling another machine doing the work.
The distinction stopped mattering.
I was still the one building.
My Tools Became My Tools
I also kept making software for problems I personally had.
Some became public tools.
git-aic.
d-vercel.
pkgpin.
dotcfg.
flenv.
And somewhere along the way, I noticed that these weren’t just projects I made so I could say I’d made them.
They became part of how I worked.
When I need to commit something, there’s a good chance I’m using git-aic, or npm commit when I’ve wired it into the project’s package.json.
When I need the deployment workflow I built d-vercel for, I use d-vercel. Multiple private organization repositories I work with use it too.
Other tools solved different problems as they appeared.
That changed how I thought about whether a project was “alive.”
A tool doesn’t need constant commits to prove that it matters.
Sometimes the best sign that something I built works is much quieter:
I reach for it when I need it.
MCL Came Back
And My Campus Library kept growing.
The first launch had arrived too late into the exam period to become what I’d hoped.
But that wasn’t the end of it.
I kept working.
I added more resources.
Improved authentication.
Built a CBT system.
And this time, students came.
Hundreds of them.
MCL eventually crossed 600 users, and during active periods, hundreds of students were using the CBT system.
That gave me a completely new category of problems.
Before, most of my problems sounded like:
How do I build this?
Now I had problems that sounded like:
What happens when hundreds of people use this at once?
Hosting limits became real.
Database limits became real.
Email limits became real.
Things that meant nothing when I was the only person clicking around suddenly mattered.
For the first time, I could break something and people I didn’t even know might notice.
That felt different.
Building an App I Couldn’t See
Then I decided to learn Flutter.
Naturally, I didn’t take a Flutter course.
I started building an app.
Lurc.
A mobile-first API client.
There was one small problem.
I was building a mobile application from my phone.
I couldn’t run an Android emulator locally.
So for a while, I was writing UI code for an application I couldn’t properly see.
Write the code.
Let CI build the APK.
Install it.
Find out what I’d made.
Fix it.
Repeat.
It was ridiculous.
But by then, ridiculous wasn’t enough to stop me.
Eventually I got the interface running on my actual phone.
I could finally see the thing I’d been building.
More Than Code
Something else had changed by then too.
People.
When I was younger, I could spend months in the same classroom as people without knowing most of their names.
At 17, my world looked very different.
I met people through X.
Some started as mutuals. Some became people I'd talk to outside X. Sometimes weeks or even months could pass without us talking, then one of us would check in and we'd pick up again.
Sometimes complete strangers would message me just to say they'd seen what I was building and that I was doing good work.
One of those strangers was Oyibe.
He asked for my WhatsApp.
Somehow, stranger became friend.
We started talking regularly. We built things together. We contributed to each other's open-source projects. We sent opportunities to each other.
Offline changed too.
I had friends in my department. Friends around where I lived.
And I still had friends from before university.
We didn't always talk regularly either. Sometimes life happened, months passed, and then somebody checked in and we picked up from wherever we'd stopped.
There were more people in my life now.
That's strange to think about when I remember the boy who barely knew his classmates.
I didn't just learn how to build things.
Somewhere along the way, I found people too.
What I Made at Seventeen
Financially, 17 wasn’t some incredible breakthrough year.
I didn’t make a lot of money.
In some ways, that bothered me.
I was actively trying to earn while simultaneously running into the fact that I wasn’t legally an adult yet. Some opportunities simply weren’t available to me. Some platforms made things harder. And the machine I was trying to build a career from was still a phone.
I had responsibilities.
Titles.
Projects.
Users.
People asking me for technical help.
People trusting me with their products.
And yet I was still doing far too much without getting paid.
But when I look at what I gained that year, money doesn’t describe it very well.
I learned how to work inside other people’s code.
I learned how to work with teams.
I learned how to lead a team.
And I was beginning to learn that being able to build something and being able to make people value what you build are completely different skills.
Technical ability wasn’t enough by itself.
You could be very good at making things and terrible at communicating their value. You could build something useful and have almost nobody know it existed. You could do valuable work and still somehow end up doing it for free.
I was getting better at the building part.
I still had a lot to learn about the rest.
I learned about servers, deployment, infrastructure and the cloud.
I learned that sometimes my phone could do the work.
And when it couldn’t, I could make another computer do it from somewhere else.
I learned to contribute.
I learned to teach.
I learned to charge, even if I still wasn’t very good at it.
I learned that I could build something hundreds of people would actually use.
I learned that I could be trusted with things that weren’t mine.
And I learned to design things so they didn’t have to depend entirely on me.
I also learned that I could take all of this too far.
There were periods where I couldn’t stop.
I’d work for hours.
I’d keep going while my phone heated up in my hands.
I’d take on another thing because the idea interested me even when I already had enough things to do.
At some point I had to admit that I wasn’t just interested in coding anymore.
I could become consumed by it.
And still, there was always another thing I hadn’t done before.
Not long before I turned 18, I built my first Telegram bot.
Then I started connecting it to blockchains.
A year earlier, I couldn’t properly continue a desktop application because I had no machine to test it on.
Now I was looking back at that same application again.
Biuld.
This time, I knew more.
A lot more.
And I knew ways around problems that would have stopped me before.
So I came back.
Coming Back to Biuld
Almost a year after I had to step away from Biuld, I came back to it.
The project hadn’t changed nearly as much as I had.
When I first built it, I was learning almost everything as I went.
Next.js.
WebSockets.
Desktop applications.
CI.
GitHub Actions.
Networking.
I remember needing 79 workflow runs just to get my first proper build matrix working.
I remember writing Biuld code from my phone and then being stuck because the thing I was building was a desktop application and I had no computer to properly test it on.
That limitation had been enough to make me step away.
Now I looked at the same kind of problems differently.
In the year between, I’d built full-stack applications from my phone.
I’d worked with databases, authentication, APIs, proxies, workers and queues.
I’d used Docker.
I’d worked with cloud environments and remote machines.
I’d contributed to other people’s codebases.
I’d published my own tools.
I’d learned Rust.
I’d started learning Flutter.
I’d worked on products other people were depending on.
I’d dealt with actual users.
I’d dealt with infrastructure limits.
I’d dealt with teams.
I’d dealt with code I didn’t write.
I’d dealt with people I couldn’t fix with a commit.
The phone was still the phone.
But I wasn’t the same developer using it.
So I came back to Biuld.
Not because all the limitations had disappeared.
I’d just gotten much better at finding ways around them.
And there was something satisfying about returning to one of the projects that had once been too difficult for my setup.
It felt like meeting an older version of myself through his code.
Sometimes I understood exactly what he’d been trying to do.
Sometimes I wondered what on earth he’d been thinking.
But he had built it with what he knew.
Now I knew more.
So I kept going.
The Things I Didn’t Become
When I was 9 or 10, I used to imagine myself at 17, 18 and 19.
Those ages sounded old.
Not old old.
Just old enough that I assumed I would have become whoever I was supposed to become by then.
In the world I created in my head, there was an industry.
There were inventions.
There were companies.
There was money.
There were things with names that didn’t exist anywhere except my imagination.
I spent years walking around thinking about that person.
Now I’m 18.
And I haven’t become him.
I don’t have the giant company I imagined.
I haven’t built most of the inventions that existed in my head.
I haven’t made some ridiculous amount of money.
There are things I thought I’d have figured out by now that I absolutely haven’t.
There are projects sitting unfinished.
Ideas I said I’d start and didn’t.
Things I built that almost nobody saw.
Posts that went nowhere.
Opportunities I missed.
Weeks where I wasted time.
Days where I did almost nothing.
Times I worked far too much.
Times I crashed out.
There are people my age doing things I haven’t done.
There are people younger than me doing things I haven’t done.
And if I stare at that for long enough, I can make everything I’ve done feel very small.
I’ve done that before.
But that’s not the whole story.
At 18
At 18, I don’t have the world I imagined when I was 10.
But for the first time, I know I can actually build pieces of it.
I know how it feels to start with a blank file and eventually have hundreds of people using what came out of it.
I know how it feels to have somebody recommend me because they believe I can build something.
I know how it feels to open someone else’s code and contribute something back.
I know how it feels to lead.
I know how it feels to make money from something I know how to do.
I know how it feels to make no money from something I probably should have charged for.
I know how it feels to build with the wrong tools because they’re the only tools available.
I know how it feels to hit the limits of those tools and find another way.
I know how it feels to fail a workflow 78 times and run it one more time.
I know how it feels to crash out and still come back.
And maybe most importantly, the things in my head aren’t only in my head anymore.
Some of them have names.
Some have domains.
Some have repositories.
Some have users.
Some are installed on my phone.
Some are running on servers somewhere.
Some didn’t work.
Some are still becoming.
And there are still far more of them in my head than I could possibly build right now.
That part hasn’t changed.
The Age I Used to Imagine
I turned 18 on September 24, 2026.
There wasn’t some transformation at midnight.
I didn’t wake up suddenly knowing what I’m doing.
My problems didn’t disappear because a number changed.
If anything, turning 18 has made me think more about time.
Because I’m finally standing inside one of those ages I used to imagine.
And it’s nothing like I thought it would be.
It’s messier.
Smaller in some ways.
Much bigger in others.
Ten-year-old me probably wouldn’t understand half the words I’ve written in this story.
He wouldn’t know what Next.js is.
Or Rust.
Or Git.
Or a VPS.
Or CI.
Or why anyone would willingly spend hours reading error logs.
But he’d understand the important part.
I’m still imagining things.
The difference is that I don’t want to spend the next eight years only imagining them.
I already did enough of that.
I want to make them real.
One at a time.
And if I don’t know how yet—
I’ve gotten pretty good at figuring it out.
No comments yet