Tips for Excelling in Software Development

The best advice I got as a junior engineer: 1. Make it work: In the initial stages, focus on creating a functional solution. Prioritise getting the core functionality up and running to establish a baseline. 2. Then make it right: Once the basic functionality is achieved, shift your focus to refining the code. Clean up your implementation, improve code structure, and adhere to best practices for better maintainability. 3. Then make it fast & pretty: After achieving functionality and code cleanliness, work on optimizing performance and enhancing the user interface. Ensure that the software runs efficiently and has a polished, user-friendly design. 4. Embrace Continuous Learning: Stay curious and committed to ongoing learning. Keep abreast of new technologies, tools, and methodologies to stay relevant and enhance your skills throughout your career. 5. Seek Feedback and Collaboration: Actively seek feedback from peers and experienced colleagues to improve your skills. Foster a collaborative environment that encourages open communication, leading to innovative solutions and a stronger team dynamic. 6. Prioritize Documentation: Document your code, processes, and decisions clearly. This not only aids in understanding your work later on but also helps team members comprehend and maintain the code, contributing to an efficient workflow. 7. Understand the Business Context: Go beyond technical skills and strive to understand the broader business context. Align your technical efforts with organizational goals to make your contributions more impactful and meaningful. 8. Practice Problem-Solving: Develop a problem-solving mindset by breaking down complex issues into manageable components. This approach not only makes problem-solving feasible but also helps in identifying root causes and fosters resilience in the face of technical challenges. 9. Prioritize Security and Reliability: Emphasize security and reliability in your work. Write secure code, ensure robustness in solutions, and prioritize testing to create software that not only functions well but is also resilient to potential vulnerabilities and failures. Remember, a well-rounded set of skills and attitudes will not only make you a proficient engineer but also contribute to a positive and productive work environment.

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

I’m 40. Here are 23 things I wish I knew at 21 about being a good software engineer. (After spending 18+ years working as a software engineer at Amazon, Paytm, Google & startups) If you’re just starting out or in your 20s this might save you years of trial and error. 1. Don’t get attached to your code, someone else might see a better way. Real growth comes from letting your work be improved. 2. Every clever shortcut you add today can become a nightmare at 2 a.m. during on-call. Simplicity wins in the long run. 3. Fixing bugs on the surface is a temporary win. Solving root problems is what makes teams and products stronger over time. 4. Users don’t care about perfect code, they care about what works. Don’t lose sight of the real goal: delivering value. 5. Document your design decisions, even the small ones. Future-you (and your teammates) will thank you when debugging months later. 6. Every new line of code means more to maintain. Ask yourself if it’s really needed before hitting save. 7. Software is always evolving, there’s no “final version.” Embrace iteration and constant improvement. 8. Slow down and fully understand the problem before building. Rushing in usually means missing important details. 9. Clear, specific commit messages save hours when retracing what changed and why. Write them for your future self. 10. Every dependency you add is a potential source of bugs and pain later. Only include what’s essential. 11. Code reviews aren’t just for catching bugs, they’re for sharing ideas and building collective team knowledge. 12. Every technical decision has trade-offs. Always consider what you’re gaining and what you’re giving up. 13. Estimates are just guesses, not promises. Communicate the uncertainty and adapt as reality unfolds. 14. Release early, get feedback, and improve quickly. Waiting for perfection usually delays real progress. 15. Follow coding standards, they help teams move faster and avoid pointless debates. 16. Design with tomorrow in mind. The code you write today will almost always need to change later. 17. No one instantly understands code they didn’t write. Leave helpful comments and context for others (and yourself). 18. Don’t hesitate to ask for help. Even the best engineers get stuck, collaboration saves time and teaches you more. 19. Technology never stands still. Stay curious, keep learning, and don’t be afraid to admit what you don’t know. 20. Simple designs are easier to test, debug, and evolve. Resist the urge to add complexity for its own sake. 21. Your first solution is rarely your best one. Be ready to revisit, refine, and improve as you learn more. 22. Small, frequent improvements beat one big overhaul. Incremental progress adds up to major wins over time. 23. Take time to celebrate solved problems, but also to reflect on what could have gone smoother.

7 pieces of advice from a Senior software engineer (me) for software developers in their 20s who want to grow fast to the next level: I learned this after effing up 10s of times, attending postmortem & observing my seniors, follow this and it will fast-track your career growth: 1// Know the next level before promotion   - study the expectations of the next level early.   - observe senior engineers, ask questions, and understand their thought process.   - prove you’re already operating at the next level before asking for a promotion.  2// Become the user & engineer - read Reddit, X, and user forums, see what real users complain about.   - go beyond just shipping features, improve the experience.   - if possible, talk to users. the best engineers are empathetic.   3// Data = Cheat Code - check logs, events, and exceptions, where are users struggling?   - identify drop-offs, slow workflows, and unintuitive flows.   - let data guide your decisions, not just assumptions.   4// Not every problem is yours to solve   - ask: should I solve this, or guide someone else?   - learn to delegate, it’s not about doing more; - it’s about making sure the right things get done.   - the best engineers aren’t workhorses; they’re strategic.   5// Write code that saves time for others   - automate boring, repetitive tasks.   - document your work so others don’t struggle.   - invest in tools and scripts, it pays off exponentially.   6// Build strong relationships   - your career will grow faster if you have good mentors and peers.   - learn to communicate clearly, especially in writing.   - people don’t just promote great coders, they promote great collaborators.   7// Think like an owner, not just an engineer   - don’t just wait for tasks, proactively find ways to add value.   - be someone who sees problems before they become blockers.   - own your impact, not just your code.  The biggest jumps in my career came from changing how I think, prioritize, and collaborate.  If you’re in your 20s and serious about growing fast, start applying these today.

5 Things Every New Developer Should Learn (Most newbies miss the real essentials) Coding is more than typing fast. Many beginners focus on the wrong skills. Real growth comes from habits and mindset. Without these, projects feel too hard to finish. The right skills make learning much easier. I’ve helped many junior developers succeed. I’ve seen what makes some grow fast. → Problem-Solving Mindset ↳ Break big problems into smaller pieces. ↳ Ask “why” before writing any code. ↳ Plan steps ahead, think before coding. → Version Control (Git) ↳ Mistakes happen; Git keeps work safe. ↳ Git makes teamwork much easier for everyone. ↳ Knowing Git builds confidence on projects. → Debugging Skills ↳ Bugs are lessons, not failures. ↳ Read error messages carefully every time. ↳ Step through code, understand every part. → Clean, Readable Code ↳ Name variables and functions clearly. ↳ Write code easy to understand later. ↳ Clean code saves time and headaches. → Continuous Learning ↳ Tech changes fast; keep learning daily. ↳ Learn how to learn, not memorize. ↳ Read docs, blogs, and learn from others. Tips for Beginners: • Ask questions, curiosity helps you grow. • Pair programming teaches faster than alone. • Build small projects to gain confidence. • Don’t compare yourself with other coders. Coding is more than syntax and frameworks. It is thinking, debugging, learning constantly. Stop chasing shortcuts; focus on core skills. Master these five, doors will open . Good habits matter more than talent alone. P.S. Which of these five skills have you learned?

I’m often asked by software developers how they can grow—especially those early in their careers. I rarely tailor my answer to someone’s skill level. The truth is, the same habits that help you level up early on will carry you through your entire career. Here are six I always come back to: 1. Ask why before you build. Don’t just take a ticket and run with it. Ask what problem it solves and why it matters. That context will make you 10x more effective. 2. Ship small and often. You don’t need everything figured out to get started. Build something small that works, get feedback, and keep improving. Progress > perfection. 3. Own your stuff. If you built it, you’re responsible for how it works in prod. That doesn’t mean doing everything alone—it means caring enough to follow through. 4. Review code like it’s part of the job. Reviews aren’t a favor—they’re how you learn. Read more code than you write and ask questions when something doesn’t make sense. 5. It’s OK to mess up. Just learn from it. Mistakes happen. What matters is that you dig in, figure out what went wrong, and share what you learned. 6. Build side projects. Nothing accelerates learning like building something end to end—design, code, bugs, and all. You’ll gain confidence, pick up new skills, and maybe even build something useful. — If you’re doing those things, you’re way ahead of the curve. Keep showing up, stay curious, and keep shipping.

10 years of software engineering lessons Am I missing anything critical? 1. Go deep before you go wide. Master one language before chasing new frameworks. 2. Learn a strongly typed language like Java or Kotlin. It changes how you design systems. 3. Data structures, algorithms, and design patterns matter. You’ll use them constantly. 4. Debugging is a core skill. Think in first principles, not memorized fixes. 5. Ship something end to end. Nothing teaches you more than maintaining a real app. 6. Don’t chase every new framework. Understand principles and learn tools as needed. 7. Getting into FAANG or a top-tier company can be life changing for growth and pay. 8. Interviews are a skill. Treat them like one and they become predictable. 9. Don’t job hop every two years. Deep trust and ownership take time. 10. Promotions are a system. Learn what leadership values and align to it. 11. Keep a brag document. Memory fades, receipts don’t. 12. The top 1% of engineers get outsized rewards. Aim for impact, not activity. 13. Soft skills become the real bottleneck. Communication and empathy scale your influence. 14. Take full ownership of your work. Your career grows with your responsibility. 15. Stop waiting for permission. Success favors action. 16. Learn to say no. Impact depends on protecting your time. 17. Don’t ignore AI. The next great engineers will master it early. 18. Invest in your setup. Focus on ergonomics. 19. Remember a job is temporary. Skills and habits stay with you. 20. Read more. Not all readers lead by all leaders read. 21. Learn to write clearly. Your writing determines how far your ideas spread. 22. Mentorship matters. Both giving and receiving it accelerate growth. 23. Build public artifacts like talks or posts. They boost your visibility. 24. Build strong ties with PMs and designers. Great products are team sports. 25. Document your decisions. Future you will thank you. 26. Prioritize long-term code health. Refactors are cheaper early. 27. Build side projects. They keep your curiosity alive. 28. Don’t confuse complexity with sophistication. Simplicity wins. 29. Be known for something. A niche makes you memorable. 30. Learn to influence without authority. 31. When you feel stuck, teach. Explaining brings clarity. 32. Build relationships early. Networking works best when it’s genuine. 33. Protect deep work hours. Distraction kills true level output. 34. Don’t compare your path. Compounding careers look nonlinear. 35. Every career has seasons: growth, plateau, burnout, recovery. Respect them. 36. Workplaces change fast. Adapt or risk irrelevance. 37. You can’t outwork bad direction. Strategy beats hustle. 38. Don’t let perfection delay shipping. Excellence comes from iteration. 39. Be reliable. Consistency beats brilliance over time. 40. Keep learning, but also keep living. Your best ideas often come outside code.

After 5 years in software engineering, I thought I’d have it all figured out. Instead, I have better questions, a few scars, and lessons I wish I had learned earlier. Early on, I believed writing great code was enough.That if I worked hard, kept my head down, and delivered… everything else would fall into place. It doesn’t work that way. Growth in this field is less about just what you build and more about how you work, who you work with, and how you show up every day. Here are 20 lessons I’ve learned the hard way: ✅ Who you work for matters more than where you work. A great manager will accelerate your growth more than any big-name company. ✅ Loyalty has a price. Switching jobs is often the fastest way to grow your salary and role. ✅ Being easy to work with beats being brilliant. Communication > raw skill. ✅ Slow down and get it right. Speed is useless if the outcome is wrong. ✅ Stay friendly, but keep boundaries. Your personal life doesn’t belong at work. ✅ Titles can mislead. Real growth comes from skills, ownership, and impact. ✅ Visibility matters. Consistent updates build more trust than occasional big wins. ✅ Your reputation arrives before you do. Protect it. ✅ Share what you learn. Teaching others accelerates your own growth. ✅ Read other people’s code. It’s one of the fastest ways to improve. ✅ Master the boring work. Reliability earns you better opportunities. ✅ Keep building for yourself. Side projects keep the spark alive. ✅ If you can’t explain it simply, you don’t understand it well enough. ✅ Fundamentals outlast trends. Tools change, principles don’t. ✅ Hard work alone is invisible. Impact + visibility is what counts. ✅ Learn to say no. Focus is a career advantage. ✅ Documentation is a superpower. Clear writing scales your impact. ✅ Managers aren’t mind readers. Ask clearly for what you want. ✅ Learn the business, not just the code. That’s where real value lies. ✅ It’s a long game. Progress feels slow, but consistency compounds. Still learning. Still unlearning. Still building. 📸 For more behind-the-scenes, quick tips and opportunities like hackathons, internships, follow me on Instagram to stay ahead https://lnkd.in/gDHD-Q9A #tech #softwareengineering #careergrowth #sde

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.

I have been building software for 6 years (26% of my life 🤯). These are 10 things I wish I knew when I started: 1) Don't be afraid to look stupid ↳ Lying about understanding something takes away an opportunity to learn. 2) Less code = fewer bugs. ↳ Every line of code is a liability. Build only what’s necessary. 3) Ship small, learn fast. ↳ The faster you get feedback, the fewer wrong turns you take. 4) Users don’t care about your tech stack. ↳ They care if it works. Choose tools that get the job done, not the ones that make you look smart. 5) Break large task into smaller ones ↳ You think you have it all figured out, but describing the task in detail ALWAYS reveals something you haven’t thought about. 6) You don’t have to fix every bug immediately. ↳ Prioritize. Some bugs can wait, and some aren't worth fixing. Listen to users, not just your instincts. 7) Know when to stop optimizing. ↳ There’s no reason to make sure your app scales to 1 million users if you can’t even find the first one. 8) Validate before you build. ↳ Code is expensive. A quick prototype or landing page can save months of wasted work. 9) Technical debt is a business decision. ↳ Sometimes, shipping fast is more important than perfection. But know when to refactor. 10) Business goals first, tech second. ↳ Cool tech is useless if it doesn’t drive value. Always ask: How does this serve the business? Did I miss something? What would you add?