How to Get Promoted as a Software Engineer (Even During Tough Times)

“Congratulations,” my manager smiled. “You’ve been promoted.” Despite the toughest job market since the Great Depression, coronavirus, working from home, two reorgs, and two different managers, I finally succeeded at getting a promotion (and a raise).

Many people assume, “I’ll work hard, keep my head down, and eventually The Company will recognize me.” Other people believe getting a raise is impossible. They blame anything and everything, repeat the same anecdotes, but never ask “What if I…?”.

When you work hard but get a 0% raise

I did not get promoted for working 80 hours a week or for being a yes-man. I was promoted for prioritizing the right projects and making them succeed.

I wish I had a nice little story that goes from point A to point B.  Instead, promo was a compilation of many behaviors and small accomplishments over the years. I hope that engineers can learn from my good behaviors, and senior engineers can correct me when I focused on the wrong thing. I recommend these behaviors in both easy times and tough times.

Standard disclaimer: don’t take my advice.

My Strategy

My promo journey began two years ago. Google has a rubric about the behaviors and accomplishments it expects from its engineers. I looked at the rubric and thought to myself, “What would it take for me to do those things at the next level, L5? And how do I prove that I did them?”

Every week, I had a 1:1 with my manager. I told him that I wanted to work towards promo. And every week, I would ask questions like:

What things should I keep doing?

What should I do differently?

How can I help the team?

How can I help you?

How can I help our product area in general?

What would it take to get to the next rating?

In other words, I was saying both directly and indirectly, “If I did X, would that give me a promotion/raise?” Then I got my manager’s commitment to proceed, and I aimed to make those things happen.

Make It Happen

I use the phrase make it happen deliberately.  It doesn’t have to be me that works on a specific project. Ramit Sethi says you have two options. “You can do it, or you can cause it to get done.”

For example, the Snapshot page has 65 engineers that have contributed a small amount of code. All their features need tests. Most did not have any. Over time, the bug list grew longer, and I realized we were driving down the road to disaster.

Since it’s infeasible for me to manually fix everyone’s bugs, I built a framework and provided guidance. I followed up by asking everyone to take responsibility for their own code (and their own tests). Thanks to the framework, the system began to scale without any single engineer being the bottleneck.

Sometimes, this “glue” work involved working outside my main codebase. Sometimes it meant non-coding tasks like documentation, attending meetings, and writing emails. A beginner programmer would think, “That’s not my job.” In contrast, I thought, “This is necessary for the ecosystem.”

With extreme ownership and a “make it happen” philosophy, I became an engineer that others trust to handle important projects. Managers love being able to hand off an important project and trust that the engineer independently makes progress.

In general, a good engineer can unblock themselves and get things done without needing constant micromanagement.

A good manager notices this behavior.

In case the manager doesn’t recognize this, a good engineer makes sure their manager understands the truthful difficulty and impact of their work.

Communication is a Superpower

I believe communication is a superpower. I can’t be the most knowledgeable person on every topic. But, if I could convince the smartest people in the room to be on my team, we would be unstoppable.

Not all superheroes wear capes.

Despite my start as an ordinary, computer-loving programmer, I became known as a strong communicator. If a project involved talking with many people outside the immediate team, I was the go-to guy. I felt surprised when my manager complimented me on my communication skills. I simply used Dale Carnegie’s “How To Win Friends And Influence People” to guide my interactions.

Thanks to Carnegie, I have good relationships with my colleagues. When we had disagreements, they were always resolved amicably. I made positive impressions on other teams. Instead of criticizing, I suggested ways they could improve. I aimed to make life easier for my client teams and I genuinely wanted them to succeed.

Finally, I put a 30-minute weekly block on my calendar.  I devoted that time to thinking about perf and the bigger picture. I compiled a little bit of evidence every week in the 6 months leading up to promo. When it was time to write performance reviews, I was ready to go.

The Outcome

I was not nervous when waiting for my promo result. The result was uncertain, but I had done everything necessary, and I did not worry about the outcome. Worst case, I apply again in six months with a stronger review packet–or even appeal immediately.

When my manager told me I was promoted, I felt more relief than excitement. I had planned to take a nice vacation after promo, but Coronavirus held off a big celebration.

But it’s a pandemic? What did you do differently?

Tough times make getting promoted harder. However, the core principles remain the same. Understand what your team and organization needs. Tell you manager what you plan to do (and confirm it’s the right path). Then hit a home run.

Who will your manager promote when budget is limited? The person that proves they have helped the organization.

If you continue to think about the bigger picture, remain a trustworthy person, bring projects to completion, and make the people around you happy, you’ll be a level above everyone who keeps their head down and wishes for a raise.

The Downside

One of the worst parts about working at Google is “perf driven development”. You can get rewarded for solving a problem, but it’s harder to prove that you prevented a problem from happening in the first place.  A focus on metrics means activities that are hard to measure won’t get rewarded.

In my case, I chose projects that would look better for perf. There were some cleanup tasks that I wanted to do, but they kept getting de-prioritized.

Additionally, I could have bit off more than I could chew. I learned an effective tactic to avoid overcommitting. When my manager asked me to take on a new task, I would check my notes and reply, “That will require me to push X to next week. Is that OK?” We understood prioritization. Not all work has the same urgency and importance.

Promo is Easy (For Some)

Another engineer didn’t think much about promo. One day, his manager asked, “Do you want to go up for promotion?”

Engineer: “No”

Manager: “You are doing valuable work. I think you should apply.”

Engineer: “Okay.”

A few weeks later, the engineer was promoted to the same level as me without doing much differently.

So who knows if my intentionality and focus were necessary.

Posted in Software | Tagged , , , , , , | 5 Comments

The One Meeting that Changed Our Relationship

Our program manager (PgM) was a stern lady. She kept the project on track, and as a deadline neared, she grew more and more serious. I worked on the iOS client, and I felt like she was ignoring me in favor of the Android developers.

One day, I was scheduled to meet our PgM in person, alone, for the first time. She worked on another continent, so I had only seen her through a conference room camera. I expected her to berate me for not keeping the iOS client up to spec with Android. They have five engineers, and I’m working alone on iOS! No reasonable person could expect the two clients to be the same. I felt a sense of dread as the meeting approached. 

When I found our PgM in the conference room, she jumped up and greeted me with a smile and a hug. Immediately, she complimented me on my amazing work on iOS while everyone was focused on Android. She quickly offered to help me fix the list of issues plaguing the iOS client and barely asked anything of me. In less than 30 minutes, we had a game plan for the upcoming launch. A surprise to be sure, but a welcome one!

Our PgM genuinely wanted both clients to succeed. We simply hadn’t communicated well until we had a face to face interaction. That afternoon, we solved the problem together as teammates, and we’ve had a good relationship to this day.

Posted in Psychology | Tagged , | 4 Comments

How do I make protocol methods optional in Objective-C?

Imagine you have a protocol in Obective-C.

@protocol ABCRocket

- (void)start;


What if you want to make some properties or methods optional? You can use the optional keyword.

@protocol ABCRocket

- (void)start; // Required


- (double)speed; // Optional


Not all objects to implement the protocol will have the -speed method. Trying to call -speed on those objects will crash the program, so we should check if the object implements -speed first.

if ([foo respondsToSelector:@selector(speed)]) {
      // Foo has the -speed method. Do something awesome!

It’s simple and easy.

Posted in Software | Tagged , | Leave a comment

A Quiz to Practice Big O for a Software Interview

Estimating big O is a crucial part of software engineering interviews. If you can write decent code, but can’t analyze big O, interviewers will mentally subtract points from your score.

Tips for analyzing Big O

  • Consider the worst case
  • Think about when n is very large. 2^n dwarfs O(n^2)
  • Drop constants (e.g. O(2n) -> O(n))

Quick Test

Here’s a quick test (answers at the bottom). For each question, write down the big O runtime of run(…).

Question 1

public int run(int[] input) {
  if (input.length < 1000) {
    return -1;
  for (i = 0; i < 1000; ++i) {
    input[i] = input[i] + 1;
  return 0;

Question 2

public void run(int[] input) {
  for (i = 0; i < input.length; ++i) {
    input[i] = input[i] + 1;

Question 3

public void run(int[] input) {
  for (i = 0; i < input.length; i += 2) {
    input[i] = input[i] + 2;

Question 4

public int run(int[][] input) {
  int sum = 0;
  for (i = 0; i < input.length; ++i) {
    for (j = 0; j < input[i].length; ++j) {
      sum += input[i][j];
  return sum;

Question 5

// Return a random number between 0 and m-1
public int random(int m); // O(1)

public int run(int[] input, int k) {
  int index = random(input.length);
  input[index] = input[0];
  if (k < 0) {
    return 1;
  return run(input, k - 1) + 1;

Question 6

// Return a random number between 0 and m-1
public int random(int m); // O(1)

public int run(int[] input) {
  return inner(input, input.length - 1);

public int inner(int[] input, int i) {
  int foo = random(10);
  input[i] += foo;
  if (i < 0) {
    return 1;
  return inner(input, i - 1) + inner(input, i - 2) + 1;

Question 7

// Return a random number between 0 and m-1
public int random(int m); // O(1)

public int run(int n) {
  int[] input = new int[n]; // Initialized to all 0s
  return inner(input, n - 1);

public int inner(int[] input, int i) {
  if (i < 0) {
    return 0;
  } else if (input[i] > 0) {
    return input[i];
  input[i] = random(10);
  return inner(input, i - 1) + inner(input, i - 2);

The answers are below this photo of young Alan Turing.

Photo of Alan Turing


  1. O(1). When n is large, the runtime is the same as when n is small (max 1000 iterations).
  2. O(n). Directly based on input.length
  3. O(n). Based on input.length. O(n/2) is equivalent to O(n)
  4. O(n^2). The outer loop is executed n times. What does each iteration of the outer loop do? It executes the inner loop n times.
  5. O(k). You could also say “O(n), where n is k”. The important thing is that the number of times the function is called is based on k. Executing one stack frame of run(…) is constant time.
  6. O(2^n). The runtime is like the number of nodes in a binary tree with n levels. The recursive function causes big O to grow exponentially. The branching factor is 2 because each stack frame calls inner(…) twice.
  7. O(n). input acts as a cache that limits the number of calls to inner(…). The recursive function only branches when input[i] <= 0. Therefore, the number of function calls is proportional to input’s length.

How many did you get right?

0-4 – I recommend brushing up on the basics of big O.

5-6 – You’re on a solid path. Keep practicing so you don’t trip up in an interview.

7 – Perfect score! Now’s the time to level up your practice with other data structures like trees and graphs.

Posted in Software | Tagged , , | 1 Comment

A Small Note After George Floyd

On May 25, an African American man named George Floyd was murdered by police officers. It was a tragedy, and not the first.

I haven’t focused on this blog in recent months. After George Floyd, I wasn’t sure what to write. Bragging about how “woke” you are feels off-putting to me, and I still have much to learn. So I’ll say this:

To the African Americans reading this: I stand with you.

To the other people reading this: Read about the experiences of African Americans, both historically and in recent years. If you find yourself dismissing their stories, ask yourself why.

At this moment, I feel like the best thing I can do is to continually listen, learn, support my friends and colleagues, and translate these ideas into long-term action. Posting to social media feels like virtue signaling. The real heroes were the people working towards justice before it was “popular”. And while talking about race is often uncomfortable, that’s OK. Being uncomfortable is necessary for growth.

Posted in Other | Tagged | Leave a comment