Playmaker: The Reality of 10x Engineer
By: Ofer Karp
Tags: Software Development, Technology, Software Engineering, Leadership, Programming

Playmaker: The Reality of 10x Engineer

You become one by making 10 teammates 2x

“We will work as a group, we need to be a real team, that is the only way to go far” (Francesco Totti)

Sometimes I feel sorry for our recruitment team. They spent years looking for rockstar developers, only to realize that the developers they should have been searching for are actually ninjas. When they finally found where ninja developers live, and learned to speak the ninja language, the target moved once again. Right now, the thing they need to hunt is called a 10x engineer. But what exactly is a 10x engineer? How do you identify one?

Looking from the other direction, as a software engineer, if so many employers are looking for 10x engineers and some are willing to pay them 5x or even more, it’s only natural that I would do my best to become one. But what exactly does it take? Is there a set of skills or some kind of “10x criteria”?

Define x:

If you ask the head hunters what does 10x engineer means, they will probably say something like “Productivity! 10x is an engineer that can complete a task 10 times faster”. This sounds great, but before paying the 5x salary, I just have 2 quick questions:

When we say “10 times faster”, what is our baseline and to whom are we comparing? Is it “10 times faster” for any task our team has, or just for specific tasks?

Now, don’t get me wrong. I do believe that there are software engineers that can make a huge impact on our product, on our team, and eventually on our business. In some cases, a single uniquely talented engineer can be the difference between winning and losing. I have seen this happening and I will share two examples in this article. I can also share that as an engineering manager leading a fairly large team (currently at WalkMe we are over 200 engineers), I am investing a significant portion of my time in finding uniquely talented engineers and helping them take their best career decision which is to join our team. But I am not looking for engineers that can complete any task 10 times faster. I am looking for a different kind of magic.

“My mama says they were magic shoes. They could take me anywhere” (Forrest Gump)

The Two Types of 10x Engineers:

The way I see it, there are two types of 10x engineers. I will explain my theory and dive deeper into each of these two types, including a concrete example from people I worked with and teams I led.

Let me start by saying that both 10x types are valuable and that in most engineering orgs you need both of them. I would also claim that there are several personality attributes and behavioral patterns that are commonly found in both types of 10x engineers. But in terms of the type of excellence they bring to the table, they are completely different from each other.

Type #1: Wide & Shallow:

I want to take you back to 2012. I was working for HP, leading the R&D group for a product called UCMDB. The product’s main value prop was providing Ops people with a near-realtime picture of the topology of the infrastructure and applications they were operating.

The data we were collecting and storing was super valuable, the only problem was that in order to actually be able to use this data the user had to be both an expert in graph theory as well as have an intimate knowledge of our proprietary data model. In reality, the learning curve was so steep, that most of our customers had no more than 3 people who were able to query the data. All other potential data consumers had to “submit a request for a UCMDB view” and wait for these honorable 3 admins to prepare it for them. Not a very efficient way to consume real-time data.

UCMDB original query builder

After a few failed attempts to simplify the query language plus a series of cosmetic UI changes that miserably failed to bring more users into a very advanced application, we decide to take a different direction:

Instead of our old and heavyweight application (huge java applet) that could only run on strong desktops, we wanted a modern and lightweight web application that can run on any device including tablets and smartphones.

application (huge java applet) that could only run on strong desktops, we wanted a modern and web application that can run on any device including tablets and smartphones. Instead of a super complex query creation experience that was based on pattern matching on directed graphs, we wanted a simple query creation experience that is based on natural language search.

query creation experience that was based on pattern matching on directed graphs, we wanted a query creation experience that is based on natural language search. Instead of the old-fashioned query results consumption interface with multiple tabs and huge results tables, we wanted a modern interface that presents only the important data points and then helps the user to navigate and extract more information.

query results consumption interface with multiple tabs and huge results tables, we wanted a interface that presents only the important data points and then helps the user to navigate and extract more information. Instead of our slow-paced release cycle (a version every 6 months), we wanted to be able to continuously release new features and have a short feedback loop.

Introducing: UCMDB Browser (AKA “Mitzi”)

But how do you do that? We were aiming to introduce to the market something that isn’t just incremental, but rather a game-changer capability that will make our product relevant to new use cases and new personas. Clearly, for such an initiative to be successful, we couldn’t use the tech stack, architecture, and dev methodologies that we were using in other areas of our product. We needed something completely different.

This is where a “wide & shallow” 10x engineer shines. Before assembling a full feature team, we assigned him the task of building the skeleton of the new app. Now I know it sounds a bit strange. How can one person be an expert in so many domains? But in reality, after 4 weeks or so, we had a nice app skeleton, with a search engine that could translate natural language search terms into the existing topological queries, with a simple backend that exposed a RESTful API, and a basic Web fronted (implemented with GWT which was a thing back then). All wrapped with a good CI/CD pipeline and a testing framework (unit, component, E2E) that was based on ideas and tools that were suitable for satisfying our continuous delivery requirement.

This app skeleton created by the 10x engineer wasn’t production-ready. It wasn’t supposed to be. But it gave us a great starting point for the entire feature team to start from. The 10x engineer who created the skeleton doesn’t just throw it over the fence to the team. Instead, he is becoming part of the team. At this point, his mission is to ramp up the different team members on the tech stack and architecture he chose, in a way that will allow them to become the experts and the owners of the product. This is usually done best with 1:1 sessions, tailored to the domain expertise and skill set of each team member.

In the UCMDB case, this worked pretty well. The team very quickly ramped up. They embraced many of the ideas and directions that were used in the app skeleton while also changing a few. For some of the team members, this was an opportunity to learn new technologies and more important to be coached by a very experienced and talented engineer. After 3 months of focused work by a team of 8 engineers, we released a new product called UCMDB Browser to the market. It was a huge success both from a business perspective as well as from an engineering perspective.

Our 10x movie

Type #2: Narrow & Deep:

There is a common pattern that I keep on seeing in many engineering teams that are working on successful products and fast-growing businesses. The pattern is not very easy to explain, but generally what happens is that an area in the product that used to be one of your strengths and even a core differentiator from competitors, gradually becomes very hard to support and maintain. In many cases, It’s not easy to identify the pattern and admit that this is happening to you, especially for people who have been part of the team for a long time. But when you analyze how your resources are allocated, you realize that a nice chunk of your team (developers, support engineers, professional services engineers) are spending most of their time fighting to keep alive what used to be a core product strength.

This common pattern also happened to us in my current team at WalkMe. One of the strengths of our platform is the ability to identify GUI elements in the hosting application (the application that WalkMe is running on) in an efficient and reliable way. We had a working solution, that was built in the early days of the company (~9 years ago) and was continuously extended and improved since then. It was (and still is) by far better solution than what other vendors (including all our competitors) have in the sense that it was able to identify more GUI elements, faster, and with low overhead on the resource consumption (CPU, memory) of the hosting application.

With success comes scale. More customers, more data, more use cases. In the domain of GUI element identification, the factors that added complexity were the requirement to support new UI technologies (Single Page Apps, Shadow DOM, etc.) and the requirement to support highly personalized applications in which the GUI that is presented to each user might be different based on her role, geo-location, or simply her user preferences. Our “Find Element” module was flexible enough to satisfy these requirements (usually by adding plugins for specific UI technologies and platforms), but the amount of effort that was required to keep this machine running was gradually (but constantly) increasing.

“Perhaps time’s definition of coal is the diamond” (Khalil Gibran)

Identifying the pattern is nice, but doing something about it is the real deal. We understood that we need to build the next generation of our GUI element identification solution. The primary goal was to improve the accuracy and robustness of element identification. On top of that, we wanted a solution that can evolve beyond just identifying single UI elements, toward understanding context and discover user flows in the application. Much like in the “wide and shallow” example, it was clear that this isn’t an incremental addition to the existing product, but rather a complete replacement of one of the core engines in our product.

But how do you replace the engine while the car is driving full speed? This is where a 10x engineer can make a huge difference. Actually, in our case, it was 2 10x engineers. It all started with a strategic acquisition of a small company called DeepUI. The acquired company was not focused on building the exact thing WalkMe needed, but the 2 engineers that founded DeepUI were top tier experts in using machine learning for GUI understanding.

The next phase is research. You want to analyze the existing solution, and understand how it performs with the different use cases. This serves as a “minimal requirement” definition for the new solution, and it may take a few months depending on the complexity of the system. Only then you can design the new solution and build an initial prototype. As with all “replacing the engine” projects, there is a huge value in being able to run the new solution alongside the existing solution, in production, and on real data. This is the best way to validate the strength and weaknesses of the new solution. Clearly, this isn’t easy to build, but that exactly why you need 10x engineers.

Then comes the really tricky part. You have successfully validated the new solution, and you now want to productize it and start migrating your customers from the old solution to the new one. For this, you must build a team. Suddenly, the 10x engineers need to switch from being researchers and developers, into being leaders. And not just ordinary leaders, but rather super leaders. Among all types of projects that an engineering org may be involved in, this is the most complicated and risky type. Replacing the core engine of the product? checked. Introducing a new paradigm (ML)? checked. Impacting the daily work of multiple teams in the company(R&D, Support, Services)? checked.

How do you make this switch and build such a team? I don’t think there is one recipe and it’s truly very rare to find people that are capable of doing it. One thing that worked well was offering people that were working in the teams responsible for the legacy solution, to move to the new team that was building the new solution. It worked well because these people were domain experts, and they understood the huge value of the new solution. They also knew best what it takes to migrate from the old solution to the new one. Finally, for them personally, it was an opportunity to work with very strong engineers and learn new technologies. At the end of the day, it’s all about people and leadership. The engineers who started the project really became 10x engineers only when they managed to create a strong team that can make sure the new solution works in production at scale.

In our case, it worked very well, and we now have a team of ~30 engineers working on DeepUI. The solution is in production, and we are already working on leveraging its potential for additional use cases.

“Before we work on artificial intelligence why don’t we do something about natural stupidity?” (Andy Kelly on Unsplash)

10x Impact on People:

Although the two types of 10x engineers are very different in terms of the things they do exceptionally well, there is one thing they have in common: 10x engineers of both types have a huge impact on other people in the team. Here is how they are doing it:

Role Model: other engineers want to be like them. It starts with the compensation package they have and goes further to the impact they have on technological decisions being made. Their existence is proof that there is a technical career path, which means that as a good engineer you don’t have to become a manager in order to be promoted. Standards: since other engineers want to be like them, they will try to replicate their professionalism and adhere to the technical standards they set. You will find that people are actually following their lead, reading their code, using the same design patterns they used, write tests in the same way, document and present their work like them, etc. Mentoring: it takes one to know one. 10x engineers are very good at detecting junior engineers with the potential to grow and become experts. With a small push, each 10x engineer can be a great mentor for at least one talented junior developer.

“Winning one league title at Roma, to me, is worth winning 10 at Juventus or Real Madrid” (Francesco Totti)

Conclusion:

10x engineers do exist in reality. As a manager, finding engineers that can have a 10x effect on your team requires time and focus, but it is well worth the investment. A super talented engineer can make the entire team 10 times better, similarly to a super talented playmaker taking an average plus football team all the way to the league championship.

As an engineer, it is possible to become 10x. You can either take the “wide and shallow” path or the “narrow and deep” path. In both cases, this is going to be a long journey, so pick a domain that you really love. Last but not least, always remember that it’s not only about how much knowledge you have or how great your execution skills as a developer are. Being 10x is all about your ability to lead other engineers and make them better.