Understanding The Differences Between Engineering Levels

True or false: Very senior engineers are at their levels because they act and operate in a fundamentally different way from their more junior peers.

How can you properly tell the more senior engineers from the others?

Which one of these is a core example of what a very senior (i.e. Staff or above) engineer would do?

Master The Behavioral Interview [Part 12] - Double Dip

Software engineers and people in general don't realize how incredibly powerful questions can be when you ask the right ones. This lesson teaches you:

- How the best questions that you can ask in a behavioral interview actually help you pass on top of extracting useful team selection information
- What the 2 core failure modes are when it comes to you asking the interviewer questions

DSA Crash Course [Part 33] - Reverse List Walkthrough

In this lesson, Alvin walks through the python implementation for the *reverse_list* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/reverse-list?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.

Use [**this link to get 20% off**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: <https://www.linkedin.com/in/alvin-zablan-b73a92117/>

How To Work With Your Manager To Get The Performance Review Rating You Want

Too many engineers are afraid of awkward conversations, so their plan is to just do good work and hope for the best. This rarely works.

Here are the points from the video:
- **Getting the rating you want is a team sport** - You need to be in-sync with others (particularly with your manager) on your desired outcome. You have to be transparent about what you want. Use your 1 on 1 to have those hard conversations with your manager on the delta between where you are now and where you want to be. It's painful to hear that you're falling behind, but it's much better to hear it 3 months before the performance review instead of 3 days before.
- **Don't assume that you're doing well** - Just because you're not receiving negative feedback doesn't mean that you're doing okay; the reality is that you could be doing as bad as trending towards PIP. Remember that managers are busy, and they can easily forget to give you critical feedback in a timely manner (or just not fully realize you're not doing well until they see peer feedback).

Related resources:
- [[Taro Top 10] Software Engineer To Engineering Manager (IC -> M Track)](https://www.jointaro.com/playlist/oz0mnJvHHgM8NfVF7rgp/)
- [[Masterclass] What Software Engineers Should Look For In Their Engineering Manager](https://www.jointaro.com/lesson/oeY7ncZhzJ5NO6dij5e7/masterclass-what-software-engineers-should-look-for-in-their-engineering-manager/)

Asking Great Questions [Part 5] - Figure It Out Or Get Help?

As a software engineer, you need to figure out a lot of things on your own (that's why you get paid the big bucks). However, you don't want to go the extreme where you endlessly run yourself into a wall by not getting help. This lesson teaches you:

- When to figure it out on your own vs. get help
- The dynamic behind solving complex engineering problems
- How to identify if you're stuck
- When to ask for help earlier instead of later

Write A Stellar Resume As A Software Engineer [Part 9] - I Know (Suck At) Everything

When it comes tech stacks on your resume as a software engineer, less is usually more. This lesson teaches you:

- What employers are looking for when it comes to an engineer's technical skills on their resume
- Why it's dangerous to put a bunch of technical terms (i.e. keyword stuffing) on your resume
- A simple framework to determine whether or not you should put a technical term (programming language, library, domain) on your resume

Take the code quality course here: [Level Up Your Code Quality As A Software Engineer](https://www.jointaro.com/course/level-up-your-code-quality-as-a-software-engineer/)

DSA Crash Course [Part 27] - Sum List Walkthrough

In this lesson, Alvin walks through the python implementation for the *sum_list* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/sum-list?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.

Use [**this link to get 20% off**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: <https://www.linkedin.com/in/alvin-zablan-b73a92117/>

Write A Stellar Resume As A Software Engineer [Part 7] - It's Too Long

Having a resume that's too long is one of the easiest ways software engineers get their resume (and their job candidacy) immediately thrown out. This lesson teaches you:

- The optimal length for a resume
- Why shorter is better when it comes to resumes (and why very long resumes make 0 sense)
- How to convert your years of experience to a resume length
- Tactics to trim down your resume and make it more concise

DSA Crash Course [Part 28] - Linked List Find Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *linked_list_find*, that takes in the head of a linked list and a target value. The function should return a boolean indicating whether or not the linked list contains the target.

```
a = Node("a")
b = Node("b")
c = Node("c")
d = Node("d")
a.next = b
b.next = c
c.next = d

# a -> b -> c -> d
linked_list_find(a, "c") # True
```

```
a = Node("a")
b = Node("b")
c = Node("c")
d = Node("d")
a.next = b
b.next = c
c.next = d

# a -> b -> c -> d
linked_list_find(a, "d") # True
```

```
a = Node("a")
b = Node("b")
c = Node("c")
d = Node("d")
a.next = b
b.next = c
c.next = d

# a -> b -> c -> d
linked_list_find(a, "q") # False
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.

Use [**this link to get 20% off**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: <https://www.linkedin.com/in/alvin-zablan-b73a92117/>

Break Into Tech And Become A Software Engineer [Part 2] - There's More To It Than Coding

In this lesson, we cover the essential steps beyond just learning to code for successfully transitioning into a tech career.

This lesson covers:

- The limitations of advice for engineers at top companies like FAANG and how to focus on realistic guidance for the majority of engineers
- The importance of developing a clear learning path, mastering time management, and focusing on one meaningful side project
- How building an online presence, networking authentically, and maintaining optimism throughout the journey is critical for career-switchers

If you need extra help breaking into tech, join Brian's exclusive, cohort-based bootcamp (just 10 students per batch). Use this special link for $800 off: <https://www.parsity.io/taro>

Connect with Brian on LinkedIn: <https://www.linkedin.com/in/brianjenney/>

Maximize Your Productivity As A Software Engineer [Part 21] - Verify Your Foundation

Work and life are deeply interconnected, despite how much we want this to not be the case. If your personal foundation isn't there, it's hard to get anything done working a mentally-intensive job like software engineer. This lesson teaches you:

- How it's possible to implement literally all the advice from this course and still not be productive
- What to do if you're stuck in a productivity rut that you just can't get out of
- The ingredients behind a healthy personal foundation

Learn more about how to have good work-life balance here: [\[Taro Top 10\] Work-Life Balance](https://www.jointaro.com/playlist/JNCZ1vbRF3NwsOQCqblt/)

Grow From Mid-Level To Senior Engineer [Part 15] - What's The Plan?

The best engineers act proactively instead of reactively, and this is critical for successful project execution. This lesson teaches you:

- The evolution in ownership of a project when it comes to a mid-level engineer vs. a senior engineer
- What a good project plan looks like

Check out the system design course for an excellent example of a master spec document: [\[Course\] Frontend System Design Masterclass - Building Playlists](https://www.jointaro.com/course/frontend-system-design-masterclass-building-playlists/)

20 Years Of Fighting Procrastination [Part 4] - The Most Important Productivity Tip Nobody Follows

Productivity isn't just about doing things faster - That’s only half the story. Here are the core points from the lesson:

- Productivity isn't just about efficiency, it's about working efficiently on *important* tasks that actually move the needle
- Prioritization requires painful trade-offs—you must let go of low-impact activities even if they're easy, fun, or popular
- Define your personal values and consciously deprioritize areas that don’t align with them, like staying updated on politics or reading a book a week
- A simple yet powerful framework for teams is evaluating tasks based on impact and time required, then prioritizing high-impact, low-time work first

DSA Crash Course [Part 41] - Breadth First Values Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *breadth_first_values*, that takes in the root of a binary tree. The function should return a list containing all values of the tree in breadth-first order.

```
a = Node('a')
b = Node('b')
c = Node('c')
d = Node('d')
e = Node('e')
f = Node('f')
a.left = b
a.right = c
b.left = d
b.right = e
c.right = f

#      a
#    /   \
#   b     c
#  / \     \
# d   e     f

breadth_first_values(a)
#    -> ['a', 'b', 'c', 'd', 'e', 'f']
```

```
a = Node('a')
b = Node('b')
c = Node('c')
d = Node('d')
e = Node('e')
f = Node('f')
g = Node('g')
h = Node('h')
a.left = b
a.right = c
b.left = d
b.right = e
c.right = f
e.left = g
f.right = h

#      a
#    /   \
#   b     c
#  / \     \
# d   e     f
#    /       \
#   g         h

breadth_first_values(a)
#   -> ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
```

```
a = Node('a')
#      a

breadth_first_values(a)
#    -> ['a']
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.

Use [**this link to get 20% off**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: <https://www.linkedin.com/in/alvin-zablan-b73a92117/>

Grow From Mid-Level To Senior Engineer [Part 8] - Fill In The Gaps

Senior engineers solve fundamentally different problems compared to mid-level engineers. This lesson teaches you:

- The expectation for senior engineer mindset and behavior when problems arise in a project they're working on
- The types of problems that mid-level engineers tend to avoid
- The types of problems that senior engineers uniquely solve compared to more junior engineers

Write A Stellar Resume As A Software Engineer [Part 8] - Intro Summaries

It's common practice for engineers (and almost everyone else) to include a paragraph at the very top of their resume summarizing their overall experience and explaining why they're great. This lesson teaches you:

- Why those intro summaries actually hurt you, especially in tech
- What to do instead of having an intro summary

FAANG: Great For Compensation, Less So For Promotion

Getting into FAANG is the dominant thing on so many software engineers' minds, but most of them are making the mistake of not thinking about what happens after they get in. When it comes to that, hitting a growth wall is a very common (and painful) career trap Big Tech engineers run into.

Here are the core points from the video:
- **Most big problems have been solved** - Many teams at FAANG are maintaining flagship products at this point. While these products are great for consumers by being universally known and very useful, they are usually not great for engineers looking to grow. Since they are so hyper-optimized, it's very common for a software engineer to run 10 experiments on a product like Facebook home feed only to have every single one of them fail.
- **Getting to senior/staff is very hard** - Because scope gets so hard to find, these promotions in particular can be *extremely* difficult. SDE 2 -> SDE 3 at Amazon is notoriously impossible, and L4 -> L5 at Google is known to be very tricky as well.
- **You're competing against teammates** - While scope can be created and expanded, there is often a finite amount of it. This means that Big Tech engineers are often jockeying against their very talented peers to own this limited resource. In the worst case scenario, this leads to very dirty politics.

Related resources:
- ["What does it mean to not have enough scope to be promoted?"](https://www.jointaro.com/question/bJuagPwOEEy5vkcXKkqh/what-does-it-mean-to-not-have-enough-scope-to-be-promoted/)
- ["What should I look for in a new team in terms of growth?"](https://www.jointaro.com/question/i2bOMPrqaRc0NUZ7918F/what-should-i-look-for-in-a-new-team-in-terms-of-growth/)

Maximize Your Equity And Benefits In Tech [Part 20] - Backdoor And Mega Backdoor Roths

Backdoor and Mega Backdoor Roth strategies offer powerful ways to boost tax-advantaged retirement savings for high earners. Here are the core points from the lesson:

- A Backdoor Roth involves making a non-deductible IRA contribution and quickly converting it to a Roth IRA, but you must avoid having pre-tax IRA balances or you'll face tax via the pro-rata rule
- Mega Backdoor Roths allow after-tax 401(k) contributions (beyond the regular limit) to be converted into Roth accounts, enabling up to \~$40K in additional Roth savings annually
- The ideal Mega Backdoor setup includes in-plan Roth conversions, which are often automatable and avoid tax on earnings during the transition
- Be cautious of contribution timing to avoid missing employer match benefits—either spread contributions evenly or ensure your plan supports a “true-up” feature

Next steps with Andy:

- [Connect with Andy on LinkedIn](https://www.linkedin.com/in/andymoranio)
- [Leave feedback and/or sign up for Andy’s newsletter](https://subscribepage.io/taroequitycourse)
- [Schedule a consultation](http://adastrafp.com/contact-us/)

Ace Your Tech Interview As A Software Engineer [Part 21] - Recruiter Screen

Having a recruiter talk to you is one of the most common ways tech companies start the interview process for software engineers. Here's the thing: These recruiter screen ones can be surprisingly tricky for many software engineers. This lesson teaches you:

- When recruiter screens happen
- How difficult recruiter screens can be, how often software engineers fail them, and why many software engineers are terrible at them (when they really shouldn't be)
- What to expect in a recruiter screen so you can pass it with ease

Maximize Your Productivity As A Software Engineer [Part 16] - Mentor And Delegate

Many software engineers are naturally lone wolves due to their introverted nature. While this can work out as a junior or mid-level engineer, it quickly becomes unsustainable as you reach senior/staff levels and beyond due to the immense workload. This lesson teaches you:

- Why being a lone wolf is terrible for your productivity
- The importance of uplifting others around you when it comes to getting stuff done
- One of the core virtues the best engineers have, which is particularly needed for mentorship

Here's Alex's Meta mentorship case study: [\[Case Study\] Mentoring Junior SWEs \[E3\] to Senior \[E5\] In Just 2.5 Years At Meta](https://www.jointaro.com/lesson/EX9563YnxcJb62cCmetg/case-study-mentoring-junior-swes-e3-to-senior-e5-in-just-25-years-at-meta/?playlistId=oLssVMdTJ9NtX5SX1fek)

Tech Career Growth Videos

Our instructional videos provide software engineers with insights needed for career growth. Masterclasses go incredibly in-depth on a specific tech topic while case studies are real examples from established engineering leaders.