Rôles et autorisations : règles claires avec exemples concrets
Rôles et autorisations expliqués avec des exemples concrets pour décider ce que Propriétaire, Responsable, Personnel et Client peuvent voir et ainsi prévenir les fuites de données.

Le vrai problème : des personnes voyant des données qu’elles ne devraient pas voir
Une « fuite de données » au travail a souvent l’air ennuyeux. Un agent support ouvre le profil d’un client et voit l’historique complet des paiements. Un client se connecte et tombe sur des notes internes comme « Offrir 20% s’il se plaint » ou sur le coût réel et la marge d’une facture. Personne n’a volé de mot de passe. L’application a simplement affiché la mauvaise chose.
La plupart des fuites arrivent par accident. Les permissions sont ajoutées tard, un nouvel écran est livré rapidement, ou quelqu’un copie un ancien rôle qui était « assez bon » pour les tests. Puis un petit changement, comme l’ajout d’un champ à une table, devient silencieusement visible par tout le monde.
C’est pourquoi les rôles et les autorisations doivent être une partie prioritaire de l’appli, pas une case cochée à la dernière minute. La plupart des petites entreprises finissent par utiliser les mêmes quatre types de rôles : Propriétaire, Responsable, Personnel et Client.
L’objectif est simple : chaque personne doit voir uniquement ce dont elle a besoin pour faire son travail, et rien d’autre. Cela inclut les données en coulisses, pas seulement les écrans attendus.
Si vous construisez rapidement sur une plateforme no‑code comme AppMaster, cela compte encore plus. La vitesse est excellente, mais elle facilite aussi l’exposition accidentelle de notes privées, règles de tarification ou dossiers clients si l’accès n’est pas conçu dès le départ.
Rôles, autorisations et portée : définitions simples
Les rôles et autorisations sont les règles qui décident qui peut faire quoi dans une appli.
- Un rôle est une étiquette de poste comme Propriétaire, Responsable, Personnel ou Client.
- Les autorisations sont les actions spécifiques que ce rôle est autorisé à faire.
Un niveau d’accès est le résultat pratique de ces règles. Deux personnes peuvent être « Personnel », mais l’une a un niveau d’accès plus élevé parce qu’elle peut approuver des remboursements tandis que l’autre ne le peut pas.
Une méthode fiable pour éviter les erreurs est de commencer par l’accès minimum, puis d’ajouter seulement ce dont la personne a besoin pour effectuer son travail quotidien. Si quelqu’un ne modifie jamais de factures, ne lui donnez pas les droits d’édition « au cas où ». Il est plus facile d’ajouter un accès plus tard que de réparer une fuite de données.
La plupart des permissions se résument à un petit ensemble d’actions : voir, créer, modifier, supprimer, et quelques actions à risque élevé comme exporter ou approuver.
La portée répond à une autre question : « Sur quels enregistrements cela s’applique‑t‑il ? » Quelqu’un peut être autorisé à voir des factures, mais seulement les siennes, pas celles de tout le monde.
Les motifs de portée typiques sont :
- Enregistrements propres (seulement les éléments qu’ils ont créés ou qui leur sont assignés)
- Équipe ou lieu (leur agence, département ou projet)
- Toute l’entreprise (tous les enregistrements de l’entreprise)
Un commercial peut créer et voir ses propres devis, mais ne peut pas exporter la liste complète des clients. Un responsable commercial peut voir les devis de toute l’équipe et approuver des remises. Le propriétaire peut tout voir et exporter des rapports pour la comptabilité.
Ce dont les propriétaires, responsables, le personnel et les clients ont généralement besoin
La plupart des applis finissent par avoir ces quatre groupes. Les détails varient, mais le modèle reste le même. Si vous commencez par des rôles et permissions clairs, vous évitez beaucoup de moments embarrassants du type « pourquoi peut‑il voir ça ? » plus tard.
Propriétaires ont généralement besoin d’une visibilité totale sur l’entreprise. Cela inclut souvent la facturation, les paramètres de sécurité (règles de mot de passe et MFA) et l’historique d’audit pour voir qui a modifié quoi et quand.
Responsables doivent piloter une équipe sans être des administrateurs complets. Ils ont besoin de supervision (voir tout dans leur service), d’approuver des actions (remises, remboursements, congés, modifications de contenu) et de lire des rapports. Ils peuvent aussi avoir des actions d’administration limitées, comme inviter du personnel ou réinitialiser un mot de passe, mais pas d’accès à la facturation ou aux contrôles de sécurité globaux.
Le personnel doit pouvoir faire le travail quotidien rapidement, avec un risque minimal. Un défaut sûr est « uniquement ce qui m’est assigné ». Un agent support voit seulement ses tickets, un répartiteur voit uniquement les tournées du jour, et un commercial voit uniquement ses prospects. Les exports et téléchargements en masse doivent être désactivés par défaut et activés seulement en cas de besoin réel.
Les clients ne doivent voir que leurs propres données, même si plusieurs personnes partagent un compte. Laissez‑les effectuer des actions limitées (créer des demandes, payer des factures, mettre à jour leur profil), mais cachez les notes internes, commentaires du personnel et statuts réservés au staff.
Un ensemble de valeurs par défaut qui fonctionne dans beaucoup d’entreprises :
- Propriétaire : tout, y compris facturation, sécurité et journaux d’audit
- Responsable : données d’équipe, approbations, rapports, gestion utilisateur limitée
- Personnel : uniquement les enregistrements assignés, pas d’export massif, pas de paramètres d’administration
- Client : uniquement leurs enregistrements, pas de notes internes, actions limitées
Scindez l’accès par type de données, pas seulement par écran
Beaucoup d’équipes définissent rôles et autorisations par écran : « Le personnel peut ouvrir la page Commandes, les clients non. » C’est utile, mais cela manque le vrai risque. Les mêmes données apparaissent dans la recherche, les commentaires, les notifications, les exports et les pièces jointes.
Commencez par lister vos zones de données, pas vos menus. Les zones à fort impact incluent généralement les contacts clients, commandes et statuts de livraison, factures et paiements, salaires et notes RH, et notes internes ou analytics.
Décidez ensuite ce que chaque rôle peut faire pour chaque type de donnée : voir, créer, modifier, supprimer, approuver et partager. C’est là que les règles au niveau des champs comptent. Un même objet a souvent besoin d’une vue publique et d’une vue interne.
Exemple : une Commande peut inclure le nom du client, l’adresse de livraison, le prix, la marge interne et une note interne comme « Client se plaint souvent, offrir remise ». Un client doit voir l’adresse et le statut, mais jamais la marge ou la note interne. Un responsable peut voir tous les champs et approuver des remises. Le personnel voit les champs nécessaires à la livraison, mais pas les détails financiers.
Les fichiers et pièces jointes nécessitent une attention particulière. Contrats, pièces d’identité, reçus et captures d’écran contiennent souvent des infos plus sensibles que les champs du formulaire. Traitez‑les comme une permission distincte : qui peut téléverser, qui peut télécharger et qui peut prévisualiser. Décidez aussi si les pièces jointes héritent de l’accès de l’enregistrement parent (par ex. une facture) ou ont leurs propres règles.
Enfin, ne considérez pas les exports et actions en masse comme « inclus » parce qu’un rôle peut voir une liste. Rendez‑les explicites : export CSV/PDF, téléchargement en masse de pièces jointes, changements d’état en masse (approuver, annuler, rembourser), envoi de messages en masse (email/SMS/Telegram) et actions admin comme réaffecter des enregistrements.
Exemple business 1 : appli de ventes et facturation
Imaginez une petite société de services : le propriétaire vend des projets, des responsables supervisent les chantiers, le personnel exécute, et les clients approuvent les devis et paient les factures. Le moyen le plus rapide d’éviter les erreurs gênantes est de se mettre d’accord sur les rôles et permissions avant que quelqu’un ne se connecte.
Commencez par les détails d’argent. La tarification peut être visible par plus de personnes que la marge. Une règle commune : le personnel voit ce qu’il faut facturer, mais pas pourquoi vous avez choisi ce prix. Un technicien peut avoir besoin des lignes pour expliquer une facture, mais il n’a pas besoin de la marge interne, du coût fournisseur ni de la remise spéciale accordée pour obtenir le contrat.
Les données clients sont un autre point sensible. Beaucoup d’équipes veulent que plusieurs personnes puissent voir les coordonnées (pour appeler la bonne personne), mais que peu puissent les modifier. Sinon vous obtenez des écrasements accidentels comme l’adresse email de facturation remplacée par une adresse personnelle, et les factures n’atteignent plus la comptabilité.
Une configuration simple qui marche bien :
- Propriétaire : voit tout, y compris marge et historique des remises, et peut modifier le statut de paiement
- Responsable : peut créer devis et factures, approuver des remises et modifier les contacts clients
- Personnel : peut voir les détails clients qui lui sont assignés et les lignes de facture, mais ne peut pas éditer les règles de tarification ni voir la marge
- Client : ne voit que ses devis et factures, peut payer ou demander des changements
Verrouillez les actions à risque élevé. Marquer une facture comme payée, émettre un remboursement ou changer un moyen de paiement doit être limité au propriétaire (ou à un rôle financier de confiance).
Exemple business 2 : support client avec notes internes
Un support semble simple : les clients envoient des messages, votre équipe répond, et les tickets sont clos. Les problèmes commencent quand la même vue de ticket est réutilisée pour tout le monde. Un mauvais réglage, et les clients voient des notes internes, des tags ou même des statistiques de performance du personnel.
Imaginez une petite boutique en ligne avec une boîte de réception de support partagée. Un ticket contient le message client, les détails de commande, le statut d’expédition et des notes internes comme « possible fraude, vérifier pièce d’identité » ou « VIP, prioriser ». Ce contexte interne aide l’équipe, mais il ne doit jamais être visible du client.
Une séparation claire qui protège les données sensibles :
- Client : voit ses messages, les mises à jour publiques et la résolution finale. Pas de tags internes, pas de notes réservées au personnel.
- Agent support : voit les messages clients et seulement les données nécessaires pour résoudre le problème (historique de commande, etc.). Peut ajouter des notes internes et des tags.
- Responsable : voit tout ce que voit le personnel, plus des contrôles de réaffectation et des dérogations SLA.
- Propriétaire/admin : voit tous les tickets et des rapports globaux.
Les données personnelles identifiables (PII) côté client sont un autre piège. Le support a souvent besoin d’un téléphone ou d’une adresse, mais pas sur chaque ticket. Une bonne règle : afficher les champs sensibles seulement quand le flux le nécessite. Par exemple, montrer l’adresse seulement après que l’agent a sélectionné « problème de livraison », et la masquer quand le ticket est clos.
Gardez les métriques internes séparées de l’expérience client. Des indicateurs comme « temps avant première réponse », « score agent » ou « escalade vers le juridique » appartiennent uniquement aux vues staff et responsable.
Exemple business 3 : opérations et suivi des livraisons
Imaginez un entrepôt et une équipe terrain qui effectuent des livraisons toute la journée. Une personne planifie les tournées, une autre prépare les colis, et des chauffeurs effectuent les arrêts. Si votre appli montre de mauvaises informations aux mauvaises personnes, ce n’est pas seulement gênant — cela peut exposer des adresses client, des prix ou des notes internes.
Commencez par séparer ce dont chaque groupe a besoin chaque jour.
Personnel (préparateurs et chauffeurs) ont généralement une vue restreinte et centrée sur la tâche. Un chauffeur devrait ouvrir l’appli et ne voir que les missions assignées du jour, l’ordre des arrêts, les coordonnées du point et les instructions de livraison. Il ne doit pas pouvoir parcourir la liste complète des clients ni voir les missions des autres chauffeurs. Si quelqu’un couvre un service, un responsable peut réaffecter une mission plutôt que de donner un accès large.
Responsables ont besoin d’une vision opérationnelle plus large. Ils doivent voir les plannings de toutes les équipes, les niveaux d’inventaire et les problèmes en cours (livraisons en retard, échecs de livraison, articles endommagés, signatures manquantes). Ils ont aussi besoin d’outils pour résoudre les exceptions : réaffecter un arrêt, diviser une tournée ou approuver un ajustement d’inventaire.
Clients ont la vue la plus restreinte : uniquement le statut de leur livraison. Ils peuvent suivre l’ETA, voir la preuve de livraison et recevoir des mises à jour comme « en cours de livraison » ou « retardé ». Ils ne doivent jamais voir d’autres clients, les plans de tournées complets ou les notes d’exception internes.
Un moyen simple d’appliquer les rôles ici est de scoper les données par assignation et par compte client. Par exemple, un enregistrement Job de livraison peut être lisible seulement par (1) le membre du personnel assigné, (2) les responsables, et (3) le client lié à cette commande.
Étape par étape : comment concevoir rôles et autorisations
Commencez par nommer vos groupes d’utilisateurs en langage simple. « Propriétaire », « Responsable », « Personnel » et « Client » sont un bon départ, mais seulement s’ils correspondent à votre organisation. Pour chaque groupe, écrivez ce à quoi ressemble le succès en une phrase, par exemple « Les responsables peuvent affecter du travail et voir la performance de l’équipe sans voir la paie ».
Ensuite, mappez les actions aux zones de données. Ne pensez pas d’abord en termes d’écrans. Pensez aux données existantes et à ce que les gens peuvent en faire. Une simple grille sur papier suffit :
- Listez vos rôles et les zones de données (clients, commandes, factures, tickets, rapports).
- Pour chaque rôle, écrivez les actions nécessaires (voir, créer, modifier, approuver, exporter).
- Décidez de la portée pour chaque action (propre, équipe, ou tout).
- Définissez « équipe » clairement (agence, région, projet ou subordonnés directs).
- Marquez les éléments « jamais » (par ex. les clients ne voient jamais les notes internes).
Puis testez votre brouillon avec des tâches réelles, pas des hypothèses. Parcourez des flux courants comme « créer une commande », « résoudre un ticket » et « télécharger un rapport ». Si une tâche vous force à donner un accès large, il vous manque probablement une permission (par ex. « voir les totaux » sans « exporter »).
Ajoutez des approbations quand l’argent ou des changements sensibles sont en jeu. Le personnel peut rédiger une facture, mais seul un responsable peut l’approuver ou l’envoyer. Le personnel peut modifier des adresses de livraison, mais changer des coordonnées bancaires exige l’approbation du propriétaire.
Erreurs courantes qui causent des fuites de données accidentelles
La plupart des fuites dans les petites équipes ne sont pas des piratages. Elles arrivent quand l’appli donne silencieusement à quelqu’un plus d’accès que nécessaire. Les rôles et permissions échouent quand on les définit une fois et qu’on n’y revient jamais.
Un schéma courant : donner un accès admin complet « juste pour la configuration ». L’urgence passée, l’accès reste. Des semaines plus tard, cette personne exporte la liste complète des clients pour « aider à un rapport » et des données privées se retrouvent dans un tableur.
Erreurs récurrentes :
- Faire de « Admin » le rôle par défaut pour éviter les tickets support
- Autoriser des exports larges (clients, contacts, paiements, factures) sans limites ni audit
- Partager un seul identifiant pour une équipe sur un poste, ce qui empêche de savoir qui a consulté ou modifié quoi
- Sécuriser les écrans principaux mais oublier les portes de côté comme les vues mobiles, les PDF, les notifications email, les pièces jointes et les formulaires auto‑remplis
- Ne pas révoquer les accès : les ex‑employés conservent accès à l’appli, aux boîtes mail ou à des sessions sauvegardées sur leur téléphone
Les portes de côté sont les plus sournoises. Vous pouvez bloquer le personnel sur un écran contrat, mais leur envoyer quand même le PDF en pièce jointe par email. Ou votre mise en page mobile peut afficher des champs cachés sur la version desktop.
Une solution pratique est de traiter l’export et le téléchargement comme des permissions distinctes, pas comme un droit « voir ». Si un rôle a besoin d’une liste, donnez‑lui une vue filtrée plutôt qu’un export complet.
Vérifications rapides avant d’inviter de vrais utilisateurs
Avant d’inviter de vrais utilisateurs, supposez que quelqu’un cliquera sur le mauvais bouton, partagera un écran ou téléchargera un fichier qu’il ne devrait pas avoir. Quelques vérifications maintenant évitent un nettoyage douloureux plus tard.
Commencez par des valeurs par défaut prudentes. Lorsqu’un nouvel utilisateur est créé, il doit atterrir dans le rôle le plus bas par défaut, sans accès à l’argent, aux exports ou aux paramètres d’administration. Si quelqu’un a besoin de plus, que ce soit un changement délibéré.
Ensuite, testez l’expérience client comme un étranger le ferait. Les clients ne doivent voir que leurs propres enregistrements, même s’ils modifient des URL, recherchent ou filtrent. Un test rapide : connectez‑vous en tant que Client A et essayez de trouver Client B par nom, numéro de facture ou ID de ticket.
Cinq vérifications rapides qui attrapent la plupart des fuites :
- Masquez les champs sensibles par défaut (salaire, coût/marge, pièces d’identité, notes internes)
- Verrouillez exports et actions en masse
- Ajoutez des approbations pour les erreurs coûteuses (remboursements, paiements, changements de rôle)
- Confirmez que la portée est appliquée partout (écrans, résultats de recherche, réponses API)
- Assurez‑vous de pouvoir auditer les changements : qui a modifié quoi et quand, y compris les mises à jour de rôle et les actions de paiement
Faites un « test d’accident ». Demandez à un collègue d’accomplir une vraie tâche avec un compte personnel, puis essayez la même tâche avec un compte client. Si le client voit les prix internes, télécharge des listes clients complètes ou déclenche un remboursement, vos permissions sont trop larges.
Un scénario réaliste : une même appli utilisée par le personnel et les clients
Une demande courante commence comme ceci : un client veut un portail pour « vérifier le statut », mais votre personnel utilise déjà le même système pour gérer le travail. Sans rôles et permissions clairs, le portail peut exposer des notes internes, des commandes d’autres clients ou des tarifications réservées au staff.
Imaginez une imprimerie sur mesure. Une commande passe du devis à la production, à la livraison puis à la facture, le tout dans la même appli.
Voici ce que chaque rôle devrait voir dans ce flux :
- Propriétaire : tout, y compris la marge, la performance du personnel et tous les comptes clients
- Responsable : toutes les commandes de son équipe, les notes internes et la possibilité d’approuver remises et remboursements
- Personnel : uniquement les commandes qui leur sont assignées, l’étape suivante à réaliser et les coordonnées nécessaires
- Client : uniquement ses commandes, le statut haut‑niveau (Approuvé, En production, Expédié), les preuves de livraison et les factures à payer
Deux cas limites cassent souvent le modèle.
D’abord, un responsable couvre temporairement une autre équipe. Ne le transformez pas en Propriétaire. Donnez‑lui plutôt une portée limitée dans le temps, par ex. accès aux commandes de l’Équipe B pendant 7 jours. Quand la couverture se termine, l’accès expire.
Ensuite, un client VIP demande « plus de visibilité ». Donnez‑lui plus de contexte sans augmenter l’accès aux données. Affichez une timeline étendue ou un fil de discussion dédié, mais gardez les notes internes (comme « client en retard de paiement » ou « réimpression due à notre erreur ») réservées au personnel.
Les responsabilités évoluent, donc considérez l’accès comme quelque chose à revoir, pas comme définitif. Quand quelqu’un change de poste, évitez d’empiler les permissions. Retirez ce qui n’est plus nécessaire, puis ajoutez le jeu minimal requis pour le nouveau rôle.
Prochaines étapes : définissez une politique d’accès claire et mettez‑la en œuvre
Commencez petit. Choisissez un seul flux important, comme « créer une facture et encaisser un paiement » ou « enregistrer un ticket et répondre ». Définissez les rôles et permissions pour ce flux unique d’abord, puis étendez.
Mettez les règles dans un tableau simple et traitez‑le comme un document vivant : rôle, ce qu’il peut faire, ce qu’il ne peut pas faire, et les limites (par ex. « seulement ses enregistrements » ou « seulement son site »). Quand on vous demande « Le personnel voit‑t‑il le numéro de téléphone client ? », le tableau doit répondre en quelques secondes.
Déploiement pratique :
- Rédigez le tableau pour votre premier flux (Propriétaire, Responsable, Personnel, Client)
- Mappez chaque règle aux données spécifiques (y compris les champs) et aux actions (voir, modifier, exporter, supprimer)
- Créez des comptes démo pour chaque rôle et testez les tâches réelles bout à bout
- Lancez auprès d’un petit groupe, puis étendez une fois que rien d’anormal n’apparaît
- Révisez l’accès trimestriellement et immédiatement après des changements organisationnels (nouveau responsable, nouvelle équipe, nouveau prestataire)
Si vous construisez sur AppMaster (appmaster.io), il est utile de planifier les rôles en même temps que votre modèle de données et votre logique métier afin que les mêmes règles s’appliquent de manière cohérente sur le web, le mobile et les endpoints API.
Si vous le souhaitez, rédigez aujourd’hui votre premier tableau d’accès et testez‑le sur un flux. Cette seule étape prévient la plupart des fuites de données accidentelles.
FAQ
Commencez par lister les données que vous stockez (clients, commandes, factures, notes internes, fichiers), puis décidez qui peut voir, créer, modifier, supprimer, approuver, et exporter chacune d’elles. Partez du principe du moindre privilège et n’ajoutez que ce qui est nécessaire au travail quotidien.
Les permissions décident quelles actions une personne peut faire, tandis que la portée (scope) décide sur quels enregistrements ces actions s’appliquent. Par exemple, un membre du personnel peut voir des factures, mais seulement celles qui lui sont assignées ou liées à son site.
“Propriétaire, Responsable, Personnel, Client” couvre la plupart des petites entreprises parce que cela reflète la répartition habituelle du travail et des risques. Si votre organisation est plus complexe, conservez cette structure et ajoutez quelques rôles spécialisés (par ex. Finance ou Prestataire) plutôt que de faire de tout le monde un admin.
Par défaut sûr : les clients voient et peuvent agir uniquement sur leurs propres enregistrements, mais ne voient pas les notes internes, les statuts internes, les marges ou les tags réservés au personnel. Si un client demande plus de visibilité, offrez plus de contexte (un journal de suivi) sans exposer davantage de champs bruts.
Séparez « ce qu’il faut facturer » de « pourquoi ce prix ». Le personnel a souvent besoin des lignes de facture et du statut, mais ne devrait pas voir la marge, le coût fournisseur, l’historique des remises ou les contrôles de paiement comme le fait de marquer une facture comme payée.
Considérez l’export comme une permission à risque élevé, pas comme un droit lié à la simple consultation d’une liste. Beaucoup de fuites accidentelles viennent d’une exportation d’une liste client complète ou d’un historique de factures vers un tableur sans qu’on réalise le niveau de données inclus.
Les écrans ne sont qu’un lieu d’affichage : les données peuvent aussi apparaître dans les résultats de recherche, les notifications, les PDF, les mises en page mobiles, les pièces jointes et les réponses API. Sécurisez d’abord la couche données et la visibilité des champs, puis construisez les écrans par dessus.
Traitez les pièces jointes à part car elles contiennent souvent des informations plus sensibles que les champs d’un formulaire. Décidez qui peut téléverser, prévisualiser et télécharger les fichiers, et si l’accès aux fichiers hérite automatiquement de l’enregistrement parent (par ex. une facture) ou nécessite une permission supplémentaire.
Construisez deux vues d’un même ticket : une vue client sécurisée sans notes internes, tags ou métriques staff, et une vue interne avec le contexte complet. Affichez les champs sensibles du client seulement lorsque le workflow l’exige (par ex. l’adresse seulement pour « problème de livraison ») pour éviter qu’ils soient visibles sur chaque ticket.
Créez des comptes démo pour chaque rôle et effectuez des tâches réelles bout à bout, y compris les cas limites comme recherche, filtres, ouverture de pièces jointes et génération de documents. Testez aussi « Client A cherche Client B » avec noms, identifiants et URL pour confirmer que la portée est bien appliquée partout.


