snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-docs/l/it/user-guide/workflows/capabilities/send-emails-from-workflows.mdx

@@ -0,0 +1,167 @@
+---
+title: Invia email dai flussi di lavoro
+description: Invia automaticamente email personalizzate utilizzando le azioni dei flussi di lavoro.
+---
+
+Invia automaticamente email quando si verificano eventi specifici nel tuo CRM—dai il benvenuto ai nuovi contatti, effettua il follow-up delle opportunità o avvisa i membri del team.
+
+## Prerequisiti
+
+Prima di poter inviare email dai flussi di lavoro:
+
+1. Collega un account email in **Impostazioni → Account**
+2. Assicurati che l'account abbia le autorizzazioni di invio abilitate
+
+## Flusso di lavoro email di base
+
+### Esempio: Email di benvenuto per i nuovi contatti
+
+**Obiettivo**: Inviare un'email di benvenuto quando una nuova persona viene aggiunta al CRM.
+
+**Impostazione**:
+
+1. **Crea flusso di lavoro**: Vai su **Impostazioni → Flussi di lavoro** e fai clic su **+ Nuovo flusso di lavoro**
+
+2. **Aggiungi trigger**: Seleziona **Record creato** → **Persone**
+
+3. **Aggiungi l'azione Invia email**:
+   * Fai clic su **+** per aggiungere un'azione
+   * Seleziona **Invia email**
+   * Configura l'email:
+
+| Campo       | Valore                                 |
+| ----------- | -------------------------------------- |
+| **A**       | `{{trigger.object.email}}`             |
+| **Oggetto** | `Benvenuto in {{Your Company Name}}`   |
+| **Corpo**   | `Hi {{trigger.object.firstName}}, ...` |
+
+4. **Testa e attiva**: Esegui un test con un record di esempio, quindi attiva
+
+## Uso delle variabili nelle email
+
+Richiama i dati dai passaggi precedenti usando la sintassi `{{variable}}`:
+
+```text
+Hi {{trigger.object.firstName}},
+
+Thank you for connecting with us!
+
+Your company, {{trigger.object.company.name}}, is now in our system.
+
+Best regards,
+The Team
+```
+
+### Variabili disponibili dai trigger
+
+| Tipo di trigger              | Variabili comuni                       |
+| ---------------------------- | -------------------------------------- |
+| **Record creato/aggiornato** | `{{trigger.object.fieldName}}`         |
+| **Manuale**                  | `{{trigger.selectedRecord.fieldName}}` |
+| **Webhook**                  | `{{trigger.body.fieldName}}`           |
+
+## Avanzato: Email condizionali
+
+### Esempio: Email diverse in base all'origine del lead
+
+**Obiettivo**: Inviare email di benvenuto diverse in base alla provenienza del lead.
+
+**Impostazione**:
+
+1. **Trigger**: Record creato (Persone)
+
+2. **Aggiungi l'azione Filtro**:
+   * Condizione: `{{trigger.object.source}}` uguale a `"Website"`
+   * Se vero → continua con l'email di benvenuto per il sito web
+
+3. **Diramazione per altre origini**:
+   * Crea diramazioni parallele per origini diverse
+   * Ogni diramazione ha la propria azione Invia email
+
+## Inviare email a più destinatari
+
+### Esempio: Notifica al team quando un'opportunità viene chiusa
+
+**Obiettivo**: Inviare un'email al commerciale e al suo responsabile quando un'opportunità viene vinta.
+
+**Impostazione**:
+
+1. **Trigger**: Record aggiornato (Opportunità, Fase = "Chiusa vinta")
+
+2. **Cerca record**: Trova il responsabile del proprietario dell'opportunità
+
+3. **Invia email n. 1**: Al proprietario dell'opportunità
+   * A: `{{trigger.object.owner.email}}`
+   * Oggetto: `Congratulazioni per la chiusura di {{trigger.object.name}}!`
+
+4. **Invia email n. 2**: Al responsabile
+   * A: `{{searchRecords.manager.email}}`
+   * Oggetto: `Opportunità vinta: {{trigger.object.name}}`
+
+## Email di follow-up programmate
+
+### Esempio: Follow-up 3 giorni dopo la riunione
+
+**Obiettivo**: Inviare un'email di follow-up 3 giorni dopo la registrazione di una riunione.
+
+**Impostazione**:
+
+1. **Trigger**: Record creato (Attività, Tipo = "Riunione")
+
+2. **Azione di ritardo**: Attendi 3 giorni
+
+3. **Invia email**:
+   * A: Partecipante alla riunione
+   * Oggetto: Seguito alla nostra conversazione
+   * Corpo: Richiama i dettagli della riunione dal trigger
+
+## Allegati email
+
+Puoi allegare file alle email inviate dai flussi di lavoro. L'allegato è un file statico che carichi durante la configurazione del flusso di lavoro.
+
+### Come aggiungere un allegato
+
+1. Nell'azione **Invia email**, fai clic sul pulsante **Allegati**
+2. Fai clic per caricare un file dal tuo computer
+3. Il file verrà allegato a tutte le email inviate da questa azione
+
+### Casi d'Uso Comuni
+
+| Caso d'uso                 | File di esempio                    |
+| -------------------------- | ---------------------------------- |
+| **Email di benvenuto**     | Brochure aziendale (PDF)           |
+| **Sequenze di onboarding** | Guida per iniziare                 |
+| **Follow-up vendite**      | Catalogo prodotti o listino prezzi |
+| **Conferme degli eventi**  | Dettagli dell'evento o programma   |
+
+<Note>
+Gli allegati sono statici—lo stesso file viene inviato a tutti i destinatari. Per documenti dinamici (come i preventivi personalizzati), genera e allega i file utilizzando una [Funzione serverless](/l/it/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty).
+</Note>
+
+## Migliori Pratiche
+
+### Contenuto dell'email
+
+* Mantieni le righe dell'oggetto concise e pertinenti
+* Personalizza con il nome del destinatario
+* Includi una chiara chiamata all'azione
+* Testa le email prima di attivare
+
+### Recapito
+
+* Non inviare troppe email troppo rapidamente
+* Usa firme email professionali
+* Evita parole che attivano i filtri antispam
+* Assicurati che le email di marketing includano opzioni di disiscrizione
+
+### Risoluzione dei problemi
+
+* Verifica che l'account email sia connesso e attivo
+* Controlla che l'indirizzo email del destinatario sia valido
+* Esamina le esecuzioni dei flussi di lavoro per eventuali messaggi di errore
+* Prova prima con il tuo indirizzo email
+
+## Correlati
+
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)

packages/twenty-docs/l/it/user-guide/workflows/capabilities/use-branches-in-workflows.mdx

@@ -0,0 +1,88 @@
+---
+title: Usare le diramazioni nei flussi di lavoro
+description: Comprendi come funzionano le diramazioni e come controllare quale percorso viene eseguito.
+---
+
+## Come funzionano le diramazioni
+
+Nell'editor dei flussi di lavoro, puoi creare più percorsi (diramazioni) che partono da un singolo nodo. Questo ti consente di creare automazioni complesse con risultati diversi.
+
+**Importante**: Quando viene eseguito un flusso di lavoro, **tutte le diramazioni vengono eseguite in parallelo per impostazione predefinita**. Non esiste una logica "if/else" integrata per scegliere una diramazione rispetto a un'altra — ogni percorso verrà eseguito simultaneamente.
+
+## Controllare quale diramazione viene eseguita
+
+Per eseguire una sola diramazione in base a condizioni specifiche, **aggiungi un nodo Filtro all'inizio di ogni diramazione**.
+
+### Esempio di configurazione
+
+1. Crea il tuo flusso di lavoro con più diramazioni da un singolo nodo
+2. Aggiungi un nodo **Filtro** come primo passaggio in ogni diramazione
+3. Imposta le condizioni su ciascun Filtro per determinare quando quella diramazione deve continuare
+4. Procederanno solo le diramazioni per cui le condizioni del Filtro sono soddisfatte
+
+### Come funzionano i filtri
+
+* Se la condizione del Filtro è **soddisfatta**: la diramazione continua l'esecuzione
+* Se la condizione del Filtro **non è soddisfatta**: la diramazione si ferma al nodo Filtro
+
+Questo crea di fatto una logica condizionale in cui, in base ai tuoi dati, viene eseguita solo la diramazione appropriata.
+
+## Esempio: instradare in base al valore dell'opportunità
+
+**Scenario**: Quando un'opportunità viene chiusa, invia notifiche diverse in base al valore dell'opportunità.
+
+1. **Trigger**: Opportunità aggiornata (Fase = Chiusa vinta)
+2. **Diramazione 1**: Filtro per Importo > $10.000 → Invia un messaggio Slack a #big-deals
+3. **Diramazione 2**: Filtro per Importo ≤ $10.000 → Invia un'email al responsabile vendite
+
+Entrambe le diramazioni iniziano, ma solo quella che corrisponde all'importo dell'opportunità continuerà oltre il suo Filtro.
+
+## Creare le diramazioni
+
+<Note>
+Per creare una nuova diramazione da un passaggio esistente, fai clic sul pulsante **+** nel passaggio e aggiungi la tua azione. Puoi aggiungere più diramazioni facendo clic su **+** più volte.
+</Note>
+
+1. Nell'editor dei flussi di lavoro, seleziona il passaggio da cui vuoi creare la diramazione
+2. Fai clic su **+** per aggiungere un'azione
+3. Questo crea una diramazione
+4. Fai di nuovo clic su **+** sullo stesso passaggio per creare diramazioni aggiuntive
+5. Ogni diramazione può avere la propria sequenza di azioni
+
+## Riunire le diramazioni
+
+Dopo che le diramazioni parallele hanno completato il loro lavoro, puoi riunirle in un unico percorso:
+
+1. Completa le azioni nelle diramazioni
+2. Aggiungi un nuovo passaggio che deve essere eseguito dopo tutte le diramazioni
+3. Trascina una connessione dall'ultimo passaggio di ciascuna diramazione verso questo nuovo passaggio
+4. Il passaggio riunito attende il completamento di tutte le diramazioni collegate prima di essere eseguito
+
+### Esempio: elabora quindi notifica
+
+```
+Trigger
+   │
+   ├── Branch A: Update Customer Record
+   │
+   └── Branch B: Create Support Ticket
+
+       ↘  ↙
+
+   Merged Step: Send Confirmation Email
+```
+
+L'email di conferma viene inviata solo dopo che sia l'aggiornamento del cliente che la creazione del ticket sono stati effettuati.
+
+## Migliori Pratiche
+
+* Usa sempre i **nodi Filtro** all'inizio delle diramazioni quando desideri un'esecuzione condizionale
+* Mantieni le condizioni delle diramazioni **mutuamente esclusive** per evitare azioni duplicate
+* Testa i tuoi flussi di lavoro con dati diversi per assicurarti che vengano eseguite le diramazioni corrette
+* **Rinomina i passaggi delle diramazioni** in modo descrittivo, così è chiaro cosa fa ogni percorso
+* **Riunisci le diramazioni** quando ti serve un'azione finale dopo l'elaborazione parallela
+
+## Correlati
+
+* [Domande frequenti sui flussi di lavoro](/l/it/user-guide/workflows/how-tos/need-more-help/workflows-faq) — risposte sull'esecuzione parallela
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions) — azioni disponibili per le diramazioni

packages/twenty-docs/l/it/user-guide/workflows/capabilities/use-iterator.mdx

@@ -0,0 +1,183 @@
+---
+title: Usare Iterator
+description: Cicla attraverso array di record per eseguire azioni su ciascun elemento.
+---
+
+Iterator consente di scorrere un array di record ed eseguire azioni su ciascuno. È essenziale per i flussi di lavoro che devono elaborare più record restituiti da Search Records o ricevuti tramite webhook.
+
+## Quando utilizzare Iterator
+
+| Scenario                                | Esempio                                      |
+| --------------------------------------- | -------------------------------------------- |
+| **Elaborare i risultati della ricerca** | Invia un'email a ciascuna persona trovata    |
+| **Gestire array di webhook**            | Crea record per ciascun elemento nell'ordine |
+| **Aggiornamenti massivi**               | Aggiorna più record con valori calcolati     |
+| **Notifiche**                           | Avvisa più persone riguardo a un evento      |
+
+## Comprendere Iterator
+
+Iterator si aspetta un **array** come input. Quindi:
+
+1. Prende il primo elemento dall'array
+2. Esegue tutte le azioni all'interno dell'Iteratore con quell'oggetto
+3. Passa all'elemento successivo
+4. Ripete finché tutti gli elementi non sono stati elaborati
+
+### Selezionare l'array su cui iterare
+
+La maggior parte delle origini di array (Search Records, un campo array di un webhook, un trigger manuale Bulk) può essere selezionata direttamente nel selettore di variabili.
+
+Quando uno step **Code** o **Logic Function** restituisce un *array di primo livello*, il relativo output viene visualizzato nel selettore di variabili come voci indicizzate (`0`, `1`, `2`, …). Per iterare sull'intero array, seleziona l'opzione **Whole list** per quello step — l'Iterator deduce quindi automaticamente la struttura di ciascun elemento dall'elenco.
+
+## Configurazione di base
+
+### Esempio: inviare un'email a tutti nei risultati della ricerca
+
+**Obiettivo**: Trovare tutti i contatti in un'azienda specifica e inviare a ciascuno un'email personalizzata.
+
+### Passaggio 1: Cerca i record
+
+1. Aggiungi un'azione **Search Records**
+2. Oggetto: **Persone**
+3. Filtro: Azienda uguale a "Acme Inc"
+4. Questo restituisce un array di persone
+
+### Passaggio 2: Verifica che i risultati esistano
+
+1. Aggiungi l'azione **Filter**
+2. Condizione: `{{searchRecords.length}}` è maggiore di 0
+3. Questo evita errori di Iterator su risultati vuoti
+
+### Passaggio 3: Aggiungi un Iterator
+
+1. Aggiungi un'azione **Iterator**
+2. Input dell'array: Seleziona `{{searchRecords}}`
+3. Questo crea un ciclo
+
+### Passaggio 4: Aggiungi azioni all'interno di Iterator
+
+Le azioni posizionate sotto Iterator vengono eseguite per ciascun elemento:
+
+1. Aggiungi azione **Invia email** (dentro Iterator)
+2. A: `{{iterator.currentItem.email}}`
+3. Oggetto: Ciao `{{iterator.currentItem.firstName}}`!
+4. Corpo: Messaggio personalizzato utilizzando i campi dell'elemento corrente
+
+### Risultato
+
+Se Search Records restituisce 5 persone, Iterator:
+
+* Invia un'email alla persona 1
+* Invia un'email alla persona 2
+* ... continua per tutte e cinque
+
+## Accedere ai dati dell'elemento corrente
+
+All'interno di Iterator, usa `{{iterator.currentItem}}` per accedere al record corrente:
+
+| Variabile                               | Descrizione                                           |
+| --------------------------------------- | ----------------------------------------------------- |
+| `{{iterator.currentItem}}`              | L'intero oggetto del record corrente                  |
+| `{{iterator.currentItem.id}}`           | ID del record                                         |
+| `{{iterator.currentItem.email}}`        | Campo email                                           |
+| `{{iterator.currentItem.company.name}}` | Nome dell'azienda correlata                           |
+| `{{iterator.index}}`                    | Posizione corrente nell'array (indice a partire da 0) |
+
+Nel selettore di variabili, puoi esplorare un campo specifico dell'elemento corrente oppure scegliere **Use the whole item** per fare riferimento all'intero elemento corrente (`{{iterator.currentItem}}`). Selezionare l'intero elemento è utile quando vuoi passare un record completo direttamente a uno step a valle invece di ricostruirlo campo per campo.
+
+## Modelli comuni
+
+### Aggiornare più record
+
+**Obiettivo**: Contrassegnare tutte le attività in ritardo come "Late"
+
+```
+1. Search Records (Tasks, Due Date < Today, Status ≠ Completed)
+2. Filter (length > 0)
+3. Iterator (searchRecords)
+   └── Update Record
+       - Object: Tasks
+       - Record: {{iterator.currentItem.id}}
+       - Status: Late
+```
+
+### Creare record da un array
+
+**Obiettivo**: Il webhook riceve un ordine con più elementi e crea un record per ciascuno
+
+```
+1. Webhook Trigger (receives items array)
+2. Filter (items.length > 0)
+3. Iterator (trigger.body.items)
+   └── Create Record
+       - Object: Order Items
+       - Name: {{iterator.currentItem.name}}
+       - Quantity: {{iterator.currentItem.qty}}
+       - Related Order: {{trigger.body.orderId}}
+```
+
+### Elaborazione condizionale all'interno del ciclo
+
+**Obiettivo**: Inviare email solo ai contatti con indirizzi email validi
+
+```
+1. Search Records (People)
+2. Iterator (searchRecords)
+   └── Filter (currentItem.email is not empty)
+       └── Send Email
+           - To: {{iterator.currentItem.email}}
+```
+
+## Risoluzione dei problemi
+
+### "Iterator expects an array"
+
+**Causa**: Hai passato un singolo record invece di un array.
+
+**Soluzione**: Assicurati di passare il risultato di Search Records o un campo di tipo array, non un singolo record.
+
+```
+✅ Correct: {{searchRecords}}
+❌ Wrong: {{searchRecords[0]}}
+```
+
+### Iterator non viene eseguito
+
+**Causa**: L'array è vuoto.
+
+**Soluzione**: Aggiungi un'azione **Filter** prima di Iterator per verificare la lunghezza dell'array:
+
+```
+Filter: {{searchRecords.length}} > 0
+```
+
+### Le azioni vengono eseguite troppe volte
+
+**Causa**: Search Records ha restituito più record del previsto.
+
+**Soluzione**:
+
+* Aggiungi filtri più specifici a Search Records
+* Imposta un limite su Search Records (massimo 200)
+* Aggiungi **Filter** all'interno di Iterator per condizioni aggiuntive
+
+## Considerazioni sulle prestazioni
+
+* **Utilizzo dei crediti**: ogni iterazione consuma crediti per le sue azioni
+* **Tempo**: gli array di grandi dimensioni richiedono più tempo per essere elaborati
+* **Limiti**: prendi in considerazione l'esecuzione in batch di operazioni molto grandi
+* **Limiti di frequenza**: le chiamate API esterne potrebbero raggiungere i limiti di frequenza con molte iterazioni
+
+## Migliori Pratiche
+
+1. **Controlla sempre la lunghezza dell'array** prima di Iterator per evitare errori
+2. **Aggiungi filtri all'interno dei cicli** quando non è necessario elaborare tutti gli elementi
+3. **Rinomina il passaggio di Iterator** per descrivere ciò su cui sta scorrendo
+4. **Esegui test con array piccoli** prima di elaborare set di dati di grandi dimensioni
+5. **Monitora le esecuzioni dei flussi di lavoro** per assicurarti che le iterazioni si completino come previsto
+
+## Correlati
+
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Come utilizzare le diramazioni](/l/it/user-guide/workflows/capabilities/use-branches-in-workflows)
+* [Domande frequenti sui flussi di lavoro](/l/it/user-guide/workflows/how-tos/need-more-help/workflows-faq)

packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-actions.mdx

@@ -0,0 +1,332 @@
+---
+title: Azioni del workflow
+description: Scopri le azioni disponibili nei workflow di Twenty.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+## Informazioni sulle azioni
+
+Le azioni definiscono cosa accade dopo l'attivazione di un trigger. Puoi concatenare più azioni per creare automazioni complesse.
+
+<Tip>
+* Usa il selettore di variabili (fai clic sull'icona `(x+)`) per sfogliare i dati disponibili dai passaggi precedenti
+* Passa il mouse su qualsiasi campo di input per vedere da quale passaggio proviene una variabile — utile quando lo stesso campo (ad es., ID) esiste in più passaggi precedenti
+* Assegna a ogni azione un nome descrittivo per una manutenzione più semplice
+</Tip>
+
+## Azioni sui record
+
+<img src="/images/user-guide/workflows/workflow_actions.png" style={{width:'100%'}} />
+
+### Crea Record
+
+Aggiunge un nuovo record a un oggetto selezionato.
+
+**Configurazione:**
+
+* Seleziona l'oggetto di destinazione
+* Compila i campi richiesti e opzionali
+* Usa i dati dai passaggi precedenti oppure inserisci i valori manualmente per popolare i campi
+
+**Output**: I dati del nuovo record creato sono disponibili per l'uso in passaggi successivi.
+
+### Aggiorna Record
+
+Modifica un record esistente in un oggetto selezionato.
+
+<img src="/images/user-guide/workflows/update_record.png" style={{width:'100%'}} />
+
+**Configurazione:**
+
+* Seleziona l'oggetto di destinazione
+* Scegli il record specifico da aggiornare.
+  * Puoi scegliere un record fisso, utilizzando il menu a discesa che mostra tutti i record disponibili.
+  * Oppure puoi selezionare dinamicamente il record, indicando un record trovato in un passaggio precedente, usando `(x+)`. In questa fase non è possibile cercare il record in base a criteri diversi. Se non hai ancora identificato il record, aggiungi un passaggio `Search Record` prima di questo passaggio `Update Record`.
+* Seleziona i campi da modificare e inserisci nuovi valori
+
+**Output**: I dati del record aggiornato sono disponibili per l'uso in passaggi successivi.
+
+### Elimina Record
+
+Rimuove un record da un oggetto selezionato.
+
+**Configurazione**:
+
+* Seleziona l'oggetto di destinazione
+* Scegli il record specifico da eliminare
+
+**Output**: I dati del record eliminato rimangono disponibili per l'uso in passaggi successivi.
+
+### Cerca Record
+
+Trova i record all'interno di un oggetto selezionato utilizzando condizioni di filtro.
+
+**Configurazione**:
+
+* Seleziona l'oggetto da cercare
+* Imposta criteri di filtro per restringere i risultati
+* Configura l'ordinamento e i limiti
+
+**Output**: Restituisce i record corrispondenti utilizzabili in passaggi successivi.
+
+<Note>
+**Limite**: Search Records restituisce un massimo di **200 record**. Se devi elaborarne di più, aggiungi filtri specifici per ridurre i risultati oppure usa workflow pianificati per elaborare a lotti.
+</Note>
+
+**Migliore Pratica**: Usa [rami](/l/it/user-guide/workflows/capabilities/workflow-branches) dopo Search Records per gestire scenari "trovato" vs "non trovato".
+
+### Inserisci o aggiorna Record
+
+Crea un nuovo record o aggiorna uno esistente in base ai criteri di corrispondenza. È utile quando non sei sicuro che un record esista già.
+
+<img src="/images/user-guide/workflows/upsert_double_identifier.png" style={{width:'100%'}} />
+
+**Configurazione**:
+
+* Seleziona l'oggetto di destinazione
+* Tieni presente quali campi possono essere utilizzati per la corrispondenza: email per Persone, dominio per Aziende, ID per qualsiasi oggetto o qualsiasi campo contrassegnato come Univoco. Dovrai compilare almeno uno di questi qui sotto.
+* Compila i valori dei campi. Non dimenticare di valorizzare almeno uno degli identificatori univoci.
+
+<Note>
+**La corrispondenza di solito funziona ancora meglio aggiungendo un solo identificatore univoco.** Ad esempio, lo screenshot qui sotto abbinerà le aziende in base al loro dominio. L'ID non è necessariamente richiesto.
+</Note>
+
+<img src="/images/user-guide/workflows/upsert_simple_identifier.png" style={{width:'100%'}} />
+
+* Usa dati dai passaggi precedenti per popolare i campi
+
+**Come funziona**:
+
+1. Cerca un record che corrisponde ai tuoi criteri
+2. Se trovato → aggiorna il record esistente
+3. Se non trovato → crea un nuovo record
+
+**Output**: I dati del record creato o aggiornato sono disponibili per l'uso nei passaggi successivi.
+
+## Azioni del flusso
+
+### Iteratore
+
+**Esegue un ciclo su un array di record** restituito da un passaggio precedente, consentendo di eseguire azioni su ciascun record individualmente.
+
+**Configurazione**:
+
+* Selezionare l'array di record da un passo precedente (ad esempio, risultati da record di ricerca, da un trigger manuale con disponibilità di massa, da un nodo Codice). Quando un passaggio di tipo Code o Logic Function restituisce un array di primo livello, seleziona l'opzione **Whole list** per eseguire il loop su tutto l'output.
+* Definisci le azioni da eseguire su ciascun record nel ciclo.
+
+<Note>
+- È possibile aggiungere diverse azioni all'interno di un Iterator.
+- Quando si utilizzano rami all'interno di un Iterator, assicurarsi che l'ultimo passo di ogni ramo si connetta all'Iteratore per chiudere il ciclo.
+</Note>
+
+* Accedi ai campi di `Current Item`: per utilizzare i campi del record attualmente in elaborazione, fai clic sul passaggio **Iterator**, quindi seleziona **Current item**. Verrà visualizzato l'elenco dei campi disponibili di quel record e potrai selezionarli per l'uso nelle azioni successive. Puoi anche selezionare **Use the whole item** per passare l'intero elemento corrente a un passaggio a valle.
+
+<VimeoEmbed videoId="1146577247" title="Dimostrazione video" />
+
+### Filtro
+
+Filtra i record in base a condizioni specificate, consentendo il passaggio solo ai record che soddisfano i criteri.
+
+**Configurazione**:
+
+* Seleziona il record da filtrare
+* Definisci le condizioni e i criteri di filtro
+* Configura quali record devono passare ai passaggi successivi
+
+<Note>
+1. **Output**: I nodi filtro non restituiscono dati — agiscono come porte di accesso. Se le condizioni sono soddisfatte, il flusso di lavoro continua. In caso contrario, il flusso di lavoro si interrompe in quel ramo.
+2. L'operatore `IS` può essere utilizzato con i campi numerici. Funziona come `EQUAL`.
+</Note>
+
+### Ritardo
+
+Mette in pausa l'esecuzione del flusso di lavoro per una durata specificata o fino a una data/ora specifica.
+
+**Tipi di ritardo**:
+
+| Tipo                 | Descrizione                                                                |
+| -------------------- | -------------------------------------------------------------------------- |
+| **Durata**           | Attendi per una quantità di tempo specifica (giorni, ore, minuti, secondi) |
+| **Data programmata** | Attendi fino a una data e un'ora specifiche                                |
+
+**Configurazione della durata**:
+
+* Imposta giorni, ore, minuti e/o secondi
+* Combina più unità (ad es., 2 giorni e 4 ore)
+
+**Configurazione della data programmata**:
+
+* Seleziona una data e un'ora
+* Può fare riferimento a un campo data di un passaggio precedente (ad es., follow-up 3 giorni dopo una riunione)
+
+**Casi di utilizzo**:
+
+* Attendi 24 ore prima di inviare un'email di follow-up
+* Metti in pausa fino alla data di chiusura di un'opportunità
+* Pianifica azioni per l'orario lavorativo
+
+<Note>
+La data programmata non può essere nel passato. Se viene utilizzato un campo data di un passaggio precedente e la data è già passata, il flusso di lavoro non riuscirà.
+</Note>
+
+**Limiti e crediti**:
+
+* **Nessun limite massimo di durata** — puoi impostare ritardi di minuti, giorni, settimane o oltre
+* **1 credito consumato** quando il nodo Ritardo viene eseguito, indipendentemente dalla durata
+* **Nessun credito consumato** durante l'attesa — un ritardo di 5 minuti costa come un ritardo di 5 giorni
+
+## Azioni di comunicazione
+
+### Invia email
+
+Invia un'email dal tuo flusso di lavoro. Ottimo per email di gruppo basate su modelli. Le email avranno l'aspetto di quelle inviate dalla tua casella di posta.
+Non è adatto per le newsletter (che richiedono una formattazione più ricca) o le sequenze automatiche di posta elettronica.
+
+**Prerequisiti**: Aggiungi un account email in Impostazioni → Account
+
+**Configurazione**:
+
+* Seleziona l'account email del mittente
+
+<Note>
+Puoi inviare email solo dalle caselle di posta sincronizzate con il tuo account Twenty. L'invio dalle caselle di posta di altri membri del team (ad es., l'email del proprietario dell'account) è nella roadmap.
+</Note>
+
+Per tutti i passaggi seguenti, puoi fare riferimento a variabili dei passaggi precedenti per la personalizzazione.
+
+* Inserisci l'indirizzo email del destinatario.
+
+<Note>
+Al momento è possibile un solo destinatario.
+</Note>
+
+* Imposta l'oggetto della email.
+* Componi il corpo del messaggio. È possibile formattare i collegamenti, creare liste numerate, elenchi punti puntati e aggiungere allegati.
+
+<Note>
+Al momento non è possibile aggiungere firme HTML.
+</Note>
+
+### Modulo
+
+Visualizza un modulo durante l'esecuzione del flusso di lavoro per raccogliere l'input dell'utente. Le risposte possono quindi essere utilizzate nei passaggi successivi per creare record, inviare email o eseguire qualsiasi altra azione basata sull'input.
+
+<Warning>
+**I moduli sono progettati solo per i trigger manuali**. Per i flussi di lavoro con altri trigger (Record Creato, Aggiornato, ecc.), i moduli sono accessibili solo tramite l'interfaccia di esecuzione del flusso di lavoro, il che non è l'esperienza utente prevista. Un centro di notifica sarà rilasciato nel 2026 per supportare adeguatamente i moduli nei flussi di lavoro automatizzati.
+</Warning>
+
+**Configurazione**:
+
+* Configura i campi che verranno chiesti agli utenti di compilare. Per ogni campo, scegli
+  * un tipo tra testo, numero, data, un determinato record, un campo di selezione. I campi di tutti gli oggetti sono disponibili per la selezione.
+  * un'etichetta
+  * un valore predefinito sotto `Placeholder` (opzionale)
+* Modifica il titolo del modulo
+
+**Output**: Le risposte ai moduli sono disponibili per l'uso in passaggi successivi.
+
+**Esempio**: Il flusso di lavoro "Quick Lead" è disponibile per impostazione predefinita in tutti gli spazi di lavoro, disponibile ovunque nel menu dei comandi `Cmd+K`.
+
+**Come compilare il modulo**:
+
+* Attiva il tuo flusso di lavoro manuale dal menu dei comandi `Cmd+K`
+* Compila il modulo visualizzato nel pannello laterale e fai clic su `Submit`.
+
+<Note>
+I campi non possono essere resi obbligatori.
+</Note>
+
+<VimeoEmbed videoId="1147277989" title="Dimostrazione video" />
+
+## Azioni di integrazione
+
+### Codice
+
+Esegue JavaScript personalizzato all'interno del tuo workflow.
+
+In background, ogni azione Code è supportata dalla propria **logic function**, una funzione TypeScript lato server che viene eseguita sulla piattaforma Twenty. Quando aggiungi un'azione Code, Twenty crea una logic function dedicata per quel passaggio e ne espone l'editor inline, in modo che il codice che scrivi rimanga all'interno del flusso di lavoro.
+
+**Configurazione**:
+
+* Accedi alle variabili dai passaggi precedenti. È possibile modificare i nomi delle variabili dinamicamente.
+
+<VimeoEmbed videoId="1147281795" title="Dimostrazione video" />
+
+* Scrivi il codice JavaScript nell'editor
+* Restituisci variabili per l'uso in passaggi successivi
+* Verifica il codice direttamente nel passaggio
+
+<Note>
+Se devi utilizzare chiavi API esterne nel tuo codice, devi inserirle direttamente nel corpo della funzione. Non puoi configurare le chiavi API altrove e farvi riferimento nella funzione logica.
+</Note>
+
+<Tip>
+**Lavori con gli array?** Gli array provenienti da sistemi esterni o da passaggi precedenti possono arrivare come stringhe. Vedi [Come gestire gli array nelle azioni Code](/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions) per la soluzione.
+</Tip>
+
+<Tip>
+Fai clic sull'icona quadrata in alto a destra dell'editor di codice per visualizzarlo a schermo intero — utile poiché la larghezza predefinita dell'editor è limitata.
+</Tip>
+
+#### Riutilizzare una logic function tra i flussi di lavoro
+
+L'azione Code inline è ideale per la logica "usa e getta", ma il codice che contiene appartiene a quel singolo passaggio. Quando vuoi condividere la stessa logica tra vari flussi di lavoro o mantenerla come sorgente versionata in un'app, definisci una **reusable logic function** al posto di copiare e incollare il codice in ogni azione Code.
+
+Una logic function è definita una volta in un'app (usando l'SDK `defineLogicFunction`) ed esposta al generatore di flussi di lavoro aggiungendo `workflowActionTriggerSettings`. Una volta installata l'app, quella funzione compare come azione autonoma nel generatore di flussi di lavoro, insieme alle azioni integrate. Selezionandola, vengono mostrati i campi di input che hai dichiarato (con i selettori di variabili, proprio come per le altre azioni) e viene eseguito il tuo codice condiviso, senza bisogno di JavaScript inline.
+
+|                            | Code action                                                       | Reusable logic function                                                          |
+| -------------------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| **Dove risiede il codice** | Editor inline, legato a un singolo passaggio del flusso di lavoro | Definita in un'app, sottoposta a versionamento nel controllo del codice sorgente |
+| **Riutilizzo**             | Copiata e incollata per ogni passaggio                            | Aggiunta come azione in qualsiasi flusso di lavoro                               |
+| **Input**                  | Variabili collegate nell'editor                                   | Campi generati dallo schema di input dichiarato                                  |
+| **Ideale per**             | Logica rapida e specifica del flusso di lavoro                    | Logica condivisa usata in più flussi di lavoro                                   |
+
+Entrambe vengono eseguite sullo stesso runtime di logic function, quindi un'azione Code che hai prototipato inline può in seguito essere trasformata in una reusable logic function con modifiche minime.
+
+<Tip>
+Per le informazioni di riferimento destinate agli sviluppatori sulla definizione delle logic function e sulla loro esposizione al generatore di workflow, vedi [Logic Functions](/l/it/developers/extend/apps/logic/logic-functions), in particolare la sezione **Exposing a function as an AI tool or workflow action** e `workflowActionTriggerSettings`.
+</Tip>
+
+### Richiesta HTTP
+
+Invia una richiesta a un API esterno come parte del tuo workflow.
+
+<img src="/images/user-guide/workflows/http_action.png" style={{width:'100%'}} />
+
+**Configurazione**:
+
+* Inserisci l'URL del punto finale dell'API. È possibile utilizzare parametri dai passaggi precedenti.
+* Seleziona metodo HTTP (GET, POST, PUT, PATCH, DELETE)
+* Aggiungi intestazioni e valori richiesti
+* Fornisci una risposta di esempio per l'anteprima della struttura
+
+## Azioni AI
+
+### Agente AI - In arrivo
+
+Esegue un agente AI all'interno del tuo flusso di lavoro per svolgere attività intelligenti.
+
+**Configurazione**:
+
+* **Agente**: Seleziona un agente AI esistente o usa l'agente predefinito
+* **Prompt**: Scrivi l'istruzione per l'agente AI
+* Fai riferimento a variabili dei passaggi precedenti nel prompt
+
+**Cosa possono fare gli agenti AI**:
+
+* Analizzare e riassumere dati
+* Classificare o categorizzare i record
+* Generare contenuti testuali
+* Prendere decisioni basate sui dati
+* Interagire con i dati del tuo CRM utilizzando strumenti
+
+**Output**: La risposta dell'agente AI è disponibile per l'uso nei passaggi successivi. Se l'agente ha uno schema di output strutturato, la risposta seguirà tale formato.
+
+<Note>
+Le azioni dell'agente AI consumano crediti del flusso di lavoro in base al modello AI utilizzato. Vedi [Crediti del flusso di lavoro](/l/it/user-guide/workflows/capabilities/workflow-credits) per i dettagli.
+</Note>
+
+<Note>
+Gli agenti AI rispettano le autorizzazioni basate sui ruoli. Puoi assegnare ruoli specifici agli agenti in **Impostazioni → Membri → Ruoli** per controllare a quali dati possono accedere. Vedi [Autorizzazioni](/l/it/user-guide/permissions-access/capabilities/permissions) per i dettagli.
+</Note>

packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-branches.mdx

@@ -0,0 +1,66 @@
+---
+title: Rami Di Workflow
+description: Crea percorsi paralleli e logica condizionale nei tuoi flussi di lavoro.
+---
+
+I rami ti consentono di suddividere il tuo workflow in più percorsi che possono essere eseguiti simultaneamente o in modo condizionale in base ai tuoi dati.
+
+<img src="/images/user-guide/workflows/branches.png" style={{width:'100%'}} />
+
+## Come funzionano i rami
+
+Quando crei più connessioni da un singolo nodo, ogni percorso diventa un ramo. Per impostazione predefinita, **tutti i rami vengono eseguiti in parallelo**—non si attendono a vicenda.
+
+## Creazione dei rami
+
+### Aggiungi un nuovo ramo
+
+1. **Fai clic con il tasto destro sull'area di lavoro principale** del workflow (non su un nodo esistente)
+2. Clicca su **Aggiungi nodo**
+3. Scegli il tipo di nodo per il tuo nuovo ramo
+4. Trascina una freccia dalla parte inferiore del passaggio precedente alla parte superiore di questa nuova azione
+5. Ripeti per aggiungere altri rami dallo stesso nodo
+
+<Note>
+Ogni ramo è indipendente. L'aggiunta di un ramo non influisce sugli altri percorsi esistenti da quel nodo.
+</Note>
+
+### Layout visivo
+
+I rami appaiono come percorsi paralleli nell'editor del workflow. Puoi trascinare i nodi per riorganizzare il layout visivo senza influire sull'esecuzione.
+
+## Rami condizionali
+
+Poiché tutti i rami vengono eseguiti per impostazione predefinita, usa nodi **Filtro** per controllare quali percorsi vengono effettivamente eseguiti:
+
+| Ramo | Condizione del filtro | Azione                            |
+| ---- | --------------------- | --------------------------------- |
+| A    | Fase = "Vinta"        | Invia un'email di congratulazioni |
+| B    | Fase = "Persa"        | Crea un'attività di follow-up     |
+| C    | Fase = "Negoziazione" | Notifica il responsabile          |
+
+1. Crea rami dal tuo trigger o dall'azione
+2. Aggiungi un nodo **Filtro** come primo passaggio di ciascun ramo
+3. Configura ciascun filtro con condizioni reciprocamente esclusive
+4. Aggiungi le azioni dopo ciascun filtro
+
+Solo i rami in cui la condizione del filtro è soddisfatta continueranno l'esecuzione.
+
+## Unione dei rami
+
+**I rami non si uniscono automaticamente.** Ogni ramo viene eseguito in modo indipendente fino a quando non termina. Hai la massima flessibilità su come gestirlo:
+
+* **Opzione 1: Mantieni i rami separati**
+  Ogni ramo gestisce indipendentemente le proprie azioni di follow-up. Questo è l'approccio più semplice quando i rami non devono convergere.
+
+* **Opzione 2: Unisci i rami manualmente**
+  Quando crei il tuo workflow, puoi collegare manualmente più rami alla stessa azione a valle. Trascina semplicemente le frecce dalla fine di ciascun ramo a un nodo comune.
+
+<Note>
+Sebbene tu possa usare un nodo [Delay](/l/it/user-guide/workflows/capabilities/workflow-actions#delay) per mettere in pausa l'esecuzione, al momento non è configurabile per attendere "fino a quando termina un altro ramo".
+</Note>
+
+## Correlati
+
+* [Come usare i rami nei workflow](/l/it/user-guide/workflows/capabilities/use-branches-in-workflows) - Guida passo passo
+* [Azioni del workflow](/l/it/user-guide/workflows/capabilities/workflow-actions) - Azioni disponibili, incluso Filtro

packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-credits.mdx

@@ -0,0 +1,75 @@
+---
+title: Crediti del flusso di lavoro
+description: Comprendere il consumo e la gestione dei crediti dei flussi di lavoro.
+---
+
+I crediti del flusso di lavoro alimentano le tue automazioni in Twenty. Capire come funzionano ti aiuta a ottimizzare i costi e a gestire efficacemente il tuo budget di automazione.
+
+## Allocazione dei crediti
+
+I crediti dei flussi di lavoro sono assegnati in base al ciclo di fatturazione, non al livello del piano:
+
+| Ciclo di fatturazione   | Crediti             |
+| ----------------------- | ------------------- |
+| **Abbonamento mensile** | 5 crediti al mese   |
+| **Abbonamento annuale** | 50 crediti all'anno |
+
+<Note>
+5 crediti mensili sono generosi per le automazioni standard. La maggior parte dei team non supererà questo limite con un utilizzo tipico dei flussi di lavoro. I crediti aggiuntivi sono necessari principalmente per le azioni Code avanzate e i flussi di lavoro basati sull'AI.
+</Note>
+
+## Come Funziona il Consumo dei Crediti
+
+I crediti vengono consumati quando i flussi di lavoro vengono eseguiti, non quando li crei. Ogni azione del flusso di lavoro consuma crediti in base alla sua complessità:
+
+### Consumo di Crediti per Tipo di Azione
+
+* **Operazioni interne di base**: Consumo di crediti molto basso
+  * Cerca Record
+  * Crea Record
+  * Aggiorna Record
+  * Elimina Record
+  * Azioni del modulo
+
+* **Operazioni complesse**: Consumo di crediti più alto
+  * Azioni di codice (esecuzione JavaScript)
+  * Richieste HTTP a servizi esterni
+
+* **Funzionalità AI**: Consumo di crediti più elevato
+  * Le azioni dell'agente AI consumano crediti in base al modello AI utilizzato
+  * Prompt più complessi e output più lunghi utilizzano più crediti
+
+* **Azioni Delay**: Consumo di crediti minimo
+  * Il nodo Delay consuma **1 credito** quando viene eseguito
+  * **Nessun credito viene consumato** durante il periodo di attesa
+  * Un ritardo di 5 minuti costa quanto un ritardo di 5 giorni
+
+### Deduzione in Tempo Reale
+
+I crediti vengono detratti in tempo reale quando i flussi di lavoro vengono eseguiti. Ciò significa:
+
+* I flussi di lavoro di bozza non consumano crediti
+* Solo i flussi di lavoro attivi e in esecuzione utilizzano la tua allocazione di crediti
+* I flussi di lavoro falliti consumano comunque crediti per i passaggi completati
+
+## Gestione dei Crediti
+
+### Verifica l'Uso dei Crediti
+
+1. Vai a **Impostazioni → Fatturazione**
+2. Visualizza il tuo attuale consumo di crediti e il saldo rimanente
+3. Monitora i modelli di utilizzo per ottimizzare i tuoi flussi di lavoro
+
+### Acquisto di Crediti Aggiuntivi
+
+Se hai bisogno di più crediti oltre alla tua assegnazione del piano:
+
+1. Vai a **Impostazioni → Fatturazione**
+2. Clicca sull'opzione per acquistare crediti aggiuntivi. Sono disponibili pacchetti di diverse dimensioni.
+3. I crediti vengono aggiunti al tuo saldo attuale
+
+## Migliori Pratiche
+
+* **Elaborazione batch**: Utilizza in modo efficiente le operazioni di massa e le azioni di Iteratore per ridurre le singole chiamate di azione
+* **Ottimizzazione del trigger manuale**: Per i trigger manuali, scegli la disponibilità `Bulk` per elaborare più record in una singola esecuzione del flusso di lavoro
+* Ottimizza le azioni di codice per l'efficienza

packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-runs.mdx

@@ -0,0 +1,93 @@
+---
+title: Esecuzioni del workflow
+description: Monitora e gestisci le esecuzioni dei flussi di lavoro.
+---
+
+## Informazioni sulle esecuzioni
+
+Un'**Esecuzione** è una registrazione dell'esecuzione di un flusso di lavoro. Ogni volta che un flusso di lavoro viene attivato — che sia da un evento di record, una pianificazione, un'azione manuale o un webhook — viene creata una nuova esecuzione.
+
+## Visualizzazione delle esecuzioni
+
+### Dall'editor del flusso di lavoro
+
+1. Apri il flusso di lavoro che desideri monitorare
+2. Fai clic sul pannello **Esecuzioni** a destra
+3. Visualizza un elenco delle esecuzioni recenti con il relativo stato
+
+### Dalla vista Esecuzioni dei flussi di lavoro
+
+1. Vai a **Esecuzioni dei flussi di lavoro** nella barra laterale
+2. Visualizza le esecuzioni in tutti i flussi di lavoro
+3. Filtra per stato, flusso di lavoro o data
+
+## Stati delle esecuzioni
+
+| Stato             | Descrizione                                                                                       |
+| ----------------- | ------------------------------------------------------------------------------------------------- |
+| **In esecuzione** | Il flusso di lavoro è in esecuzione                                                               |
+| **Completato**    | Il flusso di lavoro è terminato correttamente                                                     |
+| **Non riuscito**  | Il flusso di lavoro ha riscontrato un errore ed è stato interrotto                                |
+| **In attesa**     | Il flusso di lavoro è in pausa (ad es., in attesa di un'azione Ritardo o dell'invio di un modulo) |
+
+## Dettagli dell'esecuzione
+
+Fai clic su una qualsiasi esecuzione per visualizzare:
+
+* **Stato**: stato attuale dell'esecuzione
+* **Ora di avvio**: quando è iniziata l'esecuzione
+* **Durata**: quanto è durata l'esecuzione
+* **Dati del trigger**: l'input che ha avviato il flusso di lavoro
+* **Output dei passaggi**: dati restituiti da ciascun passaggio
+* **Messaggi di errore**: se l'esecuzione non è riuscita, cosa è andato storto
+
+## Esecuzione passo dopo passo
+
+Ogni esecuzione mostra l'avanzamento nel flusso di lavoro:
+
+1. Vedi quali passaggi sono stati completati correttamente
+2. Identifica dove si sono verificati errori
+3. Visualizza i dati scambiati tra i passaggi
+4. Esegui il debug dei problemi esaminando gli input e gli output dei passaggi
+
+## Gestione degli errori
+
+Quando un'esecuzione non riesce:
+
+1. Apri l'esecuzione non riuscita
+2. Trova il passaggio che ha causato l'errore
+3. Controlla il messaggio di errore per i dettagli
+
+Problemi comuni:
+
+* Campi obbligatori mancanti
+* Formato dati non valido
+* Errori dell'API esterna
+* Problemi di autorizzazione
+
+## Riesecuzione dei flussi di lavoro
+
+Se un'esecuzione non riesce, puoi:
+
+* Correggere il problema di base e attendere il trigger successivo
+* Per i flussi di lavoro manuali, attiva nuovamente il flusso con gli stessi dati o con dati aggiornati
+* Rivedere la logica del flusso di lavoro per evitare errori futuri
+
+## Consigli Per Prestazioni
+
+### Gestire La Cronologia Esegui
+
+* Le corse sono mantenute per riferimento storico
+* Le corse molto vecchie possono essere archiviate automaticamente
+* Esporta i dati di esecuzione se hai bisogno di mantenere i record
+
+### Monitoraggio Delle Migliori Pratiche
+
+* Controlla viene eseguito regolarmente dopo aver attivato nuovi flussi di lavoro
+* Revisione non riuscita per identificare i modelli
+
+## Correlati
+
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Workflow Troubleshooting](/l/it/user-guide/workflows/how-tos/need-more-help/workflow-troubleshooting)

packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-triggers.mdx

@@ -0,0 +1,137 @@
+---
+title: Attivatori dei flussi di lavoro
+description: Scopri i diversi attivatori che avviano i tuoi flussi di lavoro.
+---
+
+## Informazioni sugli attivatori
+
+I flussi di lavoro iniziano sempre con un singolo attivatore che definisce quando deve essere eseguita l'automazione.
+
+<img src="/images/user-guide/workflows/workflow_triggers.png" style={{width:'100%'}} />
+
+<Tip>
+**Gli oggetti avanzati sono supportati!** Oltre agli oggetti CRM standard (Persone, Aziende, Opportunità), puoi anche avviare flussi di lavoro ed eseguire azioni su:
+* Membri dello spazio di lavoro
+* Eventi del calendario
+* Messaggi (email)
+* Attività, note e molti altri oggetti di sistema
+
+Questo consente potenti automazioni, come notificare i membri del team quando vengono creati eventi del calendario oppure elaborare automaticamente le email in arrivo.
+</Tip>
+
+## Record Creato
+
+Avvia il flusso di lavoro quando viene creato un nuovo record in un oggetto selezionato (Persone, Aziende, Opportunità o un qualsiasi oggetto personalizzato).
+
+**Configurazione**: Seleziona il tipo di oggetto da monitorare per i nuovi record.
+
+<Note>
+* Questo trigger è ottimo per i record creati da CSV, mailbox e sincronizzazione del calendario, o API.
+* **Non è consigliato per i record creati manualmente**: con questo attivatore, i flussi di lavoro iniziano non appena il record viene creato. Dal momento che Twenty UI offre il salvataggio automatico sul volo (non c'è alcuna modalità di modifica e quindi una convalida per salvare i record), il flusso di lavoro verrà attivato prima che l'utente inserisca tutti i campi.
+  Per attivare questo flusso di lavoro sui record creati manualmente, si consiglia invece di usare l'attivatore `Record is created or updated`.
+</Note>
+
+## Record Aggiornato
+
+Avvia il flusso di lavoro quando vengono apportate modifiche a un record esistente.
+
+**Configurazione**:
+
+* Seleziona il tipo di oggetto
+* Specifica opzionalmente quali campi monitorare per le modifiche
+
+## Record Aggiornato o Creato
+
+Avvia il flusso di lavoro quando un record viene creato o aggiornato in un oggetto selezionato.
+
+**Perché è Importante:** Questo trigger è particolarmente utile perché i record creati tramite diversi metodi si comportano diversamente:
+
+* **Importazioni API/CSV:** I record vengono creati con tutti i campi popolati immediatamente
+* **Creazione manuale:** Prima vengono creati i record, poi i campi vengono aggiunti con aggiornamenti successivi
+
+**Configurazione**:
+
+* Seleziona il tipo di oggetto da monitorare
+* Specifica opzionalmente quali campi monitorare per le modifiche
+* Il flusso di lavoro verrà attivato sia alla creazione iniziale sia a qualsiasi aggiornamento successivo
+
+## Record Eliminato
+
+Avvia il flusso di lavoro quando un record viene rimosso da un oggetto.
+
+**Configurazione**: Seleziona il tipo di oggetto da monitorare per le eliminazioni.
+
+## Attivatore manuale
+
+Avvia il flusso di lavoro quando viene attivato da un'azione dell'utente. È possibile accedere a questo attivatore tramite il menu `Cmd+K` o tramite un pulsante personalizzato che verrà visualizzato nella barra di navigazione superiore dopo aver selezionato uno o più record.
+
+<img src="/images/user-guide/workflows/add_to_newsletter_button.png" style={{width:'100%'}} />
+
+**Configurazione di Disponibilità:**
+Scegli come il flusso di lavoro dovrebbe gestire la selezione dei record:
+
+* **Globale:** Non è richiesto alcun record per attivare questo flusso di lavoro. Il flusso di lavoro viene attivato dal menu di comando `Cmd+K` ovunque (da qualsiasi oggetto) e non usa i record come input.
+
+Per la disponibilità **Single** e **Bulk**, i record selezionati saranno passati al tuo flusso di lavoro. Questo è configurato per un dato oggetto, e diversi record possono essere selezionati prima di attivare il flusso di lavoro.
+
+* **Singolo**: Il flusso di lavoro verrà eseguito dall'inizio alla fine quante volte ci sono record selezionati.
+
+  <Note>
+    **Limite soft: 100 esecuzioni/minuto**. Oltre questa soglia, i flussi di lavoro rimangono nello stato "Not Started" e vengono elaborati gradualmente—o da un processo in background oppure quando un altro flusso di lavoro entra in coda. Questo significa che puoi selezionare più di 100 record con un attivatore Singolo; l'esecuzione sarà semplicemente più lenta.
+  </Note>
+
+* **Bulk**: Il flusso di lavoro verrà eseguito una volta, fornendo l'intero elenco di record come input. Questo significa che il flusso di lavoro deve contenere un'[azione Iteratore](/l/it/user-guide/workflows/capabilities/workflow-actions#iterator).
+
+<Note>
+È più avanzato ed è ideale per chi vuole ottimizzare il numero di esecuzioni del flusso di lavoro.
+</Note>
+
+<img src="/images/user-guide/workflows/manual_trigger.png" style={{width:'100%'}} />
+
+**Configurazione Aggiuntiva**:
+
+* Seleziona l'oggetto di destinazione (per disponibilità Singola e Bulk)
+* Scegli un'icona di comando per attivare il flusso di lavoro.
+* Configura la posizione nella barra di navigazione (Fissa o Non Fissa)
+
+**Metodi di Accesso**:
+
+* Menu `Cmd+K` per trovare e avviare flussi di lavoro manuali
+* Pulsante personalizzato nella barra di navigazione in alto (se configurato)
+
+## Attivatore basato sul tempo: Su pianificazione
+
+Avvia il flusso di lavoro con una ricorrenza da te definita.
+
+**Configurazione**:
+
+* Seleziona l'unità di tempo (minuti, ore, giorni)
+* Inserisci un valore o usa espressioni cron personalizzate per pianificazioni avanzate
+
+<Note>
+**Fuso orario**: I flussi di lavoro pianificati vengono eseguiti in **UTC**. Quando imposti gli orari per le pianificazioni giornaliere, converti la tua ora locale in UTC.
+</Note>
+
+## Attivatore esterno: Webhook
+
+Avvia il flusso di lavoro quando viene ricevuta una richiesta GET o POST da un servizio esterno.
+
+<img src="/images/user-guide/workflows/webhook_trigger.png" style={{width:'100%'}} />
+
+**Configurazione**:
+
+* Il flusso di lavoro fornisce un URL webhook univoco: copialo e aggiungilo al tuo sistema esterno come endpoint da chiamare.
+* Per le richieste POST, definisci la struttura del body prevista in modo che Twenty sappia quali dati aspettarsi. Aggiungi qui i campi che riceverai e che saranno necessari più avanti nel tuo flusso di lavoro.
+* Configura l'autenticazione (presto disponibile).
+
+## Scegliere l'attivatore giusto
+
+| Caso d'uso                            | Attivatore consigliato      |
+| ------------------------------------- | --------------------------- |
+| Nuovi lead da elaborare               | Record Creato               |
+| Modifiche ai dati da sincronizzare    | Record Aggiornato           |
+| Gestione dati da importazione/manuale | Record Aggiornato o Creato  |
+| Pulizia dopo l'eliminazione           | Record Eliminato            |
+| Azione avviata dall'utente            | Avvia Manualmente           |
+| Report ricorrenti                     | Su pianificazione           |
+| Integrazione esterna                  | Webhook o Su pianificazione |

packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-versions.mdx

@@ -0,0 +1,84 @@
+---
+title: Versioni del workflow
+description: Gestisci le versioni e le bozze dei workflow.
+---
+
+## Informazioni sulle versioni
+
+Ogni volta che attivi un workflow, viene creata una nuova versione. Questo ti permette di tenere traccia delle modifiche nel tempo e ripristinare le configurazioni precedenti se necessario.
+
+## Stati delle versioni
+
+| Stato           | Descrizione                                   |
+| --------------- | --------------------------------------------- |
+| **Bozza**       | In fase di modifica, non ancora pubblicata    |
+| **Attivo**      | Versione live che risponde ai trigger         |
+| **Disattivato** | In precedenza attivo ma fermato manualmente   |
+| **Archiviato**  | Versioni passate conservate per la cronologia |
+
+## Lavorare con le bozze
+
+Quando modifichi un workflow attivo, le modifiche vengono salvate come **bozza**. La versione attiva continua a essere eseguita mentre lavori agli aggiornamenti.
+
+Una volta terminata la modifica, puoi:
+
+* **Attiva**: Pubblica la bozza come nuova versione attiva (la versione precedente viene archiviata)
+* **Scarta**: Elimina la bozza e mantieni l'attuale versione attiva
+
+## Cronologia Versioni
+
+### Visualizzare le versioni precedenti
+
+1. Apri il workflow
+2. Fai clic sulla scheda **Versioni**
+3. Visualizza tutte le versioni precedenti con timestamp
+
+### Ripristinare una versione
+
+1. Trova la versione che desideri ripristinare
+2. Fai clic su **Usa come bozza**
+3. La versione viene copiata in una nuova bozza
+4. Apporta gli aggiornamenti necessari
+5. Attiva quando sei pronto
+
+## Migliori Pratiche
+
+### Gestione delle versioni
+
+* Attiva solo quando pronta per la produzione
+* Mantieni modifiche significative tra le versioni
+* Documenta le modifiche importanti nei nomi o nelle descrizioni dei workflow
+* Testa in modalità bozza prima di attivare i workflow
+
+### Ripristino delle modifiche
+
+* Se una nuova versione causa problemi, ripristina la versione precedente
+* Usa la cronologia delle versioni per tenere traccia delle modifiche
+* Testa sempre le versioni ripristinate prima di attivare
+
+## Workflow comuni
+
+### Modifica rapida
+
+1. Apporta piccole modifiche a un workflow attivo
+2. Testa in modalità bozza
+3. Attiva la nuova versione
+
+### Revisione importante
+
+1. Usa la versione precedente come punto di partenza
+2. Apporta modifiche significative in bozza
+3. Testa approfonditamente tutti gli scenari
+4. Attiva quando sei sicuro
+
+### Ripristino
+
+1. Identifica il problema con la versione corrente
+2. Trova nella cronologia l'ultima versione funzionante
+3. Fai clic su **Usa come bozza**
+4. Attiva per ripristinare il comportamento precedente
+
+## Correlati
+
+* [Guida introduttiva ai workflow](/l/it/user-guide/workflows/overview)
+* [Esecuzioni dei workflow](/l/it/user-guide/workflows/capabilities/workflow-runs)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx

@@ -0,0 +1,82 @@
+---
+title: Gestire gli array nelle azioni Code
+description: Scopri come gestire correttamente gli input di tipo array nelle azioni Code dei workflow.
+---
+
+Quando lavori con gli array nelle azioni Code, potresti incontrare due problemi comuni:
+
+1. **Array passati come stringhe** — i dati provenienti da sistemi esterni o da passaggi precedenti arrivano come stringa invece che come un vero array
+2. **Impossibile selezionare singoli elementi** — puoi selezionare solo l'intero array, non i campi specifici al suo interno
+
+Entrambi i casi si possono risolvere con un nodo Code.
+
+## Analizzare gli array dalle stringhe
+
+Gli array vengono spesso passati tra i passaggi del workflow come stringhe o JSON invece che come array nativi. Ciò accade quando:
+
+* Ricezione di dati da API esterne tramite HTTP Request
+* Elaborazione dei payload dei webhook
+* Passaggio di dati tra i passaggi del workflow
+
+**Soluzione**: aggiungi questo pattern all'inizio della tua azione Code:
+
+```javascript
+export const main = async (params: {
+  users: any;
+}): Promise<object> => {
+  const { users } = params;
+
+  // Handle input that may come as a string or an array
+  const usersFormatted = typeof users === "string" ? JSON.parse(users) : users;
+
+  // Now you can safely work with usersFormatted as an array
+  return {
+    users: usersFormatted.map((user) => ({
+      ...user,
+      activityStatus: String(user.activityStatus).toUpperCase(),
+    })),
+  };
+};
+```
+
+La riga chiave `typeof users === "string" ? JSON.parse(users) : users` verifica se l'input è una stringa, lo analizza se necessario o lo usa direttamente se è già un array.
+
+## Estrazione di campi specifici dagli array
+
+Un webhook potrebbe restituire un array come `answers: [...]`, ma nei passaggi successivi del workflow puoi selezionare solo l'**intero array** — non i singoli elementi al suo interno.
+
+**Soluzione**: aggiungi un nodo Code per estrarre campi specifici e restituirli come oggetto strutturato:
+
+```javascript
+export const main = async (params: {
+  answers: any;
+}): Promise<object> => {
+  const { answers } = params;
+
+  // Handle input that may come as a string or an array
+  const answersFormatted = typeof answers === "string"
+    ? JSON.parse(answers)
+    : answers;
+
+  // Extract specific fields from the array
+  const firstname = answersFormatted[0]?.text || "";
+  const name = answersFormatted[1]?.text || "";
+
+  return {
+    answer: {
+      firstname,
+      name
+    }
+  };
+};
+```
+
+Il nodo Code restituisce un oggetto strutturato invece di un array. Nei passaggi successivi, ora puoi selezionare campi individuali come `answer.firstname` e `answer.name` dal selettore delle variabili.
+
+<Tip>
+**Vuoi iterare sull'array invece di estrarre i campi?** Quando uno step di Code o Logic Function restituisce un array di primo livello, puoi passarlo direttamente a un [Iterator](/l/it/user-guide/workflows/capabilities/use-iterator): seleziona l'opzione **Whole list** dello step come input dell'Iterator, quindi fai riferimento a ciascun elemento con `{{iterator.currentItem}}` all'interno del ciclo. In quel caso non è necessario ristrutturare l'array in un oggetto.
+</Tip>
+
+<Tip>
+Fai clic sull'icona quadrata in alto a destra dell'editor di codice per visualizzarlo a tutto schermo — utile poiché la larghezza predefinita dell'editor è limitata.
+</Tip>

packages/twenty-docs/l/it/user-guide/workflows/how-tos/connect-to-other-tools/bring-product-data-in-twenty.mdx

@@ -0,0 +1,182 @@
+---
+title: Porta i dati di prodotto in Twenty
+description: Sincronizza i dati del catalogo prodotti da un data warehouse nel tuo CRM in base a una pianificazione.
+---
+
+Usa questo modello per mantenere Twenty sincronizzato con i dati di prodotto dal tuo data warehouse (ad esempio, Snowflake, BigQuery, PostgreSQL).
+
+## Struttura del flusso di lavoro
+
+1. **Trigger**: In base a una pianificazione
+2. **Code**: Interroga il tuo data warehouse
+3. **Code** (opzionale): Formatta i dati come array
+4. **Iterator**: Itera su ciascun prodotto
+5. **Upsert Record**: Crea o aggiorna in Twenty
+
+<img src="/images/user-guide/workflows/create_users_workflow.png" style={{width:'100%'}} />
+
+## Passaggio 1: Pianifica il trigger
+
+Imposta il flusso di lavoro per l'esecuzione con una frequenza che corrisponda alle tue esigenze di aggiornamento dei dati:
+
+* Ogni 5 minuti per una sincronizzazione quasi in tempo reale
+* Ogni ora per i dati meno critici
+* Ogni giorno per aggiornamenti in batch
+
+## Passaggio 2: Interroga il tuo data warehouse
+
+Aggiungi un'azione **Code** per recuperare i dati recenti:
+
+```javascript
+export const main = async () => {
+  const intervalMinutes = 10; // Match your schedule frequency
+  const cutoffTime = new Date(Date.now() - intervalMinutes * 60 * 1000).toISOString();
+
+  // Replace with your actual data warehouse connection
+  const response = await fetch("https://your-warehouse-api.com/query", {
+    method: "POST",
+    headers: {
+      "Authorization": "Bearer YOUR_API_KEY",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query: `
+        SELECT id, name, sku, price, stock_quantity, updated_at
+        FROM products
+        WHERE updated_at >= '${cutoffTime}'
+      `
+    })
+  });
+
+  const data = await response.json();
+  return { products: data.results };
+};
+```
+
+<Tip>
+Filtra per `updated_at >= last X minutes` per recuperare solo i record modificati di recente. Questo mantiene efficiente la sincronizzazione.
+</Tip>
+
+## Passaggio 3: Formatta i dati (opzionale)
+
+Se il tuo data warehouse restituisce dati in un formato che richiede una trasformazione, aggiungi un'altra azione **Code**. Le trasformazioni comuni includono conversioni di tipo, ridenominazione dei campi e pulizia dei dati.
+
+### Esempio: Dati utente con campi booleani e di stato
+
+```javascript
+export const main = async (params: {
+  users: any;
+}): Promise<object> => {
+  const { users } = params;
+  const usersFormatted = typeof users === "string" ? JSON.parse(users) : users;
+
+  // Convert string "true"/"false" to actual booleans
+  const toBool = (v: any) => v === true || v === "true";
+
+  return {
+    users: usersFormatted.map((user) => ({
+      ...user,
+      activityStatus: String(user.activityStatus).toUpperCase(),
+      isActiveLast30d: toBool(user.isActiveLast30d),
+      isActiveLast7d: toBool(user.isActiveLast7d),
+      isActiveLast24h: toBool(user.isActiveLast24h),
+      isTwenty: toBool(user.isTwenty),
+    })),
+  };
+};
+```
+
+### Esempio: Dati di prodotto con conversioni di tipo
+
+```javascript
+export const main = async (params: { products: any }) => {
+  const products = typeof params.products === "string"
+    ? JSON.parse(params.products)
+    : params.products;
+
+  return {
+    products: products.map(product => ({
+      externalId: product.id,
+      name: product.name,
+      sku: product.sku,
+      price: parseFloat(product.price),        // String → Number
+      stockQuantity: parseInt(product.stock_quantity),
+      isActive: product.status === "active"    // String → Boolean
+    }))
+  };
+};
+```
+
+### Esempio: Formattazione di date e valute
+
+```javascript
+export const main = async (params: { deals: any }) => {
+  const deals = typeof params.deals === "string"
+    ? JSON.parse(params.deals)
+    : params.deals;
+
+  return {
+    deals: deals.map(deal => ({
+      ...deal,
+      // Convert Unix timestamp to ISO date
+      closedAt: deal.closed_timestamp
+        ? new Date(deal.closed_timestamp * 1000).toISOString()
+        : null,
+      // Ensure amount is a number (remove currency symbols)
+      amount: parseFloat(String(deal.amount).replace(/[^0-9.-]/g, "")),
+      // Normalize stage names
+      stage: deal.stage?.toLowerCase().replace(/_/g, " ")
+    }))
+  };
+};
+```
+
+### Trasformazioni comuni
+
+| Formato di origine   | Formato di destinazione | Codice                                   |
+| -------------------- | ----------------------- | ---------------------------------------- |
+| `"true"` / `"false"` | `true` / `false`        | `v === true \|\| v === "true"`           |
+| `"123.45"`           | `123.45`                | `parseFloat(value)`                      |
+| `"active"`           | `"ACTIVE"`              | `value.toUpperCase()`                    |
+| `1704067200` (Unix)  | Data ISO                | `new Date(v * 1000).toISOString()`       |
+| `"$1,234.56"`        | `1234.56`               | `parseFloat(v.replace(/[^0-9.-]/g, ""))` |
+| `null` / `undefined` | `""`                    | `value \|\| ""`                          |
+
+## Passaggio 4: Itera sui prodotti
+
+Aggiungi un'azione **Iterator**:
+
+* Input: `{{code.products}}`
+
+Questo esegue un ciclo su ogni prodotto nell'array.
+
+## Passaggio 5: Esegui l'upsert di ogni record
+
+All'interno dell'Iterator, aggiungi un'azione **Upsert Record**:
+
+| Impostazione           | Valore                                    |
+| ---------------------- | ----------------------------------------- |
+| **Oggetto**            | Il tuo oggetto Prodotto personalizzato    |
+| **Corrispondenza per** | ID esterno o SKU (identificatore univoco) |
+| **Nome**               | `{{iterator.item.name}}`                  |
+| **SKU**                | `{{iterator.item.sku}}`                   |
+| **Prezzo**             | `{{iterator.item.price}}`                 |
+
+<Tip>
+Usa **Upsert** (aggiornare o creare) invece di creare rami separati per creazione e aggiornamento. È più veloce da costruire e più facile da eseguire il debug.
+</Tip>
+
+## Esempi di casi d'uso
+
+| Fonte                      | Dati                                        |
+| -------------------------- | ------------------------------------------- |
+| **Sistema ERP**            | Catalogo prodotti, prezzi, inventario       |
+| **Piattaforma e-commerce** | Ordini, clienti, aggiornamenti dei prodotti |
+| **Data warehouse**         | Metriche aggregate, dati arricchiti         |
+| **Sistema di inventario**  | Livelli di stock, avvisi di riordino        |
+
+## Correlati
+
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Gestire gli array nelle azioni Code](/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/connect-to-other-tools/bring-typeform-submissions-in-twenty.mdx

@@ -0,0 +1,130 @@
+---
+title: Importa gli invii di Typeform in Twenty
+description: Gestisci il payload del webhook di Typeform per creare lead dalle risposte del modulo.
+---
+
+Per la configurazione standard del webhook, vedi [Configura un trigger webhook](/l/it/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger). Questo articolo tratta la gestione specifica richiesta dalla struttura di payload personalizzata di Typeform.
+
+### Passaggio 1: Crea un flusso di lavoro webhook
+
+1. Vai a **Impostazioni → Flussi di lavoro**
+2. Fai clic su **+ Nuovo flusso di lavoro**
+3. Seleziona **Webhook** come trigger
+4. Copia l'URL del webhook
+
+### Passaggio 2: Configura Typeform
+
+1. In Typeform, apri il tuo modulo
+2. Vai a **Connect → Webhooks**
+3. Incolla l'URL del webhook di Twenty
+4. Salva
+
+### Passaggio 3: Comprendi il payload di Typeform
+
+Typeform invia una struttura JSON annidata. Ecco un esempio semplificato:
+
+```json
+{
+  "event_type": "form_response",
+  "form_response": {
+    "form_id": "abc123",
+    "submitted_at": "2025-01-15T10:30:00Z",
+    "answers": [
+      {
+        "text": "Jane",
+        "type": "text",
+        "field": { "id": "field1", "type": "short_text", "title": "First Name" }
+      },
+      {
+        "text": "Smith",
+        "type": "text",
+        "field": { "id": "field2", "type": "short_text", "title": "Last Name" }
+      },
+      {
+        "text": "Acme Corp",
+        "type": "text",
+        "field": { "id": "field3", "type": "short_text", "title": "Company" }
+      },
+      {
+        "email": "jane@acme.com",
+        "type": "email",
+        "field": { "id": "field4", "type": "email", "title": "Email" }
+      },
+      {
+        "type": "choice",
+        "field": { "id": "field5", "type": "dropdown", "title": "Team Size" },
+        "choice": { "label": "10-50" }
+      }
+    ]
+  }
+}
+```
+
+Punti chiave da notare:
+
+* I dati del modulo sono annidati in `form_response`
+* **Le risposte vengono restituite come array**, non come campi denominati
+* Ogni risposta include il tipo e il titolo del campo come riferimento
+
+### Passaggio 4: Estrai i campi dall'array delle risposte
+
+Poiché `answers` è un array, nei passaggi successivi puoi selezionare solo l'intero array — non i singoli campi. Aggiungi un'azione **Code** per estrarre i campi di cui hai bisogno:
+
+```javascript
+export const main = async (params: {
+  answers: any;
+}): Promise<object> => {
+  const { answers } = params;
+
+  // Handle input that may come as a string or an array
+  const answersFormatted = typeof answers === "string"
+    ? JSON.parse(answers)
+    : answers;
+
+  // Extract fields by position or by finding the field type
+  const firstName = answersFormatted[0]?.text || "";
+  const lastName = answersFormatted[1]?.text || "";
+  const company = answersFormatted[2]?.text || "";
+  const email = answersFormatted.find(a => a.type === "email")?.email || "";
+  const teamSize = answersFormatted.find(a => a.type === "choice")?.choice?.label || "";
+
+  return {
+    contact: {
+      firstName,
+      lastName,
+      company,
+      email,
+      teamSize
+    }
+  };
+};
+```
+
+Ora, nei passaggi successivi, puoi selezionare `contact.firstName`, `contact.email`, ecc. dal selettore delle variabili.
+
+<Tip>
+Per maggiori dettagli sulla gestione degli array, vedi [Gestire gli array nelle azioni Code](/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions).
+</Tip>
+
+### Passaggio 5: Crea il record
+
+Aggiungi un'azione **Create Record**:
+
+| Campo       | Valore                                            |
+| ----------- | ------------------------------------------------- |
+| **Oggetto** | Persone                                           |
+| **Nome**    | `{{code.contact.firstName}}`                      |
+| **Cognome** | `{{code.contact.lastName}}`                       |
+| **Email**   | `{{code.contact.email}}`                          |
+| **Azienda** | Cerca o crea in base a `{{code.contact.company}}` |
+
+### Passaggio 6: Testa e attiva
+
+1. Invia una risposta di prova in Typeform
+2. Controlla l'esecuzione del flusso di lavoro per verificare che i dati siano stati acquisiti
+3. Attiva il flusso di lavoro
+
+## Correlati
+
+* [Configura un trigger webhook](/l/it/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger)
+* [Gestire gli array nelle azioni Code](/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty.mdx

@@ -0,0 +1,263 @@
+---
+title: Genera un PDF da Twenty
+description: Crea un flusso di lavoro per generare e allegare un PDF (ad esempio un preventivo) a un record.
+---
+
+Genera o recupera automaticamente un PDF e allegalo a un record in Twenty. Questo viene comunemente utilizzato per creare preventivi, fatture o report collegati ad Aziende, Opportunità o altri oggetti.
+
+## Panoramica
+
+Questo flusso di lavoro usa un **Attivatore manuale** così gli utenti possono generare un PDF su richiesta per qualsiasi record selezionato. Una **Funzione logica** gestisce:
+
+1. Scaricare il PDF da un URL (da un servizio di generazione di PDF)
+2. Caricare il file su Twenty
+3. Creare un allegato collegato al record
+
+## Prerequisiti
+
+Prima di configurare il flusso di lavoro:
+
+1. **Crea una chiave API**: vai su **Impostazioni → API** e crea una nuova chiave API. Avrai bisogno di questo token per la Funzione Logica.
+2. **Configura un servizio di generazione PDF** (opzionale): se vuoi generare dinamicamente PDF (ad es. preventivi), usa un servizio come Carbone, PDFMonkey o DocuSeal per creare il PDF e ottenere un URL di download.
+
+## Configurazione passo-passo
+
+### Passaggio 1: Configura il trigger
+
+1. Vai su **Flussi di lavoro** e crea un nuovo flusso di lavoro
+2. Seleziona **Attivatore manuale**
+3. Scegli l'oggetto a cui vuoi allegare i PDF (ad es. **Company** o **Opportunity**)
+
+<Tip>
+Con un Trigger manuale, gli utenti possono eseguire questo flusso di lavoro utilizzando un pulsante che appare in alto a destra una volta selezionato un record: questo esegue il flusso di lavoro per generare e allegare un PDF.
+</Tip>
+
+### Passaggio 2: aggiungi una Funzione logica
+
+1. Aggiungi un'azione **Codice** (Funzione logica)
+2. Crea una nuova funzione con il codice seguente
+3. Configura i parametri di input
+
+#### Parametri di input
+
+| Parametro   | Valore                  |
+| ----------- | ----------------------- |
+| `companyId` | `{{trigger.object.id}}` |
+
+<Note>
+Se alleghi a un oggetto diverso (Person, Opportunity, ecc.), rinomina di conseguenza il parametro (ad es. `personId`, `opportunityId`) e aggiorna la funzione logica.
+</Note>
+
+#### Codice della Funzione logica
+
+```typescript
+export const main = async (
+  params: { companyId: string },
+) => {
+  const { companyId } = params;
+  // Replace with your Twenty GraphQL endpoints (/metadata for metadata and files or /graphql for your records)
+  // Cloud: https://api.twenty.com/graphql
+  // Self-hosted: https://your-domain.com/graphql
+
+  const metadataGraphqlEndpoint = 'https://api.twenty.com/metadata';
+  const dataGraphqlEndpoint = 'https://api.twenty.com/graphql';
+
+  // Replace with your API key from Settings → APIs
+  const authToken = 'YOUR_API_KEY';
+
+  // Replace with your PDF URL
+  // This could be from a PDF generation service or a static URL
+  const pdfUrl = 'https://your-pdf-service.com/generated-quote.pdf';
+  const filename = 'quote.pdf';
+
+  // Step 1: Download the PDF file
+  const pdfResponse = await fetch(pdfUrl);
+
+  if (!pdfResponse.ok) {
+    throw new Error(`Failed to download PDF: ${pdfResponse.status}`);
+  }
+
+  const pdfBlob = await pdfResponse.blob();
+  const pdfFile = new File([pdfBlob], filename, { type: 'application/pdf' });
+
+  const fieldMetadataIdQuery = `
+    query FindUploadFileFieldMetadataId {
+      objects {
+        edges {
+          node {
+            nameSingular
+            fieldsList {
+              id
+              name
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  // Step 2: Find a fieldMetadataId of "Attachment file" field in Attachments object with GraphQL API
+  const response = await fetch(metadataGraphqlEndpoint, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${authToken}`
+      },
+      body: {
+        query: fieldMetadataIdQuery,
+      }
+    });
+  const result = await response.json();
+  const uploadFileFieldMetadataId = result.data.objects.edges.find(object => object.node.nameSingular === 'attachment').node.fieldsList.find(field => field.name === 'file').id;
+
+  // Step 3: Upload the file via GraphQL multipart upload
+  const uploadMutation = `
+    mutation UploadFilesFieldFile($file: Upload!, $fieldMetadataId: String!) {
+      uploadFilesFieldFile(file: $file, fieldMetadataId: $fieldMetadataId) {
+        id
+      }
+    }
+  `;
+
+  const uploadForm = new FormData();
+  uploadForm.append('operations', JSON.stringify({
+    query: uploadMutation,
+    variables: { file: null, fieldMetadataId: uploadFileFieldMetadataId },
+  }));
+  uploadForm.append('map', JSON.stringify({ '0': ['variables.file'] }));
+  uploadForm.append('0', pdfFile);
+
+  const uploadResponse = await fetch(metadataGraphqlEndpoint, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${authToken}` },
+    body: uploadForm,
+  });
+
+  const uploadResult = await uploadResponse.json();
+
+  if (uploadResult.errors?.length) {
+    throw new Error(`Upload failed: ${uploadResult.errors[0].message}`);
+  }
+
+  const fileId = uploadResult.data?.uploadFilesFieldFile?.id;
+
+  if (!fileId) {
+    throw new Error('No file id returned from upload');
+  }
+
+  // Step 4: Create the attachment linked to the company
+  const attachmentMutation = `
+    mutation CreateOneAttachment($data: AttachmentCreateInput!) {
+      createAttachment(data: $data) {
+        id
+        name
+      }
+    }
+  `;
+
+  const attachmentResponse = await fetch(dataGraphqlEndpoint, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${authToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      query: attachmentMutation,
+      variables: {
+        data: {
+          name: filename,
+          targetCompanyId: companyId,
+          file: [
+            {
+              fileId: fileId,
+              label: filename
+            }
+          ]
+        },
+      },
+    }),
+  });
+
+  const attachmentResult = await attachmentResponse.json();
+
+  if (attachmentResult.errors?.length) {
+    throw new Error(`Attachment creation failed: ${attachmentResult.errors[0].message}`);
+  }
+
+  return attachmentResult.data?.createAttachment;
+};
+```
+
+### Passaggio 3: personalizza per il tuo caso d'uso
+
+#### Per allegare a un oggetto diverso
+
+Sostituisci `targetCompanyId` con il campo appropriato:
+
+| Oggetto                | Nome del campo             |
+| ---------------------- | -------------------------- |
+| Azienda                | `targetCompanyId`          |
+| Persona                | `targetPersonId`           |
+| Opportunità            | `targetOpportunityId`      |
+| Oggetto personalizzato | `targetYourCustomObjectId` |
+
+Aggiorna sia il parametro della funzione sia l'oggetto `variables.data` nella mutation dell'allegato.
+
+#### Per usare un URL PDF dinamico
+
+Se usi un servizio di generazione PDF, puoi:
+
+1. Per prima cosa esegui un'azione HTTP Request per generare il PDF
+2. Passa l'URL PDF restituito alla funzione logica come parametro
+
+```typescript
+export const main = async (
+  params: { companyId: string; pdfUrl: string; filename: string },
+) => {
+  const { companyId, pdfUrl, filename } = params;
+  // ... rest of the function
+};
+```
+
+### Passaggio 4: Testa e attiva
+
+1. Salva il flusso di lavoro
+2. Vai a un record di Company
+3. Fai clic sul menu **⋮** e seleziona il tuo flusso di lavoro
+4. Controlla la sezione **Attachments** nel record per verificare che il PDF sia stato allegato
+5. Attiva il flusso di lavoro
+
+## Integrazione con servizi di generazione PDF
+
+Per creare preventivi o fatture dinamici:
+
+### Esempio: Genera preventivo → Allega PDF
+
+| Passaggio | Azione                       | Scopo                                                    |
+| --------- | ---------------------------- | -------------------------------------------------------- |
+| 1         | Attivatore manuale (Company) | L'utente avvia l'operazione su un record                 |
+| 2         | Cerca record                 | Ottieni i dettagli di Opportunity o delle righe articolo |
+| 3         | Richiesta HTTP               | Chiama l'API di generazione PDF con i dati del record    |
+| 4         | Funzione logica              | Scarica e allega il PDF generato                         |
+
+### Servizi di generazione PDF più diffusi
+
+* **Carbone** - Generazione di documenti basata su modelli
+* **PDFMonkey** - Creazione dinamica di PDF da modelli
+* **DocuSeal** - Piattaforma di automazione dei documenti
+* **Documint** - Generazione di documenti API-first
+
+Ogni servizio fornisce un'API che restituisce un URL PDF, che puoi poi passare alla Funzione Logica.
+
+## Risoluzione dei problemi
+
+| Problema                               | Soluzione                                                                                |
+| -------------------------------------- | ---------------------------------------------------------------------------------------- |
+| "Download del PDF non riuscito"        | Verifica che l'URL del PDF sia accessibile e restituisca un PDF valido                   |
+| "Caricamento non riuscito"             | Verifica che la tua chiave API sia valida e abbia i permessi di scrittura                |
+| "Creazione dell'allegato non riuscita" | Assicurati che il nome del campo ID dell'oggetto corrisponda all'oggetto di destinazione |
+
+## Correlati
+
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)
+* [Funzioni logiche](/l/it/user-guide/workflows/capabilities/workflow-actions#code)
+* [Genera un preventivo o una fattura da Twenty](/l/it/user-guide/workflows/how-tos/connect-to-other-tools/generate-quote-or-invoice-from-twenty)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/connect-to-other-tools/generate-quote-or-invoice-from-twenty.mdx

@@ -0,0 +1,144 @@
+---
+title: Genera un preventivo o una fattura da Twenty
+description: Crea automaticamente fatture negli strumenti esterni quando le opportunità vengono chiuse.
+---
+
+Invia automaticamente i dati dell'opportunità al tuo sistema di fatturazione (Stripe, QuickBooks, Xero, ecc.) quando un'opportunità è chiusa come vinta.
+
+## Struttura del flusso di lavoro
+
+1. **Trigger**: Il Record è Aggiornato (Opportunità)
+2. **Filtro**: Fase = Closed Won
+3. **Search Record**: Recupera i dettagli dell'azienda
+4. **Code** (opzionale): Formatta il payload
+5. **HTTP Request**: Invia al sistema di fatturazione
+
+## Passaggio 1: Configura il trigger
+
+1. Crea un nuovo flusso di lavoro
+2. Seleziona il trigger **Record is Updated**
+3. Scegli **Opportunity** come oggetto
+
+## Passaggio 2: Filtra per Closed Won
+
+Aggiungi un'azione **Filtro** per proseguire solo quando l'opportunità è chiusa come vinta:
+
+| Impostazione   | Valore                                  |
+| -------------- | --------------------------------------- |
+| **Campo**      | Fase                                    |
+| **Condizione** | Uguale a                                |
+| **Valore**     | `CLOSED_WON` (o il nome della tua fase) |
+
+<Tip>
+Il trigger si attiva a ogni aggiornamento di un'Opportunità. Il filtro garantisce che il flusso di lavoro prosegua solo quando la fase cambia in Closed Won.
+</Tip>
+
+## Passaggio 3: Ottieni i dettagli dell'azienda
+
+Il record Opportunity potrebbe non includere tutti i campi dell'azienda necessari per la fattura. Aggiungi un'azione **Search Record**:
+
+| Impostazione           | Valore                                     |
+| ---------------------- | ------------------------------------------ |
+| **Oggetto**            | Azienda                                    |
+| **Corrispondenza per** | ID uguale a `{{trigger.object.companyId}}` |
+
+Questo recupera il record completo dell'azienda con indirizzo di fatturazione, partita IVA, ecc.
+
+## Passaggio 4: Formatta il payload (opzionale)
+
+Se il tuo sistema di fatturazione richiede un formato specifico, aggiungi un'azione **Code**:
+
+```javascript
+export const main = async (params: {
+  opportunity: any;
+  company: any;
+}): Promise<object> => {
+  const { opportunity, company } = params;
+
+  return {
+    invoice: {
+      // Customer info from Company
+      customer_name: company.name,
+      customer_email: company.email || "",
+      billing_address: {
+        line1: company.address?.street || "",
+        city: company.address?.city || "",
+        postal_code: company.address?.postalCode || "",
+        country: company.address?.country || ""
+      },
+      tax_id: company.taxId || null,
+
+      // Invoice details from Opportunity
+      amount: opportunity.amount,
+      currency: opportunity.currency || "USD",
+      description: `Invoice for ${opportunity.name}`,
+      due_days: 30,
+
+      // Reference back to Twenty
+      metadata: {
+        opportunity_id: opportunity.id,
+        company_id: company.id
+      }
+    }
+  };
+};
+```
+
+## Passaggio 5: Invia al sistema di fatturazione
+
+Aggiungi un'azione **HTTP Request**:
+
+| Impostazione     | Valore                                          |
+| ---------------- | ----------------------------------------------- |
+| **Metodo**       | POST                                            |
+| **URL**          | L'endpoint API del tuo sistema di fatturazione  |
+| **Intestazioni** | `Authorization: Bearer YOUR_API_KEY`            |
+| **Corpo**        | `{{code.invoice}}` o mappa direttamente i campi |
+
+### Esempio: Fattura Stripe
+
+```
+POST https://api.stripe.com/v1/invoices
+Headers:
+  Authorization: Bearer sk_live_xxx
+  Content-Type: application/x-www-form-urlencoded
+
+Body:
+  customer: {{company.stripeCustomerId}}
+  collection_method: send_invoice
+  days_until_due: 30
+```
+
+### Esempio: Fattura QuickBooks
+
+```
+POST https://quickbooks.api.intuit.com/v3/company/{realmId}/invoice
+Headers:
+  Authorization: Bearer YOUR_ACCESS_TOKEN
+  Content-Type: application/json
+
+Body: {{code.invoice}}
+```
+
+## Riepilogo completo del flusso di lavoro
+
+| Passaggio | Azione                  | Scopo                                                     |
+| --------- | ----------------------- | --------------------------------------------------------- |
+| 1         | Trigger: Record Updated | Si attiva a ogni modifica di un'Opportunità               |
+| 2         | Filtro                  | Procedi solo se Fase = Closed Won                         |
+| 3         | Search Record           | Ottieni tutti i dettagli dell'azienda per la fatturazione |
+| 4         | Codice                  | Formatta i dati per l'API di fatturazione                 |
+| 5         | Richiesta HTTP          | Crea la fattura in un sistema esterno                     |
+
+## Suggerimenti
+
+* **Memorizza gli ID esterni**: Salva l'ID della fattura restituito dall'API nell'Opportunity utilizzando un'azione **Update Record**
+* **Gestione degli errori**: Aggiungi un ramo per inviare una notifica se la richiesta HTTP non riesce
+* **Prima prova**: Usa la modalità sandbox/test del tuo sistema di fatturazione prima di andare in produzione
+
+## Correlati
+
+* [Generare un PDF da Twenty](/l/it/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty) — allegare i PDF generati ai record
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Automazioni Closed Won](/l/it/user-guide/workflows/how-tos/crm-automations/closed-won-automations)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger.mdx

@@ -0,0 +1,170 @@
+---
+title: Configura un trigger webhook
+description: Ricevi dati da servizi esterni per attivare i flussi di lavoro.
+---
+
+I trigger webhook consentono ai servizi esterni di avviare i tuoi flussi di lavoro inviando dati a un URL univoco. Usali per connettere moduli, app di terze parti e integrazioni personalizzate.
+
+## Quando utilizzare i webhook
+
+| Caso d'uso                      | Esempio                                      |
+| ------------------------------- | -------------------------------------------- |
+| **Moduli web**                  | Gli invii del modulo di contatto creano lead |
+| **App di terze parti**          | Pagamento Stripe → crea un record cliente    |
+| **Integrazioni personalizzate** | La tua app → automazione Twenty              |
+| **Strumenti no-code**           | Connessioni Zapier, Make, n8n                |
+
+## Configurazione passo-passo
+
+### Passaggio 1: Crea il flusso di lavoro
+
+1. Vai a **Impostazioni → Flussi di lavoro**
+2. Fai clic su **+ Nuovo flusso di lavoro**
+3. Assegnagli un nome (ad es., "Invio modulo sito web")
+
+### Passaggio 2: Configura il trigger webhook
+
+1. Fai clic sul blocco del trigger
+2. Seleziona **Webhook**
+3. Riceverai un URL webhook univoco come:
+   ```
+   https://api.twenty.com/webhooks/workflow/abc123...
+   ```
+4. Copia questo URL—ti servirà per il tuo servizio esterno
+
+### Passaggio 3: Definisci la struttura dati attesa
+
+Per le richieste **POST**, definisci la struttura del corpo prevista:
+
+1. Fai clic su **Definisci corpo previsto**
+2. Inserisci un JSON di esempio che corrisponda a ciò che il tuo servizio invierà:
+
+```json
+{
+  "firstName": "John",
+  "lastName": "Doe",
+  "email": "john@example.com",
+  "company": "Acme Inc",
+  "message": "Interested in your product"
+}
+```
+
+3. Fai clic su **Salva**—questo crea variabili che puoi usare nei passaggi successivi
+
+### Passaggio 4: Aggiungi azioni
+
+Ora aggiungi azioni che utilizzano i dati del webhook:
+
+**Esempio: Crea un record Persona**
+
+1. Aggiungi l'azione **Crea record**
+2. Seleziona l'oggetto **People**
+3. Mappa i campi:
+
+| Campo   | Valore                                            |
+| ------- | ------------------------------------------------- |
+| Nome    | `{{trigger.body.firstName}}`                      |
+| Cognome | `{{trigger.body.lastName}}`                       |
+| Email   | `{{trigger.body.email}}`                          |
+| Azienda | Cerca o crea in base a `{{trigger.body.company}}` |
+
+### Passaggio 5: Testa il webhook
+
+Prima di attivare, testa il tuo webhook:
+
+**Utilizzando cURL**:
+
+```bash
+curl -X POST https://api.twenty.com/webhooks/workflow/abc123... \
+  -H "Content-Type: application/json" \
+  -d '{"firstName":"Test","lastName":"User","email":"test@example.com"}'
+```
+
+**Utilizzando Postman o simili**:
+
+1. Crea una richiesta POST verso l'URL del tuo webhook
+2. Imposta l'header Content-Type su `application/json`
+3. Aggiungi il body JSON di test
+4. Invia e controlla le esecuzioni del flusso di lavoro
+
+### Passaggio 6: Attiva
+
+Una volta testato, fai clic su **Attiva** per rendere operativo il flusso di lavoro.
+
+## Gestione di strutture dati diverse
+
+### Dati annidati
+
+Se il tuo webhook invia dati annidati:
+
+```json
+{
+  "contact": {
+    "name": "John Doe",
+    "email": "john@example.com"
+  },
+  "source": "website"
+}
+```
+
+Fai riferimento con: `{{trigger.body.contact.email}}`
+
+### Array
+
+Se i dati includono array:
+
+```json
+{
+  "items": [
+    {"name": "Product A", "qty": 2},
+    {"name": "Product B", "qty": 1}
+  ]
+}
+```
+
+Il modo in cui gestisci gli array dipende dal caso d'uso:
+
+**Numero di elementi sconosciuto → Usa Iterator**
+
+Se devi elaborare ogni elemento dell'array (ad es., creare un record per ciascuno), aggiungi un'azione **Code** per analizzare l'array, quindi usa **Iterator**:
+
+```javascript
+export const main = async (params: { items: any }) => {
+  const items = typeof params.items === "string"
+    ? JSON.parse(params.items)
+    : params.items;
+  return { items };
+};
+```
+
+Quindi usa Iterator per iterare su: `{{code.items}}`
+
+**Campi noti/specifici → Estrai in campi denominati**
+
+Se l'array contiene campi specifici a cui vuoi accedere singolarmente (ad es., risposte di un modulo in cui la posizione 0 è sempre "nome", la posizione 1 è sempre "cognome"), aggiungi un'azione **Code** per estrarli:
+
+```javascript
+export const main = async (params: { items: any }) => {
+  const items = typeof params.items === "string"
+    ? JSON.parse(params.items)
+    : params.items;
+
+  return {
+    product: {
+      name: items[0]?.name || "",
+      qty: items[0]?.qty || 0
+    }
+  };
+};
+```
+
+Ora puoi selezionare `product.name` e `product.qty` singolarmente nei passaggi successivi.
+
+<Tip>
+Per maggiori dettagli sulla gestione degli array, vedi [Gestire gli array nelle azioni Code](/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions).
+</Tip>
+
+## Correlati
+
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/crm-automations/auto-reply-to-inbound-emails.mdx

@@ -0,0 +1,121 @@
+---
+title: Risposta automatica alle email in arrivo
+description: Crea un flusso di lavoro che utilizza l'IA per smistare le email in arrivo e inviare automaticamente risposte in thread.
+---
+
+Rispondi alle email in arrivo in pochi secondi — non ore. Questo flusso di lavoro utilizza un agente IA per filtrare il rumore (newsletter, spam, auto-replies) e redigere una risposta personalizzata ai messaggi reali. Poi, AI lo invia come risposta filettata all'interno della conversazione originale.
+
+## Come funziona il threading delle email
+
+Ogni email include un'intestazione nascosta `Message-ID` — un'impronta univoca assegnata dal server di posta del mittente. Quando rispondi a un'email, il tuo client di posta imposta un'intestazione `In-Reply-To` che fa riferimento a quell'impronta. È così che Gmail, Outlook e tutti gli altri client raggruppano i messaggi nei thread.
+
+In Twenty, quell'impronta è memorizzata come `headerMessageId` sull'oggetto Message. Il tuo flusso di lavoro la recupera e la passa al campo In-Reply-To dell'azione Send Email.
+
+## Creazione del flusso di lavoro
+
+### Passaggio 1: Crea un nuovo flusso di lavoro
+
+Vai a **Impostazioni -> Flussi di lavoro** e fai clic su **+ New Workflow**.
+
+### Passaggio 2: Imposta il trigger sui messaggi in arrivo
+
+Scegli **When a Record is Created** e seleziona **Messages**.
+
+Ogni volta che un'email arriva in Twenty, questo si attiva.
+
+<img src="/images/user-guide/workflows/auto-reply/workflow-overview.png" style={{width:'100%'}} />
+
+### Passaggio 3: Cerca chi l'ha inviato
+
+Aggiungi un'azione **Search Records**.
+
+L'indirizzo del mittente non è presente sul messaggio stesso — si trova nel record Message Participant correlato.
+
+| Campo       | Valore                          |
+| ----------- | ------------------------------- |
+| **Oggetto** | Partecipanti al messaggio       |
+| **Filtro**  | Message **is** `{{trigger.id}}` |
+| **Filtro**  | Role **is** From                |
+| **Limite**  | 1                               |
+
+Questo ti fornisce l'email del mittente in `handle` e il suo nome in `displayName`.
+
+<img src="/images/user-guide/workflows/auto-reply/find-sender.png" style={{width:'100%'}} />
+
+### Passo 4: Triage e bozza una risposta con AI
+
+Aggiungi un'azione **AI Agent**. Questo singolo passaggio fa due cose: decide se l'email merita una risposta e, in tal caso, ne scrive una.
+
+Usa un prompt come:
+
+```
+You are an email triage assistant for a sales team. Read the following
+inbound email and decide if it deserves a reply.
+
+Subject: {{trigger.subject}}
+Body: {{trigger.text}}
+From: {{Find Sender.first.displayName}} ({{Find Sender.first.handle}})
+
+If this email is spam, a newsletter, an automated notification, or
+otherwise does not need a human reply, respond with exactly: SKIP
+
+Otherwise, write a short, professional reply (3-4 sentences max) that:
+- Acknowledges their specific message
+- Lets them know someone from the team will follow up shortly
+- Is warm but not overly casual
+
+Respond with only the reply text, no subject line or greeting prefix.
+```
+
+AI Agent produce la sua risposta in un campo `response` a cui i passaggi successivi possono fare riferimento.
+
+<img src="/images/user-guide/workflows/auto-reply/ai-triage.png" style={{width:'100%'}} />
+
+### Passaggio 5: Ramifica in base alla decisione dell'AI
+
+Aggiungi un'azione **If/Else** per verificare se l'AI ha deciso di rispondere o saltare.
+
+| Campo          | Valore                                          |
+| -------------- | ----------------------------------------------- |
+| **Condizione** | AI Agent `response` **does not contain** `SKIP` |
+| **Se vero**    | Continua con Send Email                         |
+| **Altrimenti** | Non fare nulla (il flusso di lavoro termina)    |
+
+Spam, newsletter e messaggi generati automaticamente vengono scartati. Tutto il resto passa al passaggio successivo.
+
+<img src="/images/user-guide/workflows/auto-reply/should-reply.png" style={{width:'100%'}} />
+
+### Passaggio 6: Invia una risposta nello stesso thread
+
+Aggiungi un'azione **Send Email** nel ramo "if true". Fai clic su **Advanced options**, quindi su **Add In-Reply-To**.
+
+| Campo           | Valore                                 |
+| --------------- | -------------------------------------- |
+| **A**           | `{{Find Sender.first.handle}}`         |
+| **Oggetto**     | `Re: {{trigger.subject}}`              |
+| **Corpo**       | `{{AI Triage & Draft Reply.response}}` |
+| **In-Reply-To** | `{{trigger.headerMessageId}}`          |
+
+Il campo In-Reply-To è ciò che rende questo un messaggio di risposta invece di una nuova conversazione. Il destinatario lo vede nel thread sotto l'email originale in Gmail, Outlook o qualsiasi altro client.
+
+<img src="/images/user-guide/workflows/auto-reply/send-email.png" style={{width:'100%'}} />
+
+<Tip>
+**In-Reply-To** si aspetta un `message.headerMessageId` dal trigger — è l'impronta univoca dell'email, non un indirizzo del destinatario. Se lo lasci vuoto, l'email viene comunque inviata, solo come messaggio autonomo.
+</Tip>
+
+<Warning>
+Gmail usa l'oggetto per raggruppare i messaggi nei thread. L'oggetto **deve** iniziare con `Re:` (inclusi i due punti e lo spazio) affinché Gmail visualizzi la risposta all'interno del thread originale. Senza di esso, la risposta apparirà come una conversazione separata — anche se l'intestazione In-Reply-To è impostata correttamente.
+</Warning>
+
+### Passaggio 7: Testa e attiva
+
+Fai clic su **Test**, quindi controlla il tuo client di posta. La risposta dovrebbe comparire annidata sotto il messaggio originale.
+
+Attivalo quando sei soddisfatto.
+
+## Idee per sviluppare ulteriormente
+
+* **Rispondi solo ai VIP** — aggiungi un ramo che controlli il dominio del mittente o se esiste come Contatto in Twenty
+* **Instrada in base all'intento** — usa prompt distinti di AI Agent per gestire le richieste commerciali in modo diverso rispetto a quelle di supporto
+* **Arricchisci prima di rispondere** — aggiungi un passaggio Search Records per inserire nel prompt dell'AI l'azienda del mittente o la cronologia delle trattative per risposte più personalizzate

packages/twenty-docs/l/it/user-guide/workflows/how-tos/crm-automations/closed-won-automations.mdx

@@ -0,0 +1,179 @@
+---
+title: Automazioni per trattative chiuse come vinte
+description: Automatizza le attività post-vittoria quando le opportunità vengono chiuse.
+---
+
+Quando una trattativa si chiude, devono succedere più cose: aggiornare lo stato dell'azienda, notificare i membri del team, creare attività di onboarding. Automatizza tutto questo con un unico flusso di lavoro.
+
+## Il problema
+
+Quando un'opportunità passa a "Chiusa vinta":
+
+* Il tipo di azienda deve passare da "Potenziale cliente" a "Cliente"
+* Devono essere create le attività di onboarding
+* Il team di Customer Success deve essere avvisato
+* Il rappresentante commerciale ha bisogno di una conferma
+
+Farlo manualmente richiede tempo ed è soggetto a errori.
+
+## La soluzione
+
+Crea un flusso di lavoro che gestisca automaticamente tutte le attività post-vittoria.
+
+## Configurazione completa del flusso di lavoro
+
+### Passaggio 1: Crea il flusso di lavoro
+
+1. Vai a **Impostazioni → Flussi di lavoro**
+2. Fai clic su **+ Nuovo flusso di lavoro**
+3. Assegna il nome "Trattativa vinta - Automazione post-vittoria"
+
+### Passaggio 2: Configura il trigger
+
+1. Seleziona **Record is Updated**
+2. Seleziona **Opportunità**
+3. In "Fields to monitor", seleziona **Stage**
+
+### Passaggio 3: Aggiungi un filtro sulla fase
+
+1. Aggiungi l'azione **Filter**
+2. Condizione: `{{trigger.object.stage}}` uguale a "Chiusa vinta"
+
+### Passaggio 4: Aggiorna il tipo di azienda
+
+1. Aggiungi l'azione **Update Record**
+2. Configura:
+
+| Campo                           | Valore                          |
+| ------------------------------- | ------------------------------- |
+| **Oggetto**                     | Aziende                         |
+| **Record**                      | `{{trigger.object.company.id}}` |
+| **Tipo**                        | Cliente                         |
+| **Data della prima trattativa** | `{{trigger.object.closedAt}}`   |
+| **Proprietario dell'account**   | `{{trigger.object.owner.id}}`   |
+
+### Passaggio 5: Crea un'attività di onboarding
+
+1. Aggiungi l'azione **Create Record**
+2. Configura:
+
+| Campo                     | Valore                                                                                                                 |
+| ------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| **Oggetto**               | Attività                                                                                                               |
+| **Titolo**                | `Onboarding: {{trigger.object.name}}`                                                                                  |
+| **Assegnatario**          | Membro del team di Customer Success                                                                                    |
+| **Data di scadenza**      | Tra 3 giorni                                                                                                           |
+| **Priorità**              | Alta                                                                                                                   |
+| **Azienda correlata**     | `{{trigger.object.company.id}}`                                                                                        |
+| **Opportunità correlata** | `{{trigger.object.id}}`                                                                                                |
+| **Descrizione**           | `Onboarding del nuovo cliente per {{trigger.object.company.name}}. Valore della trattativa: {{trigger.object.amount}}` |
+
+### Passaggio 6: Notifica il team di Customer Success
+
+1. Aggiungi l'azione **Send Email**
+2. Configura:
+
+| Campo       | Valore                                              |
+| ----------- | --------------------------------------------------- |
+| **A**       | customer-success@yourcompany.com                    |
+| **Oggetto** | `🎉 Nuovo cliente: {{trigger.object.company.name}}` |
+| **Corpo**   | Vedi l'esempio sotto                                |
+
+**Esempio di corpo dell'email**:
+
+```
+Hi CS Team,
+
+We have a new customer!
+
+Company: {{trigger.object.company.name}}
+Deal: {{trigger.object.name}}
+Value: {{trigger.object.amount}}
+Sales Rep: {{trigger.object.owner.name}}
+Close Date: {{trigger.object.closedAt}}
+
+An onboarding task has been created automatically.
+
+Let's give them a great start!
+```
+
+### Passaggio 7: Conferma al rappresentante commerciale
+
+1. Aggiungi un'altra azione **Send Email**
+2. Configura:
+
+| Campo       | Valore                                                                                                                        |
+| ----------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| **A**       | `{{trigger.object.owner.email}}`                                                                                              |
+| **Oggetto** | `✅ Trattativa chiusa: {{trigger.object.name}}`                                                                                |
+| **Corpo**   | Congratulazioni! La tua trattativa è stata elaborata. Il team di Customer Success è stato avvisato e l'onboarding è iniziato. |
+
+### Passaggio 8: Testa e attiva
+
+1. Esegui un test spostando un'opportunità di prova su "Chiusa vinta"
+2. Verifica:
+   * Il tipo di azienda è stato modificato in "Cliente"
+   * Attività di onboarding creata
+   * Il team di Customer Success ha ricevuto l'email
+   * Il rappresentante commerciale ha ricevuto la conferma
+3. Attiva quando sei pronto
+
+## Gestione di "Chiusa persa"
+
+Crea un flusso di lavoro simile per le trattative perse:
+
+### Scatenante
+
+* Record is Updated (Opportunità, Fase = "Chiusa persa")
+
+### Azioni
+
+1. **Create Record**: Attività per "Analisi trattativa persa"
+2. **Update Record**: Aggiungi il motivo della perdita al record dell'azienda
+3. **Send Email**: Notifica il responsabile della trattativa persa
+
+## Avanzato: Onboarding a più fasi
+
+Per un onboarding complesso, crea più attività:
+
+```javascript
+export const main = async (params) => {
+  const tasks = [
+    { title: "Welcome call", daysFromNow: 1, assignee: "CS" },
+    { title: "Send onboarding materials", daysFromNow: 2, assignee: "CS" },
+    { title: "Technical setup", daysFromNow: 5, assignee: "Support" },
+    { title: "30-day check-in", daysFromNow: 30, assignee: "CS" }
+  ];
+
+  return { tasks };
+};
+```
+
+Usa **Iterator** per creare ogni attività a partire dall'array.
+
+## Idee di personalizzazione
+
+### Mantieni aggiornati gli altri strumenti
+
+* Crea il cliente nel sistema di fatturazione con una **HTTP Request**
+
+### Azioni condizionali
+
+Usa le azioni **Filter** per:
+
+* Onboarding diverso per Enterprise rispetto alle PMI
+* Assegnatari diversi in base alla regione
+* Salta le notifiche per le trattative di piccolo valore
+
+### Includi dettagli offerta
+
+Usa l'azione **Code** per formattare:
+
+* Documenti riepilogativi della trattativa
+* Note di passaggio per il team di Customer Success
+* Checklist di onboarding personalizzate
+
+## Correlati
+
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Inviare email dai flussi di lavoro](/l/it/user-guide/workflows/capabilities/send-emails-from-workflows)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/crm-automations/detect-stale-opportunities.mdx

@@ -0,0 +1,136 @@
+---
+title: Rileva opportunità stagnanti
+description: Notifica automaticamente i responsabili quando le opportunità non sono state aggiornate.
+---
+
+Mantieni in salute la tua pipeline avvisando i responsabili quando le opportunità diventano stagnanti. Questo flusso di lavoro verifica le opportunità che non sono state aggiornate in un numero di giorni specificato.
+
+## Il problema
+
+Le opportunità senza aggiornamenti comportano:
+
+* Trattative che si raffreddano
+* Previsioni inaffidabili
+* Perdita di ricavi
+
+## La soluzione
+
+Crea un flusso di lavoro pianificato che individua le opportunità stagnanti e invia un'email ai loro responsabili.
+
+## Configurazione passo-passo
+
+### Passaggio 1: Crea il flusso di lavoro
+
+1. Vai a **Impostazioni → Flussi di lavoro**
+2. Fai clic su **+ Nuovo flusso di lavoro**
+3. Assegna il nome "Avviso di opportunità stagnanti"
+
+### Passaggio 2: Configura il trigger
+
+1. Seleziona **On a Schedule**
+2. Imposta l'esecuzione giornaliera (ad es., ogni giorno alle 8:00)
+
+### Passaggio 3: Cerca le opportunità stagnanti
+
+1. Aggiungi un'azione **Search Records**
+2. Configura:
+
+| Campo       | Valore                                         |
+| ----------- | ---------------------------------------------- |
+| **Oggetto** | Opportunità                                    |
+| **Filtro**  | Updated At è precedente a (oggi - 7 giorni)    |
+| **Filtro**  | Stage non è "Closed Won" AND non "Closed Lost" |
+| **Limite**  | 100                                            |
+
+### Passaggio 4: Verifica se ne sono state trovate
+
+1. Aggiungi l'azione **Filter**
+2. Condizione: `{{searchRecords.length}}` è maggiore di 0
+3. Se non ci sono opportunità stagnanti, il flusso di lavoro si ferma qui
+
+### Passaggio 5: Formatta l'avviso (azione Code)
+
+Aggiungi un'azione **Code** per formattare l'email:
+
+```javascript
+export const main = async (params) => {
+  const opportunities = params.opportunities;
+
+  // Group opportunities by owner
+  const byOwner = {};
+  opportunities.forEach(opp => {
+    const ownerEmail = opp.owner?.email || 'unassigned';
+    if (!byOwner[ownerEmail]) {
+      byOwner[ownerEmail] = [];
+    }
+    byOwner[ownerEmail].push({
+      name: opp.name,
+      amount: opp.amount,
+      lastUpdated: opp.updatedAt,
+      stage: opp.stage
+    });
+  });
+
+  // Format summary for manager
+  let summary = "Stale Opportunities Report\n\n";
+  Object.entries(byOwner).forEach(([owner, opps]) => {
+    summary += `${owner}: ${opps.length} stale opportunities\n`;
+    opps.forEach(opp => {
+      summary += `  - ${opp.name} (${opp.stage})\n`;
+    });
+    summary += "\n";
+  });
+
+  return {
+    summary,
+    totalCount: opportunities.length
+  };
+};
+```
+
+### Passaggio 6: Invia l'email di avviso
+
+Aggiungi l'azione **Send Email**:
+
+| Campo       | Valore                                                               |
+| ----------- | -------------------------------------------------------------------- |
+| **A**       | sales-manager@yourcompany.com                                        |
+| **Oggetto** | `🚨 {{code.totalCount}} opportunità stagnanti richiedono attenzione` |
+| **Corpo**   | `{{code.summary}}`                                                   |
+
+### Passaggio 7: Testa e attiva
+
+1. Fai clic su **Test** per eseguire il flusso di lavoro
+2. Verifica che l'email contenga i dati corretti
+3. Attiva quando sei pronto
+
+## Opzioni di personalizzazione
+
+### Modifica la soglia di stagnazione
+
+Modifica il filtro di **Search Records** per passare da 7 giorni al periodo preferito:
+
+* 3 giorni per vendite ad alta velocità
+* 14 giorni per trattative enterprise
+* 30 giorni per cicli di vendita lunghi
+
+### Avvisa i singoli rappresentanti
+
+Invece di un'unica email al responsabile, usa **Iterator** per inviare email personalizzate a ciascun rappresentante sulle proprie trattative stagnanti.
+
+### Aggiungi un'escalation
+
+Crea più flussi di lavoro con gravità crescente:
+
+1. Giorno 7: Email al rappresentante
+2. Giorno 14: Email al rappresentante + al responsabile
+3. Giorno 21: Crea un'attività per il responsabile affinché intervenga
+
+### Includi in Slack
+
+Usa **HTTP Request** per inviare a un webhook Slack invece o in aggiunta all'email.
+
+## Correlati
+
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Inviare email dai flussi di lavoro](/l/it/user-guide/workflows/capabilities/send-emails-from-workflows)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/crm-automations/display-number-of-emails-received.mdx

@@ -0,0 +1,69 @@
+---
+title: Visualizza il numero di email ricevute
+description: Crea un flusso di lavoro per contare e visualizzare automaticamente il numero di email ricevute da ciascun contatto.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<img src="/images/user-guide/workflows/workflow-number-of-emails-received.png" style={{width:'100%'}} />
+
+## Panoramica
+
+Questo flusso di lavoro si attiva ogni volta che viene ricevuta una nuova email e aggiorna un campo personalizzato sul record Persona con il conteggio totale delle email provenienti da quel mittente.
+
+## Prerequisiti
+
+Prima di configurare questo flusso di lavoro, crea un campo personalizzato sull'oggetto **People**:
+
+1. Vai a **Impostazioni → Modello dati → People**
+2. Aggiungi un nuovo campo **Number**
+3. Assegnagli un nome come "Numero di email ricevute da questa persona"
+
+## Configurazione passo-passo
+
+<VimeoEmbed videoId="1148700336" title="Dimostrazione video" />
+
+### Passaggio 1: Configura il trigger
+
+1. Vai su **Flussi di lavoro** e crea un nuovo flusso di lavoro
+2. Seleziona **Record is Created** come trigger
+3. Scegli **Message Participants** (disponibile sotto Oggetti avanzati)
+
+<Note>
+Un Message Participant è una combinazione di un ID messaggio e di un ID persona, che crea un record univoco per ogni messaggio. Questo è più semplice da tracciare rispetto ai Messaggi direttamente perché possiamo accedere al campo `handle`, che contiene l'indirizzo email del mittente (o del destinatario).
+</Note>
+
+### Passaggio 2: Filtra per ruolo
+
+1. Aggiungi l'azione **Filter**
+2. Imposta la condizione: **Role** uguale a **FROM**
+
+Questo garantisce che tu conteggi solo i messaggi inviati da questa persona, non quelli inviati a questa persona.
+
+### Passaggio 3: Cerca tutti i Message Participants con lo stesso handle
+
+1. Aggiungi un'azione **Search Records**
+2. Seleziona **Message Participants** come oggetto
+3. Aggiungi dei filtri: **Handle** uguale all'handle del trigger (l'indirizzo email del mittente) e **Role** uguale a **FROM**
+4. Aumenta il **Limit** da 1 a **200** (il massimo)
+
+In questo modo si trovano tutti i messaggi provenienti da questo indirizzo email per ottenere il conteggio totale.
+
+<Note>
+L'azione Search Records è limitata a restituire al massimo 200 record. Tuttavia, poiché stai usando solo il valore `totalCount` (non i singoli record), questo passaggio restituirà il numero totale di email inviate da questa persona.
+</Note>
+
+### Passaggio 4: Aggiorna il record Persona con un'azione Create or Update Record
+
+1. Aggiungi un'azione **Create or Update Record**
+2. Seleziona **People** come oggetto
+3. Trova la persona facendo corrispondere la sua email all'`handle` del Message Participant
+4. Imposta il tuo campo personalizzato "Numero di email ricevute" su `{{searchRecords.totalCount}}`
+
+Il valore `totalCount` dell'azione Search Records rappresenta il numero totale di email ricevute da questa persona.
+
+## Correlati
+
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Crea campi personalizzati](/l/it/user-guide/data-model/how-tos/customize-your-data-model)
+* [Azione Search Records](/l/it/user-guide/workflows/capabilities/workflow-actions#search-records)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/crm-automations/display-related-record-data.mdx

@@ -0,0 +1,170 @@
+---
+title: Visualizza i dati dei record correlati
+description: Mostra i dati dei record correlati (ad es., informazioni sull'Azienda nelle Opportunità) usando i flussi di lavoro.
+---
+
+Visualizza i dati dei record correlati direttamente sui tuoi record — ad esempio, mostra il numero di dipendenti di un'Azienda nelle sue Opportunità. Questa soluzione alternativa con i flussi di lavoro è utile finché i campi annidati non sono disponibili nativamente.
+
+## Casi d'Uso Comuni
+
+| Fonte       | Destinazione | Campi da copiare                                          |
+| ----------- | ------------ | --------------------------------------------------------- |
+| Azienda     | Opportunità  | Settore, Dimensione aziendale, ARR                        |
+| Persona     | Opportunità  | Email, Telefono, Qualifica                                |
+| Opportunità | Azienda      | Importo dell'ultimo affare, Data dell'ultimo affare vinto |
+
+## Copia di campi di base
+
+### Esempio: copia l'Email del contatto nell'Opportunità
+
+**Obiettivo**: Quando imposti un Punto di contatto su un'opportunità, copia la sua email nell'opportunità per un accesso rapido.
+
+### Prerequisito
+
+Crea i campi di destinazione in **Impostazioni → Modello dati → Opportunità** prima di creare il flusso di lavoro:
+
+* Email del contatto (tipo: Email)
+* Telefono del contatto (tipo: Telefono)
+
+### Impostazione
+
+1. **Trigger**: Il record è aggiornato (Opportunità, campo Punto di contatto)
+
+2. **Filtro**: Verifica che il Punto di contatto non sia vuoto
+
+3. **Cerca record**: Trova la persona collegata
+   * Oggetto: Persone
+   * Filtro: ID uguale a `{{trigger.object.pointOfContact.id}}`
+
+4. **Aggiorna record**:
+   * Oggetto: Opportunità
+   * Record: `{{trigger.object.id}}`
+   * Email del contatto: `{{searchRecords[0].email}}`
+   * Telefono del contatto: `{{searchRecords[0].phone}}`
+
+## Copia di più campi
+
+### Esempio: sincronizza le informazioni dell'Azienda con tutte le Opportunità correlate
+
+**Obiettivo**: Quando i dettagli dell'azienda cambiano, aggiorna tutte le opportunità correlate.
+
+### Impostazione
+
+1. **Trigger**: Il record è aggiornato (Aziende)
+   * Campi: Settore, Dimensione aziendale, Ricavi annuali
+
+2. **Cerca record**: Trova tutte le opportunità per questa azienda
+   * Oggetto: Opportunità
+   * Filtro: ID Azienda uguale a `{{trigger.object.id}}`
+
+3. **Iteratore**: Itera su ciascuna opportunità
+
+4. **Aggiorna record** (all'interno dell'iteratore):
+   * Oggetto: Opportunità
+   * Record: `{{iterator.currentItem.id}}`
+   * Settore aziendale: `{{trigger.object.industry}}`
+   * Dimensione aziendale: `{{trigger.object.companySize}}`
+   * ARR dell'azienda: `{{trigger.object.annualRevenue}}`
+
+## Copia alla creazione del record
+
+### Esempio: precompila l'Opportunità con i dati dell'Azienda
+
+**Obiettivo**: Quando crei un'opportunità collegata a un'azienda, copia automaticamente le informazioni principali dell'azienda.
+
+### Prerequisito
+
+Crea i campi di destinazione in **Impostazioni → Modello dati → Opportunità**:
+
+* Settore aziendale (tipo: Testo)
+* Dimensione aziendale (tipo: Numero)
+
+### Impostazione
+
+1. **Trigger**: Il record è creato (Opportunità)
+   * Filtro: l'Azienda non è vuota
+
+2. **Cerca record**: Recupera i dettagli dell'azienda collegata
+   * Oggetto: Aziende
+   * Filtro: ID uguale a `{{trigger.object.company.id}}`
+
+3. **Aggiorna record**:
+   * Oggetto: Opportunità
+   * Record: `{{trigger.object.id}}`
+   * Settore aziendale: `{{searchRecords[0].industry}}`
+   * Dimensione aziendale: `{{searchRecords[0].employees}}`
+
+<Note>
+**Limitazione di Attività e Note**: Le relazioni su Attività e Note sono codificate come molte-a-molte e non sono ancora disponibili nei trigger o nelle azioni dei flussi di lavoro. Per accedere a queste relazioni, usa invece le [API](/l/it/developers/extend/api).
+</Note>
+
+## Sincronizzazione bidirezionale
+
+### Esempio: mantieni sincronizzato il Contatto principale
+
+**Obiettivo**: Quando cambia il contatto principale di un'azienda, aggiorna il contatto. Quando una persona diventa principale, aggiorna l'azienda.
+
+### Flusso di lavoro 1: Azienda → Persona
+
+1. **Trigger**: Il record è aggiornato (Aziende, campo Contatto principale)
+2. **Aggiorna record**: Imposta "È Contatto principale" della persona su true
+3. **Cerca record**: Trova il precedente contatto principale
+4. **Aggiorna record**: Imposta "È Contatto principale" del contatto precedente su false
+
+### Flusso di lavoro 2: Persona → Azienda
+
+1. **Trigger**: Il record è aggiornato (Persone, È Contatto principale = true)
+2. **Aggiorna record**: Imposta il Contatto principale dell'azienda su questa persona
+
+<Note>
+Fai attenzione con le sincronizzazioni bidirezionali per evitare loop infiniti. Usa filtri per verificare che il valore sia effettivamente cambiato prima di aggiornare.
+</Note>
+
+## Uso del codice per mappature complesse
+
+### Esempio: trasformare i dati durante la copia
+
+**Obiettivo**: Copia e formatta il numero di telefono dalla persona all'opportunità.
+
+```javascript
+export const main = async (params) => {
+  const { phone } = params;
+
+  if (!phone) return { formattedPhone: null };
+
+  // Remove non-numeric characters
+  const digits = phone.replace(/\D/g, '');
+
+  // Format as (XXX) XXX-XXXX
+  const formatted = digits.length === 10
+    ? `(${digits.slice(0,3)}) ${digits.slice(3,6)}-${digits.slice(6)}`
+    : phone;
+
+  return { formattedPhone: formatted };
+};
+```
+
+## Migliori Pratiche
+
+### Evita i loop
+
+* Non creare flussi di lavoro che si attivano a vicenda all'infinito
+* Usa condizioni specifiche sui campi
+* Aggiungi controlli per verificare se il valore è effettivamente cambiato
+
+### Gestisci i dati mancanti
+
+* Verifica sempre che il record di origine esista prima di copiare
+* Fornisci valori predefiniti per i campi facoltativi
+* Usa filtri per saltare quando il campo di origine è vuoto
+
+### Prestazioni
+
+* Esegui aggiornamenti in batch quando copi su molti record
+* Usa flussi di lavoro pianificati per operazioni di sincronizzazione in blocco
+* Valuta l'uso dell'Iteratore per aggiornamenti di più record
+
+## Correlati
+
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/crm-automations/formula-fields.mdx

@@ -0,0 +1,202 @@
+---
+title: Campi formula
+description: Crea campi formula usando i flussi di lavoro finché il supporto nativo non sarà disponibile.
+---
+
+Venti non supportano ancora i campi di formula nativi (arrivando nel 2026), ma puoi ottenere lo stesso risultato usando i flussi di lavoro. Questa soluzione alternativa consente di calcolare e compilare automaticamente i valori dei campi — dalle semplici concatenazioni alla logica aziendale più complessa.
+
+## Casi d'Uso Comuni
+
+| Caso d'uso               | Esempio di formula                 |
+| ------------------------ | ---------------------------------- |
+| **Nome completo**        | Nome + " " + Cognome               |
+| **Importo previsto**     | Importo × Probabilità              |
+| **Giorni alla scadenza** | Data di scadenza - Oggi            |
+| **Giorni nella fase**    | Oggi - Data di ingresso nella fase |
+| **Punteggio lead**       | Punti in base a criteri multipli   |
+
+<Tip>
+Per un esempio completo del monitoraggio del tempo nelle fasi della pipeline, vedi [Traccia quanto tempo le opportunità restano in ogni fase](/l/it/user-guide/views-pipelines/how-tos/track-time-in-stage).
+</Tip>
+
+## Formula di base: concatenazione
+
+### Esempio: compilazione automatica del nome completo
+
+**Obiettivo**: combinare automaticamente nome e cognome in un campo nome completo.
+
+### Impostazione
+
+1. **Trigger**: il record viene aggiornato o creato (Persone)
+
+2. **Filtro**: verifica che il nome o il cognome siano cambiati
+
+3. **Azione di codice**:
+
+```javascript
+export const main = async (params) => {
+  const { firstName, lastName } = params;
+
+  const fullName = [firstName, lastName]
+    .filter(Boolean)
+    .join(' ');
+
+  return { fullName };
+};
+```
+
+4. **Aggiorna record**: imposta Nome completo su `{{code.fullName}}`
+
+## Formula numerica: importo previsto
+
+### Esempio: calcolare il ricavo previsto
+
+**Obiettivo**: moltiplicare l'importo dell'opportunità per la probabilità per ottenere l'importo previsto.
+
+Vedi [Come mostrare l'importo previsto nella pipeline](/l/it/user-guide/views-pipelines/how-tos/show-expected-amount-in-pipeline) per il flusso di lavoro completo.
+
+### Impostazione
+
+1. **Trigger**: il record viene aggiornato (Opportunità, campo Importo oppure Probabilità)
+
+2. **Azione di codice**:
+
+```javascript
+export const main = async (params) => {
+  const { amount, probability } = params;
+
+  const expectedAmount = (amount || 0) * (probability || 0) / 100;
+
+  return { expectedAmount };
+};
+```
+
+3. **Aggiorna record**: imposta Importo previsto su `{{code.expectedAmount}}`
+
+## Formula sulle date: calcolo dei giorni
+
+### Esempio: giorni alla scadenza dell'attività
+
+**Obiettivo**: calcolare quanti giorni mancano alla data di scadenza di un'attività.
+
+### Impostazione
+
+1. **Trigger**: il record viene aggiornato o creato (Attività, campo Data di scadenza)
+
+2. **Azione di codice**:
+
+```javascript
+export const main = async (params) => {
+  const { dueDate } = params;
+
+  if (!dueDate) {
+    return { daysUntilDue: null };
+  }
+
+  const due = new Date(dueDate);
+  const today = new Date();
+  const diffTime = due - today;
+  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+
+  return { daysUntilDue: diffDays };
+};
+```
+
+3. **Aggiorna record**: imposta Giorni alla scadenza su `{{code.daysUntilDue}}`
+
+<Note>
+I valori negativi indicano attività scadute. Puoi usare questo campo per filtrare o ordinare le attività per urgenza.
+</Note>
+
+## Formula condizionale: punteggio lead
+
+### Esempio: calcolare il punteggio lead in base a criteri
+
+**Obiettivo**: assegnare un punteggio ai lead in base alla dimensione aziendale, al settore e al coinvolgimento.
+
+### Impostazione
+
+1. **Trigger**: il record viene aggiornato (Persone o Aziende)
+
+2. **Azione di codice**:
+
+```javascript
+export const main = async (params) => {
+  const { companySize, industry, hasEmail, hasPhone, source } = params;
+
+  let score = 0;
+
+  // Company size scoring
+  if (companySize === 'Enterprise') score += 30;
+  else if (companySize === 'Mid-Market') score += 20;
+  else if (companySize === 'SMB') score += 10;
+
+  // Industry scoring
+  const targetIndustries = ['Technology', 'Finance', 'Healthcare'];
+  if (targetIndustries.includes(industry)) score += 25;
+
+  // Contact info scoring
+  if (hasEmail) score += 10;
+  if (hasPhone) score += 15;
+
+  // Source scoring
+  if (source === 'Referral') score += 20;
+  else if (source === 'Website') score += 10;
+
+  return { leadScore: score };
+};
+```
+
+3. **Aggiorna record**: imposta Punteggio lead su `{{code.leadScore}}`
+
+## Formula di testo: estrazione del dominio
+
+### Esempio: estrarre il dominio dall'email
+
+**Obiettivo**: estrarre e archiviare automaticamente il dominio dell'email.
+
+### Impostazione
+
+1. **Trigger**: il record viene aggiornato (Persone, campo Email)
+
+2. **Azione di codice**:
+
+```javascript
+export const main = async (params) => {
+  const { email } = params;
+
+  if (!email) return { domain: null };
+
+  const domain = email.split('@')[1]?.toLowerCase();
+
+  return { domain };
+};
+```
+
+3. **Aggiorna record**: imposta il campo Dominio su `{{code.domain}}`
+
+## Migliori Pratiche
+
+### Prestazioni
+
+* Attiva solo in caso di modifiche ai campi rilevanti
+* Usa filtri per ignorare i record che non richiedono calcolo
+* Evita calcoli complessi in flussi di lavoro ad alto volume
+
+### Gestione degli errori
+
+* Verifica i valori null/undefined prima dei calcoli
+* Usa valori predefiniti quando i dati mancano
+* Restituisci messaggi di errore chiari quando i calcoli falliscono
+
+### Testing
+
+* Esegui test con casi limite (campi vuoti, valori zero)
+* Verifica manualmente i calcoli prima dell'attivazione
+* Monitora le esecuzioni dei flussi di lavoro per risultati imprevisti
+
+## Correlati
+
+* [Come mostrare l'importo previsto nella pipeline](/l/it/user-guide/views-pipelines/how-tos/show-expected-amount-in-pipeline)
+* [Come tracciare il tempo in fase](/l/it/user-guide/views-pipelines/how-tos/track-time-in-stage)
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/crm-automations/notify-teammates-of-note-to-review.mdx

@@ -0,0 +1,127 @@
+---
+title: Notificare ai colleghi una nota da rivedere
+description: Invia notifiche email automatiche quando assegni a un collega la revisione di una nota.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<Note>
+**Menzionare direttamente i colleghi nelle note non è ancora supportato.** Questa funzionalità è prevista per la seconda metà del 2026. Nel frattempo, questo flusso di lavoro fornisce una soluzione alternativa pratica.
+</Note>
+
+## La sfida
+
+Vuoi menzionare un collega in una nota affinché riceva una notifica per rivederla. Al momento, Twenty non supporta le @menzioni nelle note o nelle attività.
+
+## La soluzione alternativa
+
+Invece di menzionare nel testo della nota, puoi:
+
+1. Crea un campo di relazione **Reviewer** sull'oggetto Note
+2. Assegna il revisore quando crei o modifichi la nota
+3. Avere un flusso di lavoro inviare automaticamente una e-mail al revisore con un link alla nota
+
+<Warning>
+**Limitazione**: Questo approccio consente di assegnare un solo revisore per campo. Se devi notificare più persone, crea campi di relazione aggiuntivi (ad es., Reviewer 1, Reviewer 2). Questo non scala bene se devi taggare molti collaboratori in una volta sola.
+</Warning>
+
+## Configurazione passo-passo
+
+### Passaggio 1: Crea il campo Reviewer
+
+<img src="/images/user-guide/workflows/reviewer-field-for-note.png" style={{width:'100%'}} />
+
+1. Vai a **Impostazioni → Modello dati → Note**
+2. Fai clic su **Aggiungi campo**
+3. Configura:
+
+| Impostazione          | Valore                                        |
+| --------------------- | --------------------------------------------- |
+| **Name**              | Reviewer                                      |
+| **Tipo**              | Relazione                                     |
+| **Oggetto correlato** | Membro dello spazio di lavoro                 |
+| **Tipo di relazione** | Molte note → Un membro dello spazio di lavoro |
+
+4. Salva il campo
+
+### Passaggio 2: Crea il flusso di lavoro
+
+<VimeoEmbed videoId="1151897168" title="Dimostrazione video" />
+
+#### Crea il trigger del flusso di lavoro
+
+1. Vai alla vista principale e crea un nuovo flusso di lavoro
+2. Seleziona **Record Updated** come trigger
+3. Scegli **Note** come oggetto e specifica il campo Reviewer.
+4. Questo si attiverà ogni volta che il revisore di una nota viene aggiornato.
+
+#### Aggiungi un filtro per verificare che il revisore sia stato appena assegnato
+
+Aggiungi un'azione **Filtro** per garantire che il flusso di lavoro prosegua solo quando è stato assegnato un revisore:
+
+| Condizione   | Valore      |
+| ------------ | ----------- |
+| **Reviewer** | non è vuoto |
+
+#### Cerca il membro dello spazio di lavoro
+
+1. Aggiungi un'azione **Search Records**
+2. Seleziona **Workspace Member** (nella sezione Oggetti avanzati)
+3. Aggiungi un filtro:
+
+| Condizione | Valore                         |
+| ---------- | ------------------------------ |
+| **ID**     | uguale a `{{note.reviewerId}}` |
+
+Questo recupera il record completo del membro dello spazio di lavoro, inclusi l'indirizzo email e il nome.
+
+#### Invia l'email di notifica
+
+1. Aggiungi un'azione **Send Email**
+2. Configura:
+
+| Campo       | Valore                                              |
+| ----------- | --------------------------------------------------- |
+| **A**       | Search Record → First Workspace Member → User Email |
+| **Oggetto** | Una nota richiede la tua revisione                  |
+| **Corpo**   | Vedi l'esempio sotto                                |
+
+**Esempio di corpo dell'email:**
+
+```text
+Hi {{searchRecord.firstWorkspaceMember.name.firstName}},
+
+You've been assigned to review a note.
+
+View the note here:
+https://yourSubDomain.twenty.com/object/note/{{recordIsUpdated.id}}
+
+Best,
+Twenty
+```
+
+<Note>
+Sostituisci `yourSubDomain` con il tuo effettivo sottodominio dello spazio di lavoro Twenty.
+</Note>
+
+#### Esegui il test e attiva
+
+1. Fai clic su **Test** per eseguire manualmente il flusso di lavoro
+2. Crea o modifica una nota e assegna un revisore
+3. Controlla la casella di posta del revisore per l'email di notifica
+4. Attiva il flusso di lavoro
+
+## Utilizzo
+
+Una volta configurato, il tuo team può utilizzare questo flusso di lavoro:
+
+1. Creando una nuova nota (o modificandone una esistente)
+2. Selezionando un collega nel campo **Reviewer**
+3. Il collega riceve automaticamente un'email con un link diretto alla nota
+
+## Correlati
+
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)
+* [Inviare email dai flussi di lavoro](/l/it/user-guide/workflows/capabilities/send-emails-from-workflows)
+* [Crea campi personalizzati](/l/it/user-guide/data-model/how-tos/create-custom-fields)
+* [Crea campi di relazione](/l/it/user-guide/data-model/how-tos/create-relation-fields)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/crm-automations/send-email-alerts-with-tasks-due.mdx

@@ -0,0 +1,106 @@
+---
+title: Invia avvisi via email per le attività in scadenza
+description: Notifica automaticamente ai membri del team le attività imminenti o in ritardo.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<img src="/images/user-guide/workflows/email_tasks_due.png" style={{width:'100%'}} />
+
+Invia promemoria email quotidiani a ciascun membro del team sulle attività in scadenza oggi.
+
+## Panoramica
+
+Questo flusso di lavoro viene eseguito secondo una pianificazione e:
+
+1. Recupera tutti i membri dello spazio di lavoro
+2. Scorre ciascun membro
+3. Trova le loro attività in scadenza oggi
+4. Formatta e invia un'email personalizzata
+
+## Configurazione passo-passo
+
+<VimeoEmbed videoId="1147463514" title="Dimostrazione video" />
+
+### Passaggio 1: Configura il trigger
+
+1. Vai su **Impostazioni → Flussi di lavoro** e crea un nuovo flusso di lavoro
+2. Seleziona **On a Schedule** come trigger
+3. Usa un'espressione cron per ogni giorno alle 8:00: `0 8 * * *`
+
+### Passaggio 2: Cerca tutti i membri dello spazio di lavoro
+
+1. Aggiungi un'azione **Search Records**
+2. Seleziona **Workspace Members** (nella sezione Oggetti avanzati)
+3. Non sono necessari filtri — questo restituisce tutti i membri
+
+### Passaggio 3: Aggiungi un Iterator
+
+1. Aggiungi un'azione **Iterator**
+2. Imposta l'array di input con i membri dello spazio di lavoro del passaggio precedente
+3. Tutte le azioni all'interno dell'Iterator verranno eseguite una volta per membro
+
+### Passaggio 4: Cerca le attività in scadenza oggi (all'interno dell'Iterator)
+
+1. All'interno dell'Iterator, aggiungi un'azione **Search Records**
+2. Seleziona **Tasks** come oggetto
+3. Aggiungi filtri:
+   * **Assignee** = membro corrente dello spazio di lavoro (dall'Iterator)
+   * **Due Date** = oggi
+
+### Passaggio 5: Formatta le attività nel corpo dell'email (all'interno dell'Iterator)
+
+Aggiungi un'azione **Code** per formattare le attività in un elenco leggibile con link:
+
+```javascript
+export const main = async (params: {
+  tasksDue?: Array<{ id: string; title: string }> | null | string;
+}) => {
+  const tasksDue =
+    typeof params.tasksDue === "string"
+      ? JSON.parse(params.tasksDue)
+      : params.tasksDue;
+
+  if (!Array.isArray(tasksDue) || tasksDue.length === 0) {
+    return {
+      formattedTasks: "No tasks due today."
+    };
+  }
+
+  const formattedTasks = tasksDue
+    .map(
+      t =>
+        `${t.title}\nhttps://yourSubDomain.twenty.com/object/task/${t.id}`
+    )
+    .join("\n\n");
+
+  return { formattedTasks };
+};
+```
+
+<Note>
+Sostituisci `yourSubDomain` con il tuo effettivo sottodominio dello spazio di lavoro Twenty.
+</Note>
+
+### Passaggio 6: Invia email (all'interno dell'Iterator)
+
+1. Aggiungi un'azione **Send Email** (sempre all'interno dell'Iterator)
+2. Configura:
+
+| Campo       | Valore                                                                         |
+| ----------- | ------------------------------------------------------------------------------ |
+| **A**       | `{{iterator.currentItem.userEmail}}` (email del membro dello spazio di lavoro) |
+| **Oggetto** | Le tue attività in scadenza oggi                                               |
+| **Corpo**   | `{{code.formattedTasks}}`                                                      |
+
+### Passaggio 7: Testa e attiva
+
+1. Fai clic su **Test** per eseguire manualmente il flusso di lavoro
+2. Controlla le caselle di posta per le email
+3. Attiva il flusso di lavoro
+
+## Correlati
+
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Inviare email dai flussi di lavoro](/l/it/user-guide/workflows/capabilities/send-emails-from-workflows)
+* [Gestire gli array nelle azioni Code](/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/it/user-guide/workflows/how-tos/need-more-help/professional-services.mdx

@@ -0,0 +1,21 @@
+---
+title: Servizi Professionali
+description: Ottieni assistenza professionale per creare flussi di lavoro e automazioni complessi dal team di Twenty e dai partner certificati.
+---
+
+## Quando Hai Bisogno di Aiuto Professionale?
+
+Considera i servizi professionali per:
+
+* Complesse integrazioni multi-sistema
+* Logica aziendale avanzata e regole di automazione
+* Flussi di lavoro di elaborazione dati su larga scala
+* Sviluppo API personalizzato
+* Formazione del team e ottimizzazione dei flussi di lavoro
+* Quando non si hanno risorse interne
+
+## Opzioni di Servizio
+
+### Partner di Implementazione
+
+Collabora con partner certificati per personalizzazioni avanzate. Contattaci all'indirizzo [contact@twenty.com](mailto:contact@twenty.com) per entrare in contatto con i nostri [partner di implementazione](https://twenty.com/partners).

packages/twenty-docs/l/it/user-guide/workflows/how-tos/need-more-help/workflow-troubleshooting.mdx

@@ -0,0 +1,170 @@
+---
+title: Risoluzione dei problemi del flusso di lavoro
+description: Problemi comuni dei flussi di lavoro e come risolverli.
+---
+
+## Problemi comuni e soluzioni
+
+### Flusso di lavoro non attivato
+
+**Sintomi**: Il flusso di lavoro non viene eseguito quando previsto.
+
+**Possibili cause**:
+
+1. **Flusso di lavoro non attivato**: Assicurati che il flusso di lavoro sia impostato su "Attivo" e non su "Bozza"
+2. **Condizioni del trigger non soddisfatte**: Verifica che il trigger corrisponda all'evento previsto
+3. **Campo non monitorato**: Per i trigger "Record is Updated", assicurati che il campo specifico sia monitorato
+4. **Autorizzazioni**: Verifica di avere l'autorizzazione per eseguire i flussi di lavoro
+
+**Soluzioni**:
+
+* Verifica lo stato del flusso di lavoro nell'elenco dei flussi di lavoro
+* Esegui un test con l'azione specifica che dovrebbe attivarlo
+* Rivedi la configurazione del trigger
+* Contatta l'amministratore per le autorizzazioni
+
+### Il flusso di lavoro si attiva troppo presto (campi vuoti)
+
+**Sintomi**: Quando crei manualmente un record nell'interfaccia utente, il flusso di lavoro si attiva prima che tu abbia il tempo di compilare tutti i campi. Il flusso di lavoro viene eseguito con valori di campo per la maggior parte vuoti.
+
+**Perché accade**: Twenty salva tutto in tempo reale — non esiste una modalità separata "modifica" vs "lettura". Quando crei un record, questo viene salvato immediatamente, attivando l'evento "Record is created" prima che tu possa compilare i campi aggiuntivi.
+
+**Quando "Record is created" funziona bene**:
+
+* Record creati tramite chiamate API (i campi vengono popolati in un'unica richiesta)
+* Record creati tramite importazione
+* Creazione automatizzata di record da altri flussi di lavoro
+
+**Soluzione**: Per i record creati manualmente nell'interfaccia utente, usa **"Record is created or updated"** come trigger. In questo modo:
+
+* Il flusso di lavoro si attiva dopo che l'utente ha terminato di compilare e salvare i campi
+* Ottieni i dati completi invece di valori vuoti
+
+<Tip>
+Se desideri che il flusso di lavoro venga eseguito solo una volta per record, aggiungi un'azione Filter per verificare un campo come `createdAt equals updatedAt` (primo salvataggio) oppure usa un campo casella di controllo personalizzato per tracciare se il flusso di lavoro è già stato eseguito.
+</Tip>
+
+### Azioni non riuscite
+
+**Sintomi**: Il flusso di lavoro viene eseguito ma alcune azioni non riescono.
+
+**Possibili cause**:
+
+1. **Dati mancanti**: I campi obbligatori sono vuoti
+2. **Riferimenti non validi**: Le variabili dei passaggi precedenti non esistono
+3. **Errori API**: I servizi esterni restituiscono errori
+4. **Problemi di autorizzazioni**: L'azione richiede autorizzazioni che non possiedi
+
+**Soluzioni**:
+
+* Controlla i dettagli dell'esecuzione del flusso di lavoro per eventuali messaggi di errore
+* Verifica che tutti i campi obbligatori abbiano un valore
+* Testa le connessioni API in modo indipendente
+* Rivedi le autorizzazioni del ruolo
+
+### Errori delle richieste HTTP
+
+**Sintomi**: Le azioni HTTP Request non riescono o restituiscono risultati inattesi.
+
+**Codici di errore comuni**:
+
+* **400**: Richiesta non valida - controlla il formato del corpo della richiesta
+* **401**: Non autorizzato - verifica la chiave API
+* **403**: Vietato - controlla le autorizzazioni dell'API
+* **404**: Non trovato - verifica l'URL dell'endpoint
+* **429**: Troppe richieste - implementa la limitazione della frequenza
+* **500**: Errore del server - problema del servizio esterno
+
+**Soluzioni**:
+
+* Verifica l'URL dell'endpoint API
+* Controlla le intestazioni di autenticazione
+* Esegui prima il test della chiamata API al di fuori di Twenty
+* Aggiungi la gestione degli errori nelle azioni di Codice
+
+### Errori delle azioni di Codice
+
+**Sintomi**: Il codice JavaScript non viene eseguito.
+
+**Problemi comuni**:
+
+1. **Errori di sintassi**: Refusi o JavaScript non valido
+2. **Variabili non definite**: Riferimento a variabili che non esistono
+3. **Errori di tipo**: Operazioni su tipi di dati errati
+4. **Timeout**: Il codice impiega troppo tempo per essere eseguito
+
+**Soluzioni**:
+
+* Usa la convalida dell'editor di codice integrato
+* Verifica prima la logica del codice in una console JavaScript
+* Aggiungi istruzioni console.log per il debug
+* Semplifica le operazioni complesse
+
+### Le email non vengono inviate
+
+**Sintomi**: L'azione Invia email non recapita le email.
+
+**Possibili cause**:
+
+1. **Nessun account email connesso**: Controlla Impostazioni → Account
+2. **Indirizzo email non valido**: L'email del destinatario non è valida
+3. **Limiti di invio**: Raggiunti i limiti di frequenza del provider email
+4. **Filtri antispam**: Le email vengono bloccate
+
+**Soluzioni**:
+
+* Verifica la connessione dell'account email
+* Convalida gli indirizzi email dei destinatari
+* Controlla i limiti del provider email
+* Rivedi il contenuto dell'email per possibili trigger di spam
+
+## Debug dei flussi di lavoro
+
+### Utilizzo delle esecuzioni del flusso di lavoro
+
+1. Vai all'editor dei flussi di lavoro
+2. Apri il pannello **Esecuzioni**
+3. Trova l'esecuzione non riuscita
+4. Fai clic per vedere i dettagli passo dopo passo
+5. Rivedi i messaggi di errore e i dati di output
+
+### Test dei singoli passaggi
+
+1. Per le azioni di Codice, usa il pulsante **Test**
+2. Per le richieste HTTP, testa separatamente l'endpoint
+3. Crea record di test per attivare i flussi di lavoro
+4. Usa trigger manuali per test controllati
+
+### Schemi comuni di debug
+
+**Aggiungi logging**:
+Usa le azioni di Codice per registrare valori intermedi per il debug.
+
+**Isola i passaggi**:
+Testa ogni passaggio in modo indipendente per identificare gli errori.
+
+**Controlla il flusso dei dati**:
+Verifica che ogni passaggio riceva i dati di input previsti.
+
+## Buone pratiche per evitare problemi
+
+### Prima dell'attivazione
+
+* Esegui test approfonditi in modalità bozza
+* Convalida tutte le connessioni API
+* Rivedi attentamente le condizioni del trigger
+* Documenta il comportamento previsto
+
+### Durante lo sviluppo
+
+* Usa nomi di passaggio descrittivi
+* Aggiungi commenti nelle azioni di Codice
+* Testa con dati realistici
+* Pianifica i casi limite
+
+### Dopo l'attivazione
+
+* Monitora attentamente le esecuzioni iniziali
+* Configura avvisi per gli errori
+* Rivedi regolarmente la cronologia delle esecuzioni
+* Mantieni i flussi di lavoro semplici quando possibile

packages/twenty-docs/l/it/user-guide/workflows/how-tos/need-more-help/workflows-faq.mdx

@@ -0,0 +1,236 @@
+---
+title: FAQ sui flussi di lavoro
+description: Domande frequenti sui flussi di lavoro in Twenty.
+---
+
+<AccordionGroup>
+
+  <Accordion title="Perché non riesco ad attivare un flusso di lavoro?">
+    È probabilmente un problema di permessi. Hai bisogno dell'accesso ai flussi di lavoro per crearli e attivarli.
+
+    **Soluzione**: Contatta l'amministratore dello spazio di lavoro per concederti l'accesso ai flussi di lavoro in **Impostazioni → Membri → Ruoli**.
+
+    Se non vedi affatto la sezione Flussi di lavoro nella barra laterale, ciò conferma che è un problema di permessi.
+  </Accordion>
+
+  <Accordion title="Perché non vedo il pulsante del flusso di lavoro manuale nella barra di navigazione superiore?">
+    I flussi di lavoro manuali compaiono nella barra di navigazione solo se configurati correttamente:
+
+    1. Il flusso di lavoro deve essere **attivato** (non in modalità bozza)
+    2. Il posizionamento nella barra di navigazione deve essere impostato su **Pinned**
+    3. Per i trigger Single/Bulk, devi trovarti nella pagina dell'oggetto corretta
+
+    **Per verificare**: Apri il flusso di lavoro → fai clic sul trigger → verifica che "Navbar placement" sia impostato su "Pinned".
+
+    Puoi sempre accedere ai flussi di lavoro manuali tramite **Cmd + K** (o **Ctrl + K**) indipendentemente dalle impostazioni della barra di navigazione.
+  </Accordion>
+
+  <Accordion title="Qual è la differenza tra i trigger manuali Single, Global e Bulk?">
+    | Tipo | Record richiesti | Esecuzioni del workflow |
+    | ---- | ---------------- | ----------------------- |
+    \| **Global** | Nessuno | Una volta, senza input di record |
+    \| **Single** | Uno o più selezionati | Una volta per ogni record selezionato |
+    \| **Bulk** | Uno o più selezionati | Una volta, con tutti i record come array |
+
+    * **Global**: Usalo quando il flusso di lavoro non richiede alcun contesto di record (ad es., generare un report)
+    * **Single**: Usalo quando vuoi elaborare ogni record selezionato in modo indipendente (ad es., inviare email singole)
+    * **Bulk**: Usalo quando devi elaborare i record insieme o ottimizzare l'uso dei crediti (richiede l'azione Iterator)
+
+    Vedi [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers) per i dettagli.
+  </Accordion>
+
+  <Accordion title="Non vedo un nodo If/Else. Cosa devo fare?">
+    Un nodo If/Else esplicito non è ancora disponibile ma è nella nostra roadmap.
+
+    **Soluzione temporanea**: Crea più diramazioni dal tuo passaggio, ciascuna iniziando con un'azione **Filtro**:
+
+    ```
+    Step 1
+       │
+       ├── Branch A: Filter (condition = true) → Actions...
+       │
+       └── Branch B: Filter (condition = false) → Actions...
+    ```
+
+    Solo la diramazione in cui la condizione del filtro è soddisfatta eseguirà le azioni successive.
+
+    Consulta [Come usare le diramazioni](/l/it/user-guide/workflows/capabilities/workflow-branches) per una guida passo passo.
+  </Accordion>
+
+  <Accordion title="Le diramazioni del flusso di lavoro vengono eseguite in parallelo?">
+    **Sì**, le diramazioni vengono eseguite in parallelo per impostazione predefinita.
+
+    Se vuoi che venga eseguita solo una diramazione:
+    * Aggiungi un'azione **Filtro** all'inizio di ogni diramazione
+    * Imposta condizioni opposte (ad es., Diramazione A: stato = "Open", Diramazione B: stato ≠ "Open")
+
+    Le diramazioni che non soddisfano la loro condizione di filtro interrompono l'esecuzione, mentre le altre continuano.
+  </Accordion>
+
+  <Accordion title="Posso riunire le diramazioni?">
+    **Sì**. Dopo che le diramazioni parallele sono state completate, puoi aggiungere un passaggio a cui si colleghino entrambe.
+
+    Nell'editor dei flussi di lavoro:
+    1. Completa le azioni nelle diramazioni
+    2. Aggiungi un nuovo passaggio dopo le diramazioni
+    3. Trascina le connessioni dalla fine di ciascuna diramazione verso questo nuovo passaggio
+
+    Il passaggio unificato verrà eseguito dopo il completamento di tutte le diramazioni collegate.
+  </Accordion>
+
+  <Accordion title="Qual è il limite dei risultati di Search Records?">
+    **Search Records restituisce un massimo di 200 record.**
+
+    Se devi elaborarne di più:
+    * Aggiungi filtri più specifici per ridurre i risultati
+    * Usa flussi di lavoro pianificati per elaborare in lotti
+    * Valuta di usare le API per operazioni in blocco
+
+    Per la maggior parte dei flussi di lavoro, 200 record sono sufficienti. Se raggiungi regolarmente questo limite, valuta di ristrutturare l'automazione.
+  </Accordion>
+
+  <Accordion title="Posso mettere in CC persone nelle email dei flussi di lavoro?">
+    **Non ancora.** I campi CC e BCC per l'azione Send Email sono nella nostra roadmap.
+
+    **Soluzione temporanea**: Aggiungi più azioni Send Email per inviare ad altri destinatari, oppure usa una HTTP Request per inviare tramite un servizio email esterno che supporti CC.
+  </Accordion>
+
+  <Accordion title="Come si usano gli output dai passaggi precedenti?">
+    Ogni azione produce dati di output che possono essere utilizzati nei passaggi successivi.
+
+    **Per fare riferimento ai dati del passaggio precedente**:
+    * Usa il selettore di variabili durante la configurazione di un campo
+    * Oppure digita `{{stepName.fieldName}}` direttamente
+
+    **Esempi**:
+    * Dati del trigger: `{{trigger.object.email}}`
+    * Risultati della ricerca: `{{searchRecords[0].name}}`
+    * Output del codice: `{{code.calculatedValue}}`
+
+    Passa il mouse su qualsiasi campo nella configurazione dell'azione per vedere le variabili disponibili dai passaggi precedenti.
+  </Accordion>
+
+  <Accordion title="Perché il mio Iterator non riesce?">
+    **Iterator richiede un input di tipo array.** Problemi comuni:
+
+    1. **L'input non è un array**: Assicurati di passare i risultati di Search Records o di un'altra azione che restituisce un array
+    2. **L'array è vuoto**: Aggiungi un filtro prima di Iterator per verificare `{{searchRecords.length}} > 0`
+    3. **Variabile sbagliata selezionata**: Assicurati di selezionare l'array stesso, non un singolo record
+
+    **Configurazione corretta**:
+    1. Search Records (restituisce un array)
+    2. Filtro: length > 0
+    3. Iterator: seleziona `{{searchRecords}}`
+    4. Le azioni all'interno di Iterator usano `{{iterator.currentItem.fieldName}}`
+  </Accordion>
+
+  <Accordion title="Qual è il tempo massimo di esecuzione per le azioni di codice?">
+    Le azioni di codice (funzioni serverless) hanno un **timeout predefinito di 5 minuti** (300 secondi).
+
+    Il timeout massimo configurabile è di **15 minuti** (900 secondi).
+
+    Se il tuo codice supera questo limite, l'azione non riuscirà con un errore di timeout.
+
+    **Suggerimenti per evitare timeout**:
+    * Suddividi le operazioni grandi in parti più piccole usando Iterator
+    * Evita elaborazioni pesanti; usa servizi esterni tramite HTTP Request per processi intensivi
+    * Ottimizza il tuo codice per ridurre il tempo di esecuzione
+    * Se hai bisogno di elaborazioni più lunghe, valuta l'uso di flussi di lavoro pianificati che elaborano i dati in lotti
+  </Accordion>
+
+  <Accordion title="Come leggere le esecuzioni dei flussi di lavoro?">
+    Le esecuzioni dei flussi di lavoro mostrano la cronologia di esecuzione e ti aiutano a eseguire il debug dei problemi.
+
+    **Accesso alle esecuzioni**:
+    * Nell'editor dei flussi di lavoro → pannello **Runs** a destra
+    * Oppure vai a **Workflow Runs** nella barra laterale
+
+    **Comprendere un'esecuzione**:
+    * **Stato**: In esecuzione, Completato, Non riuscito, In attesa
+    * **Passaggi**: Vedi quali passaggi sono stati eseguiti e il loro output
+    * **Errori**: Fai clic sui passaggi non riusciti per vedere i messaggi di errore
+    * **Dati**: Visualizza i dati di input/output a ogni passaggio
+
+    Vedi [Esecuzioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-runs) per i dettagli.
+  </Accordion>
+
+  <Accordion title="Perché non vedo le esecuzioni dei miei flussi di lavoro?">
+    Le esecuzioni dei flussi di lavoro potrebbero non riuscire immediatamente a causa dei limiti di frequenza. Twenty impone un limite rigido di 5.000 esecuzioni all'ora per spazio di lavoro.
+
+    Se superi questo limite, i flussi di lavoro vengono immediatamente contrassegnati come non riusciti e non appariranno nell'elenco delle esecuzioni.
+
+    **Scenari comuni che raggiungono questo limite**:
+    * Selezionare più di 5.000 record con un trigger manuale Single
+    * Più flussi di lavoro in esecuzione simultaneamente nel tuo spazio di lavoro
+    * Trigger automatici ad alta frequenza (ad es., Record Updated su un oggetto molto attivo)
+
+    **Soluzioni**:
+    * Usa i trigger **Bulk** invece di Single per elaborare molti record in un'unica esecuzione
+    * Scagliona nel tempo le operazioni in grandi batch
+    * Usa filtri per ridurre la frequenza dei trigger
+    * Pianifica i flussi di lavoro pesanti nelle ore di minore traffico
+  </Accordion>
+
+  <Accordion title="Quali sono i limiti di frequenza dei flussi di lavoro?">
+    Twenty ha due limiti di frequenza per garantire la stabilità del sistema:
+
+    | Limite | Valore | Comportamento |
+    | ------ | ------ | ------------- |
+    \| **Soft limit** | 100 esecuzioni/minuto | Le esecuzioni vanno in coda con stato "Not Started", elaborate gradualmente |
+    \| **Hard limit** | 5.000 esecuzioni/ora | Le esecuzioni falliscono immediatamente |
+
+    **Limite soft (100/min)**: I tuoi flussi di lavoro non falliranno: semplicemente attendono in coda e vengono elaborati nel tempo. Puoi attivare più di 100 record; l'esecuzione sarà più lenta.
+
+    **Limite hard (5.000/ora)**: Si applica all'intero spazio di lavoro. Se tutti i tuoi flussi di lavoro combinati superano 5.000 esecuzioni in un'ora, le esecuzioni aggiuntive falliranno immediatamente.
+
+    **Suggerimenti per rimanere entro i limiti**:
+    * Usa trigger Bulk con Iterator invece dei trigger Single per grandi batch
+    * Combina automazioni correlate in un numero minore di flussi di lavoro
+    * Usa flussi di lavoro pianificati per distribuire il carico nel tempo
+  </Accordion>
+
+  <Accordion title="Posso ritentare un'esecuzione di flusso di lavoro non riuscita?">
+    **No, al momento non esiste una funzionalità di ritentativo automatico.**
+
+    Se un'esecuzione di flusso di lavoro non riesce, dovrai:
+    1. Rivedi l'errore in **Impostazioni → Flussi di lavoro → [Il tuo flusso di lavoro] → Runs**
+    2. Risolvi il problema (dati, configurazione o servizio esterno)
+    3. Attiva manualmente di nuovo il flusso di lavoro sui record interessati
+
+    **Suggerimenti per ridurre gli errori**:
+    * Aggiungi nodi **Filtro** per convalidare i dati prima delle azioni
+    * Usa **Search Records** per verificare se esistono record correlati
+    * Esegui test accurati con pochi record prima delle operazioni in blocco
+
+    La funzionalità di ritentativo automatico è nella nostra roadmap per un rilascio futuro.
+  </Accordion>
+
+  <Accordion title="Devo disattivare i flussi di lavoro prima delle importazioni CSV?">
+    **Sì, se i tuoi flussi di lavoro sono attivati dalla creazione o dall'aggiornamento dei record.**
+
+    Quando importi dati tramite CSV, ogni record creato o aggiornato può attivare flussi di lavoro. Una grande importazione (migliaia di record) potrebbe:
+    * Raggiungere il limite di 5.000 esecuzioni/ora
+    * Consumare una quantità significativa di crediti dei flussi di lavoro
+    * Inviare email o notifiche inattese
+    * Creare attività o record duplicati
+
+    **Prima di un'importazione massiva**:
+    1. Vai a **Impostazioni → Flussi di lavoro**
+    2. Identifica i flussi di lavoro attivati dall'oggetto che stai importando
+    3. **Disattivali** temporaneamente
+    4. Esegui l'importazione CSV
+    5. **Riattiva** i flussi di lavoro al termine
+
+    **Alternativa**: Se hai bisogno che i flussi di lavoro vengano eseguiti sui dati importati, importa in batch più piccoli per rimanere entro i limiti di frequenza.
+  </Accordion>
+
+  <Accordion title="Come posso pulire il layout del mio flusso di lavoro?">
+    Se il canvas del flusso di lavoro sembra disordinato, con nodi sparsi, puoi organizzarli automaticamente:
+
+    1. Fai clic con il pulsante destro in un punto qualsiasi del canvas del flusso di lavoro
+    2. Fai clic su **Tidy up workflow**
+
+    Questo riorganizzerà automaticamente tutti i nodi in un layout pulito e ordinato.
+  </Accordion>
+
+</AccordionGroup>

packages/twenty-docs/l/it/user-guide/workflows/overview.mdx

@@ -0,0 +1,81 @@
+---
+title: Flussi di Lavoro
+description: Scopri come creare automazioni in Twenty.
+---
+
+## Perché i Workflow sono importanti
+
+Twenty è stato creato per offrire la massima flessibilità ai suoi utenti. Piuttosto che costringerti ad adattare i tuoi processi aziendali a funzionalità rigide e predefinite, i workflow ti consentono di creare automazioni che creano il CRM che meglio supporta i tuoi casi d'uso aziendali unici.
+
+I workflow sono la funzione in-app di Twenty per creare queste automazioni. Ti forniscono gli elementi costitutivi per creare esattamente ciò di cui la tua attività ha bisogno, quando ne ha bisogno.
+
+## Cosa posso fare con i workflow?
+
+Consigliamo di costruire automazioni per due scopi principali:
+
+1. **Automazioni interne per facilitare le attività quotidiane del tuo team**: Riduci il numero di inserimenti manuali e compiti ripetitivi che rallentano il tuo team.
+2. **Portare i dati dentro e fuori da Twenty**: Collega Twenty tramite chiamate API e webhooks al tuo database e ad altri strumenti.
+
+## Creare il tuo primo flusso di lavoro
+
+### Passaggio 1: Crea un nuovo flusso di lavoro
+
+1. Vai a **Flussi di lavoro**, che si trova sotto gli altri oggetti
+2. Fai clic su **+ Nuovo record**
+3. Assegna un nome al tuo flusso di lavoro
+
+### Passaggio 2: Aggiungi un trigger
+
+Ogni flusso di lavoro inizia con un trigger. Scegli tra:
+
+* **Eventi dei record**: quando un record viene creato, aggiornato o eliminato
+* **Pianificazione**: Esegui in orari specifici (giornalmente, settimanalmente, ecc.)
+* **Manuale**: Attivato da un'azione dell'utente
+* **Webhook**: Attivato da un webhook
+
+<img src="/images/user-guide/workflows/workflow_triggers.png" style={{width:'100%'}} />
+
+### Passaggio 3: Aggiungi azioni
+
+Dopo il tuo trigger, aggiungi una o più azioni:
+
+* **Crea record**: Aggiungi nuovi record a qualsiasi oggetto
+* **Aggiorna record**: Modifica i dati dei record esistenti
+* **Elimina record**: Rimuovi i record dagli oggetti
+* **Cerca record**: Trova i record che corrispondono ai criteri
+* **Upsert record**: Crea o aggiorna in base ai criteri di corrispondenza
+* **Iterator**: Itera sugli array di record
+* **Filtro**: Controlla quali record proseguono
+* **Ritardo**: Attendi prima di continuare (durata o data programmata)
+* **Invia email**: Invia email tramite il tuo account collegato
+* **Codice**: Esegui JavaScript personalizzato
+* **Richiesta HTTP**: Chiama API esterne
+* **Modulo**: Raccogli input dagli utenti all'interno di Twenty UI al momento dell'esecuzione
+* **Agente IA** (In arrivo): Esegui attività di IA intelligenti
+
+<img src="/images/user-guide/workflows/workflow_actions.png" style={{width:'100%'}} />
+
+### Passaggio 4: Testa e attiva
+
+1. Usa il pulsante **Test** per eseguire il tuo flusso di lavoro con dati di esempio
+2. Esamina i risultati per assicurarti che funzioni come previsto
+3. Imposta il flusso di lavoro su **Attivo** quando sei pronto
+
+## Pratiche migliori per i flussi di lavoro
+
+* **Modifica i nomi dei passaggi**: Rinomina gli step del tuo flusso di lavoro per descrivere chiaramente cosa fa ciascuno. Ciò aiuta con la manutenzione e facilita il passaggio ai colleghi
+* **Sfrutta i dati dei passaggi precedenti**: Puoi utilizzare i campi dei record restituiti da qualsiasi passaggio precedente nel tuo flusso di lavoro
+* **Inizia in modo semplice**: Comincia con flussi di lavoro di base e aggiungi complessità nel tempo man mano che diventi più a tuo agio con il sistema
+* **Pianifica prima di costruire**: Mappa la logica del tuo flusso di lavoro prima di iniziare a costruire per evitare di rimanere bloccato a metà
+
+## Prossimi Passi
+
+* [Trigger dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-triggers)
+* [Azioni dei flussi di lavoro](/l/it/user-guide/workflows/capabilities/workflow-actions)
+* [Automazioni CRM](/l/it/user-guide/workflows/how-tos/crm-automations/closed-won-automations)
+
+## Hai Bisogno di Aiuto?
+
+<Tip>
+  Vuoi aiuto per automatizzare i tuoi workflow? [Trova un partner di venti certificati](https://twenty.com/partners/list?categories=SOLUTIONING\&ref=docs-workflows) per progettare e costruire le tue automazioni end-to-end.
+</Tip>