Introduction

Today, I will talk about a career in software engineering and what it means to be an effective software engineer.

Responsibilities of a Software Engineer

First of all, let’s define the responsibilities of a software engineer. It’s not merely about writing code or drawing designs for 8 hours a day. The primary responsibility of a software engineer is to solve business problems through software engineering.

Who is an Effective Software Engineer?

It’s critical to understand the pathway to becoming an effective software engineer. After understanding the responsibilities of a software engineer, I can confidently say that merely writing another 100 unit tests does not make one more effective. Instead, solving business problems quickly does. Take, for example, database optimization, which prevents client issues with each new software release. An ineffective software engineer might spend a month fixing a problem, whereas an effective one could do it in a week. This leads to the definition of an effective software engineer as a person who quickly solves business problems.

But this is just the first part of the puzzle. If we focus only on this aspect, there’s a significant risk of becoming a good employee without personal growth and happiness in life. For an employee who concentrates solely on business problems, it means neglecting the job market and economic volatility, which can lead to layoffs, poor salaries, and a constant fear of being fired. In today’s IT market, this situation leads me to a second definition of an effective software engineer: a person who can quickly adapt and change jobs.

How to be an Effective Software Engineer?

Having understood the definition of an effective software engineer, which includes two parts:

1. A person who quickly solves business problems.
2. A person who can swiftly change jobs.

I can now offer some advice on becoming an effective software engineer.

Solving Business Problems Quickly

To become someone who solves business problems quickly, one must first understand the business they are working in — how it earns money and what its real problems are. Let’s consider some examples.

Example 1: A B2C Product Company with Rapid Feature Development

This company will focus on how quickly a software engineer can develop new features and how stable these features will be. At the same time, the quality of the source code plays a significant role because when a company is constantly developing new features, high-quality source code is key to continuing to develop new features quickly.

In this company, a software engineer should focus on the following areas:

• Speed of new feature development.
• High quality of source code — this will allow for the continuation of quick feature development, as low-quality source code can make it very hard to develop new features, especially in cases like a Java class with 5,000 lines in a main method.
• Unit tests — this will enable the quick identification of any issues when a new feature breaks an old one, thus supporting faster development.

Example 2: A B2B Product Company with High Software Stability

This company will focus on how quickly a software engineer can develop new features and their stability. However, unlike Example 1, the main emphasis in this company is on the stability of the software, rather than the quality of the source code, due to the reliance on B2B clients who need a stable product for their business needs.

Software engineers in this company should focus on:

• Speed of new feature development — speed is always important, regardless of the company type.
• High stability of the source code — given the need for stability, software engineers should include tests for stability and continuously check edge cases to prevent the release of unstable software.
• Unit tests — Stability tests are crucial to ensure the software remains stable.

These examples demonstrate that companies may have different objectives and implementation strategies. Therefore, software engineers should be mindful of these during their work. A focus on different areas, such as stability over source code quality, doesn’t necessarily imply a company is bad; it simply indicates a different focus area.

Meanwhile, there are some areas common to all companies where a software engineer should improve their skills:

• Excellent Knowledge of Tools: If the company uses Spring Framework and the engineers works with it, they should have a very good understanding of Spring Framework. This knowledge guarantees rapid feature development without needing to consult with colleagues frequently.
• Excellent Knowledge of Infrastructure: It may sound strange, but understanding the infrastructure is essential for a software engineer, even with a separate DevOps department. If the company uses AWS, the engineer should be proficient with AWS and capable of developing infrastructure on it. This knowledge is necessary for providing better solutions and sometimes for implementing new features.
• Excellent Communication Skills: Communication is critical in any role, particularly for software engineers. Many engineers, including myself, initially chose this profession to work more with machines than people. However, the reality is that effective communication is key to efficiently solving business problems. Software engineers should communicate with others without criticism and passive aggression.

Following these pieces of advice will make you a good employee, but not necessarily an effective software engineer. Remember, life is more than working at one company. To be an effective engineer, focus on yourself first. You can’t help the world without first helping yourself.

Quickly Changing a Job

In the previous section, I offered advice on how to be a good employee, but as mentioned earlier, this alone is not sufficient to become an effective software engineer.

In today’s world of layoffs and economic instability, a key skill for an effective software engineer is the ability to quickly change jobs. This is crucial because being an effective software engineer first requires having a job in the field. The skill to swiftly find new employment largely depends on the market in which you are working. While I will provide some advice based on the markets I have experienced, the best way to develop this skill is through personal research and investigation.

Europe

In Europe, the most crucial skills for a software engineer are direct hard skills that solve problems: programming, system design, infrastructure, and concepts like DDD and SOLID.

While aspects like system design, programming, and DDD are straightforward, I highly recommend focusing on infrastructure. In Europe, knowledge about Kubernetes and AWS is very common in interviews (at least in my experience). Therefore, acquiring AWS Solution Architect certification or Certified Kubernetes Developer (CKAD) certification can be a significant advantage.

Interestingly, I have rarely encountered algorithmic questions in interviews. For those preparing for an interview in Europe, I can recommend the following courses on infrastructure:

• Kubernetes Certified Application Developer (CKAD) with Tests
• AWS Certified Solutions Architect Associate (SAA-C03) Course

USA/Canada

For the USA or Canada, the situation in the job market for software engineers is slightly different than in Europe. The main skill that is always asked about in interviews is algorithms and data structures. I interviewed with different companies here (from small to big), and I was always asked about algorithms and data structures in the first interview. At the same time, infrastructure skills are important, but not as critical as in Europe, so to prepare for an interview in the USA or Canada, it makes sense to focus on algorithms and data structures. Of course, system design and programming are critical skills too, but they are critical in all markets, so I will not stop on them.

I can recommend this course and set of exercises to prepare for algorithmic interviews:

• LeetCode’s Interview Crash Course — an excellent course about algorithms and data structures.
• Top Interview 150 — just a list of 150 excercies.

Also, after preparation, it makes sense to have continuous practice at home with algorithms and data structures at least once or twice per week, even if the job is stable.

A common recommendation for all markets and preparation for system design interviews:

• Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems — an excellent book that provides very strong knowledge. (I read it twice for my work but still recommend it for interview preparations — in 2020 and in 2023; each time it helped me to build better systems)
• Grokking Modern System Design Interview for Engineers & Managers — a good course.

Conclusions

In this post, I provided advice to be an effective software engineer, which contains two parts.

Quickly solve business problems

1. Excellent knowledge of tools that the company uses.
2. Excellent knowledge of infrastructure.
3. Excellent communications skills.

Quickly find a new job

1. Be constantly prepared for new interviews in the market where you are working.
2. For Europe — infrastructure knowledge is critical, for USA/Canada — algorithms and data structures.