Ahh, time flies! I can't believe it's already been a 10 years since I wrote my first line of code. Looking back, it's been a rollercoaster - full of lessons, challenges and unexpected turns.

This is a story of growth, challenges and persistence. If you're on similar path or just curious - I hope you'll find it inspiring or insightfull.

Early days

It's all started after I finished my computer science degree and began searching for an Internship. Finding one wasn't easy, but eventually I landed a group internship in a large enterprise fintech company, along with nine other aspiring intern developers.

I was super excited and couldn't wait to start. My parents even borrowed me a car so I could commute daily. 8 hours at internship and then back home - 30 days straight. I don't even remember If I was hoping for a job there. I think I wasn't. All I really wanted is to finally experience real life software development.

The company was well structured, three floors, a modern and clean workspace, big server rooms, groups of senior teams working together.

Everything seemed so professional. I felt small in that world, but knowing that nine other interns are in the same boat, gave me a sense of calm.

The First Not-so-Nice Surprise(but a useful one!)

Before anything, I have to admit - I had very little practical coding experience. The only real project I had worked on was a graduate thesis - a simple e-commerce web application built for a local company. I've developed it with C# (.NET) and Angular.

So when our mentor assigned us first tasks, I felt impostor Syndrome, instantly.

The real schock came when I saw some of the younger interns dealing with tasks with ease.

My self-confidence took a hit, but my motivation didn't.

I though - "This is exactly where I want to be. The dumbest person in the room".

Every day felt like a new knowledge. And I soaked it all in.

Lection #1 learned

Our task was to build a web app with various forms and backend actions behind it.

Among the interns, there was one guy(just a year younger than me), who was incredibly knowledgeable and eager to help. I was. I was impressed by his obsession in technology and unselfishness in sharing what he knew.

That was actually the first big lesson I learned - and it wasn't even technical. It was a soft skill. I realized that it's not just about how much you know, but how you approach learning. Instead of feeling overwhelmed by how little I knew, I learned to enjoy curiosity and enjoy how to solve problems.

Lection #2 learned

Long story short - I finished my internship, but at the end of it, I learned my second big lection.

I forgot to mention that internship was designed so that the only one person would get a job at the end.

I was convinced it wouldn't be me - and I was right. But, I was almost certain that one of the two brilliant guys I met there, who absolutely rocked, would get the offer.

I was wrong.

In the end the job didn't go to the most skilled intern. It went to the average guy who had already built a good connection within the company. That thought me a crucial lesson: Even in the tech industry, being good at what you do, isn't always enough.

Considering that I wasn't even an average intern there, I didn't take it too hard. In fact, I was happy I finally gotten my hands dirty, on a real - life project. I had a clear understanding of where I stood - not just how much I knew, but more importantly, how much I still had to learn.

I had a clear vision of what to do next.

My 2nd internship

So, I came home, reflecting on my experiences, and kept learning - diving deeper into technologies while staying in touch with my college friends to see what where they were applying.

One day, my good friend told me about a company located in our city looking for several interns. She applied and told me to do the same.

I've applied immediately and got a call, very next day!

When I went in, I presented my graduate thesis project and shared proof that I already gained practical experience during my first internship.

It went pretty well, actually. A few days later, they told me I was in - and that I'd be starting in just a few days.

This time the company desperately needed a workforce. There were more than 10 of us as I can remember.

They took couple of us, the rest were let go.

I was prepared for this internship. I had basic skills and more importantly, mentality.

I worked day and night to become one of the better interns. And I did it. Company saw it.

All was good.

My first scary software engineering job

I was hired as a Junior Backend Web Developer, with PHP as my main programming language.

The codebase was a mess, and I was the only developer - but that also meant my learning curve was steep.

Not long after working on small projects, the company assigned me to a large project for a foreign client - a website with millions of daily users and a 30 person team.

But the real shock came when I found out that a senior from my company had passed the interview on my behalf.

In other words, I had been introduced as a senior developer. And just like that, I was told to give my best.

This must not have been the most fair or ethical situation, but in the hindsight, getting thrown into the fire so early, was one of the best things that could have happened to me.

If I had been placed on comfortable projects with a mentor who expected only junior-results and gradual improvement, I wouldn't have grown into who am I today. Or, at very least, it would have taken much longer, or maybe not happened at all.

I worked as a backend PHP developer on websites handling up to 5 million requests per day.

My role involved reviewing code, following Scrum methodology (Jira, Bitbucket, daily standups), and ensuring system stability. I was also the sole developer maintaining a PHP web application built on a custom PHP framework - essentially a search engine using Redis as the primary database.

This app also had millions of daily hits, making my responsibility even greater.

It was tough.

The backend code was complex, written by senior developers before me.

The project itself was a high-performance search engine using Redis as permanent storage (Yes, redis can also function like that, not caching layer only).

A few critical cron jobs ran daily, pulling data from third-party APIs to populate Redis, ensuring the system stayed up to date.

Challenges

The toughest challenge was getting familiar with Redis for the first time - almost every Redis data type was used, from hashes and sorted sets to pub/sub messaging.

On top of that, the critical cron jobs were massive, written in procedural PHP with thousands of lines of code and minimal documentation.

These jobs pulled data from multiple third-party APIs, processed it, and stored it in Redis as a primary database.

My first real task wasn’t to optimize anything but simply to reverse-engineer the logic so I could maintain and debug it.

And it needed debugging - there were data integrity issues, like mismatched actors and movies due to incorrect key mappings in Redis.

‍

Forgot to mention - this was also my first time working with Jira, loggin time, handling manual deployments by SSH-ing into Linux servers.

It was also my first experience with pull requests (PRs).

At first, every PR I made was reviewed by a senior developer who was gradually stepping away from the project.

For six months, I was juggling a log - debugging, maintaining the backend, improving the Redis data pipeline, and getting comfortable with the entire workflow.

After those six months, things became much easier. I had a deep understanding of the system, and maintaining the backend no longer felt overwhelming.

Final words for this project

To shorten the story about this project—one major task was improving SEO by fixing a mixed content error (explained here) and migrating the entire site to SSL. The issue was caused by some assets (images, scripts, and styles) still being served over HTTP, triggering console errors and affecting rankings. I had to carefully go through the entire codebase, update asset URLs, enforce HTTPS redirects at the server level, and ensure third-party APIs weren’t returning insecure content.

At the same time, I was assigned to refactor the entire frontend, which was my first deep dive into frontend development. The frontend was written in a mix of OOP vanilla JavaScript and jQuery, with a lot of legacy code and inline scripts scattered across different views. I had to structure the code better, modularize scripts, and ensure maintainability while keeping everything functional.

During this phase, I built various features like:

• Dynamic filters for searching through large datasets efficiently.
• Infinite scrolling using AJAX to improve UX and performance.
• Voice search integration, which leveraged the Web Speech API to allow users to search using voice commands.

After battling through all the requirements of this high-traffic project, I was assigned to new ones - each just as demanding. Most were large-scale systems, including one built on the Yii PHP framework, which was new and interesting experience. These were all client projects brought in by my employer, as it was an outsourcing company.

I worked there for about two years before I started thinking about new adventures.

Why?

Simply because, as an outsourcing company, my employer acted as nothing more than a middleman. There was no structured learning path, no real mentorship, and no technical guidance. They threw me into the fire, and I delivered - making them money. And while I was grateful for the experience, in the end, I decided to throw myself into a new fire, this time on my own terms.

I quit my software development job and started freelancing

At first I wasn't sure what my next step should be. All I knew was that I started freelancing on small projects - and I liked it.

Then, I friend from USA reached out, saying he had a big project to develop. I joined in on a small scale first, just to test the waters, but soon realized he was serious - he had a six-month development plan and a solid budget. The pay was good, but six months still felt short compared to the long-term security I had at my outsourcing job.

For several days, I brainstormed, weighing my options. I think these are the moments that define whether you're meant to go entrepreneurship path or not.

Then, I had a realization: "Okay, if the pay is better than my current job, and six months of work can cover 12 months of my salary here... Why not take the risk?"

So I did. I quit my job.

My friends and colleagues were shocked. "How? Why? It's too risky!" they said. But I had made up my mind.

A wave of emotions ran through me - fear, excitement and a bit of uncertainty. But there was no turning back.

I started working on a web app my friend brought me in for. It was a social media platform for hunters and outdoors men, designed to connect enthusiasts, share experiences and organize trips. 

The social media app for hunters was built with Laravel on the backend, using Laravel's templating engine (Blade) for the frontend. The frontend was a mix of Vanilla JavaScript and jQuery, with Firebase handling push notifications. MySQL served as the primary database, while Redis was used for caching. The app was hosted on a dedicated Linux server

However, I joined mid - development and the situation wasn't ideal. Previous developer - had quit, leaving behind a codebase full of bugs and unfinished features.

I've added my friend and colleague to help on the project. I forgot to mention that my wife(girlfriend at that time) was a frontend developer and we had her help too.

Realizing the scope of the project, I brought in my friend and colleague to help. I also forgot to mention - my wife (then my girlfriend) was a frontend developer, so she joined in as well.

Suddenly, we were a small but determined team, and I found myself leading it - coordinating tasks, coding, and handling all client communication. This was my first real experience in negotiation, project estimation, and leadership.

We worked day and night, refactoring messy code and fixing the countless bugs left behind by the previous developer - all while delivering new features requested by the client. Since we weren’t paid for refactoring, we had to balance cleaning up the project with meeting deadlines for ongoing work.

Client was delighted, but somehow this turned agains us. Client suddenly got too ambitious and re-purposed this social media

After we cleaned up the codebase, fixed the bugs, and delivered new, bug-free features, the client was thrilled. But that excitement backfired on us. He became overly ambitious and decided to pivot the project - transforming it from a niche social network for hunters into a general-purpose platform, like Facebook.

A wave of disappointment hit us. At that time, there was no proper social media platform for hunters, and we were excited to build something unique. But in the end, the client pays, and the client decides.

Long story short - the project lasted a year longer than expected due to constant new feature requests. And like many startups, it never saw the light of day due to lack of funding.

The project came to a sudden halt after a few failed investor meetings, leaving us without income. It was unexpected and hit hard. But from that moment, I learned a crucial lesson - never rely on just one client.

With no steady work lined up, we scrambled to pivot and find new projects. We turned to Upwork, cold outreach, and networking to keep things moving. But here’s the second big lesson - we had spent all our time and energy developing for our client, without investing in our own branding, marketing, or website. That mistake cost us.

‍

We managed to land some freelancing projects and keep paying our bills. It was an interesting time - we met great people, worked on exciting ideas, and kept pushing forward. But the income wasn’t what we hoped for.

Then, the COVID-19 pandemic hit. Investors started pulling funds, uncertainty spread across the market and we felt the impact firsthand.

‍

‍