(With apologies to my good friend Jeff Hodges this is a takeoff on Distributed Systems for Young Bloods).
I’ve been thinking about the lessons startup engineering managers learn on the job. A great deal of our instruction is by making mistakes, and as leaders, those mistakes often cost us real opportunities: people who don't join the company, people who quit, projects that don't ship, sometimes even our jobs. These scars are useful reminders, sure, but it’d be better to have more managers with the full count of their fingers.
Below is a list of some lessons I’ve learned as an startup engineering manager that are worth being told to a new manager. Some are subtle, and some are surprising, and this being human beings, some are inevitably controversial. This list is for the new head of engineering to guide their thinking about the job they are taking on. It’s not comprehensive, but it’s a good beginning.
The best characteristic of this list is that it focuses on social problems with little discussion of technical problems a manager may run into. The social stuff is usually the hardest part of any software developer’s job, and of course this goes triply for engineering managers.
I'm a distributed systems engineer by training, and I enjoy drawing lessons and making comparisons between the two worlds. I wrote this post with many indirect references to Jeff's original screed because I found it mapped quite well. It's long, and each entry is itself worthy of one or several posts, but I hope you will find it a valuable introduction.
OK, having copied Jeff's intro and lightly reworded it, let's dive in.
Managing people at startups is different because you have no safety net. You may think, having spent a few years at a big company in a management position, that you know how to manage already. You've given performance reviews, done interviews, dealt with project timelines, played politics. You know the basics. Right?
Here's what you don't see until you leave the safety of a big company. You don't see the millions of invisible systems all around you that have set you up for success. The army of recruiting personnel, the pipeline of aggregated talent, the power of a known brand. You don't have to figure out salary bands. You have standards, you have processes, you have rules, and you have people who make it relatively easy for you to live by those standards, processes, and rules. You have no idea what it is like not to have someone to check your work, to make sure that people get paid on time, that reviews happen, that holidays are tracked, that budgets get approved. You've never looked at an excel spreadsheet of numbers for year-end compensation only to find it full of errors that needed correcting.
Or maybe you've never been a manager at a big company. Your whole career has been spent in startups, and you have not only no management experience at all, but you've never experienced the safety net. You too are in for problems, but they will be much harder for you to detect, because you don't know what a smooth-running operation even looks like. You are comfortable making your own rules, but you may not appreciate the value of having a machine behind you. Instead of chafing at the chaos, you not only thrive in it, but create more of it.
In both cases, creating the safety net yourself is part of the job, whether you realize it or not. Create sane processes, sane standards, and shared values, so that the team can scale without you having to make every decision yourself. If you find your team has doubled and you're still making roughly the same decisions you were before it doubled and you're just working twice as hard to get it all done, you are trying to paper over the safety net via effort. It doesn't work.
Coordination is very hard. "I hate agile!" Yeah, I get it. But when you are expected to know the progress of 10 very different projects off the top of your head, and teams across the company from each other cannot seem to get on the same page and you find yourself in meeting upon meeting upon meeting trying to align roadmaps and get some clarity as to what the hell is going on, you may feel that at least getting some shared vocabulary and process across the company is a valuable exercise. Many tactics and theories exist for how to solve this problem, but we must acknowledge that it is fundamentally difficult, and it is unlikely that you are going to solve it perfectly on your first try.
The amount of overhead that goes into managing coordination of people cannot be overstated. It's so great that the industry invented microservices because we'd rather invest engineering headcount and dollars into software orchestration than force disparate engineering teams to work together. And even that is an illusion when it comes to true cross-functional efforts. It turns out, there is a reason big companies end up with project managers who spend all day making sure people are talking to one another.
If the set of projects going on can fit into your head, your project list is probably trivial. I do not say this to malign your company, but there is a huge separation between the management style that you can afford when you know everything that is happening in detail, and the management style when you have to do some deep reading to even know what is going on in an area.
If the set of people is small enough that everyone knows everyone else, politics is trivial. You'll have it, sure, but it will almost always be very visible very quickly. Now is the time to get out in front of it. Politics at this scale is probably a sign of either organizational illness or a lack of cultural unity. If you can easily put a label on the type of people most often bearing the brunt of the politics (engineers, marketers, women, new grads, etc), it's probably a sign of organizational illness that you need to address unless you want it to fester and cause bigger problems as you go. Unless you can literally grow your business without that group represented, you don't want to create a culture that completely excludes an entire group. If, on the other hand, the people who bring politics share personality characteristics that are not strongly correlated with their gender/race/job/experience-level/etc, then you need to figure out what kind of culture your company actually is, and start screening for that in hiring. The sooner you realize what values your company truly holds, the easier avoiding these types of problems will be. If you do not figure out your company's values, as you grow, politics will become worse and worse.
“The team is moving too slow” is the hardest problem you’ll ever debug. When your CEO asks you why nothing is getting done, why we can't do everything on their laundry list, why the project they expected would launch next quarter is still two quarters out, accurately answering that question is incredibly difficult. Once you are a level or two removed from the actual people doing the work, your previous debugging process of "going to every meeting, watching the work being committed, understanding every detail of the project" does not scale. You have to figure this out from a distance.
Implement trust and communication throughout your team. Your management team MUST trust you, and their developers MUST trust them. The basis of trust is doing what you say what you will do. At the most basic level, this is done by scheduling regular 1-1s and then showing up for them. If you don't have time to do this, think about whether you can handle having so many direct reports. You have to lead by example. Whatever you do to your direct reports will probably flow down the chain. If you disrespect their time, they will disrespect the time of their direct reports. In addition to 1-1s, find ways to be available to your whole team. I am a fan of office hours held weekly that anyone can sign up for. Spend time in the channels where the team hangs out. Show up for drinks and demos. Participate in hackweek. Enjoy this rare opportunity to build a team yourself by spending time with the team you built!
Metrics are not the only way to get your job done, but they can be useful. How often do releases happen? How often do people check in code? How many tickets are outstanding? How much time do people spend in meetings? How many people do you really need to hire this month? Here's the challenge: you're dealing with small data sets (lies, damn lies, and overfitting the data). Even if you have a year of github activity data, understanding WHY a person is coding infrequently requires an understanding of what is going on in that person's life. They may have just become a manager!
This also applies to goal-setting. If you miss your KPIs, what does that mean? Fundamentally, are you measuring the most important things?
Learn to estimate your capacity, and your team's capacity. You should know how much you can realistically do in a week. If you constantly find yourself not finishing something you said you would, you are overestimating your capacity. When you aren't finishing important things, it is a sign that you need to either delegate or simply STOP DOING SOMETHING. That something you need to stop doing is often writing code.
Here's a useful trick for estimating team capacity:
If we got some number of features done this year with our current engineering staff, we will need ~20% more engineers next year to get the same number of features done.
Technical debt and production support implies long-term cost for every new feature. You have to account for that. This is why big tech companies seem to grow massively every year.
Prepare for long feedback loops, and look for opportunities to shorten them. The feedback loop from "hired someone" to "figured out their total impact on the organization" is the duration of a person's time at a company. You will write strategies that may take years to implement. When you are coaching someone to improve in an area, that coaching will often take weeks or months to actually result in behavioral change. You are no longer in a red-green-refactor cycle. Anything you can do to build out quicker feedback loops into the company and your personal style will generally pay dividends. Beyond the common wisdom of not waiting for review cycles to give people both praise and areas for improvement, some things you can and should do:
- Get your teams in the habit of releasing code as frequently as is reasonably possible. That may not be "continuous", but it probably looks like more than once a week. If your team is unable to release code frequently (barring stupid shit like Apple store processes), it is a sign of potential bottlenecks.
- Postmortem time? Try to make sure it is held the day after the incident, when it is fresh in people's minds.
- Look for ways to prove out ideas early. This includes your architectural and strategic ideas. Work them organically into the product roadmap, to show value early.
Choose your structure (or lack thereof) wisely. You may not personally be creating technical debt much anymore, but that doesn't mean you aren't creating organizational debt. When you roll out a half-assed engineering ladder, this new structure may actually make your life harder, because now you're going to have to negotiate with engineers eager to debate the finer points of broad and vague language. Early on, structure doesn't matter much, but at some point you have to address it. Interested in going the Holacracy or other self-organizing route? I highly recommend reading Reinventing Organizations. Because guess what? They also require some thought and process to work! Be prepared to be thoughtful about this and put some time into it.
The worst situation is having random titles, random pay, random equity. I have stopped counting the number of people who have told me that they discovered massive unfairness in the salaries and equity paid to members of their team. It happens easily. You pay early employees less, assuming you'll give them more valuable equity, but that does not always happen. As the company gets bigger and the market rates change, you hire new people in at higher salaries, but never adjust older people. Cleaning this up probably requires setting up a structure for levels, pay ranges for those levels, and actually increasing the salaries of many people to bring them up to level.
People can do more than they think they can. This goes for you, and for your entire team. I can't tell you about the failure patterns of people who overwork their teams because that's not my personal failure pattern (yet). But I do sometimes fail to push people hard enough. Engineers want to ship. This goes double for startup engineers. If they are not shipping much, they will start to complain of boredom, and go looking for ways to make trouble. This may result in you having overengineered systems in prod, engineers who quit to go to a new shiny company, or worst, engineers who first push overengineered systems halfway to prod then quit to go to a new shiny company.
I know my boundaries and rarely respond well to people trying to push me to do things. I push myself hard enough. This is true for some engineers, but not all. When you are not pushing them to get something done, you may be trying to give them space, and they may consciously appreciate that while unconsciously start to think that their work doesn't matter that much. If it mattered, my boss would be pushing me!
So, if you have an engineer complaining of boredom, ask them to finish what they're doing faster. I once heard this on the topic of infrastructure engineering: "If you're bored, try doing it all 20% cheaper". Engineers will often identify interesting hard problems when they try to do things faster. Such as: it's hard for me to run tests because they're too slow, getting to prod takes a long time, the build is always broken, this downstream system is not responsive. You were saying you're bored?
People will quit. As sure as the sun rises, as sure as networks occasionally partition, people will quit. They will quit because you are a bad boss. The will quit despite you being their best boss ever. They will quit to move across the country. They will quit because they don't see the future with your company. They will quit because they got another offer they can't turn down. They will quit because it is time for them to move on.
You cannot control all the reasons that people quit, but it will feel like a punch in the gut every time it happens. Your job is to keep going. To put on a smile and go out and recruit. To rally the team. To celebrate that person even as you are seething inside, how dare they leave me right now! Try to identify common causes for people quitting your organization, and address them as best you can. Especially if those causes relate to the environment that you help create (harassing, aggressive, burnout, underpaying, favoritism, politics). If you can in good conscience look at your environment and believe that it is in pretty good shape, then be kind to yourself.
One of my greatest accomplishments was this: I told my team over the years that if they were seriously looking to move on, to tell me and let me help them find a new job. This finally happened for the first time this year and it felt like a massive win. If you care about your team, helping them move on when they want to move on is a great honor.
Jeff didn't manage to find a concluding paragraph. It's hard to put a conclusion on what is ultimately a brain dump. But here is mine:
Your job is to survive. Put one foot in front of the next. Keep going. Be open-minded. Be curious. Read about what other people are doing. Make friends who are running tech at other companies. Be kind to yourself, even if you fail. You have the power to make the world better for all of those people on your team. Use it responsibly.