When I started my career and decided on my stack (Node.js and React), I dedicated all my efforts to becoming proficient in those technologies. I firmly believed that if an opportunity arose to explore something beyond my stack, I would decline it to avoid distraction from my primary focus. I was determined to specialize and avoid diversions. It is widely recognized that as a junior developer, concentrating on a single stack is an optimal approach, and straying from it should be avoided until one feels proficient. However, a professional career is rarely a straightforward path, and being prepared for unexpected challenges is crucial.
In my recent post, I explained my point of view of how the rise of AI has impacted professional development and how it has become increasingly apparent that being exceptionally skilled in a single language or stack may no longer hold the same professional value. While it remains essential to possess strong problem-solving abilities in general programming, companies often expect professionals to adapt to new challenges and learn different languages and technologies. This has been my recent experience, especially when joining a new company or team.
Joining a new company or team presents exciting opportunities for professional growth. However, it is not uncommon to encounter tasks or responsibilities that lie outside of one's area of expertise. Initially, this can be a daunting situation, particularly if you possess limited knowledge or experience in the required domain. Failing to adopt the right mindset and strategy can burden your daily work and potentially impact your career. In this post, we will explore a step-by-step approach that has consistently helped me effectively tackle unfamiliar challenges and embrace continuous learning.
However, one day, shortly after joining a new company, I was unexpectedly assigned the task of implementing a feature in Golang. Golang was not part of my stack, and to be honest, I had no desire to learn it. In my previous roles, I had always worked as a frontend engineer, and my closest encounter with Golang was in a React project where it was used for the backend. However, I never delved into the backend code as there was a dedicated developer for that aspect. I had convinced myself that I would never have to work with Golang, as my intention was to solely focus on my chosen stack.
Normally, I would stay within my comfort zone, relying on someone else specialized in that area to handle any backend-related challenges. Therefore, this new solicited implementation scared me a lot and sparked self-doubt. I even questioned whether I was in the right place if I had to work on something unrelated to my stack, and various other childish questions crossed my mind. However, I soon realized that this was an opportunity to learn something new and expand my skill set.
With the right approach, I could overcome this challenge and thrive in unfamiliar territory.
The following steps outline the approach I took to tackle this challenge and how it can be applied to any new domain:
Step 1: Adopt the Right Mindset
Sometimes convincing yourself that you can do something is the hardest part and here the impostor syndrome kicks in quite hard. First, don't be afraid to say 'I don't know how to do it', but dont forget to continue with 'but I'll figure it out'. Nobody expects you to know something about its clear that is beyond your expertise. But they do expect you to be willing to learn and figure things out. For this mindset is the key.
The first crucial step is to cultivate an open mindset towards accepting your limited knowledge and learning new, unrelated things. Recognize that the real world demands a diverse skill set, and adaptability is a valuable trait. Embrace the fact that the boundaries of your expertise can be expanded, and be willing to step out of your comfort zone. Embracing a learning mindset will help you approach new challenges with enthusiasm and determination. There's no point on delaying the inevitable, so it's better to start as soon as possible and you'd better have a positive attitude towards it.
Step 2: Start with the Basics
When faced with a new domain, start by gaining a fundamental understanding of the subject matter. Begin with beginner-level resources such as online tutorials, coding platforms, or video lectures. There are a ton of resources for beginners -most of them free- like Codecademy, Udemy, Coursera, Freecodecamp that provide interactive courses that can guide you through the basics of various languages and frameworks. By leveraging your existing knowledge in other frameworks/languages, you can grasp new concepts more quickly and efficiently than a complete beginner and it will allow to focus your energy on understanding the specific language features. Remember, don't try to rush to the advanced topics, you'll get there eventually and you'd better have a solid foundation.
As you learn, expect to make novice errors and encounter challenges along the way. It's essential to persevere and keep learning from your mistakes. Take the time to grasp the specific features and nuances of the new language or framework, going over them repeatedly until you gain a solid understanding. While it's always good to ask questions, try to find answers on your own first. The process of self-discovery fosters deeper learning and better retention.
Step 3: Create a Proof of Concept (POC)
Once you have a foundational understanding of the new domain, it's time to apply your knowledge practically. Seek guidance from your team to understand where your implementation might fit into the existing codebase. By asking questions and seeking clarification, you can get a clearer picture of how your solution should be integrated and what possible experiments you can do to test your ideas.
To gain confidence and experience, start by creating a Proof of Concept (POC) in a separate project. This POC should mimic the structure and functionality of the actual codebase, but in a minimalistic manner. By doing this, you can experiment and test your ideas without the pressure of working directly on the production code. Create as many POCs as you need, they don't even have to resemble the actual codebase, as long as they help you to understand and practice specifics of your future implementation. Remember, what matters in this stage is to prove a solution that works, not how it looks. Don't get yourself distracted with other dependencies, concepts, or patterns that are not related to your solution. The(se) POC(s) will serve as a valuable learning tool and help you understand the practical implementation of your solution and will also bring you confidence in this new domain.
Step 4: Hands-on Actual Implementation
With the POC as your guide, it's time to transition into the actual implementation. Begin with a simple task, even if it's just a print statement. The goal at this stage is to get something working, no matter how basic. By starting with a simple task, you can gain confidence and momentum and will confirm that you're on the right track. Then gradually build upon your initial implementation, adding more functionality and complexity as you go. Aim for incremental progress, steadily improving your solution.
Throughout this process, remember that code quality and abstraction can be refined later. Focus on getting a functional implementation first, and don't be overly concerned with clean code and other good practices, make it work, and once it does, you can take time on making your code better. Commit your code frequently to version control, allowing you to track your progress and revert changes if necessary. I made this blog post of how in order to create great code, you must write ugly code that works first.
Step 5: Seek Feedback
Once you have a working implementation, seek feedback from experienced colleagues on your team. Be open about your newness to the domain and express your willingness to learn. Also, don't expect that your colleague will do the work for you, while they might help your with some specific questions, you should rely on them only for guidance, not for implementation. That should be enough for you to keep improving your implementation. The reviews can and should be iterative, you're most likely not going to get it right the first time, so don't be afraid to ask for feedback multiple times.
Sharing your progress and seeking guidance can help you identify areas for improvement, rectify any mistakes early on, and streamline your codebase. Leveraging the expertise of others can save you time and prevent headaches down the line.
Step 6: Celebrate Your Success
There's nothing more rewarding than overcoming a —probably quite tough— challenge and learning in the process. And believe me, you will learn a lot. You should be proud of your achievement, and hopefully your team will acknowledge all the effort placed on this new challenge.
Congratulations! You now have a new highlight on your professional career and who knows, this may take you to new and exciting opportunities that you'd never thought of before.
Believe me, next time the process will be easier.
Conclusion:
Embracing new challenges outside your comfort zone is an essential part of professional growth. The steps outlined above have helped me to get past the initial hurdles and embrace new challenges with the confidence that they can be overcome with the right strategies and mindset. Remember, learning is a continuous journey, and every new experience expands your skill set. So embrace any possible opportunity to learn about anything new, and watch as your career blossoms with newfound versatility.
Photo from Markus Spiske at Unsplash
Top comments (0)