Backend de Verificación de Síntomas

Plantilla de Backend de Aplicación de Verificación de Síntomas
Encuestas de ingreso guiadas, resultados de triaje y evaluación de árbol de decisiones

Q: ¿Qué es un backend de Comprobador de Síntomas?

Un backend de verificador de síntomas es un esquema y API de BaaS que modela encuestas de ingreso, árboles de lógica de decisión, perfiles de usuario, respuestas, resultados y registros de auditoría para apoyar aplicaciones de triaje.

Q: ¿Qué incluye esta plantilla?

Incluye Encuesta, DecisionNode, UserProfile, SurveyResponse, TriageOutcome, AuditEntry, diagrama ER, playground de API, esquema JSON y un aviso de agente de IA para ayudar a generar contenido.

Q: ¿Por qué usar Back4app para una aplicación de triaje de síntomas?

Back4app proporciona almacenamiento de datos gestionado, autenticación, puntos finales REST/GraphQL generados, Live Queries, y Cloud Code para que los equipos puedan iterar contenido y lógica sin operar infraestructura de backend.

Q: ¿Cómo recolecto y reproduzco una sesión de encuesta?

Guarda cada respuesta en SurveyResponse.answers con referencias de nodo y ruta; utiliza la ruta almacenada para reproducir la secuencia de evaluaciones de DecisionNode.

Q: ¿Cómo creo un TriageOutcome después de la evaluación?

Ya sea el cliente o el servidor crea un registro TriageOutcome vinculado a SurveyResponse. Por seguridad, usa Cloud Code para verificar los resultados de la evaluación antes de persistir los resultados.

Q: ¿Puedo almacenar en caché los árboles de DecisionNode en móvil para uso sin conexión?

Sí. Se publican encuestas y registros de DecisionNode en la base de datos local para que la evaluación pueda continuar sin conexión y sincronizar las respuestas cuando esté en línea.

Q: ¿Cómo audito por qué se dio un consejo particular?

Inspeccione los registros SurveyResponse.path y AuditEntry para ver qué nodos coincidieron con las condiciones y qué entradas se utilizaron para generar el TriageOutcome.

Q: ¿Cuál es la forma recomendada de actualizar el contenido clínico?

Cree una nueva versión de la encuesta y pruebe en staging; una vez validada, publíquela y migre a los clientes a la nueva versión para nuevas evaluaciones.

Q: ¿Cómo debo manejar el cumplimiento regulatorio?

Aplique CLP/ACL estrictos a los datos personales, considere la encriptación cuando sea apropiado, mantenga registros completos de auditoría y consulte a los equipos de gobernanza clínica o legal para los requisitos locales.

Q: ¿Cómo prevengo la inyección de reglas maliciosas?

Restringa la edición de DecisionNode a autores de confianza, valide los esquemas de reglas en Cloud Code y evite ejecutar scripts arbitrarios de registros almacenados en producción.

Un backend de Verificación de Síntomas listo para producción en Back4app con encuestas de ingreso, árboles de lógica clínica, resultados de triaje, perfiles de usuario y registros de auditoría. Incluye diagrama ER, diccionario de datos, esquema JSON, área de juego API y un prompt de Agente AI para un arranque rápido.

Construir con Agente de IA Elige tu tecnología

Puntos clave

Esta plantilla proporciona un backend de Verificador de Síntomas con modelos de encuesta, árbol de decisiones, resultados, usuario y auditoría para que tu equipo pueda centrarse en el contenido clínico y la experiencia de usuario.

Modelo de ingreso opinado — Rastrea definiciones de encuestas, variantes de preguntas y respuestas de usuarios para reconstruir de manera confiable las sesiones de ingreso.
Nodos de lógica clínica — Representa árboles de decisiones como registros de DecisionNode vinculados para que la lógica de evaluación esté desacoplada del código del cliente.
Resultados de triage — Almacena resultados de triage deterministas (consejos, nivel de urgencia, próximos pasos recomendados) para análisis y enrutamiento posterior.
Auditoría y explicabilidad — Captura el camino de decisión y las entradas del usuario para que los resultados sean auditables y explicables para los clínicos y las revisiones de cumplimiento.
APIs multiplataforma — Los endpoints REST y GraphQL sirven a clientes móviles y web con contratos consistentes para la recepción y la triage.

¿Qué es la plantilla de backend de la aplicación de verificación de síntomas?

Back4app es un backend como servicio (BaaS) para una rápida entrega de productos. La plantilla de backend de la aplicación de verificación de síntomas es un esquema preconstruido para encuestas, nodos de decisión, respuestas de encuesta, resultados de triage, perfiles de usuario y entradas de auditoría. Conecta tu frontend preferido (React, Flutter, Next.js, y más) y envía más rápido.

Mejor para:

Triage de síntomas para pacientesPrototipos de soporte para la toma de decisiones clínicasFlujos de trabajo de admisión de telemedicinaHerramientas de triaje interno para clínicasMVPs para productos de triaje digitalEquipos que utilizan BaaS para contenido regulado

Descripción general

Un verificador de síntomas confiable requiere datos de admisión estructurados, lógica de decisión explícita y resultados auditables para apoyar el triaje y la analítica.

Este template define Encuesta, NodoDecisión, PerfilUsuario, RespuestaEncuesta, ResultadoTriaje y EntradaAuditoria con reglas de propiedad y validación sensatas para apoyar los flujos de trabajo de admisión clínica.

Características principales del Comprobador de Síntomas

Cada tarjeta de tecnología en este hub utiliza el mismo esquema de backend de Symptom Checker con Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome y AuditEntry.

Definición y versionado de encuestas

La clase de encuesta almacena título, versión, startNode y metadatos para la creación de flujos de ingreso guiados.

Árboles de DecisionNode

El modelo DecisionNode plantea preguntas, lógica de ramificación, expresiones de condición y punteros a nodos subsiguientes.

Seguimiento de respuestas de encuesta

SurveyResponse almacena las respuestas de los usuarios, las marcas de tiempo y la ruta evaluada a través del árbol de decisiones.

Resultados de Triage

TriageOutcome captura el nivel evaluado (autocuidado, urgente, emergencia), el texto de asesoramiento y los próximos pasos recomendados.

Gestión de perfiles de usuario

UserProfile vincula las cuentas de Back4app a los metadatos demográficos y clínicos utilizados durante el triaje.

Entradas de auditoría explicables

AuditEntry registra actor, acción, contexto y carga útil para cada evaluación crítica y resultado.

¿Por qué construir el backend de su comprobador de síntomas con Back4app?

Back4app proporciona la construcción gestionada de Blocks para intake, lógica de decisión y triaje, para que su equipo pueda centrarse en el contenido clínico, la experiencia del usuario y las integraciones.

•Gestión de encuestas y contenido: Autoriza encuestas y versiona las mismas para que los flujos de intake puedan evolucionar mientras se preservan sesiones anteriores para revisión.
•Lógica clínica determinista: Almacena nodos de decisión como datos para que las reglas sean auditables, testables y editables sin nuevas versiones para aplicaciones cliente.
•APIs flexibles + auditoría: Utiliza REST y GraphQL para acceso de cliente y registra entradas de auditoría detalladas para capturar entradas y caminos de decisión para explicabilidad.

Componga, pruebe y despliegue flujos de triaje de síntomas rápidamente con un contrato de backend gestionado que soporte múltiples frontends.

Beneficios clave

Un backend de triage de síntomas que te ayuda a iterar rápidamente mientras mantienes la lógica de decisión auditable y basada en contenido.

Iteración rápida de contenido

Crea encuestas y nodos de decisión sin necesidad de enviar lanzamientos de cliente para cada cambio de contenido.

Resultados explicables

Persistir el camino de decisión y las entradas para que los clínicos y auditores puedan reconstruir por qué se emitió una recomendación de triaje particular.

Resultados de triaje consistentes

Usar evaluación de reglas determinísticas para asegurar que entradas idénticas produzcan resultados repetibles en todas las plataformas.

Edición de contenido con permisos

Controlar quién puede autorizar o publicar contenido de la encuesta utilizando ACLs basadas en roles y verificaciones de Cloud Code.

Datos listos para análisis

Capturar respuestas y resultados estructurados para que los equipos de producto y clínicos puedan analizar señales de uso y seguridad.

Flujo de trabajo de arranque asistido por IA

Sembrar encuestas, nodos y ejemplos de resultados de triaje rápidamente con un aviso de agente de IA listo para usar.

¿Listo para lanzar tu plataforma de triaje de síntomas?

Deja que el Agente de IA de Back4app cree la estructura de tu backend del Verificador de Síntomas y genere encuestas, nodos de decisión, respuestas, resultados y registros de auditoría desde un solo aviso.

Construye con Agente de IA Prueba el API Playground

Gratis para comenzar — 50 avisos de Agente de IA/mes, no se requiere tarjeta de crédito

Pila técnica

Todo incluido en esta plantilla de backend del Verificador de Síntomas.

Frontend

13+ tecnologías

Backend

Back4app

Base de datos

MongoDB

Autenticación

Autenticación y sesiones integradas

API

REST y GraphQL

En tiempo real

Live Queries

Diagrama ER

Modelo de relación de entidades para el esquema backend del Checador de Síntomas.

common.erDiagramPlaceholder

Ver fuente del 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
    }

Flujo de integración

Flujo de ejecución típico para la autenticación, ingreso guiado, evaluación de decisiones y persistencia de triaje.

common.erDiagramPlaceholder

Ver fuente del 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

Diccionario de datos

Referencia completa a nivel de campo para cada clase en el esquema del Verificador de Síntomas.

Campo	Tipo	Descripción	Requerido
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 campos en SymptomSurvey

Seguridad y Permisos

Cómo la estrategia de ACL y CLP asegura el contenido de la encuesta, la lógica de decisión y los datos de respuesta sensibles.

Control de contenido basado en roles

Permitir que solo autores clínicos y administradores creen o publiquen artefactos de Encuesta y DecisionNode; los espectadores ven versiones publicadas.

Datos de usuario protegidos

Los registros de SurveyResponse y UserProfile tienen permisos para que los usuarios y clínicos accedan solo a registros autorizados; utilizar campos encriptados para datos sensibles cuando sea necesario.

Auditoría solo de anexos

Las escrituras de AuditEntry están restringidas a flujos de backend de confianza para preservar la trazabilidad y prevenir la manipulación de registros de decisiones históricas.

Esquema (JSON)

Definición de esquema JSON en bruto lista para copiar en Back4app o usar como referencia de implementación.

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 con agente de IA

Utiliza el agente de IA de Back4app para generar una aplicación de Verificador de Síntomas a partir de esta plantilla, incluyendo estructura de encuesta, árboles de decisiones, resultados de triaje e integración de frontend para {tech}.

Agente de IA de Back4app

Listo para construir

Crea un backend de Verificador de Síntomas en Back4app con este esquema y comportamiento exactos.

Esquema:
1. Encuesta: título (Cadena, requerido), versión (Cadena, requerido), startNode (Puntero a DecisionNode, requerido), metadata (Objeto, opcional).
2. DecisionNode: pregunta (Cadena, requerido), inputType (Cadena: singleChoice, multiChoice, numérico, texto), condiciones (Array de objetos de condición), nextNode (Puntero a DecisionNode, opcional), outcome (Puntero a TriageOutcome, opcional), ruleType (Cadena: determinístico, programable).
3. UserProfile: usuario (Puntero a Usuario, requerido), rangoDeEdad (Cadena, opcional), flagsCrónicos (Array, opcional), consentimientoDado (Booleano, requerido).
4. EncuestaRespuesta: encuesta (Puntero a Encuesta, requerido), usuario (Puntero a Usuario, opcional), respuestas (Objeto: indexado por nodeId), ruta (Array de punteros de DecisionNode), startedAt (Fecha), completedAt (Fecha, opcional).
5. TriageOutcome: respuesta (Puntero a EncuestaRespuesta, requerido), nivel (Cadena: autocuidado, atención primaria, urgente, emergencia), textoConsejo (Cadena), acciónRecomendada (Cadena), createdAt (sistema).
6. AuditEntry: actor (Puntero a Usuario, requerido), acción (Cadena, requerido), contexto (Objeto), carga (Objeto, opcional).

Seguridad:
- Utiliza ACL/CLP para restringir la creación de encuestas y proteger los datos de EncuestaRespuesta. Las escrituras de AuditEntry deben ser solo de apéndice para no administradores.

Autenticación:
- Registro, inicio de sesión, cierre de sesión para usuarios finales y clínicos; permisos basados en roles para autores y revisores.

Comportamiento:
- Obtener Encuesta y árboles de DecisionNode publicados, evaluar nodos progresivamente, persistir EncuestaRespuesta con el camino de decisión, calcular o registrar TriageOutcome y crear registros de AuditEntry por cada evaluación completada.

Entrega:
- Aplicación Back4app con esquema, ACLs, CLPs; encuestas iniciales y nodos de decisión; guía de integración de frontend para {tech}; ejemplos de API playground.

Presiona el botón de abajo para abrir el Agente con este aviso de plantilla prellenado.

Este es el aviso base sin un sufijo tecnológico. Puedes adaptar la pila de frontend generada después.

Desplegar en minutos50 avisos gratuitos / mesNo se requiere tarjeta de crédito

API Playground

Prueba los endpoints REST y GraphQL contra el esquema del Verificador de Síntomas. Las respuestas utilizan datos simulados y no requieren una cuenta de Back4app.

common.loadingPlayground

Usa el mismo esquema que esta plantilla.

Elige tu Tecnología

Expande cada tarjeta para obtener pasos de integración, patrones de estado, ejemplos de modelo de datos y notas sin conexión.

Lo que obtienes con cada tecnología

Cada stack utiliza el mismo esquema de backend del Verificador de Síntomas y contratos de API.

Estructura de datos unificada verificación de síntomas

Un esquema cohesivo para encuestas y perfiles de usuario adaptados para verificación de síntomas.

Resultados de triaje en tiempo real

Retroalimentación instantánea sobre los síntomas del usuario con nodos de decisión dinámica para verificación de síntomas.

Gestión segura de datos del usuario

Control de acceso robusto que garantiza la confidencialidad de la información del usuario de verificación de síntomas.

Acceso a API REST/GraphQL

Integre fácilmente con marcos frontend a través de APIs flexibles para verificación de síntomas.

Experiencia de encuesta personalizable

Adapte las encuestas para satisfacer las necesidades específicas de los usuarios de verificación de síntomas para una mejor participación.

Herramientas de análisis e informes

Obtenga información de las interacciones y resultados de los usuarios en la aplicación verificación de síntomas.

Comparación del marco de verificación de síntomas

Comparar la velocidad de configuración, estilo de SDK y soporte de IA a través de todas las tecnologías soportadas.

Marco	Tiempo de configuración	Beneficio de la verificación de síntomas	Tipo de SDK	Soporte de IA
Flutter	Menos de 5 minutos	Código base único para la verificación de síntomas en móvil y web.	Typed SDK	Completo
React	~3–7 min	Tablero web rápido para la verificación de síntomas.	Typed SDK	Completo
React Nativo	Configuración rápida (5 min)	Aplicación móvil multiplataforma para la verificación de síntomas.	Typed SDK	Completo
Next.js	~5 min	Aplicación web renderizada en el servidor para la verificación de síntomas.	Typed SDK	Completo
JavaScript	~3–5 min	Integración web ligera para la verificación de síntomas.	Typed SDK	Completo
Android	Menos de 5 minutos	Aplicación nativa de Android para la verificación de síntomas.	Typed SDK	Completo
iOS	~3–7 min	Aplicación nativa de iOS para la verificación de síntomas.	Typed SDK	Completo
Vue	Configuración rápida (5 min)	Interfaz web Reactiva para la verificación de síntomas.	Typed SDK	Completo
Angular	~5 min	Aplicación web empresarial para la verificación de síntomas.	Typed SDK	Completo
GraphQL	Menos de 2 min	API flexible de GraphQL para la verificación de síntomas.	GraphQL API	Completo
REST API	Configuración rápida (2 min)	Integración de REST API para la verificación de síntomas.	REST API	Completo
PHP	~3 min	Backend de PHP del lado del servidor para la verificación de síntomas.	REST API	Completo
.NET	Configuración rápida (5 min)	Backend de .NET para la verificación de síntomas.	Typed SDK	Completo

El tiempo de configuración refleja la duración esperada desde el inicio del proyecto hasta la primera encuesta y evaluación de decisiones usando este esquema de plantilla.

Preguntas Frecuentes

Preguntas comunes sobre la construcción de un backend de Checkeador de Síntomas con esta plantilla.

¿Qué es un backend de Comprobador de Síntomas?

¿Qué incluye esta plantilla?

¿Por qué usar Back4app para una aplicación de triaje de síntomas?

¿Cómo recolecto y reproduzco una sesión de encuesta?

¿Cómo creo un TriageOutcome después de la evaluación?

¿Puedo almacenar en caché los árboles de DecisionNode en móvil para uso sin conexión?

¿Cómo audito por qué se dio un consejo particular?

¿Cuál es la forma recomendada de actualizar el contenido clínico?

¿Cómo debo manejar el cumplimiento regulatorio?

¿Cómo prevengo la inyección de reglas maliciosas?

Confiado por desarrolladores en todo el mundo

Los equipos que construyen experiencias de triaje y recepción dependen de las plantillas de Back4app para obtener backends rápidos y conformes

¿Listo para construir tu aplicación de verificación de síntomas?

Inicia tu proyecto de triaje de síntomas en minutos. No se requiere tarjeta de crédito.

Elegir Tecnología

Plantilla de Backend de Aplicación de Verificación de SíntomasEncuestas de ingreso guiadas, resultados de triaje y evaluación de árbol de decisiones