Nos experts vous parlent
Le décodeur

Ce scénario est loin d’être rare, car beaucoup d’entreprises tombent dans le piège de mesurer la livraison plutôt que l’impact. Un projet est trop souvent déclaré “réussi” parce qu’il a été déployé, alors qu’il devrait l’être parce qu’il a changé la donne sur le terrain. 

Le problème : un logiciel n’a de valeur que si ses utilisateurs en tirent un bénéfice concret. Les tâches critiques sont-elles réalisées plus vite ? Les erreurs réduites ? Les nouvelles fonctionnalités sont-elles adoptées… ou déjà contournées ? 

S’il n’y a pas de réponses claires dans vos dashboards, c’est que vous n’avez pas posé les bons indicateurs. Vous ne mesurez rien - et ce que vous ne mesurez pas, vous ne l’améliorez pas. 

Piloter un logiciel, ce n’est pas compter les connexions. C’est mesurer son impact réel. On vous explique comment. 

1- Commencez par vous aligner sur la stratégie d’entreprise et les besoins métier

Créer un logiciel ne sert à rien s’il ne répond pas aux bonnes priorités. Avant même de parler roadmap, il faut se poser la vraie question : à quoi doit servir cet outil ?

D’où viennent les objectifs ? 

Tout part de la stratégie d’entreprise. Un logiciel métier n’est pas une brique isolée : il doit s’inscrire dans une vision plus large et répondre à des enjeux concrets.

Deux approches existent :

• Top-down → Les décideurs (DSI, direction produit, responsables métier) définissent les objectifs en fonction des grandes priorités stratégiques.
• Bottom-up → Les équipes terrain (utilisateurs finaux, opérationnels) font remonter leurs besoins réels pour s’assurer que le logiciel simplifie leur travail.

Dans la réalité, le bon équilibre est souvent un mix des deux. Un cadrage top-down donne la vision, une approche bottom-up garantit que l’outil sera réellement utilisé.

Le plus important : chaque objectif doit être actionnable et rattaché à un besoin concret. Une roadmap ne sert pas à livrer des fonctionnalités, mais à atteindre des résultats.

Pourquoi fixer des objectifs clairs ?

Un bon objectif donne une direction, motive les équipes et aligne tout le monde sur un même cap.

• Il fixe l’ambition : quelle transformation veut-on atteindre avec ce logiciel ?
• Il évite la dispersion : chaque nouvelle fonctionnalité doit servir un but précis.
• Il garantit l’autonomie : une équipe qui sait où elle va peut prendre les bonnes décisions.
• Il favorise la collaboration : un objectif clair permet à l’IT, aux métiers et à la direction de parler la même langue.

2 - Utilisez la méthode SMART pour construire vos objectifs

Un objectif ne doit pas juste être une intention vague du type “améliorer l’expérience utilisateur” ou “optimiser la gestion des stocks”. Il doit être SMART : 

Specific (Spécifique) → Un seul enjeu, clair et précis.Ex. Réduire de 30 % le temps de saisie des données par les commerciaux.

‍Measurable (Mesurable) → Basé sur des chiffres, pas des impressions.Ex. Augmenter de 20 % le taux d’adoption du module de reporting.

Achievable (Atteignable) → Ambitieux, mais réaliste compte tenu des contraintes techniques et organisationnelles. Un objectif irréalisable démotive plus qu’il ne motive.

Relevant (Pertinent) → En lien direct avec les besoins des utilisateurs et les priorités stratégiques.

Time-bound (Temporellement défini) → Avec une deadline claire pour évaluer l’impact.Ex. Objectif atteint en 6 mois.

Comment fixer des objectifs efficaces

Vos objectifs doivent s’inscrire dans un cycle produit : une période définie (de quelques semaines à plusieurs mois) durant laquelle l’équipe livre des évolutions ciblées et mesure leur impact. L’enjeu, c’est d’éviter les plans figés et d’itérer rapidement en fonction des retours terrain. Un objectif n’est donc pas gravé dans le marbre, il peut être recalibré.  

Trop d’objectifs tuent l’objectif. Pour être efficace, concentrez-vous sur 3 à 4 priorités par cycle produit. Inutile d’empiler les ambitions si elles sont ingérables en pratique.

Autre point clé : un objectif doit être un cap, pas une liste d’actions. Dire “déployer un module de reporting” n’a aucun sens si on ne sait pas pourquoi. En revanche, viser “80% des managers utilisent le module de reporting chaque semaine” donne une vision de l’impact recherché. 

En pratique : un objectif SMART appliqué 

❌ "Améliorer le reporting."

C’est vague et inutilisable. 

✅ "D’ici 6 mois, 90% des rapports doivent être générés automatiquement sans correction manuelle."

Ici, on fixe une échéance, un seuil de performance clair et on traduit un impact métier concret : réduire la charge de travail liée aux corrections manuelles et fiabiliser les données. 

‍

3 - Suivez l’impact dans le temps avec le framework OKR

L’approche OKR (Objectives and Key Results) est une méthode puissante pour piloter la performance d’un logiciel et s’assurer qu’il génère un impact réel.

Développée par Intel et popularisée par Google en 1999, elle repose sur un principe simple : 

1- Un objectif ambitieux et inspirant ;

2- Des résultats clés (Key Results) pour mesurer le succès.

L’intérêt ? Aligner les équipes techniques et métiers sur des objectifs concrets et mesurables, pour assurer que les évolutions du logiciel génèrent un impact tangible.

Dans une organisation bien structurée, chaque équipe décline les OKR globaux de l’entreprise en objectifs opérationnels adaptés à son périmètre.

Prenons un exemple :

OKR Produit

KR 1 : Réduire de 40 % le délai moyen de traitement des tickets d’intervention.

KR 2 : Augmenter de 25 % l’utilisation du module de planification automatique.

KR 3 : Diminuer de 30 % le taux de reprogrammation des interventions.

‍

OKR Dév

KR 1 : Réduire le temps de chargement du module de planification de 2s à 500ms.

KR 2 : Automatiser 90% des tests de facturation en intégrant des tests unitaires et des tests d’intégration dans la CI/CD.

KR 3 : Diminuer le taux de bugs critiques sur la planification à < 1 %.

Pour aller plus loin, voyons comment les OKR se déclinent à partir de la vision et de la stratégie d’entreprise : 

‍

‍

Comment piloter ses OKR avec précision

La première règle : un Key Result doit être quantifiable.

Évitez les formulations vagues qui ne disent rien sur l’impact recherché, comme "Améliorer la planification". Privilégiez "Augmenter de 25 % l’usage du module de planification en 3 mois", qui suit une évolution concrète.

Ensuite, restez focus. Multiplier les métriques dilue l’attention et brouille les priorités. Un objectif = 3 à 4 Key Results maximum. 

Enfin, un bon OKR évolue avec le produit. Ne vous accrochez pas coûte que coûte à un objectif : revoyez-le régulièrement pour qu’il reste pertinent par rapport aux usages réels. 

4 - Fixez des KPIs utiles, pas des chiffres vides de sens 

Un bon logiciel n’a de valeur que si son impact est mesurable. Se baser sur le nombre d’utilisateurs ou le taux de connexion ? Inutile. Ces chiffres ne disent rien sur l’efficacité réelle du produit.

Ce qu’il faut suivre, c’est ce que le logiciel change concrètement.

Vous pouvez valoriser trois catégories de KPIS : 

• Impact → Effet direct sur le métier : gain de productivité, réduction des erreurs, accélération des processus. (Ex. réduction de 30 % du temps de traitement des demandes clients)
• Ship → Livraison des fonctionnalités clés et leur déploiement. (Ex. adoption du nouveau module de reporting à 80 % en 3 mois)
• Learn → Ce que l’équipe apprend grâce aux retours utilisateurs et aux usages réels. (Ex. 50 % des utilisateurs déclarent que la nouvelle interface réduit leurs efforts de saisie)

‍

Un KPI doit toujours avoir une cible à atteindre et une échéance claire. Sinon, impossible de savoir si l’objectif a été rempli ou s’il faut ajuster la trajectoire.

‍

Comment fixer des KPIs pertinents

Un KPI isolé n’a aucune valeur. Il doit être directement rattaché à un objectif stratégique.

Associez systématiquement vos KPIs aux OKR, pour éviter de suivre des métriques sans impact réel.

Et surtout : ne vous fiez pas uniquement aux chiffres bruts. Analysez-les au fil de l’eau pour ajuster la roadmap et affiner votre stratégie produit en continu.

Exemple concret

❌ KPIs exclus par l’équipe Produit

Atteindre 10 000 nouveaux prospects ajoutés dans le CRM d’ici juin.

Atteindre un taux d’utilisation du module de scoring supérieur à 80%.

👉 On mesure une activité mais pas un impact. Un commercial peut ajouter 500 prospects sans que ça n’améliore les ventes. 

✅ KPIs de l’équipe Produit pour mesurer l’impact

Pour l’objectif "Améliorer l’efficacité commerciale en optimisant le ciblage des prospects", nous pouvons fixer, d’ici à juin :

• Impact → Augmenter le taux de conversion des prospects qualifiés de 15 % à 25 %.
• Ship → Déploiement du module d’analyse prédictive pour 100 % des commerciaux d’ici fin avril.
• Learn → 70 % des commerciaux déclarent que le nouveau scoring facilite leur priorisation des leads.

Ici, on ne mesure pas seulement l’adoption mais l’efficacité commerciale. 

5 - Ne tombez pas dans le piège des vanity metrics : misez sur des métriques actionnables

La différence entre une bonne et une mauvaise métrique ? Une métrique de vanité vous rassure mais ne vous apprend rien d’utile, tandis qu’une métrique actionnable vous alerte et vous guide sur ce qu’il faut optimiser.

Ce qui compte, ce n’est pas combien de personnes cliquent, mais comment elles utilisent réellement l’outil.

❌ Mauvais indicateurs : Nombre total d’inscrits, pages vues, sessions ouvertes...
Un logiciel peut afficher 50 000 connexions par mois sans que personne n’exploite vraiment ses fonctionnalités clés.

✅ Bons indicateurs : Taux d’utilisation des fonctionnalités critiques, temps gagné par utilisateur, réduction des erreurs, taux de satisfaction des utilisateurs métier…
Ex. « 80 % des utilisateurs complètent un rapport en moins de 10 minutes » prouve que le produit répond bien à son objectif.

6 - Suivez vos objectifs et ajustez en continu

Ce qui semblait prioritaire il y a six mois ne l’est peut-être plus aujourd’hui. Un KPI censé mesurer l’impact d’une fonctionnalité peut se révéler inadapté une fois sur le terrain. Bref, un objectif n’a de valeur que s’il est réévalué en continu.

Révisez chaque trimestre

Tous les trois mois, prenez le temps d’analyser vos KPIs :

• L’objectif fixé correspond-il encore aux enjeux métier ?
• Les résultats obtenus permettent-ils d’ajuster concrètement la roadmap ?
• Les métriques traduisent-elles une vraie amélioration pour les utilisateurs ?

Si un KPI ne guide pas vos décisions, il n’a rien à faire dans votre tableau de bord.

Adaptez les métriques aux usages réels

Le bon indicateur n’est pas figé : il s’affine, se précise et parfois se remplace. Un logiciel vivant s’adapte aux retours terrain :

• Les utilisateurs contournent une feature ? Le problème vient peut-être du process et pas de l’outil.
• Une métrique atteint son objectif mais l’expérience reste mauvaise ? Il faut revoir l’indicateur.
• Un nouveau besoin émerge ? Ajustez votre suivi pour rester aligné avec l’évolution du produit.

Intégrez des objectifs de responsabilité produit

Performance ne doit pas rimer avec court-termisme. Un produit bien conçu intègre des critères de responsabilité au même titre que ses objectifs business. RGPD, accessibilité, impact environnemental… ces sujets méritent des KPIs dédiés.

Par exemple : 

• Rendre 100 % des nouvelles fonctionnalités conformes aux normes WCAG.
• Réduire de 50 % le nombre d’incidents liés à la gestion des données personnelles.
• Maintenir un taux de satisfaction supérieur à 90 % sur les fonctionnalités critiques.

Rendez vos objectifs visibles et actionnables

Un objectif qui dort sur Notion ne sert à rien. Pour piloter efficacement, il doit être suivi, visible et actionnable. Sinon, il finira oublié et la roadmap se déconnectera des vrais enjeux.

Comment éviter ça ? En s’appuyant sur trois principes : 

1. Un tableau de bord visuel où l’équipe suit l’avancement des objectifs et repère immédiatement les écarts. Pas de KPIs décoratifs ici : il faut comprendre en un coup d'œil où on en est. 

2. Des rituels réguliers avec les parties prenantes : un point trimestriel pour ajuster les priorités, mais aussi des check-in plus fréquents pour capter les signaux faibles et affiner la roadmap en fonction du terrain. 

3. Une communication transparente : un objectif qui n’est pas partagé est un objectif mort-né. L’équipe doit savoir quels résultats sont atteints, ce qui fonctionne (ou pas) et pourquoi certaines priorités évoluent. 

Piloter un logiciel, c’est piloter l’impact

L’erreur la plus fréquente : se focaliser sur la livraison au lieu de l’impact. Un logiciel ne vaut rien s’il n’améliore pas concrètement un process métier. La vraie question n’est pas “est-ce que la fonctionnalité a été livrée ?” mais “a-t-elle changé quelque chose pour ses utilisateurs ?”

Les meilleures équipes produit ne suivent pas des KPIs figés. Elles ajustent en continu, éliminent les métriques inutiles et adaptent leurs objectifs aux apprentissages terrain. Un bon produit n’est pas celui qui respecte un cahier des charges, c’est celui qui prouve sa valeur.

Besoin d’un cadre clair pour fixer vos objectifs et piloter l’impact de votre logiciel métier ? Nous vous aidons à structurer votre stratégie produit, aligner vos KPIs et construire une roadmap actionnable. Discutons-en. 

‍

Vous avez déjà vu ça : un nouveau logiciel déployé avec enthousiasme, censé révolutionner un process interne… et six mois plus tard, les équipes continuent à bricoler sur Excel ou à contourner l’outil.

Le problème n’est pas le logiciel. C’est le process qu’il digitalise. S’il est bancal à la base, la technologie ne fera que figer ses défauts.

Alors, avant d’ajouter un énième outil au parc applicatif, posez-vous les bonnes questions :

• Vos équipes perdent-elles vraiment du temps à cause de l’outil, ou à cause du process ?
• Quelles étapes sont inutiles, répétitives ou contournées en douce ?
• Où sont les vrais blocages qui ralentissent la production ?

Sans ce diagnostic, vous risquez de digitaliser un problème… et non de le résoudre. Voyons comment éviter ce piège.

‍

‍

Votre logiciel sera-t-il adopté… ou contourné comme les précédents ?

Un logiciel mal cadré ne corrige pas un process bancal, il le fige.

Trop d’entreprises digitalisent à l’aveugle, pensant que l’outil suffira à améliorer le travail. Et les résultats sont souvent les mêmes :

• Un ERP qui impose 10 écrans pour une tâche simple.
• Une validation qui prend 3 jours au lieu de 3 clics.
• Des saisies répétées dans trois systèmes non connectés.

Conséquence ? L’adoption est catastrophique. Les équipes retournent sur Excel, emails et solutions maison, et l’IT se retrouve avec un logiciel fantôme de plus à maintenir.

👉 Décryptons les 5 principales raisons pour lesquelles ces projets échouent avant même leur lancement.

Raison n°1 : Le process que vous digitalisez est-il vraiment le bon ?

Les équipes vous disent : "Notre outil est obsolète, remplaçons-le."

Mais vous devez vous demander : "Pourquoi nos équipes perdent du temps ? D’où vient vraiment le blocage ?"

Trop souvent, on part du postulat que l’outil est le problème. Mais et si le problème venait du process lui-même ?

Exemples concrets :

• Un workflow avec trop d’étapes inutiles.
• Des validations bloquantes qui ralentissent tout.
• Une organisation du travail mal pensée, qui oblige les équipes à contourner le système.

👉 Avant de développer une nouvelle solution, posez-vous la question : l’outil actuel est-il vraiment dépassé, ou simplement mal utilisé ?

Raison n°2 : Vos équipes trouvent le process lourd… mais où sont les preuves ?

"On perd trop de temps.”

"C’est trop compliqué"

Vous avez sûrement entendu ces plaintes. Mais quelles sont les vraies données derrière ?

‍

Les bonnes questions à se poser :

• Combien de temps vos équipes passent-elles réellement sur chaque tâche ?
• Où sont les blocages qui freinent la production ?
• Quelle part du travail est contournée via Excel, emails ou solutions maison ?

👉 Sans ces réponses, impossible de prioriser les bons sujets. Et vous risquez de digitaliser un problème qui n’existe pas vraiment.

Raison n°3 : Faut-il tout refaire de zéro ou améliorer l’existant ?

La tentation est forte de repartir de zéro. Mais est-ce vraiment nécessaire ? 

Dans bien des cas, 90% des besoins sont déjà couverts par l’outil actuel. Le problème ? Il est mal exploité. 

Ergonomie bancale, manque d’intégration avec d’autres solutions, fonctionnalités sous-utilisées… Ce sont ces irritants qu’il faut traiter avant d’envisager un remplacement total.

📌 Le risque d’une refonte totale ?

• Un projet long, coûteux et risqué.
• Une transition brutale qui perturbe les équipes.
• Une nouvelle solution… qui sera contournée si elle ne corrige pas les vrais irritants.

👉 Posez-vous la question : L’outil est-il réellement dépassé, ou simplement mal exploité ?

Raison n°4 : Si vos équipes n’utilisent pas l’outil actuel, pourquoi adopteraient-elles le nouveau ?

Si vos équipes ont abandonné l’ancien outil, ce n’est pas juste une question d’interface ou de formation. C’est qu’il ne leur facilitait pas la vie. 

Trop rigide, trop éloigné des contraintes terrain, trop de clics pour une simple action… Résultat ? Elles ont trouvé mieux ailleurs : Excel, WhatsApp, emails.

Deux approches s’opposent : 

❌ Croire qu’un outil avec une nouvelle UI fera la différence.

✅ Comprendre pourquoi l’ancien a été contourné et intégrer ces contraintes dans la nouvelle solution.

👉 Un bon logiciel n’est pas celui qui a le plus de fonctionnalités. C’est celui que vos équipes veulent utiliser.

Raison n°5 : Chaque service a une vision différente du problème : comment aligner tout le monde ?

Dans un projet de digitalisation, chaque équipe tire dans sa direction :

• L’IT veut une architecture scalable et sécurisée.
• Les métiers veulent un outil simple et rapide à utiliser.
• La finance veut limiter les coûts et éviter un projet trop ambitieux.

Si chacun défend sa vision sans un cadre clair, le projet devient un compromis mou qui ne satisfait personne et qui finira par être abandonné. 

👉 Seule une cartographie précise des workflows peut aligner IT, Métiers et Finance pour s’assurer que l’investissement répond à un vrai besoin business.

3 étapes pour analyser le travail de vos équipes

Vous avez identifié un problème. Mais êtes-vous sûr d’avoir bien cerné l’enjeu ? Trop souvent, la digitalisation est vue comme une réponse miracle, alors qu’elle ne fait que reproduire – voire amplifier – les dysfonctionnements existants.

Un projet bien cadré commence toujours par une phase d’analyse fine. Comment vos équipes travaillent-elles réellement ? Quels sont les blocages concrets ? Où sont les pertes de temps, les frustrations, les inefficacités ?

Avant d’envisager une solution, posez un diagnostic précis. On vous donne la méthode step by step. 

‍

‍

Étape n°1 : aligner IT, Métiers et Finance avant de lancer le projet

Ne tombez pas dans le piège d’identifier un point de friction et de chercher immédiatement un nouvel outil, sans interroger la structure même du process.

Identifier les parties prenantes et leurs enjeux

Dans un projet de digitalisation, trois groupes d’acteurs ont généralement des attentes différentes :

• Les opérationnels : ce sont eux qui appliquent le process sur le terrain. Leur priorité ? Travailler efficacement sans contraintes inutiles.
• Les responsables métiers : ils supervisent l’activité et sont garants de la qualité et de la performance. Ils cherchent à standardiser les pratiques et à éviter les pertes de temps.
• La DSI et le support IT : ils doivent garantir la compatibilité des outils et leur sécurité. Leur objectif : une solution stable, évolutive et intégrée au SI existant.
• La finance et la direction : elles veillent au budget et au ROI. Leur enjeu ? Éviter un projet trop ambitieux qui explose les coûts, mais aussi un sous-investissement qui génère des dépenses cachées.

Si vous concevez une solution sans inclure ces trois groupes, vous risquez un projet en décalage avec la réalité. Une solution pensée uniquement par l’IT sera perçue comme un carcan par les métiers. Et une solution métier sans cadrage IT créera une dette technique difficile à gérer.

Comprendre comment le travail est réellement effectué

Sur le papier, un process semble clair. Mais dans la pratique, les équipes terrain l’adaptent constamment pour contourner ses défauts. 

Pour analyser un process, il ne suffit pas d’interroger les managers. Il faut aller voir sur le terrain. Plusieurs méthodes :

• Observation terrain (shadowing) : suivez les équipes en situation réelle pour voir où se situent les blocages.
• Interviews des opérationnels : appréhendez leurs contraintes et leurs habitudes de travail.
• Audit des outils utilisés : identifiez les écarts entre les usages prévus et les usages réels.

Étape n°2 : identifier les vrais irritants (et pas juste les symptômes visibles)

Un workflow peut sembler logique sur le papier, mais être un enfer pour ceux qui l’utilisent. Avant d’apporter une solution, il faut comprendre ce qui coince concrètement.

Comprendre où se situe la perte de temps

On entend souvent : "Le logiciel est lent", "On perd trop de temps sur cette tâche"... Mais ces constats vagues n’aident pas à agir. Il faut aller plus loin :

• Quelles étapes du workflow prennent anormalement du temps ?
• Où les équipes créent-elles des solutions alternatives pour contourner les blocages ?
• À quel moment les outils deviennent-ils un frein plutôt qu’un soutien ?

Un bon indicateur : si les équipes utilisent Excel, des emails ou WhatsApp en parallèle de l’outil officiel, c’est qu’un problème structurel existe. Le but est de repérer ces détours et comprendre pourquoi ils sont jugés plus efficaces que le système en place.

Aller sur le terrain pour identifier les irritants

Les problèmes les plus critiques ne se trouvent pas dans un fichier de specs ou une analyse théorique. Ils apparaissent dans l’usage quotidien. Pour les identifier, il faut consulter ceux qui vivent ces process :

• Les responsables métiers, qui ont une vision globale et peuvent détecter les goulets d’étranglement.
• Les utilisateurs, qui subissent les lenteurs, les doublons et les contraintes inutiles.
• Le support IT, qui voit remonter les plaintes récurrentes et repère les problèmes techniques à l’origine de certains blocages.

Objectiver les irritants pour mieux prioriser

Une fois ces problèmes identifiés, il faut mesurer leur impact. Sans chiffres, impossible de prioriser les bons sujets. Plusieurs méthodes permettent d’objectiver ces irritants :

• Ateliers de friction : regroupez plusieurs équipes et cartographiez ensemble les irritants concrets qu’elles rencontrent.
• Analyse des tickets support : repérez les plaintes récurrentes pour identifier les dysfonctionnements les plus fréquents.
• Observations terrain : suivez les utilisateurs dans leur quotidien pour détecter les contournements et blocages réels.

L’idée n’est pas de tout optimiser, mais d’éliminer les ralentisseurs inutiles. 

Étape n°3 : cartographier les usages réels (et pas ceux sur le papier)

Sans cartographie précise des workflows, impossible de comprendre où se perdent les infos, où les équipes contournent le système et pourquoi. 

Alors, comment travaillent réellement vos équipes ?

Démêler les vraies étapes du process

Un workflow ne suit jamais la ligne droite imaginée dans un cahier des charges. Dans la vraie vie, des raccourcis sont pris, des étapes sont sautées, des solutions alternatives émergent. 

Un exemple classique : une demande de validation qui, sur le papier, passe par un outil dédié. Sauf que dans la réalité, un coup de fil ou un message WhatsApp accélèrent la procédure. Le problème ? L’information n’est ni tracée, ni structurée.

Comment cartographier le process réel ?

• Observation terrain (shadowing) : passez une journée avec les équipes et regardez comment elles exécutent réellement le process.
• Entretiens avec les métiers : demandez-leur où ils perdent du temps, quelles étapes ils contournent et pourquoi.
• Audit des outils utilisés : vérifiez où l’information transite, si elle est dupliquée et comment elle est saisie. Un ERP peut être utilisé comme simple base documentaire au lieu d’être un véritable outil métier.

Comprendre comment circulent les informations

Quand les équipes passent leur temps à jongler entre plusieurs logiciels, à recopier des informations d’un tableau Excel à un CRM ou à refaire trois fois la même saisie, ce n’est pas un manque de formation, c’est un signal d’alerte.

Ce sont ces points de friction qu’il faut repérer avant de digitaliser. Où les infos sont ressaisies inutilement ? Où les échanges passent en "off" pour gagner du temps ? Où les outils ralentissent le travail au lieu de le fluidifier ?

Comment analyser la circulation des informations ?

• Cartographie des flux IT : analysez comment les outils interagissent entre eux et identifiez les doublons.
• Tracking des tâches : mesurez le temps passé à chaque étape pour repérer les goulets d’étranglement.
• Analyse des logs et des tickets IT : repérez les plaintes récurrentes et les points de friction les plus signalés.

Repérer les blocages invisibles

Un workflow ne bloque pas toujours là où on l’attend. Parfois, un simple mail en attente d’une réponse devient le goulet d’étranglement de toute une chaîne de production.

C’est souvent là que le temps se perd : des étapes de validation trop longues, des transferts d’infos non automatisés, des doublons… 

Comment identifier ces blocages ?

• Diagramme BPMN : formalisez les flux et visualisez les étapes superflues ou redondantes.
• Validation métiers : présentez la cartographie aux équipes terrain et ajustez selon leurs retours.
• Tests de simulation : expérimentez différents scénarios pour voir où le workflow coince réellement.

Étude de cas : pourquoi un logiciel métier peut échouer si les usages sont mal compris (et comment l’éviter)

Un acteur majeur du BTP déploie un nouvel outil pour structurer ses rapports de contrôle sur chantier. Ses objectifs : gagner en traçabilité, accélérer la transmission des données, sécuriser la conformité réglementaire.

Sur le papier, le logiciel devait standardiser les rapports. En réalité, il a ajouté de la complexité et personne ne l’a adopté.

On a mené un travail de fond pour comprendre où le projet avait déraillé et comment reconstruire un process digital réellement adapté aux usages terrain.

Comprendre le vrai problème 

Dès l’observation terrain, une évidence : un manque total de cadre pour standardiser les documents. Le problème ne vient pas du logiciel, mais d’un process inexistant. 

Chaque consultant perdait en moyenne 1h/jour à structurer ses rapports à sa façon. Word, Excel, modèles hérités… aucun standard, aucune homogénéité. L’outil officiel ? Utilisé uniquement pour générer un PDF final. Et encore, quand il n’était pas oublié. Les champs obligatoires ? Parfois ignorés, faute de règles claires. 

Identifier les irritants

L’outil en place était censé structurer et fluidifier la gestion des rapports. En réalité, il imposait aux consultants un formalisme rigide, une navigation lourde et trop de saisies inutiles. Au lieu d’aider, il freinait.

Les irritants majeurs qu’on a identifiés : 

• Un temps de saisie trop long : jusqu’à 1h pour rédiger un rapport, entre prise de notes sur site et mise en page.
• Trop d’étapes inutiles : chaque champ était obligatoire, même ceux non pertinents selon la mission.
• Une ergonomie inadaptée au terrain : trop de clics, une interface pensée pour le bureau, pas pour le mobile.

Cartographier le flux de travail réel

En cartographiant tout le cycle de rédaction des rapports, une faille majeure est apparue : il n’y avait aucune distinction entre les différents types de contrôles réalisés par les consultants (conception vs exécution). 

Le logiciel imposait un format unique pour toutes les missions, sans tenir compte des spécificités de ces deux phases. Conséquences : 

• Un process rigide qui ne reflétait pas les méthodes de travail terrain.
• Des contournements systématiques pour s’adapter aux spécificités de chaque chantier.
• Une traçabilité compromise avec des rapports dispersés et non standardisés.

Il fallait revoir la logique de travail en profondeur : adapter les modèles de rapports aux différents types de contrôle et, surtout, simplifier la saisie pour que les consultants passent moins de temps sur la forme.

"Avant, on développait trop vite et on se retrouvait avec un outil inutilisé. En prenant le temps d’analyser les vrais irritants, on a évité de refaire les mêmes erreurs. Cette approche a aligné IT, consultants et direction technique, ce qui a facilité l’adoption et sécurisé la conformité des rapports."

La leçon : un logiciel n’est qu’un outil, le vrai enjeu c’est l’usage

L’erreur aurait été de croire qu’un nouveau logiciel allait résoudre un problème d’organisation. On aurait pu repartir sur une refonte technique, avec une interface plus fluide, des fonctionnalités enrichies… mais en laissant intactes les vraies causes du dysfonctionnement.

Le constat était simple : le logiciel précédent avait été conçu pour répondre aux attentes de la direction, pas aux besoins du terrain. Résultat ? Un outil contourné, des process éclatés et une perte de traçabilité.

Le levier d’optimisation ne se trouvait pas dans la technologie, mais dans une refonte des usages : distinguer les types de contrôle, simplifier la saisie, intégrer les contraintes des consultants. 

Vous voulez éviter l’échec d’adoption lors du développement de votre logiciel ? On peut vous à cartographier vos process, identifier les vrais irritants et construire une solution pensée pour être utilisée – pas contournée.

Parlons-en. 

‍

Expose est un outil dont le but est d’exposer des services locaux vers l’extérieur. Il a été développé en PHP par Beyond Code.

Contrairement à ngrok, Expose est une solution OpenSource qui peut être auto-hébergée.

On a donc davantage de contrôle côté serveur et sur le trafic.

Dans quel cas pouvons-nous utiliser Expose ?

Il peut par exemple servir de :

• Debug lors du développement d’une application mobile
  ‍En effet, lorsque l’on développe une application mobile on souhaite parfois tester un build de notre application sur les stores.
  Notre application n’ayant pas accès à notre API locale, on doit pouvoir ouvrir un accès pour pouvoir tester nos features, notamment sur un build de staging si nous n’avons pas encore d’environnement adéquat en early.

• Faciliter la mise en place de webhook
  Qui n’a pas déjà implémenté un service bancaire ?
  On peut parfois avoir besoin de créer un webhook accessible depuis le service bancaire pour avoir les codes retours suite à un test de paiement et mettre à jour nos commandes de test.Et pour un système d’authentification avec Facebook ou Google ?Il est possible de paramètrer une URL de Callback en y mettant l’URL Expose afin de tester l’authentification.
  
  Et pour un système d’authentification avec Facebook ou Google ?
  Il est possible de paramètrer une URL de Callback en y mettant l’URL Expose afin de tester l’authentification.

• Ou tout simplement exposer un projet en cours de développement.
  Pour le montrer à un client lors d’une démo, et afin qu’il puisse tester un POC très rapidement.

Installation

Expose s’installe assez facilement, il suffit d’un serveur qui supporte PHP 7.2 avec composer

composer global require beyondcode/expose

En s’assurant que le dossier bon de composer est bien dans le PATH (vous pouvez ajouter cette ligne à la fin du .bashrc selon l’endroit où se trouve vos fichiers composer).

composer global require beyondcode/expose

On peut aussi l’installer directement via l’exécutable :

curl https://github.com/beyondcode/expose/raw/master/builds/expose -L --output expose
chmod +x expose
./expose

Utilisation

En utilisant le serveur d’expose

Tout d’abord créer un compte sur https://expose.dev.

On obtient ensuite un token que l’on doit activer :

expose token <montoken>

Vous pouvez ensuite démarrer un tunnel sur le port souhaité avec la commande :

expose share http://monsite.test

Expose génère une URL publique accessible via l’extérieur.

Vous avez également accès à un dashboard pour visualiser les requêtes HTTP http://127.0.0.1:4040

Pour le moment l’utilisation reste la même que pour ngrok, tirons tous les avantages d’expose en auto-hébergeant la solution.

Mise en place de l’auto-hébergement

Prérequis :

• PHP 8.1
• extension sqlite3
• installer expose comme précédemment (celui-ci installe le client et le serveur)

Pour lancer le serveur expose, rien de plus simple, cela se fait en une seule commande :

expose serve monnomdedomaine.fr

Dans notre exemple sur mon serveur j’exécute la commande :

expose serve dtang.fr --port=3000

L’argument port permet de spécifier un port différent du port 8080 (défaut).

N’oubliez pas d’ouvrir le port en TCP sur le serveur.

J’ai maintenant un tunnel Expose opérationnel !

Il faut maintenant configurer notre client expose sur notre machine pour qu’il passe par notre serveur.

Pour cela il faut modifier le fichier ~/.expose/config.php et y ajouter notre serveur

‍

Vous pouvez également modifier d’autres paramètres dans ce fichier, n’hésitez pas à vous référer à la documentation officielle https://expose.dev/docs/server/starting-the-server

Relancez la commande sur votre machine :

expose share http://monsite.test

Voilà, vous exposez à présent votre site local à travers votre serveur !

Avantages par rapport à ngrok

Lorsque l’on utilise ngrok, on peut rapidement être embêté par le fait de ne pas utiliser d’url custom, ce qui force dans certains cas spécifique à redéployer une version de notre application pour utiliser la bonne url, d’autant plus qu’il y a un temps limité à l’utilisation d’une url avec ngrok.

En auto-hébergeant sa propre instance d’Expose on élimine toutes les limites qui nous auraient été imposées :

• Nombre de requêtes (20000 par mois)
• Limite de requêtes par minute (4000 par minutes)
• Limitation du maximum de données (1Go sur la version gratuite de ngrok)

Pricingngrok propose trois versions :

• personal : 8$/dev/mois, ce qui revient à 96$ annuel
• pro : 20$/dev/mois, ce qui revient à 240$ annuel
• enterprise : 39$/dev/mois, ce qui revient à 468$ annuel

Tandis qu’Expose propose (prix annuels) :

• pro : 59$/dev/an
• business : 499$/dev/an
• Enterprise : sur mesure

Il faudra donc bien choisir son offre par rapport à nos besoins, si nos besoins restent basiques, la version personal d’ngrok fera très bien l’affaire.ConclusionExpose constitue une bonne alternative Open Source à ngrok, ce qui permet de ne pas dépendre d’un seul acteur et de confronter deux solutions par rapport à nos besoins.Il permet un contrôle total grâce à son auto-hébergement, sans les limitations imposées par ngrok (requêtes, débit de données, etc.). Les coûts annuels d’Expose sont également plus compétitifs, bien que la version basique de ngrok puisse suffire pour des besoins limités.Aller plus loin avec ExposeNous avons vu comment mettre une instance auto-hébergeable d’Expose, celui-ci permet également d’aller plus loin avec sa gestion d’utilisateurs pour l’authentification, la gestion de domaines, de sites partagés ainsi qu’une interface pour faciliter l’administration.

DSI vs Digital Factory : quelle organisation choisir pour accélérer l’innovation ?

Depuis des années, les DSI sont le moteur technologique des entreprises. Infrastructure, cybersécurité, ERP, CRM… tout passe par elles. Mais face à l’accélération du numérique, ce modèle atteint ses limites : les DSI sont engorgées, les délais explosent, et les métiers cherchent des alternatives pour innover plus vite.

C’est là qu’interviennent les Digital Factories. Ces structures agiles, centrées sur le produit, permettent de contourner les lenteurs des processus traditionnels. Mais faut-il vraiment opposer DSI et Digital Factory ? Ne sont-elles pas complémentaires ?

👉 Dans cet article, on analyse les forces et limites des deux modèles et on vous aide à choisir la bonne organisation pour maximiser votre impact digital.

Pourquoi les DSI peinent à suivre le rythme de l’innovation ?

Historiquement, la DSI est la garante de la stabilité du système d’information. Son rôle principal est de maintenir un SI sécurisé, fiable et performant. Mais face à l’explosion des besoins numériques, ce modèle montre ses limites :

1. Des cycles de développement trop longs

Les méthodes traditionnelles de gestion de projet (cycle en V, waterfall) imposent des délais importants. Résultat ? Il faut parfois plusieurs mois, voire des années, pour livrer une application qui, entre-temps, peut être devenue obsolète.

2. Une dette technique qui freine les évolutions

Beaucoup d’entreprises fonctionnent encore avec des systèmes legacy complexes et coûteux à faire évoluer. Chaque nouvelle application doit s’intégrer avec un SI vieillissant, ce qui ralentit considérablement les déploiements.

3. Une surcharge de demandes

Les DSI doivent gérer une avalanche de projets internes : maintenance du SI, cybersécurité, conformité, support, gestion des infrastructures… Elles n’ont souvent pas la bande passante pour mener des initiatives d’innovation ambitieuses.

4. Une difficulté à recruter et fidéliser les talents

Les profils tech les plus recherchés (développeurs, architectes cloud, experts IA) préfèrent souvent travailler dans des startups ou des structures agiles où ils peuvent coder et livrer rapidement. Dans une DSI traditionnelle, ils risquent d’être freinés par des process trop lourds.

👉 Conséquence : les métiers contournent de plus en plus les DSI en adoptant des solutions SaaS en autonomie (Shadow IT) ou en externalisant leurs projets.

Digital Factory : une alternative plus agile ?

Face à ces limites, de nombreuses entreprises créent leur propre Digital Factory : une entité autonome dédiée à l’innovation digitale. Son objectif ? Produire rapidement des applications et services digitaux à forte valeur ajoutée.

1. Un fonctionnement en mode startup

Contrairement aux DSI, les Digital Factories adoptent un mode produit, avec des équipes pluridisciplinaires capables de livrer rapidement des solutions complètes. Elles travaillent souvent en sprints courts et utilisent des méthodes agiles comme Scrum ou Kanban.

2. Une autonomie technologique

Exit les contraintes des SI historiques : une Digital Factory choisit ses propres outils et technologies (cloud-first, API-first, microservices…). Elle peut ainsi développer et déployer beaucoup plus vite.

3. Un alignement fort avec les métiers

Les équipes produit collaborent directement avec les métiers pour co-construire des solutions adaptées. Pas de cahier des charges rigide, mais un travail en continu avec les utilisateurs finaux pour garantir l’adoption des outils développés.

4. Une culture de l’expérimentation et de l’impact

L’objectif d’une Digital Factory n’est pas de multiplier les POCs, mais de livrer des produits digitaux concrets, utilisés en production. Elle fonctionne avec des KPIs business clairs (adoption, chiffre d’affaires généré, gain de productivité…).

👉 Résultat : alors qu’une DSI peut mettre 18 mois à sortir une application, une Digital Factory peut livrer une première version exploitable en quelques semaines.

DSI vs Digital Factory : opposition ou complémentarité ?

Plutôt que d’opposer ces deux modèles, il est plus pertinent de les faire travailler ensemble. Voici comment bien structurer leur relation :

1. La DSI pose le cadre, la Digital Factory exécute

• La DSI assure la sécurité, la conformité et la scalabilité des solutions développées.
• La Digital Factory expérimente, teste, et livre rapidement des produits digitaux.
• Un dialogue doit être mis en place pour éviter que la Digital Factory ne crée des solutions non intégrables au SI.

2. Un modèle bimodal : stabilité vs innovation

Certaines entreprises adoptent un modèle bimodal :

• Mode 1 (DSI) : Focus sur la fiabilité, la maintenance et l’optimisation du SI existant.
• Mode 2 (Digital Factory) : Axé sur l’innovation, l’agilité et le développement de nouvelles applications.

👉 Ce modèle permet d’accélérer les développements tout en garantissant la robustesse du SI.

3. Une Digital Factory intégrée à la gouvernance IT

• La Digital Factory ne doit pas être un électron libre.
• Elle doit être sponsorisée par la DSI et la direction générale.
• Il faut mettre en place des standards pour assurer une interopérabilité des solutions développées.

4. Une montée en compétences des équipes DSI

• La Digital Factory ne doit pas remplacer la DSI, mais l’aider à évoluer.
• Les DSI peuvent adopter progressivement des méthodes agiles et une approche produit.
• Une montée en compétences sur le cloud, l’IA et l’API-first est essentielle.

Comment choisir la bonne organisation ?

Le choix entre une DSI classique et une Digital Factory dépend de plusieurs facteurs :

✅ Si votre entreprise doit moderniser un SI vieillissant et sécurisé → La DSI reste le bon choix.

✅ Si vous devez lancer rapidement des services numériques innovants → Une Digital Factory est indispensable.

✅ Si vous souhaitez concilier stabilité et innovation → Le modèle bimodal (DSI + Digital Factory) est la meilleure option.

👉 En réalité, la plupart des grandes entreprises ont besoin des deux !

Conclusion : ne pas choisir, mais combiner intelligemment

Les Digital Factories ne remplacent pas les DSI. Elles sont là pour accélérer l’innovation, tout en s’appuyant sur les fondations solides de l’IT corporate. Pour garantir leur succès, elles doivent être intégrées à la gouvernance IT, alignées avec les enjeux business et fonctionner en synergie avec la DSI.

💬 Votre entreprise hésite entre ces modèles ? Discutons ensemble de la meilleure approche pour structurer votre transformation digitale.

‍

Un géant du retail investit 5 millions dans une Digital Factory flambant neuve. Trois ans plus tard ? 80 % des projets lancés n’ont jamais été adoptés. Résultat : un budget qui s’évapore, des équipes frustrées et un retour sur investissement quasi nul.

Ce scénario est loin d’être isolé. Pourtant, bien exécutée, une Digital Factory peut transformer une entreprise et accélérer sa transformation digitale. Alors pourquoi certaines cartonnent et d’autres s’enlisent ? Et surtout, comment éviter de faire partie des échecs ?

Dans cet article, on décortique les vraies raisons derrière l’explosion des Digital Factories et les clés pour en faire un levier stratégique efficace.

Pourquoi les Digital Factories se multiplient ?

Les entreprises ont un besoin urgent d’innover. Mais dans la plupart des grands groupes, les DSI sont saturées, les cycles de développement sont longs et la dette technique freine toute évolution. La solution ? Créer une structure plus agile et autonome, capable de livrer rapidement des produits digitaux sans être ralentie par les lourdeurs IT traditionnelles.

1. Répondre à la pression du marché

Les startups et scale-ups innovent à vitesse grand V. Pour rester compétitives, les grandes entreprises doivent accélérer leurs cycles d’innovation et livrer rapidement des solutions numériques à leurs clients et collaborateurs.

2. Débloquer l’innovation en interne

Les DSI sont souvent submergées par la gestion de l’existant : infrastructure, cybersécurité, support IT… Résultat, les projets d’innovation passent au second plan. La Digital Factory agit alors comme un accélérateur interne, dédié au développement de nouveaux produits digitaux.

3. Rapprocher IT et métiers

Les Digital Factories adoptent un mode produit, avec des équipes pluridisciplinaires : développeurs, designers, Product Managers et experts métiers. Objectif : aligner la technologie avec les besoins business et éviter les décalages entre les attentes des utilisateurs et les solutions développées.

Pourquoi tant de Digital Factories échouent ?

Malgré leur promesse, beaucoup de Digital Factories peinent à démontrer leur impact réel. Voici les 4 erreurs les plus fréquentes :

1. Un manque d’alignement avec la stratégie d’entreprise

Une Digital Factory qui fonctionne en vase clos, déconnectée des objectifs stratégiques, produit des solutions qui ne trouvent pas leur place dans l’organisation. Résultat ? Des POCs qui s’accumulent sans jamais être industrialisés.

👉 Assurez un sponsoring fort de la direction et un alignement avec les priorités business. Chaque projet doit répondre à un besoin clair et mesurable.

2. Une autonomie mal calibrée

Trop d’indépendance, et la Digital Factory devient une entité à part, difficile à intégrer dans l’écosystème existant. Trop peu, et elle se retrouve piégée par les lourdeurs organisationnelles qu’elle devait contourner.

👉 Trouver le bon équilibre entre autonomie et intégration, avec une gouvernance claire et des interactions régulières avec la DSI et les métiers.

3. Une approche trop tournée vers l’expérimentation

Si une Digital Factory ne produit que des prototypes sans impact concret, elle sera perçue comme un gadget coûteux.

👉 Passer d’une logique de POC à une logique de livraison continue, avec des indicateurs de succès clairs et un vrai travail d’industrialisation des solutions développées.

4. Une mauvaise gestion des talents

Attirer des profils tech de haut niveau est un défi. Si la Digital Factory n’offre pas un environnement stimulant et des projets concrets, les meilleurs éléments partiront rapidement.

👉 Investir dans une culture produit forte, avec une autonomie réelle, des méthodes de travail modernes (Lean, DevOps, Agile) et des technologies attractives.

Les 5 piliers d’une Digital Factory performante

1. Une mission claire et stratégique

Votre Digital Factory doit répondre à une question simple : quel problème résolvons-nous pour l’entreprise ? Chaque projet doit être évalué selon son impact business et utilisateur.

2. Un modèle d’équipe pluridisciplinaire

Les équipes doivent être autonomes et complètes :

• Product Manager pour piloter la vision et l’impact,
• Développeurs pour exécuter rapidement,
• UX/UI Designers pour garantir une expérience utilisateur fluide,
• Experts métiers pour assurer l’alignement avec les besoins business.

3. Une approche Lean et Agile

Exit les cycles longs et rigides. Une Digital Factory performante fonctionne en itérations courtes, avec des tests utilisateur fréquents et des ajustements continus.

4. Un cadre technologique moderne

Cloud-first, API-first, DevOps, CI/CD… Une Digital Factory ne peut pas fonctionner avec une stack obsolète. Elle doit pouvoir scaler facilement et s’intégrer sans friction avec le SI existant.

5. Un pilotage basé sur des KPIs d’impact

Pas juste du nombre de POCs réalisés. Les métriques doivent inclure :

• Adoption utilisateur,
• Réduction du time-to-market,
• Impact business généré (CA, réduction de coûts, gains de productivité).

Conclusion : une Digital Factory, oui, mais pas n’importe comment !

Les Digital Factories ne sont pas des gadgets. Bien conçues, elles peuvent transformer la façon dont une entreprise innove et accélérer sa transition vers le numérique. Mais sans un alignement clair, une gouvernance adaptée et une vraie culture produit, elles risquent de devenir un simple laboratoire d’expérimentation… sans impact.

‍

Si vous développez une application SaaS, un réseau social, une marketplace ou encore une application métier, il est fort probable que vous aillez besoin d’envoyer des e-mails ou des SMS transactionnels à vos utilisateurs.

Si vous vous demandez ce qu’est un message transactionnel, c’est un message automatisé qui fournit aux utilisateurs des informations utiles qui visent à l’aider et améliorer son expérience. Parmi les exemples les plus courants, on retrouve les confirmations de commande, les rappels de rendez-vous et l'authentification à deux facteurs.

‍

L’envoi d’e-mails et de SMS transactionnels avec Laravel est un jeu d’enfant, cette simplicité nous la devons au composant Notifications.

Laravel embarque le support de certains canaux : SMTP, Vonage et Slack. Les développeurs peuvent ensuite intégrer leurs propres canaux et les partager à la communauté sous forme de librairies.

C’est ce que nous avons fait chez Yield Studio en développant des packages pour Brevo, Mailjet et Expo !

Dans ce tutoriel, nous allons vous expliquer étape par étape comment envoyer des e-mails et des SMS transactionnels avec yieldstudio/laravel-brevo-notifier !

Étape 1 : Créer un compte Brevo

Pour commencer, vous devez vous créer un compte sur Brevo et vérifier votre adresse e-mail. Après ça vous pourrez vous rendre sur le tableau de bord.

Le plan Gratuit de Brevo vous permet d’envoyer jusqu’à 300 e-mails par jour, quant au SMS vous devrez charger votre compte avec des crédits SMS, à titre d’exemple le pack de 100 crédits SMS à destination de la France est facturé 4,5€.

Étape 2 : Installer Laravel Brevo Notifier

Après avoir créé votre compte Brevo, nous pouvons continuer l’installation.

composer require yieldstudio/laravel-brevo-notifier

Une fois l'installation terminée, nous pouvons éditer le fichier .env et ajouter les variables suivantes avec vos propres valeurs.

BREVO_KEY=your-brevo-key
BREVO_SMS_SENDER=Yield

# Laravel variables
MAIL_FROM_ADDRESS=hello@yieldstudio.fr
MAIL_FROM_NAME=Yield Studio

La valeur de BREVO_KEY peut être obtenue sur votre tableau de bord dans SMTP et API.

Quant à la valeur de BREVO_SMS_SENDER, elle est limitée à 11 caractères alphanumériques ou 15 caractères numériques. Il s’agit de l’expéditeur que verra votre utilisateur lors de l’envoi SMS (Yield, Amazon, IKEA)

Étape 3 : Authentifier vos expéditeurs

Avec Brevo comme avec de nombreux fournisseurs, les adresses e-mail qui servent à envoyer des e-mails doivent être une adresse authentifiée. Vous pouvez authentifier une adresse e-mail en particulier ou bien directement un nom de domaine.

Vous devez vous rendre dans Expéditeurs, domaines et IP dédiées et ajouter les adresses e-mails ou les domaines qui vous serviront à envoyer des e-mails.

Étape 4 : Générer la Notification

Vous devez ensuite créer une classe pour votre notification, vous pouvez utiliser la commande Artisan ci-dessous, par exemple nous créons une notification OrderShipped

php artisan make:notification OrderShipped

Cette commande génère la classe dans le dossier App\Notifications. Si ce dossier n’existe pas encore, Laravel le créera pour nous.

Étape 5 : Envoyer un e-mail et un SMS

Assurez ensuite vous de changer le retour de la méthode via pour y ajouter notre BrevoSmsChannel  et/ou BrevoEmailChannel

<?php

namespace App\Notifications;

use Illuminate\Notifications\Notification;
use YieldStudio\LaravelBrevoNotifier\BrevoSmsChannel;
use YieldStudio\LaravelBrevoNotifier\BrevoEmailChannel;

class OrderShipped extends Notification
{
    public function via(): array
    {
        return [BrevoSmsChannel::class, BrevoEmailChannel::class];
    } 
}

Vous pouvez ensuite préparer votre notification en ajoutant la méthode toBrevoSms et/ou toBrevoEmail :

<?php

namespace App\Notifications;

use Illuminate\Notifications\Notification;
use YieldStudio\LaravelBrevoNotifier\BrevoSmsMessage;
use YieldStudio\LaravelBrevoNotifier\BrevoEmailMessage;

class OrderShipped extends Notification
{
    public function __construct(private Order $order) {
    }

    // ...
    
    public function toBrevoSms($notifiable): BrevoSmsMessage
    {
        return (new BrevoSmsMessage())
            ->to($notifiable->phone)
            ->content('La commande n°' . $this->order->number . ' a été expédiée.');
    }

    public function toBrevoEmail($notifiable): BrevoEmailMessage
    {
        return (new BrevoEmailMessage())
            ->templateId(1)
            ->to($notifiable->firstname, $notifiable->email)
            ->params(['order_number' => $this->order->number]);
    }
}

Pour envoyer un e-mail transactionnel avec Brevo, vous devez créer des Templates.

Vous pouvez maintenant envoyer votre notification depuis votre controller, un listener ou l’endroit le plus approprié dans votre cas :

<?php

namespace App\Http\Controllers;

use App\Notifications\SendSMSMessageNotification;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

final class MarkOrderAsShipped extends Controller
{
    public function __invoke(Request $request, Order $order)
    {
        // ...
        $request->user->notify(new OrderShipped($order));
        // ...
    }
}

Et voilà vous avez envoyé votre première notification avec Brevo ⚡

Conclusion

Et voila, envoyer un e-mail ou un SMS transactionnel avec Brevo à partir d'une application Laravel c’est relativement simple. Créez d'abord un compte Brevo, installez la librairie yieldstudio/laravel-brevo-notifier, configurez et envoyez votre superbe notification.

Vous pouvez aller encore plus loin en ajoutant des destinataires en copie, des pièces jointes (une facture par exemple) et bien plus.

Sentez-vous libre de tester ce package et d’y contribuer sur Github.

‍

Introduction

‍

En tant que développeurs, nous savons que les projets évoluent constamment : les besoins changent, les designs se métamorphosent et les spécifications initiales peuvent rapidement devenir obsolètes.

Face à cet environnement mouvant, nos composants traditionnels montrent parfois leurs limites. Ils ne sont pas tous adaptés pour faire face de manière flexible et robuste à cette évolution constante.

Qui n'a jamais été frustré par un composant trop rigide pour s'accommoder d'un changement de maquette ou d'une mise à jour des exigences du projet ?

‍

Examinons ensemble, deux exemples, pour illustrer le Design Pattern : Compound Components.

‍

‍

‍

Exemple d’un composant d’UI simple ✏️

Supposons que nous devons créer un composant Card tout ce qu’il y a de plus classique. On a besoin d’affiche un title, une description et un thumbnail.

Voilà une implementation simple de ce que pourrait être ce composant :

// card.tsx

type CardProps = {
	title: string;
	description: string;
	thumbnail: string;
}

function Card({ title, description, thumbnail }: CardProps) {
	return (
		<View>
			<Image source={{ uri: thumbnail }} />
			<Text>{title}</Text>
			<Text>{description}</Text>
		</View>
	)
}

‍

Ainsi que son usage :

‍

// home.tsx

function HomeScreen() {
	return (
		<View>
			<Card
				title="Lorem ipsum"
				description="Quis enim aliqua ad et consectetur laboris reprehenderit ea anim occaecat adipisicing duis exercitation magna cupidatat."
				thumbnail="https://picsum.photos/200/300"
			/>
		</View>
	)
}

‍

Jusque là, tout va bien, notre composant est simple à développer, simple à utiliser et facile à relire.

‍

Maintenant, comme dans tous les projets, le besoin évolue et le design de nos composants avec. Admettons, que notre besoin a évolué de façon à ce qu’on ai besoin d’ajouter un bouton sur notre composant Card. Mais, ce bouton ne doit pas apparaître à tous les endroits de mon application.

‍

Ce que l’on va retrouver dans la plupart des projets professionnels aujourd’hui, c’est une surcharge de propriétés sur le composant. Le plus souvent, notre composant serait comme suit :

‍

// card.tsx

type CardProps = {
	title: string;
	description: string;
	thumbnail: string;
	buttonLabel?: string;
	showButton?: boolean;
	onPressButton?: () => void;
}

function Card({ 
	title, 
	description, 
	thumbnail,
	buttonLabel,
	showButton = false,
	onPressButton
}: CardProps) {
	return (
		<View>
			<Image source={{ uri: thumbnail }} />
			<Text>{title}</Text>
			<Text>{description}</Text>
			{showButton && <Button label={buttonLabel} onPress={onPressButton} />}
		</View>
	)
}

‍


NB : c’est volontairement exagéré pour mettre en avant le problème. Même sans Compound Components que l’on verra après, on pourra avoir un composant bien plus propre !

‍

Et l’usage du composant serait comme suit :

‍

// home.tsx

function HomeScreen() {
	return (
		<View>
			<Card
				title="Lorem ipsum"
				description="Quis enim aliqua ad et consectetur laboris reprehenderit ea anim occaecat adipisicing duis exercitation magna cupidatat."
				thumbnail="https://picsum.photos/200/300"
			/>
			<Card
				title="Lorem ipsum"
				description="Quis enim aliqua ad et consectetur laboris reprehenderit ea anim occaecat adipisicing duis exercitation magna cupidatat."
				thumbnail="https://picsum.photos/200/300"
				buttonLabel="Lorem"
				onPressButton={() => { /* ... */}}
				showButton
			/>
		</View>
	)
}

‍


Observations

Que peux-tu observer sur cet exemple de composant “traditionnel” qui ne représente que de l’UI ?

‍

1. Structure rigide
   ‍Le composant Card a une structure définie, il contient toujours une image, un titre, une description et un bouton. Il n’y a flexibilité pour changer la structure d’un composant en fonction des besoins.
   ‍
2. Passage de props
   ‍Toutes les données dont le composant Card a besoin sont passées via les props. Cela peut devenir encombrant et difficile à maintenir à mesure que nous ajoutons plus de props au composant.
   ‍
3. Moins de réutilisabilité
   ‍Les sous-composants ne peuvent pas être réutilisés indépendamment. Par exemple, si nous voulons utiliser seulement le bouton ou l'image de la carte dans un autre composant, cela ne serait pas possible.
   ‍
4. Peu extensible
   ‍Ajouter de nouvelles fonctionnalités à la carte nécessite une modification de l'implémentation de la carte elle-même, augmentant potentiellement le risque de créer des bugs non liés.
   ‍
5. Simplicité
   ‍Cependant, dans certains cas, cette approche peut être préférable pour sa simplicité. Si votre composant est très simple et n'a pas besoin des avantages offerts par le pattern de Compound Components, le surcoût en complexité peut ne pas en valoir la peine.

‍

‍

Exemple d’un composant plus complexe ✏️

Supposons maintenant que nous devons créer un composant plus complexe, des composants mêmes, qui ont besoin de travailler ensuite pour mettre en oeuvre une fonctionnalité de Todo-list.

‍

Pour cela, nous allons avoir les composants TodoList (pour afficher une liste d’item de todo), TodoItem (qui représente un item de todo), TodoForm (qui représente le formulaire d’un item de todo) et TodoStats (qui affiche des statistiques pour une liste de todo donnée).

‍

Voilà une implementation de ce que pourrait être ces composants :

‍

// todo-list.tsx

type TodoListProps = {
	todos: Array<{ id: string; content: string }>;
	onPressDelete: (id: string) => void;
}

function TodoList({ todos, onPressDelete }: TodoListProps) {
	return (
		<View>
			{todos.map((todo) => (
				<TodoItem 
					key={todo.id} 
					id={todo.id} 
					content={todo.content}
					onPressDelete={onPressDelete}
				/>
			)}
		</View>
	)
}

// todo-item.tsx

type TodoItemProps = {
	id: string;
	content: string;
	onPressDelete: (id: string) => void;
}

function TodoItem({ id, content onPressDelete }: TodoListItemProps) {
	return (
		<View>
			<Text>{content}</Text>
			<Button label="Delete" onPress={() => onPressDelete(id)} />
		</View>
	)
}

// todo-form.tsx

type TodoFormProps = {
	onPressSubmit: (content: string) => void;
}

function TodoForm({ onPressSubmit }: TodoFormProps) {
	const [value, setValue] = useState<string>('')
	
	return (
		<View>
			<TextInput value={value} onChangeText={setValue} />
			<Button label="Add" onPress={() => onPressSubmit(value)} />
		</View>
	)
}

// todo-stats.tsx

type TodoStatsProps = {
	todos: Array<{ id: string; content: string }>;
}

function TodoStats({ todos }: TodoStatsProps) {
	return (
		<View>
			<Text>Sum of todos: {todos.length}</Text>
			{/* average number of characters */}
			{/* ... */}
		</View>
	)
}

‍


Ainsi que l’usage de ces composants :

‍

// home.tsx

function HomeScreen() {
	const [todos, setTodos] = useState([])
	
	return (
		<View>
			<TodoList 
				todos={todos} 
				onPressDelete={(id) => 
					setTodos((state) => state.filter(todo) => todo.id !== id
				}
			/>
			<TodoStats todo={todos} />
			<TodoForm 
				onPressSubmit={(content) =>
					setTodos((state) => [...state.todos, { id: uuid(), content }])
				} 
			/>
		</View>
	)
}

‍


Observations

Que peux-tu observer sur cet exemple de composant “traditionnel” qui ne représente cette fois une fonctionnalité plus complexe ?

‍

1. Rigidité
   ‍Dans l'état actuel, la structure est assez rigide. Par exemple, si vous voulez une autre variante de TodoItem qui a un bouton pour marquer une tâche comme terminée, ou peut-être une variante de TodoForm qui a des champs supplémentaires, l'adaptation de ces composants à ces scénarios serait plus complexe.
   ‍
2. Passage de props
   ‍Les fonctions de suppression et d'ajout sont transmises en tant que props aux composants enfants TodoItem et TodoForm depuis le composant parent HomeScreen. Cela peut devenir compliqué à gérer à mesure que l'application s'agrandit, car chaque fois que vous voulez utiliser ces fonctions, vous devez les transmettre à travers tous les composants intermédiaires.
   ‍
3. Manque d’encapsulation
   ‍Les composants TodoItem et TodoForm exposent trop de détails d'implémentation. Par exemple, TodoItem a besoin de connaître non seulement le contenu de la tâche, mais aussi son id et comment traiter une action de suppression. De même, TodoForm doit gérer son propre état et savoir comment gérer une action de soumission. Cela pourrait être évité avec une version composée qui masquerait ces détails.
   ‍
4. Peu extensible et peu lisible
   ‍Ce point est suffisamment explicite je pense !

‍

‍

Le Design Pattern : Compound Components 👀

‍

Le Design Pattern : Compound Components s’applique à n’importe quel langage fonctionnant avec des composants et de la gestion d’états. Il s’agit d’une approche qui offre :

‍

1. Structure
   ‍Le terme "Compound Components" décrit une relation "a un" entre les composants. Un composant comporte plusieurs sous-composants qui travaillent ensemble pour former une unité cohérente. Le composant parent sert de composant de mise en page tandis que les sous-composants déterminent le contenu.
   ‍
2. Flexibilité
   ‍Les Compound Components offrent une grande flexibilité dans l'arrangement des sous-composants. Les utilisateurs de cette API de composant peuvent contrôler l'organisation, la structure et la présentation d'un composant.
   ‍
3. Abstraction
   ‍Ils permettent une bonne séparation des préoccupations car chaque sous-composant traite une fonctionnalité particulière. Cela permet une meilleure réutilisation des composants et simplifie le test et la maintenance.
   ‍
4. Pas de passage de props
   ‍Un avantage majeur du modèle de Compound Components est l'évitement du prop-drilling, qui est un problème où des props doivent être passés à travers de nombreux niveaux de composants. Les Compound Components résolvent ce problème en utilisant le contexte React pour partager la valeur entre les composants.
   ‍
5. Encapsulation
   ‍Avec les Compound Components, nous pouvons exposer ce qui est nécessaire et masquer les détails d'implémentation spécifiques. Cela aide à produire un code plus clair et plus facile à maintenir.

‍

Mise en pratique

‍

Maintenant, voyons ensemble un refactor de nos composants précédents en version Compound Components.

‍

‍

Le composant d’UI simple en Compound Components

Reprenons notre composant d’UI simple et convertissons les props title, description, etc. en sous-composants pour en faire une composition comme suit :

‍

// card.tsx

type CardProps = PropsWithChildren

function Card({ children }: CardProps) {
	return <View>{children}</View>
}

Card.Title = CardTitle
Card.Description = CardDescription
Card.Thumbnail = CardThumbnail
Card.Button = CardButton

// card-title.tsx

type CardTitleProps = {	title: string }

function CardTitle({ title }: CardTitleProps) {
	return <Text>{title}</Text>
}

// card-description.tsx

type CardDescriptionProps = {	description: string }

function CardDescription({ description }: CardDescriptionProps) {
	return <Text>{description}</Text>
}

// card-thumbnail.tsx

type CardThumbnailProps = {	source: string }

function Card({ source }: CardThumbnailProps) {
	return <Image source={{ uri: thumbnail }} />
}

// card-button.tsx

type CardButtonProps = {
	label: string;
	onPress: () => void;
}

function CardButton({ label, onPress }: CardButtonProps) {
	return <Button label={label} onPress={onPress} />
}

‍


Et maintenant l’usage :

‍

// home.tsx

function HomeScreen() {
	return (
		<View>
			<Card>
				<Card.Thumbnail source="https://picsum.photos/200/300" />
				<Card.Title title="Lorem ipsum" />
				<Card.Description 
					description="Quis enim aliqua ad et consectetur laboris reprehenderit ea anim occaecat adipisicing duis exercitation magna cupidatat."
				/>
			</Card>
			<Card>
				<Card.Thumbnail source="https://picsum.photos/200/300" />
				<Card.Title title="Lorem ipsum" />
				<Card.Description 
					description="Quis enim aliqua ad et consectetur laboris reprehenderit ea anim occaecat adipisicing duis exercitation magna cupidatat."
				/>
				<Card.Button label="Lorem" onPress={() => { /* ... */}} />
			</Card>
		</View>
	)
}

‍


Observations

Quelles observations peux-tu faire cette fois ci ?

‍

1. Flexibilité
   ‍Le Compound Components donne un plus grand contrôle sur l'organisation des éléments dans le rendu. Dans le deuxième exemple d'utilisation, nous avons de l'information supplémentaire et une absence de bouton, ce qui ne serait pas possible avec une version non composée du composant qui limiterait strictement la structure.
   ‍
2. Réutilisabilité
   ‍Les sous-composants, comme CardTitle, CardImage, et CardContent peuvent être réutilisés et réarrangés librement. Cette approche réduit la duplication du code et accroît la maintenabilité.
   ‍
3. Lisibilité
   ‍Le code est plus facile à comprendre. Alors qu'un composant non composé pourrait avoir un grand nombre de props, ce qui pourrait rendre le code plus difficile à suivre, chaque sous-composant sait clairement quel est son rôle dans le composant de carte.
   ‍
4. Isolation
   ‍Les sous-composants (comme CardButton ou CardImage) peuvent être mis à jour indépendamment des autres sous-composants, évitant ainsi les effets de bord inattendus.
   ‍
5. Scalabilité
   ‍Les nouveaux sous-composants peuvent être ajoutés facilement en suivant cette approche, permettant au composant de s'adapter et de se développer avec le temps. Par exemple, un sous-composant CardFooter pourrait être ajouté si besoin.

‍

Le composant complexe en Compound Components

Enfin, passons au plus intéressant, le groupe de composant qui représente la fonctionnalité de Todo-list, voilà la version Compound Components :

‍

// home.tsx

function HomeScreen() {
	return (
		<View>
			<Card>
				<Card.Thumbnail source="https://picsum.photos/200/300" />
				<Card.Title title="Lorem ipsum" />
				<Card.Description 
					description="Quis enim aliqua ad et consectetur laboris reprehenderit ea anim occaecat adipisicing duis exercitation magna cupidatat."
				/>
			</Card>
			<Card>
				<Card.Thumbnail source="https://picsum.photos/200/300" />
				<Card.Title title="Lorem ipsum" />
				<Card.Description 
					description="Quis enim aliqua ad et consectetur laboris reprehenderit ea anim occaecat adipisicing duis exercitation magna cupidatat."
				/>
				<Card.Button label="Lorem" onPress={() => { /* ... */}} />
			</Card>
		</View>
	)
}

‍

Ainsi que son usage, drastiquement simplifiée :

‍

// home.tsx

function HomeScreen() {
	return (
		<View>
			<Todos todos={[]}>
				<Todos.List />
				<Todos.Stats />
				<Todos.Form />
			</Todos>
		</View>
	)
}

‍


Observations

Que peux t-on observer sur cette dernière partie ?

‍

1. Flexibilité d’affichage
   ‍Avec l'approche de Compound Components, la disposition des composants est beaucoup plus flexible. Vous pouvez choisir de rendre Todos.List, Todos.Form, et Todos.Stats dans n'importe quel ordre ou même de ne pas les afficher en fonction des spécificités des spécifications ou des besoins de votre application.
   ‍
2. Utilisation du Contexte
   ‍Grâce à l'utilisation de React Context (TodosContext), vous pouvez facilement partager des données (todos) et des fonctions (add, remove) entre tous les composants enfants. Cela permet d'éviter le problème de prop-drilling propre à l'approche non compound components.
   ‍
3. Hook personnalisé
   ‍Ils utilisent un hook personnalisé useTodosContext pour obtenir les valeurs du contexte. Ce hook rend le code plus lisible et plus facile à utiliser.
   ‍
4. Réutilisabilité accrue
   ‍Les composants sont désormais plus indépendants et peuvent être facilement réutilisés ailleurs dans l'application. Par exemple, Todos.List pourra être utilisé dans un autre écran ou dans une sidebar sans avoir besoin de passer d'informations supplémentaires via les props.
   ‍
5. Extensibilité
   ‍Avec cette approche, vous pouvez également étendre facilement le composant Todos en ajoutant des sous-composants supplémentaires sans bouleverser l'architecture existante. Par exemple, si vous voulez ajouter une fonctionnalité pour marquer les tâches comme faites, vous pourriez créer un nouveau sous-composant Todos.Checkbox.

‍

Le mot de la fin 👋

‍

De manière générale, le composant “traditionnel” est plus simple, mais il offre moins de flexibilité et de potentiel de réutilisation que le Compound Components. Le choix entre les deux approches dépend des besoins spécifiques du projet. Mais de mon experience, partir direct sur du Compound Components est rarement une mauvaise idée !

‍

Les inconvénients potentiels de cette approche sont qu'elle est plus complexe et qu'elle nécessite une compréhension plus approfondie des concepts de React (pour le cas de React), tels que le Contexte et les Compound Components eux-mêmes. De plus, il est important de noter que bien que le Context puisse sembler être une solution à tous les problèmes, il doit être utilisé avec parcimonie pour éviter un couplage excessif entre les composants de votre application.

‍

L'adoption du pattern Compound Components dans la conception d'interfaces utilisateur peut sembler déroutante au début, mais les avantages qu'elle offre en termes de modularité, de flexibilité et de réutilisabilité sont indéniables. Ainsi, en décomposant intelligemment les composants en des sous-éléments logiques, nous pouvons produire des systèmes d'UI flexibles, réutilisables et gérables.

‍

Vous pouvez retrouvez cet article au format vidéo sur YouTube en suivant ce lien.

‍

Bienvenue dans notre guide complet sur la création et la publication d'applications sur le Google Play Store. Si vous vous demandez comment donner vie à votre application Android et la partager avec le monde, vous êtes au bon endroit. Dans cet article, nous allons vous expliquer étape par étape comment créer, préparer et publier votre application, en mettant l'accent sur l'optimisation pour maximiser sa visibilité.

Vous découvrirez comment créer un compte développeurs Google Play, préparer les éléments graphiques essentiels, développer votre application Android, rédiger une description convaincante, préparer des captures d'écran attrayantes, publier votre application, la tester en toute sécurité et suivre ses performances. Que vous soyez novice ou que vous ayez déjà une idée en tête, ce guide vous fournira les conseils, les astuces et les meilleures pratiques pour réussir dans l'univers du Google Play Store. Alors, prêt à plonger dans le monde passionnant de la création d'applications Android ?

‍

Suivez-nous pour tout savoir sur la réalisation de votre projet d'application mobile.

‍

#1 Créer un compte développeurs Google Play

La première étape cruciale pour publier une application sur le Google Play Store est de créer un compte développeurs Google Play. Suivez ces étapes pour démarrer :

1. Rendez-vous sur la plateforme Google Play Console pour les développeurs en utilisant votre compte Google existant ou en en créant un nouveau.
2. Pour pouvoir publier des applications sur le Google Play Store, vous devrez payer des frais d'inscription unique de $25 pour vous donner accès à la plateforme de publication à vie.
3. Une fois inscrit, remplissez les informations de votre compte développeurs. Assurez-vous de fournir une description complète et précise de votre entreprise ou de vous-même, car cela aidera les utilisateurs à vous identifier plus facilement.
4. Incluez une politique de confidentialité pour votre application si elle collecte des données personnelles. Google Play Store exige une politique de confidentialité claire pour toutes les applications.
5. Choisissez une langue par défaut pour votre compte développeurs. Cela déterminera la langue dans laquelle vos communications avec Google se feront.
6. Une fois toutes les informations fournies, terminez la configuration de votre compte développeurs Google Play. Vous êtes maintenant prêt à commencer à publier des applications sur la plateforme.

#2 Préparer les éléments graphiques

L'une des étapes cruciales pour publier une application réussie sur le Google Play Store consiste à préparer les éléments graphiques essentiels. Voici comment vous pouvez procéder :

Icône d'application

Créez une icône d'application attrayante qui représente votre application de manière mémorable. Cette icône sera la première chose que les utilisateurs verront. Assurez-vous que l'icône est claire, nette et conforme aux normes de qualité.‍

1. Taille recommandée : 512 x 512 pixels
2. Format : PNG avec un arrière-plan transparent
3. Taille maximale du fichier : 1024 Ko

Bannières promotionnelles

Préparez des bannières promotionnelles qui mettent en avant les fonctionnalités uniques de votre application. Utilisez ces bannières pour attirer l'attention des utilisateurs potentiels. Créez des images promotionnelles qui reflètent le style de votre application.‍

1. Taille recommandée : 1024 x 500 pixels
2. Format : PNG ou JPEG
3. Taille maximale du fichier : 1024 Ko

Vidéo de présentation

Si possible, créez une vidéo de présentation de votre application. Les vidéos peuvent donner aux utilisateurs un aperçu interactif de votre application et augmenter leur intérêt. Assurez-vous que la vidéo est informative, concise et professionnelle.

1. Dimensions : 16:9 (paysage)
2. Durée recommandée : 30 secondes à 2 minutes
3. Hébergement : YouTube (ajoutez le lien YouTube dans la console Google Play)

Logo de l'éditeur‍

Téléchargez un logo de l'éditeur, qui représente votre entreprise ou vous-même en tant que développeur. Veillez à ce que le logo soit net et qu'il reflète l'identité de votre marque.
‍

1. Taille recommandée : 512 x 512 pixels
2. Format : PNG avec un arrière-plan transparent
3. Taille maximale du fichier : 1024 Ko

Autres éléments graphiques

Envisagez d'inclure d'autres éléments graphiques tels que des images promotionnelles, des graphiques ou des illustrations qui peuvent améliorer l'attractivité de votre page d'application.

‍

En préparant soigneusement les éléments graphiques de votre application, vous augmentez vos chances d'attirer l'attention des utilisateurs sur le Google Play Store. Des éléments visuels bien conçus peuvent faire la différence pour inciter les utilisateurs à télécharger votre application.

Pour préparer les éléments graphiques et les captures d'écran pour votre application sur le Google Play Store, voici les tailles et déclinaisons spécifiques à respecter :

#3 Développer l'application pour Android

La création d'une application pour le Play Store commence par une étape cruciale : choisir les bons outils. React Native est une excellente option pour développer une application compatible avec Android et iOS. Voici les étapes essentielles à suivre avec React Native.

Tout d'abord, assurez-vous que votre ordinateur est équipé d'un système d'exploitation adapté au développement mobile, comme Windows, macOS, ou Linux. Installez Node.js, puis utilisez npm (Node Package Manager) pour installer l'interface de ligne de commande (CLI) de React Native.

Prenez le temps de vous familiariser avec les concepts de base de React Native, notamment le JavaScript ES6, les composants, les états, et les props, ainsi que le style des composants avec CSS ou des objets JavaScript.

Planifiez l'architecture et le design de votre application. Définissez ses fonctionnalités clés, son interface utilisateur, et sa navigation. Utilisez des outils de maquettage pour esquisser l'apparence de votre application avant de commencer à coder.

Pour coder votre application, ouvrez un terminal et créez un nouveau projet React Native en exécutant npx react-native init nom-de-votre-app. Ceci crée une structure de base pour votre application.

Intégrez les bonnes pratiques de développement pour assurer la performance et la stabilité de votre application. Testez-la régulièrement sur des simulateurs ou des appareils physiques.

Voici un exemple de code source basique qui affiche une page avec un texte de bienvenue :

Pour publier votre application, générez une version de production en suivant les instructions spécifiques à React Native pour Android. Assurez-vous que votre application respecte les directives du Google Play Store concernant le contenu, la publicité, la sécurité, et la confidentialité.

Préparez une description attrayante pour le Play Store, détaillant les fonctionnalités et les bénéfices de votre application. Effectuez des tests complets pour corriger les bugs et organisez des tests fermés avec des utilisateurs bêta pour recueillir des retours.

#4 Ajouter une description complète

Lorsque vous publiez une application sur le Google Play Store, l'ajout d'une description complète est une étape cruciale pour informer les utilisateurs potentiels sur le fonctionnement et l'utilité de votre application. Voici comment vous pouvez procéder :

• La première partie de votre description devrait être une introduction engageante qui capte l'attention des utilisateurs. Expliquez brièvement ce que fait votre application et ce qui la rend unique.
• Décrivez ensuite les principales fonctionnalités de votre application. Mettez en évidence ce qui la distingue des autres applications similaires sur le marché.
• Si votre application a des fonctionnalités complexes, offrez des instructions claires sur la manière de les utiliser. Les utilisateurs doivent comprendre rapidement comment tirer le meilleur parti de votre application.
• Expliquez en quoi votre application peut améliorer la vie des utilisateurs ou résoudre leurs problèmes. Mettez en avant les avantages et les gains qu'ils peuvent obtenir en l'utilisant.
• Si votre application a reçu des témoignages positifs ou des avis élogieux, n'hésitez pas à les inclure dans la description. Les avis d'autres utilisateurs peuvent renforcer la confiance des nouveaux utilisateurs.
• Mentionnez les spécifications techniques pertinentes, telles que les versions minimales d'Android prises en charge et les éventuelles exigences matérielles
• Concluez la description en invitant les utilisateurs à télécharger votre application. Utilisez un appel à l'action clair et incitatif.
• Relisez attentivement votre description pour éviter les fautes d'orthographe et les erreurs grammaticales. Une description bien rédigée donne une impression professionnelle.
• Si votre application cible un public mondial, envisagez de proposer des descriptions traduites dans plusieurs langues pour atteindre un public plus large.

En ajoutant une description complète et convaincante, vous maximisez vos chances de convaincre les utilisateurs potentiels de télécharger votre application depuis le Google Play Store. Une description informative et attrayante peut faire la différence dans la décision des utilisateurs de tester votre application.

#5 Préparer des captures d'écran

‍

Préparer des captures d'écran de qualité est essentiel pour présenter votre application de manière attrayante sur le Google Play Store. Voici comment vous pouvez procéder :

Prenez des captures d'écran de haute qualité qui mettent en valeur les fonctionnalités clés de votre application. Choisissez des moments pertinents qui montrent à quoi ressemble l'utilisation de votre application. Assurez-vous que les captures d'écran sont nettes, bien cadrées et sans distorsion. Évitez les images floues ou pixellisées.

Le Google Play Store recommande des tailles spécifiques pour les captures d'écran. Assurez-vous de les respecter pour une présentation optimale sur différentes tailles d'écran d'appareils Android. Il est généralement conseillé de fournir des captures d'écran pour les formats de téléphone et de tablette.

Pour les téléphones :

• Taille minimale : 320 pixels (largeur) x 320 pixels (hauteur)
• Taille maximale : 3840 pixels (largeur) x 3840 pixels (hauteur)
• Format : PNG ou JPEG
• Nombre recommandé : 4 à 8 captures d'écran

Pour les tablettes (7 pouces) :

• Taille minimale : 320 pixels (largeur) x 320 pixels (hauteur)
• Taille maximale : 3840 pixels (largeur) x 3840 pixels (hauteur)
• Format : PNG ou JPEG
• Nombre recommandé : 4 à 8 captures d'écran

Pour les tablettes (10 pouces) :

• Taille minimale : 320 pixels (largeur) x 320 pixels (hauteur)
• Taille maximale : 3840 pixels (largeur) x 3840 pixels (hauteur)
• Format : PNG ou JPEG
• Nombre recommandé : 4 à 8 captures d'écran

Incluez une variété de captures d'écran pour donner aux utilisateurs un aperçu complet de votre application. Montrez différentes fonctionnalités, écrans d'accueil et avantages clés. Les utilisateurs doivent pouvoir visualiser l'expérience complète de votre application grâce à ces captures d'écran.

Utilisez des légendes ou des annotations pour mettre en évidence les points forts de chaque capture d'écran. Expliquez brièvement ce que les utilisateurs peuvent attendre de chaque fonctionnalité ou écran. Assurez-vous que les annotations sont lisibles et ne gênent pas la vue d'ensemble.

Avant de publier vos captures d'écran, assurez-vous qu'elles s'affichent correctement sur différents appareils Android. Vérifiez l'apparence sur des téléphones de différentes tailles et des tablettes.

Si vous apportez des modifications significatives à votre application, assurez-vous de mettre à jour également les captures d'écran pour refléter les nouvelles fonctionnalités ou les changements d'interface utilisateur.

En préparant des captures d'écran de qualité et diversifiées, vous améliorez la présentation visuelle de votre application sur le Google Play Store. Des captures d'écran attrayantes donnent aux utilisateurs un aperçu immersif de votre application et peuvent les inciter à en savoir plus et à la télécharger.

#6 Publier l’application

Une fois que vous avez préparé votre application, il est temps de la publier sur le Google Play Store pour qu'elle soit accessible aux utilisateurs du monde entier. Voici les étapes pour publier votre application avec succès :

1. Accédez au tableau de bord du développeur Google Play

Connectez-vous à votre compte Google Play Console en utilisant le compte développeur que vous avez créé précédemment.

2. Créez un nouveau projet

Si c'est votre première application, vous devrez créer un nouveau projet dans le Tableau de Bord du Développeur.

3. Commencez la publication

Cliquez sur "Créer une nouvelle application" pour commencer le processus de publication.

4. Remplissez les informations de base

Vous devrez fournir des informations de base sur votre application, telles que son nom, sa catégorie, sa description courte, et l'icône de l'application.

5. Ajoutez des détails et du contenu

Rédigez une description complète de votre application en utilisant les conseils précédents. Ajoutez également des captures d'écran de haute qualité.

6. Configurations de tarification et de distribution

Choisissez si votre application sera gratuite ou payante. Configurez les pays où elle sera disponible et choisissez les méthodes de distribution.

7. Gestion des versions

Ajoutez votre fichier APK (Android Package) pour la première version de votre application. Assurez-vous que l'APK est signé et prêt pour la publication.

8. Testez votre application

Avant de publier, il est fortement recommandé de tester votre application sur différentes configurations d'appareils pour vous assurer qu'elle fonctionne correctement.

9. Analysez et soumettez

Lorsque vous êtes sûr que votre application est prête, effectuez une dernière vérification. Assurez-vous que toutes les informations sont correctes et que votre application respecte les politiques du Google Play Store.

Cliquez sur le bouton "Soumettre à l'examen" pour envoyer votre application à Google pour examen.

10. Attendez l'examen de Google

Google examinera votre application pour s'assurer qu'elle répond à toutes les normes de qualité et de sécurité. Cela peut prendre un certain temps, alors soyez patient.

11. Publication de l'application

Une fois que Google approuve votre application, elle sera publiée sur le Google Play Store et deviendra accessible aux utilisateurs.

12. Gérez les mises à jour

Après la publication, assurez-vous de gérer correctement les mises à jour de votre application. Vous devrez peut-être télécharger de nouvelles versions avec des correctifs ou des améliorations.

‍

La publication de votre application sur le Google Play Store est une étape importante pour la rendre disponible au public. Suivez ces étapes avec soin pour garantir une publication réussie et pour que votre application soit à la disposition des utilisateurs Android du monde entier.

La création et la publication d'une application sur le Google Play Store peuvent sembler complexes, mais avec les bonnes étapes et une préparation minutieuse, vous pouvez atteindre un public mondial et partager votre application avec des utilisateurs Android du monde entier.

Nous avons exploré chaque étape du processus, depuis la création d'un compte développeur Google Play jusqu'à la publication de votre application. Nous avons également mis en avant l'importance de tester rigoureusement votre application, de suivre ses performances et de répondre aux retours des utilisateurs.

N'oubliez pas que la qualité de votre application est essentielle. Une interface utilisateur soignée, une expérience fluide et des fonctionnalités attrayantes sont autant de facteurs qui peuvent influencer le succès de votre application.

En fin de compte, la persévérance, l'écoute des utilisateurs et l'adaptation aux évolutions du marché sont les clés du succès dans le monde des applications mobiles. Créer une application sur le Google Play Store est une aventure passionnante qui peut aboutir à une large base d'utilisateurs satisfaits.

Nous espérons que cet article vous a fourni des conseils utiles pour démarrer votre voyage de développement d'applications sur Android. Que vous choisissiez React Native, Flutter ou d'autres technos ... Bonne création d'application et bonne chance sur le Google Play Store !

Bienvenue dans le monde fascinant de Laravel, le framework PHP qui a révolutionné le développement web avec sa simplicité, son élégance et sa puissance. Que vous soyez un développeur chevronné ou simplement curieux de découvrir comment les applications web modernes sont construites, Laravel est un outil incontournable qui facilite la réalisation de projets complexes grâce à ses fonctionnalités avancées et son code élégant.

‍

Dans cet article, nous allons plonger dans cinq exemples d'applications web exceptionnelles développées avec Laravel, qui illustrent parfaitement la polyvalence et l'efficacité de ce framework. De la préparation aux tests linguistiques avec GlobalExam à l’apprentissage de la conduite avec Ornikar, en passant par la formation logicielle via Lemon Learning ou encore le recrutement en ligne avec HelloWork, préparez-vous à être inspiré par la créativité et l'innovation que Laravel rend possible. Suivez-nous dans ce voyage à la découverte des meilleures applications Laravel et voyez par vous-même pourquoi ce framework est tant plébiscité dans le monde du développement web.

‍

1. GlobalExam : Optimiser la préparation aux tests de langues

GlobalExam est une plateforme innovante qui permet aux utilisateurs de se préparer efficacement à divers tests de langues officiels tels que le TOEFL, le TOEIC, et le DELF. Utilisant Laravel, GlobalExam offre une interface flexible et robuste pour l'apprentissage en ligne, la gestion de contenu dynamique, et un suivi personnalisé des progrès des utilisateurs.

‍

GlobalExam tire parti de Laravel pour développer une interface utilisateur qui facilite l'interaction et l'engagement des apprenants. Laravel aide à structurer des parcours d'apprentissage personnalisés en fonction des besoins spécifiques de chaque utilisateur, intégrant des exercices pratiques, des simulations d'examens, et des analyses de performances.

Exemple de code pour afficher des exercices personnalisés aux utilisateurs :

‍

public function showExercises(Request $request)
{
	$userLevel = $request->user()->level;
	$exercises = Exercise::where('difficulty', $userLevel)->get();
	return view('exercises.list', compact('exercises'));
}

Ce code PHP illustre comment Laravel peut être utilisé pour récupérer et afficher des exercices adaptés au niveau de difficulté de l'utilisateur, en utilisant l'ORM Eloquent pour une extraction efficace des données correspondantes.

La capacité de Laravel à gérer de grandes quantités de contenu éducatif est essentielle pour une plateforme comme GlobalExam, qui offre des ressources pour une variété de tests dans plusieurs langues. Laravel facilite la mise à jour et l'organisation du contenu, assurant que les informations restent à jour et pertinentes.

public function updateContent(Request $request, $contentId)
{
	$content = Content::find($contentId);
	$content->update($request->all());
	return redirect()->back()->with('status', 'Content updated successfully!');
}

‍

Cet exemple montre comment Laravel gère la mise à jour du contenu éducatif, permettant aux administrateurs de la plateforme de maintenir facilement le matériel à jour avec des informations précises et actuelles.

Un aspect crucial de la préparation aux tests est le suivi des performances. Laravel aide GlobalExam à collecter et analyser les données des utilisateurs pour fournir des feedbacks détaillés et des recommandations personnalisées. Laravel offre des outils robustes pour le reporting et les analytics, qui sont essentiels pour optimiser les parcours d'apprentissage.

public function getUserProgress($userId)
{
	$progress = Progress::where('user_id', $userId)->latest()->first();
	return view('users.progress', compact('progress'));
}

Ce code démontre l'utilisation de Laravel pour suivre et afficher les progrès des utilisateurs, en permettant un accès facile aux informations historiques et actuelles sur les performances.

GlobalExam est un exemple parfait de la façon dont Laravel peut être utilisé pour développer des applications web complexes, centrées sur l'utilisateur, dans le domaine de l'éducation.

‍

‍

2. Ornikar : Révolutionner l'apprentissage de la conduite

Ornikar est non seulement une auto-école en ligne qui offre des leçons de conduite et des cours de code de la route, mais elle transforme également la façon dont les gens apprennent à conduire en France. Utilisant Laravel, Ornikar offre une plateforme flexible et sécurisée pour que les utilisateurs planifient leurs leçons, étudient le code de la route et passent leurs examens, le tout en ligne.

Laravel permet à Ornikar de proposer une interface utilisateur (UI) fluide qui s'adapte à tous les appareils, essentielle pour les étudiants en déplacement. La facilité d'utilisation est améliorée par Laravel, qui soutient une expérience utilisateur homogène sur le site web, en permettant de réserver des leçons et d'accéder à des matériaux d'étude interactifs.

Exemple de code pour une réservation de leçon dans Laravel :

‍

public function bookLesson(Request $request)
{
	$request->validate([
    	'lesson_date' => 'required|date',
    	'instructor_id' => 'required|exists:instructors,id',
	]);
 
	$lesson = new Lesson([
    	'student_id' => auth()->id(),
    	'instructor_id' => $request->instructor_id,
    	'scheduled_date' => $request->lesson_date,
	]);
 
	$lesson->save();
 
	return redirect()->back()->with('success', 'Lesson booked successfully!');
}

Ce code Laravel illustre comment une leçon peut être réservée via la plateforme, en s'assurant que toutes les données sont validées avant de procéder à l'enregistrement dans la base de données.

Avec un grand nombre d'utilisateurs accédant à des cours variés, la gestion efficace du contenu est cruciale. Laravel aide Ornikar à organiser et à mettre à jour ses contenus éducatifs de manière dynamique, garantissant que les informations sont toujours actuelles et pertinentes.

‍

public function updateCourseMaterial(Request $request, $courseId)
{
	$course = Course::findOrFail($courseId);
	$course->update($request->all());
 
	return redirect()->back()->with('status', 'Course material updated successfully!');
}

Ce morceau de code permet aux administrateurs de mettre à jour facilement le matériel de cours, en utilisant l'ORM Eloquent de Laravel pour une interaction fluide avec la base de données.

Ornikar utilise Laravel pour suivre les progrès des étudiants et analyser les données d'utilisation pour améliorer continuellement leurs services. Cette fonctionnalité est essentielle pour fournir un feedback personnalisé aux étudiants et pour ajuster les méthodes d'enseignement en fonction des besoins des utilisateurs.

‍

public function getStudentProgress($studentId)
{
	$progress = Progress::where('student_id', $studentId)->latest()->get();
	return view('students.progress', ['progress' => $progress]);
}

Ce code utilise Laravel pour récupérer et afficher les progrès d'un étudiant, aidant les instructeurs et les étudiants à visualiser les améliorations au fil du temps et à identifier les domaines nécessitant une attention supplémentaire.

Ornikar est un exemple éloquent de la manière dont Laravel peut être utilisé pour transformer des industries traditionnelles comme l'éducation à la conduite.

‍

3. Lemon Learning : Transformer la formation logicielle en entreprise

Lemon Learning est une plateforme innovante qui révolutionne la formation logicielle en entreprise en intégrant des guides interactifs directement dans les outils SaaS utilisés par les entreprises. Grâce à Laravel, Lemon Learning offre une solution fluide et intégrée qui aide les employés à maîtriser rapidement et efficacement divers logiciels, en réduisant le temps nécessaire à la formation et en maximisant la productivité.

L'un des défis majeurs pour Lemon Learning était d'assurer une intégration transparente de ses guides interactifs avec une multitude d'applications d'entreprise sans perturber l'expérience utilisateur. Laravel a permis de développer une API robuste et sécurisée qui s'interface facilement avec n'importe quel logiciel d'entreprise utilisé par les clients.

Exemple de code pour une API Laravel gérant les requêtes d'intégration :

‍

Route::post('/integration/setup', 'IntegrationController@store');
 
public function store(Request $request)
{
	$this->validate($request, [
    	'software_id' => 'required|exists:softwares,id',
    	'client_id' => 'required|exists:clients,id',
    	// Autres validations nécessaires
	]);
 
	$integration = new Integration([
    	'software_id' => $request->software_id,
    	'client_id' => $request->client_id,
    	// Autres paramètres
	]);
 
	$integration->save();
 
	return response()->json(['message' => 'Integration setup successfully!'], 201);
}

Ce code illustre comment Laravel peut être utilisé pour créer des endpoints API qui facilitent l'intégration de la plateforme Lemon Learning avec divers logiciels d'entreprise, permettant des configurations personnalisées pour chaque client.

Laravel aide également Lemon Learning à gérer de manière dynamique et efficace les contenus de formation. La plateforme doit constamment mettre à jour et personnaliser les tutoriels pour s'adapter aux logiciels qui évoluent rapidement. Laravel offre des outils puissants pour la gestion de contenu qui facilitent ces mises à jour régulières.

public function updateTutorial(Request $request, $tutorialId)
{
	$tutorial = Tutorial::findOrFail($tutorialId);
	$tutorial->update($request->all());
 
	return redirect()->back()->with('success', 'Tutorial updated successfully!');
}

Ce morceau de code permet aux administrateurs de Lemon Learning de mettre à jour les tutoriels directement via le tableau de bord, en utilisant l'ORM Eloquent pour une interaction efficace avec la base de données.

Un autre aspect crucial de Lemon Learning est le suivi des progrès des utilisateurs et l'analyse des performances des tutoriels. Laravel fournit des capacités sophistiquées de reporting et d'analyse qui permettent à Lemon Learning d'offrir des insights précieux aux entreprises sur l'efficacité des formations.

‍

public function getUserProgress($userId)
{
	$progress = Progress::with('tutorials.completed')->where('user_id', $userId)->get();
	return view('progress.show', compact('progress'));
}

Ce code utilise Laravel pour recueillir et présenter des données détaillées sur la progression de chaque utilisateur, aidant les entreprises à mesurer l'impact réel de la formation sur la productivité et l'efficacité des employés.

Lemon Learning illustre parfaitement la capacité de Laravel à soutenir des solutions technologiques innovantes dans le domaine de la formation en entreprise.

‍

4. HelloWork : Dynamiser le recrutement en ligne

HelloWork est une plateforme française leader dans le domaine du recrutement en ligne, qui connecte les employeurs aux candidats à travers une interface intuitive et efficace. Utilisant Laravel, HelloWork optimise les processus de recherche d'emploi et de recrutement, facilitant les interactions entre les entreprises et les chercheurs d'emploi grâce à des fonctionnalités avancées et une gestion fluide des données.

La plateforme HelloWork repose sur Laravel pour fournir une expérience utilisateur (UX) riche et interactive, facilitant la navigation, la recherche d'emploi et la gestion des candidatures. Laravel aide à structurer une interface utilisateur qui répond rapidement aux actions des utilisateurs, améliorant ainsi leur engagement et leur satisfaction.

Exemple de code pour afficher les offres d'emploi selon les filtres de l'utilisateur :

public function listJobs(Request $request)
{
	$jobs = Job::query();
 
	if ($request->has('location')) {
    	$jobs->where('location', $request->location);
	}
	if ($request->has('keyword')) {
    	$jobs->where('title', 'like', '%' . $request->keyword . '%');
	}
 
	return view('jobs.index', ['jobs' => $jobs->paginate(10)]);
}

Ce code illustre comment Laravel peut être utilisé pour créer des filtres dynamiques qui ajustent les résultats de recherche en fonction des préférences des utilisateurs, rendant la recherche d'emploi plus ciblée et efficace.

‍

Laravel fournit à HelloWork les outils nécessaires pour gérer dynamiquement des milliers d'annonces d'emploi et de profils de candidats. L'ORM Eloquent intégré permet une manipulation aisée des données, assurant une mise à jour et une récupération efficace des informations pertinentes.

‍

public function updateJob(Request $request, $jobId)
{
	$job = Job::findOrFail($jobId);
	$job->update($request->all());
 
	return redirect()->back()->with('success', 'Job updated successfully!');
}

‍

Ce morceau de code montre comment les annonces d'emploi peuvent être mises à jour facilement par les employeurs, garantissant que les informations restent actuelles et précises.

La capacité de suivre les candidatures et d'analyser le comportement des utilisateurs est cruciale pour optimiser les stratégies de recrutement. Laravel aide HelloWork à collecter et analyser les données des utilisateurs, fournissant des insights précieux pour les employeurs sur l'efficacité de leurs annonces.

‍

public function trackApplications($jobId)
{
	$applications = Application::where('job_id', $jobId)->get();
	return view('employers.analytics', ['applications' => $applications]);
}

Ce code utilise Laravel pour récupérer et afficher les données sur les candidatures reçues pour un poste spécifique, permettant aux employeurs de mesurer l'intérêt et l'efficacité de leurs annonces.

HelloWork démontre l'efficacité de Laravel dans le développement de solutions de recrutement en ligne.

‍

5. Ecodrop : Faciliter le recyclage pour les professionnels du BTP

Ecodrop est une plateforme innovante qui révolutionne la gestion des déchets de construction en facilitant le recyclage pour les professionnels du BTP en France. Utilisant Laravel, Ecodrop offre une solution efficace pour localiser les points de collecte les plus proches, gérer les déchets de manière responsable, et optimiser la logistique des déchets de chantier.

Laravel aide Ecodrop à fournir une interface utilisateur claire et facile à naviguer, permettant aux professionnels de trouver rapidement des solutions de recyclage à proximité. La plateforme permet également une interaction fluide pour la réservation de collectes de déchets, la consultation des prix et le suivi des transactions.

Exemple de code pour la recherche de centres de recyclage par localisation :

‍

public function searchRecyclingCenters(Request $request)
{
	$centers = RecyclingCenter::query();
	if ($request->has('zipcode')) {
    	$centers->where('zipcode', $request->zipcode);
	}
	return view('recycling.centers', ['centers' => $centers->get()]);
}

Ce code montre comment Laravel peut être utilisé pour filtrer les centres de recyclage en fonction du code postal fourni par l'utilisateur, simplifiant ainsi la recherche et aidant les professionnels à trouver les options les plus pratiques.

Laravel fournit les outils nécessaires pour gérer efficacement les profils des utilisateurs et les commandes de collecte de déchets. Les professionnels peuvent s'enregistrer, gérer leurs informations, et planifier des collectes en quelques clics.

‍

public function updateProfile(Request $request)
{
	$user = Auth::user();
	$user->update($request->all());
 
	return redirect()->route('profile')->with('success', 'Profile updated successfully!');
}

Ce morceau de code illustre la mise à jour du profil utilisateur avec Laravel, utilisant l'authentification intégrée et l'ORM Eloquent pour une interaction sécurisée et efficace avec la base de données.

Laravel aide Ecodrop à suivre les transactions et à analyser l'efficacité des services offerts. La plateforme collecte des données sur les types et volumes de déchets collectés, permettant des analyses approfondies pour améliorer continuellement le service.

‍

public function getTransactionDetails($transactionId)
{
	$transaction = Transaction::with('user', 'recyclingCenter')->findOrFail($transactionId);
	return view('transactions.detail', ['transaction' => $transaction]);
}

Ce code utilise Laravel pour récupérer les détails d'une transaction spécifique, y compris les informations sur l'utilisateur et le centre de recyclage, facilitant le suivi et l'analyse des services de collecte.

Ecodrop illustre parfaitement comment Laravel peut être exploité pour développer des solutions durables et efficaces dans le secteur du BTP.

‍

En explorant ces cinq applications fascinantes développées avec Laravel - de GlobalExam à Ecodrop, en passant par Ornikar, Lemon Learning, et HelloWork -, il est clair que Laravel ne se contente pas d'être un simple outil de développement web. Il représente une solution complète qui offre flexibilité, efficacité et puissance pour relever les défis du développement web moderne. Chaque exemple met en lumière la capacité de Laravel à transformer des idées ambitieuses en réalités numériques robustes et performantes, offrant des expériences utilisateur riches et intuitives.

‍

Que vous soyez un développeur cherchant à affiner vos compétences ou une entreprise en quête d'innovation, Laravel se présente comme le framework de choix pour créer des applications web qui se distinguent. En définitive, ces cinq exemples ne sont qu'un aperçu de ce qui est possible avec Laravel, ouvrant la porte à un monde de potentiel illimité pour les développeurs et les entreprises du monde entier.

‍