Key Qualities of a Great Software Engineer

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

Great Backend Engineering: 1) Master one language deeply (Go, Java, or Rust). Don't just write code, understand memory, concurrency, and performance. 2) Build systems that handle 10,000+ requests per second. Know where bottlenecks hide. 3) Own database design. Indexes, normalization, query optimization. Your schema decisions matter for years. 4) Write code that others can read in 6 months. Clean architecture beats clever code. 5) Understand distributed systems. CAP theorem, eventual consistency, and failure modes aren't theory. 6) Monitor everything. Logs, metrics, traces. You can't fix what you can't see. 7) Know your infrastructure costs. Cloud bills reflect your design choices. 8) Ship features fast, but build systems that last. Balance speed with sustainability. This is the goal. You might not have all of these today. But work towards this. The difference between a good engineer and a great one isn't always talent. It's good systems thinking.

I've interviewed 100+ engineers at Microsoft, VMware & Instacart. The best predictor of performance isn't what you think. Here's what actually works: Most technical interviews are fundamentally broken. I ask candidates to describe their home internet setup. This single question reveals more than hours of coding tests. True engineers are obsessed with optimization. They can detail their router model, network configuration, and backup systems with enthusiasm. If they respond with "I don't know, it just works" - immediate red flag. The best candidates treat their home network like mission-critical infrastructure: "If the internet dies, I'm going ninja-level to figure it out. It's as important as breathing." This reveals the first trait I look for: Deep curiosity. The second trait? Systems thinking. I ask them to explain how email works. Not looking for textbook answers. Average candidates give surface-level explanations. Great candidates dive deep into: • DNS lookups • MX records • Multi-tier architecture • Edge cases They can't help themselves - they're fascinated by complexity. The third trait is crucial: Making complex things simple. At Acompli (acquired by Microsoft for $200M), I interviewed 100 iOS engineers to hire ONE. The key question: "How would you build an app where long lists scroll at 60fps?" 99% jumped straight into technical solutions. The 1% we hired? They started by asking about user experience and performance tradeoffs. These 3 traits combined: • Deep curiosity • Systems thinking • Simplifying complexity Are worth more than any coding test. Here's the counterintuitive part: You can't teach these traits. They're ingrained patterns developed over years. That's why I'd rather hire someone who compiled their own router firmware as a hobby than someone who aced every CS course. This approach helped me build teams that: • Scaled to hundreds of engineers • Shipped products used by millions • Led to multiple $100M+ exits The hard truth: Technical skills can be taught. But curiosity, systems thinking, and simplification abilities? Those are the real predictors of engineering excellence. Want to master the founder mindset and build better? Join Founder Mode for free weekly insights on startups, systems, and personal growth: https://lnkd.in/gSjjvzt9

What makes a great engineer great? I was asked this question on a job application lately, with the stated intent to learn more about my leadership approach. Which makes sense - what you value and encourage in your team members is a fantastic reflection of your values as a leader. I don't know if I ever was a great engineer when I was an IC - but I definitely have had the opportunity and pleasure to work with many amazing engineers since I stepped into leadership roles. Here are some of the themes I identified when reflecting on this question. This may not be a definition that works for every team, and it's certainly not novel - but it's what I've learned in my years running teams at SaaS products. - Great engineers are focused on leverage. They're focused on getting the most "bang for their buck," if you will, and not on doing things in the most fun or creative way. They aren't afraid to do the "boring" work of documentation, data analysis, or whatever else will add the most value to the team. - Great engineers emphasize collective ownership. They're willing to delegate expertise and grow other members of their team rather than exert their own influence or maintain control over their projects. They're invested in the success of not just their team, but the whole company - they don't shy away from collaborating across departments and are always looking for mutual purpose and benefit in their work. - Great engineers live at multiple levels of abstraction. They are capable of fluidly switching between the metaphorical forest and the trees, and are often the first people to say things like "wait, do we really need to build this?" in meetings. They know that the most effective code is often the code not written, and they are adept at pulling the team out of rabbit holes and perfection traps. - Great engineers pursue outcomes, not output. They don't measure themselves in how many stories they close, or how many pull requests they merge, but in the impact they have on the business. Not only do they focus their own efforts in this direction, but they inspire the rest of their team to do so as well. What may be interesting about this list is what's *not* present. Technical expertise and problem-solving skills are "necessary, but not sufficient" in my experience - you can't be successful without them, but you can't stand on technical proficiency alone and be a great engineer. You aren't building code in a vacuum - you're working with a team towards a business goal, and your ability to meet those needs effectively is what makes you great at your job. As an engineering leader, these are the qualities that I try to instill in my team. When I build career ladders, when I deliver feedback, when I structure coaching plans, and when I write promotion letters, these are the ideas I come back to again and again to demonstrate how the people on my team have grown and the value that they have been delivering to the business.

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.

After working with hundreds of startups and thousands of top software engineers, here’s what I’ve learned about what startups look for in a great software engineer (beyond technical skills): 14 Traits of High-Performing Software Engineers (And what we look for too!) 1. Grit Persistence, tenacity, and resilience. Keep moving against all odds. 2. No Ego Help others, collaborate, and be respectful. Listen to and share ideas—your idea doesn’t always have to win. 3. Mission-Aligned Not a 9-to-5er. Willing to push through when it matters for the mission, not by the clock. 4. Resourceful With little information, figure it out and get it done. Solve problems independently while keeping the big picture in mind. 5. Big Thinkers Understand the big picture and take the right action. Think strategically and act decisively. 6. Player/Coach A leader and a contributor. Lead by doing—guide others while rolling up your sleeves. 7. Growth Mindset Embrace challenges, experiment, and learn from mistakes. Always growing and improving. 8. Passion Love what you do so much that you solve problems in your sleep. 9. Lifelong Learners Genuinely curious, constantly learning inside and outside of work. Always upskilling. 10. Adaptability Comfortable with constant change. Thrive in fast-paced, ever-changing environments. 11. Self-Awareness Know when to take a break and refresh your mind and body to avoid burnout. 12. Communication Communicate for clarity—not to prove busyness. Don’t work in a silo. 13. Discipline & Focus Produce consistently, independent of noise and distractions. 14. Accountability Take responsibility for your actions and outcomes. Own your work and deliver on promises. -- Startups, especially in scale mode, focus heavily on culture fit. They look for people in it for more than a paycheck—those willing to dig in, solve problems, and help propel the company forward. Not about titles or org charts—just about getting sh*t done.

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.

Too often, coding is seen as a mechanical process, a means to an end. But coding isn’t just about writing functional software—it’s about shaping the future. Every line of code is a decision: about scalability, maintainability, and the legacy we leave for those who inherit our systems. Great code doesn’t just "work." It solves problems elegantly, anticipates future needs, and withstands the pressures of time and scale. Achieving this requires discipline, a commitment to simplicity, and a refusal to overengineer. Modularity and testability? Essential. Avoiding object-oriented Python? A pragmatic choice that respects Python’s strengths while embracing OOP in Java or C++ or C# for structured complexity. As software engineers, we must demand excellence—not because it’s easy, but because anything less undermines our work, our teams, and the companies we serve. The code we ship into production is the only work that matters. Anything else is noise. The lesson? Code as if the next person to maintain your work has zero patience. Respect your craft. Respect your peers. And most importantly, respect the user—because they are the reason we build. What practices have elevated the quality of your code? Let’s discuss.