Quand on débute en développement web, les premières pages fonctionnent souvent « à peu près » : le texte s’affiche, un bouton réagit, quelques styles donnent une apparence correcte. Pourtant, sous cette surface encourageante, certaines erreurs reviennent très vite. Elles ne sont pas graves en soi, mais elles rendent les projets difficiles à modifier, peu accessibles, mal adaptés aux mobiles et pénibles à faire évoluer.

L’objectif n’est pas d’écrire un code parfait dès le premier jour. L’objectif est plutôt d’apprendre à repérer les mauvaises habitudes avant qu’elles deviennent automatiques. Une page web solide repose sur trois couches complémentaires : HTML pour la structure, CSS pour la présentation, JavaScript pour le comportement. Cette séparation est détaillée dans l’introduction à HTML, les bases de CSS et les premiers pas en JavaScript.

Erreur 1 : écrire du HTML qui décrit l’apparence au lieu de la structure

Une erreur très fréquente consiste à utiliser les balises HTML selon leur rendu visuel par défaut. Par exemple, choisir une balise div partout, utiliser un titre uniquement parce qu’il est gros, ou créer un bouton avec un lien parce que cela ressemble à ce que l’on veut obtenir.

Voici un exemple fragile :

<div class="page">
  <div class="title">Nos produits</div>
  <div class="card" onclick="openProduct()">
    <div class="card-title">Sac à dos urbain</div>
    <div class="card-text">Voir le détail</div>
  </div>
</div>

Visuellement, ce code peut fonctionner. Sémantiquement, il est pauvre : le navigateur ne comprend pas vraiment la hiérarchie du contenu, les technologies d’assistance n’identifient pas l’action comme un bouton, et le clavier risque de ne pas permettre l’interaction.

Une version plus robuste utilise les balises pour leur rôle réel :

<main class="page">
  <h2>Nos produits</h2>

  <article class="card">
    <h3>Sac à dos urbain</h3>
    <p>Un modèle compact pour les trajets quotidiens.</p>
    <button type="button">Voir le détail</button>
  </article>
</main>

Le HTML ne sert pas seulement à afficher du contenu. Il donne du sens au document. Cette sémantique améliore l’accessibilité, le SEO, la maintenabilité et parfois même la simplicité du CSS. Avant d’ajouter une classe ou du JavaScript, demandez-vous toujours : « Quelle est la nature de cet élément ? Un titre, une navigation, un article, un formulaire, un bouton ? »

Pour aller plus loin, les bases de l’accessibilité web montrent pourquoi cette structure est essentielle dès les premiers projets.

Erreur 2 : créer un CSS qui devient impossible à maintenir

Au début, on écrit souvent le CSS au fil de l’eau : une règle ici, une surcharge là, puis un !important quand rien ne marche. Le résultat devient vite imprévisible. Plus le fichier grossit, plus chaque modification risque de casser une autre partie de la page.

Exemple typique :

.title {
  color: blue;
  font-size: 32px;
}

.card .title {
  color: black !important;
  font-size: 18px;
}

div div p {
  margin-top: 20px;
}

Ce code pose plusieurs problèmes : noms trop génériques, dépendance forte à la structure HTML, spécificité mal contrôlée, usage de !important comme rustine. Une approche plus saine consiste à nommer les rôles visuels et à limiter la profondeur des sélecteurs.

.product-card {
  padding: 1rem;
  border: 1px solid #ddd;
  border-radius: 0.75rem;
}

.product-card__title {
  margin: 0 0 0.5rem;
  font-size: 1.125rem;
}

.product-card__description {
  margin: 0 0 1rem;
  color: #555;
}

Il n’est pas nécessaire d’adopter immédiatement une méthodologie complète. Mais quelques règles simples changent déjà beaucoup : éviter les sélecteurs trop longs, limiter !important, nommer les classes selon le rôle du composant, regrouper les styles par bloc d’interface, et garder une cohérence dans les espacements.

Sur des projets plus avancés, des outils comme les cascade layers CSS, le CSS nesting natif ou les design tokens en CSS et TypeScript permettent de structurer les styles de façon plus industrielle. Pour un débutant, le principe à retenir est simple : le CSS doit rester lisible même trois semaines après l’avoir écrit.

Erreur 3 : dupliquer le même code partout

La duplication est rassurante au début. On copie une carte, on change le texte, puis on recommence. Cela semble rapide, jusqu’au jour où il faut modifier la même structure à dix endroits.

<article class="product-card">
  <h3>Lampe de bureau</h3>
  <p>Éclairage réglable.</p>
  <button>Ajouter</button>
</article>

<article class="product-card">
  <h3>Chaise ergonomique</h3>
  <p>Dossier ajustable.</p>
  <button>Ajouter</button>
</article>

En HTML statique, une certaine répétition est normale. Mais dès que les données se multiplient, il devient utile de penser en modèle : une structure commune, des données variables.

Avec JavaScript, on peut déjà centraliser le rendu :

type Product = {
  name: string;
  description: string;
};

const products: Product[] = [
  { name: "Lampe de bureau", description: "Éclairage réglable." },
  { name: "Chaise ergonomique", description: "Dossier ajustable." }
];

const list = document.querySelector("#products");

if (list) {
  list.innerHTML = products
    .map(
      (product) => `
        <article class="product-card">
          <h3>${product.name}</h3>
          <p>${product.description}</p>
          <button type="button">Ajouter</button>
        </article>
      `
    )
    .join("");
}

Dans un projet Vue ou React, cette logique devient un composant réutilisable. L’idée n’est pas de choisir un framework trop tôt, mais de comprendre le réflexe : quand une même structure apparaît plusieurs fois, elle cache souvent une abstraction utile.

Attention toutefois à ne pas tout abstraire immédiatement. Deux blocs qui se ressemblent aujourd’hui peuvent évoluer différemment demain. Le bon signal est la répétition réelle : même structure, même intention, mêmes règles de modification.

Erreur 4 : tester uniquement sur son grand écran

Beaucoup de débutants construisent leur page dans une fenêtre de navigateur confortable, puis découvrent trop tard que le site est inutilisable sur mobile. Texte trop large, boutons trop petits, images qui débordent, menus inaccessibles : ces problèmes viennent souvent d’un manque de tests réguliers.

Un exemple classique :

.layout {
  width: 1200px;
  display: flex;
  gap: 32px;
}

Sur un écran étroit, cette mise en page déborde. Une version plus souple commence par accepter que la largeur disponible varie.

.layout {
  width: min(100% - 2rem, 1200px);
  margin-inline: auto;
  display: flex;
  flex-wrap: wrap;
  gap: 2rem;
}

.sidebar {
  flex: 1 1 240px;
}

.content {
  flex: 3 1 320px;
}

Il faut aussi vérifier les interactions : peut-on cliquer facilement avec le pouce ? Les champs de formulaire sont-ils lisibles ? Les images restent-elles proportionnées ? Le contenu est-il compréhensible sans survol de souris ? Ces questions sont au cœur du responsive design.

Une bonne habitude consiste à ouvrir les outils de développement du navigateur dès le début, pas seulement à la fin. Testez régulièrement à 375 px, 768 px et sur une largeur desktop. Le responsive ne doit pas être une correction finale, mais une contrainte intégrée pendant la conception.

Erreur 5 : ignorer les petits tests manuels

Quand on débute, on pense souvent que « tester » signifie écrire une suite complète de tests automatisés. En réalité, les premiers tests sont souvent manuels et très concrets : recharger la page, naviguer au clavier, réduire la fenêtre, cliquer plusieurs fois, envoyer un formulaire vide, vérifier les erreurs dans la console.

Voici une courte checklist utile avant de considérer une page terminée :

  • la page reste lisible sur mobile ;
  • les boutons et liens sont accessibles au clavier ;
  • la console ne contient pas d’erreur JavaScript ;
  • les images ont une alternative pertinente quand nécessaire ;
  • les formulaires ont des labels visibles ;
  • les textes restent compréhensibles sans dépendre uniquement de la couleur.

Pour les projets plus avancés, des tests end-to-end avec Playwright permettent de vérifier automatiquement les parcours importants. Mais même sans outillage complexe, un débutant peut déjà éviter beaucoup de régressions avec une routine de vérification simple.

Erreur 6 : corriger sans comprendre la cause

Copier une solution depuis un forum ou une IA peut débloquer une situation, mais cela devient dangereux si l’on ne comprend pas ce qui a été ajouté. Un position: absolute, un z-index: 9999, un overflow: hidden ou un !important peuvent masquer le problème au lieu de le résoudre.

Une bonne méthode consiste à isoler le bug dans un exemple minimal : enlever tout ce qui n’est pas nécessaire, garder seulement le HTML et le CSS concernés, puis réintroduire les éléments progressivement. Cette démarche développe une compétence fondamentale : diagnostiquer au lieu d’empiler des corrections.

Conclusion : progresser, c’est stabiliser ses habitudes

Les erreurs de débutant en développement web ne sont pas des échecs. Elles indiquent simplement les endroits où il faut construire de meilleurs réflexes : structurer le HTML selon le sens, écrire un CSS lisible, éviter la duplication inutile, tester tôt sur mobile et vérifier les comportements essentiels.

Le développement web devient beaucoup plus clair quand chaque technologie garde son rôle. HTML décrit le contenu, CSS organise l’apparence, JavaScript ajoute les interactions, et les tests vérifient que l’ensemble reste utilisable. En adoptant ces habitudes dès les premiers projets, vous écrivez du code plus propre, plus durable et plus agréable à faire évoluer.