Tech interviews with NeetCode
Tech interviews with NeetCodeNeetCode shares his journey from Amazon and Google to building a startup, and why deep expertise still matters in the age of AI.
Stream the latest episodeListen and watch now on YouTube and Apple (you can try Spotify, but there’s an ongoing outage, again, new episodes are not published). See the episode transcript at the top of this page, and timestamps for the episode at the bottom. Brought to You by
• Antithesis – If you’re using agents to code, the problem isn’t writing the code but making sure it didn’t break anything. Antithesis runs your whole system in a hostile environment and identifies hard-to-find bugs before users hit them in production. With Antithesis, teams like Jane Street, Fly.io, and the etcd community use agents safely and ship better code, faster. Learn more. • Sentry – application monitoring software built by developers, for developers. Sentry’s Seer AI agent is growing on me, as a way to debug errors faster. Same with Sentry’s MCP server. Check out Sentry. • Google Cloud Run – a fully managed platform that runs your code directly on top of Google’s scalable infrastructure. Run frontend and backend services, batch jobs, host LLMs, and agents without managing infrastructure. Oh, it has automatic zonal failover out of the box – something that Coinbase could have used a few weeks back! Get started. In this episodeNavdeep Singh – oftentimes better known as NeetCode – is the creator of NeetCode.io, one of the most popular coding interview preparation platforms and YouTube channels for software engineers. Before building NeetCode full-time, he worked as a software engineer at Amazon and Google. In this episode of The Pragmatic Engineer, I sit down with Neet to discuss his path from Amazon and Google to building his own startup, why he left Amazon after just two months, what he learned at Google, and the decision to leave a stable engineering career to bet on himself. We also discuss what coding interview preparation teaches beyond passing interviews, the value of going deep on difficult problems, and why systems thinking and domain expertise remain essential engineering skills in the age of AI. Throughout the conversation, NeetCode makes the case that learning hard things is one of the single best investments an engineer can make, helping build the judgment and expertise that remain valuable no matter how the tools change. Key observations from NeetHere are 10 interesting takeaways from our chat: 
1. Companies have no real method for evaluating engineers, and likely never did. Neet believes that the leetcode-style interview survived not because it predicts job performance but because it scales suprisingly well at large tech companies that need to train hundreds (or thousands!) of interviewers. 2. The CAP theorem’s “two of three” framing is widely taught but technically shaky. Neet felt that is an awkward theorem that is incomplete, and felt validated when Martin Kleppmann publicly criticized it too. This is a good reminder that it’s worth thinking for yourself, and not accepting theorems as true, without understanding them. 3. Amazon’s intense culture left Neet in afraid to ask for help – and that paradoxically, this helped him at Google. At Neet’s first job, he became used to work alone and to never ask questions, and continued this working style at Google. At Gooogle, his Google manager read him as independent: and thanks to this independence, he got promoted very quickly from L3 to L4 (to the mid-level engineering role.) 4. The Neetcode YouTube channel took off after Neet posted that he’ll post less because he got into Google. Before he shared that he got a software engieneering job at Google – back at that time, one of the most competitive companies to get into – there were not many people watching the Neetcode channel. Sharing that he got into Google turned out to be the best “sales pitch” though: and suddenly, people wanted to understand what he’d practiced that helped him get this job! 5. Cheating tools are resulting in in-person whiteboard interviews returning at Google. Neet noted how Google has started to return to onside onsite coding interviews, because it is only in this setting that interviewiewers can make sure that interviewees are not using invisible AI-powered cheating tools, which make it effortless to do well on data structure and algorithms (DSA) interviews. 6. Neet finds AI most valuable as a tech-debt and refactoring assistant. Neet is using AI to clean up years of very bad code quality on the Neetcode backend. Doint so also validates his original decision to take shortcuts because they could later be corrected. 7. Effort is becoming the differentiator because AI made everything else cheap. Neet says how you can prompt a design, a feature, or an answer (to a coding question.) But you cannot prompt caring, or your ability to defend why you made a choice. You can only do these if you put in the effort, and don’t leave it all to AI! 8. Predictions of coding’s death haven’t materialized as expected. Despite dramatic AI model improvements, Neet does not observe most engineers aren’t being laid off. In fact, he sees the opposite: devs doing more work than before! 9. Weighing tradeoffs is likely to be someting that we’ll remain better than LLMs. While LLMs have become a lot better at coding, Neet doesn’t believe they will be all that helpful making decisions involving judgement tradeoffs. 10. When hiring for Neetcode, personality traits and motivation are more important than coding skill. Neet’s best, recent hire is still an undergrad. This hire does not have as much coding experience, but does exceptionally well thanks to high agency. As Neet explained: “even if they have no idea how to start it, a week later they’ll have learned everything about it.” The Pragmatic Engineer deepdives relevant for this episode• Learnings from conducting ~1,000 interviews at Amazon • How experienced engineers get unstuck in coding interviews • The Reality of Tech Interviews in 2025 • Tech hiring: is this an inflection point? • AI fakers exposed in tech dev recruitment: postmortem Timestamps00:00 Intro 02:57 Neet’s take on coding interviews 06:41 Getting into tech 08:56 Why Neet isn’t a fan of the CAP theorem 13:12 Quitting Amazon after two months 18:22 Google vs Amazon 22:26 The origins of NeetCode 25:27 Leaving Google to go all in on NeetCode 32:02 Why Neet doesn’t fix every bug 39:26 The value of coding interview prep 42:57 Systems thinking and domain expertise 47:28 Hiring at Big Tech 52:15 Tech stack at Neetcode 57:57 The NeetCode redesign contest 1:01:46 The future of software engineers 1:09:04 Hot takes: AGI, AI skill erosion, personality traits 1:22:49 “Maybe some people should just give up” 1:24:39 How to be a standout engineer 1:27:55 Book recommendation ReferencesWhere to find Navdeep Singh (NeetCode): • LinkedIn: https://www.linkedin.com/in/navdeep-singh-3aaa14161 • YouTube: https://www.youtube.com/c/neetcode • Website: https://neetcode.io Mentions during the episode: • A critique of the CAP theorem: https://martin.kleppmann.com/2015/09/17/critique-of-the-cap-theorem.html • Designing Data-intensive Applications with Martin Kleppmann: https://newsletter.pragmaticengineer.com/p/designing-data-intensive-applications • PACELC design principle: https://en.wikipedia.org/wiki/PACELC_design_principle • Amazon Chime: https://aws.amazon.com/chime/getting-started • Musk’s 5 Step Design Process: https://modelthinkers.com/mental-model/musks-5-step-design-process • AI Engineering with Chip Huyen: https://newsletter.pragmaticengineer.com/p/ai-engineering-with-chip-huyen • Angular: https://angular.dev • Firebase: https://firebase.google.com • TypeScript: https://www.typescriptlang.org • An update on recent Claude Code quality reports: https://www.anthropic.com/engineering/april-23-postmortem • Building Claude Code with Boris Cherny: https://newsletter.pragmaticengineer.com/p/building-claude-code-with-boris-cherny • Sora: https://en.wikipedia.org/wiki/Sora_(text-to-video_model) • Attention is all you need: https://arxiv.org/abs/1706.03762 • The End of Programming as We Know It: https://www.oreilly.com/radar/the-end-of-programming-as-we-know-it • Satya Nadella on X: https://x.com/satyanadella • Replit: https://replit.com • Lovable: https://lovable.dev • 37signals: https://37signals.com • DHH’s new way of writing code: https://newsletter.pragmaticengineer.com/p/dhhs-new-way-of-writing-code • MongoDB: https://www.mongodb.com • Maybe some people should just give up: 
— Production and marketing by Pen Name. You’re on the free list for The Pragmatic Engineer. For the full experience, become a paying subscriber. Many readers expense this newsletter within their company’s training/learning/development budget. If you have such a budget, here’s an email you could send to your manager. This post is public, so feel free to share and forward it. If you enjoyed this post, you might enjoy my book, The Software Engineer's Guidebook: navigating senior, tech lead, staff and principal positions at tech companies and startups.
|
%26stroke%3Dnone%26strokeWidth%3D3.6){kind=small}
Comments
Post a Comment