Everyone Struggles: But We Still Ship

Until death, all defeat is psychological

In 2018, I tried to build a navigation drawer in Android(Java). It was my first real attempt at creating something, and I recall copying code I didn’t fully understand, hoping it would just work. It didn’t.

I closed my laptop at 4 AM, completely frustrated after hours of configuration and confusion. I had poured energy into this thing that refused to give back. No fancy setup, no smooth Gradle syncs — just me, a stubborn laptop, and data that was never enough.

I asked myself, “Do I even belong here?”
The self-doubt crept in fast: Maybe I’m not smart enough. Maybe tech isn’t for me.

I gave up. Not forever, but for a while. I pivoted to HTML and CSS, hoping for a softer landing. Even tried Python and practised algorithms. But deep down, Android still called to me. So I went back — this time with a book in hand.

On page one, it said:

“If you don’t know OOP, you should close this book now and study that first.”

Another hit to the gut. But I didn’t quit this time. I studied object-oriented programming, learned about multithreading, and slowly climbed my way back. Eventually, Android development began to feel... doable. Even exciting.

Fast forward to 2024, during the Outreachy application process, I found myself back in a Kotlin Android codebase — a full circle moment. That same skill I once struggled with had now become the bridge to one of the most prestigious internships in the world. Wild, right?

But of course, the struggles didn’t end with getting in.

One of my recent hurdles? Setting up a GitHub Actions workflow for running Android instrumented tests. I thought, “Should be straightforward.” Spoiler alert: It wasn’t.

Managing the emulator, allocating memory, and disabling animations — all things I didn’t anticipate. Tests kept failing. The logs made no sense. I was annoyed but determined. I turned to AI tools, Stack Overflow, and GitHub docs. After hours of digging, I discovered a key fix:

You must wait for the emulator to fully boot before running tests. That was it. One line. One timing issue. But learning that made everything click.

And somewhere along the line, I stumbled on a Git concept that made me feel like I had unlocked a secret level:

git pull --rebase

One day, I saw this message:

Your branch and 'origin/feat/X-BRANCH-NAME' have diverged, and have 2 and 1 different commits each, respectively.
(use "git pull" if you want to integrate the remote branch with yours)

At first, I just shrugged and ran git pull. But the history looked messy. Then I learned about rebasing and how it could give me a cleaner, more linear commit history. It felt like a superpower.

Rebasing, I discovered, takes your local commits and re-applies them on top of the latest version of the branch. In open source, where clarity and collaboration matter, it helps keep things neat for reviewers and maintainers.

That tiny vocabulary term — rebase — made a huge difference. I didn’t know it when I started. But now I understand it, use it, and teach it

The truth is, I still struggle. I still hit walls. I still Google things I’ve Googled before. But I’ve learned that struggling doesn’t mean I’m not smart — it means I’m learning.

To anyone just starting:

If you feel like everyone else is ahead of you — you’re not alone. Everyone struggles. Everyone starts from zero.

What matters is that you keep going. Ask the “silly” question. Read the docs (again). Be patient with yourself. You don’t have to know everything now — you just have to believe you can learn it.

As one of my favourite quotes says: