Ship & Grow 500k+ User Side Projects [Part 20] - When To Give Up

Side projects can give you massive, career-changing, *life-changing* benefits. However, in order for this to happen, you need to put in a lot of work. This lesson teaches you:

- The balance you need to strike when it comes to working on side projects, particularly which ones you work on
- The minimum amount of time you need to give a side project that you genuinely believe in
- A detailed list of criteria you can use to figure out whether you should abandon a side project
- Why failed side projects are actually good for you

Ship & Grow 500k+ User Side Projects [Part 15] - ASO

When it comes to mobile apps, you have a much simpler tool in your arsenal to get users. This lesson teaches you:

- What ASO (app store optimization) is
- Why ASO is much simpler than SEO
- The highest leverage thing you can do to optimize your ASO, explained with a simple example
- Basic, largely technical ways to improve your ASO, which you should just already be doing anyways as a good engineer

Make amazing mobile app pictures for free here: <https://app-mockup.com/>

Ship & Grow 500k+ User Side Projects [Part 9] - Leverage Existing Patterns

Just because you're an engineer doesn't mean that you can't be a solid product designer. This lesson teaches you:

- The easiest way to bootstrap a product design from scratch
- What the pinnacle of front-end UI/UX looks like and the company behind it
- A company you can use as inspiration for a back-end project
- A company you can use as inspiration for an ML project

Ship & Grow 500k+ User Side Projects [Part 8] - Easy Design Wins

Creating a smooth, functional user experience isn't too hard. This lesson teaches you:

- How you can make features easier to access for users, explained with an in-depth example
- How to take care of users in trickier situations, explained with an in-depth example
- What you can do to lower the cognitive burden of using your product, explained with an in-depth example

Engineer Your Ideal Tech Career [Part 13] - Daniel Tomko: Choosing The Tech Lead Route

Lastly, we have [Daniel Tomko](https://www.linkedin.com/in/danieltomko) (ex-Meta, ex-Microsoft, Head of Instruction at Formation) reflect on his experience as a Tech Lead.

He points out some common misconceptions, how the role may vary company to company, and then shares a real-life example of the great magnitude and scale of impact that being a tech lead can drive.

Looking for mentorship from tech’s top engineers (like Daniel!) + personalized job hunt assistance and interview prep? [Formation.dev](http://Formation.dev) can provide you unlimited career coaching, technical mentorship, personalized practice, and mock interviews. Join us here: <https://formation.dev/partners/taro>

Worksheet: [Formation - Coding Your Career](https://firebasestorage.googleapis.com/v0/b/tech-career-growth.appspot.com/o/courses%2Fslides%2FFormation%20Career%20Direction%20Worksheet.pdf?alt=media&token=f6344b78-529a-411e-a449-7a34a8d55fc8)

15 SWE Years In 1.5 Hours [Part 20] - Conclusion

Congratulations on making it to the end of the course! The goal of this course was to capture Rahul's biggest, broadest, higher-level learnings across a multitude of core software engineering subjects. While this is indeed valuable, it's impossible to master a massive topic like all of data structures and algorithms in just 5 minutes

To go deeper into these subjects, we recommend following our learning path here: [Become A Better Engineer](https://www.jointaro.com/learning-paths/become-a-better-engineer/)

Get The Rating You Deserve [Part 5] - Detailed Breakdown

**In this lesson, we'll delve into the intricacies of career advancement and explore strategies to maximize your impact and recognition.**

- **Understanding Impact Dynamics:** We'll examine the relationship between the value you create and the rewards you receive, considering factors like organizational culture, business objectives, and individual performance.
- **Increasing Your Luck Surface Area:** We'll explore techniques to increase your visibility and opportunities for advancement, including effective communication, networking, and self-promotion.
- **Sustainable Career Growth:** We'll discuss strategies for maintaining a healthy work-life balance, building strong relationships, and continuously developing your skills to ensure long-term success.

By understanding these key principles and implementing practical strategies, you can position yourself for significant career growth and fulfillment.

If you want to get personalized support from Yogi, you can reach out to him at [coaching@yogisharma.com](mailto:coaching@yogisharma.com) or schedule an introductory call to dive into your situation at <https://tinyurl.com/meetyogi>.

Come Up With 500k+ User Project Ideas [Part 12] - Do A Search

The key towards building any successful product is to make something people want. Turns out that this actually isn't too difficult when it comes to side projects. This lesson teaches you:

- How to do a basic search to find relevant competitors and inspiration
- How to find core keywords that people use to find products in your space
- A simple, free way to understand the traffic of a website and see if it's worth building a similar webapp

You can download the Similarweb extension here: <https://www.similarweb.com/corp/extension/>

Come Up With 500k+ User Project Ideas [Part 11] - Simple Is Complex

Engineers tend to get excited for complex ideas and bored with simple ones. However, there's more to the technical realm than simply "complex" and "simple". This lesson teaches you:

- How simplicity and complexity aren't a binary spectrum
- How complexity can actually be created from simplicity if you come in with the right mentality
- Why striving for a certain level of quality always brings a meaningful degree of complexity, explained with how Alex made 60,000+ lines of code changes to grow Random Name Picker to a 1 million+ user app
- Why the "simple is complex" mentality is critical towards becoming a truly strong engineer

Come Up With 500k+ User Project Ideas [Part 10] - Keep The Stakes Low

Every piece of software inevitably breaks. This is incredibly important to remember when it comes to side projects. This lesson teaches you:

- Why side projects are especially vulnerable to production issues
- Why you want the stakes for your side project to be low
- What it means to have high stakes vs. low stakes with a product, explained with a concrete example

What Order Should You Study Data Structures & Algorithms?

Instead of doing random problems, you need to structure your DSA prep to tackle concepts in the right order.

Course: <https://www.jointaro.com/course/crash-course-data-structures-and-algorithms-concepts/>

DSA Crash Course [Part 76] - Counts Paths Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/count-paths?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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 75] - Count Paths Approach

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

> Write a function, *count_paths*, that takes in a grid as an argument. In the grid, 'X' represents walls and 'O' represents open spaces. You may only move down or to the right and cannot pass through walls. The function should return the number of ways possible to travel from the top-left corner of the grid to the bottom-right corner.

```
grid = [
["O", "O"],
["O", "O"],
]

count_paths(grid) # -> 2
```

```
grid = [
["O", "O", "X"],
["O", "O", "O"],
["O", "O", "O"],
]

count_paths(grid) # -> 5
```

```
grid = [
["O", "O", "O"],
["O", "O", "X"],
["O", "O", "O"],
]

count_paths(grid) # -> 3
```

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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 73] - Minimum Change Approach

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

> Write a function *min_change* that takes in an amount and a list of coins. The function should return the minimum number of coins required to create the amount. You may use each coin as many times as necessary.
>
> If it is not possible to create the amount, then return -1.

```
min_change(8, [1, 5, 4, 12]) # -> 2, because 4+4 is the minimum coins possible
```

```
min_change(13, [1, 9, 5, 14, 30]) # -> 5
```

```
min_change(23, [2, 5, 7]) # -> 4
```

```
min_change(102, [1, 5, 10, 25]) # -> 6
```

```
min_change(200, [1, 5, 10, 25]) # -> 8
```

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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 69] - Tribonacci Approach

In this lesson, Alvin explores the strategy to solving the following problem using dynamic programming:

> Write a function *tribonacci* that takes in a number argument, *n*, and returns the *n*\-th number of the Tribonacci sequence.
>
> The 0-th and 1-st numbers of the sequence are both 0.
>
> The 2-nd number of the sequence is 1.
>
> To generate further numbers of the sequence, calculate the sum of previous three numbers.
>
> Solve this recursively.

```
tribonacci(0) # -> 0
```

```
tribonacci(1) # -> 0
```

```
tribonacci(2) # -> 1
```

```
tribonacci(5) # -> 4
```

```
tribonacci(7) # -> 13
```

```
tribonacci(14) # -> 927
```

```
tribonacci(20) # -> 35890
```

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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 61] - Shortest Path Approach

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

> Write a function, *shortest_path*, that takes in a list of edges for an undirected graph and two nodes (\*node_A\*, *node_B*). The function should return the length of the shortest path between *A* and *B*. Consider the length as the number of edges in the path, not the number of nodes. If there is no path between *A* and *B*, then return -1. You can assume that *A* and *B* exist as nodes in the graph.

```
edges = [
['w', 'x'],
['x', 'y'],
['z', 'y'],
['z', 'v'],
['w', 'v']
]

shortest_path(edges, 'w', 'z') # -> 2
```

```
edges = [
['w', 'x'],
['x', 'y'],
['z', 'y'],
['z', 'v'],
['w', 'v']
]

shortest_path(edges, 'y', 'x') # -> 1
```

```
edges = [
['a', 'c'],
['a', 'b'],
['c', 'b'],
['c', 'd'],
['b', 'd'],
['e', 'd'],
['g', 'f']
]

shortest_path(edges, 'a', 'e') # -> 3
```

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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 45] - Tree Includes Approach

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

> Write a function, *tree_includes*, that takes in the root of a binary tree and a target value. The function should return a boolean indicating whether or not the value is contained in the tree.

```
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

tree_includes(a, "e") # -> True
```

```
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

tree_includes(a, "a") # -> True
```

```
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

tree_includes(a, "n") # -> 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/>

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/>

DSA Crash Course [Part 13] - Pair Sum Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/pair-sum?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 Crack System Design Interviews - Part 2: Clarifying Requirements

In a system design interview, the first step is gathering requirements, focusing on how users will interact with the system. Here's how we approach this:

- **Understand user needs:** We consider the basic functions users will need, such as applying filters, viewing original images, and deleting images.
- **Confirm and prioritize:** We check with the interviewer to ensure we've captured all the key requirements and prioritize the most important ones.
- **Identify trade-offs:** We analyze potential trade-offs, such as image quality versus storage needs, and quantify them whenever possible.
- **Set realistic expectations:** We avoid aiming for perfection and instead focus on creating a practical design that meets the core requirements.
- **Provide concrete examples:** We use real-world examples to illustrate our understanding of system design concepts and demonstrate our ability to make informed decisions.

[Gaurav Sen](https://www.linkedin.com/in/gkcs/) has conducted 1000s of system design interviews while working at Uber and building his [YouTube channel](https://www.youtube.com/@gkcs) to 500K+ subscribers. His platform [InterviewReady](https://interviewready.io/?_aff=JOINTARO) combines video explainers, live Zoom classes, and an automated System Design Judge.

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.