Effective Communication Guide [Part 3] - Building Relationships

In order to succeed as a software engineer, you need people to like you. So how do you make that happen quickly? This lesson teaches you:

- **Relationships are all about trust** - The more someone trusts you, the more they will share with you, and the more effective your collaboration can become. The 1 on 1 meeting is the most mechanism to earn this trust.
- **Trust by default** - Trust is extremely hard to earn and very easy to lose. The best way to earn someone's trust is to give them a lot of your trust. This will trigger a response where they will strive to follow The Golden Rule, giving you more of their trust to make things balanced. For an example of trusting by default and earning trust lightning fast, check out [our deep dive into great mentorship here](https://link.jointaro.com/YdUM4JP89Sjh7ruv5).
- **Make small talk** - 2-5 minutes of small talk per 1 on 1 can go a long way. By talking about things outside of work, you are showing that you truly care about them as a person.
- **Be honest** - Tell it to people straight, and don't mince words. By showing that you're comfortable sharing what you're genuinely thinking, people will want to do the same. This is especially powerful when talking about problems.
- **Use humor and self-deprecation** - Everyone likes to laugh: It's a very human thing to do. Crack a joke here and there when you can. Self-deprecation is effective as it's safe (you are poking fun at yourself instead of someone else) and shows your humility.
- **Show thanks** - Don't take your colleagues doing great work for granted: Doing great work is always hard. There is really no such thing as giving too much thanks and making people feel too appreciated. *This is a severely under-utilized technique*. Giving heartfelt thanks is supremely powerful - You can turn someone's bad day into a good one.

Effective Communication Guide [Part 2] - Basic Tactics

Most software engineers are socially awkward, and they perceive communication as this mythical skill that is impossible for them to master. Well, it turns out that there's quite a lot of very easy things you can do to become much better at communication. This lesson teaches you:

- **Use tentative language** - You can always be wrong, and you should acknowledge that in how you communicate:
  - Bad: "Your code isn't performant."
  - Good: "I think this code may have performance issues."
- **Body language matters** - Communication isn't only the words you say or write, it's also how you express with your face and body. This is something that is biologically wired into humans: Put your entire self into it when you are communicating, especially when you're listening! This is covered more in the part of this course: [Effective Communication Guide \[Part 3.2\] - Deep Listening](https://www.jointaro.com/lesson/q1UyjOoZ2pud9IdmXlVJ/effective-communication-guide-part-32-deep-listening/)
- **No leading "hello" for digital communication** - When asking for help digitally, don't do a greeting and then wait for a response greeting before jumping into your ask: Just attach your ask from the get-go. Software is all about efficiency and waiting for this round trip makes things less efficient. For more advice around asking for help effectively, here's our in-depth video about it: [Asking Effective Questions That Get Great Answers Quickly](https://www.jointaro.com/lesson/HV8sq75WxM9VhK0dhUun/asking-effective-questions-that-get-great-answers-quickly/)
- **Lead with the core point** - Think of a "tldr" when it comes to long articles. This also applies to how you talk: Start with the main idea, and then go into the details. When you start by going into the weeds (very common for earlier-in-career engineers), it's very easy for people to be uninterested or get lost in what you're saying. For an example of how this applies to technical writing, check out this Q&A from a Meta engineer about it: ["How to get more visibility on work?"](https://www.jointaro.com/question/XA0X51AypDLCeVeleJv4/how-to-get-more-visibility-on-work/)

Effective Communication Guide [Part 1] - Core High-level Principles

Software engineers are notorious for their poor soft skills, often thinking that being able to write decent code while isolated in a corner is all they need to succeed. This couldn't be further from the truth. Communication in particular is crucial for software engineer career development, especially to senior and staff level. This lesson teaches you:

- **Communication is fundamentally an exercise in empathy** - The entire goal of communication is to align with or win over another human being in some way.
  - Strive to put yourself in the shoes of the person you're communicating with. Try to see the world through their eyes.
  - What are their values? What makes them happy? What are they struggling with? What do they care about? What's their background?
- **Understand others' incentives** - This is especially important in a corporate environment where every employee has some incentives they're pursuing. This will often times manifest as what are the values of the other person's org and even more concretely, *what they get rewarded for in performance review*.
- **Over-communication &gt;&gt;&gt; Under-communication** - Under-communication's downside is that people are not aligned, which usually leads to lots of thrash and wasted work. That is much, much worse than the failure mode of over-communication, which is that you're a bit annoying (and this can be easily toned down and fixed). If you're trying to get better at communication, push for the over-communication extreme: Chances are, you will never reach it. It is *very rare* for someone to be communicating too much - Most people will appreciate the increased availability of information.

Related resources:

- [The Crucial First Step To Building Relationships That Everyone Misses](https://www.jointaro.com/lesson/YPniDFNQqoHEpYHC9JEq/the-crucial-first-step-to-building-relationships-that-everyone-misses/)
- [Stop Getting Ghosted With Your Reachouts - How To Write A Great Cold Message](https://www.jointaro.com/lesson/eZRHXEpxdJjcxK2aQTWl/stop-getting-ghosted-with-your-reachouts-how-to-write-a-great-cold-message/)
- [I Sucked At This For 25 Years As An Engineer – 8 Tips For Communication](https://www.jointaro.com/lesson/s0vZkFtwe3x4tALbdbEr/i-sucked-at-this-for-25-years-as-an-engineer-8-tips-for-communication/)

[Case Study] Mentoring Junior SWEs [E3] to Senior [E5] In Just 2.5 Years At Meta

For the key points, you can find them in the slides (linked below), so the summary will be framed more as action items.

**If You're Pushing For Senior/Are Senior+ Already**

- Mentorship is a core part of healthy senior engineer behavior, so invest in it if you aren't already.
- Now you need to find good mentees. *The main thing to look for is their coachability, which largely depends on how smoothly they process feedback*.
- How can you tell if someone is coachable?
  - They go the extra mile making sure their code is clean.
  - They respond to code review comments (particularly yours) with enthusiasm and speed. They're hungry to learn more and go deeper into feedback on their code.
  - They go out of their way to help others as opposed to many people who just help reactively (or not at all).
  - They have a good cadence with you when you spend time with them (e.g. it's easy to have a fun conversation with them over lunch).

**If You're Mentoring Other Engineers**

- *If the extent of your mentorship is that you answer a lot of your mentee's question, you're not truly a mentor.*
  - True mentorship is being proactive and having a clear vision for what your mentee will become. Create a growth plan for them to get to the next level and outline deltas to make it clear.
- If you haven't already make sure that your manager and the manager of your mentee (if they're on a separate team) are aware of your involvement. This is vital for getting proper credit and not growing them incorrectly.
- Your mentality should be that you serve your mentee, not the other way around.
- To build a ton of trust quickly, tell your mentee this: *"No matter what happens, I'll do whatever extra work is necessary to make sure that you're okay."* You are majorly responsible for your mentee's well-being.
- Always call out when your mentee does good work, even if it's something small like a well-written commit. Do it in your 1:1 where it has more gravity. Showing appreciation as a trust/morale building technique is *severely* underutilized.

**If You're A Mentee Looking For A Mentor**

- Show strong gratitude for code review comments on your commits. Don't just give them a thumbs up or worse, silently make the change. For deeper feedback (often times coming from senior engineers who you want to mentor you), go the extra mile giving thanks.
- Put yourself out there: Don't be a hermit. Go to team lunch, offsites, coworking - Become known as a friendly face within your team. Strike up conversations with engineers more senior than you just to get to know them.
- Strive to write good code. It can scary as a junior engineer in particular and default to churning out tickets as fast as possible with bare minimum quality; avoid that instinct and try to spend an extra 30 minutes to 1 hour trying to build things out properly (and then talk about your thought process on your pull requests). You want to show senior+ engineers that your hunger to be an actually good software engineer instead of a commodity coder is there.

Related Resources:

- [Presentation Slides](https://docs.google.com/presentation/d/12OelIHF08oBZwe-TzVlz8fqp4WiOTem_e9KsGe7X8XA/edit?usp=sharing)
- [Meta E4 To E5 Growth Plan (Pretty Applicable To Any Large Company)](https://firebasestorage.googleapis.com/v0/b/tech-career-growth.appspot.com/o/articles%2Fmeta_e4_to_e5_growth_plan.pdf?alt=media&token=e13d88fd-9356-4c20-a229-cf0cad78a9af)
- ["How do you get the most out of mentorship?"](https://www.jointaro.com/question/IbuZydz0QzsVVqESVaxQ/how-do-you-get-the-most-out-of-mentorship/)

The Silent Killer Of Too Many Software Engineer Careers: Burnout

Burnout is a form of exhaustion caused by constantly feeling like you have too much to do. Most software engineers will encounter burnout at some point in their career. Four reasons you may hit burnout, and how to mitigate: 

1. **You can do your job anytime + anywhere.** Try to create some separation between work and home, or set deadlines for yourself. 
2. **Unlimited complexity.** A typical codebase will have too much complexity for one person to understand all of it. Instead, share with coworkers where you feel lost, and start small.
3. **Unclear roles.** There’s often ambiguity around things like handling support requests or maintenance. Try to create structure around this, and acknowledge that this work does exist. 
4. **Unclear communication.** For your work, over-communicate the bad news and refer to [this Taro session about communication](https://link.jointaro.com/6jdUd3ucPprEEVog6).

[Masterclass] How To Build And Grow Tech Products To 500k+ Users For Free

Here are our Top 5 points from this session:
- **Side projects are incredibly powerful** - They improve your portfolio, increase your coding velocity, and give you holistic experience around building products end-to-end.
- **Care deeply about quality** - Users notice when your app or website is buggy. Strive to cover all edge cases and provide a truly polished experience.
- **Eat your own dogfood** - The best way to know how to improve your product is to use it yourself. This was a staple of Meta's engineering culture.
- **Least clicks design** - At the end of the day, it doesn't matter how "pretty" your product looks if it isn't efficient. Think about how you can have your "hero flow" take as few clicks as possible.
- **Understand SEO** - Work backwards from what people will be searching for when they need a product like yours. Then have those words in your product title and relevant metadata.

Related resources:
- [Presentation Slides](https://docs.google.com/presentation/d/1lfSCWI_OUtchWpIEKwG8JkII8IUvBeACRqEJlnTErjU/edit?usp=sharing)
- [How To Come Up With Product Ideas That Get 100k+ Users](https://link.jointaro.com/7Q8cDrda23zv2omU9)
- [How Side Projects Make Recruiters Come To You](https://link.jointaro.com/rxqDDu4sgMQbP6LT8)
- [Why Side Projects Are So Powerful For Junior Engineers](https://link.jointaro.com/cFo3doiWDeE5dpa67)
- [How To Split Your Time Properly Between Work & Side Projects](https://link.jointaro.com/YFCmNrsdqhuMSeUw5)

The Hardest Part Of Peer Feedback: Giving Them Constructive Criticism

- When the feedback prompt asks you for what your peer can improve on, it is *not* asking you what your peer is doing poorly. If you see your peer doing something toxic/negative, you should give them that feedback *immediately*. Don't wait 6-12 months until performance review season to drop this giant ball on them.
- The *real* question behind this prompt is: "How can your peer expand their scope?". This often times involves something they're already doing well that they can do even better and expand to achieve even greater impact.
- This question will be much easier to answer once you have a deep understanding of engineer levels as a lot of this feedback will be around what you think your peers can do to reach the next level.
- Example: Your peer is very passionate about automated testing and always pairs their landed code with robust test coverage. You suggest that they push to spread this behavior across the entire team with an overall testing initiative.

Making The BEST Case For Yourself In Performance Review: The Self Review

- Your self-review is the most important feedback for you come performance review season: Ignore the weirdness you may feel hyping yourself up and take it very seriously.
- The onus for representing yourself well falls mainly on you, not your manager or peers. Nobody knows you better than you. It's your job to make sure that none of your awesome achievements fall through the cracks.
- Start your self-review early and refine it across several iterations with your manager.
- Use [your brag journal](https://www.jointaro.com/course/nail-your-promotion-as-a-software-engineer/brag-journal/) to seed the self-review.
- Show the impact. Attach links to proof as much as you can (e.g. linking a dashboard with positive metrics to show that the project you launched added business value).

Related resources:

- ["How can I most effectively talk about my projects?"](https://www.jointaro.com/question/c0CDYi5VCRXz0gHHLiGP/how-can-i-most-effectively-talk-about-my-projects/)
- ["How to figure out what the most important projects are?"](https://www.jointaro.com/question/CgCPA60bDDHoOteN7Lmb/how-to-figure-out-what-the-most-important-projects-are/)

360 Feedback: The BEST Performance Review System Top Companies Use

- The goal of 360 feedback is to generate as holistic and fair a picture of employee performance as possible.
- It does this by getting feedback from all directions:
  - Within (yourself)
  - Above (your manager)
  - Below (your reports if you are a manager)
  - Laterally (your teammates)
- This system prevents employee performance from reducing down to sucking up to the manager, which is the case in more traditional companies that aren't using this system.
- 360 feedback also makes the power dynamic between manager and report more equal. A manager will have a bad feedback packet if their reports all share bad feedback about them. This holds bad managers accountable.

[Case Study] Becoming A Tech Lead Again In Just 1 Month After Joining Robinhood From Meta

- The expectations for an L5+ (senior+ at a FAANG or similar company) engineer are high. You won't get 12 months or even 6 months to fully onboard: You need to start having huge impact and showing your depth within 1-2 months.
- After starting, Alex told his managers that he was happy to offload any responsibilities they had so they could focus on higher-level issues and expand their scope. As a tech lead, you need to view your manager as a partner, not just a boss. "Treat me as a resource."
- The project that Alex was first put on was to make settings more server-driven within Robinhood
- The most impactful thing to do was to add color to the project:
  - Stabilize and then drive the workstream meetings
  - Create a thorough tech spec
  - Align XFN to figure out how to treat each settings section properly, especially in places where there were inconsistencies
- How Alex added his depth:
  - Wrote a 5+ page Android spec for his portion
  - Manually audited all of settings and compiled a detailed spreadsheet of inconsistencies to fully capture impact
  - Thorough data analysis spec, doing complicated SQL queries himself
  - Mentored an L4 engineer in the process, giving them L5 scope
- Recap (how you can incorporate the learnings here into your work):
  - Earn trust quickly: Be "aggressively" nice. Find out how you can add value to others and be very sincere and upfront about it.
  - Fill in the gaps: View your projects holistically and figure out what's missing to move the project forward. This will often times be "less flashy" non-coding work.
  - Bring people together: Don't be paralyzed by your lack of knowledge. Especially if you're new to a company, you will be clueless in a lot of scenarios. If you're in a cutting edge company like Meta/Robinhood, there will be a smart person(s) somewhere out there with the answer: You just need to bring them together in a healthy way.
  - Go deep: There's far more to a senior engineer than their ability to code. If you're a new L5+ engineer, even the tenured L3/L4s at the company will code circles around you in the beginning. If you're an L5+ engineer, figure out what behaviors and fundamentals you have that more junior engineers don't and show those as much as you can. This generally involves shipping software in a much more holistic way.

Related resources:
- [Presentation slides](https://docs.google.com/presentation/d/1j5Lj_IGrtCRUpobj0f8k9egrBAej9apzikGp_V_iTCk/edit?usp=sharing)

This Is What Most Companies Get WRONG About Promotion

- 2 types of promotion:
  - **Strong companies:** Already functioning at the next level
  - **Weak companies:** Mastery of current level + long tenure
- In the best tech companies, each level is fundamentally different from the previous one. This is why promotion is lagging there: You need to be functioning at the next level consistently for 3-6 months before getting promotion.
- The goal is to avoid the Peter Principle: Getting promoted to higher and higher levels until you are completely incompetent. When levels are truly meaningful, it's really easy to be doing great at your current level and then be struggling to survive at the next one.

[Masterclass] How To Navigate Your Performance Review In Tech

The slides provide a great high-level overview of the entire session for your notes, so here's our Top 5 thoughts that aren't entirely in the slides:

- Not deeply understanding your company's performance review cycle is job suicide, especially in the current age of layoffs and stack-rank (the latter being perennial).
- If you're truly working at a top company, you shouldn't be promoted to the next level unless you have been functioning there for at least 3-6 months. Companies that don't do this tend to promote due to raw experience and have many incompetent people at senior+ levels.
- Always have a plan for your performance review, even if your goal is just to be average and survive. Work with your manager at the beginning of every cycle to create a clear and living expectations document.
- Be very deliberate about the peers you want leaving feedback for you on your performance review. Assemble that cast at the beginning of the cycle and start building those deep 1 on 1 relationships once you have done that.
- When you are asked to leave constructive feedback for a peer, flip the question from *"What did they do poorly?"* to *"How can they expand their scope?"*. This will become easier as you reach an L5 (senior) level and more deeply understand what each engineering level means.

Related resources:

- [\[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/)
- [\[Masterclass\] How To Get Promoted Faster In Tech](https://www.jointaro.com/lesson/W730BOdrfAIXAEVd8HUf/masterclass-how-to-get-promoted-faster-in-tech/)
- [\[Masterclass\] How To Have Impactful 1:1 Meetings](https://www.jointaro.com/lesson/FEK6JZqW2Jg3rdN9yeGn/masterclass-how-to-have-impactful-1-on-1-meetings/)
- [Presentation Slides](https://docs.google.com/presentation/d/142PsWRJ-fmdP42CrFpR0VD64L1qFP-6nPTmjk5g1DKM/edit?usp=sharing)

[Case Study] Solving A Multi-Million $$ Instagram Bug

- A big part of moving from L4 (mid-level) to L5 (senior level) is being able to create your own scope. You can't just expect a perfect suite of projects to come from your manager.
- Like in this session's case study, bugs are a great source of finding your own scope!
- The bug was very slight: Instagram story ads started off on the wrong part when they were resurfaced to a user. As an Android engineer, Alex discovered this in IG Android initially. This bug had been in production *for over a year* at this point.
- How Alex expanded the scope after finding this bug:
  - Worked with iOS to see if the bug was there (it was)
  - Worked with PMMs to confirm that this violated the advertiser contract and merited a refund. This made the bug an immediate SEV.
  - Worked with a data scientist to figure out exactly how many times this bug occurred and calculate the exactly refund to advertisers ($2M+)
  - Put the fix behind an A/B test to measure impact and make sure it was working
- How you can incorporate the learnings from this case study:
  - Be detail-oriented. At Big Tech in particular, seemingly small issues can have massive impact.
  - Don't just silently fix bugs. Take the time to figure out its entire scope - It could be a SEV!
  - Understand the world outside of yours. Look for opportunities to bring in others (especially those of different roles) into what you're working on to expand scope for everyone!

Here's the [link to the slides](https://docs.google.com/presentation/d/1vPtelhi5caMsZNC-XFGhy1FtRveIbNxg0k3LZctRPOs/edit?usp=sharing).

For more resources around creating scope:
- ["How do I come up with innovative, impactful ideas and bring them to my team?"](https://link.jointaro.com/uBcb5LjZiD5DasfB9)
- ["How can I come up with big initiatives, especially those at a Staff level?"](https://link.jointaro.com/6MWig3VSr3nVo81w9)

How Alex Got Into Meta With 0 Prior LeetCode Experience

[Masterclass] How To Do Amazing Code Review

Code review is one of the most effective ways to learn as a software engineer, especially for those earlier-in-career. Unfortunately, way too many engineering teams get it wrong with slow review speed and low quality comments.

There is a mountain of information in this presentation, so here's our 5 favorite points (in no particular order):
- **Code review is NOT for catching bugs** - Of course, if you find a bug in a PR (pull request), you should call it out, but that's not the primary purpose of code review. The core benefit of code review is to build up engineering culture, propagating best practices amongst the team and growing newer and more junior engineers.
- **Add deep context to your PRs** - Explain what your pull request does and the reasoning behind your approach. Also, *include a test plan.* A test plan is a demo showcasing what your code changes do; try to make it a video/gif, which is especially powerful if you work on front-end (Android/iOS/web). If you can't do a video, try attaching a screenshot or a set of commands to run tests.
- **One diff, one thesis** - Every PR should be focused and atomic: Don't jam the entire new feature you just coded up in a single 1,000+ line PR. Huge commits are hard to review, and your teammates will hate you for it. For the vast majority of cases, you can break down your PRs to 25-250 lines of code.
- **Read others' code reviews** - Similar to so many other things in tech, stand on the shoulders of giants where you can. With code review, this means looking at how senior+ engineers on your team comment on reviews. Try to find patterns in the issues they're finding and incorporate it into how you review code. Revisions that have been rejected with changes requested are a gold mine for this learning.
- **Code review MUST be fast** - When we say fast, we mean that feedback should arrive in <24 hours. What a lot of engineers don't realize is that code review delay is multiplicative: Sometimes commit will need 3-5 revisions before they're able to be merged. If turnaround is 2+ days, this can easily lead to commits taking weeks to land, which is far too slow.

A lot of the terminology in this video is Meta specific. If you're more used to GitHub:
- Diff review = Pull request
- Diff = Commit

Related resources:
- ["How to give better code reviews without full business context?"](https://www.jointaro.com/question/vio35mw1SYWM8AYojB2w/how-to-give-better-code-reviews-without-full-business-context/)
- ["How to review code in another language/ from another team?"](https://www.jointaro.com/question/B79W3aWc8xMB8cCULFdJ/how-to-review-code-in-another-language-from-another-team/)
- [Presentation Slides](https://docs.google.com/presentation/d/1koyIR9K_CtESD7Vnh3GQOE-svFW-ngrQeEAduSAoH0w/edit)

What Gets Communicated Gets Done: Why Slack Sucks

[Masterclass] How To Ace Your Big Tech Interview - System Design

System design is a crucial software engineer interview skill, especially for FAANG and Big Tech in general. It is effectively a requirement to be leveled at a senior software engineer or higher and will show up in mid-level engineer interviews as well (with the occasional appearance in even junior engineer interviews). The cool thing about system design (unlike data structures and algorithms) is that it's something you actually need to do on the job.

Here are our Top 5 points from the session (in no particular order):
- **Leverage engineering blogs of top companies** - And if you're applying to one of these companies, definitely read their blog. This will help you understand their high-level design and gives you a real-world example to anchor off of, as opposed to something more abstract and high-level that you would get from a traditional book.
- **Do NOT write code** - System design is a *high-level* exercise meant to gauge seniority. Writing raw code is the mark of a more junior software engineer, which is why you should never be writing code in a system design interview. Instead, draw boxes with arrows where the boxes represent components and the arrows represent how they interact.
- **There is no right answer** - One of the main reasons software is hard is because of how open it is. For any complex technical problem, there will be several good solutions, each with varying tradeoffs. System design is not like school or DSA where there is a singular right answer.
- **Understand the problem requirements** - System design problems are, by design, very open-ended. For example, if you get "Build the Twitter feed", there are so many features that make it up: There is no way you can design the entire thing in 1 interview round. Work with your interviewer to understand the scope of the problem and which parts should be prioritized.
- **Follow mature software principles** - The 5 covered in this presentation are robustness, scalability, performance, extensibility, and resiliency. Don't just get the happy flow working - Think about how your system will react when edge cases are hit and things go wrong.

Related resources:
- [How To Ace Your Big Tech Interview [Data Structures & Algorithms]](https://link.jointaro.com/iTNxPCvkdGite4wT9)
- [System Design Series: Taro Playlists [Part 1] - What REAL System Design Looks Like](https://link.jointaro.com/4obaFizTZAdAcStY6)
- [Presentation slides](https://docs.google.com/presentation/d/1z4yX5LiiSxbHiNrBOTPIiDfhBL5qmwRUrDojT71OROY/edit)

[Masterclass] How To Ace Your Big Tech Interview - Data Structures And Algorithms

Data structures and algorithms (often abbreviated as "DSA") is an infamous staple of the software engineer interview experience. Data structures and algorithms problems are the most well-known for being part of the FAANG interview process, especially for Google.

Here are our Top 5 favorite points from this masterclass (in no particular order):

- **DSA prep is insanely high ROI** - In fact, the return on investment for time spent on DSA studying makes it one of the highest yield activities any human can do period. If you haven't worked at FAANG / Big Tech before, switching into it is likely to increase your pay by 50%+. If you're in the US, this will often mean a raise of $50k+. So the next time you're feeling burnt out from DSA studying, keep this very bright light at the end of the tunnel in mind.
- **Leetcode and Glassdoor are all you need** - DSA studying is a solved problem. You can use other, newer tools if you want, but the old-school ones still work just fine. Glassdoor in particular is naturally very effective given the "Big" nature of "Big Tech". Go through the recent data points from Glassdoor if you're interviewing for Big Tech and make sure you have a good grip on recurring recent problems.
- **Learning DSA is all about pattern recognition** - For 80%+ of DSA problems, there will be some 1-2 liner "trick" that represents the whole solution. For example, the "trick" to 2 sum is "Look for the difference and use a set/dictionary". It is not scalable to memorize solutions as code - Look for patterns and remember solutions as that high-level insight.
- **Communicate, communicate, communicate** - Since FAANG companies are so huge, there are naturally going to be far more stakeholders on every project, making alignment far more important. Because of this, Big Tech companies will often closely judge your communication skills during the interview. Don't just code in silence - Even if you get the right answer, you may still fail for not maintaining a dialogue with your interviewer.
- **Don't forget about space** - Most people are aware of big O run-time complexity, but candidates often forget about space complexity. Make sure to talk about both when you analyze your solution. As a side note, remember that a recursive solution will *not* be O(1) space.

Related resources:

- [\[Course\] Master The Data Structures And Algorithms Interview](https://www.jointaro.com/course/master-the-data-structures-and-algorithms-interview/)
- [How Alex Got Into Meta With 0 Prior LeetCode Experience](https://www.jointaro.com/lesson/ZYiTbN21FsqFxFdpwt5a/how-alex-got-into-meta-with-0-prior-leetcode-experience/)
- ["How do I balance my time between studying DSA and fleshing out my portfolio?"](https://www.jointaro.com/question/fhV2SCn56aYF4gfPVLmV/how-do-i-balance-my-time-between-studying-dsa-and-fleshing-out-my-portfolio/)
- ["Should I quit to prep for interviews?"](https://www.jointaro.com/question/Cno3oaZkvUu7BPLhHB7g/should-i-quit-to-prep-for-interviews/)
- [Presentation Slides](https://docs.google.com/presentation/d/13uLUHDvZifjp2aVClGsW29nfuVpQYvrkGLP8cej0R_k/edit#slide=id.p)

[Masterclass] How To Come Up With 100k+ Users App Ideas You Can Build For Free

Start with a simple side project and keep iterating on it to separate your side project from the rest.

Related resources:
- [[Masterclass] How To Build And Grow Tech Products To 500k+ Users For Free](https://www.jointaro.com/lesson/OEuX0KMhcnNSTJ50Voee/masterclass-how-to-build-and-grow-tech-products-to-500k-users-for-free/)
- [How Alex Made An App That Got 80k+ Users In 1 Month](https://www.jointaro.com/lesson/GlSjjLhuUdHt5drq3l5F/how-alex-made-an-app-that-got-80k-users-in-1-month/)
- ["Finding a mobile app idea - How to do it?"](https://www.jointaro.com/question/KJ4VXh6rUhKbWeiJoRDe/finding-a-mobile-app-idea-how-to-do-it/)
- ["What are some of the side income or passive income sources you can suggest?"](https://www.jointaro.com/question/URhejS9m02tEFM9WLZsd/what-are-some-of-the-side-income-or-passive-income-sources-you-can-suggest/)
- [Presentation Slides](https://docs.google.com/presentation/d/1ai8lxU1B-bH35iiSFf5hvk6NjAHpUyF2rshjyDipvaY/edit?usp=sharing)

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.