What My First 75 LeetCode Problems Taught Me

A few months ago, I started spending more time on LeetCode. At the time of writing this, I've solved around 75 problems. That isn't a huge number compared to people who have solved hundreds or even thousands, but it's enough that I've started noticing changes in how I approach problems and think about code.

Since I'm a Full-Stack & IoT Systems Engineer, I didn't come from a particularly DSA-heavy background. Most of my day-to-day work involves building applications, APIs, embedded systems, and connecting different pieces together. Because of that, learning DSA through LeetCode has been a very different experience than I expected.

My First Impression of LeetCode

One thing that surprised me early on was that many LeetCode questions weren't necessarily difficult conceptually.

Often, I could understand the idea behind the solution after reading the problem. The difficult part was translating that idea into actual code. Knowing what should happen and being able to implement it correctly turned out to be two very different skills.

I would frequently find myself understanding the logic but getting stuck on edge cases, loops, conditions, or simply figuring out how to structure the solution.

Coming From Web Development

A lot of the concepts on LeetCode are things I rarely encounter in everyday web development.

For example, linked lists are not something I've had to use in most of my projects. The same goes for several other classic DSA topics. Because of that, many problems felt completely new to me.

Interestingly, that was also one of the things I enjoyed most. Instead of repeatedly working with concepts I already knew, I was constantly being introduced to new ways of thinking about data and problem-solving.

Learning Through Tutorials

When I first started, I relied heavily on tutorials.

In particular, I watched a lot of NeetCode videos. There were many occasions where I couldn't solve a problem on my own and needed someone to explain the underlying concept before things finally clicked.

At first, I felt a little guilty about that. It felt like I should be solving everything independently.

Over time, though, I realized that learning the concept was more important than forcing myself to struggle endlessly. If I encountered something completely unfamiliar, watching an explanation often helped me build the foundation needed to solve similar problems later.

The First Time Something Clicked

One of the earliest problems I remember solving mostly on my own was Roman to Integer.

Compared to many other LeetCode questions, it isn't considered particularly difficult, but for me it felt like a major milestone.

Up until that point, I had often needed significant help understanding the approach. Solving Roman to Integer felt different. It gave me confidence that I could take a problem, break it down, and arrive at a working solution myself.

Looking back, that small win was probably more important than I realized at the time.

Recognizing Patterns

After enough problems, something interesting started happening.

Instead of treating every question as completely new, I began recognizing familiar patterns. Sometimes a problem would remind me of a previous two-pointer question. Other times it would resemble a stack problem or a binary search problem I'd already seen.

Even concepts that initially felt intimidating started becoming more approachable.

Dynamic programming is a good example. The first time I encountered it, it looked overwhelming. After seeing it repeatedly and studying the reasoning behind solutions, it slowly became less scary. I still have a lot to learn, but now I at least know what I'm looking at.

What My First 75 Problems Taught Me

The biggest lesson from my first 75 LeetCode problems is that I'm still very much a beginner.

At the same time, I can clearly see progress.

I now understand many core DSA concepts that were unfamiliar to me when I started. More importantly, I've developed a better process for approaching problems. Instead of immediately looking for answers, I spend more time breaking the problem into smaller pieces, identifying patterns, and thinking through possible approaches.

The solutions don't always come quickly, but the process feels much more structured than it did before.

Thoughts on Difficulty

If I had to pick a favorite difficulty level, it would probably be Medium.

Easy problems are useful for learning fundamentals, but Medium problems often feel like the sweet spot. They usually require some thought without becoming overwhelmingly complex.

What's interesting is that difficulty can be misleading. Some Medium problems feel surprisingly easy once you recognize the pattern. Others can feel extremely difficult when they introduce a concept you've never encountered before.

Because of that, I've stopped judging problems purely by their difficulty label.

Advice for Other Beginners

The biggest piece of advice I can offer is to focus on understanding concepts rather than increasing your solved count.

When you encounter a new idea, spend time learning why it works. Watch explanations, read solutions, and revisit the problem if necessary. Rushing through dozens of questions without understanding the underlying concepts hasn't been nearly as valuable for me as spending extra time on something new.

The number next to your profile will eventually go up. The understanding is what actually matters.

Final Thoughts

I'm still early in my LeetCode journey, and I definitely don't have enough experience to give expert advice.

These are simply observations from my first 75 problems and what learning DSA has felt like from the perspective of someone coming from a full-stack and IoT background.

If you're also learning DSA or working through your first LeetCode problems, hopefully something here was useful or relatable.

And if not, thanks for taking the time to read anyway.