Instagram

• Landed the largest single efficiency win at the company that half and wrote publicly about the optimization (https://engineering.fb.com/2022/11/04/video-engineering/instagram-video-processing-encoding-reduction/)
• Won a company-wide award for efficiency work that Mark Zuckerberg recognized publicly (IG - https://www.instagram.com/p/CkihQRtO5yO/, FB - https://www.facebook.com/4/videos/884058129426425/)

Staff Software Engineer

• Incepted and led video ads pipeline rewrite (5 eng involved) that reduced memory errors by 98%, drove +3.9% ads watch time wins, and exceeded cross-org revenue goals
• Wrote about the optimization publicly here - https://about.instagram.com/blog/engineering/making-instagram-video-ads-performant

Senior Software Engineer

• Cut send latency in half for Instagram media messages as backend tech lead for a workstream of 5 engineers
• Wrote a technical blog post detailing the biggest win here: https://about.instagram.com/blog/engineering/cutting-threads-send-latency-in-half
• Found and fixed bug in cache breaking hash function which reduced cache fill from origin data centers by 50%

Software Engineer II

• Drove full rewrite of IG's video processing pipeline which reduced CPU costs by 23% and prevented 3 site-wide outages by removing an unreliable dependency
• Wrote for the IG Engineering Blog about strategies we used in the rewrite to keep latency down - https://instagram-engineering.com/video-upload-latency-improvements-at-instagram-bcf4b4c5520a

Software Engineer I

Amazon Lab126

• Brought daily ETL run time down from 3-5 hours to a few minutes on average 
• Migrated old Postgres data pipeline to a new solution using S3 for storage and Spark for processing
• Incepted and drove project to add automated test coverage which prevented dozens of breakages

Bloomberg L.P.

Software Engineering Intern

In 3 years at Instagram I got promoted from new grad (IC3) to staff engineer (IC6). I got lucky to have had such wonderful mentorship and aim to share that knowledge through my newsletter (www.developing.dev) to help others who don’t have access to similar resources. If you're a software engineer, you might be interested in subscribing.

I haven't written much code outside of work ever since getting a full-time job.

That's because writing code at work has more benefits:

1. Your career will grow faster - The more impact you have at work, the more you'll be recognized by your company. This will grow your career much more than side projects will

2. You learn faster - Since everyone is working full-time, feedback loops are shorter and your peers take the work more seriously

That's not to say that side projects are a bad idea. If you're looking to learn a new domain or are passionate about coding outside of work, go for it.

Just don't think that it's a requirement to stay on top of the job market.

Do you think Github contributions are necessary for getting senior roles?

Ryan Peterman

7 famous GitHub repos to help you pass software engineering job interviews:

1. System Design Primer (252k stars): https://lnkd.in/g6yMEsGv 
2. Coding Interview University (282k stars): https://lnkd.in/gWnd3n6C
3. Awesome Interview Questions (66.4k stars): https://lnkd.in/gY-AYpQk
4. Front End Interview Handbook (39.9k stars): https://lnkd.in/gpZpC_ZX
5. Javascript Algorithm Implementations (182k stars): https://lnkd.in/g9V7d-Ya
6. Python Algorithm Implementations (178k stars): https://lnkd.in/g7hv9ShZ
7. Tech Interview Handbook (109k stars): https://lnkd.in/gU6kk5eN

Covers algorithms, system design, data structures, and more. 

If this post was helpful, react/share/comment for reach so more people can benefit

Any other top resources I'm missing?

Staff Software Engineer @ Instagram | Writing About Software Engineering & Career Growth

Getting good at Leetcode got me offers from every company I interviewed at (Facebook, Google, Affirm, Blend, Riot, and a few others) but one. Here are 3 tips that helped me out a lot:

1. Switch to Python - It's easier to read and solutions are much shorter in this language. For instance, "Two Sum" in Python is only 8 lines of code while it's 15 lines in C++. This helps me get the code out a lot faster.

2. Practice Like It's Game Day - When I first started doing Leetcode, I did over 100 questions but still wasn’t that great because I'd hit "submit" early and look up the solution. 

Later, I changed my approach to practice like I’d be interviewed. I set a 20-minute timer for each Leetcode question and graded myself on the % of questions I could get right on the first submission. I only let myself submit code if I was confident it was right and only looked at solutions after the timer was up. 

3. Play The Game Like It's Practice - I made a minor process change that had a huge effect on my confidence. I split my job applications into two waves. In the first wave, I applied to companies I’d be content with but were not my top choice. 

Because I wasn’t afraid to fail with these companies, I felt more confident. This, along with easier interviews, helped me pass and further increased my confidence. When I moved on to the companies I was most excited to work at, I wasn't as anxious.

Although people criticize Leetcode for not testing the skills we use on the job, it’s not changing anytime soon. Focus your energy on getting good at it. By doing so, you’ll increase your chances of getting offers significantly.

Biggest lie in software engineering: "This shouldn't take long to implement"

It's hard to provide accurate estimates. Almost all software engineering projects don't ship on time.

One of the biggest reasons is that unforeseen issues come up.

For instance, the change might seem simple at first, but some coupling with other code makes the change much more complicated.

These gotchas are hard to see without digging into the code and planning out the changes.

Think through each change that need to be made to avoid getting surprised like this.

What's your best tip on how to provide more accurate estimates?

9 company engineering blog posts that will help you improve at system design & learn Kubernetes:

1. OpenAI: Scaling Kubernetes to 2,500 nodes https://lnkd.in/gxPJUkhZ

2. OpenAI: Scaling Kubernetes to 7,500 nodes https://lnkd.in/dQup2TXr

3. Netflix: Kubernetes And Kernel Panics https://lnkd.in/g23pEvf9

4. Airbnb: A “Krispr” Approach to Kubernetes Infrastructure https://lnkd.in/gSxf8gkh

5. Airbnb: Dynamic Kubernetes Cluster Scaling at Airbnb https://lnkd.in/gN37eXmW

6. Stripe: Railyard: how we rapidly train machine learning models with Kubernetes https://lnkd.in/gJ9ZZcGM

7. Spotify: Designing a Better Kubernetes Experience for Developers https://lnkd.in/gjvbDDTP

8. Palantir: Kubernetes at Palantir https://lnkd.in/gUiGHAKZ

9. Pinterest: PinCompute: A Kubernetes Backed General Purpose Compute Platform https://lnkd.in/gxZ5A5J8

Any other good engineering blog posts that you think I should add to this list?

3 reasons why meetings are especially bad for software engineers:

1. Writing code requires deep focus - It takes hours of continued focus to make any meaningful progress

2. Context switching is expensive - It takes a fixed amount of time to start writing code. Each time you switch you pay that cost

3. Fragments your time - Meetings chunk up your calendar into smaller fragments of time that aren't as useful for making progress

Not to mention that many meetings aren't even necessary. How often have you attended a meeting only to realize it wasn't worth the time?

What are some strategies for maintaining focus while coding?

How can I minimize the cost of context switching?

What are some best practices for managing meetings?

No one ever sat me down and taught me explicitly how to review code. Here are 8 things I wish I had known earlier:

1. You don’t need to accept code - Early in my career I accepted changes I knew nothing about to unblock people. This code review was useless and let bugs into production. If you don’t feel comfortable reviewing a change, then don’t and make sure you pull in the right audience

2. Learn which code matters most to review - Develop a sense of how risky code changes are. If the code is running in prod then you should spend more time scrutinizing it, while you can save time on generated/test code.

3. Always review the test plan - It’s almost always not okay to leave this section blank. Spend some time here to interact with the app/check the test runs. Make sure the thoroughness of the test plan matches the expected risk of the code change

4. Ask questions for context - No one will know the written code better than the author. If you don’t understand a change's intention, test plan, or risk, then leave a comment asking for clarity

5. It’s okay to request changes - There are two benefits to this: (1) it puts the change back in the author's queue for their convenience and (2) it prevents other team members from wasting time on code that you already reviewed

6. Don’t block changes on nits - You should trust the engineers on your team enough to not need to reject if you have small nits. I often leave my nit feedback but still accept to remove the need for another round of review

7. Code reviews influence engineering culture - It’s easy to get lazy with code reviews and start accepting code without much review. Standing up for quality, well-tested code sets an example for teams on what should be allowed to land

8. Break down needlessly large changes - It's okay to request the author to split up a large diff (or PR) so it is easier to review. This makes the code easier to review and reason about.

Hope these were helpful; is there anything I missed that you would add to this list?

Stop doing scrum. My personal story that shows why:

At my first internship we had a 2 hour meeting every other week to hand out tasks and debate how many "story points" each was. 

Most engineers tuned out during these meetings. Then these hand-wavy "story points" were used to judge how well our team was doing. 

I didn't know better at the time so I went along with it. In hindsight, those meetings were a waste of time. 

Since then in my current role, I've seen how much better project management can be. Now, engineers own whole projects which gives them more autonomy. 

There is much less micromanagement since engineers are held accountable for their project outcomes rather than their task-level "story points". 

Engineers set reasonable timelines and update stakeholders offline which cuts down on meeting times too. 

This has been much more efficient in my experience. 

What are your thoughts on scrum? If you don't use scrum, how does your team do project management?

The goal of a tech lead isn't to write better software than your teammates.

The goal is to build great software together.

Since software engineering is collaborative, good tech leads grow others and do what it takes for the team to succeed (even if it isn't writing software).

Software engineers shouldn't only grow through years of experience.

Just relying on time in role is too slow and passive.

You can grow much faster by focusing on:

- Taking on larger and larger projects
- Working with talented peers
- Finding mentorship

Time only helps so much, owning your growth is much more important.

How can mentorship help software engineers grow faster?

How can working with talented peers help software engineers grow faster?

How can taking on larger projects help software engineers grow faster?

When I was a new grad, biggest surprise was how much of the job wasn't code:

What are some non-coding tasks in tech jobs?

What are some common surprises for new grads?

What are some common misconceptions about the tech industry?

6 most common reasons software engineers fail to get to Staff:

1. Weak direction - creating scope for the team is the hardest part; it's difficult to figure out what direction to go in an ambiguous space

2. Lacking ownership mindset - You need to make the project successful, that's it. You don't need to write all the code yourself

3. Reorgs or lack of scope - Sometimes your situation will get in the way of promotion. Reorgs can affect your ability to deliver on Staff-level scope

4. Getting attached to the solution rather than the problem - You are accountable for the impact you have, not the technology you build

5. Not being able to influence across teams - You need to be able to influence other teams without any authority over them

6. Poor conflict resolution - Staff engineers should be able to step back and manage conflicts among collaborators

Getting promoted to Staff is more about developing these behaviors rather than the raw amount of work you do. 

Your situation isn't always in your control, but working on your behaviors always is. Focus on developing Staff behaviors.

This is assuming you want to get to the Staff level. At most companies, you can stay at Senior forever if you don't want to push for the Staff promotion.

How can software engineers influence other teams without authority?

What are some strategies for managing conflicts among collaborators?

What are some examples of Staff-level behaviors?

Software engineers need to write.

You've probably heard this before, but why? Here's a few concrete reasons:

1. Almost everything software engineers do requires writing. We need to write when we ask technical questions, comment on code reviews, or create design docs. This is because writing software is collaborative. The better you are at writing, the more effective you'll be at building software.

2. It's an effective way to scale yourself. If you write down the answers to questions you get repeatedly, you can help people even while you sleep.

3. Writing doesn't just clarify your existing ideas; it generates more of them. When I write design docs, I often discover optimizations or edge cases I didn't think of at first.

These are just a few reasons why writing is helpful for software engineers. How has writing helped you as a software engineer?

Why does Elon Musk celebrate deleting code more than writing it? Although a lot of what he says is controversial, cleaning up unused code isn't. Here's why:

1. Easier to maintain - Code that doesn't exist can't have bugs and requires no maintenance

2. Resource optimization - Binary sizes, build processes, and test run times are all more efficient if there is less code. It's easy for the codebase to grow little by little until this bloat is noticeable to users and engineers

3. Increased dev velocity - It's easier to understand existing code and change it if there is less of it. Engineers waste time understanding code paths that don't matter

What if we need that code one day? No worries if you're using source control. You can easily look up old deleted code if needed.

What are some other good reasons to delete code?

If I was a junior engineer (IC3) at Instagram again and just starting my career here's what I'd tell myself (knowing what I know now):

1. Learn what is impactful ASAP (most important) - You'll be much more efficient if you laser focus on what matters to the business. This will help you do more with less time. 

Promotions and career growth come as a byproduct of honing this skill.

2. Hard work leads to opportunity - Working harder increases your blast radius. More people will recognize you if you're putting out a lot of quality work. 

More opportunities will come your way because of this increased surface area.

3. Learn how to lead before you need to - One day you will transition from purely writing code to leading meetings and guiding the team. 

You'll have a much easier time if you learn those soft skills early rather than lazy loading them.

4. Don't stress about ratings if you're doing well - I wasted time stressing about if I was getting "exceeds" vs "greatly exceeds" vs "redefines" expectations at first. 

Aside from a bigger bonus, ratings don't change your career trajectory much after "exceeds".

Great companies reward outcomes and don't micromanage what you do with your time.

I've been lucky with this and it's one of the reasons I love my job. I could understand if this person was underperforming but otherwise, it seems off.

What do you think, should engineers be fired for doing Leetcode at work?

What are the consequences of doing Leetcode at work?

Finding scope is often the hardest part of growing your career. Once you find something impactful to work on, it's just a matter of execution.

Therefore, an unexpected benefit of a more senior teammate leaving is there's more opportunity for you.

Run towards the fire and you'll get promoted quickly.

Taplio

Ryan Peterman's Linkedin Analytics

Ryan Peterman

What is Ryan talking about?

Who is engaging with Ryan

Ryan Peterman's Best Posts (last 30 days)

Want to drive more opportunities from LinkedIn?

Taplio

.css-1jgreyo{background-image:linear-gradient(284deg, rgba(39,43,72,1) 0%, rgba(33,47,183,1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Ryan Peterman's Linkedin Analytics

Ryan Peterman

What is Ryan talking about?

Who is engaging with Ryan

Ryan Peterman's Best Posts .css-qqfgvy{font-size:var(--chakra-fontSizes-md);}(last 30 days)

Want to drive more opportunities from LinkedIn?

Ryan Peterman's Linkedin Analytics

Ryan Peterman's Best Posts (last 30 days)