Backend Verifica Sintomi

Modello Backend App Verifica Sintomi
Sondaggi di assunzione guidati, esiti di triage e valutazione ad albero decisionale

Q: Cos'è un backend Symptom Checker?

Un backend di Symptom Checker è uno schema e un'API di BaaS che modella i questionari di intake, gli alberi di logica di decisione, i profili utente, le risposte, i risultati e le tracce di audit per supportare le applicazioni di triage.

Q: Cosa include questo modello?

Include Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome, AuditEntry, diagramma ER, ambiente di sviluppo API, schema JSON e un prompt di AI Agent per avviare contenuti.

Q: Perché usare Back4app per un'app di triage dei sintomi?

Back4app offre archiviazione dati gestita, autenticazione, endpoint REST/GraphQL generati, Live Queries e Cloud Code così i team possono iterare contenuti e logica senza gestire infrastrutture backend.

Q: Come posso raccogliere e riprodurre una sessione di sondaggio?

Salva ogni risposta in SurveyResponse.answers con riferimenti ai nodi e ai percorsi; usa il percorso memorizzato per riprodurre la sequenza delle valutazioni di DecisionNode.

Q: Come posso creare un TriageOutcome dopo la valutazione?

Sia il client che il server creano un record TriageOutcome collegato a SurveyResponse. Per sicurezza, usa Cloud Code per verificare i risultati della valutazione prima di persistere i risultati.

Q: Posso memorizzare in cache gli alberi DecisionNode sui dispositivi mobili per un uso offline?

Sì. I record Survey e DecisionNode pubblicati nel datastore locale in modo che la valutazione possa continuare offline e sincronizzare le risposte quando online.

Q: Come faccio a verificare perché è stato dato un particolare consiglio?

Ispeziona i record SurveyResponse.path e AuditEntry per vedere quali nodi hanno soddisfatto le condizioni e quali input sono stati utilizzati per generare il TriageOutcome.

Q: Qual è il modo consigliato per aggiornare i contenuti clinici?

Crea una nuova versione del Survey e testala in staging; una volta convalidata, pubblicala e migra i clienti alla nuova versione per nuove valutazioni.

Q: Come dovrei gestire la conformità normativa?

Applica rigide CLP/ACL ai dati personali, considera la crittografia dove appropriato, mantieni audit trails completi e consulta i team di governance clinica o legale per i requisiti locali.

Q: Come posso prevenire l'iniezione di regole malevole?

Restringi la modifica del DecisionNode ad autori fidati, convalida gli schemi delle regole nel Cloud Code e evita di eseguire script arbitrari dai record memorizzati in produzione.

Un backend Verifica Sintomi pronto per la produzione su Back4app con sondaggi di assunzione, alberi di logica clinica, esiti di triage, profili utente e registri di audit. Include diagramma ER, dizionario dei dati, schema JSON, area di gioco API e un prompt Agente AI per un rapido avvio.

Costruisci con AI Agent Scegli la tua tecnologia

Punti chiave

Questo modello fornisce un backend per il Controllo dei Sintomi con modelli di sondaggio, albero decisionale, esito, utente e audit in modo che il tuo team possa concentrarsi sul contenuto clinico e sull'UX.

Modello di raccolta opinato — Monitora le definizioni dei sondaggi, le varianti delle domande e le risposte degli utenti per ricostruire affidabilmente le sessioni di raccolta.
Nodi di logica clinica — Rappresenta gli alberi decisionali come record di DecisionNode collegati in modo che la logica di valutazione sia disaccoppiata dal codice client.
Risultati della triage — Memorizza risultati della triage deterministici (consigli, livello di urgenza, passi successivi raccomandati) per analisi e instradamento a valle.
Audit e spiegabilità — Cattura il percorso decisionale e gli input degli utenti in modo che i risultati siano auditabili e spiegabili per i clinici e le revisioni di conformità.
API multipiattaforma — Le API REST e GraphQL servono client mobili e web con contratti consistenti per l'assunzione e il triage.

Che cos'è il modello di backend dell'app Symptom Checker?

Back4app è un backend-as-a-service (BaaS) per una consegna rapida dei prodotti. Il modello di backend dell'app Symptom Checker è uno schema pre-costruito per sondaggi, nodi decisionali, risposte ai sondaggi, risultati del triage, profili utente e voci di audit. Collega il tuo frontend preferito (React, Flutter, Next.js, e altro) e spedisci più velocemente.

Migliore per:

Triage dei sintomi rivolto ai pazientiPrototipi di supporto decisionale clinicoFlussi di lavoro per l'assunzione della telemedicinaStrumenti di triage interni per clinicheMVP per prodotti di triage digitaleTeam che utilizzano BaaS per contenuti regolamentati

Panoramica

Un attendibile controllore dei sintomi richiede dati di assunzione strutturati, logica decisionale esplicita e risultati auditabili per supportare il triage e le analisi.

Questo modello definisce Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome e AuditEntry con regole di proprietà e convalida sensate per supportare i flussi di lavoro di assunzione clinica.

Funzionalità principali del Symptom Checker

Ogni scheda tecnologica in questo hub utilizza lo stesso schema di backend del Symptom Checker con Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome e AuditEntry.

Definizione e versioning del sondaggio

La classe del sondaggio memorizza titolo, versione, startNode e metadati per l'autore delle flussi di intake guidati.

Alberi DecisionNode

I modelli DecisionNode modellano domande, logica di ramificazione, espressioni condizionali e puntatori ai nodi successivi.

Tracciamento della risposta al sondaggio

La risposta al sondaggio memorizza le risposte degli utenti, le timestamp e il percorso valutato attraverso l'albero decisionale.

Registro dei risultati di triage

Il risultato di triage cattura il livello valutato (auto-cura, urgente, emergenza), il testo del consiglio e i passi successivi raccomandati.

Gestione del profilo utente

Il profilo utente collega gli account Back4app a metadati demografici e clinici utilizzati durante il triage.

Voci di audit spiegabili

AuditEntry registra attore, azione, contesto e payload per ogni valutazione critica e risultato.

Perché costruire il tuo backend per il Symptom Checker con Back4app?

Back4app fornisce le Blocks di building gestite per l'assunzione, la logica decisionale e il triage, in modo che il tuo team possa concentrarsi sui contenuti clinici, sull'UX e sulle integrazioni.

•Gestione di sondaggi e contenuti: Crea sondaggi e versioni in modo che i flussi di assunzione possano evolversi preservando le sessioni precedenti per la revisione.
•Logica clinica deterministica: Memorizza i nodi decisionali come dati in modo che le regole siano verificabili, testabili e modificabili senza nuove versioni delle app client.
•API flessibili + auditing: Utilizza REST e GraphQL per l'accesso del client e registra voci di audit dettagliate per catturare input e percorsi decisionali per la spiegabilità.

Compila, testa e distribuisci rapidamente i flussi di triage dei sintomi con un contratto backend gestito che supporta più frontend.

Benefici principali

Un backend di triage dei sintomi che ti aiuta a iterare rapidamente mantenendo la logica decisionale auditable e basata sui contenuti.

Iterazione rapida dei contenuti

Autore e versioni di survey e nodi decisionali senza dover inviare versioni client per ogni cambiamento di contenuto.

Risultati spiegabili

Mantieni il percorso decisionale e gli input in modo che i clinici e gli auditor possano ricostruire perché è stata emessa una particolare raccomandazione di triage.

Risultati di triage coerenti

Utilizza la valutazione di regole deterministiche per garantire che input identici producano risultati ripetibili su tutte le piattaforme.

Modifica dei contenuti autorizzata

Controlla chi può creare o pubblicare contenuti del sondaggio utilizzando ACL basate sul ruolo e controlli di Cloud Code.

Dati pronti per l'analisi

Cattura risposte e risultati strutturati affinché i team di prodotto e clinici possano analizzare utilizzo e segnali di sicurezza.

Flusso di lavoro assistito da AI

Avvia rapidamente sondaggi, nodi e risultati di triage di esempio con un prompt AI Agent già pronto.

Pronto a lanciare la tua piattaforma di triage dei sintomi?

Lascia che l'agente AI di Back4app fornisca la struttura per il tuo backend del Controllore dei Sintomi e generi questionari, nodi decisionali, risposte, risultati e registri di audit da un'unica richiesta.

Costruisci con l'Agente AI Prova l'API Playground

Gratis per iniziare — 50 richieste dell'Agente AI/mese, nessuna carta di credito richiesta

Stack Tecnico

Tutto incluso in questo template del backend del Controllore dei Sintomi.

Frontend

13+ tecnologie

Backend

Back4app

Database

MongoDB

Autenticazione

Autenticazione integrata + sessioni

API

REST e GraphQL

In tempo reale

Live Queries

Diagramma ER

Modello di relazione tra entità per lo schema backend del Symptom Checker.

common.erDiagramPlaceholder

Visualizza sorgente del diagramma

Mermaid

erDiagram
    SymptomSurvey ||--o{ DecisionNode : "contains"
    DecisionNode ||--o{ DecisionNode : "branches to"
    DecisionNode }|..|{ Advice : "recommends"
    PatientProfile ||--o{ Encounter : "starts"
    SymptomSurvey ||--o{ Encounter : "used in"
    Advice ||--o{ Encounter : "applies to"

    SymptomSurvey {
        String objectId PK
        String title
        String description
        String version
        Boolean isActive
        Array nodes FK
        Date createdAt
        Date updatedAt
    }

    DecisionNode {
        String objectId PK
        String questionText
        Array options FK
        Object nextMap
        Boolean isTerminal
        Pointer advice FK
        Date createdAt
        Date updatedAt
    }

    Advice {
        String objectId PK
        String title
        String description
        String urgency
        String followUp
        Date createdAt
        Date updatedAt
    }

    PatientProfile {
        String objectId PK
        Pointer user FK
        String fullName
        Date birthDate
        String sex
        String contact
        Array medicalHistory FK
        Date createdAt
        Date updatedAt
    }

    Encounter {
        String objectId PK
        Pointer patient FK
        Pointer survey FK
        Object responses
        Array decisionPath FK
        Pointer recommendedAdvice FK
        Number riskScore
        String status
        Date createdAt
        Date updatedAt
    }

    AuditLog {
        String objectId PK
        Pointer actor FK
        String entityType
        String entityId
        String action
        String summary
        Object metadata
        Date createdAt
        Date updatedAt
    }

Flusso di integrazione

Flusso di esecuzione tipico per l'autenticazione, l'assunzione guidata, la valutazione delle decisioni e la persistenza del triage.

common.erDiagramPlaceholder

Visualizza sorgente del diagramma

Mermaid

sequenceDiagram
  participant User
  participant App as Symptom Checker App
  participant Back4app as Back4app Cloud

  User->>App: Open app and Login
  App->>Back4app: POST /login
  Back4app-->>App: Session token and patient context

  User->>App: Request active triage surveys
  App->>Back4app: GET /classes/SymptomSurvey?where={"isActive":true}
  Back4app-->>App: List of SymptomSurvey

  User->>App: Start survey "Respiratory Triage"
  App->>Back4app: POST /classes/Encounter (patient, survey, status: in_progress)
  Back4app-->>App: Encounter objectId

  User->>App: Answer node Q1 -> "Yes"
  App->>Back4app: PUT /classes/Encounter/{id} (append responses, decisionPath)
  Back4app-->>App: Updated Encounter

  User->>App: Complete survey
  App->>Back4app: PUT /classes/Encounter/{id} (status: completed) + POST /classes/AuditLog
  Back4app-->>App: Encounter with recommendedAdvice (pointer) and riskScore

  Back4app-->>App: LiveQuery event if urgency == high (real-time escalation)
  App-->>User: Show advice and escalation instructions

Dizionario dei dati

Riferimento completo a livello di campo per ogni classe nello schema del Controllore dei Sintomi.

Campo	Tipo	Descrizione	Richiesto
objectId	String	Auto-generated unique identifier	Auto
title	String	Survey display title (e.g. Respiratory Triage)
description	String	Short description or purpose of the survey	—
version	String	Semantic version for survey logic
isActive	Boolean	Whether this survey is available to users
nodes	Array<Pointer<DecisionNode>>	Ordered decision nodes that make the clinical tree	—
createdAt	Date	Auto-generated creation timestamp	Auto
updatedAt	Date	Auto-generated last-update timestamp	Auto

8 campi in SymptomSurvey

Sicurezza e Permessi

Come la strategia ACL e CLP protegge il contenuto del sondaggio, la logica decisionali e i dati sensibili delle risposte.

Controllo del contenuto basato su ruoli

Consenti solo agli autori clinici e agli amministratori di creare o pubblicare artefatti di Sondaggio e DecisionNode; i visualizzatori vedono le versioni pubblicate.

Dati utente protetti

Le registrazioni di SurveyResponse e UserProfile sono autorizzate affinché utenti e clinici accedano solo ai record autorizzati; utilizza campi crittografati per i dati sensibili ove necessario.

Audit solo in append

Le scritture di AuditEntry sono limitate a flussi backend fidati per preservare la tracciabilità e prevenire manomissioni con i log decisionali storici.

Schema (JSON)

Definizione dello schema JSON pronta per essere copiata in Back4app o utilizzata come riferimento per l'implementazione.

JSON

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

{
  "classes": [
    {
      "className": "SymptomSurvey",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "description": {
          "type": "String",
          "required": false
        },
        "version": {
          "type": "String",
          "required": true
        },
        "isActive": {
          "type": "Boolean",
          "required": true
        },
        "nodes": {
          "type": "Array<Pointer>",
          "required": false,
          "targetClass": "DecisionNode"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "DecisionNode",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "questionText": {
          "type": "String",
          "required": true
        },
        "options": {
          "type": "Array",
          "required": true
        },
        "nextMap": {
          "type": "Object",
          "required": false
        },
        "isTerminal": {
          "type": "Boolean",
          "required": true
        },
        "recommendedAdvice": {
          "type": "Pointer",
          "required": false,
          "targetClass": "Advice"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Advice",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "description": {
          "type": "String",
          "required": true
        },
        "urgency": {
          "type": "String",
          "required": true
        },
        "followUp": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "PatientProfile",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "user": {
          "type": "Pointer",
          "required": false,
          "targetClass": "_User"
        },
        "fullName": {
          "type": "String",
          "required": false
        },
        "birthDate": {
          "type": "Date",
          "required": false
        },
        "sex": {
          "type": "String",
          "required": false
        },
        "contact": {
          "type": "String",
          "required": false
        },
        "medicalHistory": {
          "type": "Array",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Encounter",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "patient": {
          "type": "Pointer",
          "required": true,
          "targetClass": "PatientProfile"
        },
        "survey": {
          "type": "Pointer",
          "required": true,
          "targetClass": "SymptomSurvey"
        },
        "responses": {
          "type": "Object",
          "required": true
        },
        "decisionPath": {
          "type": "Array<Pointer>",
          "required": false,
          "targetClass": "DecisionNode"
        },
        "recommendedAdvice": {
          "type": "Pointer",
          "required": false,
          "targetClass": "Advice"
        },
        "riskScore": {
          "type": "Number",
          "required": false
        },
        "status": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "AuditLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "actor": {
          "type": "Pointer",
          "required": false,
          "targetClass": "_User"
        },
        "entityType": {
          "type": "String",
          "required": true
        },
        "entityId": {
          "type": "String",
          "required": true
        },
        "action": {
          "type": "String",
          "required": true
        },
        "summary": {
          "type": "String",
          "required": true
        },
        "metadata": {
          "type": "Object",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Costruisci con l'agente AI

Usa l'agente AI di Back4app per generare un'app di controllo dei sintomi da questo modello, inclusi la struttura del sondaggio, gli alberi decisionali, i risultati triage e l'integrazione frontale per {tech}.

Agente AI di Back4app

Pronto per costruire

Crea un backend di controllo dei sintomi su Back4app con questo schema e comportamento esatti.

Schema:
1. Sondaggio: titolo (String, richiesto), versione (String, richiesta), startNode (Puntatore a DecisionNode, richiesto), metadata (Oggetto, facoltativo).
2. DecisionNode: domanda (String, richiesta), inputType (String: singleChoice, multiChoice, numeric, text), conditions (Array di oggetti condizionali), nextNode (Puntatore a DecisionNode, facoltativo), outcome (Puntatore a TriageOutcome, facoltativo), ruleType (String: deterministico, scriptabile).
3. UserProfile: utente (Puntatore a User, richiesto), fascia di età (String, facoltativo), chronicFlags (Array, facoltativo), consentGiven (Boolean, richiesto).
4. SurveyResponse: sondaggio (Puntatore a Survey, richiesto), utente (Puntatore a User, facoltativo), risposte (Oggetto: chiave per nodeId), path (Array di puntatori a DecisionNode), startedAt (Data), completedAt (Data, facoltativa).
5. TriageOutcome: risposta (Puntatore a SurveyResponse, richiesta), livello (String: auto-cura, assistenza primaria, urgente, emergenza), adviceText (String), recommendedAction (String), createdAt (sistema).
6. AuditEntry: attore (Puntatore a User, richiesto), azione (String, richiesta), contesto (Oggetto), payload (Oggetto, facoltativo).

Sicurezza:
- Utilizza ACL/CLP per limitare la creazione di sondaggi e per proteggere i dati di SurveyResponse. Le scritture di AuditEntry dovrebbero essere solo appendibili per i non amministratori.

Autenticazione:
- Registrazione, accesso, disconnessione per gli utenti finali e i clinici; permessi basati sul ruolo per autori e revisori.

Comportamento:
- Recupera gli alberi di Survey e DecisionNode pubblicati, valuta i nodi progressivamente, persisti SurveyResponse con il percorso decisionale, calcola o registra TriageOutcome e crea record AuditEntry per ciascuna valutazione completata.

Consegna:
- App Back4app con schema, ACL, CLP; sondaggi e nodi decisionali per principianti; guida all'integrazione frontale per {tech}; esempi di playground API.

Premi il pulsante qui sotto per aprire l'agente con questo prompt del modello già compilato.

Questo è il prompt base senza un suffisso tecnologico. Puoi adattare lo stack frontale generato in seguito.

Distribuisci in pochi minuti50 prompt gratuiti / meseNessuna carta di credito richiesta

API Playground

Prova gli endpoint REST e GraphQL contro lo schema del Controllo Sintomi. Le risposte utilizzano dati fittizi e non richiedono un account Back4app.

common.loadingPlayground

Utilizza lo stesso schema di questo modello.

Scegli la tua tecnologia

Espandi ogni scheda per i passi di integrazione, schemi di stato, esempi di modello di dati e note offline.

Cosa ottieni con ogni tecnologia

Ogni stack utilizza lo stesso schema del backend del Symptom Checker e i contratti API.

Struttura dati unificata controllo dei sintomi

Uno schema coeso per sondaggi e profili utente personalizzati per controllo dei sintomi.

Risultati di triage in tempo reale

Feedback immediato sui sintomi degli utenti con nodi decisionali dinamici per controllo dei sintomi.

Gestione sicura dei dati degli utenti

Controllo degli accessi robusto che garantisce la riservatezza delle informazioni degli utenti controllo dei sintomi.

Accesso API REST/GraphQL

Integra facilmente con i framework frontend attraverso API flessibili per controllo dei sintomi.

Esperienza di sondaggio personalizzabile

Personalizza i sondaggi per soddisfare le esigenze specifiche degli utenti controllo dei sintomi per un migliore coinvolgimento.

Strumenti di analisi e reporting

Ottieni approfondimenti dalle interazioni e dai risultati degli utenti nell'app controllo dei sintomi.

Confronto del framework per il controllo dei sintomi

Confronta la velocità di configurazione, lo stile SDK e il supporto AI tra tutte le tecnologie supportate.

Framework	Tempo di Configurazione	Vantaggio del controllo dei sintomi	Tipo SDK	Supporto AI
Flutter	Meno di 5 minuti	Codice sorgente unico per il controllo dei sintomi su mobile e web.	Typed SDK	Completo
React	~3–7 min	Dashboard web veloce per il controllo dei sintomi.	Typed SDK	Completo
React Nativo	Configurazione rapida (5 min)	App mobile cross-platform per il controllo dei sintomi.	Typed SDK	Completo
Next.js	~5 min	App web renderizzata sul server per il controllo dei sintomi.	Typed SDK	Completo
JavaScript	~3–5 min	Integrazione web leggera per il controllo dei sintomi.	Typed SDK	Completo
Android	Meno di 5 minuti	App nativa Android per il controllo dei sintomi.	Typed SDK	Completo
iOS	~3–7 min	App nativa iOS per il controllo dei sintomi.	Typed SDK	Completo
Vue	Configurazione rapida (5 min)	React interfaccia web per il controllo dei sintomi.	Typed SDK	Completo
Angular	~5 min	App web enterprise per il controllo dei sintomi.	Typed SDK	Completo
GraphQL	Meno di 2 min	API flessibile GraphQL per il controllo dei sintomi.	GraphQL API	Completo
REST API	Configurazione veloce (2 min)	Integrazione REST API per il controllo dei sintomi.	REST API	Completo
PHP	~3 min	Backend PHP lato server per il controllo dei sintomi.	REST API	Completo
.NET	Configurazione rapida (5 min)	Backend .NET per il controllo dei sintomi.	Typed SDK	Completo

Il tempo di configurazione riflette la durata prevista dalla creazione del progetto alla prima indagine e valutazione della decisione utilizzando questo schema del modello.

Domande Frequenti

Domande comuni sulla costruzione di un backend per il Controllo dei Sintomi con questo modello.

Cos'è un backend Symptom Checker?

Cosa include questo modello?

Perché usare Back4app per un'app di triage dei sintomi?

Come posso raccogliere e riprodurre una sessione di sondaggio?

Come posso creare un TriageOutcome dopo la valutazione?

Posso memorizzare in cache gli alberi DecisionNode sui dispositivi mobili per un uso offline?

Come faccio a verificare perché è stato dato un particolare consiglio?

Qual è il modo consigliato per aggiornare i contenuti clinici?

Come dovrei gestire la conformità normativa?

Come posso prevenire l'iniezione di regole malevole?

Fidato da sviluppatori in tutto il mondo

I team che costruiscono esperienze di triage e accettazione si affidano ai modelli di Back4app per back-end rapidi e conformi

Pronto per costruire la tua app di controllo dei sintomi?

Inizia il tuo progetto di triage dei sintomi in pochi minuti. Nessuna carta di credito richiesta.

Scegli tecnologia

Modello Backend App Verifica SintomiSondaggi di assunzione guidati, esiti di triage e valutazione ad albero decisionale