Yury Pukhov, YuSMP Group
Yury Pukhov CEO & Mobile Engineering Lead, YuSMP Group
Aggiungi YuSMP come fonte preferita su Google
TL;DR: La progettazione software è la fase in cui i requisiti diventano un progetto realizzabile: architettura, modello dei dati, interfacce, flussi utente e decisioni di sicurezza. Si colloca tra l’analisi dei requisiti e la scrittura del codice. Un buon design si articola in una parte di alto livello e una di basso livello, segue principi come SOLID e KISS ed è documentato in diagrammi, registri delle decisioni e contratti API che il team revisiona prima dello sviluppo.

La progettazione software è la parte di un progetto in cui il team decide come funzionerà il software prima di scriverlo. I requisiti dicono che cosa deve fare il prodotto. Il design risponde al come: quali componenti esistono, come comunicano tra loro, dove risiedono i dati, che cosa vede l’utente su ogni schermata e quali rischi vengono gestiti in anticipo. Anche il codice scritto senza questo progetto finisce per essere progettato, solo più tardi, per caso e a un prezzo più alto.

La maggior parte dei problemi costosi che riscontriamo nei progetti di recupero risale a questa fase: un modello di database che non regge un secondo tipo di cliente, un’API che espone la struttura interna, un’app mobile mai pensata per una connettività scarsa. Per questo i servizi di product engineering guidati dal design trattano progettazione e sviluppo software come un unico lavoro continuo, in cui la fase di progettazione è responsabile delle decisioni più difficili da invertire.

Questa guida è pensata per CTO, product owner e founder che stanno pianificando uno sviluppo o valutando il design di un fornitore. Tratta:

  • che cos’è la progettazione software e dove si colloca la fase di progettazione nel ciclo di vita dello sviluppo software;
  • progettazione software e architettura software a confronto, design di alto livello e di basso livello;
  • gli elementi di un design completo e perché questa fase ripaga il suo costo;
  • un processo di progettazione in 7 passi, i principi fondamentali e i pattern più utili;
  • i deliverable da richiedere, gli strumenti e come l’AI cambia il lavoro di design nel 2026;
  • gli errori comuni, una checklist di revisione, tempi tipici e costi.

Che cos’è la progettazione software?

La progettazione software è il processo che trasforma i requisiti in un piano tecnico da cui gli sviluppatori possono partire: la struttura del sistema, i componenti e le loro responsabilità, i modelli dei dati, le interfacce, i flussi utente e le regole che mantengono il codice manutenibile. Il risultato è un insieme di modelli e documenti, non codice funzionante.

Il termine copre due idee collegate. La prima è la fase di progettazione, una fase del progetto con un inizio, una fine e dei deliverable. La seconda è il design come attività continua: ogni pull request contiene piccole decisioni di design su nomi, confini e dipendenze. I team sani fanno entrambe le cose. Prendono deliberatamente nella fase di progettazione le decisioni grandi e costose da modificare, e lasciano quelle piccole a chi scrive il codice, guidato da principi condivisi.

In questa guida, progettazione software, sviluppo e progettazione software e design dello sviluppo software indicano lo stesso lavoro pratico: decidere la struttura di un prodotto prima di realizzarlo e mantenere visibili queste decisioni mentre cresce.

Dove si colloca la fase di progettazione dello sviluppo software nel ciclo di vita?

La fase di progettazione arriva dopo l’analisi dei requisiti e prima dell’implementazione. In un SDLC classico l’ordine è pianificazione, requisiti, progettazione, sviluppo, test, rilascio e manutenzione. Quindi, quando qualcuno chiede quale sia la prima fase del processo di sviluppo software, la risposta è la pianificazione e la raccolta dei requisiti, non il design: non si può progettare una soluzione finché non si conosce il problema.

Il design riceve tre input dalle fasi precedenti:

  • Requisiti funzionali: user story, casi d’uso o un documento dei requisiti di prodotto che descrive che cosa deve fare il sistema;
  • Requisiti non funzionali: prestazioni, disponibilità, sicurezza, conformità normativa, accessibilità e limiti di budget;
  • Vincoli: sistemi esistenti con cui integrarsi, competenze del team, regole di hosting e scadenze.

Consegna tre output allo sviluppo: un’architettura condivisa dal team, specifiche dettagliate per i moduli da realizzare per primi e il design delle interfacce (schermate e API) su cui i tester possono scrivere i casi di test. Nei progetti waterfall la fase di progettazione si chiude con un’approvazione formale. Nei progetti agile il design d’insieme avviene all’inizio e quello di dettaglio si ripete a ogni sprint, come spieghiamo nella sezione sull’agile più avanti.

Qual è la differenza tra progettazione software e architettura software?

L’architettura software è l’insieme delle decisioni di alto livello sulla struttura di un sistema che sono costose da cambiare; la progettazione software include l’architettura ma anche le decisioni di dettaglio all’interno di ogni componente. L’architettura chiede «quali grandi parti esistono e come comunicano?». Il design di dettaglio chiede «come funziona questa parte al suo interno?».

DimensioneArchitettura softwareProgettazione software di dettaglio
AmbitoL’intero sistema e il suo contestoUn componente, un modulo o una funzionalità
Decisioni tipicheMonolite o servizi, tipo di database, piattaforma cloud, stile di integrazione, modello di sicurezzaClassi e funzioni, strutture dati, algoritmi, endpoint API, gestione degli errori
Costo di una modifica successivaAlto: spesso settimane di rilavorazionePiù basso: di solito un refactoring locale
Responsabile principaleArchitetto o tech leadGli sviluppatori che realizzano il componente
Artefatti tipiciDiagrammi di contesto e dei container, ADR, diagramma di deploymentDiagrammi dei componenti e di sequenza, schemi, contratti API, pseudocodice
Guidata soprattutto daRequisiti non funzionali e vincoliRequisiti funzionali e principi di qualità del codice

Il confine tra le due è sfumato nei piccoli progetti, dove un solo ingegnere senior prende entrambi i tipi di decisione nella stessa settimana. Diventa netto nei grandi sistemi, dove una cattiva decisione architetturale, come dividere troppo presto in microservizi (si veda la nostra guida su monolite e microservizi), può costare più dell’intero lavoro di design di dettaglio.

Quali sono i livelli della progettazione software?

La progettazione software si svolge di solito su due livelli tecnici, il design di alto livello (HLD) e il design di basso livello (LLD), più un livello di interfaccia che copre l’esperienza utente e le API esterne. Ogni livello risponde a una domanda diversa per un pubblico diverso.

Design di alto livello (HLD)

Il design di alto livello descrive il sistema come un insieme di componenti principali e delle loro interazioni. Mostra applicazioni, servizi, database, sistemi di terze parti e i protocolli tra di essi, insieme al modo in cui il sistema viene distribuito. Il suo pubblico è l’intero team, compresi product owner e stakeholder, quindi evita i dettagli a livello di codice. Un buon HLD sta in pochi diagrammi e spiega il ragionamento dietro ogni scelta importante.

Design di basso livello (LLD)

Il design di basso livello scompone ogni componente dell’HLD in dettagli implementabili: moduli e classi, tabelle e indici del database, endpoint API con la forma di richieste e risposte, macchine a stati, algoritmi e gestione degli errori. Il suo pubblico sono gli sviluppatori e i tester che realizzeranno e verificheranno quel componente. L’LLD viene spesso scritto poco prima che il componente sia sviluppato, così riflette le conoscenze più aggiornate.

Design dell’interfaccia e UX

Il design dell’interfaccia copre tutto ciò che un utente o un altro sistema tocca: flussi utente, wireframe, prototipi, il design system visivo e i contratti delle API pubbliche. È design in senso di prodotto più che in senso ingegneristico, ma appartiene alla stessa fase perché schermate e API danno forma al modello dei dati. Il nostro articolo su UX design e UI design spiega come le due discipline si dividono il lavoro.

Product designer che dispone schizzi di wireframe su carta e post-it su una scrivania in legno accanto a un portatile

Quali sono gli elementi chiave di una progettazione software?

Una progettazione software completa copre sei elementi: architettura, dati, interfacce, esperienza utente, sicurezza e infrastruttura. Se ne manca anche uno solo, la decisione verrà comunque presa, solo più tardi e sotto la pressione delle scadenze.

ElementoChe cosa definisceA quale domanda risponde
ArchitetturaI componenti, le loro responsabilità e il modo in cui comunicanoQuali sono le grandi parti e dove passano i confini?
Design dei datiEntità, relazioni, motori di archiviazione, conservazione e migrazioniChe cosa archiviamo, dove e come cambia nel tempo?
Design delle interfacceAPI interne e pubbliche, eventi, formati di file, contratti di integrazioneCome si scambiano i dati componenti e partner?
UX e UI designFlussi utente, wireframe, prototipi, design system, accessibilitàChe cosa vede e fa ogni utente?
Design della sicurezzaAutenticazione, autorizzazione, cifratura, threat model, audit trailChe cosa può andare storto e come lo preveniamo o rileviamo?
Design dell’infrastrutturaHosting, ambienti, CI/CD, osservabilità, scalabilità e backupDove gira e come lo gestiamo?

La scelta dello stack tecnologico attraversa diversi di questi elementi. Dovrebbe derivare da essi, non precederli: scegliere prima un framework e adattarvi il design è uno degli errori elencati più avanti in questa guida.

Perché il design è decisivo nello sviluppo e progettazione software?

La progettazione software è importante perché le decisioni prese in questa fase determinano gran parte del costo di lungo periodo di un prodotto, e correggere un problema strutturale dopo il lancio costa molto più che correggerlo su un diagramma. Una revisione del design richiede ore. Ristrutturare un modello dei dati in produzione può richiedere mesi e spesso un piano di migrazione dedicato.

I numeri a livello di settore sono elevati. Il Consortium for Information and Software Quality (CISQ) ha stimato il costo della scarsa qualità del software negli Stati Uniti in circa 2,41 trilioni di dollari nel suo rapporto del 2022, con un debito tecnico accumulato di circa 1,52 trilioni di dollari. Non si tratta interamente di debito di design, ma le scorciatoie strutturali prese all’inizio ne sono una fonte importante.

Per un singolo prodotto, un buon design ripaga in cinque modi concreti:

  1. Costo delle modifiche più basso: confini chiari significano che una nuova funzionalità tocca un modulo invece di dieci.
  2. Consegne prevedibili: le stime sono più accurate quando il team sa quali componenti una story coinvolge.
  3. Meno incidenti in produzione: modalità di guasto, retry e limiti vengono considerati prima che li scoprano gli utenti.
  4. Onboarding più semplice: i nuovi sviluppatori imparano il sistema da diagrammi e registri delle decisioni, non da scavi archeologici nel codice.
  5. Indipendenza dal fornitore: un design documentato permette di cambiare team senza perdere il ragionamento alla base del sistema.

Come si progetta un software? Il processo di progettazione software in 7 passi

Il processo di progettazione software si svolge in sette passi: confermare i requisiti, definire gli attributi di qualità, abbozzare l’architettura, progettare dati e interfacce, progettare l’esperienza utente, dettagliare i primi componenti e revisionare. Nella pratica i passi si sovrappongono, ma saltarne uno di solito si traduce in rilavorazioni successive.

1. Confermare requisiti e vincoli

Il primo passo del design consiste nel riformulare i requisiti con parole proprie dei progettisti ed elencare i vincoli. Si passano in rassegna ogni ruolo utente e i suoi compiti principali, i sistemi esistenti, gli obblighi di conformità e il budget. Le lacune trovate qui costano poco; quelle trovate al quarto sprint no.

2. Definire gli attributi di qualità

Gli attributi di qualità trasformano desideri vaghi in obiettivi misurabili che guidano l’architettura. «Veloce» diventa «il 95% delle chiamate API sotto i 300 ms con 500 utenti simultanei». «Sicuro» diventa «controlli SOC 2, SSO, cifratura a livello di campo per i dati sanitari». Vanno ordinati per priorità, perché sono in conflitto: massima flessibilità e costo minimo raramente convivono nello stesso design.

3. Abbozzare l’architettura di alto livello

L’architettura di alto livello viene redatta in due o tre opzioni, confrontate con gli attributi di qualità, e se ne sceglie una registrando il ragionamento. A questo punto di solito bastano un diagramma di contesto C4 e un diagramma dei container. Ogni scelta significativa riceve un architecture decision record (ADR): contesto, decisione, alternative e conseguenze.

4. Progettare il modello dei dati e le interfacce

Il modello dei dati e le interfacce si progettano insieme, perché ciascuno vincola l’altro. Si definiscono le entità principali e le relazioni, si decide quali dati sono relazionali, quali a documento e quali basati su eventi, poi si scrivono i principali contratti API in un formato leggibile dalle macchine come OpenAPI. I contratti permettono di avviare in parallelo il lavoro su front-end, back-end e integrazioni.

5. Progettare l’esperienza utente

Il design dell’esperienza utente traduce i flussi di ogni ruolo in wireframe e in un prototipo cliccabile che utenti reali possono testare. Le ricerche sull’usabilità del Nielsen Norman Group indicano che un test con circa cinque utenti fa emergere la maggior parte dei problemi di usabilità di un design, e un prototipo consente di svolgere questi test prima che esista codice di produzione. Il design system della UI (componenti, spaziature, colori, stati) segue quando i flussi sono stabili.

6. Dettagliare i primi componenti (LLD)

Il design di basso livello si scrive per i componenti che verranno realizzati per primi, non per l’intero sistema in una volta. Include la struttura dei moduli, gli schemi con gli indici, i diagrammi di sequenza per i flussi complessi, la gestione degli errori e l’approccio ai test. I componenti successivi ricevono il loro LLD al momento giusto, quando il team ne sa di più.

7. Revisione, threat modeling e approvazione

La revisione del design verifica il risultato rispetto a requisiti e attributi di qualità prima che inizi lo sviluppo. Vanno coinvolti uno sviluppatore che lo realizzerà, un tester, un responsabile della sicurezza e il product owner. Si esegue un threat model leggero (ad esempio STRIDE) sui flussi di dati. Si registrano le domande aperte e la data entro cui devono avere risposta.

Quali sono i principi fondamentali della progettazione software?

I principi fondamentali della progettazione software sono SOLID, DRY, KISS e YAGNI, supportati dalla separazione delle responsabilità e dall’accoppiamento debole. Sono euristiche più che leggi: ciascuno previene un modo comune in cui il codice diventa difficile da modificare, e applicarne uno in modo dogmatico crea un problema diverso.

PrincipioChe cosa affermaChe cosa va storto senza di esso
Single Responsibility (S)Un modulo dovrebbe avere un solo motivo per cambiare«God class» in cui ogni modifica rischia di rompere qualcosa di non correlato
Open/Closed (O)Estendere il comportamento senza modificare codice già testatoOgni nuovo metodo di pagamento o tipo di report richiede di modificare uno switch centrale
Liskov Substitution (L)I sottotipi devono funzionare ovunque sia atteso il tipo baseCasi speciali e controlli sui tipi si diffondono nel codice
Interface Segregation (I)I client non dovrebbero dipendere da metodi che non usanoInterfacce sovradimensionate che impongono implementazioni vuote o fittizie
Dependency Inversion (D)Dipendere da astrazioni, non da implementazioni concreteLogica di business saldata a un database specifico o all’SDK di un fornitore
DRYOgni elemento di conoscenza ha un’unica rappresentazione autorevoleLa stessa regola implementata in tre modi e corretta in uno solo
KISSPreferire il design più semplice che soddisfa i requisitiAstrazioni ingegnose che nessun altro sa manutenere
YAGNINon sviluppare per esigenze che non si hanno ancoraSettimane spese in una flessibilità che non viene mai usata

Come SOLID si applica oltre il codice orientato agli oggetti

SOLID è nato per le classi orientate agli oggetti, ma le stesse idee valgono per servizi e moduli. Un microservizio con una sola responsabilità di business, un contratto pubblico stabile e dipendenze iniettate tramite configurazione segue SOLID a livello architetturale, anche se è scritto in un linguaggio funzionale.

Come DRY e KISS si bilanciano

DRY e KISS tirano in direzioni opposte, e un buon design li mantiene in equilibrio. Eliminare ogni duplicazione porta ad astrazioni che accoppiano funzionalità non correlate; mantenere tutto semplice può significare copiare logica. Una regola pratica usata da molti team: tollerare la duplicazione fino alla terza occorrenza, poi estrarla, e solo se le copie cambiano davvero per lo stesso motivo.

Separazione delle responsabilità e accoppiamento

La separazione delle responsabilità significa che ogni parte del sistema gestisce un solo aspetto del problema, come presentazione, regole di business o persistenza. Unita ad accoppiamento debole e alta coesione, è ciò che permette a un team di sostituire il provider di pagamento, aggiungere un client mobile o passare a un altro cloud senza riscrivere il nucleo.

Quali design pattern contano nella progettazione software?

I design pattern sono soluzioni collaudate e con un nome a problemi ricorrenti, e operano su due livelli: design pattern a livello di codice all’interno di un componente e pattern architetturali sull’intero sistema. Conoscerne i nomi è importante perché comprime le discussioni di design: «qui usiamo un adapter» dice in poche parole ciò che altrimenti richiederebbe un paragrafo.

Design pattern a livello di codice

Il libro della «Gang of Four» del 1994 ha catalogato 23 pattern orientati agli oggetti in tre gruppi, e la maggior parte è ancora in uso quotidiano:

  • I pattern creazionali controllano come vengono creati gli oggetti: Factory Method, Builder, Singleton (da usare con parsimonia).
  • I pattern strutturali compongono gli oggetti in strutture più grandi: Adapter, Facade, Decorator, Proxy.
  • I pattern comportamentali descrivono come collaborano gli oggetti: Strategy, Observer, Command, State.

Pattern architetturali

PatternIdeale perCompromesso principale
A strati (n-tier)Applicazioni aziendali con livelli chiari di UI, logica e datiSemplice da avviare, senza disciplina può diventare una «big ball of mud»
Monolite modulareLa maggior parte dei nuovi prodotti e degli MVPUn solo deployment; richiede confini tra moduli applicati con rigore
MicroserviziProdotti grandi con diversi team indipendentiScalabilità e rilasci indipendenti, costi operativi elevati
Event-drivenIntegrazioni, aggiornamenti in tempo reale, workflow tra sistemiAccoppiamento debole, debug e coerenza dei dati più difficili
Esagonale (ports and adapters)Domini con molte integrazioni esterneNucleo testabile, più interfacce da manutenere
ServerlessCarichi a picchi o a basso volume, codice di raccordoNessun server da gestire, cold start e vendor lock-in

Per la maggior parte dei nuovi prodotti partiamo da un monolite modulare con confini tra moduli ben definiti, ed estraiamo servizi solo quando un team o un’esigenza di scalabilità lo giustifica. Questa scelta predefinita mantiene bassi i costi operativi ed evita i problemi dei sistemi distribuiti prima che siano necessari.

Quali deliverable deve produrre la fase di progettazione software?

La fase di progettazione dovrebbe produrre un piccolo insieme di documenti vivi che un nuovo sviluppatore possa usare per capire ed estendere il sistema. Se la fase di progettazione del Suo fornitore si chiude con una presentazione e nient’altro, il lavoro di design non è stato davvero svolto.

Una checklist pratica dei deliverable:

  • Documento di progettazione software (SDD): una breve narrazione che lega insieme i pezzi, con i link a tutto ciò che segue;
  • Diagrammi architetturali: viste C4 di contesto e dei container, più un diagramma di deployment;
  • Architecture decision record: uno per ogni decisione significativa, comprese le alternative scartate;
  • Modello dei dati: diagramma entità-relazione, bozze dello schema, note su conservazione e migrazione dei dati;
  • Contratti API: specifiche OpenAPI o AsyncAPI per le interfacce interne ed esterne;
  • Artefatti UX: flussi utente, wireframe, un prototipo cliccabile e la prima versione del design system;
  • Requisiti non funzionali: obiettivi misurabili per prestazioni, disponibilità, sicurezza e accessibilità;
  • Threat model e design della sicurezza: flussi di dati, confini di fiducia, modello di autenticazione e autorizzazione;
  • Strategia di test: che cosa viene testato con unit test, test di integrazione e test end-to-end, e i quality gate nella CI.

Conservi questi documenti nel repository accanto al codice (Markdown, diagram-as-code), così cambiano nelle stesse pull request del sistema. I documenti di design archiviati in una wiki separata spesso diventano obsoleti perché nessuno li aggiorna quando il codice cambia.

Piccolo team di ingegneri in una sala riunioni che esamina insieme disegni stampati del design di sistema, con un ingegnere che indica un diagramma

Come funziona la progettazione software nello sviluppo agile?

Nello sviluppo agile il design si divide in una breve fase iniziale per le decisioni costose da modificare e in un design continuo durante gli sprint per tutto il resto. Il mito secondo cui i team agile «non progettano» nasce dal confondere il big design up front con qualsiasi forma di design.

AspettoWaterfallAgile
Quando avviene il designUna volta sola, come fase completa prima del codiceArchitettura all’inizio (spesso 1–4 settimane), dettaglio a ogni sprint
DocumentazioneSpecifica completa, approvazione formaleDocumenti snelli, ADR, diagrammi aggiornati insieme al codice
Gestione dell’incertezzaRisolta sulla carta prima dello sviluppoDesign spike e prototipi per testare le idee rischiose
Rischio principaleIl design è sbagliato e lo si scopre tardiL’architettura si erode sprint dopo sprint senza revisioni

Tre pratiche fanno funzionare il design nei team agile. I design spike sono esperimenti a tempo limitato che rispondono a una domanda tecnica prima di impegnarsi su un approccio. Gli ADR registrano ogni decisione nel momento in cui viene presa, così il ragionamento sopravvive ai cambi di team. Revisioni architetturali regolari, ad esempio una volta a trimestre, intercettano l’erosione prima che si consolidi. Anche pratiche come lo sviluppo guidato dai test fungono da strumenti di design, perché il codice difficile da testare è di solito strutturato male.

Quali strumenti si usano per la progettazione software nel 2026?

Gli strumenti di progettazione software rientrano in cinque gruppi: product design, diagrammi, diagram-as-code, design delle API e modellazione dei dati. Alla maggior parte dei team serve uno strumento per gruppo, non dieci strumenti dello stesso gruppo.

CategoriaStrumenti comuniUtilizzo
Product e UI designFigma, PenpotWireframe, prototipi, design system, handoff agli sviluppatori
Lavagne e diagrammiMiro, FigJam, draw.io, LucidchartWorkshop, prime bozze architetturali, diagrammi di flusso
Diagram-as-codeStructurizr (C4), Mermaid, PlantUMLDiagrammi architetturali, di sequenza e dei componenti versionati nel repository
Design delle APIOpenAPI con Swagger Editor o Stoplight, AsyncAPIInterfacce REST e a eventi contract-first, mock server
Modellazione dei datidbdiagram.io, DBeaver, funzioni ERD degli IDEDiagrammi entità-relazione e bozze di schema

Lo strumento conta meno dell’abitudine: i diagrammi che vivono nel repository, cambiano in pull request revisionate e sono richiamati dal README restano accurati. La nostra rassegna degli strumenti di sviluppo software per il 2026 copre la toolchain più ampia attorno al design.

Come sta cambiando l’AI la progettazione software nel 2026?

Gli assistenti AI oggi accelerano le parti meccaniche della progettazione software, come la stesura di diagrammi, modelli dei dati, specifiche API e documenti di design, ma le decisioni di compromesso richiedono ancora una persona responsabile. Nello Stack Overflow Developer Survey 2025, l’84% degli intervistati ha dichiarato di usare o di voler usare strumenti di AI nel proprio processo di sviluppo, quindi il lavoro di design si svolge sempre più spesso accanto a un assistente.

Dove l’AI aiuta nella fase di progettazione:

  • generare prime bozze di diagrammi C4 in Mermaid o PlantUML a partire da una descrizione scritta;
  • proporre modelli entità-relazione e scheletri OpenAPI a partire dalle user story;
  • riassumere lunghi documenti di requisiti ed elencare contraddizioni o casi mancanti;
  • suggerire minacce per un flusso di dati come input per una sessione di threat modeling.

Dove non sostituisce le persone: scegliere tra opzioni con veri compromessi di business, valutare che cosa è costoso da cambiare nel proprio contesto e assumersi le conseguenze. Il codice generato dall’AI accresce anche il valore del design, perché una struttura chiara e contratti espliciti sono ciò che mantiene coerente il codice scritto rapidamente dagli assistenti. I team che adottano assistenti senza confini solidi tendono ad accumulare duplicazioni più in fretta, esattamente ciò che il principio DRY descritto sopra intende prevenire.

Quali sono gli errori più comuni nella progettazione software?

Gli errori più comuni nella progettazione software sono progettare troppo o troppo poco, scegliere la tecnologia prima di aver capito il problema e trattare il design come un documento da scrivere una volta sola. Ciascuno costa poco da evitare e molto da correggere.

  1. Trascurare i requisiti non funzionali. Il sistema funziona nella demo e crolla con un carico 10 volte superiore, oppure non supera una revisione di sicurezza.
  2. Design guidato dalla tecnologia. Scegliere un framework o i microservizi perché sono popolari, poi piegare il problema per adattarlo.
  3. Over-engineering. Costruire sistemi di plugin, configurazioni multi-region e motori generici per esigenze che potrebbero non arrivare mai (YAGNI).
  4. Modello dei dati sottoprogettato. Trattare il database come un ripensamento, il che rende dolorosi reportistica, multi-tenancy e migrazioni.
  5. Nessun registro delle decisioni. Sei mesi dopo nessuno sa perché è stata fatta una scelta, quindi la si teme o la si inverte alla cieca.
  6. Progettare senza gli utenti. Saltare i test sui prototipi e scoprire i problemi di usabilità dopo aver sviluppato le schermate.
  7. Documentazione obsoleta. Diagrammi che descrivono il sistema come era stato pianificato, non com’è.

Come capire se una progettazione software è buona?

Una progettazione software è buona quando soddisfa gli attributi di qualità concordati, mantiene locali le modifiche più probabili e può essere compresa da uno sviluppatore che non era presente alle decisioni. Gran parte di questo si può verificare prima di scrivere codice con una revisione strutturata, e confermare dopo il rilascio con le metriche di delivery.

Domande per una revisione del design:

  • Ogni requisito principale corrisponde a un componente che ne è responsabile?
  • Ogni attributo di qualità è supportato da un meccanismo concreto (cache, code, repliche, cifratura)?
  • Quali sono le tre modifiche più probabili nel prossimo anno, e quanti componenti toccherebbe ciascuna?
  • Dove sono i single point of failure, e che cosa succede quando un servizio di terze parti non è disponibile?
  • Un nuovo sviluppatore riesce a spiegare il sistema dai diagrammi in 15 minuti?
  • Ogni decisione significativa è registrata con le sue alternative?

Dopo il rilascio, le metriche DORA (frequenza di deployment, lead time delle modifiche, tasso di fallimento delle modifiche e tempo di ripristino del servizio) mostrano se il design supporta consegne rapide e sicure. Un aumento del tasso di fallimento delle modifiche o del lead time indica spesso problemi di accoppiamento nel design. Per i sistemi più grandi, metodi formali come l’Architecture Tradeoff Analysis Method (ATAM) del SEI strutturano la stessa revisione attorno a scenari di business.

Quanto dura la fase di progettazione e quanto costa?

La fase di progettazione dura di solito da una a sei settimane, a seconda del numero di ruoli utente, integrazioni e requisiti di conformità. Nei nostri progetti, uno sviluppo piccolo con un solo flusso principale richiede circa una settimana di design, mentre un portale multi-modulo con integrazioni esterne richiede da quattro a sei settimane prima del primo sprint.

Tipo di progettoImpegno di design tipicoPrezzo di partenza YuSMP (sviluppo completo)
Landing page o progetto piccoloDa qualche giorno a 1 settimanada $1,100
Sistema aziendale1–2 settimaneda $2,900
Negozio online o marketplace2–4 settimaneda $5,800
Portale o servizio web4–6 settimaneda $10,400

I nostri progetti hanno perimetro fisso e sono quotati in USD, e la fase di progettazione è inclusa nel prezzo anziché fatturata a parte. Il preventivo finale dipende dal numero di sezioni, ruoli e integrazioni. Se sta confrontando dei fornitori, chieda quali deliverable di design sono inclusi: due preventivi con lo stesso totale possono nascondere quantità molto diverse di lavoro di design. La guida al processo di sviluppo software su misura mostra come il design si collega alle fasi successive.

Domande frequenti sulla progettazione software

Che cos’è la progettazione software?

La progettazione software è la fase in cui i requisiti vengono trasformati in un progetto tecnico: architettura, componenti, modello dei dati, interfacce, flussi utente e decisioni di sicurezza. Arriva dopo l’analisi dei requisiti e prima della scrittura del codice, e produce diagrammi, registri delle decisioni e specifiche da cui partono gli sviluppatori.

Che cosa avviene nella fase di progettazione dello sviluppo software?

Nella fase di progettazione il team conferma i requisiti, fissa obiettivi di qualità misurabili, sceglie un’architettura, progetta il modello dei dati e le API, crea wireframe e prototipi, scrive il design di basso livello dei primi componenti e revisiona il risultato, compreso un threat model, prima che inizi lo sviluppo.

Qual è la prima fase del processo di sviluppo software?

La prima fase del processo di sviluppo software è la pianificazione con la raccolta dei requisiti. Il design viene subito dopo: un team non può progettare una soluzione finché non comprende il problema, gli utenti, i vincoli e i criteri di successo.

Qual è la differenza tra design di alto livello e di basso livello?

Il design di alto livello mostra i componenti principali del sistema, come comunicano e come vengono distribuiti, per l’intero team. Il design di basso livello dettaglia un singolo componente: moduli, classi, tabelle del database, endpoint API, algoritmi e gestione degli errori, per gli sviluppatori che lo realizzano.

Quali sono i principali principi della progettazione software?

I principali principi della progettazione software sono i cinque principi SOLID (single responsibility, open/closed, Liskov substitution, interface segregation, dependency inversion), DRY, KISS e YAGNI, supportati da separazione delle responsabilità, accoppiamento debole e alta coesione.

Progettazione software e architettura software sono la stessa cosa?

No. L’architettura software è il sottoinsieme delle decisioni di design sulla struttura complessiva che sono costose da cambiare, come i confini tra servizi e la scelta del database. La progettazione software comprende anche le decisioni di dettaglio all’interno di ogni componente, che costano meno da modificare.

Quanto dura la fase di progettazione software?

La fase di progettazione software dura in genere da una a sei settimane. Un progetto piccolo con un solo flusso principale può richiedere una settimana; un portale con diversi ruoli, integrazioni e requisiti di conformità richiede di solito da quattro a sei settimane di design prima del primo sprint.

Fonti: standard, rapporti e metodi

Pubblicato il 17 novembre 2026. I dati dei sondaggi e le stime dei rapporti provengono dalle fonti citate. I prezzi di YuSMP Group sono prezzi di partenza pubblicati sulle nostre pagine dei servizi; i preventivi finali dipendono dal perimetro del progetto. Le tempistiche di design sono intervalli tipici dei nostri progetti, non garanzie.