Symptom Checker Backend

Symptom Checker App Backend Template
Guided intake surveys, triage outcomes, and decision-tree evaluation

Q: What is a Symptom Checker backend?

A Symptom Checker backend is a BaaS schema and API that models intake surveys, decision logic trees, user profiles, responses, outcomes, and audit trails to support triage applications.

Q: What does this template include?

It includes Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome, AuditEntry, ER diagram, API playground, JSON schema, and an AI Agent prompt to bootstrap content.

Q: Why use Back4app for a symptom triage app?

Back4app provides managed data storage, auth, generated REST/GraphQL endpoints, live queries, and Cloud Code so teams can iterate content and logic without operating backend infrastructure.

Q: How do I collect and replay a survey session?

Save each answer into SurveyResponse.answers with node references and path; use the stored path to replay the sequence of DecisionNode evaluations.

Q: How do I create a TriageOutcome after evaluation?

Either client or server creates a TriageOutcome record linked to the SurveyResponse. For safety, use Cloud Code to verify evaluation results before persisting outcomes.

Q: Can I cache DecisionNode trees on mobile for offline use?

Yes. Pin published Survey and DecisionNode records in local datastore so evaluation can continue offline and sync responses when online.

Q: How do I audit why a particular advice was given?

Inspect the SurveyResponse.path and AuditEntry records to see which nodes matched conditions and what inputs were used to generate the TriageOutcome.

Q: What is the recommended way to update clinical content?

Create a new Survey version and test it in staging; once validated, publish it and migrate clients to the new version for fresh evaluations.

Q: How should I handle regulatory compliance?

Apply strict CLP/ACL to personal data, consider encryption where appropriate, maintain full audit trails, and consult clinical governance or legal teams for local requirements.

Q: How do I prevent malicious rule injection?

Restrict DecisionNode editing to trusted authors, validate rule schemas in Cloud Code, and avoid executing arbitrary scripts from stored records in production.

A production-ready Symptom Checker backend on Back4app with intake surveys, clinical logic trees, triage outcomes, user profiles, and audit trails. Includes ER diagram, data dictionary, JSON schema, API playground, and an AI Agent prompt for rapid bootstrap.

Build with AI Agent Choose Your Technology

Key Takeaways

This template provides a Symptom Checker backend with survey, decision tree, outcome, user, and audit models so your team can focus on clinical content and UX.

Opinionated intake model — Track survey definitions, question variants, and user responses to reliably reconstruct intake sessions.
Clinical logic nodes — Represent decision trees as linked DecisionNode records so evaluation logic is decoupled from client code.
Triage outcomes — Store deterministic triage outcomes (advice, urgency level, recommended next steps) for downstream analytics and routing.
Audit and explainability — Capture the decision path and user inputs so results are auditable and explainable for clinicians and compliance reviews.
Cross-platform APIs — REST and GraphQL endpoints serve mobile and web clients with consistent contracts for intake and triage.

What Is the Symptom Checker App Backend Template?

Back4app is a backend-as-a-service (BaaS) for fast product delivery. The Symptom Checker App Backend Template is a pre-built schema for surveys, decision nodes, survey responses, triage outcomes, user profiles, and audit entries. Connect your preferred frontend (React, Flutter, Next.js, and more) and ship faster.

Best for:

Patient-facing symptom triageClinical decision support prototypesTelehealth intake workflowsInternal triage tools for clinicsMVPs for digital triage productsTeams using BaaS for regulated content

Overview

A reliable symptom checker requires structured intake data, explicit decision logic, and auditable outcomes to support triage and analytics.

This template defines Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome, and AuditEntry with sensible ownership and validation rules to support clinical intake workflows.

Core Symptom Checker Features

Every technology card in this hub uses the same Symptom Checker backend schema with Survey, DecisionNode, UserProfile, SurveyResponse, TriageOutcome, and AuditEntry.

Survey definition and versioning

Survey class stores title, version, startNode, and metadata for authoring guided intake flows.

DecisionNode trees

DecisionNode models questions, branching logic, condition expressions, and pointers to subsequent nodes.

SurveyResponse tracking

SurveyResponse stores user answers, timestamps, and the evaluated path through the decision tree.

TriageOutcome records

TriageOutcome captures the evaluated level (self-care, urgent, emergency), advice text, and recommended next steps.

UserProfile management

UserProfile links Back4app User accounts to demographic and clinical metadata used during triage.

Explainable audit entries

AuditEntry records actor, action, context, and payload for each critical evaluation and outcome.

Why Build Your Symptom Checker Backend with Back4app?

Back4app provides the managed building blocks for intake, decision logic, and triage so your team can focus on clinical content, UX, and integrations.

•Survey and content management: Author surveys and version them so intake flows can evolve while preserving earlier sessions for review.
•Deterministic clinical logic: Store decision nodes as data so rules are auditable, testable, and editable without new releases to client apps.
•Flexible APIs + auditing: Use REST and GraphQL for client access and record detailed audit entries to capture input and decision paths for explainability.

Compose, test, and deploy symptom triage flows quickly with a managed backend contract that supports multiple frontends.

Core Benefits

A symptom triage backend that helps you iterate quickly while keeping decision logic auditable and content-driven.

Rapid content iteration

Author and version surveys and decision nodes without shipping client releases for every content change.

Explainable outcomes

Persist the decision path and inputs so clinicians and auditors can reconstruct why a particular triage recommendation was issued.

Consistent triage results

Use deterministic rule evaluation to ensure identical inputs produce repeatable outcomes across platforms.

Permissioned content editing

Control who can author or publish survey content using role-based ACLs and Cloud Code checks.

Analytics-ready data

Capture structured responses and outcomes so product and clinical teams can analyze usage and safety signals.

AI-assisted bootstrap workflow

Seed surveys, nodes, and example triage outcomes quickly with a ready-made AI Agent prompt.

Ready to launch your symptom triage platform?

Let the Back4app AI Agent scaffold your Symptom Checker backend and generate surveys, decision nodes, responses, outcomes, and audit logs from one prompt.

Build with AI Agent Try the API Playground

Free to start — 50 AI Agent prompts/month, no credit card required

Technical Stack

Everything included in this Symptom Checker backend template.

Frontend

13+ technologies

Backend

Back4app

Database

MongoDB

Auth

Built-in auth + sessions

API

REST and GraphQL

Realtime

Live Queries

ER Diagram

Entity relationship model for the Symptom Checker backend schema.

common.erDiagramPlaceholder

View diagram source

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
    }

Integration Flow

Typical runtime flow for auth, guided intake, decision evaluation, and triage persistence.

common.erDiagramPlaceholder

View diagram source

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

Data Dictionary

Full field-level reference for every class in the Symptom Checker schema.

Field	Type	Description	Required
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 fields in SymptomSurvey

Security and Permissions

How ACL and CLP strategy secures survey content, decision logic, and sensitive response data.

Role-based content control

Allow only clinical authors and admins to create or publish Survey and DecisionNode artifacts; viewers see published versions.

Protected user data

SurveyResponse and UserProfile records are permissioned so users and clinicians access only authorized records; use encrypted fields for sensitive data where required.

Append-only audit

AuditEntry writes are restricted to trusted backend flows to preserve traceability and prevent tampering with historical decision logs.

Schema (JSON)

Raw JSON schema definition ready to copy into Back4app or use as implementation reference.

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

Build with AI Agent

Use the Back4app AI Agent to generate a Symptom Checker app from this template, including survey scaffolding, decision trees, triage outcomes, and frontend integration for {tech}.

Back4app AI Agent

Ready to build

Create a Symptom Checker backend on Back4app with this exact schema and behavior.

Schema:
1. Survey: title (String, required), version (String, required), startNode (Pointer to DecisionNode, required), metadata (Object, optional).
2. DecisionNode: question (String, required), inputType (String: singleChoice, multiChoice, numeric, text), conditions (Array of condition objects), nextNode (Pointer to DecisionNode, optional), outcome (Pointer to TriageOutcome, optional), ruleType (String: deterministic, scriptable).
3. UserProfile: user (Pointer to User, required), ageRange (String, optional), chronicFlags (Array, optional), consentGiven (Boolean, required).
4. SurveyResponse: survey (Pointer to Survey, required), user (Pointer to User, optional), answers (Object: keyed by nodeId), path (Array of DecisionNode pointers), startedAt (Date), completedAt (Date, optional).
5. TriageOutcome: response (Pointer to SurveyResponse, required), level (String: self-care, primary-care, urgent, emergency), adviceText (String), recommendedAction (String), createdAt (system).
6. AuditEntry: actor (Pointer to User, required), action (String, required), context (Object), payload (Object, optional).

Security:
- Use ACL/CLP to restrict survey authoring and to protect SurveyResponse data. AuditEntry writes should be append-only for non-admins.

Auth:
- Sign-up, login, logout for end users and clinicians; role-based permissions for authors and reviewers.

Behavior:
- Fetch published Survey and DecisionNode trees, evaluate nodes progressively, persist SurveyResponse with the decision path, compute or record TriageOutcome, and create AuditEntry records for each completed evaluation.

Deliver:
- Back4app app with schema, ACLs, CLPs; starter surveys and decision nodes; frontend integration guide for {tech}; API playground examples.

Press the button below to open the Agent with this template prompt pre-filled.

This is the base prompt without a technology suffix. You can adapt the generated frontend stack afterward.

Deploy in minutes50 free prompts / monthNo credit card required

API Playground

Try REST and GraphQL endpoints against the Symptom Checker schema. Responses use mock data and do not require a Back4app account.

common.loadingPlayground

Uses the same schema as this template.

Choose Your Technology

Expand each card for integration steps, state patterns, data model examples, and offline notes.

What You Get with Every Technology

Every stack uses the same Symptom Checker backend schema and API contracts.

Unified symptom checker data structure

A cohesive schema for surveys and user profiles tailored for symptom checker.

Real-time triage outcomes

Instant feedback on user symptoms with dynamic decision nodes for symptom checker.

Secure user data management

Robust access control ensuring confidentiality of symptom checker user information.

REST/GraphQL API access

Easily integrate with frontend frameworks via flexible APIs for symptom checker.

Customizable survey experience

Tailor surveys to meet specific needs of symptom checker users for better engagement.

Analytics and reporting tools

Gain insights from user interactions and outcomes in the symptom checker app.

Symptom Checker Framework Comparison

Compare setup speed, SDK style, and AI support across all supported technologies.

Framework	Setup Time	Symptom Checker Benefit	SDK Type	AI Support
Flutter	Under 5 minutes	Single codebase for symptom checker on mobile and web.	Typed SDK	Full
React	~3–7 min	Fast web dashboard for symptom checker.	Typed SDK	Full
React Native	Rapid (5 min) setup	Cross-platform mobile app for symptom checker.	Typed SDK	Full
Next.js	~5 min	Server-rendered web app for symptom checker.	Typed SDK	Full
JavaScript	~3–5 min	Lightweight web integration for symptom checker.	Typed SDK	Full
Android	Under 5 minutes	Native Android app for symptom checker.	Typed SDK	Full
iOS	~3–7 min	Native iOS app for symptom checker.	Typed SDK	Full
Vue	Rapid (5 min) setup	Reactive web UI for symptom checker.	Typed SDK	Full
Angular	~5 min	Enterprise web app for symptom checker.	Typed SDK	Full
GraphQL	Under 2 min	Flexible GraphQL API for symptom checker.	GraphQL API	Full
REST API	Quick (2 min) setup	REST API integration for symptom checker.	REST API	Full
PHP	~3 min	Server-side PHP backend for symptom checker.	REST API	Full
.NET	Rapid (5 min) setup	.NET backend for symptom checker.	Typed SDK	Full

Setup time reflects expected duration from project bootstrap to first survey and decision evaluation using this template schema.

Frequently Asked Questions

Common questions about building a Symptom Checker backend with this template.

What is a Symptom Checker backend?

What does this template include?

Why use Back4app for a symptom triage app?

How do I collect and replay a survey session?

How do I create a TriageOutcome after evaluation?

Can I cache DecisionNode trees on mobile for offline use?

How do I audit why a particular advice was given?

What is the recommended way to update clinical content?

How should I handle regulatory compliance?

How do I prevent malicious rule injection?

Trusted by developers worldwide

Teams building triage and intake experiences rely on Back4app templates for fast, compliant backends

Ready to Build Your Symptom Checker App?

Start your symptom triage project in minutes. No credit card required.

Choose Technology

Symptom Checker App Backend TemplateGuided intake surveys, triage outcomes, and decision-tree evaluation