Critères d'acceptation : comment les rédiger (avec exemples)

Que sont les critères d'acceptation ? Schéma d'un contrat de validation réussite ou échec au niveau de la story.

Turn this article into takeaways for your work.

Each assistant summarizes the article only for you and suggests best practices for your work.

Les critères d'acceptation sont les conditions qu'une user story doit remplir avant que votre équipe la considère comme prête à être livrée. Bien rédigés, ils réduisent les retouches, les discussions et les bugs surprises au moment de la revue.

Que sont les critères d'acceptation ?

Les critères d'acceptation sont un ensemble de conditions précises et testables rattachées à une seule user story. Ils définissent ce que la fonctionnalité doit faire (et ne pas faire) du point de vue de l'utilisateur. Quand toutes les conditions sont remplies, la story est acceptée. Dès qu'une seule échoue, le travail continue.

Voyez-les comme le contrat entre la personne qui a demandé la fonctionnalité et l'équipe qui la construit. Plus de devinettes, plus de « je pensais que vous vouliez autre chose ». Juste une liste claire de conditions réussite ou échec, écrite avant le début du développement.

Les critères d'acceptation se situent au niveau de la story. Ils répondent à la question : « Comment saurons-nous que cette story est terminée ? » C'est une question différente de « Comment saurons-nous que le sprint est terminé ? », à laquelle répond la definition of done.

Chiffres clés

  • Le format Given-When-Then pour les critères d'acceptation a été introduit par Dan North dans le cadre du behaviour-driven development (BDD) vers 2006, afin de donner aux équipes une manière structurée et testable d'exprimer le comportement attendu. (Source : Dan North, « Introducing BDD », dannorth.net, 2006.)
  • L'Agile Alliance note que des critères d'acceptation ambigus ou absents comptent parmi les causes les plus courantes de retouches dans les projets agiles. (Source : Agile Alliance Glossary, agilealliance.org.)
  • Les équipes qui rédigent les critères d'acceptation avant de coder signalent des passages de relais plus rapides entre le développement et la QA, car les testeurs savent déjà quoi vérifier.

Formats de rédaction des critères d'acceptation

Deux formats sont les plus utilisés par les équipes. Aucun n'est meilleur dans l'absolu. Choisissez celui qui correspond à la façon de travailler de votre équipe.

Formats de critères d'acceptation : séquence BDD face à des règles indépendantes.

Given-When-Then (par scénario)

Aussi appelé format Gherkin, il vient du behaviour-driven development (BDD). Il structure chaque condition comme un scénario en trois parties :

  • Given (étant donné), l'état de départ ou le contexte
  • When (quand), l'action de l'utilisateur
  • Then (alors), le résultat attendu

Exemple, connexion d'un utilisateur :

Given un utilisateur inscrit se trouve sur la page de connexion
When il saisit un e-mail valide et le bon mot de passe puis clique sur « Se connecter »
Then il est redirigé vers son dashboard et voit un message de bienvenue

Given un utilisateur inscrit se trouve sur la page de connexion
When il saisit un e-mail valide et un mot de passe incorrect
Then il voit un message d'erreur : « E-mail ou mot de passe incorrect » et reste sur la page de connexion

Ce format convient bien quand le comportement est séquentiel et que vous pouvez écrire plusieurs scénarios d'échec à côté des scénarios nominaux. Les ingénieurs QA peuvent transformer chaque scénario directement en cas de test.

Par règles (liste de contrôle)

Certaines équipes préfèrent une simple liste à puces de règles. Ce format convient aux stories dont les conditions sont indépendantes plutôt que séquentielles.

Exemple, recherche de produits :

- Les résultats de recherche s'affichent en moins de 2 secondes pour toute requête
- Les résultats sont triés par pertinence par défaut
- Les utilisateurs peuvent filtrer les résultats par catégorie, fourchette de prix et note
- Si aucun résultat n'est trouvé, la page affiche : « Aucun résultat pour [requête]. Essayez d'autres mots-clés. »
- La barre de recherche conserve la requête de l'utilisateur après le chargement des résultats

Les critères d'acceptation par règles sont plus rapides à écrire et plus faciles à parcourir. Ils conviennent surtout aux contraintes d'interface, aux exigences de performance et aux cas limites qui ne s'inscrivent pas dans une séquence d'actions de l'utilisateur.

Critères d'acceptation et definition of done

Ces deux concepts sont souvent confondus. Ils résolvent des problèmes différents.

Critères d'acceptation et definition of done : conditions fonctionnelles propres à chaque story face à des contrôles qualité globaux.

Critères d'acceptation Definition of done
Périmètre Une user story Chaque story, chaque sprint
Qui la rédige Le product owner avec l'équipe Toute l'équipe ensemble
Quand elle est rédigée Avant le début du développement Une fois par projet ou par cycle de sprint
Ce qu'elle couvre Les conditions fonctionnelles de cette fonctionnalité Les contrôles qualité transverses (tests, revues, documentation)
Si elle n'est pas respectée Cette story n'est pas acceptée Aucune story du sprint n'est livrée

Une story peut satisfaire tous ses critères d'acceptation et échouer quand même à la definition of done, par exemple si elle n'a pas de tests unitaires ou n'a pas été relue par un pair. Les deux listes doivent être validées pour que le travail soit vraiment terminé.

Retrouvez le détail complet dans l'article sur la definition of done.

Caractéristiques de bons critères d'acceptation

Toute liste de conditions ne constitue pas de bons critères d'acceptation. Voici ce qui distingue l'utile du vague :

Testables. Chaque condition doit avoir un résultat clair, réussite ou échec. « L'interface est jolie » n'est pas testable. « Le bouton respecte un ratio de contraste de 4,5:1 » l'est.

Écrits du point de vue de l'utilisateur. Les critères d'acceptation décrivent ce que l'utilisateur vit, pas la manière dont le code est structuré. Évitez les détails d'implémentation comme « l'API renvoie un statut 200 ». Préférez « l'utilisateur voit immédiatement son profil mis à jour ».

Précis. Les chiffres, les états et les libellés comptent. « Réponse rapide » devient « réponse en moins de 1,5 seconde ». « Un message d'erreur » devient « le texte exact : "Le mot de passe doit comporter au moins 8 caractères." »

Validés avant le début du développement. Des critères rédigés une fois la fonctionnalité construite tendent à justifier ce qui a été fait plutôt qu'à décrire ce qui était nécessaire. Rédigez-les pendant le backlog refinement.

Pas trop nombreux. De trois à huit conditions, c'est une fourchette saine. Une story avec quinze critères d'acceptation cache probablement deux ou trois stories en une.

Comment rédiger des critères d'acceptation

Partez d'une story claire, couvrez les résultats attendus et les cas limites, employez un langage testable, relisez ensemble et rattachez les critères définitifs à la story.

Comment rédiger des critères d'acceptation : user story, cas limites, format, revue d'équipe, rattachement.

Étape 1 : partir de la user story

Impossible de rédiger des critères d'acceptation sans user story claire. Vérifiez que vous en avez une dans ce format :

En tant que [persona], je veux [objectif], afin de [raison].

Si la story est floue, précisez-la avant de rédiger les conditions.

Étape 2 : se demander « qu'est-ce qui doit être vrai pour que cela fonctionne ? »

Listez les comportements et les résultats que la fonctionnalité doit produire. Couvrez d'abord le scénario nominal, puis les cas limites et les états d'échec.

Étape 3 : choisir un format

Choisissez Given-When-Then si le comportement est séquentiel et que la QA pilotera la création des tests. Choisissez les règles si les conditions sont indépendantes ou si vous manquez de temps.

Étape 4 : écrire dans un langage testable

Remplacez les mots vagues. « Rapidement » devient un chiffre. « Correctement formaté » devient le format exact. « Doit fonctionner sur mobile » devient « la mise en page s'adapte à une largeur de 375 px ».

Étape 5 : relire avec l'équipe avant le début du développement

Partagez le brouillon avec les développeurs, la QA et les parties prenantes. Les développeurs repéreront les conditions techniquement impossibles. La QA verra les cas limites manquants. Les parties prenantes corrigeront les erreurs de logique métier. Faites-le pendant le backlog refinement ou le sprint planning, afin que tout le monde soit d'accord avant la première ligne de code.

Étape 6 : les rattacher à la story

Ajoutez les critères définitifs à la story dans votre product backlog. Ils restent attachés tout au long du développement et constituent la liste de contrôle que votre équipe utilise pendant la revue de sprint.

Exemples de critères d'acceptation

Voici trois exemples détaillés couvrant différents types de stories.

Exemples de critères d'acceptation : connexion, total de commande, état sans résultat.

Exemple 1 : connexion d'un utilisateur

Story : en tant qu'utilisateur régulier, je veux me connecter avec mon e-mail et mon mot de passe, afin d'accéder à mon compte.

Given l'utilisateur se trouve sur la page de connexion
When il saisit un e-mail enregistré et le bon mot de passe puis clique sur « Se connecter »
Then il est redirigé vers son dashboard en moins de 2 secondes

Given l'utilisateur saisit trois fois un mot de passe incorrect
When il tente une quatrième connexion
Then le compte est verrouillé pendant 30 minutes et l'utilisateur voit :
« Trop de tentatives échouées. Réessayez dans 30 minutes. »

Given l'utilisateur est connecté
When il clique sur « Se déconnecter »
Then sa session prend fin et il est redirigé vers la page d'accueil

Exemple 2 : total de la commande

Story : en tant qu'acheteur, je veux voir le total de ma commande avant de payer, afin de savoir exactement ce que je dois.

Condition Validée quand
Le sous-total est affiché Les lignes de commande s'additionnent correctement
La taxe est détaillée Le taux et le montant de la taxe sont affichés séparément
La remise est appliquée Le code promo réduit le sous-total avant taxe
La livraison est affichée Le coût est affiché, ou « Livraison gratuite » si la commande y est éligible
Le total se met à jour en temps réel Le total est recalculé quand le panier change, sans rechargement de la page

Exemple 3 : recherche sans résultat

Story : en tant qu'utilisateur, je veux savoir quand ma recherche ne renvoie rien, afin d'essayer d'autres mots-clés.

- Lorsqu'une recherche renvoie zéro résultat, la page affiche : « Aucun résultat pour "[requête]". Essayez d'autres mots-clés. »
- La barre de recherche conserve la requête d'origine de l'utilisateur
- Des suggestions de catégories associées apparaissent sous le message si elles existent
- Le titre de la page est mis à jour pour refléter l'état de recherche vide

Erreurs courantes à éviter

Les rédiger après coup. Des critères d'acceptation écrits après le développement décrivent ce qui a été construit, pas ce qui était nécessaire. Rédigez-les en premier.

Rester vague sur les états d'erreur. Des critères limités au scénario nominal laissent les développeurs deviner la gestion des échecs. Incluez toujours au moins un scénario d'échec.

Y mélanger de l'implémentation technique. « Le service appelle l'API de paiement avec une requête POST » n'est pas un critère d'acceptation. « L'utilisateur voit une confirmation de paiement en moins de 3 secondes » en est un.

Les rendre trop larges. Si vos critères d'acceptation couvrent plusieurs fonctionnalités distinctes, scindez la story. Une bonne story, avec de bons critères, tient sur une fiche cartonnée.

Sauter la revue d'équipe. Des critères rédigés seul (en général par le product owner) passent à côté des contraintes des développeurs et des cas limites de la QA. Relisez ensemble avant le début du sprint. Servez-vous des cérémonies agiles comme le refinement pour le faire de façon régulière.


De bons critères d'acceptation ne garantissent pas un excellent produit, mais ils évitent une catégorie précise d'échec : construire quelque chose que personne n'avait l'intention de construire. Rédigez-les tôt, relisez-les ensemble, et vos revues de sprint passeront de débats sur le sens de « terminé » à de simples démonstrations d'un logiciel qui fonctionne.

About the author

Tara Minh

Tara Minh

Senior Operations & Growth Strategist

Tara Minh is Senior Operations & Growth Strategist at Rework, helping B2B SaaS leaders scale without breaking their teams. Tara turns messy workflows into systems people actually follow. Readers get practical frameworks they can use to cut waste, align teams, and grow on purpose.