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

# Riduci la latenza del checkout con tre strategie a confronto

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="Riduci la latenza del checkout con tre strategie concorrenti" description="Metti in competizione 3 sessioni Devin in parallelo contro un'API di checkout lenta — ognuna prova un'ottimizzazione diversa, quindi porta in produzione l'approccio migliore." prompt="La latenza p99 della nostra API di checkout è di 1,8 s e deve scendere sotto i 400 ms. Avvia 3 sessioni Devin in parallelo per ottimizzarla in modo indipendente. Ognuna deve profilare l'endpoint, implementare una strategia di ottimizzazione diversa ed eseguire il benchmark del risultato. Una volta che tutte e 3 hanno finito, confronta i loro approcci e apri una PR finale con la soluzione migliore." category="Ottimizzazione con Devin" features="Avanzato" agent="advanced" intent="batch" />

<div className="uc-detail-wrapper">
  <Tip>Non vuoi configurarlo manualmente? Incolla un collegamento a questa pagina in una sessione Devin e chiedigli di configurare tutto per te.</Tip>

  <Steps>
    <Step title="Definire il problema e i criteri di successo">
      La tua API di checkout (`POST /api/checkout`) ha una latenza p99 di 1,8 secondi — gli utenti abbandonano i carrelli e il tuo obiettivo di SLA è 400 ms. Esistono diversi modi validi per risolvere il problema: caching, ottimizzazione delle query, elaborazione asincrona, pooling delle connessioni. Non sai quale funzionerà meglio finché non li provi, e provarli in sequenza significa aspettare giorni.

      Invece, chiedi a Devin di avviare 3 sessioni in parallelo, ognuna delle quali esplora una strategia diversa. Dopo che tutte e 3 hanno terminato, Devin confronta i risultati e applica la soluzione vincente — oppure combina le parti migliori di ognuna in una singola PR.

      Per iniziare, apri una nuova sessione Devin dalla [homepage di Devin](https://app.devin.ai/?utm_source=docs\&utm_medium=use-case-gallery) e descrivi l'attività batch.
    </Step>

    <Step title="Scrivi un prompt che indirizzi ogni sessione verso una soluzione diversa">
      Il valore di eseguire 3 sessioni dipende dal fatto che ognuna esplori un approccio davvero diverso. Scrivi il tuo prompt in modo da incoraggiare la divergenza — suggerisci strategie specifiche e definisci cosa significa "migliore" così che i risultati siano direttamente confrontabili.

      <PromptBlock agent="advanced" intent="batch">
        ```txt Ridurre la latenza del checkout — 3 strategie in competizione theme={null}
        La nostra API di checkout (POST /api/checkout in src/routes/checkout.ts) ha
        una latenza p99 di 1,8s. Dobbiamo portarla sotto i 400ms.

        Avvia 3 sessioni in parallelo. Ciascuna deve:
        1. Profilare l'endpoint per trovare i colli di bottiglia (esegui `npm run bench:checkout`)
        2. Scegliere una strategia di ottimizzazione DIVERSA — ad es. caching,
           ottimizzazione delle query, elaborazione asincrona, connection pooling o denormalizzazione
        3. Implementare l'ottimizzazione
        4. Rieseguire il benchmark e riportare il nuovo p99

        Criteri di confronto — classifica ciascun risultato in base a:
        - Latenza p99 (deve essere sotto i 400ms per superare il test)
        - Tasso di errore (non deve aumentare)
        - Complessità del codice aggiunta (meno nuove dipendenze = meglio)
        - Compromessi sulla consistenza dei dati (documenta qualsiasi rischio di coerenza eventuale / eventual consistency)

        Una volta che tutte e 3 hanno terminato, confronta i risultati usando i criteri sopra
        e crea una PR finale che usi l'approccio migliore — oppure combini idee
        da più sessioni se questo ci consente di ridurre ulteriormente la latenza.
        ```
      </PromptBlock>

      **Suggerimenti per un buon prompt multi-strategia:**

      * **Definisci "migliore" con criteri ordinati.** Elencare le dimensioni di confronto — latenza, tasso di errore, complessità, consistenza — impedisce a Devin di privilegiare soltanto la velocità pura.
      * **Suggerisci strategie specifiche.** Opzioni come "caching, riscrittura delle query, elaborazione asincrona" spingono ciascuna sessione verso un percorso diverso.
      * **Includi un comando di benchmark.** Ogni sessione ha bisogno di un modo riproducibile per misurare il proprio risultato — `npm run bench`, `k6 run load-test.js` o un semplice loop curl.
      * **Indica il codice.** Un percorso di file come `src/routes/checkout.ts` assicura che tutte e 3 le sessioni partano dallo stesso punto.
    </Step>

    <Step title="Confronta i risultati e seleziona il vincitore">
      Una volta che tutte e tre le sessioni sono state completate, Devin esamina il lavoro prodotto confrontandolo con i tuoi criteri — strategie utilizzate, metriche di benchmark, compromessi — e poi sceglie la soluzione migliore oppure sintetizza una soluzione combinata in un’unica PR finale (pull request finale).

      Ecco come si presenta questo confronto per il problema della latenza nel checkout:

      ```
      Sessione 1 — Caching delle risposte Redis
        Strategia:  Cache del carrello serializzato + lookup inventario in Redis con
                    TTL di 30s, bypass del DB per richieste ripetute
        p99:        1.8s -> 320ms  (PASS — riduzione dell'82%)
        Errori:     Nessuna modifica
        Complessità: +1 dipendenza (ioredis), 2 nuovi file
        Compromesso: Dati inventario non aggiornati per un massimo di 30s; 40MB di memoria Redis

      Sessione 2 — Ottimizzazione query + connection pooling
        Strategia:  Sostituzione delle query N+1 con un singolo JOIN, aggiunto PgBouncer
                    connection pool (25 connessioni)
        p99:        1.8s -> 580ms  (FAIL — ancora sopra i 400ms)
        Errori:     Nessuna modifica
        Complessità: 0 nuove dipendenze, query più pulite
        Compromesso: Nessuno significativo — carico DB complessivamente inferiore

      Sessione 3 — Elaborazione ordini asincrona
        Strategia:  Spostamento dell'elaborazione pagamenti e delle email in una coda in background
                    (BullMQ), restituzione del 202 immediatamente dopo il controllo inventario
        p99:        1.8s -> 190ms  (PASS — riduzione dell'89%)
        Errori:     Nessuna modifica
        Complessità: +1 dipendenza (bullmq), 3 nuovi file, webhook handler
        Compromesso: Il checkout diventa eventually consistent; richiede webhook
                    per la conferma del pagamento

      Verdetto: Le sessioni 1 e 3 superano entrambe il target di 400ms. Le
      correzioni alle query della sessione 2 sono utili ma insufficienti da sole.

      PR finale: Combinata l'ottimizzazione delle query della sessione 2 (nessun costo aggiuntivo,
      decisamente migliore) con l'elaborazione asincrona della sessione 3. Pagamenti + email spostati nella
      coda, query N+1 corrette. p99 finale: 150ms. PR #412 aperta.
      ```

      Puoi rivedere le singole PR di sessione prima che Devin crei quella combinata. Se preferisci chiaramente uno degli approcci, ti basta dirlo a Devin — "segui l'approccio della sessione 3, salta la combinazione."
    </Step>

    <Step title="Quando far competere 3 strategie su un unico problema">
      **Buon caso d'uso — esistono più approcci validi:**

      * Collo di bottiglia delle prestazioni in cui caching, ottimizzazione delle query e modifiche all’architettura potrebbero funzionare tutte
      * Decisioni di architettura con tradeoff reali (estrazione da un monolite, riprogettazione della gestione dello stato)
      * Scelta dell’algoritmo per un problema fortemente basato sui dati (diverse strategie di indicizzazione, ranking o approcci di ML)

      **Cattivo caso d'uso — la soluzione è ovvia:**

      * Correzioni di bug con causa principale chiara
      * Aggiunta di un endpoint CRUD standard
      * Aggiornamento di dipendenze o file di configurazione

      Questo pattern utilizza 3 volte gli [ACU](/it/admin/billing/usage) di una singola sessione. Riservalo a problemi per cui altrimenti passeresti giorni a provare approcci in sequenza. Per attività semplici, una singola sessione di Devin è più veloce ed economica.

      Puoi anche attivare sessioni parallele [tramite l’API](/it/api-reference/v3/sessions/post-organizations-sessions) impostando `advanced_mode` su `batch` — utile per integrarle in pipeline CI che mettono automaticamente in competizione più correzioni per una regressione di prestazioni. Se vuoi che Devin venga eseguito in modo completamente autonomo senza attendere la tua approvazione sulle proposte, abilita il flag **bypass permissions** così le sessioni si approvano automaticamente e continuano ad avanzare.
    </Step>
  </Steps>
</div>