When looking at codebases or web-based products, we can learn a lot about their authors, their priorities, which technologies were used, and more. Unfortunately, we can also identify skill gaps and afterthoughts. In fact, you don’t have to be a developer to spot these, as they regularly hinder regular usage. Run some websites through Lighthouse and we find a myriad of issues — often performance and accessibility-related. Why do so many websites have the same flaws?
If job openings are any indication of what an average web development team looks like, it seems the average team is skilled at JavaScript, or rather JavaScript frameworks, and a host of tools that come from the JavaScript ecosystem like React, TypeScript, Zod, GraphQL/tRPC, Prisma/Drizzle, and many more. Often, these developers are so caught up with these tools and skills, that they’re at best somewhat competent in technologies and concepts we used to consider fundamental, like HTML and CSS. These openings also rarely mention accessibility, front-end performance, search engine optimization, or basic security practices. Apparently, these are all afterthoughts.
It’s clear that we, as an industry, build homogeneous — both technically and otherwise — teams with a lot of overlapping skills, leaving many essential skills to develop good software woefully absent. Consequently, many qualities are lacking in codebases whereas the JavaScript code is generally good or great. It’s sad the user won’t notice the neatness of our JavaScript, but will notice a poor Time To Interactive, a missing skip link when using a keyboard to navigate, or the announcement of dozens of ”click here“ links when requiring a screen reader.
Just like a state-of-the-art high-end computer with a decade-old processor will suck ass, so will every website and web app where essentials are afterthoughts. To achieve quality, we must achieve quality across the board. We cannot do that with significant skill gaps. Teams without a good coverage of skills to meet what they’re supposed to deliver are incomplete.
I will spare you from being shamed into developing skills you don’t want. Teams, however, do have the responsibility to identify and address skill gaps. If the description above sounds like your team, perhaps you should run a small workshop to self-assess and reflect on skills, or to gauge competency through tests or exercises. If your team is indeed primarily JavaScript-oriented, it’s likely there’s a front-of-the-front-end-shaped skill gap, and the flaws of the product you’re developing can be mitigated by filling it.
After identification comes mitigation. We can watch some talks or follow a training, but developers specialize in these things — you can’t catch up in a day or two. Alternatively, we can up the product quality by hiring a consultant or freelancer to identify the issues and potentially help fix them. But that won’t prevent future mistakes.
The only lasting fix is to have the knowledge in the team at all times, to make sure team members have complementary skills. This is also the hardest option to sell internally — you’ll have to convince whoever makes that decision. It’s a tough sell, and one that is unlikely to happen short-term. You can do both — mitigate issues immediately by hiring help temporarily and making sure that the next job opening fits your needs. Regardless of your approach, nothing happens when skill gaps are never identified or left unaddressed.
Run some websites through Lighthouse, and you’ll find perfectly functional sites with accessibility, performance, and other issues. Typically, the kind that could’ve been avoided with the skills of a front-of-the-front-end developer.