1. Soft skills

Best Practices

Getting started modules

This module provides recommendations of soft skills that students can aim to get better at while learning web development, and which constitute good traits to have when entering the industry. They will help immensely in developing the right attitudes for learning, researching, and collaborating, and increase the chances of getting hired.

1.1 Constant learning mindset

Students should get into the mindset of constant learning. The web is constantly evolving and technologies and trends are always changing, and they need to constantly update their knowledge to keep up.

  • Get into the habit of regularly reading technical news, blogs, and browser release notes.
  • Engage in reading tasks or small research projects semi-regularly.
  • Set aside specific learning time to spend on acquiring new skills.
  • Be curious.

Recommended news and information sites:

1.2 Open to embracing failure

A very common issue that causes students and new developers to shy away from experimentation and taking risks (for example when starting new projects or exploring new ideas) is fear of failure. Spend some time learning about the value that can be gleaned from making mistakes, and the lessons that can be learned and applied in the future in similar situations.

Here are some tips to improve this skill:

  • Define a safe space/peer group where people are free to ask questions and failure will not be judged harshly.
  • Look to your local community and try to find meetup groups with people who can either give you help and advice or are facing the same issues you are and can provide moral support or experiment together with you.
  • (For educators) Set up the marking schemes for your assessments so that you can still get a reasonable number of marks even if you didn't get the correct result provided the process is well documented. Award extra marks for innovation.
  • Run show 'n' tell or one-on-one sessions part-way through a project with peers and mentors to get feedback and insights into where you are going wrong and get advice on how to get back on the right path.
  • Run retrospective meetings to analyze projects, look at what didn't go so well, and talk about how to improve things next time.

1.3 Effective research

Web developers spend a lot of time searching for solutions to problems encountered in their work. Students should learn effective strategies for finding answers, and when to use which methods (e.g. don't jump straight to pestering the senior dev every time you hit a roadblock).

These strategies include:

  • Consulting the documentation.
    • When you are stuck with using a tool/product, consult the official documentation first. It is surprising how many people do not think to do this; official docs are often geared towards beginners, so people with experience may not think of them as being suitable for them.
    • Learn about different types of documentation — for example, tutorials, references, and other types — and understand when each type is useful.
  • Using search engines effectively (See How to use search like a pro: 10 tips and tricks for Google and beyond).
  • Choosing valid information sources:
    • Choose recommended sites such as Stack Overflow and MDN.
    • Check the dates on articles, and consider whether the techniques discussed are out-of-date. For example, does an article on CSS layout talk about modern approaches like grid and flexbox, or does it still present obsolete techniques like multi-column layouts with floats? Does it still talk about hacks for ancient browsers like Internet Explorer or Netscape 4?
  • Using social media effectively:
    • Build a network of folks who can help.
    • Join community groups where you can look for answers. For example:
    • Learn to give back as well as take; web developers who reciprocate are much more likely to build strong relationships and keep getting help.
    • When you find a useful answer, write about it. For example, blog about it or share it on a social network. Not only will the process of writing clarify the concepts to you, but you'll also get validation and/or feedback from the community. It could also help you to start making a name for yourself in the industry.
  • Making effective use of an experienced contact's time:
    • By "experienced contact", we mean a teacher, mentor, or senior developer.
    • Ask them what communication methods they prefer.
    • Think carefully about what questions to ask them beforehand, consider their time limited and precious.
    • Be sure to do some background research about the topic beforehand and don't ask questions that you can find answers to by searching the web or the official documentation.
    • Timebox the session to say 30 minutes.
    • Prioritize your issues.
    • Set a goal for the session, for example, "try to find a solution to the highest priority issue"; solving the biggest issue may also lead to a fix for other issues.
  • Rubber ducking as an effective help mechanism. See also https://rubberduckdebugging.com/.
  • Using AI to help with coding issues (for example ChatGPT or GitHub Copilot). You should use AI tools with caution, and familiarize yourself with their strengths and weaknesses:
    • On the plus side, they can speed up research/searches enormously, and help with structuring code and copy.
    • On the other hand, AI tools have no reasoning skills and frequently provide answers that are misleading or just plain wrong. You shouldn't just assume that AI answers are correct, and test them/verify them with other sources.


  • There is definitely a balance to knowing the right time to ask for help. Web developers shouldn't constantly pester their peers/colleagues, but equally, they shouldn't soldier on and pretend they know what they are doing when they don't.
  • Consider the value of saying "I don't know" at the right time.


1.4 Collaboration and teamwork

As a professional in the web industry, you are going to have to work with other people on projects, and while brainstorming ideas and proposals. Not everyone is born with an innate ability to work in a team, so it is beneficial to start incorporating some best practices early on and putting work into areas where you think you are lacking.


  • Learn about empathy, humility, conflict resolution, and cooperation. In all engagements, stay polite and respectful and do not use offensive language.
  • While working in a team in the real world, you will frequently be expected to do peer reviews. Practice how to deliver feedback constructively and respectfully. When receiving feedback, practice how to not take it personally, and focus on the positives and what you can learn.
  • Participate in pair programming, or work in teams on assessments to experience working with other people.
  • Practice running projects like a real software project, with a timeline, plan, and responsibilities. Learn about the software development lifecycle. Pick up some basic project planning skills and tools to be able to estimate and plan your work/project.
  • As part of the course, blog about your work, learnings, and roadblocks, share your code repositories, get peers to critique your work, and offer updates to fix issues in other people's work.
  • Join a Slack channel, Discord, or a similar space, ask peers for help, share resources, and discuss the work to be done (for example, see the Frontend Developers Discord server).
  • Practice asking and answering questions. Even if they seem somewhat trivial, always come up with one or two questions to ask when discussing or reviewing peer work. It is essential to practice explaining what you are doing and asking the right questions to find out what you need to know.
  • Help each other, rather than waiting for a teacher or senior dev to go around and help everyone. Less able peers will get help more quickly, and more able peers will become mentors and experience the satisfaction that it brings.
  • Observe and learn from other experienced folks how to engage in discussions as well as how to approach problem-solving/debugging.
  • Join an open-source project to practice the skills you learn, engage with folks in the community, and learn from observing others (see How to Contribute to Open Source Projects – A Beginner's Guide for useful information).

1.5 Succeeding in job interviews

Technical job interviews can be very demanding, and some have quite specific requirements.


  • Learn effective strategies for job searching. For example:
    • Attend networking events and job fairs to meet potential employers.
    • Keep an inventory of the people you meet and the companies you apply to.
    • Follow up with any promising leads you meet.
  • Create a portfolio.
  • Build the perfect resumé.
  • Get experience — build real projects and contribute to open source.
  • Build your online persona.
  • Use sites like LinkedIn to help with the above.
  • Practice writing answers for coding and design interview questions.
  • Build a collection of anecdotes to use for experience-based interview questions.
  • Be aware of the attributes that hiring managers look for in a candidate and prepare accordingly:
    • Someone they can get along with.
    • Positive attitude, respectful, empathic, constructive.
    • Open-minded and works well in a diverse team with diverse viewpoints.
    • Graceful when a decision does not go their way, able to align for the greater good.
    • Good communicator and relationship builder.
    • Tenacious, focused, good problem solver.
    • Having a good portfolio.
  • Be patient. Even the best candidates will get rejections from multiple job applications before they land the job they want.


1.6 Workflows and processes

An important aspect of technical projects that beginners often miss out on is an idea of the bigger picture of a project. They might learn an individual tool or language and understand what they need to do, but be unaware of all the other codebases, tools, systems, and job roles that go together to deliver an entire web application. It is useful to understand the following at a high level:

  • Typical technology combinations and application architectures in common web projects.
  • Typical processes for a technical project, including where different tools are used in those processes.
  • Typical job roles, and where they are involved in those processes.
  • Common work management styles, such as agile and waterfall.


1.7 Relevant contextual information

While not essential for understanding the technical topics listed in the curriculum, there is a range of contextual information that can help developers gain a well-rounded and flexible perspective.


  • To understand why things are the way they are, study the relevant historical context. For example:
    • Why was the web designed like it is in terms of data delivery when arguably faster mechanisms exist?
    • Why does the web use a document model with links as a central feature when these days it is largely used to build apps?
    • Why are web standards created like they are, in collaboration, when the process isn't necessarily as efficient as it could be?
  • Study general programming concepts where relevant, for example:
    • The purpose of objects, and what they enable in terms of the design of a language like JavaScript and its surrounding APIs.
    • How loops work and why they are needed.
Previous: Getting started modulesNext: 2. Environment setup