{"id":1563,"date":"2021-11-03T14:58:00","date_gmt":"2021-11-03T13:58:00","guid":{"rendered":"https:\/\/brentasoft.com\/blog\/dora-metrics-devops-kpi-2021\/"},"modified":"2026-06-04T08:57:20","modified_gmt":"2026-06-04T06:57:20","slug":"dora-metrics-devops-kpi-2021","status":"publish","type":"post","link":"https:\/\/brentasoft.com\/blog\/dora-metrics-devops-kpi-2021\/","title":{"rendered":"DORA metrics 2021: i 4 KPI DevOps per team engineering"},"content":{"rendered":"

Nel giugno 2021 Google Cloud, in collaborazione con il team DORA<\/strong> (DevOps Research and Assessment), ha pubblicato l’ottava edizione del report Accelerate State of DevOps<\/em>. Lo studio ha raccolto le risposte di oltre 36.000 professionisti tech<\/strong> a livello globale e ha confermato, ancora una volta, che le pratiche DevOps non sono solo “una moda da Silicon Valley”, ma una leva concreta di performance per qualsiasi organizzazione che sviluppa software. Dietro al rumore di sigle, dashboard e framework, il report ricorda una verit\u00e0 semplice: quello che non si misura non si migliora.<\/p>\n

Le DORA metrics<\/strong> sono il linguaggio comune che oggi engineering manager, CTO<\/strong> e responsabili di engineering usano per parlare di velocit\u00e0, qualit\u00e0 e affidabilit\u00e0 del software. Quattro indicatori storici (Deployment Frequency<\/strong>, Lead Time for Changes<\/strong>, MTTR<\/strong>, Change Failure Rate<\/strong>) ai quali nel 2021 si aggiunge una quinta dimensione: la Reliability<\/strong> operativa, in linea con i principi SRE<\/strong> di Google.<\/p>\n

Questa guida \u00e8 pensata per chi guida un team di sviluppo in una PMI<\/strong> software house italiana e vuole capire come introdurre le DORA metrics<\/strong> senza trasformarle nell’ennesimo cruscotto vanity. Vedremo cosa misurare, come misurarlo con tool maturi nel 2021, quali errori evitare e una roadmap di adozione a 60 giorni testata sul campo.<\/p>\n

\n

TL;DR<\/strong><\/p>\n

    \n
  • Le DORA metrics<\/strong> sono 4 KPI (+1 dal 2021): Deployment Frequency<\/strong>, Lead Time for Changes<\/strong>, MTTR<\/strong>, Change Failure Rate<\/strong>, Reliability<\/strong>.<\/li>\n
  • I team Elite<\/strong> deployano fino a 973x<\/strong> piu’ spesso dei team Low<\/strong> e si recuperano dagli incidenti in minuti, non giorni.<\/li>\n
  • Strumenti maturi 2021: GitLab<\/strong> Value Stream Analytics, GitHub<\/strong> Insights, Jenkins<\/strong>, CircleCI<\/strong>, Datadog<\/strong>, LinearB<\/strong>, Sleuth<\/strong>, Faros AI<\/strong>.<\/li>\n
  • Una PMI<\/strong> puo’ raggiungere il tier High<\/strong> in 6 mesi se evita le vanity metrics e introduce un loop di miglioramento mensile.<\/li>\n<\/ul>\n<\/div>\n

    Cosa sono le DORA metrics<\/h2>\n

    L’acronimo DORA<\/strong> sta per DevOps Research and Assessment<\/em>: un team di ricerca fondato nel 2015 da Nicole Forsgren<\/strong>, Jez Humble<\/strong> e Gene Kim<\/strong>, acquisito da Google Cloud<\/strong> a fine 2018. La loro tesi, validata da sei anni di ricerca quantitativa e dal libro Accelerate<\/em> (2018), e’ che esistono quattro indicatori capaci di prevedere in modo statisticamente significativo la performance di un’organizzazione software.<\/p>\n

    I quattro KPI originali si dividono in due famiglie: velocita’<\/strong> di consegna (Deployment Frequency e Lead Time) e stabilita’<\/strong> (MTTR e Change Failure Rate). Il messaggio chiave del report 2021 e’ che velocita’ e stabilita’ non sono in trade-off, anzi: i team che vanno piu’ veloci sono anche quelli che falliscono meno. La quinta metrica introdotta nel 2021 – la Reliability<\/strong> operativa – chiude il cerchio collegando il lavoro di engineering all’esperienza percepita dall’utente finale tramite SLO<\/strong>, SLI<\/strong> e error budget<\/strong>.<\/p>\n

    Le DORA metrics<\/strong> non sono inventate dal nulla: derivano da decenni di Lean Manufacturing applicato al software, e si integrano in modo naturale con framework come Scrum<\/strong>, Kanban<\/strong> e SAFe<\/strong>. Per una PMI<\/strong>, il valore non e’ nel singolo numero ma nel trend<\/em>: misurare per migliorare, non per giustificare bonus.<\/p>\n

    \"Schermata<\/p>\n

    I 4 KPI DORA + la quinta metrica 2021<\/h2>\n

    Vediamo nel dettaglio i cinque indicatori del report 2021. Per ciascuno indico definizione operativa, unita’ di misura e soglie per il tier Elite<\/strong> dichiarate nel report.<\/p>\n

      \n
    • Deployment Frequency<\/strong> – quanto spesso il team rilascia codice in produzione. Elite<\/strong>: on demand<\/em>, piu’ deploy al giorno. Low<\/strong>: meno di un deploy ogni sei mesi.<\/li>\n
    • Lead Time for Changes<\/strong> – tempo che intercorre tra il commit del codice e il suo rilascio in produzione. Elite<\/strong>: meno di un’ora. Low<\/strong>: oltre sei mesi.<\/li>\n
    • MTTR<\/strong> (Mean Time To Restore) – tempo medio per ripristinare il servizio dopo un incidente in produzione. Elite<\/strong>: meno di un’ora. Low<\/strong>: oltre sei mesi.<\/li>\n
    • Change Failure Rate<\/strong> – percentuale di deploy che causano un degrado del servizio (rollback, hotfix, incident). Elite<\/strong>: 0-15%. Low<\/strong>: 46-60%.<\/li>\n
    • Reliability<\/strong> (nuova 2021) – misura quanto le promesse fatte agli utenti (SLA<\/strong>, SLO<\/strong>) vengono rispettate, includendo disponibilita’, latenza e correttezza.<\/li>\n<\/ul>\n

      La quinta metrica nasce dall’osservazione che molti team raggiungevano tier Elite<\/strong> sui primi quattro KPI ma fallivano nel mantenere la promessa di affidabilita’ verso l’utente: deployare 50 volte al giorno non serve se il servizio e’ instabile. La Reliability<\/strong> riallinea la velocita’ al valore percepito.<\/p>\n

      Elite vs Low performer: il moltiplicatore 973x<\/h2>\n

      Il dato piu’ impressionante del report 2021 e’ il differenziale tra tier Elite<\/strong> e tier Low<\/strong>: i primi rilasciano codice in produzione 973 volte piu’ spesso<\/strong> dei secondi. Hanno un Lead Time<\/strong> piu’ breve di un fattore 6.570x<\/strong> e si recuperano dagli incidenti 6.570 volte piu’ velocemente<\/strong>. Numeri che sembrano usciti da una presentazione marketing, ma che derivano da survey peer-reviewed.<\/p>\n

      I quattro tier sono Elite<\/strong>, High<\/strong>, Medium<\/strong>, Low<\/strong>. Nel 2021 circa il 26%<\/strong> dei rispondenti si colloca nel tier Elite<\/strong>, il 40%<\/strong> in High<\/strong>, il 28%<\/strong> in Medium<\/strong> e solo il 7%<\/strong> in Low<\/strong>. Il dato e’ incoraggiante: due terzi dei team mondiali ha gia’ superato la soglia di “deploy multipli a settimana”.<\/p>\n

      Per una PMI<\/strong> italiana il riferimento realistico nei primi 6-12 mesi e’ il tier High<\/strong>: deploy giornalieri o quasi, lead time di un giorno, MTTR<\/strong> sotto le 24 ore, CFR<\/strong> sotto il 20%. Saltare direttamente a Elite<\/strong> richiede investimenti in automazione, infrastruttura e cultura che raramente si giustificano per progetti monolitici o legacy.<\/p>\n

      Come misurare Deployment Frequency in una PMI<\/h2>\n

      La Deployment Frequency<\/strong> e’ il KPI piu’ semplice da misurare e quello con cui partire. Bastano tre fonti dati: tag git<\/strong>, log della pipeline CI\/CD<\/strong>, registro deploy del sistema di orchestrazione.<\/p>\n

      In GitLab<\/strong> bastano due colpi di SQL sul database delle pipeline o un export via API. GitHub Actions<\/strong> offre da fine 2020 un endpoint REST per i workflow run filtrabili per environment. Jenkins<\/strong> espone via plugin “Build History” un report mensile. Se usi CircleCI<\/strong>, l’orb ufficiale espone metriche su pipeline e job.<\/p>\n

      Il consiglio operativo e’ definire fin da subito cosa conta come “deploy”. Solo produzione? Anche staging? Solo deploy completi o anche feature flag attivati a runtime? Senza una definizione condivisa, due team della stessa PMI<\/strong> finiscono per misurare cose diverse e confrontarsi diventa impossibile. Nella nostra esperienza la definizione piu’ utile e’ “ogni push in produzione che cambia comportamento osservabile dall’utente, inclusi gli attivatori di feature flag”.<\/p>\n

      Come misurare Lead Time for Changes<\/h2>\n

      Il Lead Time for Changes<\/strong> e’ la metrica piu’ delicata perche’ richiede di tracciare la storia di ogni commit dal momento in cui entra in main<\/code> fino al rilascio in produzione. Strumenti come LinearB<\/strong>, Sleuth<\/strong> e Faros AI<\/strong> (quest’ultimo lanciato a gennaio 2021) lo calcolano in automatico correlando eventi git, ticket Jira e deploy.<\/p>\n

      Se preferisci un approccio fatto in casa, la formula e’ semplice: per ogni release, prendi il timestamp del primo commit incluso e quello del deploy, poi calcola la mediana e il 95esimo percentile su una finestra mensile. La mediana e’ utile per il trend, il p95 per individuare i bottleneck.<\/p>\n

      Un Lead Time alto in una PMI<\/strong> ha sempre la stessa causa: troppe review manuali, ambienti di staging instabili, batch di rilascio mensili. La cura e’ altrettanto nota: trunk-based development<\/em>, feature flag, deploy continui. La transizione richiede tempo e un buy-in del business: bisogna spiegare a vendite e marketing che la frequenza alta non significa “rilasciare codice rotto”, ma “rilasciare piu’ piccoli incrementi controllati”.<\/p>\n

      \"Cronometro<\/p>\n

      Come misurare MTTR e gestire l’incident response<\/h2>\n

      Il MTTR<\/strong> (Mean Time To Restore, da non confondere con MTTR-repair) si calcola sommando il tempo tra l’apertura di un incident e la sua risoluzione conclamata, diviso per il numero di incident in un periodo. La precondizione e’ avere un processo di incident management<\/em> tracciato: senza ticket aperti su PagerDuty<\/strong>, Opsgenie<\/strong> o un canale Slack dedicato, qualsiasi misura e’ una stima.<\/p>\n

      Per una PMI<\/strong> con due-tre sviluppatori in on-call, il setup minimo prevede: un canale di alert (Datadog<\/strong>, Grafana<\/strong>, New Relic<\/strong>), una rotazione settimanale documentata, una postmortem template e un registro condiviso degli incident. Datadog ha introdotto nel corso del 2021 una DORA dashboard<\/em> in preview che calcola MTTR<\/strong> e Change Failure Rate<\/strong> correlando deploy events e monitor.<\/p>\n

      Un errore frequente e’ considerare “incident” solo quanto viene dichiarato esplicitamente dal team. Per metriche affidabili serve definire a priori<\/em> una soglia tecnica: per esempio “ogni alert P1\/P2 che dura piu’ di 10 minuti e che ha generato un ticket”. Le micro-degradazioni risolte in 30 secondi non hanno bisogno di entrare nel calcolo, altrimenti il MTTR<\/strong> diventa rumore.<\/p>\n

      Come misurare Change Failure Rate<\/h2>\n

      Il Change Failure Rate<\/strong> e’ il KPI piu’ politicamente sensibile, perche’ tocca la qualita’ del lavoro del team. Si calcola dividendo il numero di deploy che hanno richiesto rollback, hotfix o causato incident attribuibili nei n<\/em> giorni successivi, per il totale dei deploy nello stesso periodo.<\/p>\n

      La parola chiave e’ “attribuibili”: serve un meccanismo per collegare un incident al deploy che l’ha causato. Sleuth<\/strong> e LinearB<\/strong> lo fanno tracciando deploy markers<\/em> nei sistemi di monitoring. Se preferisci una soluzione artigianale, ti basta una tabella su BigQuery o un foglio condiviso aggiornato durante la postmortem.<\/p>\n

      Le soglie del report 2021 sono: Elite<\/strong> 0-15%, High<\/strong> 16-30%, Medium<\/strong> 16-30%, Low<\/strong> 46-60%. Per una PMI<\/strong> che parte da zero, un CFR<\/strong> del 30% e’ un buon obiettivo a 6 mesi. Se sei sopra il 40% non e’ un problema di metriche ma di processo: probabilmente mancano test automatici, review strutturate o canary release.<\/p>\n

      Tools 2021 per DORA metrics: ecosistema maturo<\/h2>\n

      Nel 2021 il mercato dei tool per DORA si e’ affollato di soluzioni specializzate. Vediamo le opzioni piu’ rilevanti per una PMI<\/strong> software house.<\/p>\n

        \n
      • GitLab<\/strong> – Value Stream Analytics nativo da Premium tier, calcola Lead Time, deploy frequency e cycle time. Ideale se gia’ usi GitLab CI.<\/li>\n
      • GitHub<\/strong> – Insights e Code Scanning, integrazione con GitHub Actions per metriche deploy. Per il calcolo completo DORA serve un layer aggiuntivo.<\/li>\n
      • Jenkins<\/strong> – plugin “Build History Metrics” e “Performance” per dashboard custom. Storicamente la scelta dell’enterprise on-premise.<\/li>\n
      • CircleCI<\/strong> – Insights nativo da inizio 2020, mostra success rate, duration e throughput per pipeline.<\/li>\n
      • Datadog<\/strong> – DORA dashboard preview lanciata nel 2021, integra deploy events e APM per CFR<\/strong> e MTTR<\/strong>.<\/li>\n
      • LinearB<\/strong> – lanciato nel 2020, specializzato su DORA + workflow git. Pricing accessibile alle PMI<\/strong>.<\/li>\n
      • Sleuth<\/strong> – dal 2020, focus su deploy tracking e Change Failure Rate. Integrazione nativa con feature flag e monitoring.<\/li>\n
      • Faros AI<\/strong> – lanciato a gennaio 2021, piattaforma di engineering operations con DORA come prodotto core.<\/li>\n
      • Allstacks<\/strong> – analytics di engineering con visione predittiva, integra DORA con risk scoring.<\/li>\n
      • Pluralsight Flow<\/strong> e Jellyfish<\/strong> – alternative enterprise per organizzazioni piu’ grandi.<\/li>\n
      • Code Climate Velocity<\/strong>, Athenian<\/strong> – opzioni focalizzate su productivity engineering.<\/li>\n<\/ul>\n

        La scelta dipende da budget e maturita’. Una PMI<\/strong> che parte da zero puo’ iniziare con GitLab<\/strong> o GitHub<\/strong> nativo, integrare un cruscotto Datadog per stabilita’ e adottare LinearB<\/strong> o Sleuth<\/strong> quando serve un layer specifico DORA. Evita di comprare suite costose prima di aver chiarito chi guarda le dashboard e con quale frequenza.<\/p>\n

        DORA come baseline per Lean e Agile transformation<\/h2>\n

        Una delle scoperte piu’ importanti del filone di ricerca DORA<\/strong> e’ che le metriche non sono solo descrittive ma prescrittive: migliorarle implica adottare pratiche di Lean<\/strong> e Agile<\/strong> mature. Trunk-based development, infrastructure as code, test automation, observability, postmortem blameless: tutte pratiche che convergono nei KPI.<\/p>\n

        Per una PMI<\/strong> che sta avviando una trasformazione Agile, usare DORA come baseline e come “stella polare” e’ molto piu’ efficace di misurare velocity o burndown. Le metriche tradizionali Scrum descrivono “quanto lavoro abbiamo fatto”, le metriche DORA descrivono “quanto valore abbiamo consegnato in produzione”. E’ una differenza enorme: e’ la differenza tra produrre output e produrre outcome.<\/p>\n

        Un consiglio dal libro Accelerate<\/em> (Forsgren, Humble, Kim, 2018) e’ partire con un assessment, identificare il KPI piu’ debole e dedicare un trimestre a un esperimento mirato. La trasformazione DORA non e’ big bang: e’ una sequenza di piccole vittorie misurabili.<\/p>\n

        Errori comuni nell’adozione DORA<\/h2>\n

        Dopo decine di progetti di engineering transformation, gli errori ricorrenti che vediamo in PMI<\/strong> italiane sono pochi e ricorrenti.<\/p>\n

          \n
        • Vanity metrics<\/strong>: pubblicare numeri senza un piano di intervento. Un cruscotto DORA appeso al muro che nessuno commenta in retrospettiva e’ un costo, non un valore.<\/li>\n
        • No buy-in del team<\/strong>: imporre dall’alto le metriche senza spiegare il “perche'”. Il rischio e’ che il team ottimizzi i numeri (deployare cose vuote per gonfiare la frequency) anziche’ il valore.<\/li>\n
        • Comparazioni tra team disomogenei<\/strong>: confrontare un team che gestisce un microservizio con uno che lavora su un monolite e’ ingiusto e demotivante.<\/li>\n
        • Mancanza di improvement loop<\/strong>: senza un meeting mensile dedicato a interpretare i trend, le metriche scivolano nell’irrilevanza.<\/li>\n
        • Mescolare DORA con valutazioni di performance individuale<\/strong>: i KPI sono di team, non di persona. Usarli per bonus individuali distrugge la fiducia.<\/li>\n
        • Ignorare la Reliability<\/strong>: ottimizzare solo i primi quattro KPI puo’ portare a deploy frequenti ma instabili.<\/li>\n<\/ul>\n

          L’antidoto e’ un patto culturale: il cruscotto DORA appartiene al team, viene rivisto in retrospettiva ogni due o quattro settimane e ogni KPI debole genera un’azione concreta. Non slogan, non bonus, non politica.<\/p>\n

          \"Team<\/p>\n

          Relazione tra DORA e SRE Google: SLO, SLI, SLA<\/h2>\n

          La quinta metrica del 2021, la Reliability<\/strong>, e’ il ponte esplicito tra le pratiche DevOps<\/strong> e la disciplina SRE<\/strong> (Site Reliability Engineering) di Google. SLO<\/strong> (Service Level Objective), SLI<\/strong> (Service Level Indicator) e SLA<\/strong> (Service Level Agreement) sono i mattoni del libro Site Reliability Engineering<\/em> pubblicato da Google nel 2016.<\/p>\n

          Per una PMI<\/strong> che vuole adottare la Reliability metric, il punto di partenza e’ definire 2-3 SLI<\/strong> per ogni servizio critico: tipicamente disponibilita’ (uptime), latenza (p95) e tasso di errore. Per ciascuno si fissa un SLO<\/strong>: per esempio “99% di uptime mensile” o “latenza p95 sotto 300ms”. La differenza tra realta’ e SLO<\/strong> alimenta l’error budget<\/em>: lo spazio di “errore tollerato” che il team puo’ bruciare per innovare velocemente.<\/p>\n

          La logica e’ geniale: se l’error budget e’ ampio, il team puo’ deployare aggressivamente; se e’ esaurito, deve rallentare e investire in qualita’. E’ un sistema di auto-regolazione che incarna lo spirito DORA: velocita’ e stabilita’ non in conflitto ma in equilibrio dinamico.<\/p>\n

          Caso reale: PMI romana SaaS, da 1 deploy a settimana a 8 al giorno<\/h2>\n

          Per concretizzare, condivido il caso di una PMI<\/strong> romana, software house SaaS<\/strong> B2B con 14 sviluppatori, su cui abbiamo lavorato nel 2021. Stack: monorepo PHP\/Symfony, frontend Vue 2, infrastruttura AWS gestita via Terraform. Situazione iniziale:<\/p>\n

            \n
          • Deployment Frequency<\/strong>: 1 deploy a settimana, sempre il giovedi’ pomeriggio.<\/li>\n
          • Lead Time for Changes<\/strong>: 6 giorni in mediana, 18 al p95.<\/li>\n
          • MTTR<\/strong>: 4 ore in mediana, con picchi di 12 ore.<\/li>\n
          • Change Failure Rate<\/strong>: 38%.<\/li>\n<\/ul>\n

            Tier Medium<\/strong> al limite con il Low<\/strong> sul CFR<\/strong>. Il primo intervento e’ stato culturale: workshop di 2 giorni sul libro Accelerate<\/em>, definizione condivisa di “deploy” e setup di una dashboard Datadog<\/strong> condivisa con i quattro KPI. Poi, in sei mesi, gli interventi tecnici:<\/p>\n

              \n
            • migrazione da branch lunghi a trunk-based development con feature flag (Unleash<\/strong> self-hosted);<\/li>\n
            • introduzione di canary release con Kubernetes Argo Rollouts;<\/li>\n
            • refactoring della test suite (da 12 a 4 minuti di esecuzione, parallelizzazione su CircleCI<\/strong>);<\/li>\n
            • postmortem template e canale Slack dedicato per incident, rotazione on-call settimanale;<\/li>\n
            • training su observability con Datadog APM e log strutturati.<\/li>\n<\/ul>\n

              Dopo sei mesi, i numeri:<\/p>\n

                \n
              • Deployment Frequency<\/strong>: 8 deploy al giorno, distribuiti su tre microservizi.<\/li>\n
              • Lead Time for Changes<\/strong>: 2 ore in mediana, 8 al p95.<\/li>\n
              • MTTR<\/strong>: 22 minuti in mediana.<\/li>\n
              • Change Failure Rate<\/strong>: 12%.<\/li>\n<\/ul>\n

                Tier Elite<\/strong> su tre KPI, High<\/strong> sul Lead Time. Il punto chiave non sono i numeri assoluti, ma il modo: nessun outsourcing, nessun rewrite del monolite, nessun “DevOps engineer” assunto ad hoc. Solo pratiche, disciplina e una dashboard che il team controlla ogni venerdi’.<\/p>\n

                Roadmap DORA in 60 giorni: piano step-by-step<\/h2>\n

                Vediamo una roadmap concreta per una PMI<\/strong> che parte da zero e vuole avere un cruscotto DORA funzionante in 60 giorni.<\/p>\n

                Settimana 1-2: assessment.<\/strong> Mappa lo stato attuale leggendo log di GitLab\/GitHub e ticket di incident degli ultimi 90 giorni. Costruisci un foglio con i quattro KPI in valore mediano. Identifica il KPI piu’ debole.<\/p>\n

                Settimana 3-4: definizione operativa.<\/strong> Concorda con il team cosa conta come deploy, come incident, come hotfix. Documenta tutto in una pagina di Confluence\/Notion. Allinea aspettative con il management su tier target a 6 mesi.<\/p>\n

                Settimana 5-6: strumentazione.<\/strong> Implementa la dashboard. Per partire bastano due script Python che leggono API di GitLab\/GitHub e Datadog, e un cron che alimenta una tabella su BigQuery o un foglio Google. Non serve LinearB<\/strong> dal giorno 1.<\/p>\n

                Settimana 7-8: primo improvement loop.<\/strong> Retrospettiva dedicata a DORA: il team guarda i numeri, sceglie un’azione di miglioramento sul KPI piu’ debole, la incorpora nello sprint successivo. Ripeti ogni due settimane.<\/p>\n

                Settimana 9-10: socializzazione.<\/strong> Condividi il cruscotto con il management. Racconta il trend, non il numero assoluto. Allinea le aspettative: il miglioramento e’ graduale, ma costante.<\/p>\n

                Sessanta giorni dopo, dovresti avere: una dashboard funzionante, una baseline storica, un loop di miglioramento attivo e un team che comincia a sentire le metriche come proprie. Da qui in poi e’ tutto manutenzione e iterazione.<\/p>\n

                \n

                Come implementare DORA metrics in 5 step<\/p>\n

                  \n
                1. Assessment baseline<\/strong>: misura i 4 KPI con dati degli ultimi 90 giorni.<\/li>\n
                2. Definizione operativa<\/strong>: documenta cosa conta come deploy, incident, hotfix.<\/li>\n
                3. Dashboard MVP<\/strong>: integra GitLab\/GitHub + Datadog in un cruscotto condiviso.<\/li>\n
                4. Improvement loop<\/strong>: retrospettiva dedicata ogni 2 settimane.<\/li>\n
                5. Iterazione<\/strong>: aggiungi Reliability con SLI\/SLO quando i 4 KPI sono stabili.<\/li>\n<\/ol>\n<\/div>\n

                  FAQ – Domande frequenti su DORA metrics<\/h2>\n

                  Quali sono i 4 KPI delle DORA metrics?<\/strong><\/p>\n

                  I 4 KPI originali sono Deployment Frequency<\/strong>, Lead Time for Changes<\/strong>, MTTR<\/strong> e Change Failure Rate<\/strong>. Nel 2021 e’ stata aggiunta la Reliability<\/strong> come quinta metrica.<\/p>\n

                  Chi pubblica le DORA metrics?<\/strong><\/p>\n

                  Le DORA metrics sono pubblicate nel report annuale Accelerate State of DevOps<\/em> di Google Cloud, basato sulla ricerca del team DORA<\/strong> fondato da Forsgren, Humble e Kim. L’edizione 2021 ha raccolto oltre 36.000 risposte.<\/p>\n

                  Quanto deve essere alta la Deployment Frequency per essere Elite?<\/strong><\/p>\n

                  Il tier Elite<\/strong> richiede deploy on demand<\/em>, cioe’ multipli deploy al giorno. Il tier High<\/strong> e’ tra una volta al giorno e una a settimana.<\/p>\n

                  Una PMI italiana puo’ raggiungere il tier Elite?<\/strong><\/p>\n

                  Si’, ma richiede tipicamente 12-18 mesi di lavoro su automazione, cultura e infrastruttura. Un obiettivo realistico a 6 mesi e’ il tier High<\/strong>.<\/p>\n

                  Qual e’ la differenza tra MTTR e MTBF?<\/strong><\/p>\n

                  MTTR<\/strong> (Mean Time To Restore) misura quanto tempo serve per recuperare da un incidente. MTBF<\/strong> (Mean Time Between Failures) misura l’intervallo medio tra un guasto e il successivo. DORA usa MTTR<\/strong>.<\/p>\n

                  Quali tool gratuiti consigliate per iniziare con DORA?<\/strong><\/p>\n

                  Per partire: GitLab CE<\/strong> con Value Stream Analytics (per le pratiche di base), GitHub Insights<\/strong>, o uno script Python che legge le API e alimenta un foglio Google. Non serve subito un tool a pagamento.<\/p>\n

                  Le DORA metrics si possono usare per valutare i singoli sviluppatori?<\/strong><\/p>\n

                  No, e’ un errore. Le DORA metrics sono di team, non individuali. Usarle per valutazioni di performance personale distrugge la fiducia e incentiva comportamenti perversi.<\/p>\n

                  \n

                  Vuoi implementare un cruscotto DORA per la tua software house?<\/h3>\n

                  Brentasoft accompagna PMI software house e team engineering nell’adozione di DORA metrics, automazione CI\/CD e dashboard di engineering operations. Personalizziamo l’approccio sul tuo stack e sulla tua cultura.<\/p>\n

                  Scopri i gestionali personalizzati<\/a> Richiedi un preventivo<\/a><\/p>\n<\/div>\n