Backend do Concierge Médico

Modelo de Backend do Aplicativo de Concierge Médico
Ofereça experiências personalizadas para pacientes, gerencie compromissos e coordene cuidados de forma segura

Q: O que é um backend de Concierge Médico?

Um backend de Concierge Médico é um esquema e API estruturados BaaS para gerenciar interações entre pacientes e Provider, agendamento de consultas, mensagens e auditoria.

Q: O que o modelo de Concierge Médico inclui?

Inclui as classes PatientProfile, Appointment, Message, ProviderProfile e AuditLog, além do diagrama ER, playground da API, esquema JSON e um prompt de Agente de IA.

Q: Por que usar Back4app para um aplicativo de concierge médico?

Back4app oferece persistência gerenciada, autenticação, geração de API, capacidades em tempo real e Cloud Code, permitindo que as equipes se concentrem no envolvimento dos pacientes em vez da infraestrutura.

Q: Como posso buscar a última consulta e sua Provider em uma única solicitação?

Utilize GraphQL para consultas aninhadas ou chamadas REST adequadas que incorporem referências de ponteiro para obter registros de Appointment junto com suas informações Provider.

Q: Como posso marcar uma mensagem como entregue?

Atualize o campo Message.status para 'entregue' enquanto confirma o papel dos atualizadores. Registre a ação no AuditLog para rastreabilidade.

Q: Posso gerenciar dados de compromissos para acesso offline no React Native?

Sim, ative o Local Datastore e fixar registros de Compromissos para garantir que dados críticos estejam acessíveis sem conexão à internet.

Q: Como faço para proteger PDFs de pacientes para compromissos?

Utilize URLs assinadas com tempos de expiração e aplique ACLs para restringir o acesso, protegendo assim dados sensíveis de visualizações não autorizadas.

Q: Qual é a melhor maneira de exibir interações de compromissos em dispositivos móveis?

Recupere Compromissos juntamente com registros de Mensagens para criar relações temporais, apresentando-os como uma linha do tempo coesa; aproveite o armazenamento local para compromissos futuros.

Q: Como funciona o processo de registro de auditoria de ponta a ponta?

Use gatilhos de Cloud Code para registrar ações (por exemplo, agendamento de compromissos ou envio de mensagens). Cada entrada armazena detalhes sobre o usuário, ação, entidade envolvida e contexto para referência futura.

Q: Como apoio o reconhecimento do paciente sobre um compromisso?

Incorpore uma flag de reconhecimento (por exemplo, campos acknowledgedBy e acknowledgedAt) no seu esquema de Compromisso e registre essa ação no AuditLog para garantir responsabilidade.

Um backend de concierge médico pronto para produção em Back4app com gerenciamento premium de pacientes, agendamento de compromissos, mensagens seguras e rigorosos logs de auditoria. Inclui diagrama ER, dicionário de dados, esquema JSON, playground da API e um prompt para Agente de IA para inicialização rápida.

Construir com Agente de IA Escolha Sua Tecnologia

Principais Conclusões

Envie um backend focado na experiência do paciente, compromissos seguros e caminhos de cuidado coordenados para permitir que sua equipe se concentre na funcionalidade e conformidade.

Modelo de dados centrado no paciente — Mantenha a identidade do paciente, compromissos, mensagens e interações com Provider separadamente, garantindo um contexto vinculado para uma clara proveniência e autorização.
Mensagens seguras — Conversas assíncronas e em threads entre pacientes e Providers com anexos opcionais e recibos de leitura.
Gerenciamento de compromissos — Gerencie facilmente os horários de compromissos, notificações de pacientes e atribuições de Provider.
Registro de auditoria — Registros de auditoria detalhados capturam eventos sensíveis para apoiar conformidade e monitoramento.
Arquitetura pronta para integração — Suporte embutido para REST e GraphQL ajuda a simplificar integrações com várias tecnologias voltadas para pacientes.

O que é o template de backend do aplicativo Concierge Médico?

Back4app é um backend como serviço (BaaS) para entrega rápida. O template de backend do aplicativo Concierge Médico é um esquema pré-projetado para gestão de pacientes, agendamento de consultas, mensagens seguras e registros de auditoria. Conecte seu front-end (React, Flutter, Next.js, etc.) para agilizar o desenvolvimento.

Melhor para:

Aplicações de concierge médicoServiços de gestão de pacientesAgendamento de consultasMensagens seguras para a saúdeEquipes construindo soluções compatíveis com HIPAA

Visão geral

Aplicações de concierge médico demandam robusta gestão de dados e manuseio seguro de itens sensíveis, como registros de pacientes e detalhes de consultas.

Este template define as classes PatientProfile, Appointment, Message, ProviderProfile e AuditLog com regras de propriedade e baseadas em funções projetadas para implementação rápida e segura de aplicações de concierge médico.

Recursos principais de Concierge Médico

Cada cartão de tecnologia neste hub utiliza o mesmo esquema de backend de concierge médico com PatientProfile, Appointment, Message, ProviderProfile e AuditLog.

Perfil do paciente e autenticação

O PerfilDoPaciente contém identidade, informações de contato e preferências associadas a um Usuário.

Gerenciamento de compromissos

A classe de Compromisso conecta pacientes aos Provider com detalhes de agendamento e status.

Mensagens seguras

As mensagens suportam thread, anexos, links de remetente/destinatário e rastreamento de status.

Registros de auditoria centralizados

AuditLog fornece informações sobre ações realizadas por usuários, capturando detalhes relevantes do evento.

Por que construir o backend do seu aplicativo de concierge médico com Back4app?

Back4app gerencia os essenciais de backend—segurança, persistência, APIs e comunicações em tempo real—permitindo que você se concentre em melhorar as experiências dos pacientes e oferecer um atendimento impecável.

•Manipulação de dados segura: Autorização e permissões integradas garantem que usuários designados possam acessar registros específicos de pacientes e funcionalidades de mensagens.
•Rastreamento de auditoria abrangente: AuditLog captura cada ação realizada em registros sensíveis para ajudar a atender aos requisitos de conformidade e facilitar a depuração.
•Ferramentas de comunicação eficazes: O suporte a mensagens em threads, anexos opcionais e atualizações em tempo real promove interações eficazes entre pacientes e Provider.

Implante rapidamente um backend seguro para concierge médico e concentre-se em melhorar a entrega de serviços em vez de operações de backend.

Benefícios principais

Um backend de concierge médico que prioriza privacidade, segurança e desenvolvimento rápido.

Entrega de serviço acelerada

Implemente o gerenciamento de pacientes, agendamento de consultas e mensagens mais rápido aproveitando uma estrutura de backend validada.

Rastreamento abrangente de registros

Gerencie com segurança as interações e históricos de consultas dos pacientes para garantir responsabilidade e conformidade.

Permissões baseadas em funções

Controle o acesso a dados sensíveis com ACLs granulares para garantir que apenas usuários autorizados possam visualizar ou modificar informações.

Canais de comunicação integrados

Utilize mensagens em threads e atualizações em tempo real para melhorar o fluxo de interação entre pacientes e Providers.

Registro pronto para conformidade

O AuditLog centralizado promove visibilidade e responsabilidade, facilitando revisões de conformidade e investigações.

Bootstrap assistido por IA

Inicie seu desenvolvimento com um prompt de agente de IA personalizado que estrutura seu esquema, permissões e código de integração.

Pronto para construir um aplicativo de concierge médico seguro?

Permita que o agente de IA Back4app estruture seu backend de concierge médico e gere essenciais, desde perfis de pacientes até gerenciamento de consultas e mensagens seguras.

Construa com o agente de IA Experimente o API Playground

Grátis para começar — 50 prompts de agente de IA/mês, sem necessidade de cartão de crédito

Pilha Técnica

Tudo incluído neste modelo de backend de concierge médico.

Frontend

13+ tecnologias

Backend

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 de entidade para o esquema de backend do Medical Concierge.

common.erDiagramPlaceholder

Ver fonte do diagrama

Mermaid

erDiagram
    PatientProfile ||--o{ LabResult : "has"
    PatientProfile ||--o{ TreatmentPlan : "receives"
    PatientProfile ||--o{ Message : "context for"
    PatientProfile ||--o{ Appointment : "scheduled in"
    _User ||--o{ Message : "sends/receives"
    _User ||--o{ TreatmentPlan : "authors"
    _User ||--o{ Appointment : "provides"

    PatientProfile {
        String objectId PK
        Pointer user FK
        String medicalRecordNumber
        String displayName
        Date dateOfBirth
        String primaryClinic
        Boolean isActive
        Date createdAt
        Date updatedAt
    }

    LabResult {
        String objectId PK
        Pointer patient FK
        Pointer orderedBy FK
        String testCode
        String testName
        String resultValue
        String units
        String referenceRange
        String status
        Date publishedAt
        Array attachments
        Date createdAt
        Date updatedAt
    }

    TreatmentPlan {
        String objectId PK
        Pointer patient FK
        Pointer createdBy FK
        String summary
        String details
        String status
        Date startDate
        Date endDate
        Date createdAt
        Date updatedAt
    }

    Message {
        String objectId PK
        String conversationId
        Pointer from FK
        Pointer to FK
        Pointer patient FK
        String body
        Array attachments
        Boolean isRead
        Date sentAt
        Date createdAt
        Date updatedAt
    }

    Appointment {
        String objectId PK
        Pointer patient FK
        Pointer provider FK
        Date startAt
        Date endAt
        String location
        String status
        String reason
        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 de execução típico para autenticação, gerenciamento de agendamentos, mensagens e notificações.

common.erDiagramPlaceholder

Ver fonte do diagrama

Mermaid

sequenceDiagram
  participant Patient
  participant App as Medical Concierge App
  participant Clinician
  participant Back4app as Back4app Cloud

  Patient->>App: Sign in with email or SSO
  App->>Back4app: POST /login (credentials/SSO token)
  Back4app-->>App: Return Session Token + Patient context

  Patient->>App: Open Dashboard (profile & recent labs)
  App->>Back4app: GET /classes/PatientProfile?where={"user":Pointer("_User", "u123")}
  Back4app-->>App: PatientProfile object
  App->>Back4app: GET /classes/LabResult?where={"patient":Pointer("PatientProfile","p123")}&order=-publishedAt
  Back4app-->>App: List of LabResult (latest first)

  Patient->>App: View active Treatment Plan
  App->>Back4app: GET /classes/TreatmentPlan?where={"patient":Pointer("PatientProfile","p123"),"status":"active"}
  Back4app-->>App: TreatmentPlan object

  Patient->>App: Send secure message to clinician
  App->>Back4app: POST /classes/Message (conversationId, body, to: Pointer(_User, clinicianId))
  Back4app-->>App: Message objectId

  Back4app-->>App: LiveQuery -> new Message or LabResult update
  App-->>Patient: Real-time notification (new message / result available)

  Clinician->>Back4app: Update LabResult (finalize)
  Back4app-->>App: LiveQuery event -> App fetches updated LabResult
  App-->>Patient: Alert: "New lab result available"

Dicionário de Dados

Referência completa em nível de campo para cada classe no esquema do Concierge Médico.

Campo	Tipo	Descrição	Obrigatório
objectId	String	Auto-generated unique identifier	Automático
user	Pointer<_User>	Linked Back4app user account
medicalRecordNumber	String	Unique MRN for the patient
displayName	String	Patient full name shown in UI
dateOfBirth	Date	Patient date of birth	—
primaryClinic	String	Primary clinic or provider group	—
isActive	Boolean	Active portal access flag
createdAt	Date	Auto-generated creation timestamp	Automático
updatedAt	Date	Auto-generated last-update timestamp	Automático

9 campos em PatientProfile

Segurança e Permissões

Como ACL, CLP e estratégias de criptografia protegem registros de pacientes, compromissos, mensagens e logs de auditoria.

Acesso e propriedade baseados em função

Empregue ACLs para que os pacientes só possam acessar seus registros e Provider veja as informações dos pacientes atribuídos; CLPs impedem operações de classe não autorizadas.

Manipulação segura de dados

Armazene informações sensíveis de pacientes com as camadas de segurança e autorização necessárias para garantir a confidencialidade.

Rastreios de auditoria somente de acréscimo

As entradas do AuditLog capturadas através do Cloud Code do lado do servidor impedem os usuários de manipularem registros sensíveis.

Esquema (JSON)

Definição de esquema JSON bruta pronta para copiar para 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

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

{
  "classes": [
    {
      "className": "PatientProfile",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "user": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "medicalRecordNumber": {
          "type": "String",
          "required": true
        },
        "displayName": {
          "type": "String",
          "required": true
        },
        "dateOfBirth": {
          "type": "Date",
          "required": false
        },
        "primaryClinic": {
          "type": "String",
          "required": false
        },
        "isActive": {
          "type": "Boolean",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "LabResult",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "patient": {
          "type": "Pointer",
          "required": true,
          "targetClass": "PatientProfile"
        },
        "orderedBy": {
          "type": "Pointer",
          "required": false,
          "targetClass": "_User"
        },
        "testCode": {
          "type": "String",
          "required": false
        },
        "testName": {
          "type": "String",
          "required": true
        },
        "resultValue": {
          "type": "String",
          "required": false
        },
        "units": {
          "type": "String",
          "required": false
        },
        "referenceRange": {
          "type": "String",
          "required": false
        },
        "status": {
          "type": "String",
          "required": true
        },
        "publishedAt": {
          "type": "Date",
          "required": false
        },
        "attachments": {
          "type": "Array",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "TreatmentPlan",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "patient": {
          "type": "Pointer",
          "required": true,
          "targetClass": "PatientProfile"
        },
        "createdBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "summary": {
          "type": "String",
          "required": true
        },
        "details": {
          "type": "String",
          "required": false
        },
        "status": {
          "type": "String",
          "required": true
        },
        "startDate": {
          "type": "Date",
          "required": false
        },
        "endDate": {
          "type": "Date",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Message",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "conversationId": {
          "type": "String",
          "required": true
        },
        "from": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "to": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "patient": {
          "type": "Pointer",
          "required": true,
          "targetClass": "PatientProfile"
        },
        "body": {
          "type": "String",
          "required": true
        },
        "attachments": {
          "type": "Array",
          "required": false
        },
        "isRead": {
          "type": "Boolean",
          "required": true
        },
        "sentAt": {
          "type": "Date",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Appointment",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "patient": {
          "type": "Pointer",
          "required": true,
          "targetClass": "PatientProfile"
        },
        "provider": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "startAt": {
          "type": "Date",
          "required": true
        },
        "endAt": {
          "type": "Date",
          "required": true
        },
        "location": {
          "type": "String",
          "required": false
        },
        "status": {
          "type": "String",
          "required": true
        },
        "reason": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "AuditLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "actor": {
          "type": "Pointer",
          "required": true,
          "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 Agente de IA

Use o Agente de IA Back4app para gerar um aplicativo Médico Concierge a partir deste template, incluindo esquema de backend, ACLs e integração de frontend inicial.

Agente de IA Back4app

Pronto para construir

Crie um backend de Concierge Médico no Back4app com este esquema e comportamento exatos.

Esquema:
1. PatientProfile: user (Ponteiro para Usuário, obrigatório), fullName (String, obrigatório), contact (Objeto), medicalRecordNumber (String, obrigatório, único); objectId, createdAt, updatedAt.
2. ProviderProfile: user (Ponteiro para Usuário, obrigatório), specialty (String), clinic (String), contact (Objeto); objectId, createdAt, updatedAt.
3. Appointment: patient (Ponteiro para PatientProfile, obrigatório), Provider (Ponteiro para ProviderProfile, obrigatório), scheduledAt (Data, obrigatório), status (String: agendado, cancelado, concluído), location (String); objectId, createdAt, updatedAt.
4. Message: sender (Ponteiro para Usuário, obrigatório), recipient (Ponteiro para Usuário, obrigatório), threadId (String, obrigatório), body (String), attachments (Array de Arquivo), status (String: enviado, entregue, lido), sentAt (Data); objectId, createdAt, updatedAt.
5. AuditLog: actor (Ponteiro para Usuário, obrigatório), action (String, obrigatório), entityType (String, obrigatório), entityId (String, obrigatório), payload (Objeto, opcional), createdAt (Data); objectId, createdAt, updatedAt.

Segurança:
- Aplicar ACLs para que os pacientes possam apenas ler seus registros de Consulta e Mensagem. Providers veem os dados do paciente designado. Use Cloud Code para transições sensíveis e para escrever entradas de AuditLog no lado do servidor.

Autenticação:
- Suporte a cadastro para pacientes e Providers; atribuição de papéis; login seguro e gerenciamento de sessão.

Comportamento:
- O paciente faz login, agenda consultas, envia mensagens aos Providers e recebe notificações. Providers gerenciam consultas e respondem às mensagens dos pacientes; o sistema escreve entradas de AuditLog para ações.

Entrega:
- App Back4app com esquema, CLPs, ACLs, ganchos de Cloud Code para ações e integração frontend inicial para visualizações de paciente e Provider.

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

Este é o prompt base sem um sufixo de tecnologia. Você pode adaptar a pilha de frontend gerada após isso.

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

API Playground

Experimente os endpoints REST e GraphQL contra o esquema de Concierge Médico. As respostas usam dados fictícios e não requerem uma conta Back4app.

common.loadingPlayground

Usa o mesmo esquema que este modelo.

Escolha sua Tecnologia

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

O que você ganha com cada tecnologia

Cada stack usa o mesmo esquema de backend e contratos de API da Medical Concierge.

Sistema de gestão de pacientes

Gerencie eficientemente os registros e agendamentos de pacientes para concierge médico.

Plataforma de mensagens segura

Facilite a comunicação segura entre pacientes e Providers em concierge médico.

Agendamento de consultas em tempo real

Otimize a reserva e as notificações para serviços de concierge médico.

Capacidades de registro de auditoria

Mantenha registros detalhados para conformidade e rastreamento em concierge médico.

Estrutura de dados unificada para pacientes

Integre diversos pontos de dados para insights abrangentes de concierge médico.

REST/GraphQL APIs

Acesse APIs poderosas para conectar seu frontend para aplicações concierge médico.

Comparação do Framework de Concierge Médico

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

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

A duração da configuração denota a expectativa desde o início do projeto até a primeira consulta do paciente e a recuperação de mensagens usando este esquema de modelo.

Perguntas Frequentes

Perguntas comuns sobre a construção de um backend de Concierge Médico com este modelo.

O que é um backend de Concierge Médico?

O que o modelo de Concierge Médico inclui?

Por que usar Back4app para um aplicativo de concierge médico?

Como posso buscar a última consulta e sua Provider em uma única solicitação?

Como posso marcar uma mensagem como entregue?

Posso gerenciar dados de compromissos para acesso offline no React Native?

Como faço para proteger PDFs de pacientes para compromissos?

Qual é a melhor maneira de exibir interações de compromissos em dispositivos móveis?

Como funciona o processo de registro de auditoria de ponta a ponta?

Como apoio o reconhecimento do paciente sobre um compromisso?

Confiado por desenvolvedores em todo o mundo

Junte-se a equipes que entregam soluções de concierge médico mais rápido com modelos Back4app

Pronto para Construir Seu Aplicativo de Concierge Médico?

Inicie seu projeto de concierge médico em poucos minutos. Não é necessário cartão de crédito.

Escolha a Tecnologia

Modelo de Backend do Aplicativo de Concierge MédicoOfereça experiências personalizadas para pacientes, gerencie compromissos e coordene cuidados de forma segura