Smit Hinsu

Imagine you just joined Google as an SWE. It’s your first week, and you’re overthinking everything. You’re surrounded by world-class engineers, new systems, and an overwhelming urge not to mess up. The pressure to prove yourself is real, and so is the anxiety…so what should you do? Over the years, I’ve moved across orgs, teams, and sometimes, entire companies. Here’s exactly what I did (and still do) to ramp up faster and enjoy the process without letting anxiety win → Don’t let yourself stay stuck. If you’re blocked for more than 30 minutes, ask for help. Share what you’ve tried, show initiative, and intent. → Read way more code than you’re assigned. Dive into related modules, historic PRs, and old design docs. The context you gain helps you spot patterns and avoid mistakes. → Ask about the story behind the system. Find out why things are built a certain way, what’s failed before, and what’s on the roadmap. Understanding the “why” beats memorizing the “what.” → Volunteer for unglamorous work. Take ownership of tests, docs, or nagging integration bugs. This is where you quietly learn the most and build your internal network. → Offer help before you’re an expert. Chime in when you see questions, review PRs, or share a script. Even small contributions get you noticed for the right reasons. → Connect with skip-levels and cross-team leads. Set up short intros to learn about the broader vision and team priorities. You’ll spot opportunities to add value beyond your immediate tasks. → Document what you learn as you go. Share notes, update READMEs, or post quick how-tos in team channels. Your future self and your teammates will thank you. → Shadow someone during incidents or launches. Sit in on debugging sessions or war rooms, even if you’re just observing. You’ll see how senior folks think, react, and communicate under pressure. → Keep a running list of “how did that break?” moments. Every time you see a system fail or a hotfix go live, dig in. Reverse-engineering past problems is the fastest way to understand the architecture. → Show up with curiosity and intent, every day. Don’t just tick off JIRA tickets. Look for the bigger picture. People notice when you genuinely want to learn and contribute, not just “do your job.” Some orgs assign mentors, some don’t. Either way, these habits put you in the driver’s seat. Ramping up is less about brilliance, more about consistent intent. And the ones who learn this early end up leading teams later.

708

52 Comments

35 practical thoughts on system design Core Principles 1. Every system is a trade-off -> you never get speed, cost, and simplicity all at once. 2. Latency compounds -> every millisecond added across layers adds up to user pain. 3. Scalability ≠ performance -> one handles growth, the other handles speed. 4. Read vs. write paths -> scaling each requires completely different strategies. 5. Design for change, not perfection -> requirements will shift. Databases & Storage 6. Indexes are levers -> high-selectivity columns are worth indexing, low ones often aren’t. 7. Replication helps reads, partitioning helps writes -> don’t confuse the two. 8. Dual writes are a lie -> without coordination, you will see drift. 9. Event stores > queues (sometimes) -> better traceability, worse simplicity. 10. Cache invalidation is still the hardest problem -> freshness vs. performance is the eternal fight. Reliability & Consistency 11. Idempotency saves you -> retries without it will hurt. 12. Fail fast, fail loud -> silent failures sink systems. 13. Eventual consistency is a feature -> not a bug, but only if the business allows it. 14. Conflict resolution in active-active is business logic, not infra. 15. Durability isn’t free -> syncing across regions has cost and latency. Architecture Patterns 16. Microservices are an org structure, not a tech goal. 17. Monolith first, modular second, microservices last -> don’t jump too early. 18. Choreography scales, orchestration simplifies -> pick based on team maturity. 19. Serverless buys you focus, costs you control. 20. Queues don’t remove work, they smooth it. Observability & Operations 21. Tracing > logging -> logs tell you “what”, traces tell you “why”. 22. Metrics rot without ownership -> measure what someone actually uses. 23. Retries without backoff = DDoS on yourself. 24. Dead-letter queues aren’t optional -> every system has poison messages. 25. Levers > knobs -> design quick kill switches and controls to contain blast radius. Performance & Cost 26. Optimize the hot path, not the cold path. 27. Most bottlenecks live in the database, not the code. 28. Horizontal scaling beats vertical scaling ->until coordination kills it. 29. Warm caches mask bad queries -> measure against cold starts too. 30. The cheapest resource is disk, the most expensive is time. People & Process 31. The best architecture dies without documentation. 32. System design reviews aren’t about diagrams, they’re about trade-offs. 33. Small PRs are for speed, big PRs are for context -> balance both. 34. A senior engineer’s role in design is asking the uncomfortable “what if”. 35. No design survives first contact with production -> but good ones bend instead of break. Want to sharpen your instincts with daily practice? Check out joinenginuity.com One system design question every day, with streaks, badges, and leaderboards, and a dashboard to keep you sharp. Enjoy the rabbit hole!

1,457

93 Comments

The first SDE-2 absolutely nailed the system design round. The question was: Design a live streaming system. The second SDE-2 was asked to Design Google Drive. He did well, spoke about trade-offs, but missed one important detail: chunking the file, especially for large uploads. Yet, the second engineer got the job. These are from real interviews I took around 4 months ago. You might ask: Why? Only one reason, the second one nailed the behavioral questions like a boss. The question was about working on a project with tight timelines. The first SDE-2 (subtly) blamed the external team’s API for delays, which led to tight project deadlines. The second one, on the other hand, shared a story about how he helped his manager prioritize requirements to navigate the crunch. That’s how important behavioral interviews are. Yet, 90% of SDEs leave them to luck. If everything else is equal: - DSA (both solved the coding problems), - LLD (designed with solid object-oriented principles), - HLD (covered all the P0 functional and non-functional requirements) then your behavioral answers become the deciding factor. Yes, the second engineer missed the file chunking detail. But it wasn’t a critical red flag. He covered all other parts well and crushed the behavioral round. As long as you're working with humans (no matter how many), you’ll be judged on your behavioral skills. Call them soft skills, leadership skills, whatever you like, but you should prepare them well in advance. You can start preparing for behavioural interviews right away, with these 5 MUST read behavioural interview posts I wrote. (tip: save this post for later, as it may take some time to complete all of them) [1] How to answer any behavioural interview question https://lnkd.in/gH3N8b5q [2] 4 step guide for behavioural interview preparation in 3 hours https://lnkd.in/gccxG3MP [3] How to create 10+ stories for your past projects https://lnkd.in/g4nv_jqU [4] How to answer a failure story? https://lnkd.in/gtN-Dfuv [5] 10 behavioural interview mistakes to avoid at all cost https://lnkd.in/gpupvYVs If you’re preparing for mid-senior SDE or EM roles and need dedicated help with behavioral interview prep, DM me COACH.

136

23 Comments

Inference is where GenAI bleeds: API bills, 300 ms latencies, idle GPUs. vLLM is how you plug the leak. AI inference cost optimization and enterprise LLM serving start here. Two days ago we proved it at India’s first vLLM meetup at Red Hat, Pune. Outcome (TL;DR): 3 talks | 1 live demo | full hands-on lab. Tech first: - Steve Shirkey: Inference (not just training) is the GenAI battleground; Red Hat AI/Inference Server shows how to ship it at scale. - Me: GenAI inference + LLM fundamentals - Prasad Mukhedkar: Intro to vLLM: paged attention, continuous batching, prefill caching. - Suresh Gaikwad: Live demo of serving & monitoring models on OpenShift AI with vLLM. Hands-on > slides: Prasad spun up GPUs and vibecoded a self-serve UI so folks could grab a GPU and build. We: Installed/configured vLLM and ran vllm serve on an HF model. Tuned engine args, benchmarked, read serving metrics, and wired a Gradio chatbot to infer. People made it work: - Shamsher Ansari kept the discussion grounded by asking insightful questions about real use cases and sharing pain points from his own projects - Avinash Singh pulled a true Red Hatter move, learning while helping others. - Pros and students (Savitribai Phule Pune University and other colleges) brought the energy that made this click Even Yann LeCun says the big spend is shifting to inference, and Andy Jassy expects those costs to tumble as chips improve. Let’s own that curve, not rent it. #vLLM #AIInference #GenAI #OpenSource #EnterpriseAI

117

7 Comments