Tips for a Learning-Focused Approach in Software Development

After 20+ years as a Java developer, I've learned that staying current isn't about mastering every new feature or framework—it's about creating sustainable learning habits that prevent burnout while keeping you relevant. Many developers I mentor struggle with the same challenge: Java's ecosystem evolves rapidly, but our mental bandwidth doesn't expand to match. The constant pressure to learn can lead to anxiety, impostor syndrome, and eventually burnout. Here's my approach to sustainable learning that has served me well: 𝗙𝗼𝗰𝘂𝘀 𝗼𝗻 𝗳𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀, 𝗻𝗼𝘁 𝗳𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸𝘀 Frameworks come and go, but core principles endure. When you understand the fundamentals deeply, adapting to new implementations becomes much easier. 𝗟𝗲𝗮𝗿𝗻 𝗶𝗻 𝗰𝗼𝗻𝗰𝗲𝗻𝘁𝗿𝗶𝗰 𝗰𝗶𝗿𝗰𝗹𝗲𝘀 Rather than trying to master everything at once:   • Start with a solid understanding of a small core   • Gradually expand outward as needed   • Deepen knowledge in areas that provide the most value 𝗖𝗿𝗲𝗮𝘁𝗲 𝗮 𝗸𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗽𝗼𝗿𝘁𝗳𝗼𝗹𝗶𝗼 Just like financial investments, diversify your knowledge:   • 70% in stable core technologies   • 20% in emerging stable technologies   • 10% in experimental technologies 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁 𝗱𝗲𝗹𝗶𝗯𝗲𝗿𝗮𝘁𝗲 𝗿𝗲𝘀𝘁 Continuous learning requires recovery periods. Schedule deliberate rest to let new concepts integrate—take walks, alternate between learning and applying, and include "no learning" days. 𝗕𝘂𝗶𝗹𝗱 𝗮 𝗳𝗲𝗲𝗱𝗯𝗮𝗰𝗸 𝗹𝗼𝗼𝗽 Accelerate understanding by explaining concepts to others, writing about what you've learned, and building small proof-of-concept applications. 𝗨𝘀𝗲 𝘁𝗵𝗲 "𝗷𝘂𝘀𝘁 𝗲𝗻𝗼𝘂𝗴𝗵, 𝗷𝘂𝘀𝘁 𝗶𝗻 𝘁𝗶𝗺𝗲" 𝗽𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 You don't need to know everything about a technology—just enough to solve your current problems. 𝗖𝗼𝗻𝗻𝗲𝗰𝘁 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝘁𝗼 𝗽𝗿𝗼𝗯𝗹𝗲𝗺-𝘀𝗼𝗹𝘃𝗶𝗻𝗴 Abstract learning without application rarely sticks. Connect new concepts to actual problems you're facing in your current projects. Remember that sustainable learning isn't about speed—it's about consistency and resilience. The developer who learns steadily over years will ultimately outpace the one who burns out after an intense cramming period. What sustainable learning strategies have worked for you? I'd love to hear your experiences in the comments.

A Thought Framework for Approaching Any Software Job This is a simple way I’ve come to think about how to approach software work, mostly built from lessons I learned the hard way. Take what I’ve figured out over the years and make it your own. 1. Start by figuring it out yourself. Whatever task lands on your plate, take the first stab at it. Explore it yourself before running to someone else. Ask LLMs, search the web, poke around the codebase, read whatever documentation you can find, run the project, debug things, and try tracing how the logic and data flow through the system. It’s okay if you don’t fully get it. This raw, first-hand exploration is gold. It’ll teach you things you didn’t even know you needed to know. 2. But don’t torture yourself trying to do everything alone. Large codebases can be confusing, messy, and poorly documented. Sometimes, even getting the project to run locally feels like jumping through hoops, like weird proxy settings, broken scripts, flaky permissions, you name it. So give it a day. Try sincerely. But if you’re still lost, ask. Ask your teammates, your mentor, senior engineers, whoever. Don’t sit in silence thinking you’re supposed to figure it all out alone. And don’t worry about how “silly” your question sounds. Especially if you’ve already tried on your own. The quicker you ask, the faster you’ll move forward. And trust me, asking those basic questions often leads to deep understanding. 3. Get comfortable with being confused, often. Software is full of unknowns. You’re not failing when you’re confused, you’re learning. Even the most experienced engineers get stuck. The key is not to avoid confusion, but to develop a habit of moving through it. 4. Document as you go. When you figure something out, especially something that took you a while, WRITE IT DOWN, THEN AND THERE. Could be a doc, a README update, a Teams message, or just a quick note to your future self. This helps you solidify your learning, and it’ll probably help the next person too. 5. Don’t just fix the bug. Understand the system. Sometimes, it’s tempting to go straight for a patch, make it work, close the ticket, move on. But slow down. Try to zoom out and understand how the system works. Where else does this piece connect? What assumptions are baked in? The deeper your understanding, the better your solutions will be. 6. Build relationships with your team. People matter. Get to know your teammates. Understand who works on what. Build trust. When you have questions or need help, it’ll be easier to reach out. And when others know you’re doing your part, they’ll be more willing to support you. This isn’t a rulebook. Just a mindset that helps me stay grounded and keep moving forward in complex projects. If it helps you too, even a little, mission accomplished!

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.

There’s a shift happening in how we think about learning at work. For a long time, "learning" meant "ergh another thing to do" or stepping away from the day-to-day. Now the focus is shifting. Not more learning, but learning that’s built into the rhythm of work itself. It’s the real-time stuff that helps people notice what’s working, what’s not, and what to try next. The debrief after a messy meeting. The pattern you catch in your team’s Slack thread. The question a manager asks that changes how someone thinks. That’s where growth actually happens - in moments that already exist - if we’re paying attention. I think the real progress comes when work and learning aren’t two separate things. When people are building new skills as they solve work problems. When reflection becomes part of how things get done, not just when things go sideways. So how do you start moving toward that with your team? To design systems, habits, and conversations that make those moments easier to spot and share? 💬 Build microlearning into your 1:1s. Add a quick learning and reflection moment to each one. It takes the pressure off leaders to have all the answers and builds autonomy and accountability for development. Honestly, if you just restructured your 1:1s this way (and did nothing else), you’d see a massive shift in how people feel about their learning opportunities. 🤝 Equip leaders with skills to coach in the flow. Asking a question before giving a response. Quick feedback, real examples, and reflection prompts that connect learning to what’s happening right now. 📈 Link learning to real outcomes. Don’t just track completion, ask "What’s changed because of it?". It might be smoother teamwork, faster problem-solving, or better decision-making, that’s where you’ll see the impact of learning in the work itself. I've seen this witht the teams I work with: when learning connects to the work that actually matters, it stops feeling like another task and more like progress in real time. McKinsey & Company recently wrote about this shift. It’s a pretty good read for anyone thinking about what learning could look like for their team: 👉 Leading in a world of merged work and learning: https://lnkd.in/gs3S2y8w #development #peopleskills #workadvice #microlearning

How can I keep up with all the changes?! Feels like every couple months there’s a new language, or massive framework overhaul coming out 👇🏼 I feel like I’m falling behind. Help! I’ve felt this many times in my career... It’s easy to stick with what we know, and not go for interesting opportunities or innovative companies that would require learning new frameworks / languages. I want to share a proven system that has allowed me to break through the noise, not having enough time, and endless tutorial hell. 😅 This proven system comes from Richard Feynman – once dubbed “The Smartest Man in the World.” He said: “There are no miracle people. It just happens they got interested in this thing and they learned all this stuff. There’s just people.” He offered a proven process for learning anything new. I’ve tweaked it slightly to apply more to software engineering. 1️⃣ Read the official docs, grab a book, etc. Just keep it simple. Start with the official docs, google, or Chat GPT to get a basic overview of the topic you want to learn. 2️⃣ Try it out It’s important to get messy and try things out as you are reading and learning. Don’t just copy and paste from a tutorial or book. Try to add another feature or switch something up to increase your learning and understanding. 1️⃣↪️ Do more reading / research Learning is a very iterative process. You should be going back and forth between trying things out and doing more research. Rinse and repeat between steps 1 & 2 as many times as necessary. 3️⃣ Get it working It may take you a while of continually reviewing docs, and trying things in your code, but you will get there. Try to get each small piece working one at a time. Once you finally got it working (even if it’s messy) – sit back, celebrate, review your progress, and don’t forget to commit you work with git! 4️⃣ Refactor What you have now is probably pretty messy. Now that you’ve got it working, take some time to clean it up. Break things out into smaller components and utility files to keep things nice and maintainable, extensible, and easy to understand. 5️⃣ Summarize and document So many of us skip this step. We just copy paste from stackoverflow, get it working and ship it off. Only to find out later we’ve completely forgotten what we’ve “learned.” Summarizing and documenting what you learned in your own words help cement it deep into your memory. 🧠 6️⃣ Share what you’ve learned This is the final step to really lock in your learning, and help you remember it for a long time to come. Explain what you’ve learned to others, and iterate/improve your understanding based on their questions. If you can't explain it simply, you don't understand it well enough. – Albert Einstein Anyone can learn somewhere engineering! I believe in you – you’ve got this. - - - - - - - - - - - - - - - - - - - - - - P.S. If you liked this post, you’ll probably love my weekly newsletter: https://lnkd.in/e95JH9qH 

As an early career software engineer, it’s tempting to rush through tasks to check them off your list. While efficiency is important, don’t miss out on a crucial part of your growth: asking questions and digging deeper. When working on a task, even if it seems straightforward, take a moment to understand why you’re doing it and how it fits into the bigger picture. Explore beyond your immediate task to see how other parts of the codebase work. Why was this approach chosen? Could there be a better way? This is the time when you're expected to ask anything that will help you learn. Don’t be afraid to push your boundaries!