Backend do Verificador de Sintomas

Modelo de Backend do Aplicativo de Verificação de Sintomas
Questionários de avaliação inicial guiados, resultados de triagem e avaliação de árvores de decisão

Q: O que é um back-end do Verificador de Sintomas?

Um back-end do Verificador de Sintomas é um esquema BaaS e uma API que modela questionários de admissão, árvores de lógica de decisão, perfis de usuário, respostas, desfechos e trilhas de auditoria para apoiar aplicações de triagem.

Q: O que este modelo inclui?

Inclui Questionário, Nó de Decisão, Perfil de Usuário, Resposta do Questionário, Desfecho de Triagem, Registro de Auditoria, diagrama ER, ambiente de API, esquema JSON e um prompt de Agente de IA para inicializar o conteúdo.

Q: Por que usar Back4app para um aplicativo de triagem de sintomas?

Back4app fornece armazenamento de dados gerenciado, autenticação, endpoints REST/GraphQL gerados, Live Queries, e Cloud Code para que equipes possam iterar conteúdo e lógica sem operar infraestrutura de backend.

Q: Como posso coletar e reproduzir uma sessão de questionário?

Armazene cada resposta em SurveyResponse.answers com referências de nó e caminho; use o caminho armazenado para reproduzir a sequência de avaliações de DecisionNode.

Q: Como crio um TriageOutcome após a avaliação?

O cliente ou o servidor criam um registro de TriageOutcome vinculado ao SurveyResponse. Por segurança, use Cloud Code para verificar os resultados da avaliação antes de persistir os desfechos.

Q: Posso armazenar em cache árvores de DecisionNode em dispositivos móveis para uso offline?

Sim. Fixe os registros publicados de Questionário e DecisionNode no armazenamento local para que a avaliação possa continuar offline e sincronizar as respostas quando estiver online.

Q: Como posso auditar por que uma orientação específica foi dada?

Inspecione o SurveyResponse.path e os registros AuditEntry para ver quais nós corresponderam às condições e quais entradas foram usadas para gerar o TriageOutcome.

Q: Qual é a maneira recomendada de atualizar o conteúdo clínico?

Crie uma nova versão do Questionário e teste-a em staging; uma vez validada, publique-a e migre os clientes para a nova versão para avaliações recentes.

Q: Como devo lidar com a conformidade regulatória?

Aplique controles estritos de CLP/ACL aos dados pessoais, considere criptografia onde for apropriado, mantenha trilhas de auditoria completas e consulte equipes de governança clínica ou jurídicas para requisitos locais.

Q: Como posso evitar a injeção maliciosa de regras?

Restringir a edição do DecisionNode apenas a autores confiáveis, validar os esquemas de regras no Cloud Code e evitar executar scripts arbitrários a partir de registros armazenados em produção.

Um back-end do Verificador de Sintomas pronto para produção em Back4app com questionários de admissão, árvores de lógica clínica, resultados de triagem, perfis de usuário e registros de auditoria. Inclui diagrama ER, dicionário de dados, esquema JSON, ambiente de API e um prompt de Agente de IA para inicialização rápida.

Desenvolver com Agente de IA Escolha a sua tecnologia

Principais pontos

Este modelo fornece um backend do Verificador de Sintomas com modelos de questionários, árvore de decisão, desfecho, usuário e auditoria, para que sua equipe possa se concentrar no conteúdo clínico e na experiência do usuário.

Modelo de intake opinativo — Acompanhe definições de questionários, variantes de perguntas e respostas dos usuários para reconstruir de forma confiável as sessões de intake.
Nós de lógica clínica — Represente árvores de decisão como registros vinculados a DecisionNode, para que a lógica de avaliação fique desacoplada do código do cliente.
Desfechos da triagem — Armazene desfechos de triagem determinísticos (orientação, nível de urgência, próximas etapas recomendadas) para análises subsequentes e roteamento.
Auditoria e explicabilidade — Capture o caminho de decisão e as entradas do usuário para que os resultados sejam auditáveis e explicáveis para clínicos e revisões de conformidade.
APIs multiplataforma — REST e os endpoints GraphQL atendem clientes móveis e web com contratos consistentes para ingestão de dados e triagem.

O que é o Symptom Checker App Backend Template?

Back4app é um backend-as-a-service (BaaS) para entrega rápida de produtos. O Symptom Checker App Backend Template é um esquema pré-construído para questionários, nós de decisão, respostas de questionários, resultados de triagem, perfis de usuário e entradas de auditoria. Conecte seu frontend de preferência (React, Flutter, Next.js, e mais) e entregue mais rápido.

Melhor para:

Triagem de sintomas voltada para o pacienteProtótipos de suporte à decisão clínicaFluxos de coleta de informações em telessaúdeFerramentas de triagem interna para clínicasMVPs para produtos de triagem digitalEquipes usando BaaS para conteúdo regulamentado

Visão geral

Um verificador de sintomas confiável requer dados de coleta estruturados, lógica de decisão explícita e resultados auditáveis para apoiar triagem e análises.

Este modelo define Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome e AuditEntry com regras de propriedade e validação adequadas para apoiar fluxos de trabalho de coleta clínica.

Principais recursos do Verificador de Sintomas

Cada cartão de tecnologia neste hub usa o mesmo esquema de backend do Symptom Checker com Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome e AuditEntry.

Definição de questionários e versionamento

A classe Survey armazena título, versão, startNode e metadados para a autoria de fluxos de entrada guiados.

Árvores de Nós de Decisão

DecisionNode modela perguntas, lógica de ramificação, expressões condicionais e ponteiros para nós subsequentes.

Rastreamento de SurveyResponse

SurveyResponse armazena as respostas do usuário, carimbos de data/hora e o caminho avaliado pela árvore de decisão.

Registros de TriageOutcome

TriageOutcome captura o nível avaliado (autocuidado, urgente, emergência), texto de orientação e as próximas etapas recomendadas.

Gerenciamento de UserProfile

UserProfile liga Back4app contas de usuário aos metadados demográficos e clínicos usados durante a triagem.

Entradas de auditoria explicáveis

AuditEntry registra o ator, a ação, o contexto e a carga útil para cada avaliação crítica e resultado.

Por que construir o seu backend de verificador de sintomas com Back4app?

Back4app fornece os blocos de construção gerenciados Blocks para entrada, lógica de decisão e triagem, para que sua equipe possa se concentrar no conteúdo clínico, UX e integrações.

•Questionários e gerenciamento de conteúdo: Crie questionários e versioná-los para que fluxos de entrada possam evoluir, preservando sessões anteriores para revisão.
•Lógica clínica determinística: Armazene os nós de decisão como dados para que as regras sejam auditáveis, testáveis e editáveis sem a necessidade de novos lançamentos para aplicativos clientes.
•APIs flexíveis + auditoria: Use REST e GraphQL para acesso do cliente e registre entradas de auditoria detalhadas para capturar as entradas e os caminhos de decisão para explicabilidade.

Construa, teste e implemente fluxos de triagem de sintomas rapidamente com um contrato de backend gerenciado que suporte múltiplos frontends.

Benefícios principais

Um backend de triagem de sintomas que ajuda você a iterar rapidamente, mantendo a lógica de decisão auditável e orientada ao conteúdo.

Iteração rápida de conteúdo

Criar e versionar pesquisas e nós de decisão sem lançar releases do cliente para cada alteração de conteúdo.

Resultados explicáveis

Persista o caminho de decisão e as entradas para que clínicos e auditores possam reconstruir por que uma determinada recomendação de triagem foi emitida.

Resultados de triagem consistentes

Use avaliação determinística de regras para garantir que entradas idênticas produzam resultados reprodutíveis entre plataformas.

Edição de conteúdo com controle de permissões

Controle quem pode criar ou publicar conteúdo de questionários usando ACLs baseadas em funções e verificações do Cloud Code.

Dados prontos para análise

Capture respostas estruturadas e resultados para que as equipes de produto e clínicas possam analisar o uso e sinais de segurança.

Fluxo de trabalho de bootstrap assistido por IA

Crie rapidamente questionários, nós e resultados de triagem de exemplo com um prompt de Agente de IA já pronto.

Pronto para lançar sua plataforma de triagem de sintomas?

Deixe que o Back4app Agente de IA estruture seu backend do Verificador de Sintomas e gere pesquisas, nós de decisão, respostas, resultados e registros de auditoria a partir de um único prompt.

Desenvolva com o Agente de IA.Experimente o Playground da API.

Grátis para começar — 50 solicitações do Agente de IA por mês, sem cartão de crédito.

Stack técnico

Tudo incluído neste modelo de backend do Verificador de Sintomas.

Front-end

13+ tecnologias

Back-end

Back4app

Banco de dados

MongoDB

Autenticação

Autenticação integrada + sessões

API

REST e GraphQL

Tempo real

Live Queries

Diagrama ER

Modelo de relacionamento entre entidades para o esquema de backend do Symptom Checker.

common.erDiagramPlaceholder

Ver fonte do diagrama

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
    }

Fluxo de Integração

Fluxo típico de tempo de execução para autenticação, coleta guiada, avaliação de decisão e persistência de triagem.

common.erDiagramPlaceholder

Ver fonte do diagrama

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

Dicionário de Dados

Referência completa em nível de campo para cada classe no esquema do Symptom Checker.

Campo	Tipo	Descrição	Obrigatório
objectId	String	Auto-generated unique identifier	Automático
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	Automático
updatedAt	Date	Auto-generated last-update timestamp	Automático

Campos 8 em SymptomSurvey

Segurança e Permissões

Como a estratégia de ACL e CLP garante a segurança do conteúdo da pesquisa, da lógica de decisão e dos dados de resposta sensíveis.

Controle de conteúdo baseado em papéis

Permitir apenas autores clínicos e administradores para criar ou publicar artefatos de Questionário e DecisionNode; os visualizadores verão as versões publicadas.

Dados do usuário protegidos

Os registros de SurveyResponse e UserProfile possuem permissões para que usuários e clínicos acessem apenas os registros autorizados; utilize campos criptografados para dados sensíveis quando necessário.

Auditoria apenas de acréscimos.

As gravações de AuditEntry são restritas a fluxos de backend confiáveis para preservar a rastreabilidade e impedir a adulteração dos logs históricos de decisões.

Esquema (JSON)

Definição bruta do esquema JSON pronta para copiar no Back4app ou usar como referência de implementação.

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
        }
      }
    }
  ]
}

Construir com o Agente de IA

Use o Agente de IA Back4app para gerar um aplicativo Verificador de Sintomas a partir deste modelo, incluindo a estrutura de questionários, árvores de decisão, desfechos de triagem e integração frontend para {tech}.

Back4app Agente de IA

Pronto para construir

Crie um backend de Verificador de Sintomas em Back4app com este esquema e comportamento exatos.

Esquema:
1. Questionário: título (String, obrigatório), versão (String, obrigatório), nó de início (Ponteiro para Nó de Decisão, obrigatório), metadados (Object, opcional).
2. Nó de Decisão: pergunta (String, obrigatória), tipoEntrada (String: singleChoice, multiChoice, numeric, text), condições (Array de objetos de condição), próximoNó (Ponteiro para Nó de Decisão, opcional), desfecho (Ponteiro para Desfecho de Triagem, opcional), tipoDeRegra (String: determinístico, scriptável).
3. Perfil do Usuário: usuário (Ponteiro para Usuário, obrigatório), faixaEtária (String, opcional), indicadoresCrônicos (Array, opcional), consentimentoConcedido (Boolean, obrigatório).
4. Resposta do Questionário: questionário (Ponteiro para Questionário, obrigatório), usuário (Ponteiro para Usuário, opcional), respostas (Object: indexado por nodeId), caminho (Array de Ponteiros para Nó de Decisão), iniciadoEm (Date), concluídoEm (Date, opcional).
5. Desfecho de Triagem: resposta (Ponteiro para Resposta do Questionário, obrigatório), nível (String: autocuidado, cuidadoPrimário, urgente, emergência), textoDeConselho (String), açãoRecomendada (String), criadoNoSistema (Date).
6. Registro de Auditoria: ator (Ponteiro para Usuário, obrigatório), ação (String, obrigatório), contexto (Object), payload (Object, opcional).

Segurança:
- Use ACL/CLP para restringir a criação de questionários e proteger os dados de Resposta do Questionário. Entradas de Auditoria devem ser apenas de adição para usuários não administradores.

Autenticação:
- Cadastro, login e logout para usuários finais e clínicos; permissões baseadas em função para autores e revisores.

Comportamento:
- Buscar questionários publicados e árvores de Nó de Decisão, avaliar os nós progressivamente, persistir Resposta do Questionário com o caminho de decisão, calcular ou registrar o Desfecho de Triagem e criar registros de Entrada de Auditoria para cada avaliação concluída.

Entrega:
- aplicativo Back4app com esquema, ACLs, CLPs; questionários iniciais e nós de decisão; guia de integração de frontend para {tech}; exemplos de playground de API.

Pressione o botão abaixo para abrir o Agente com este prompt de modelo pré-preenchido.

Este é o prompt base sem sufixo de tecnologia. Você pode adaptar o frontend gerado posteriormente.

Implantar em minutos50 prompts gratuitos por mêsNão é necessário cartão de crédito

Playground de API

Experimente os endpoints REST e GraphQL contra o esquema do Verificador de Sintomas. As respostas usam dados simulados e não requerem uma conta Back4app.

common.loadingPlayground

Utiliza o mesmo esquema deste modelo.

Escolha Sua Tecnologia

Expanda cada cartão para passos de integração, padrões de estado, exemplos de modelo de dados e notas offline.

O que você obtém com cada tecnologia

Cada stack usa o mesmo esquema de backend do Symptom Checker e contratos de API

Estrutura de dados unificada verificador de sintomas

Um esquema coeso para pesquisas e perfis de usuários adaptado para verificador de sintomas.

Resultados de triagem em tempo real

Feedback instantâneo sobre os sintomas dos usuários com nós de decisão dinâmicos para verificador de sintomas.

Gerenciamento seguro de dados do usuário

Controle de acesso robusto garantindo a confidencialidade das informações dos usuários de verificador de sintomas.

Acesso à API REST/GraphQL

Integre facilmente com frameworks de frontend via APIs flexíveis para verificador de sintomas.

Experiência de pesquisa personalizável

Personalize pesquisas para atender às necessidades específicas dos usuários de verificador de sintomas para melhor engajamento.

Ferramentas de análise e relatórios

Obtenha insights das interações e resultados dos usuários no aplicativo verificador de sintomas.

Comparação do Framework do Verificador de Sintomas

Compare a velocidade de configuração, estilo de SDK e suporte a IA em todas as tecnologias suportadas.

Framework	Tempo de Configuração	Benefício do Verificador de Sintomas	Tipo de SDK	Suporte de IA
Flutter	Menos de 5 minutos	Base de código única para o verificador de sintomas em dispositivos móveis e na web.	Typed SDK	Completo
React	~3–7 min	Painel da web rápido para o verificador de sintomas.	Typed SDK	Completo
React Nativo	Configuração rápida (5 min)	Aplicativo móvel multiplataforma para o verificador de sintomas.	Typed SDK	Completo
Next.js	~5 min	Aplicativo web renderizado no servidor para o verificador de sintomas.	Typed SDK	Completo
JavaScript	~3–5 min	Integração web leve para o verificador de sintomas.	Typed SDK	Completo
Android	Menos de 5 minutos	Aplicativo nativo Android para o verificador de sintomas.	Typed SDK	Completo
iOS	~3–7 min	Aplicativo nativo iOS para o verificador de sintomas.	Typed SDK	Completo
Vue	Configuração rápida (5 min)	Interface web Reactiva para o verificador de sintomas.	Typed SDK	Completo
Angular	~5 min	Aplicativo web corporativo para o verificador de sintomas.	Typed SDK	Completo
GraphQL	Menos de 2 min	API GraphQL flexível para o verificador de sintomas.	GraphQL API	Completo
REST API	Configuração rápida (2 min)	Integração REST API para o verificador de sintomas.	REST API	Completo
PHP	~3 min	Backend PHP do lado do servidor para o verificador de sintomas.	REST API	Completo
.NET	Configuração rápida (5 min)	Backend .NET para o verificador de sintomas.	Typed SDK	Completo

O tempo de configuração reflete a duração prevista desde a inicialização do projeto até a primeira pesquisa e avaliação de decisão usando este esquema de template.

Perguntas frequentes

Perguntas comuns sobre a construção de um backend de Verificador de Sintomas com este modelo.

O que é um back-end do Verificador de Sintomas?

O que este modelo inclui?

Por que usar Back4app para um aplicativo de triagem de sintomas?

Como posso coletar e reproduzir uma sessão de questionário?

Como crio um TriageOutcome após a avaliação?

Posso armazenar em cache árvores de DecisionNode em dispositivos móveis para uso offline?

Como posso auditar por que uma orientação específica foi dada?

Qual é a maneira recomendada de atualizar o conteúdo clínico?

Como devo lidar com a conformidade regulatória?

Como posso evitar a injeção maliciosa de regras?

Confiado por desenvolvedores em todo o mundo.

Equipes que constroem experiências de triagem e entrada dependem dos templates Back4app para backends rápidos e compatíveis.

Pronto para construir seu aplicativo de verificação de sintomas?

Inicie seu projeto de triagem de sintomas em minutos. Não é necessário cartão de crédito.

Escolha a Tecnologia

Modelo de Backend do Aplicativo de Verificação de SintomasQuestionários de avaliação inicial guiados, resultados de triagem e avaliação de árvores de decisão