5 Mistakes Beginners Make When Learning Web Development

People getting started with web application development do so with the hopes of breaking into tech. Unfortunately, I often see many get on the wrong track and end up frustrated and dejected. There are a ton of tutorials and materials out there. But often many of these approaches don’t work. This post will help you identify and avoid these mistakes.

When you start to learn something new, it’s important to tackle concepts in the right sequence. If you skip certain fundamentals, you will feel lost later when you encounter more advanced topics. If you go too fast without fully internalizing a concept, you will have trouble implementing what you have learnt. This applies to all complex skills and definitely to web development.

Here are the 5 top mistakes I see beginners make when learning web development.

Mistake 1: Starting with the frontend

If you have never worked with web technologies, it’s natural to start with HTML and CSS. This is good. HTML is the foundation of the web. Everything at the end of the day boils down to the HTML on the browser. However, once you become proficient in it, you are tempted to dive into javascript and it’s enormous world of frameworks. This right here is the mistake.

Javascript frameworks can range from simple to highly complex. Most of them enable you to build what is known as Single Page Applications (SPAs). The idea behind SPA is to enable the browser to make round trips back to the server for data without requiring a page refresh. SPAs have been with us since the Web 2.0 era and results in great user experience. However, it’s a bad idea to attempt to learn SPAs without first having worked with building a basic web app that renders pages on the server. That’s because web apps maintain the source of truth for data on the server side. Without fully understanding how this backend works, you will struggle to build a complete end-to-end app.

For example I see beginners jump right into react tutorials that gloss over how and where the data is fetched. Once someone has taken these tutorials and are left to build their own app, the first question they struggle with is: where and how do I get the data? This is exactly when people get stuck and frustrated.

Mistake 2: Not focusing on full stack end-to-end development

I have seen many beginners shy away from learning the full stack, both backend and frontend. People starting with the frontend feel intimidated by the backend systems with databases and scalability concepts. And people starting with the backend feel they don’t need to bother with the frontend. Part of the argument for this has to do with specializing in one or the other. However, the conceptual division of labor around frontend and backend is always shifting. This shift has to do with the natural pendulum swing in technology where the computational heavy lifting is either done on the server backend or the client frontend. At the time of this writing a lot of the compute is being done on the client-size through heavy javascript frameworks, but that’s starting to shift again. We are now beginning to see more and more products leverage serve-side rendering to reduce the complexity on the frontend.

By learning the full stack end-to-end, you are able to adjust and work with the different paradigms regardless of where the client-server pendulum resides. You will have the necessary knowledge to evaluate backend systems, frontend frameworks and architect the right set of solutions for your problems. Complete foundational knowledge will not prevent you from going deeper in a specific area of specialization later. Rather, it will enhance your ability to contribute and work together in a team.


Mistake 3: Learning a framework instead of the language

Some frameworks have a tendency to obscure language features with additional abstractions. These abstractions exist to simplify and speed up repetitive development work. However, for beginners, not having visibility into the detailed nuts and bolts of a language leaves them without important fundamentals. Frameworks come and go, but languages have staying power. Learning the framework and not the language will leave you high and dry when the former eventually becomes obsolete. Further, without the language fundamentals you will be unable to evaluate new emerging technology in your space.

A better alternative is to learn to write boiler-plate code in order to learn and get a strong handle of the programming language. Once you know how it’s done in the native language, you can begin to explore frameworks and libraries to make your life easier and to build more complex applications. This again is an example of learning things in the right sequence to strengthen fundamentals.

Mistake 4:  Going in circles in leetcode style programming exercises

Programming exercises can be great to build your coding muscles. They help you familiarize with the various aspects of a language. Also they are great for learning data structures and algorithms. However, overdoing them can leave you with strong language skills without the more practical understanding of how to build complete applications that people would use. At the end of the day, our goal as Software Engineers is to help people solve problems through technology. And the value we create is delivered through the applications we build.


Mistake 5:  Not building end-to-end projects

Working on a complete application will provide you with the deepest understanding of what it takes to bring an app idea to life. There are many aspects to engineering that doesn’t have anything to do with code. Things such as how to breakdown a large problem into smaller tasks, how you to sequence the development work at each step towards a complete application. You will run into many of these situations and challenges in a team setting.

So there you have it, avoid these mistakes and you are guaranteed to be on the right track. Many of these apply to not just web development, but to software engineering in general.

So what does a better roadmap look like?

If these are the mistakes, then the obvious question is what does a better roadmap look like? I am working on a piece that shows exactly that. Sign up with your email below to be notified as soon as it’s ready!

Processing…
Success! You're on the list.

Leave a Reply

%d bloggers like this: