Reflections on My First Few Years in Tech

Foreword

Before I knew it, I had spent several years working in the internet industry.

Back when I first started learning to code, I was writing all kinds of demo projects every day. From the simplest Hello World to little games, web crawlers, and admin dashboards — every new technology I picked up brought a real sense of achievement. I learned fast in those days, and I was full of enthusiasm.

As time went on, I gradually noticed something distinctive about this industry:

The barrier to entry isn't especially high, but the ceiling is extremely high.

The body of knowledge in the tech world is enormous. The more you learn, the more you realize how little you actually know. Much of the time we are simply standing on the shoulders of giants, looking up at even taller giants.

The Early Stage of Growing as an Engineer

In the early stage, most people level up in a few common ways: learning new frameworks, imitating excellent projects, reading technical articles, and building demo project after demo project.

The open source community in particular is full of great design ideas, architectural patterns, and high-quality code. Reading those projects is a fast way to absorb a lot of engineering practice.

But if you want to genuinely raise your ability, there is one process that matters more than anything:

Building a complete system entirely on your own.

From system design and implementation to deployment and ongoing maintenance — going through that whole cycle gives you a much deeper understanding of software development. The first time you design a system architecture yourself and watch it run stably in production, the sense of achievement is intense.

Hitting the Plateau

As experience accumulates, most engineers eventually reach a stage where technical growth slows down noticeably.

At this stage, the work is no longer simple feature development. You have to think about far more complex concerns, such as:

• System security
• Reliability
• High-availability architecture
• Performance optimization
• Monitoring and operations
• Scalability
• Deployment and resource management

As systems grow, the architecture becomes more and more complex, and the range of technologies you need keeps expanding. Many people get anxious at this stage — they feel their learning has slowed, and some even worry about being replaced by younger engineers.

In reality, breaking through this plateau rarely depends on raw learning speed anymore. What it takes is long-term accumulation of experience and a large volume of real project practice.

Why Depth Matters

Once your skills reach a certain level, what truly matters is no longer "how many technologies you know," but whether you have developed a core technical strength of your own.

Plenty of young engineers write excellent code, yet still lack experience in whole-system design, architectural thinking, and analyzing complex problems. That gap comes, fundamentally, from years of technical accumulation.

To keep improving past a certain point, you have to keep pushing the boundary of your knowledge outward rather than staying in a single domain.

Take databases as an example — a complete body of knowledge there includes:

• Relational databases
• Non-relational databases
• Graph databases
• Data storage structures
• Sharding strategies
• Storage engine internals

The database is often one of the most critical parts of a system, so understanding its internals matters enormously for architecture design.

The Complexity of Software Architecture

As a system scales up, its architecture touches many different technical domains, for example:

Deployment and Resource Management

• Docker containers
• CPU / memory / bandwidth limits
• Storage performance

System Architecture Design

• Microservice architecture
• API design
• Scalability
• Performance optimization

Distributed Systems

• Sharding across databases and tables
• Multi-region active-active
• Disaster recovery

Security and Data

• Encrypted communication
• Security policy
• Data validation

Even things that look like minor details — a database column's length, how many bytes a value occupies, the design of API parameters — can affect how far the system can scale in the future.

That is why a great architect needs more than strong technical skill: they need a broad base of knowledge and deep practical experience. Architecture, to a large degree, determines how much room a system has to grow.

The Different Roles in Software

Different roles in the software industry carry different responsibilities.

Product Manager

Decides what problem the software should solve and where the product is headed. A good product manager needs to understand not only market demand but also the cost and constraints of technical implementation — otherwise it's easy to design features that can never realistically ship.

Project Manager

Leans toward project management: schedule control, task allocation, and team coordination, with a clear grip on the overall state of the project.

Engineer / Architect

Responsible for technical design and system implementation — finding the right solution within a complex technology landscape and keeping the system stable over the long run.

The Shift in How You Grow

Past a certain point, many engineers gradually realize they are no longer just users of technology — they start trying to understand the deeper questions.

For example:

• Why is the system designed this way?
• Why does a particular architecture fit this business better?
• How do you break through the bottlenecks in a complex system?

From using open source software at the start, to contributing to open source projects, to eventually designing your own frameworks or middleware.

This is one of the most important transitions in an engineer's growth:

From a user of technology to a creator of technology.

Final Thoughts

Looking back on a career, perhaps everyone eventually asks themselves one question:

What has kept me going in this industry?

A hunger for technical knowledge? The fire of youth? Or has technology simply become part of life?

Maybe the answer doesn't matter much.

What matters is that in this ever-changing world of technology, you hold on to:

Curiosity, the ability to learn, and the passion to keep exploring.