> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Réduire la latence du checkout avec trois stratégies en concurrence

export const UseCaseHero = ({title, description, prompt, category, features, devinUrl, agent, intent, playbookId, type}) => {
  const encodedPrompt = encodeURIComponent(prompt || '');
  const tag = 'docs-use-case-gallery';
  const utm = 'utm_source=docs&utm_medium=use-case-gallery&utm_campaign=hero-cta';
  const agentParams = (agent ? '&agent=' + agent : '') + (intent ? '&intent=' + intent : '') + (playbookId ? '&playbookId=' + playbookId : '');
  const devinHref = type === 'schedule' ? 'https://app.devin.ai/settings/schedules/create?' + utm + agentParams + (prompt ? '&prompt=' + encodedPrompt : '') : type === 'review' ? 'https://app.devin.ai/review?' + utm : agent === 'ada' ? 'https://app.devin.ai/search?' + utm + '&noSubmit=true' + (prompt ? '&prompt=' + encodedPrompt : '') : devinUrl ? devinUrl.includes('?') ? devinUrl + '&' + utm + agentParams : devinUrl + '?' + utm + agentParams : prompt ? 'https://app.devin.ai/?tags=' + tag + '&' + utm + agentParams + '&prompt=' + encodedPrompt : 'https://app.devin.ai/?' + utm + agentParams;
  const buttonLabel = type === 'schedule' ? 'Schedule in Devin ↗' : type === 'review' ? 'Set Up Devin Review ↗' : agent === 'advanced' ? 'Try in Devin ↗' : agent === 'dana' ? 'Try in Dana ↗' : agent === 'ada' ? 'Try in Ask Devin ↗' : 'Try in Devin ↗';
  const featureList = features ? features.split(',').map(f => f.trim()) : [];
  return <div className="uc-hero">
      <div className="uc-hero-inner">
        <div className="uc-hero-left">
          <h1 className="uc-hero-title">{title}</h1>
          <p className="uc-hero-desc">{description}</p>
          <div>
            <a href={devinHref} target="_blank" rel="noopener noreferrer" className="try-in-devin-btn">
              {buttonLabel}
            </a>
          </div>
        </div>
        <div className="uc-hero-meta">
          <div className="uc-meta-item">
            <span className="uc-meta-label">Author</span>
            <span className="uc-meta-value">Cognition</span>
          </div>
          <div className="uc-meta-item">
            <span className="uc-meta-label">Category</span>
            <span className="uc-meta-value">{category}</span>
          </div>
          {featureList.length > 0 && <div className="uc-meta-item">
              <span className="uc-meta-label">Features</span>
              <span className="uc-meta-value">{featureList.join(', ')}</span>
            </div>}
        </div>
      </div>
    </div>;
};

export const PromptBlock = ({children, type, agent, intent, playbookId}) => {
  var utm = 'utm_source=docs&utm_medium=use-case-gallery&utm_campaign=prompt-block';
  var tag = 'docs-use-case-gallery';
  var agentParams = (agent ? '&agent=' + agent : '') + (intent ? '&intent=' + intent : '') + (playbookId ? '&playbookId=' + playbookId : '');
  var label = type === 'schedule' ? 'Schedule in Devin' : type === 'playbook' ? 'Create Playbook' : type === 'knowledge' ? 'Add to Knowledge' : agent === 'advanced' ? 'Try in Devin' : agent === 'dana' ? 'Try in Dana' : agent === 'ada' ? 'Try in Ask Devin' : 'Try in Devin';
  var buildUrl = function (text) {
    var encoded = encodeURIComponent(text);
    if (type === 'schedule') return 'https://app.devin.ai/settings/schedules/create?' + utm + agentParams + '&prompt=' + encoded;
    if (type === 'playbook') return 'https://app.devin.ai/settings/playbooks/create?' + utm + '&body=' + encoded;
    if (type === 'knowledge') return 'https://app.devin.ai/knowledge?' + utm + '&body=' + encoded;
    if (agent === 'ada') return 'https://app.devin.ai/search?' + utm + '&noSubmit=true&prompt=' + encoded;
    return 'https://app.devin.ai/?tags=' + tag + '&' + utm + agentParams + '&prompt=' + encoded;
  };
  const ref = React.useRef(null);
  const [href, setHref] = React.useState('#');
  React.useEffect(() => {
    if (!ref.current) return;
    var codeEl = ref.current.querySelector('pre code');
    if (codeEl) {
      var text = codeEl.textContent.trim();
      if (text) setHref(buildUrl(text));
    }
    var header = ref.current.querySelector('[data-component-part="code-block-header"]');
    if (header && !header.querySelector('.prompt-block-devin-link')) {
      var link = document.createElement('a');
      link.href = href;
      link.target = '_blank';
      link.rel = 'noopener noreferrer';
      link.className = 'prompt-block-devin-link';
      link.style.cssText = 'display:inline-flex;align-items:center;gap:6px;text-decoration:none;color:#fff;font-size:11px;font-weight:500;padding:4px 10px;border-radius:6px;white-space:nowrap;background:#317CFF;transition:background 0.2s;margin-left:8px;';
      link.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/><polyline points="15 3 21 3 21 9"/><line x1="10" y1="14" x2="21" y2="3"/></svg> ' + label;
      link.onmouseenter = function () {
        link.style.background = '#2968D9';
      };
      link.onmouseleave = function () {
        link.style.background = '#317CFF';
      };
      header.appendChild(link);
    }
    var existingLink = ref.current.querySelector('.prompt-block-devin-link');
    if (existingLink && href !== '#') existingLink.href = href;
  });
  return <div className="prompt-block" ref={ref}>{children}</div>;
};

<UseCaseHero title="Corriger la latence du checkout avec trois stratégies concurrentes" description="Lancez 3 sessions Devin en parallèle face à une API de checkout lente — chacune essaie une optimisation différente, puis la meilleure approche est déployée." prompt="La latence p99 de notre API de checkout est de 1,8 s et doit être inférieure à 400 ms. Démarrez 3 sessions Devin en parallèle pour l’optimiser chacune de son côté. Chacune doit profiler l’endpoint, mettre en œuvre une stratégie d’optimisation différente et mesurer les performances obtenues. Une fois les 3 terminées, comparez leurs approches et ouvrez une PR finale avec la meilleure solution." category="Optimisation Devin" features="Avancé" agent="advanced" intent="batch" />

<div className="uc-detail-wrapper">
  <Tip>Vous ne souhaitez pas effectuer cette configuration manuellement ? Collez un lien vers cette page dans une session Devin et demandez-lui de tout configurer pour vous.</Tip>

  <Steps>
    <Step title="Définir le problème et les critères de succès">
      Votre API de checkout (`POST /api/checkout`) a une latence p99 de 1,8 seconde : les utilisateurs abandonnent leur panier et votre objectif de SLA est de 400 ms. Il existe plusieurs approches possibles pour y remédier : mise en cache, optimisation des requêtes, traitement asynchrone, pool de connexions. Vous ne savez pas laquelle fonctionnera le mieux avant de les avoir essayées, et les tester séquentiellement signifie attendre plusieurs jours.

      Au lieu de cela, demandez à Devin de lancer 3 sessions en parallèle, chacune explorant une stratégie différente. Une fois les 3 terminées, Devin compare les résultats et déploie la solution gagnante — ou combine les meilleurs éléments de chacune en un seul PR.

      Pour commencer, ouvrez une nouvelle session Devin depuis la [page d’accueil de Devin](https://app.devin.ai/?utm_source=docs\&utm_medium=use-case-gallery) et décrivez la tâche par lots.
    </Step>

    <Step title="Rédigez un prompt qui guide chaque session vers une correction différente">
      La valeur du lancement de 3 sessions dépend du fait que chacune explore une approche réellement différente. Rédigez votre prompt pour encourager la divergence — suggérez des stratégies spécifiques et définissez ce que signifie "best" afin que les résultats soient directement comparables.

      <PromptBlock agent="advanced" intent="batch">
        ```txt Fix checkout latency — 3 competing strategies theme={null}
        Notre API de checkout (POST /api/checkout dans src/routes/checkout.ts) a
        une latence p99 de 1,8 s. Nous devons la faire passer sous 400 ms.

        Lancez 3 sessions parallèles. Chacune doit :
        1. Profiler l'endpoint pour trouver les goulots d'étranglement (exécuter `npm run bench:checkout`)
        2. Choisir une stratégie d'optimisation DIFFÉRENTE — par exemple, mise en cache, optimisation
           des requêtes, traitement asynchrone, pool de connexions ou dénormalisation
        3. Mettre en œuvre l'optimisation
        4. Relancer le benchmark et indiquer le nouveau p99

        Critères de comparaison — classez chaque résultat selon :
        - la latence p99 (doit être inférieure à 400 ms pour être acceptable)
        - le taux d'erreur (ne doit pas augmenter)
        - la complexité de code ajoutée (moins de nouvelles dépendances = mieux)
        - les compromis de cohérence des données (documenter tout risque de cohérence éventuelle / eventual consistency)

        Une fois les 3 sessions terminées, comparez les résultats à l'aide des critères ci-dessus et
        créez une PR finale qui utilise la meilleure approche — ou combine des idées
        de plusieurs sessions si cela permet d'obtenir une latence plus faible.
        ```
      </PromptBlock>

      **Conseils pour un bon prompt multi-stratégie :**

      * **Définissez "best" avec des critères hiérarchisés.** Énumérer les dimensions de comparaison — latence, taux d'erreur, complexité, cohérence — empêche Devin de se limiter à la vitesse brute.
      * **Suggérez des stratégies spécifiques.** Des options comme "caching, query rewriting, async processing" orientent chaque session vers une voie différente.
      * **Incluez une commande de benchmark.** Chaque session a besoin d'un moyen reproductible de mesurer son propre résultat — `npm run bench`, `k6 run load-test.js` ou une simple boucle curl.
      * **Pointez vers le code.** Un chemin de fichier comme `src/routes/checkout.ts` garantit que les 3 sessions partent toutes du même point.
    </Step>

    <Step title="Comparez les résultats et choisissez le meilleur">
      Une fois les 3 sessions terminées, Devin passe en revue leur travail côte à côte selon vos critères — stratégies utilisées, chiffres de référence, arbitrages — et sélectionne soit la meilleure option, soit synthétise une solution combinée sous la forme d’une pull request (PR) finale.

      Voici à quoi ressemble cette comparaison pour le problème de latence du checkout :

      ```
      Session 1 — Redis response caching
        Strategy:   Cache serialized cart + inventory lookups in Redis with
                    30s TTL, bypass DB for repeat requests
        p99:        1.8s -> 320ms  (PASS — 82% reduction)
        Errors:     No change
        Complexity: +1 dependency (ioredis), 2 new files
        Tradeoff:   Stale inventory data for up to 30s; 40MB Redis memory

      Session 2 — Query optimization + connection pooling
        Strategy:   Replaced N+1 queries with a single JOIN, added PgBouncer
                    connection pool (25 connections)
        p99:        1.8s -> 580ms  (FAIL — still above 400ms)
        Errors:     No change
        Complexity: 0 new dependencies, cleaner queries
        Tradeoff:   None significant — lower DB load overall

      Session 3 — Async order processing
        Strategy:   Moved payment processing and email to a background queue
                    (BullMQ), return 202 immediately after inventory check
        p99:        1.8s -> 190ms  (PASS — 89% reduction)
        Errors:     No change
        Complexity: +1 dependency (bullmq), 3 new files, webhook handler
        Tradeoff:   Checkout becomes eventually consistent; needs webhook
                    for payment confirmation

      Verdict: Sessions 1 and 3 both pass the 400ms target. Session 2's
      query fixes are valuable but insufficient alone.

      Final PR: Combined Session 2's query optimization (no cost, strictly
      better) with Session 3's async processing. Payment + email moved to
      queue, N+1 queries fixed. Final p99: 150ms. PR #412 opened.
      ```

      Vous pouvez revoir les PR de chaque session avant que Devin ne crée la PR combinée. Si vous préférez une approche en particulier, dites simplement à Devin : "adopte l’approche de la session 3 et ignore la combinaison."
    </Step>

    <Step title="Quand lancer 3 stratégies en parallèle sur un même problème">
      **Bon cas d’utilisation — plusieurs approches valides existent :**

      * Goulots d’étranglement de performances où la mise en cache, l’optimisation des requêtes et des changements d’architecture pourraient tous fonctionner
      * Décisions d’architecture avec de vrais compromis (extraction d’un monolithe, refonte de la gestion d’état)
      * Choix d’algorithme pour un problème très volumineux en données (différents index, méthodes de classement ou approches de ML)

      **Mauvais cas d’utilisation — la solution est évidente :**

      * Corrections de bugs avec une cause fondamentale claire
      * Ajout d’un endpoint CRUD standard
      * Mise à jour de dépendances ou de fichiers de configuration

      Ce mode utilise 3× plus d’[ACU](/fr/admin/billing/usage) qu’une seule session. Réservez-le aux problèmes pour lesquels vous passeriez autrement des jours à essayer des approches de manière séquentielle. Pour les tâches simples, une seule session Devin est plus rapide et moins coûteuse.

      Vous pouvez aussi déclencher des sessions parallèles [via l’API](/fr/api-reference/v3/sessions/post-organizations-sessions) en définissant `advanced_mode` sur `batch` — utile pour l’intégration dans des pipelines CI qui mettent automatiquement en concurrence plusieurs correctifs face à une régression de performances. Si vous voulez que Devin fonctionne de manière entièrement autonome sans attendre votre approbation sur les propositions, activez le paramètre **bypass permissions** pour que les sessions soient automatiquement approuvées et puissent se poursuivre.
    </Step>
  </Steps>
</div>