Aplicativo CRM
Construir com Agente de IA
Modelo Flutter

Modelo de Backend para App de CRM
Flutter — Guia de Schema, API e IA

Um schema de backend de Flutter CRM pronto para produção e Starter Kit na Back4app: Contato, Empresa, Negócio, Atividade, estágios do pipeline, diagrama ER, dicionário de dados, schema JSON, playground de API e um prompt de Agente de IA com um clique para implantar em minutos.

Construir com Agente de IA

Principais Conclusões

Nesta página você obtém um schema de CRM pronto para produção, um prompt de IA com um clique e código Flutter passo a passo — para que você possa lançar um app de CRM sem construir o backend.

  1. Implante em minutos — Cole o prompt do Agente de IA e obtenha um aplicativo em funcionamento com contatos, empresas, negócios e pipeline.
  2. Seguro por padrão — ACLs e acesso baseado em funções para que os usuários vejam apenas seus negócios e dados atribuídos.
  3. Flutter-nativo SDK — Objetos tipados, async/await, fixação offline e Live Queries para atualizações de pipeline.
  4. REST + GraphQL — Ambas as APIs geradas automaticamente; filtre negócios por estágio, liste atividades por relacionado a.
  5. Cinco classes — _Usuário (embutido), Empresa, Contato, Negócio (pipeline), Atividade (tarefas/eventos).

O que é o modelo de backend do aplicativo CRM Flutter?

O modelo de backend do aplicativo CRM Flutter é um esquema Back4app pronto para produção (Contact, Company, Deal, Activity) com um SDK Dart tipado, fixação offline e Live Queries. Crie uma única base de código para iOS e Android: consulte negócios por estágio, gerencie contatos e empresas, e sincronize dados do pipeline em tempo real. Sem backend personalizado ou cola REST — o SDK Back4app Flutter cuida da autenticação, CRUD e armazenamento local para que você se concentre na interface do usuário e na lógica de negócios.

Melhor para:

Equipes de vendasConstrutores de CRMPrototipagem rápidaRepresentantes de campoLançamentos de MVPEquipes escolhendo um BaaS para CRM

Visão geral

Os aplicativos de CRM Flutter precisam de contatos, negócios, estágios do pipeline e sincronização offline opcional. O esquema do Back4app (Empresa, Contato, Negócio, Atividade) se encaixa no SDK Flutter: QueryBuilder para filtragem por estágio, fixação para armazenamento local e Live Queries para atualizações em tempo real do pipeline.

As cinco classes abaixo — _User, Company, Contact, Deal, Activity — são expostas via o SDK Back4app Flutter. Use tipos Dart e async/await para buscar negócios por estágio, criar contatos e negócios, e registrar atividades. Sem REST ou conexão GraphQL em seu aplicativo; o SDK lida com serialização e sincronização.

Recursos principais do CRM

Com Flutter e o SDK Parse você obtém gerenciamento de contatos, pipeline de negócios e rastreamento de atividades — além de fixação offline e Live Queries para um backend de CRM completo.

Gerenciamento de contatos

Armazene e gerencie contatos com nome, e-mail, telefone, empresa e notas. Ideal para aplicativos Flutter.

Gestão de empresas

Rastreie empresas com nome, site, setor e endereço. Links para contatos e negócios.

Pipeline de negócios

Pipeline de vendas com etapas, valor, data de fechamento esperada e atribuição. Construído para backends Flutter.

Rastreamento de atividades

Registre chamadas, e-mails, reuniões e notas vinculadas a contatos e negócios. Funciona com o SDK Flutter.

Usuário e permissões

Modelo de usuário embutido e referências para propriedade e atribuição. ACLs prontas para uso para Flutter.

Por que construir seu backend de CRM Flutter com Back4app?

Back4app oferece um backend pronto e um SDK tipado para que você possa construir seu aplicativo de CRM com pipeline, contatos e negócios sem escrever código REST ou gerenciar autenticação você mesmo.

  • •SDK tipado e serialização: Os objetos tipados do SDK mantêm Contato, Empresa, Negócio e Atividade seguros em tipos; o SDK lida com JSON para que você escreva menos código repetitivo.
  • •Async-first e offline: O SDK Back4app Flutter usa async/await e pinning; o pipeline e os contatos funcionam offline e sincronizam quando voltam online.
  • •Sincronização Live Queries / Reactive: Inscreva-se para mudanças em Negócios e Atividades para que o pipeline e o painel sejam atualizados em tempo real.

Mesma estrutura e APIs para cada stack—troque de clientes depois sem mudar o backend.

Benefícios Principais

Um backend CRM pronto para produção para que você possa enviar mais rápido e focar no seu aplicativo.

Envie Mais Rápido, Sem Código de Backend

APIs REST & GraphQL e um esquema pronto para uso — conecte seu aplicativo e vá.

Seguro por Padrão

ACLs e permissões em nível de classe; restrição por assignedTo e createdBy.

Pipeline em Tempo Real

Live Queries sobre WebSockets para atualizações instantâneas de negócios e atividades.

Autenticação Integrada

Cadastro de usuário, login e gerenciamento de sessão prontos para uso.

Funciona Offline

O pinning local mantém contatos e negócios disponíveis offline e sincroniza quando você se reconecta.

Implante em Minutos

Use o Agente de IA para criar e implantar seu aplicativo CRM a partir deste modelo.

Pronto para experimentar?

Deixe o agente de IA da Back4app criar o backend do seu aplicativo CRM, conectar o frontend Flutter e implantar — tudo a partir de um único comando.

Construir com Agente de IAExperimente o API Playground

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

Pilha Técnica

Tudo que alimenta este modelo de aplicativo CRM em um relance.

Frontend
Flutter
Backend
Back4app
Banco de Dados
MongoDB
Autenticação
Autenticação e Controle de Acesso
APIs
REST e GraphQL
Implantação
Agente de IA / Painel

Diagrama ER

Diagrama de Entidade-Relacionamento para o modelo de dados do aplicativo Flutter CRM.

Ver fonte do diagrama
Mermaid
erDiagram
    _User {
        String objectId PK
        String username
        String email
        String password
        Date createdAt
        Date updatedAt
    }

    Company {
        String objectId PK
        String name
        String website
        String industry
        String address
        String notes
        Pointer createdBy FK
        Date createdAt
        Date updatedAt
    }

    Contact {
        String objectId PK
        String name
        String email
        String phone
        Pointer company FK
        String notes
        Pointer createdBy FK
        Date createdAt
        Date updatedAt
    }

    Deal {
        String objectId PK
        String title
        Number amount
        String stage
        Pointer contact FK
        Pointer company FK
        Date expectedCloseDate
        String notes
        Pointer assignedTo FK
        Date createdAt
        Date updatedAt
    }

    Activity {
        String objectId PK
        String type
        String subject
        String description
        Date dueDate
        Date completedAt
        Pointer relatedTo FK
        Pointer createdBy FK
        Date createdAt
        Date updatedAt
    }

    Company ||--o{ Contact : "has"
    Company ||--o{ Deal : "has"
    Contact ||--o{ Deal : "has"
    _User ||--o{ Deal : "assignedTo"
    _User ||--o{ Activity : "createdBy"
    Contact ||--o{ Activity : "relatedTo"
    Deal ||--o{ Activity : "relatedTo"
    _User ||--o{ Company : "createdBy"
    _User ||--o{ Contact : "createdBy"

Fluxo de Integração

Sequência Auth-to-CRUD: como seu aplicativo Flutter se comunica com Back4app — login, depois consulta contatos e negócios, atualiza o pipeline.

Ver fonte do diagrama
Mermaid
sequenceDiagram
  participant User
  participant App as Flutter App
  participant Back4app as Back4app Cloud

  User->>App: Login
  App->>Back4app: Parse().login(username, password)
  Back4app-->>App: Session token
  App-->>User: Logged in

  User->>App: Load contacts and deals
  App->>Back4app: Query<Deal>().find() or Query<Contact>().find()
  Back4app-->>App: List<Deal> / List<Contact>
  App-->>User: Show pipeline

  User->>App: Create deal or contact
  App->>Back4app: deal.save() or contact.save()
  Back4app-->>App: Deal (objectId)
  App-->>User: Updated list

Dicionário de Dados

Referência completa de campos para cada classe no esquema.

CampoTipoDescriçãoObrigatório
objectIdStringAuto-generated unique identifierautomático
nameStringFull name of the contact
emailStringEmail address—
phoneStringPhone number—
companyPointer<Company>Company this contact belongs to—
notesStringFree-form notes—
createdByPointer<_User>User who created this contact—
createdAtDateAuto-generated creation timestampautomático
updatedAtDateAuto-generated last-update timestampautomático

9 campos em Contact

Segurança e Permissões

Como a propriedade, ACLs e permissões em nível de classe protegem os dados neste esquema de CRM.

ACLs em Nível de Linha

Use ACLs e ponteiros (assignedTo, createdBy) para que os usuários vejam e editem apenas seus negócios atribuídos e dados relacionados.

Permissões em Nível de Classe

CLPs restringem quais funções ou usuários podem criar, ler, atualizar ou excluir objetos em nível de classe.

Propriedade Baseada em Ponteiro

Deal.assignedTo e Activity.createdBy vinculam-se a _User; o Cloud Code pode impor visibilidade e edições por função.

Esquema (JSON)

Definição de esquema JSON bruto — copie e use em seu aplicativo Back4app ou importe via API.

JSON
{
  "classes": [
    {
      "className": "Contact",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "name": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": false
        },
        "phone": {
          "type": "String",
          "required": false
        },
        "company": {
          "type": "Pointer",
          "targetClass": "Company",
          "required": false
        },
        "notes": {
          "type": "String",
          "required": false
        },
        "createdBy": {
          "type": "Pointer",
          "targetClass": "_User",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Company",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "name": {
          "type": "String",
          "required": true
        },
        "website": {
          "type": "String",
          "required": false
        },
        "industry": {
          "type": "String",
          "required": false
        },
        "address": {
          "type": "String",
          "required": false
        },
        "notes": {
          "type": "String",
          "required": false
        },
        "createdBy": {
          "type": "Pointer",
          "targetClass": "_User",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Deal",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "amount": {
          "type": "Number",
          "required": false
        },
        "stage": {
          "type": "String",
          "required": false
        },
        "contact": {
          "type": "Pointer",
          "targetClass": "Contact",
          "required": false
        },
        "company": {
          "type": "Pointer",
          "targetClass": "Company",
          "required": false
        },
        "expectedCloseDate": {
          "type": "Date",
          "required": false
        },
        "notes": {
          "type": "String",
          "required": false
        },
        "assignedTo": {
          "type": "Pointer",
          "targetClass": "_User",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Activity",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "type": {
          "type": "String",
          "required": false
        },
        "subject": {
          "type": "String",
          "required": false
        },
        "description": {
          "type": "String",
          "required": false
        },
        "dueDate": {
          "type": "Date",
          "required": false
        },
        "completedAt": {
          "type": "Date",
          "required": false
        },
        "relatedTo": {
          "type": "Pointer",
          "required": false
        },
        "createdBy": {
          "type": "Pointer",
          "targetClass": "_User",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "_User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Construa com o Agente de IA

Use o Agente de IA Back4app para construir um aplicativo CRM real a partir deste modelo: ele criará o frontend, o backend (este esquema, autenticação e APIs) e fará a implantação — sem configuração manual. O prompt abaixo descreve esta pilha de CRM para que o Agente possa gerar um aplicativo pronto para produção de uma só vez.

Agente de IA Back4app
Pronto para construir
Crie um aplicativo CRM no Back4app com este esquema e comportamento exatos.

Esquema:
1. _Usuário (use Back4app embutido): nome de usuário (String, obrigatório), email (String, obrigatório), senha (String, obrigatório); objectId, createdAt, updatedAt (sistema).
2. Empresa: nome (String, obrigatório), site (String), setor (String), endereço (String), notas (String), criadoPor (Ponteiro para _Usuário); objectId, createdAt, updatedAt (sistema).
3. Contato: nome (String, obrigatório), email (String), telefone (String), empresa (Ponteiro para Empresa), notas (String), criadoPor (Ponteiro para _Usuário); objectId, createdAt, updatedAt (sistema).
4. Negócio: título (String, obrigatório), valor (Número), estágio (String; por exemplo, lead, qualificado, proposta, negociação, ganho, perdido), contato (Ponteiro para Contato), empresa (Ponteiro para Empresa), dataFechamentoEsperada (Data), notas (String), atribuídoA (Ponteiro para _Usuário); objectId, createdAt, updatedAt (sistema).
5. Atividade: tipo (String; por exemplo, chamada, email, reunião, nota), assunto (String), descrição (String), dataVencimento (Data), concluídoEm (Data), relacionadoA (Ponteiro para Contato ou Negócio), criadoPor (Ponteiro para _Usuário); objectId, createdAt, updatedAt (sistema).

Segurança:
- Defina ACLs para que apenas usuários autenticados possam acessar os dados; use regras baseadas em função ou baseadas em proprietário onde apropriado (por exemplo, atribuídoA, criadoPor).
- Use Permissões em Nível de Classe para que apenas usuários autenticados possam criar/ler/atualizar/excluir essas classes.

Autenticação:
- Cadastro (nome de usuário, email, senha) e login; suporte para logout/sessão.

Comportamento:
- CRUD completo para Empresa, Contato, Negócio e Atividade.
- Liste negócios com filtro por estágio e ordene por dataFechamentoEsperada ou updatedAt (visualização de pipeline).
- Liste atividades por relacionadoA (Contato ou Negócio).
- Opcional: Live Queries em tempo real para Negócio e Atividade para atualizações de painel/pipeline.
- Opcional: fixação offline para mobile (Contatos, Negócios, Atividades).

Entregar:
- Crie o aplicativo Back4app com o esquema acima, ACLs e qualquer Cloud Code necessário.
- Gere o frontend e conecte-o a este backend; implante para que o aplicativo seja executável de ponta a ponta.

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

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

API Playground

Experimente os endpoints REST e GraphQL para o esquema CRM. Respostas dos dados de exemplo acima — nenhuma conta Back4app necessária.

Carregando playground…

Usa o mesmo esquema CRM (Contato, Empresa, Negócio, Atividade) que este modelo.

Integração Flutter Passo a Passo

Conecte-se ao seu backend Back4app a partir de um app Flutter usando o SDK Back4app Flutter.

  1. Passo 1: Instale o SDK Back4app Flutter

    Adicione o SDK Back4app para sua stack (por exemplo, npm, pubspec ou gerenciador de pacotes).

    YAML
    dependencies:
  flutter:
    sdk: flutter
  parse_server_sdk_flutter: ^7.0.0

  2. Passo 2: Inicialize o Back4app em seu app

    Inicialize o SDK do Back4app na inicialização do aplicativo com seu ID de aplicativo e URL do servidor.

    Dart
    import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await Parse().initialize(
    'YOUR_APP_ID',
    'https://parseapi.back4app.com',
    clientKey: 'YOUR_CLIENT_KEY',
    autoSendSessionId: true,
  );

  runApp(const MyApp());
}

  3. Etapa 3: Consultar contatos e negócios

    Use o SDK para buscar objetos de Contato e Negócio; filtre negócios por estágio para o pipeline.

    Dart
    Future<List<ParseObject>> getDeals({String stage = 'qualified'}) async {
  final query = QueryBuilder<ParseObject>(ParseObject('Deal'))
    ..whereEqualTo('stage', stage)
    ..orderByAscending('expectedCloseDate');

  final response = await query.query();
  if (response.success && response.results != null) {
    return response.results as List<ParseObject>;
  }
  return [];
}
Future<List<ParseObject>> getContacts() async {
  final query = QueryBuilder<ParseObject>(ParseObject('Contact'));
  final response = await query.query();
  if (response.success && response.results != null) {
    return response.results as List<ParseObject>;
  }
  return [];
}

  4. Etapa 4: Criar um contato ou negócio

    Crie um novo Contato ou Negócio com os campos e apontadores necessários (empresa, contato, atribuído a), e então salve.

    Dart
    Future<void> createDeal(String title, {String stage = 'lead', double? amount}) async {
  final deal = ParseObject('Deal')
    ..set('title', title)
    ..set('stage', stage);
  if (amount != null) deal.set('amount', amount);
  await deal.save();
}
Future<void> createContact(String name, {String? email, String? phone}) async {
  final contact = ParseObject('Contact')..set('name', name);
  if (email != null) contact.set('email', email);
  if (phone != null) contact.set('phone', phone);
  await contact.save();
}

  5. Etapa 5: Atualizar estágio do negócio e atividades

    Atualize Deal.stage ao mover no pipeline; crie e liste Atividades por relacionado a.

    Dart
    // Update deal stage (e.g. move in pipeline)
Future<void> updateDealStage(String objectId, String stage) async {
  final deal = ParseObject('Deal')..objectId = objectId;
  deal.set('stage', stage);
  await deal.save();
}

// Delete a deal
Future<void> deleteDeal(String objectId) async {
  final deal = ParseObject('Deal')..objectId = objectId;
  await deal.delete();
}

Integração de Gerenciamento de Estado

Integre o SDK Back4app com a camada de estado do seu aplicativo (por exemplo, contexto, loja ou serviços) para estado de pipeline e contato.

Modelo de Dados Completo

Copie um modelo completo de CRM para serialização segura por tipo (por exemplo, classe, interface ou definição de tipo).

Dart
class Deal {
  final String? objectId;
  final String title;
  final double? amount;
  final String? stage;
  final DateTime? expectedCloseDate;
  final String? contactId;
  final String? companyId;
  final String? assignedToId;
  final DateTime? createdAt;
  final DateTime? updatedAt;

  Deal({
    this.objectId,
    required this.title,
    this.amount,
    this.stage = 'lead',
    this.expectedCloseDate,
    this.contactId,
    this.companyId,
    this.assignedToId,
    this.createdAt,
    this.updatedAt,
  });

  factory Deal.fromJson(Map<String, dynamic> json) {
    return Deal(
      objectId: json['objectId'] as String?,
      title: json['title'] as String,
      amount: (json['amount'] as num?)?.toDouble(),
      stage: json['stage'] as String? ?? 'lead',
      expectedCloseDate: json['expectedCloseDate'] != null ? DateTime.parse(json['expectedCloseDate']) : null,
      contactId: json['contact'] is Map ? (json['contact'] as Map)['objectId'] as String? : null,
      companyId: json['company'] is Map ? (json['company'] as Map)['objectId'] as String? : null,
      assignedToId: json['assignedTo'] is Map ? (json['assignedTo'] as Map)['objectId'] as String? : null,
      createdAt: json['createdAt'] != null ? DateTime.parse(json['createdAt']) : null,
      updatedAt: json['updatedAt'] != null ? DateTime.parse(json['updatedAt']) : null,
    );
  }
}

Offline-First & Armazenamento Local

Use pin() e unpin() para que contatos e negócios estejam disponíveis offline e sincronizem quando voltarem online.

SDKs suportados incluem um armazenamento local. Fixe objetos de Contato, Negócio e Atividade para mantê-los no dispositivo; consulte dados fixados quando estiver offline. Quando o aplicativo voltar online, sincronize com o servidor.

Abaixo: fixe resultados após a busca e desfaça a fixação quando não precisar mais de cópias locais.

Dart
// Pin deals after fetch (offline-first)
Future<void> fetchAndPinDeals() async {
  final query = QueryBuilder<ParseObject>(ParseObject('Deal'))
    ..whereEqualTo('stage', 'qualified')
    ..orderByDescending('expectedCloseDate');
  final response = await query.query();
  if (response.success && response.results != null) {
    final results = response.results!.cast<ParseObject>();
    await ParseObject.pinAllObjects(results);
    // Now query from local store when offline:
    // QueryBuilder<ParseObject>(ParseObject('Deal')).fromLocalDatastore();
  }
}

// Unpin when no longer needed
Future<void> unpinAllDeals() async {
  await ParseObject.unpinAll('Deal');
}

Perguntas Frequentes

Perguntas comuns sobre o modelo de backend do aplicativo CRM.

O que é Back4app?
Por que usar Back4app para um aplicativo de CRM Flutter?
Como faço para consultar negócios por estágio em Flutter?
O SDK Flutter suporta dados de CRM offline?

Confiado por desenvolvedores em todo o mundo

Junte-se à comunidade que está construindo o futuro dos aplicativos

G2 Users Love Us Badge

Pronto para Construir Seu App de CRM?

Comece seu projeto Flutter em minutos. Nenhum cartão de crédito necessário.

Construa com Agente de IA