Before I even started my career, I had already written a lot of code. Not beautiful, not well-organized, not even remotely good code — no. But a lot of pretty technical and challenging stuff. I wasn’t trying to build a portfolio — I just wanted to understand how computers actually worked.

Just a kid with a computer#

I learned Basic first, but quickly moved on to Pascal and Assembly Language. Pascal became my go-to for writing tooling: sine and cosine table generators, sprite animation tools, and various other utilities I needed for my real passion at the time.

That passion was the demoscene — a subculture dedicated to pushing hardware to its absolute limits.

If you want to see what the demoscene looks like today, Assembly in Finland is one of the biggest events still running.

I helped create one of the first demo groups on PC in my country, and we released a couple of demos that I’m still proud of. I also wrote some self-replicating code that could hide itself in RAM and on disk — the kind of thing that taught you how computers really worked at the lowest level.

Did I consider myself a “senior” back then? Of course not. I was just a kid playing with computers.

The professional years#

I started my career writing C++ for Windows, moving through a few companies over almost a decade. During that time, I wrote and sold some shareware.

After nearly ten years of professional work, I felt like I was starting to understand my craft. I was beginning to care about the right things — maintainability, architecture, the long game. But I still wouldn’t have called myself senior.

Then came another decade where my team and I rode the early wave of Java and C#. This was my opportunity to learn even more, and I kept publishing side projects along the way. It was during this period that I finally felt like I actually knew what I was talking about. I could think of myself as a senior.

What “senior” meant to me#

By that point, I had written a lot of very low-level code. I had programmed extensively in different languages. I had built desktop applications, server backends, native mobile apps, and frontend code. My team and I had created software that handled massive load and required us to hunt down countless performance bottlenecks. We had built complete, fully reproducible CI/CD pipelines from scratch. I had worked with cloud providers.

I’m not trying to brag — I’m just trying to paint a picture. By the time I considered myself senior, I had seen a lot of situations, solved a lot of problems, and made so many mistakes I’d learned from. To me, that was what seniority meant.

The new “senior”#

Contrast this with today’s world, where everything needs to move fast. At some large tech companies, you join as a Software Engineer, and within two years you’re expected to climb to the highest SE grade. Within four years, you’re “senior”.

But what do you actually know after four years of working on a narrow slice of a service inside a massive codebase? Where other teams handle your tooling, the libraries you use, your environment, your deployments? How deep have you really dug? How much of the big picture have you seen — let alone understood?

This isn’t a criticism of any individual — it’s just the reality of how modern tech careers are structured at certain companies. Four years of experience in what will probably be a forty-year career is ten percent. It’s barely the beginning.

If four years make you Senior, what shall I be called?

Jurassic developer?