Aplicación CRM
Construido con Agente de IA
Plantilla React Native

Plantilla de Backend para la App CRM
React Native — Guía de Esquema, API y AI

Un esquema de backend de React Native CRM listo para producción y un Kit de Inicio en Back4app: Contacto, Empresa, Negocio, Actividad, etapas del pipeline, diagrama ER, diccionario de datos, esquema JSON, playground de API, y un prompt de Agente de AI con un clic para desplegar en minutos.

Construido con Agente de IA

Puntos Clave

En esta página obtienes un esquema de CRM listo para producción, un prompt de AI con un clic, y código React Native paso a paso — para que puedas lanzar una app CRM sin construir el backend.

  1. Despliega en minutos — Pega el aviso del Agente de IA y obtén una aplicación en funcionamiento con contactos, empresas, ofertas y pipeline.
  2. Seguro por defecto — ACLs y acceso basado en roles para que los usuarios vean solo sus ofertas y datos asignados.
  3. React Native-SDK nativo — Objetos tipados, async/await, fijación offline y Live Queries para actualizaciones de pipeline.
  4. REST + GraphQL — Ambas APIs generadas automáticamente; filtra ofertas por etapa, lista actividades por relacionado con.
  5. Cinco clases — _Usuario (incorporado), Empresa, Contacto, Oferta (pipeline), Actividad (tareas/eventos).

¿Qué es la plantilla de backend nativa de la aplicación CRM de React?

Esta plantilla proporciona a las aplicaciones nativas de React un backend CRM listo en Back4app con soporte offline-first. Fija objetos de Contacto, Oferta y Actividad localmente para que los representantes de campo puedan trabajar sin conectividad; sincroniza cuando vuelvas a estar en línea. Un backend para iOS y Android, con Live Queries para actualizaciones del canal de ventas. Perfecto para aplicaciones de ventas y de servicio de campo que necesitan acceso offline confiable.

Mejor para:

Equipos de ventasCreadores de CRMPrototipado rápidoRepresentantes de campoLanzamientos de MVPEquipos eligiendo un BaaS para CRM

Descripción general

Las aplicaciones CRM nativas de React a menudo funcionan en el campo con conectividad intermitente. Esta plantilla combina el esquema CRM de Back4app con el SDK nativo Parse React: pin objetos de Contacto y Oferta localmente, consulta cuando estés offline y sincroniza cuando vuelvas a estar en línea. Live Queries mantiene el pipeline sincronizado entre dispositivos.

Las cinco clases (_User, Company, Contact, Deal, Activity) son las mismas en el servidor; el SDK maneja la sincronización y la resolución de conflictos. Usa un backend para iOS y Android y enfoca tu código en pantallas y navegación.

Características principales del CRM

React CRM nativo con gestión de contactos, pipeline de negocios y fijación offline primero. ACLs integrados y Live Queries para que los representantes de campo vean solo sus negocios y contactos.

Gestión de contactos

Almacena y gestiona contactos con nombre, correo electrónico, teléfono, empresa y notas. Ideal para aplicaciones React Native.

Gestión de empresas

Rastrea empresas con nombre, sitio web, industria y dirección. Enlaces a contactos y ofertas.

Tubería de ofertas

Tubería de ventas con etapas, monto, fecha de cierre esperada y asignación. Construido para backends de React Native.

Seguimiento de actividades

Registra llamadas, correos electrónicos, reuniones y notas vinculadas a contactos y negocios. Funciona con el SDK de React Native.

Usuario y permisos

Modelo de usuario integrado y punteros para propiedad y asignación. ACLs listos para usar para React Native.

¿Por qué construir tu backend nativo de React CRM con Back4app?

Back4app te proporciona un backend listo y el SDK nativo Parse React para que puedas centrarte en la experiencia de usuario del pipeline y en el modo fuera de línea para representantes de campo.

  • •Primero fuera de línea y sincronización: Fija objetos de Contacto, Negocio y Actividad para que la aplicación funcione sin conexión y se sincronice al volver a estar en línea—ideal para CRM móvil.
  • •Componentes y ganchos: Usa el SDK con React ganchos; mantiene el estado del pipeline y del contacto sincronizado con Parse consultas y Live Queries.
  • •Multiplataforma, un backend: El mismo esquema y APIs para iOS y Android; un backend para ambas plataformas.

Ideal para equipos de React Native que construyen aplicaciones de CRM o ventas con Expo o flujo de trabajo bare.

Beneficios principales

Un backend CRM listo para producción para que puedas enviar más rápido y concentrarte en tu aplicación.

Envía más rápido, sin código de backend

APIs REST y GraphQL y un esquema listo para usar — conecta tu aplicación y listo.

Seguro por defecto

ACLs y permisos a nivel de clase; restringir por assignedTo y createdBy.

Pipeline en Tiempo Real

Live Queries sobre WebSockets para actualizaciones instantáneas de ofertas y actividades.

Autenticación Integrada

Registro de usuario, inicio de sesión y manejo de sesiones listos para usar.

Funciona Sin Conexión

El anclaje local mantiene contactos y ofertas disponibles sin conexión y se sincroniza cuando te reconectas.

Despliega en Minutos

Usa el Agente de IA para crear y desplegar tu aplicación CRM a partir de esta plantilla.

¿Listo para probarlo?

Deja que el agente de IA de Back4app cree el backend de tu aplicación CRM, conecte el frontend React Native y despliegue — todo desde un solo aviso.

Construir con el agente de IAPrueba el API Playground

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

Pila técnica

Todo lo que impulsa esta plantilla de aplicación CRM de un vistazo.

Frontend
React Native
Backend
Back4app
Base de datos
MongoDB
Autenticación
Autenticación y Control de Acceso
APIs
REST y GraphQL
Despliegue
Agente de IA / Panel de control

Diagrama ER

Diagrama de entidad-relación para el modelo de datos de la aplicación CRM React Native.

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

Flujo de integración

Secuencia de Auth-to-CRUD: cómo tu aplicación React Native se comunica con Back4app — iniciar sesión, luego consultar contactos y negocios, actualizar el pipeline.

Ver fuente del diagrama
Mermaid
sequenceDiagram
  participant User
  participant App as React Native App
  participant Back4app as Back4app Cloud

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

  User->>App: Load contacts and deals
  App->>Back4app: new Parse.Query('Deal').find() or Parse.Query('Contact').find()
  Back4app-->>App: Array of Deal / 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

Diccionario de datos

Referencia completa de campos para cada clase en el esquema.

CampoTipoDescripciónRequerido
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 en Contact

Seguridad y permisos

Cómo la propiedad, ACLs y permisos a nivel de clase protegen los datos en este esquema de CRM.

ACLs a Nivel de Fila

Usa ACLs y punteros (assignedTo, createdBy) para que los usuarios solo vean y editen sus tratos asignados y datos relacionados.

Permisos a Nivel de Clase

Los CLPs restringen qué roles o usuarios pueden crear, leer, actualizar o eliminar objetos a nivel de clase.

Propiedad Basada en Punteros

Deal.assignedTo y Activity.createdBy se vinculan a _User; Cloud Code puede hacer cumplir la visibilidad y las ediciones por rol.

Esquema (JSON)

Definición de esquema JSON en bruto — copia y usa en tu aplicación Back4app o importa a través de la 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
        }
      }
    }
  ]
}

Construir con el Agente de IA

Utiliza el Agente de IA de Back4app para construir una aplicación CRM real a partir de esta plantilla: creará el frontend, el backend (este esquema, autenticación y APIs) y lo desplegará — sin configuración manual. El aviso a continuación describe esta pila CRM para que el Agente pueda generar una aplicación lista para producción de una sola vez.

Agente de IA Back4app
Listo para construir
Crea una aplicación CRM en Back4app con este esquema y comportamiento exactos.

Esquema:
1. _Usuario (usar Back4app incorporado): nombre de usuario (String, requerido), correo electrónico (String, requerido), contraseña (String, requerido); objectId, createdAt, updatedAt (sistema).
2. Empresa: nombre (String, requerido), sitio web (String), industria (String), dirección (String), notas (String), creadoPor (Puntero a _Usuario); objectId, createdAt, updatedAt (sistema).
3. Contacto: nombre (String, requerido), correo electrónico (String), teléfono (String), empresa (Puntero a Empresa), notas (String), creadoPor (Puntero a _Usuario); objectId, createdAt, updatedAt (sistema).
4. Negocio: título (String, requerido), monto (Número), etapa (String; por ejemplo, cliente potencial, calificado, propuesta, negociación, ganado, perdido), contacto (Puntero a Contacto), empresa (Puntero a Empresa), fechaEsperadaCierre (Fecha), notas (String), asignadoA (Puntero a _Usuario); objectId, createdAt, updatedAt (sistema).
5. Actividad: tipo (String; por ejemplo, llamada, correo electrónico, reunión, nota), asunto (String), descripción (String), fechaVencimiento (Fecha), completadoEn (Fecha), relacionadoCon (Puntero a Contacto o Negocio), creadoPor (Puntero a _Usuario); objectId, createdAt, updatedAt (sistema).

Seguridad:
- Establecer ACLs para que solo los usuarios autenticados puedan acceder a los datos; usar reglas basadas en roles o basadas en propietarios donde sea apropiado (por ejemplo, asignadoA, creadoPor).
- Usar Permisos a Nivel de Clase para que solo los usuarios autenticados puedan crear/leer/actualizar/eliminar estas clases.

Autenticación:
- Registro (nombre de usuario, correo electrónico, contraseña) e inicio de sesión; soporte para cerrar sesión/sesión.

Comportamiento:
- CRUD completo para Empresa, Contacto, Negocio y Actividad.
- Listar negocios con filtro por etapa y ordenar por fechaEsperadaCierre o updatedAt (vista de pipeline).
- Listar actividades por relacionadoCon (Contacto o Negocio).
- Opcional: Live Queries en tiempo real para Negocio y Actividad para actualizaciones de panel/pipeline.
- Opcional: fijación fuera de línea para móvil (Contactos, Negocios, Actividades).

Entregar:
- Crear la aplicación Back4app con el esquema anterior, ACLs y cualquier Código en la Nube necesario.
- Generar el frontend y conectarlo a este backend; desplegar para que la aplicación sea ejecutable de extremo a extremo.

Presiona el botón a continuación para abrir el Agente con el aviso de esta plantilla prellenado.

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

API Playground

Prueba los endpoints REST y GraphQL para el esquema CRM. Respuestas de los datos de ejemplo anteriores — no se necesita cuenta de Back4app.

Cargando espacio de trabajo…

Utiliza el mismo esquema CRM (Contacto, Empresa, Negocio, Actividad) que esta plantilla.

Integración paso a paso React Native

Conéctate a tu backend de Back4app desde una app React Native utilizando el SDK Back4app React Native.

  1. Paso 1: Instalar el SDK Back4app React Native

    Agrega el SDK Back4app para tu stack (por ejemplo, npm, pubspec o gestor de paquetes).

    JavaScript
    npm install parse --save
# or: yarn add parse

  2. Paso 2: Inicializa Back4app en tu app

    Inicializa el SDK de Back4app al iniciar la aplicación con tu ID de aplicación y URL del servidor.

    JavaScript
    import Parse from 'parse/react-native';

Parse.setAsyncStorage(AsyncStorage);
Parse.initialize('YOUR_APP_ID', 'YOUR_JS_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

  3. Paso 3: Consultar contactos y ofertas

    Utiliza el SDK para obtener objetos de Contacto y Oferta; filtra las ofertas por etapa para el pipeline.

    JavaScript
    async function getDeals(stage = 'qualified') {
  const query = new Parse.Query('Deal');
  query.equalTo('stage', stage);
  query.ascending('expectedCloseDate');
  return await query.find();
}
async function getContacts() {
  const query = new Parse.Query('Contact');
  return await query.find();
}

  4. Paso 4: Crear un contacto u oferta

    Crea un nuevo Contacto u Oferta con los campos y punteros requeridos (empresa, contacto, asignadoA), luego guarda.

    JavaScript
    async function createDeal(title, stage = 'lead', amount) {
  const Deal = Parse.Object.extend('Deal');
  const deal = new Deal();
  deal.set('title', title);
  deal.set('stage', stage);
  if (amount != null) deal.set('amount', amount);
  await deal.save();
  return deal;
}
async function createContact(name, email, phone) {
  const Contact = Parse.Object.extend('Contact');
  const contact = new Contact();
  contact.set('name', name);
  if (email) contact.set('email', email);
  if (phone) contact.set('phone', phone);
  await contact.save();
  return contact;
}

  5. Paso 5: Actualizar la etapa de la oferta y actividades

    Actualiza Deal.stage al mover en el pipeline; crea y lista Actividad por relacionadoCon.

    JavaScript
    async function updateDealStage(objectId, stage) {
  const query = new Parse.Query('Deal');
  const deal = await query.get(objectId);
  deal.set('stage', stage);
  await deal.save();
}

async function deleteDeal(objectId) {
  const query = new Parse.Query('Deal');
  const deal = await query.get(objectId);
  await deal.destroy();
}

Integración de Gestión de Estado

Integra el SDK de Back4app con la capa de estado de tu aplicación (por ejemplo, contexto, tienda o servicios) para el estado de pipeline y contacto.

Modelo de Datos Completo

Copia un modelo CRM completo para la serialización segura por tipo (por ejemplo, clase, interfaz o definición de tipo).

JavaScript
/** @typedef {{ objectId?: string, title: string, amount?: number, stage?: string, expectedCloseDate?: string, contact?: { objectId: string }, company?: { objectId: string }, assignedTo?: { objectId: string }, createdAt?: string, updatedAt?: string }} Deal */
/** @typedef {{ objectId?: string, name: string, email?: string, phone?: string, company?: { objectId: string }, notes?: string, createdAt?: string, updatedAt?: string }} Contact */

function dealFromParse(obj) {
  return {
    objectId: obj.id,
    title: obj.get('title'),
    amount: obj.get('amount'),
    stage: obj.get('stage'),
    expectedCloseDate: obj.get('expectedCloseDate')?.toISOString?.() ?? undefined,
    contact: obj.get('contact') ? { objectId: obj.get('contact').id } : undefined,
    company: obj.get('company') ? { objectId: obj.get('company').id } : undefined,
    assignedTo: obj.get('assignedTo') ? { objectId: obj.get('assignedTo').id } : undefined,
    createdAt: obj.get('createdAt')?.toISOString?.() ?? undefined,
    updatedAt: obj.get('updatedAt')?.toISOString?.() ?? undefined,
  };
}
function contactFromParse(obj) {
  return {
    objectId: obj.id,
    name: obj.get('name'),
    email: obj.get('email'),
    phone: obj.get('phone'),
    company: obj.get('company') ? { objectId: obj.get('company').id } : undefined,
    notes: obj.get('notes'),
    createdAt: obj.get('createdAt')?.toISOString?.() ?? undefined,
    updatedAt: obj.get('updatedAt')?.toISOString?.() ?? undefined,
  };
}

Offline-First y Almacenamiento Local

Utiliza pin() y unpin() para que los contactos y las ofertas estén disponibles sin conexión y se sincronicen al volver a estar en línea.

Los SDK compatibles incluyen un almacenamiento local. Fija objetos de Contacto, Oferta y Actividad para mantenerlos en el dispositivo; consulta datos fijados cuando estés sin conexión. Cuando la aplicación vuelva a estar en línea, sincroniza con el servidor.

A continuación: fija resultados después de la búsqueda y deshazte de la fijación cuando ya no necesites copias locales.

JavaScript
// Pin deals after fetch (offline-first)
async function fetchAndPinDeals() {
  const query = new Parse.Query('Deal').equalTo('stage', 'qualified').ascending('expectedCloseDate');
  const results = await query.find();
  await Parse.Object.pinAll(results);
  // When offline, read from local datastore:
  // const localQuery = new Parse.Query('Deal').fromLocalDatastore();
  // const localResults = await localQuery.find();
}

async function unpinAllDeals() {
  await Parse.Object.unpinAll('Deal');
}

Preguntas Frecuentes

Preguntas comunes sobre la plantilla del backend de la aplicación CRM.

¿Qué es Back4app?
¿Por qué usar Back4app para una aplicación CRM React Native?
¿Cómo sincronizo negocios offline en React Native?
¿Cómo asigno negocios al usuario actual?

Confiado por desarrolladores de todo el mundo

Únete a la comunidad que está construyendo el futuro de las aplicaciones

G2 Users Love Us Badge

¿Listo para construir tu aplicación CRM?

Comienza tu proyecto React Native en minutos. No se requiere tarjeta de crédito.

Construye con Agente AI