Curso de Appsmith

Acceder a Appsmith Cloud o instancia corporativa self-hosted según el entorno disponible.

Crear workspaces, aplicaciones, páginas y estructura inicial del proyecto.

Navegar por el editor, canvas, entity explorer, properties pane, debugger, queries y configuración.

Entender la diferencia entre modo edición, preview, deploy y uso final por usuarios.

Crear primera página funcional con widgets, datos estáticos y navegación básica.

Configurar tema visual, estructura general, nomenclatura, iconos, layouts y convenciones de app.

Entender cómo Appsmith guarda estado, evalúa bindings y actualiza widgets.

Evitar empezar una app sin naming, propósito, usuarios, datos y criterios de acceso definidos.

Crear una plantilla base reutilizable para aplicaciones internas.

Realizar ejercicio de creación de primera aplicación operativa con estructura clara.

Usar widgets principales: Table, Form, Input, Select, Button, Text, Modal, Tabs, Container, Chart y FilePicker.

Diseñar layouts claros para usuarios internos con procesos repetitivos y datos operativos.

Configurar propiedades de widgets, estilos, visibilidad, eventos, acciones y comportamiento dinámico.

Crear formularios de alta, edición, validación, búsqueda y filtrado de registros.

Diseñar tablas con columnas, acciones por fila, filtros, ordenación, paginación y selección.

Usar modales para confirmaciones, edición rápida, detalles y operaciones críticas.

Crear dashboards con métricas, tarjetas, gráficos, filtros temporales y navegación.

Evitar interfaces sobrecargadas que mezclan demasiadas acciones sin jerarquía visual.

Aplicar criterios UX para herramientas internas: rapidez, claridad, bajo error y facilidad de soporte.

Realizar ejercicio de panel CRUD con tabla, formulario, modal y acciones.

Comprender el sistema de bindings con `{{ }}` y evaluación dinámica de expresiones.

Leer valores de widgets, queries, JSObjects, appsmith store, selectedRow, selectedOption y URL parameters.

Crear propiedades dinámicas para textos, colores, visibilidad, disabled, default values y validaciones.

Usar expresiones para transformar datos antes de mostrarlos en tablas, selects o gráficos.

Gestionar estado temporal mediante storeValue, appsmith.store y variables controladas.

Evitar lógica duplicada dentro de propiedades de widgets sin organización.

Diferenciar lógica simple en binding y lógica reutilizable en JSObject.

Crear patrones de visibilidad según rol, estado de proceso, selección o resultado de query.

Depurar bindings con debugger y mensajes de error claros.

Realizar ejercicio de interfaz dinámica basada en estado, selección y permisos simulados.

Crear datasources para PostgreSQL, MySQL, MongoDB, REST APIs, GraphQL y servicios SaaS.

Configurar credenciales, host, puerto, SSL, headers, parámetros y autenticación según sistema.

Probar conexiones de forma segura sin exponer datos sensibles.

Separar datasources por entorno: desarrollo, staging, producción y pruebas.

Nombrar datasources con criterio de sistema, entorno, owner y propósito.

Gestionar secretos y credenciales sin copiarlos en queries, widgets o JavaScript.

Entender limitaciones de red, firewalls, VPN, allowlists, proxies y conectividad self-hosted.

Evitar conectar Appsmith directamente a bases productivas sin permisos, límites y auditoría.

Crear conexiones a APIs mock para prácticas seguras.

Realizar ejercicio de conexión a SQL, REST API y servicio externo.

Crear consultas SELECT para listar, buscar, filtrar y paginar registros.

Parametrizar queries con valores de widgets, URL params, store y selección de tabla.

Crear operaciones INSERT, UPDATE, DELETE y UPSERT con validación previa.

Proteger consultas frente a errores por inputs vacíos, tipos incorrectos o filtros mal aplicados.

Implementar paginación server-side para tablas grandes.

Crear confirmaciones antes de operaciones destructivas.

Gestionar errores de base de datos y mostrar mensajes útiles al usuario.

Separar queries de lectura, escritura, validación y reporting.

Evitar consultas que devuelven demasiados datos o exponen columnas innecesarias.

Realizar ejercicio de CRUD completo sobre base SQL con filtros, edición y borrado controlado.

Consumir APIs REST con métodos GET, POST, PUT, PATCH y DELETE.

Configurar headers, query params, body JSON, path params y autenticación.

Procesar respuestas anidadas, listas, paginación, errores y estados HTTP.

Crear integraciones GraphQL con queries, mutations, variables y tratamiento de errores.

Encadenar llamadas API cuando una acción depende del resultado anterior.

Normalizar respuestas de distintas APIs para una misma interfaz.

Crear mocks para desarrollar sin depender de servicios externos.

Evitar exponer tokens, claves API o secretos en el lado visible de la aplicación.

Diseñar capa de integración clara entre UI, Appsmith y servicios backend.

Realizar ejercicio de app conectada a REST y GraphQL con filtros, detalle y acciones.

Usar JavaScript para transformar datos, validar formularios, preparar payloads y controlar flujos.

Crear funciones reutilizables dentro de JSObjects.

Separar lógica de presentación, lógica de negocio y lógica de integración.

Manipular arrays, objetos, fechas, strings, números, estados y respuestas de APIs.

Crear funciones para formatear importes, fechas, etiquetas, estados y mensajes.

Validar datos antes de ejecutar queries o acciones críticas.

Usar async/await cuando una función debe coordinar varias operaciones.

Evitar expresiones JavaScript gigantes dentro de propiedades de widgets.

Crear biblioteca interna de utilidades para varias páginas o aplicaciones.

Realizar ejercicio de JSObject con funciones de validación, transformación y orquestación.

Diseñar JSObjects por dominio: clientes, pedidos, usuarios, validaciones, permisos, reporting y navegación.

Crear métodos claros para cargar datos, guardar cambios, preparar formularios y gestionar errores.

Usar promesas y flujos asíncronos para encadenar queries con control.

Crear estado interno con funciones de inicialización y limpieza.

Definir patrones para evitar duplicidad entre páginas.

Preparar objetos de configuración para estados, etiquetas, colores, roles y rutas.

Documentar funciones críticas con comentarios útiles y ejemplos de uso.

Controlar side effects para no ejecutar acciones inesperadas al cambiar un widget.

Evitar JSObjects que se convierten en un backend improvisado sin control de seguridad.

Realizar ejercicio de refactor de lógica dispersa hacia JSObjects mantenibles.

Crear formularios robustos con inputs, selects, datepickers, checkboxes, filepickers y validaciones.

Definir campos obligatorios, patrones, rangos, longitudes, tipos y reglas condicionales.

Validar datos antes de enviarlos a base de datos o API.

Mostrar errores útiles, próximos pasos y mensajes de éxito.

Gestionar valores por defecto, edición de registros y reseteo de formulario.

Crear formularios dependientes donde un campo cambia opciones de otro.

Controlar estados de carga, botones deshabilitados y doble envío.

Preparar confirmaciones para cambios sensibles, aprobaciones o borrados.

Evitar formularios largos sin secciones, agrupación ni contexto de usuario.

Realizar ejercicio de formulario avanzado con validación, edición y submit seguro.

Configurar tablas con columnas, tipos, formatos, acciones, botones y componentes personalizados.

Implementar búsqueda por texto, filtros por estado, fecha, categoría, responsable y permisos.

Usar paginación server-side cuando el dataset es grande.

Crear vistas de detalle a partir de selectedRow y navegación contextual.

Añadir acciones por fila: editar, aprobar, cancelar, exportar, ver histórico o abrir modal.

Formatear valores financieros, estados, fechas, etiquetas, badges y enlaces.

Crear tablas maestro-detalle conectadas por selección.

Optimizar queries para no recargar datos innecesariamente.

Evitar cargar todo un dataset en cliente cuando debería filtrarse en backend.

Realizar ejercicio de dashboard operativo con tabla avanzada y filtros dinámicos.

Crear dashboards con KPIs, tarjetas, gráficos, tablas resumen y filtros globales.

Conectar gráficos a queries SQL, APIs o datos transformados con JavaScript.

Diseñar métricas por periodo, área, estado, usuario, equipo o categoría.

Crear filtros de fecha, selector de departamento y comparativas temporales.

Gestionar carga de datos, estados vacíos, errores y ausencia de información.

Crear gráficos de barras, líneas, áreas, tartas, series y comparativas.

Preparar dashboards para operación diaria, no solo para presentación ejecutiva.

Evitar dashboards con demasiados indicadores sin acción asociada.

Crear enlaces desde KPI hacia detalle operativo.

Realizar ejercicio de dashboard de seguimiento con filtros y drill-down.

Crear aplicaciones multipágina con estructura clara por proceso, usuario o dominio.

Gestionar navegación entre páginas con parámetros y contexto.

Usar URL params para abrir registros concretos, filtros o vistas preconfiguradas.

Diseñar menús, cabeceras, breadcrumbs y botones de retorno.

Separar páginas de administración, consulta, edición, reporting y configuración.

Reutilizar patrones de diseño entre páginas para reducir aprendizaje del usuario.

Controlar permisos y visibilidad de páginas según rol o grupo.

Evitar duplicar páginas casi iguales cuando puede usarse parametrización.

Crear arquitectura de app escalable para varios módulos internos.

Realizar ejercicio de aplicación multipágina con navegación y detalle por registro.

Comprender el modelo de usuarios, grupos, roles y permisos dentro de Appsmith.

Diferenciar permisos de plataforma, workspace, aplicación, página, datasource y acción de negocio.

Diseñar acceso según perfiles: administrador, editor, viewer, aprobador, operador y supervisor.

Configurar SSO cuando el entorno corporativo lo permite.

Implementar controles de visibilidad y acciones según rol o contexto del usuario.

Recordar que ocultar un botón no sustituye permisos reales en backend o base de datos.

Diseñar seguridad por capas: identidad, permisos Appsmith, datasource, API y reglas de negocio.

Crear matriz de permisos por aplicación, módulo, página y acción.

Evitar compartir cuentas, roles demasiado amplios o credenciales comunes.

Realizar ejercicio de aplicación con roles, visibilidad y permisos diferenciados.

Clasificar datos que circulan por la app: públicos, internos, confidenciales, personales y sensibles.

Proteger credenciales de bases de datos, APIs, SMTP, SaaS y servicios externos.

Evitar exponer secretos en JavaScript, widgets, respuestas API, logs o mensajes de error.

Limitar columnas, registros y acciones según usuario, rol y necesidad real.

Aplicar validaciones server-side en sistemas críticos, no solo validaciones visuales.

Diseñar consultas con principio de mínimo privilegio.

Configurar HTTPS, cookies, dominios, headers y red según despliegue.

Revisar riesgos de inyección SQL, permisos excesivos, endpoints inseguros y filtrado en cliente.

Crear checklist de seguridad antes de publicar una app interna.

Realizar ejercicio de auditoría de seguridad sobre una app Appsmith.

Conectar aplicaciones Appsmith con repositorios Git para versionar cambios.

Crear ramas de desarrollo, staging y producción según flujo del equipo.

Revisar cambios mediante commits, pull requests y comparativas.

Gestionar conflictos entre editores, ramas y despliegues.

Documentar cambios funcionales, técnicos y de seguridad dentro del flujo Git.

Diseñar estrategia de branching para aplicaciones internas.

Sincronizar cambios entre entornos sin pisar configuraciones sensibles.

Evitar editar directamente producción sin revisión ni trazabilidad.

Integrar Git con proceso de aprobación funcional y técnica.

Realizar ejercicio de versionado de app con ramas, cambios y despliegue controlado.

Diferenciar desarrollo, QA, staging, producción y sandbox en aplicaciones internas.

Gestionar datasources por entorno sin mezclar credenciales ni datos.

Diseñar promoción de cambios desde rama o entorno de desarrollo hacia producción.

Validar queries, permisos, widgets y lógica antes de publicar cambios.

Crear checklist funcional y técnico antes de deployment.

Controlar cambios de variables, endpoints, tokens, permisos y datos de prueba.

Evitar que el entorno de staging apunte accidentalmente a sistemas productivos.

Preparar rollback o plan de reversión ante fallos.

Documentar release notes para usuarios internos.

Realizar ejercicio de flujo completo de despliegue dev-staging-producción.

Comprender cuándo conviene usar Appsmith Cloud y cuándo self-hosted.

Desplegar Appsmith en entorno local o servidor mediante Docker.

Configurar volúmenes persistentes, variables de entorno, puertos y dominios.

Gestionar instalación, arranque, parada, actualización y revisión de estado.

Configurar SMTP, dominios, acceso, certificados y settings básicos de instancia.

Revisar logs de contenedor y errores comunes de self-hosting.

Diseñar backups de datos, volúmenes, configuración y repositorios asociados.

Evitar instancias self-hosted sin actualización, backups ni responsable técnico.

Preparar documentación de instalación para sistemas.

Realizar ejercicio de despliegue self-hosted local con Docker y comprobación funcional.

Diseñar despliegue Appsmith en Kubernetes para entornos corporativos.

Comprender componentes de arquitectura: aplicación, MongoDB, Redis, PostgreSQL, almacenamiento, ingress y servicios externos.

Decidir entre servicios embebidos, gestionados o externos según carga, disponibilidad y operación.

Configurar recursos, límites, requests, storage, secrets, config maps y healthchecks.

Diseñar ingress, TLS, dominios, proxy, balanceo y seguridad de red.

Planificar escalabilidad, disponibilidad, backups, upgrades y disaster recovery.

Integrar Appsmith con observabilidad, logs, métricas y alertas corporativas.

Coordinar responsabilidades entre plataforma, seguridad, redes, bases de datos y owners de aplicaciones.

Evitar llevar Appsmith a Kubernetes sin modelo operativo claro.

Realizar ejercicio de diseño de arquitectura Kubernetes para Appsmith enterprise.

Conectar Appsmith con Google Sheets, Airtable, S3, Slack, SMTP, Jira, HubSpot, Salesforce o servicios equivalentes.

Diseñar aplicaciones que integran varias fuentes en una sola interfaz operativa.

Gestionar credenciales, permisos, scopes, tokens y límites de APIs SaaS.

Subir y procesar ficheros mediante FilePicker y servicios de almacenamiento.

Enviar correos o notificaciones tras acciones relevantes.

Crear workflows donde una acción actualiza base de datos, envía notificación y registra auditoría.

Controlar fallos parciales cuando una integración externa no responde.

Evitar depender de integraciones SaaS sin considerar rate limits, cambios de API y permisos.

Documentar owner, credenciales, finalidad y criticidad de cada integración.

Realizar ejercicio de herramienta interna conectada a SaaS, correo y API.

Comprender Appsmith AI como datasource para añadir capacidades de IA a aplicaciones internas.

Crear acciones de generación de texto conectadas a datos de widgets, queries o contexto del usuario.

Usar IA para resumir registros, tickets, conversaciones, incidencias o comentarios largos.

Clasificar texto para priorizar casos, categorizar feedback o detectar urgencia.

Extraer entidades desde emails, formularios, documentos o respuestas de usuarios.

Describir o clasificar imágenes cuando el proceso lo requiere.

Añadir instrucciones, contexto y límites para reducir respuestas inútiles o excesivamente genéricas.

Proteger datos sensibles antes de enviarlos a cualquier capacidad de IA.

Evitar que una recomendación IA sea tratada como decisión automática sin revisión humana.

Realizar ejercicio de app interna con resumen, clasificación y extracción de entidades con IA.

Comprender Appsmith Workflows como capa para automatizar procesos y lógica de negocio.

Diseñar workflows escritos en JavaScript para tareas internas más complejas que una simple acción de UI.

Crear triggers por webhook, acción, evento, ejecución manual o programación temporal.

Implementar tareas programadas mediante cron para informes, sincronizaciones o mantenimientos.

Diseñar aprobaciones con humanos en el circuito para procesos sensibles.

Integrar workflows con bases de datos, APIs, email, Slack u otros servicios.

Registrar estado, errores, resultados y trazabilidad de cada ejecución.

Evitar automatizaciones sin owner, sin control de errores o sin mecanismo de reintento.

Crear criterios para decidir si una lógica debe estar en la app, workflow o backend externo.

Realizar ejercicio de workflow de aprobación de solicitud con notificación y registro.

Medir tiempos de carga, ejecución de queries, renderizado, tamaño de datos y experiencia de usuario.

Optimizar consultas SQL, filtros, paginación y datos devueltos.

Reducir llamadas innecesarias al cargar páginas o cambiar widgets.

Usar caching, lazy loading y ejecución bajo demanda cuando procede.

Separar queries pesadas de acciones interactivas críticas.

Evitar transformar datasets enormes en el cliente si debería hacerse en base de datos o backend.

Revisar widgets, gráficos y tablas que ralentizan la app.

Crear patrones para apps con muchos usuarios o datos voluminosos.

Medir impacto de cada cambio antes de publicarlo en producción.

Realizar ejercicio de optimización de una app lenta con problemas intencionados.

Usar debugger para revisar errores de bindings, queries, APIs, JavaScript y widgets.

Interpretar errores HTTP, SQL, GraphQL, permisos, red y autenticación.

Crear mensajes de error útiles para usuarios internos.

Registrar información suficiente para soporte sin exponer datos sensibles.

Diseñar estados de carga, vacío, error y éxito en cada componente importante.

Crear runbooks de soporte para fallos frecuentes de apps Appsmith.

Diferenciar errores de usuario, errores de datos, errores de integración y errores de plataforma.

Evitar respuestas genéricas como “algo ha fallado” cuando el usuario necesita acción.

Preparar checklist de revisión antes de escalar una incidencia a sistemas.

Realizar ejercicio de troubleshooting de app con fallos de datasource, JS y permisos.

Crear plan de pruebas para aplicaciones internas críticas.

Validar formularios, CRUDs, permisos, filtros, errores, estados y casos límite.

Probar con distintos roles, navegadores, tamaños de pantalla y datos reales anonimizados.

Revisar que queries destructivas requieren confirmación y permisos adecuados.

Crear checklist de regresión antes de desplegar cambios.

Documentar casos de prueba para usuarios clave y owners de proceso.

Automatizar pruebas externas cuando la criticidad lo justifica.

Validar rendimiento y seguridad además de funcionalidad.

Evitar publicar cambios solo porque “funcionan en mi usuario”.

Realizar ejercicio de suite de pruebas funcionales para una app interna.

Crear catálogo de aplicaciones Appsmith con owner, usuarios, criticidad, datasources y estado.

Definir lifecycle: idea, prototipo, piloto, producción, mantenimiento, deprecado y retirado.

Establecer estándares de diseño, seguridad, naming, Git, documentación, permisos y soporte.

Crear proceso de aprobación para nuevas aplicaciones y nuevas conexiones a datos.

Definir roles de plataforma, desarrollador, owner funcional, reviewer y soporte.

Medir uso, adopción, errores, valor, tiempo ahorrado y deuda técnica.

Evitar proliferación de apps sin mantenimiento, duplicadas o conectadas a datos críticos sin control.

Crear revisiones periódicas de permisos, credenciales, owners y dependencias.

Integrar Appsmith con gobierno de datos, seguridad, ITSM y arquitectura corporativa.

Realizar ejercicio de diseño de modelo operativo Appsmith para empresa.

Diseñar panel de soporte con tickets, prioridades, comentarios, estado y acciones rápidas.

Diseñar dashboard de operaciones con KPIs, alertas, filtros y detalle por proceso.

Diseñar herramienta de administración de usuarios, roles, solicitudes y aprobaciones.

Diseñar app de ventas con clientes, oportunidades, pedidos, incidencias y notas.

Diseñar app de RRHH con solicitudes internas, onboarding, documentación y seguimiento.

Diseñar app financiera con aprobaciones, facturas, conciliaciones y control de excepciones.

Diseñar app de IT asset management con inventario, asignaciones, vencimientos y mantenimiento.

Diseñar portal de compliance con controles, evidencias, responsables y fechas.

Priorizar casos según valor, riesgo, complejidad y calidad de datos.

Realizar ejercicio de selección y diseño de tres aplicaciones internas para una empresa.

Seleccionar un proceso corporativo realista para convertirlo en aplicación Appsmith.

Definir usuarios, roles, datos, acciones, permisos, KPIs, workflows y entregables esperados.

Crear workspace, aplicación, estructura multipágina, tema visual y navegación principal.

Conectar al menos una base de datos y una API REST o GraphQL de laboratorio.

Diseñar un panel CRUD completo con tabla, filtros, formulario, modal, validaciones y confirmaciones.

Implementar JSObjects para transformación de datos, validación, estados, navegación y orquestación de acciones.

Crear dashboard operativo con KPIs, gráficos, filtros globales y acceso al detalle.

Añadir control de permisos, visibilidad por rol y reglas de seguridad por acción.

Implementar gestión de errores, estados de carga, mensajes de usuario y logs funcionales.

Crear workflow de aprobación o automatización con notificación y registro de ejecución.

Incorporar Appsmith AI para resumen, clasificación, extracción de entidades o asistencia operativa.

Versionar la aplicación con Git y preparar ramas de desarrollo, revisión y producción.

Configurar entorno de despliegue, datasources por entorno y checklist de publicación.

Desplegar o documentar despliegue self-hosted con Docker o arquitectura Kubernetes propuesta.

Optimizar rendimiento de queries, widgets, carga de datos y acciones principales.

Crear plan de pruebas funcionales con roles, casos límite, errores y regresión.

Preparar documentación técnica: arquitectura, datasources, permisos, workflows, Git y soporte.

Crear guía de usuario final con procesos, pantallas, acciones y resolución de incidencias comunes.

Diseñar modelo de gobierno: owner, mantenimiento, revisiones, métricas, seguridad y ciclo de vida.

Presentar la solución final defendiendo valor de negocio, seguridad, integración, mantenibilidad y escalabilidad.