May 23rd, 2022
The worst feeling as a developer is feeling like you ‘don’t know enough’ or feeling like you are miles behind other developers. You could say that this is a symptom of Imposter Syndrome. It is something that I’ve experienced as a developer where you believe that you are not as competent as other people in your field.
Luckily for me, I found a way that has helped me BIG TIME in helping me get rid of those negative thoughts. That is, working on self-initiated projects.
They are projects that you typically build only for yourself and are an excellent way to put into practice something you’ve learned or try something new that you can later implement in real-world projects.
As of writing this blog post (May 2022), all the projects you currently see on my portfolio site are self-initiated projects. I’ve been teaching myself how to build apps using React for over a year now and in that time, I worked on some self-initiated projects where I put into action what I’ve learned. This also gave me the chance to learn and implement other new things along the way.
Here are two self-initiated projects that I recently completed:
1) Car Trader App - An app for people that want to sell their car.
2) travelGram - An app for people to upload and share their travel photos.
I believe I am now a better developer as a result of building self-initiated projects. So here are my main reasons why working on self-initiated projects improved me as a developer:
The habit I previously had when learning a new programming concept or technology was that I would spend hours watching YouTube tutorials or following a Udemy course and replicating what the instructor was doing. With this approach, I would often fail to understand how and why something works or even worse forget. I soon realised that this was not an ideal way to learn something. This, therefore, encouraged me to adopt a ‘project-based’ learning approach. This is where self-initiated projects came into action. Instead of following a tutorial from start to finish, I started to build my own projects from scratch and whenever I stumbled upon a problem or a bug, I would spend time trying to find a solution on my own such as using Google, Stack Overflow, reading documentations, etc. As a result of adopting this approach, I can now better understand how and why something works and use that to create original projects.
Another thing I learned from building self-initiated projects was my newfound ability to break down and manage a big task.
Before I started building the Car Trader App and travelGram, I knew I had to create the frontend, backend, CRUD API, and the database for these apps. This was going to take a lot of work and instead of feeling overwhelmed I decided to break the projects down into various small projects. E.g., setting up the database, creating a component and then testing it, styling the frontend, etc.
By breaking the projects down into various micro-tasks, I found the overall experience of building the apps manageable as I would focus on building one feature of the app first, and once complete, I would then move on to the next feature. I would also give myself deadlines for each task so that I did not spend too long on any one task and to keep the momentum going in order to finish building the apps.
As a developer, it is important that I continue to develop my knowledge and learn new things. Building self-initiated projects allowed me to learn new technologies and put them into practice. I previously mentioned that I’ve been building apps using the MERN stack. Although I have experience building for the frontend, I had no prior experience developing for the backend or creating a database. These two things are vital when it comes to building full-stack apps. I then started learning more about Node, Express and MongoDB, technologies that I had not previously used. Once I had a basic understanding of how these technologies worked, I used that knowledge to help me build the backend of the apps.
There is usually little room for error when working on real-world projects as you need to complete work on time and within the budget. However, with self-initiated projects, I found a great deal of freedom as I didn’t have the pressure of having to necessarily meet a tight deadline. Through trial and error, I was able to experiment with new things and try out programming concepts that I was unfamiliar with. Naturally, when implementing new ideas, you are going to make mistakes, but I benefitted from this as it gave me the chance to learn from my mistakes and not make them when it is time to work on real-world projects.
Building self-initiated projects helped me solidify my programming knowledge, specifically the key concepts of ES6 and React. As I was building these projects, I noticed a pattern where I was able to comfortably use techniques without having to look up how to use them such as using arrow function, destructing arrays, when to use the spread operator, etc. This came from consistently using the tools that ES6 and React provide to build components, custom hooks, etc. I can confidently say that my programming knowledge has grown significantly as a result of working on self-initiated projects.
As a developer, it is my responsibility to find ways to improve my knowledge and expand on my skillset. Building self-initiated projects helped me to achieve this and it is something that I would recommend to other developers to try out no matter their experience level.