I didn’t realize I was starting a 1.5-year journey when I opened my first LeetCode problem.
It didn’t start with motivation.
It started with… curiosity.
There was no plan, no roadmap, and definitely no idea that I would still be doing it a year and a half later.
It started very simply. I had just created my LeetCode account, and like most developers at that stage, I was trying to figure out where I stood.
Global rank: ~6,000,000.
Yeah… not exactly inspiring 😅
I remember thinking it was almost funny. Not in a bad way, just… far. Like starting a game from the lowest possible level without really knowing the rules.
So I did the only thing that made sense at the time. I opened a problem.
And recently, something arrived that made me reflect on that entire period differently.
BTW, I already shared another part of my journey in my previous article about my 373-day consistency streak, but this one is slightly different. It’s not about streaks or badges. It’s about something quieter, what happens after you’ve been doing it long enough that it stops feeling like a “challenge” and becomes part of your routine.
When Nothing Feels Serious (and That’s Exactly Why It Works)
At the beginning, nothing felt serious. I wasn’t grinding, and I wasn’t tracking anything. Some days I solved 3 problems; other days I stayed stuck for hours on a single one. It was completely casual.
But something subtle happens when you keep coming back to the same thing. Even if it’s irregular. Even if it’s messy.
You start recognizing patterns.
At first, every problem feels like a new language. You read it, you stare at it, you try random things, and eventually you check the solution and think: “I would never have gotten that.”
And you’re right. You wouldn’t. Not yet.
The Slow Shift You Don’t Notice Happening
What I didn’t realize at the time is that nothing changes suddenly in LeetCode. There is no moment where you wake up and feel smart. Instead, there is a long stretch of confusion where things slowly stop feeling completely foreign.
A tree problem that once felt impossible starts looking familiar. A dynamic programming question still hurts, but at least you know where to begin. You start failing less because you understand more, not because the problems get easier.
And somewhere in that process, without noticing, consistency replaces motivation.
A Small Package That Made Everything Feel Real
About a year and a half later, something arrived at my door.
The LeetCode kit.
Inside it:
- a T-shirt 👕
- a keychain 🔑
- a coaster ☕
- a sticker sheet 🎴
It sounds simple. Almost too simple to matter.
But it did matter.
Because it wasn’t about the items themselves. It was about what they represented, not a milestone, not a rank, not a badge… but time.
Time spent showing up. Time spent failing. Time spent returning again and again without knowing if it was “working” or not.
And somehow, seeing that package made everything feel real in a way numbers never did.
Around the same period, I checked my profile again.
My rank had moved from ~6,000,000 to ~26,000.
No celebration. No big moment. Just a quiet realization that something had shifted over time, even if I never noticed it happening day by day.
The Weird Relationship I Developed With Badges
At some point during this journey, I realized something slightly embarrassing about myself.
I really like badges.
Not in a “this is useful for my career” way. More like… I see a badge and my brain goes “yes, give me that shiny thing” 😄
Right now, I have 37 LeetCode badges, and I’ve somehow turned collecting them into a side hobby I didn’t plan for.
The most “serious” one so far is the 500 Days badge, which I honestly didn’t expect to care about… until I got it.
And then I cared a lot.
It’s funny how something so small on the screen can feel like a small checkpoint in your life. Not because it changes anything externally, but because it quietly marks the time you spent showing up when nobody was watching.
Of course, I didn’t stop there.
I’ve basically turned my GitHub README into a small museum of achievements, LeetCode badges, streaks, little milestones… all sitting there like trophies nobody asked for but I proudly display anyway 😄
And yes, my dev.to badges are there too, because at this point I’ve fully accepted that I am the kind of person who enjoys collecting digital stickers.
It’s slightly ridiculous.
But also kind of motivating.
Every time I see them, it reminds me of something simple: I didn’t get here in one jump. It was just a lot of small days stacked together.
1040 Problems Later, It Was Never About the Number
The number of problems I solved during that time crossed 1,000, eventually reaching 1,040.
But the number itself doesn’t really matter. What matters more is what happens to your thinking after a few hundred problems.
At some point, you stop panicking when you see something unfamiliar. Not because you know the answer, but because you’ve been stuck before and survived it. You learn that being stuck is not a special state; it’s just part of the process.
You also start noticing that improvement is not dramatic. It’s quiet. It shows up in small decisions: how you break down a problem, how quickly you recognize a pattern, how often you avoid going in the wrong direction.
The Days That Felt Slower (But Never Stopped)
There were also periods where progress felt like it slowed down.
Some days I would sit in front of a problem for a long time and not get the solution immediately. Other days I would solve problems quickly, just to keep momentum. And sometimes I would spend more time thinking deeply about a single problem than actually writing code.
But one thing never changed: I solved LeetCode problems every single day.
The consistency was never in question; what varied was the experience of each day.
And that’s probably the part people don’t talk about enough. Consistency isn’t always about intensity or output. Sometimes it’s just about showing up every day, even when progress doesn’t feel dramatic.
When Problems Start Looking Familiar Instead of New
Around the middle of this journey, I started noticing something interesting about memory. Not memorizing solutions, but recognizing shapes of problems.
You stop thinking in terms of individual questions and start seeing patterns: this feels like a graph traversal, this smells like dynamic programming, this can probably be reduced to a greedy choice.
It’s not instant. It builds slowly, almost invisibly, until one day you realize you’re thinking differently than before.
The Quiet Shift From “Solving” to “Understanding”
There is also a strange psychological shift that happens when you do something long enough. At the beginning, you measure progress in correctness: Did I solve it or not?
Later, you start measuring it in understanding: Did I learn something new, even if I failed?
That shift matters more than any ranking change.
A Small Tool That Helped Me See Patterns
At some point during this journey, I found a tool created by my friend @extinctsion called NeedCode. It is an AI-based platform that analyzes your LeetCode profile and helps you identify strengths, weaknesses, and learning directions. It was interesting to think about patterns I might have missed myself.
The Real Change Was Never Visible in the Rank
Now, looking back, I don’t think the most important thing was solving 1040 problems or moving from rank 6,000,000 to 26,000.
The more important change is simpler.
I stopped seeing problems as threats.
They became something closer to puzzles I’ve learned how to sit with, even when I don’t immediately know the answer.
And maybe that’s the real outcome of all of this: not becoming someone who always knows, but someone who doesn’t immediately quit when they don’t.
If You’re Just Starting, This Is the Only Thing That Matters
If you’re just starting out, or if you feel like you’re not improving fast enough, I don’t think the solution is to push harder.
It’s probably just to stay in the process long enough for it to start making sense.
That’s really all this was for me.
Not a transformation.
Just time passing… with problems in between.
| Thanks for reading! 🙏🏻 I hope you found this useful ✅ Please react and follow for more 😍 Made with 💙 by Hadil Ben Abdallah |
  
|
|---|
Top comments (3)
This article is really great!
And thanks for mentioning needcode.in
I hope students and professionals prepping for interviews will get advantage in their interviews.
Thank you so much, Aditya 😍
NeedCode is really amazing, and I'm sure it will be helpful for too many developers.
This article felt very real and relatable.
More than solving 1040 problems or the huge rank jump, what stood out most was the mindset shift you described: problems no longer feel like threats, but something you can patiently work through and learn from.
The part about badges was also refreshingly honest 😄
Sometimes those small rewards are exactly what keeps us going.
I think this piece captures an important truth about programming growth: real progress is usually quiet and built through small daily repetitions, not sudden dramatic breakthroughs.