Habits of Successful Engineers

The most productive engineers, I know don't work longer. They work differently. After years observing high-performing engineers, I've noticed a pattern in how they approach their work: They ruthlessly eliminate context switching. Instead of jumping between tasks, they batch similar work and protect deep focus time by blocking their calendar and turning off notifications. They distinguish between shallow and deep work. Email, meetings, and quick fixes are scheduled separately from complex problem-solving that requires uninterrupted thought. They embrace strategic procrastination. Not every problem needs to be solved immediately. Often, letting your subconscious process complex challenges yields better solutions with less effort. They prioritize based on impact, not effort. They regularly ask: "Is this the highest leverage work I could be doing right now?" This keeps them focused on what truly matters. The difference between being busy and being productive is intention. One fills your day with activity. The other fills your career with impact.

The best way to have a long and successful career as an SWE is to constantly invest in ourselves, I've been doing it for the last 19 years... (From IC → EM) 1) Initially, pick one new thing outside your daily work, maybe it's writing better documentation, joining code reviews, or learning Git inside out. Don’t aim for applause. The goal is to stretch just past your comfort zone, even if it feels invisible to everyone else. 2)  Learn to build relationships. Take the time to help a teammate debug or volunteer for onboarding a new hire. The habit of investing in people will pay off more than any one project ever will. 3) Try something you’ve never done, even if it fails. For a mentee of mine, it was launching a tiny YouTube channel to explain things simply. He didn’t care about views. He learned how to think on his feet, tell a story, and teach himself on the fly. That skill made him a better engineer and leader. 4) Commit to learning something every quarter: maybe it’s a design pattern, maybe it’s a morning routine that keeps your energy high, maybe it’s how to say no to work you shouldn’t be doing. These are the investments that stay, even when roles and companies change. 5) Shift from “what do I need now” to “who do I want to become.” Don’t be always obsessed with learning the hottest framework. What makes the real difference is learning to communicate ideas, writing clear PRs, breaking down complex problems, or even just explaining code in plain English. 6) Don’t chase skills just for your resume, learn things that interest you, even if they seem useless now. Side projects, blog posts, reading about design, or understanding how sales work, these are the things that changed the way I solve problems at work. 7) Build habits for the long haul, not just for the next review cycle. The best investment? Consistency. Whether it’s shipping code every week, running every morning, or reflecting for 5 minutes each night, pick something, stick with it, and let time do the work. 8) Remember: every company, every team, every title can disappear overnight. But the skills you’ve practiced, the relationships you’ve built, and the mindset you’ve shaped, that’s the portfolio that always moves with you. 9) The work you do on yourself is the only permanent asset in your career. Make deposits every year, big or small. That’s how you grow long after the company badges change. 10) Keep investing. It’s the only compounding asset that never gets wiped out.

I'm a Software Engineer working at AWS, with over 7 years experience. The last few years of my life has taught me a lot. If I could talk to my younger self or any other junior engineer for that matter, here's what I would tell them:  [1] Learn fundamentals, not frameworks. Frameworks change quickly, but core concepts stay with you your whole career. Strong fundamentals make you adaptable, confident, and effective anywhere. [2] Design before coding. If you can’t explain your solution clearly, then the implementation will be unclear too. Draw it. Write it. Challenge it. Then build it. Good design reduces rework and gives you a direction worth building. [3] Read code, not just write it. Study the systems you work in and understand why things were built the way they are. Reading code builds real context — and context makes you faster, wiser, and more effective. [4] Write for humans first, computers second. Choose clear names, small functions, and simple logic, and follow the practices set by your team and engineers before you. Maintainable code makes everyone’s job easier. [5] Know when not to build. Not everything needs more code, sometimes the best solution is removing or reusing what already exists. Favour simplicity, avoid premature abstractions, and keep your systems lean. Code is a liability. [6] Write things down. Design docs, architecture notes, and thoughtful PR descriptions show your thinking. Writing brings clarity, and clarity helps the entire team move faster. [7] Don’t shy away from operations / devops. Many engineers avoid this work, but understanding how your code runs in production is one of the most important parts of the job — build it, own it, run it. It leads to safer judgement. [8] Become great at debugging. Most engineers can build features, but not many fewer can fix issues under pressure. Learn how to troubleshoot calmly using logs, tracing and systematic problem solving. [9] Own your career path. If you’re in a job that doesn’t help you grow, work with your manager to change that. If things still don’t improve, find a place that supports your goals. Your career is yours to steer. [10] Communicate clearly and earn trust. Be honest about what you know and what you don’t. Listen carefully, share progress early, and follow through on what you promise. [11] Keep pushing yourself and don’t give up too quickly. There will be tough days and difficult problems. Stay patient, and keep pushing through. Growth often happens right after things start feeling uncomfortable. Resources to level up as software engineer: → The Pragmatic Engineer with Gergely Orosz for industry insights. → System Design One by Neo Kim for system design fundamentals. → Coding Challenges with John Crickett for real world project ideas. → Connect with engineers like Anton Martyniuk, saed, Alexandre Zajac, Demitri Swan, Sanchit Narula, Daniel and Mohamed A. for daily engineering wisdom. #softwareengineering

7 habits of highly valuable software engineers: 1. They Write Code, Not Puzzles. Your code isn't a secret language, it's a symphony of logic and elegance. Prioritize clarity over complexity. Craft APIs so friendly, even your grandma could integrate them. 2. They Obsess Over Users. The user isn't you (shocking, I know). They don't dream in JavaScript; they just want the damn thing to work. Test your code like your career depends on it (it kinda does). Build bridges with empathy. A happy user is the best kind of user. 3. They Swear by Teamwork. The lone wolf gets eaten alive. Share your knowledge, lift up your teammates, celebrate victories together. Remember, a rising tide lifts all boats. 4. They Pivot like Ninjas. Requirements change. Get over it. Clinging to outdated tech is like rocking a pager in your pocket. Adapt, evolve, and conquer. Flexibility is the key to survival, both in code and ninja battles. 5. They Bend Time (and Code) to Their Will. Deadlines don't care about your excuses. Neither does your boss. Break down tasks, prioritize ruthlessly, and estimate realistically (then add a buffer because of Murphy's Law). Master time or time will master you. 6. They Hunt Bugs Like Terminators. Bugs are like cockroaches – resilient and annoying as hell. Don't panic. Strategize, collaborate, exterminate. Every bug squashed is a battle won. 7. They Never Stop Growing. The tech world moves faster than a caffeinated cheetah. Stay hungry, stay curious. Read, attend, experiment. Complacency is the kiss of death for your career. Bottom line: Become a software engineer who creates magic, solves problems, and leaves a legacy that even your grandma would be proud of.

10 patterns I’ve noticed in engineers who grow, stand out and raise the bar:   They think before they speak → and when they do, it moves the conversation forward. They come prepared → ready to contribute, answer, and clarify. They read the codebase deeply → and leave it better than they found it. They stretch themselves → seeking complexity instead of staying comfortable. They document decisions → not just code → so others can trace the ‘why’ later. They offer feedback respectfully → and welcome it just as openly. They notice edge cases others miss → and quietly plug the gaps. They don’t chase credit → they chase clarity, quality, and impact. They mentor without making it a big deal → answering questions generously. They stay curious → reading PRs, RFCs, and design docs even when it’s not “their project.” -- What would you add?

Great engineers stand out through behaviors, not just technical skills. Top performers prevent problems by deeply understanding requirements before coding. This saves weeks of rework that comes from rushing. Career growth depends more on communication than knowing frameworks. Engineers who explain complex ideas simply and write clear documentation get promoted faster. Leaders notice consistent output, not short bursts of productivity. Working steadily for months impresses more than working intensely for a week. Elite engineers know when not to code. They find simpler solutions that need less maintenance and create fewer problems long-term. The biggest success factor - Making everyone around you better. Engineers who help their whole team improve always advance faster than those who work alone, no matter how brilliant.

Early in my career, I believed progress came from intensity. Long nights. Big pushes. Short bursts of extreme effort. It works for a while. But tech careers are not marathons. They’re not sprints either (pun intended!). They’re long hikes. Over more than two decades in this industry, what I’ve seen consistently outperform raw intensity is consistency. Small, repeatable learning habits. Steady exposure to new ideas. Regular practice and showing up… even when motivation is low, even when progress feels invisible, even when it may not be exciting anymore. Intensity feels productive because it’s visible. Consistency is quieter. Harder to notice day to day. But it compounds. Most people don’t burn out because they lack talent. They burn out because their pace isn’t sustainable. If you want to still enjoy this industry 10, 20, 30 years in, design habits you can maintain on a bad week, not just a good one. That’s how real careers are built. If you’re building a long-term career in tech, consistency will beat intensity every time. #careerintech #softwareengineering #techcareers #learning

I joined Google after working 2.5 years at Amazon. 6 years into tech, I’ve realized that tech isn’t just about coding—it’s about mindset, adaptability, and strategy. If you're early in your career, here are 7 things I wish I knew sooner: 1. Your Degree Stops Mattering After Your First Job No one cares about your GPA. No one asks where you studied. After your first job, what matters is: → What have you built? → How well do you solve problems? → Can you communicate your ideas? The sooner you let go of the "college mindset," the faster you grow. 2. Hard Work ≠ Career Growth Working 12-hour days and fixing endless Jira tickets won’t make you a staff engineer. What actually moves the needle? → Owning high-impact projects. → Understanding business problems, not just code. → Making your work visible (document, present, share). 3. Your Network is More Powerful Than Your Résumé Some of the best opportunities don’t come from job portals. They come from people who know your work. → Make friends with engineers outside your team. → Engage in tech communities, even if just online. → Don’t just network when you need something—give first. 4. Feedback is a Cheat Code (But Most People Avoid It) Most engineers wait for performance reviews. That’s a mistake. The best engineers seek feedback constantly. → Ask your manager: “What’s one thing I could do better?” → After a PR review, ask: “How would you have approached this?” → Feedback feels uncomfortable. Growth always is. 5. Being ‘Busy’ is a Trap Tech moves fast, and it's easy to get caught in a cycle of always feeling behind. The trick? → Focus on leverage: What’s the one task that makes everything else easier? → Ruthlessly prioritize. Not everything is urgent. → Productivity is not about doing more. It’s about doing the right things. 6. No One is Going to ‘Discover’ You A lot of smart engineers stay invisible because they assume their work will speak for itself. It won’t. → Share your knowledge (write blogs, give talks, contribute to open source). → Speak up in meetings. → If people don’t know your impact, it’s as if it never happened. 7. The Game is Long—Play it Smart Your career isn’t won or lost in a single year. The best engineers I know play the long game: → Invest in relationships. → Prioritize learning over short-term gains. → Avoid burnout—pace yourself. Tech rewards those who stick around and keep improving. Stay in the game, and success becomes inevitable.

If you're in your 20s as a software developer, here are 21 rules to remember to become an amazing engineer when you hit your 30s. I was ‘YOU’ once. These are lessons nobody taught me, but they came with experience that helped me make a strong impact at Microsoft with my team. 1. Don’t get too attached to your own code; stay open to improvements. 2. Complexity will come back to haunt you during on-call rotations. 3. Aim to resolve underlying issues, not just the surface symptoms. 4. Remember, users care about the functionality, not the elegance of your code. 5. Keep track of design decisions and document them for future reference. 6. Every piece of code you write adds maintenance risk—think twice. 7. Software is a continuous process; it’s never truly “done.” 8. Make sure you fully understand the problem before jumping into solutions. 9. Write clear and informative commit messages for your future self and others. 10. Avoid adding dependencies that aren’t essential to reduce potential issues. 11. Code reviews are a great way to share knowledge within the team. 12. Every choice in code is a compromise; weigh the pros and cons. 13. Remember that an estimate is not a guarantee. 14. Release early and refine often; iteration improves quality. 15. Following coding standards helps avoid unnecessary debates. 16. Design with future maintenance in mind to save effort later. 17. Everyone has a hard time understanding code they didn’t write. 18. Don’t hesitate to ask for assistance when you’re stuck. 19. You’ll always be learning something new in this field. 20. Simplicity in design pays off in the long run—don’t overcomplicate. 21. Don’t assume your first solution is the best; iterate and refine.

An engineer took three days to start a two-week project. The PM was getting frustrated. I was about to have a conversation about it. Then he came to Monday standup and said: "I think we can solve this without building anything. If we add one error message to the existing flow, 70% of the support tickets go away." He was right. We shipped in two days instead of two weeks. He'd spent those three days reading support tickets. Talking to the support team. Looking at what users actually complained about versus what the spec assumed they wanted. Most engineers receive a spec and start building. The good ones ask "is this the right thing to build?" before opening their editor. The great ones ask "do we need to build anything at all?" The instinct to start coding immediately feels productive. It looks productive on the board. But the highest-leverage work I've ever seen rarely starts with code. It starts with understanding the problem well enough to realize the spec is solving the wrong one. Nobody gets promoted for reading support tickets. But that engineer saved us two weeks of implementation, testing, review, and the ongoing maintenance cost of a feature that didn't need to exist. The most productive engineering work sometimes doesn't look like engineering at all. When's the last time not building something was the right call? #SoftwareEngineering #ProductThinking #EngineeringLeadership