This year marks my 8th year working at Google. Throughout that time, I’ve been on three different teams and met a ton of smart people.
I simultaneously feel like I’ve learned a ton, yet, I have so much more to learn.
The lessons I’ve learned mostly apply at large tech companies, but many of the principles apply across the tech industry.
Anyways, enough with the intro. Let’s get into it.
1. Leadership is harder than it looks
When you’re fresh out of college, you assume that everyone else knows what they’re doing, including your manager.
Wrong.
My managers have always aimed to be good at their job. But, they’re also human. They’re caught between multiple projects and a large number of people with competing interests. They have limited energy and attention. They don’t have the same information as me or any of their other reports.
So, sometimes they make mistakes.
Furthermore, I’ve learned that you don’t have to be a manager to be a leader.
Imagine proposing an API change, convincing a senior engineer to approve the change, and getting a partner team to implement one of its dependencies. That’s leadership.
In that situation, you might have only spent 20% of your time writing code. Years ago, I would have been shocked if that happened to me. That brings me to my second lesson…
2. Your job is to solve problems, not to write code
During my first year in the software industry, I thought my job was right as much code as possible. I’m a software engineer, so that’s my job, right?
My job is to solve problems. If the problem can be solved with a smaller amount of code, that solution is probably better.
If the problem can be solved with a configuration file change, that’s even better.
If we can avoid doing any work at all, that’s the best solution.
I came to realize it’s worthwhile to do other tasks like meet with other teams, write documentation, and track project statuses in spreadsheets.
I went from “How do I solve this problem in Objective-C?”
To
“How do I solve this problem?”
To
“Do I need to solve this problem at all? And if so, can I do it in a generic way that requires as little effort as possible?”
I learned to tell my manager about the problems I was solving in our 1:1s. Sometimes it was a status report. Other times, I asked for his advice. This brings me to my next lesson…
3. 1:1s are useful (when done properly)
When I first started my job at Google, I thought that 1:1s were overhead where you have to talk to your manager. You provide some status updates, go through the motions, blah blah blah.
When done right, 1:1’s are actually a way to turbocharge your career development. I love using 1:1s to influence my manager and to understand how I can better serve the team.
I go into this in a lot more detail in How to Stop Having Sucky 1:1s. Check it out and tell me what you think.
In addition to one-on-ones being a waste of time, I also thought this other thing was equally useless…
4. OKRs are useful (when done properly)
OKRs are “Objectives and Key Results”. Basically, it’s a way of summarizing quarterly or annual planning. Here are some generic examples:
- Foo Service has improved availability by 0.5%.
- Foo Service has reduced latency by 10%.
- 40% of clients have migrated from Bar Service to Foo Service.
I used to think OKRs were a waste of time. This was because my first few teams at Google had no relation to our broader organizational OKRs. (Which was part of their downfall.) So my org’s OKRs had no relation to my day-to-day work.
But when done properly, OKRs are extremely useful. OKRs are used to focus the team on the most important pieces of work. If something’s not on the OKRs, it can probably be safely dropped (which also has the side effect of making someone mad. But that’s beside my point. See lesson #8 below.)
Of course, I don’t recommend sticking to a plan for the sake of sticking to a plan. OKRs are supposed to give you enough flexibility to achieve the goal without describing exactly “how”. For instance, if your OKR is “Foo Service has reduced latency by 10%” You might make a lot of small incremental improvements. Or, you might launch one big change that improves latency by 10%.
The other problem with OKRs is that sometimes your original OKRs no longer apply halfway through the quarter. For instance, you might start by reducing latency, and then get preempted by DMA. Now, latency is no longer an issue. Such is life.
Speaking of DMA and all its logging messiness, that reminds me of my next lesson…
5. Logging, metrics, alerting, and testing are way more important than I thought
I used to think coding was the main part of software development. But there’s a lot of stuff around feature development that’s super important, too.
Logging and metrics are important because you need to know how users are using your feature. You need to know how your future is performing (e.g. availability, latency, SLOs, resource usage).
Alerting is important because you want to know when something breaks. It’s even better when you get to know exactly what change caused the breakage.
Finally, testing is important because it prevents bugs from happening in the first place. I wish more CS programs required students to take classes on writing good tests. Blanketing the codebase in unit tests is necessary but not sufficient.
This next lesson is completely unrelated to testing.
6. Dress for Success
The common Hollywood image of a software developer is a guy with a scraggly beard wearing a sweatshirt and gym shorts.
However…
You’ve probably heard of the study where a group of doctors were divided into two smaller groups.
The first group wore white coats. They looked like professionals.
The second group were plain clothes.
Later, patients were asked to rate the competence of their doctors. The doctors who wore white coats received higher scores than the doctors who wore plain clothes.
This is a strange quirk of human psychology. People shouldn’t care how you look, but they do. You could be the next Alan Turing, but if you dress sloppy, people might not take you seriously, especially if you’re young or from an underrepresented group in computer science.
So, I regularly wear clean slacks and a button up shirt during business hours. It doesn’t take longer than putting on a wrinkly t-shirt and basketball shorts. Maybe it doesn’t make a difference. But I look good, and it helps people see me as a professional. And when they see me as a professional, we act like professionals, and we treat each other like professionals.
And, if you work at Google long enough, you become a professional at this next thing: handling reorgs.
7. Reorgs can make or break your job (in the short term)
There are two types of reorgs.
The first type doesn’t affect you at all.
The second type obliterates your team.
You have no control over when or how reorgs happen. However, you can sometimes use them to your advantage.
I used to work on a product that leadership didn’t care about. For years, I struggled to convince partner teams to build features for us. No matter how hard I pushed, the rock didn’t move.
One day, we were unexpectedly reorged into another team. The team dealt with boatloads of uncertainty for months as we struggled to find our new identity and meaningful work. Several members quit or transferred to other teams (it was also COVID times, which was just weird in general).
But after the dust settled, I made the best of my situation. The new team had opportunities for leadership, learning, and growth. I was handed one task and turned it into a larger effort. Then I created a larger workstream to find and solve an entirely new class of problems. I liked my new project and eventually, I was promoted.
In a big tech company, I don’t think you should be personally attached to what you work on. Take pride in what you do, but don’t tie your self-worth to a particular project. Large organizations only give the appearance of stability, not real stability.
It’s such a strange paradox: despite being so secretly volatile, large organizations can also be incredibly bureaucratic and unmovable. Which brings me to my last lesson…
8. Organizational challenges are (often) harder to solve than technical challenges
Technical challenges are easy. You can spend time writing code. You can throw more resources at a problem. Eventually, it gets solved.
With humans, things are a bit trickier. A very common scenario is this:
- Imagine you use a tool called Foo.
- Foo is owned by another team.
- You have a small feature request for the Foo team. Other teams would benefit from this feature if it was implemented in a generic way.
- You estimate it would take 3 months of work for you to build it. But, since the Foo team knows the system well, they could add it in just 3 weeks.
- You ask the Foo team to add this feature. They decline because it’s not on their roadmap or OKRs.
- You ask how you could get the feature on their roadmap or OKRs. They say they are only accepting feature requests from P0 client teams.
- You are not on a P0 client team. You sigh and move on to another task or cobble together a hacky script that kinda sorta implements the feature in a very specific way.
- No one else gets to benefit from your work.
Of course, challenges like this are just part of life at a big tech company.
I hope this article shed some more light on career development in tech. I’ll be reducing my frequency of publishing articles through the rest of this year.
In the meantime, make it happen.
You must be logged in to post a comment.