Curso de OpenXava

Entender la estructura de un proyecto OpenXava basado en Maven.

Identificar paquetes, entidades, controladores, acciones, propiedades, recursos, configuración y despliegue.

Revisar cómo OpenXava transforma entidades JPA en módulos web funcionales.

Diferenciar capa de dominio, capa de presentación generada, lógica de negocio, persistencia y configuración.

Evitar mezclar código de negocio, consultas, validaciones y lógica de interfaz sin criterio.

Entender el ciclo de petición, edición, listado, validación, guardado y acción.

Revisar dependencias principales y su papel dentro del proyecto.

Documentar arquitectura base para aplicaciones corporativas.

Preparar estructura de carpetas escalable para proyectos medianos.

Taller: analizar proyecto OpenXava existente y explicar su arquitectura.

Crear un proyecto OpenXava desde plantilla o arquetipo recomendado.

Configurar `pom.xml`, versión de OpenXava, empaquetado, plugins y dependencias.

Ejecutar la aplicación en entorno local con Maven.

Evitar errores habituales de versión Java, Maven, puertos, dependencias o cachés locales.

Configurar nombre de aplicación, módulos iniciales y propiedades básicas.

Preparar perfiles de desarrollo, pruebas y producción.

Revisar estructura de logs y configuración inicial de arranque.

Conectar la aplicación a una base de datos local.

Crear repositorio Git con `.gitignore`, README técnico y estructura inicial.

Taller: crear aplicación OpenXava limpia, versionarla y ejecutarla correctamente.

Diseñar entidades JPA como núcleo funcional de la aplicación.

Usar anotaciones `@Entity`, `@Id`, `@GeneratedValue`, `@Column`, `@Table` y equivalentes.

Diferenciar entidad, value object, enum, servicio, repositorio y DTO cuando procede.

Evitar modelos anémicos sin reglas o modelos inflados con responsabilidades mezcladas.

Definir claves primarias, campos obligatorios, longitudes, tipos y restricciones.

Relacionar diseño JPA con interfaz generada por OpenXava.

Nombrar entidades y propiedades con lenguaje de negocio claro.

Documentar reglas de modelado para el equipo.

Preparar modelo inicial de una aplicación empresarial.

Taller: modelar un dominio de expedientes, clientes, contratos o inventario.

Crear relaciones `@ManyToOne`, `@OneToMany`, `@OneToOne` y `@ManyToMany` con criterio.

Diferenciar referencias, colecciones, agregados y relaciones de consulta.

Evitar relaciones bidireccionales innecesarias que complican mantenimiento y rendimiento.

Configurar cascadas, orphan removal y fetch type con prudencia.

Diseñar colecciones editables, solo lectura o calculadas.

Controlar integridad referencial y comportamiento de borrado.

Representar relaciones de negocio de forma útil en la interfaz.

Gestionar entidades maestras frente a entidades transaccionales.

Analizar impacto de relaciones en listados, formularios y rendimiento.

Taller: construir modelo con cliente, pedido, líneas, producto, contrato y pagos.

Usar anotaciones de vista para definir cómo se muestra una entidad en OpenXava.

Organizar campos en grupos, secciones, pestañas y bloques funcionales.

Evitar formularios enormes sin jerarquía ni criterio de uso.

Crear vistas específicas para alta, edición, consulta, resumen o tareas concretas.

Ocultar campos técnicos y mostrar información relevante para el usuario.

Gestionar propiedades calculadas y campos derivados.

Adaptar vista a perfiles funcionales o módulos cuando procede.

Documentar criterios de diseño de formularios.

Validar que la vista acompaña al proceso real del usuario.

Taller: rediseñar formulario generado automáticamente hasta convertirlo en formulario usable.

Configurar listados para mostrar columnas relevantes, ordenaciones y filtros útiles.

Evitar listados con demasiadas columnas o información irrelevante.

Crear búsquedas por campos clave del negocio.

Configurar acciones de fila, acciones masivas y navegación desde listas.

Trabajar con filtros guardados, consultas frecuentes y segmentación de datos.

Optimizar listados con grandes volúmenes de registros.

Gestionar columnas calculadas y datos relacionados.

Preparar listas para comerciales, administración, soporte o dirección.

Documentar criterios de listado por módulo.

Taller: crear listado avanzado de expedientes con filtros por estado, responsable y fecha.

Aplicar Bean Validation con `@NotNull`, `@Size`, `@Min`, `@Max`, `@Email`, `@Pattern` y validaciones equivalentes.

Diferenciar validación de interfaz, validación de dominio y validación de persistencia.

Crear validaciones condicionales según estado, tipo, importe, fecha o rol.

Evitar depender solo de restricciones de base de datos para reglas funcionales.

Mostrar mensajes de error claros y accionables.

Validar colecciones, relaciones y reglas cruzadas entre campos.

Crear validadores personalizados reutilizables.

Documentar reglas críticas de negocio.

Probar validaciones con casos positivos y negativos.

Taller: implementar validaciones avanzadas para contratos, vencimientos o expedientes.

Incorporar comportamiento de negocio dentro del modelo cuando mejora cohesión y mantenibilidad.

Crear métodos de dominio para cálculos, cambios de estado, importes, validaciones y decisiones.

Evitar entidades que solo contienen getters y setters cuando hay reglas claras.

Controlar efectos secundarios al guardar, modificar o eliminar.

Gestionar propiedades calculadas y valores derivados.

Documentar reglas complejas dentro del código y pruebas.

Separar reglas de dominio de tareas técnicas o de infraestructura.

Crear servicios de apoyo cuando la regla supera la responsabilidad de una entidad.

Revisar impacto en transacciones y persistencia.

Taller: implementar ciclo de estados y cálculos de una entidad de negocio.

Crear acciones para ejecutar operaciones de negocio desde la interfaz.

Diferenciar acción de entidad, acción de colección, acción de lista y acción global.

Evitar acciones que hacen demasiadas cosas sin feedback claro al usuario.

Solicitar confirmación antes de operaciones sensibles.

Validar estado previo antes de ejecutar una acción.

Mostrar mensajes de éxito, aviso y error con claridad.

Gestionar excepciones de negocio y técnicas.

Reutilizar lógica común en servicios.

Documentar acciones disponibles por módulo y rol.

Taller: crear acción de aprobar, rechazar, cerrar, duplicar o generar documento.

Entender cómo los controladores organizan acciones disponibles en módulos.

Añadir, quitar o modificar acciones estándar según proceso.

Evitar dejar acciones estándar que no tienen sentido para el usuario final.

Crear controladores específicos para módulos críticos.

Gestionar navegación tras ejecutar acciones.

Adaptar comportamiento a estados de la entidad.

Integrar acciones con reglas de seguridad.

Documentar configuración de controladores.

Validar experiencia completa del usuario.

Taller: crear módulo de aprobación con acciones personalizadas y flujo controlado.

Usar herencia JPA para reutilizar campos, reglas y comportamiento común.

Diferenciar mapped superclass, entity inheritance y composición.

Evitar jerarquías complejas cuando bastaría composición.

Crear entidades base para documentos, personas, contratos o movimientos.

Gestionar vistas heredadas y personalizaciones por entidad hija.

Revisar impacto de herencia en tablas, consultas y mantenimiento.

Documentar criterios para usar herencia en el dominio.

Refactorizar duplicación de campos y reglas.

Probar comportamiento de persistencia y UI.

Taller: crear jerarquía de documentos comerciales o expedientes usando herencia.

Configurar referencias a entidades relacionadas con búsqueda, descripción y filtros.

Diseñar colecciones editables para líneas, movimientos, tareas o detalles.

Evitar colecciones difíciles de manejar por exceso de campos o reglas ocultas.

Gestionar alta de objetos desde referencias o colecciones.

Aplicar vistas específicas para creación y edición de elementos relacionados.

Validar integridad de datos entre cabecera y detalle.

Controlar totales, cálculos y cambios derivados.

Mejorar usabilidad de colecciones con columnas, orden y acciones.

Documentar patrones de maestro-detalle.

Taller: construir módulo con cabecera, líneas, importes, estados y validaciones.

Modelar tablas maestras como productos, tipos, estados, provincias, categorías, tarifas o departamentos.

Diferenciar datos maestros simples, jerárquicos y configurables.

Evitar codificar valores en Java cuando deben ser administrables.

Gestionar catálogos con permisos, auditoría y control de cambios.

Crear filtros y vistas específicas para mantenimiento.

Controlar desactivación frente a borrado de maestros usados históricamente.

Documentar ownership de datos maestros.

Preparar importaciones iniciales de catálogos.

Revisar impacto en reporting y reglas.

Taller: crear catálogo maestro usado por varios módulos de negocio.

Diseñar estados de negocio para expedientes, pedidos, contratos, solicitudes o incidencias.

Evitar estados ambiguos o sin criterio de entrada y salida.

Crear transiciones controladas mediante acciones.

Validar permisos y condiciones para cambiar de estado.

Registrar fecha, usuario y motivo de cambios importantes.

Diseñar estados finales, reversibles y cancelaciones.

Relacionar estado con campos obligatorios, visibilidad y acciones disponibles.

Crear listados por estado y tareas pendientes.

Documentar ciclo de vida funcional.

Taller: implementar workflow de solicitud con borrador, revisión, aprobado, rechazado y cerrado.

Crear consultas útiles para procesos de negocio y reporting operativo.

Usar filtros por usuario, estado, fechas, importes, responsable o unidad organizativa.

Evitar consultas pesadas que degradan listados.

Gestionar propiedades calculadas y datos derivados.

Diseñar consultas para usuarios no técnicos.

Reutilizar criterios de filtrado en módulos y dashboards.

Revisar índices de base de datos cuando el volumen crece.

Documentar consultas críticas y su uso.

Validar resultados con usuarios funcionales.

Taller: construir filtros avanzados para seguimiento de vencimientos e incidencias.

Crear gráficos y paneles para resumir información relevante.

Seleccionar indicadores útiles: estados, importes, fechas, responsables, evolución y cumplimiento.

Evitar dashboards decorativos sin decisiones asociadas.

Diseñar gráficos por rol: dirección, administración, soporte, comercial o técnico.

Preparar agregaciones por periodo, categoría, usuario o estado.

Validar datos de origen antes de publicar un dashboard.

Revisar rendimiento de consultas agregadas.

Documentar definiciones de indicadores.

Incorporar dashboards en el flujo diario de usuario.

Taller: crear dashboard operativo de expedientes, importes y tareas vencidas.

Generar informes de listados, fichas, resúmenes o documentos de negocio.

Configurar exportaciones a formatos útiles según proceso.

Evitar exportaciones masivas sin control de permisos y protección de datos.

Preparar informes para administración, dirección, auditoría o cliente interno.

Diseñar plantillas de documentos cuando el proceso lo requiere.

Relacionar informes con estados y acciones.

Controlar nomenclatura y almacenamiento de documentos generados.

Validar resultados con datos de prueba.

Documentar quién puede generar cada informe.

Taller: crear informe de seguimiento y documento asociado a una entidad.

Entender el modelo de seguridad de OpenXava y opciones disponibles según edición y configuración.

Diferenciar autenticación, autorización, roles, módulos, acciones y acceso a datos.

Evitar aplicaciones internas sin control de usuarios y permisos.

Definir roles funcionales: admin, consulta, edición, aprobación, dirección y soporte.

Restringir acciones sensibles por perfil.

Controlar visibilidad de módulos según responsabilidad.

Revisar acceso a datos personales o información confidencial.

Documentar matriz de permisos.

Preparar pruebas de seguridad funcional.

Taller: diseñar permisos por rol para una aplicación de expedientes.

Revisar capacidades profesionales de XavaPro cuando la empresa requiere autenticación corporativa.

Entender integración con LDAP, Active Directory o directorios equivalentes según configuración disponible.

Analizar SSO con Microsoft Entra ID cuando el entorno lo permite.

Evitar gestionar usuarios locales duplicados si existe identidad corporativa.

Diseñar roles y organizaciones para entornos multiusuario.

Revisar multitenancy cuando la aplicación sirve a varias organizaciones.

Controlar permisos sobre módulos, miembros y acciones.

Preparar auditoría de accesos y cambios.

Documentar decisiones de seguridad empresarial.

Taller: diseñar arquitectura de autenticación y roles para una aplicación corporativa.

Entender AI Chat como funcionalidad para interactuar con datos de la aplicación en lenguaje natural.

Revisar casos de uso: consultar registros, filtrar listados, modificar datos y apoyar usuarios de negocio.

Evitar activar capacidades de IA sin revisar permisos, roles, datos sensibles y trazabilidad.

Analizar cómo afecta la seguridad funcional al acceso del chat.

Definir qué módulos y datos deberían estar disponibles para consultas conversacionales.

Preparar ejemplos de prompts seguros para usuarios internos.

Controlar riesgos de modificación de datos mediante lenguaje natural.

Documentar límites, responsabilidades y buenas prácticas de uso.

Medir valor real frente a consultas y filtros tradicionales.

Taller: diseñar política de uso de AI Chat en una aplicación de gestión.

Entender cuándo puede interesar integrar OpenXava en un proyecto Spring Boot existente.

Diferenciar aplicación OpenXava estándar desplegada como WAR y proyecto Spring Boot integrado.

Analizar ventajas, límites y complejidad de la integración.

Evitar mezclar arquitecturas sin definir ownership, dependencias y despliegue.

Configurar rutas, beans, persistencia y convivencia con controladores Spring.

Revisar compatibilidad de versiones y dependencias.

Gestionar seguridad entre OpenXava y componentes Spring.

Preparar pruebas de integración.

Documentar criterios para elegir integración o aplicación separada.

Taller: diseñar integración OpenXava + Spring Boot para módulo administrativo.

Diseñar integración de OpenXava con APIs REST externas o internas.

Diferenciar lógica de dominio, cliente REST, DTOs y entidades persistentes.

Evitar llamar servicios externos directamente desde la UI sin manejo de errores.

Gestionar timeouts, reintentos, autenticación, errores y trazabilidad.

Crear acciones que consultan o sincronizan datos con sistemas externos.

Documentar contratos de integración.

Preparar pruebas con mocks o entornos sandbox.

Registrar eventos e incidencias de integración.

Controlar datos sensibles intercambiados.

Taller: integrar módulo OpenXava con servicio REST ficticio de validación.

Configurar conexión a bases de datos corporativas como PostgreSQL, MySQL, MariaDB, Oracle, SQL Server o H2 para pruebas.

Gestionar dialectos, drivers, pools de conexión y propiedades de persistencia.

Evitar consultas N+1, relaciones demasiado ansiosas y listados pesados.

Revisar índices, restricciones y volumen de datos.

Analizar logs SQL y comportamiento de JPA.

Diseñar paginación, filtros y consultas eficientes.

Gestionar transacciones y errores de persistencia.

Preparar estrategia de migraciones de esquema.

Documentar decisiones de base de datos.

Taller: optimizar módulo con listado lento y relaciones mal configuradas.

Definir estrategia de evolución de esquema para aplicaciones OpenXava.

Usar herramientas como Flyway, Liquibase o scripts controlados cuando la empresa lo requiere.

Evitar cambios manuales en base de datos sin versionado.

Gestionar entornos de desarrollo, staging y producción.

Crear migraciones compatibles con datos existentes.

Validar constraints, índices, columnas nuevas y cambios de tipo.

Preparar rollback o scripts de contingencia.

Coordinar cambios de entidad JPA y esquema real.

Documentar migraciones por release.

Taller: añadir nueva funcionalidad con cambio de esquema versionado.

Preparar aplicaciones OpenXava para varios idiomas si el negocio lo requiere.

Gestionar etiquetas, mensajes, errores, validaciones y textos de acciones.

Evitar textos hardcodeados dentro de código o vistas.

Configurar formatos de fecha, número, moneda y zona horaria.

Revisar traducciones de entidades, propiedades y módulos.

Validar pantallas con textos largos o idiomas con otra estructura.

Documentar proceso de traducción.

Preparar fallback de idioma.

Coordinar localización con usuarios funcionales.

Taller: internacionalizar módulo de aplicación y validar dos idiomas.

Ajustar apariencia, estilos, menús, navegación y disposición cuando el proyecto lo requiere.

Evitar convertir OpenXava en un frontend totalmente custom si se pierde la ventaja del framework.

Diseñar experiencia útil para usuarios internos de gestión.

Adaptar nombres, agrupaciones, iconos, acciones y orden de campos.

Reducir fricción en tareas frecuentes.

Crear vistas simplificadas para perfiles no técnicos.

Documentar personalizaciones para evitar deuda visual.

Revisar accesibilidad básica y legibilidad.

Validar cambios con usuarios reales.

Taller: mejorar experiencia de un módulo administrativo sin romper el estándar OpenXava.

Probar entidades, validaciones, acciones, vistas, permisos e integraciones.

Diferenciar tests unitarios, integración, UI, regresión y pruebas manuales funcionales.

Evitar depender solo de pruebas exploratorias antes de producción.

Crear datos de prueba representativos.

Automatizar pruebas de lógica de negocio y persistencia.

Validar acciones personalizadas con casos positivos y negativos.

Preparar smoke tests de módulos críticos.

Integrar pruebas en Maven y CI/CD.

Documentar criterios de aceptación.

Taller: crear batería de pruebas para módulo de contratos o expedientes.

Depurar aplicación OpenXava desde IDE con breakpoints y logs.

Diagnosticar errores de arranque, dependencias, base de datos, vistas, acciones y permisos.

Evitar cambios a ciegas sin reproducir el problema.

Interpretar stack traces Java y logs de Tomcat o servidor.

Analizar errores JPA, transacciones, validaciones y conversión de tipos.

Recoger evidencias útiles para soporte o comunidad.

Crear runbooks de incidencias frecuentes.

Documentar causa raíz y solución.

Configurar logging por entorno.

Taller: resolver lote de fallos simulados en aplicación OpenXava.

Construir la aplicación con Maven y generar artefactos desplegables.

Diferenciar ejecución local, WAR, servidor Tomcat, contenedor y despliegue corporativo.

Configurar propiedades por entorno sin recompilar innecesariamente.

Evitar incluir credenciales o datos sensibles dentro del artefacto.

Preparar despliegue en Tomcat o servidor compatible.

Gestionar versiones, releases y rollback.

Documentar procedimiento de despliegue.

Validar la aplicación tras publicar.

Preparar health checks y pruebas smoke.

Taller: empaquetar aplicación OpenXava y desplegarla en servidor de laboratorio.

Crear imagen de contenedor para aplicación OpenXava.

Elegir imagen base Java/Tomcat adecuada y mantenible.

Evitar imágenes pesadas, sin usuario no root o sin gestión de configuración externa.

Configurar variables de entorno, volúmenes, logs y conexión a base de datos.

Generar SBOM y escanear vulnerabilidades de imagen.

Preparar `docker-compose` para aplicación y base de datos de laboratorio.

Gestionar persistencia y migraciones.

Documentar puertos, recursos y requisitos.

Preparar despliegue en Kubernetes u OpenShift si procede.

Taller: contenerizar aplicación OpenXava con base de datos PostgreSQL.

Diseñar pipeline con compilación, tests, análisis, empaquetado, imagen y despliegue.

Integrar GitHub Actions, GitLab CI, Jenkins, Azure DevOps o herramienta equivalente.

Evitar despliegues manuales sin trazabilidad.

Gestionar variables, secretos y perfiles por entorno.

Ejecutar pruebas automáticas y análisis estático.

Publicar artefactos o imágenes versionadas.

Preparar promoción entre entornos.

Añadir aprobación para producción si aplica.

Registrar evidencias de release.

Taller: crear pipeline completo para build y despliegue de aplicación OpenXava.

Identificar datos personales, financieros, contractuales o sensibles dentro de la aplicación.

Aplicar acceso mínimo necesario por rol y módulo.

Evitar mostrar campos sensibles en listados, vistas o AI Chat sin control.

Gestionar auditoría de acciones relevantes.

Proteger credenciales de base de datos, APIs externas y configuración.

Revisar riesgos de exportación de datos.

Aplicar HTTPS, cookies seguras y configuración del servidor.

Validar entradas y reglas de negocio críticas.

Documentar tratamiento de datos y permisos.

Taller: auditar módulo con datos sensibles y ajustar vistas, roles y acciones.

Registrar cambios relevantes en entidades críticas.

Diferenciar auditoría técnica, auditoría funcional y logs de aplicación.

Evitar aplicaciones de gestión sin rastro de aprobaciones, estados o modificaciones.

Diseñar campos de control: creado por, modificado por, fecha, estado, motivo y responsable.

Crear listados de seguimiento y revisión.

Preparar evidencias para auditoría interna.

Integrar auditoría con reporting.

Controlar cambios masivos o acciones sensibles.

Documentar requisitos de trazabilidad por módulo.

Taller: añadir auditoría funcional a ciclo de vida de expediente.

Analizar hojas Excel, Access, aplicaciones antiguas o bases heredadas como origen.

Limpiar datos antes de importarlos a entidades OpenXava.

Evitar importar datos duplicados, incompletos o sin clave de negocio.

Diseñar mapeo de campos y reglas de transformación.

Crear procesos de carga inicial y validación posterior.

Preparar informes de errores de importación.

Documentar decisiones de migración.

Coordinar validación con usuarios clave.

Planificar coexistencia y corte.

Taller: migrar dataset ficticio de Excel a una aplicación OpenXava.

Diseñar aplicaciones para varios equipos, departamentos, delegaciones u organizaciones.

Controlar visibilidad de datos según rol, área, organización o responsabilidad.

Evitar mezclar datos de diferentes unidades sin filtros de seguridad.

Modelar organizaciones, usuarios, propietarios y ámbitos de acceso.

Aplicar criterios de multitenancy si el proyecto lo requiere.

Validar consultas, listados y acciones con usuarios de distintos perfiles.

Documentar reglas de segregación de datos.

Preparar pruebas de permisos.

Auditar accesos indebidos.

Taller: diseñar aplicación con datos separados por organización o departamento.

Gestionar cambios de modelo, vistas, validaciones, acciones y permisos por release.

Evitar romper procesos existentes al añadir funcionalidades.

Crear backlog funcional y técnico.

Documentar decisiones de evolución.

Mantener compatibilidad con datos existentes.

Revisar impacto en usuarios, informes y acciones.

Preparar pruebas de regresión por módulo.

Gestionar deprecación de campos, estados o módulos.

Comunicar cambios a usuarios internos.

Taller: evolucionar una aplicación OpenXava con nueva entidad y nuevo flujo.

Medir tiempos de carga de listas, formularios, acciones y consultas.

Detectar cuellos de botella en JPA, base de datos, servidor, red o UI.

Evitar listados masivos sin filtros ni paginación adecuada.

Revisar índices y consultas SQL generadas.

Ajustar pool de conexiones y configuración del servidor.

Gestionar cachés cuando aportan valor.

Medir impacto de dashboards y agregaciones.

Preparar pruebas de carga realistas.

Documentar límites de uso y recomendaciones.

Taller: optimizar módulo lento con relaciones pesadas y consultas mejorables.

Preparar configuración por entorno: desarrollo, pruebas, preproducción y producción.

Gestionar logs, backups, monitorización, alertas, health checks y soporte.

Evitar desplegar sin plan de rollback y prueba smoke.

Definir runbooks para caídas, errores de base de datos, permisos, lentitud y despliegue fallido.

Integrar aplicación con observabilidad corporativa.

Revisar consumo de CPU, memoria, conexiones y tiempos de respuesta.

Coordinar soporte N1, N2 y desarrollo.

Documentar procedimientos de mantenimiento.

Crear checklist de paso a producción.

Taller: preparar operación productiva de aplicación OpenXava corporativa.

Identificar procesos que viven en Excel, Access, aplicaciones obsoletas o formularios manuales.

Evaluar encaje de OpenXava según complejidad, usuarios, datos, flujos e integración.

Evitar replicar una mala aplicación legacy sin mejorar el proceso.

Rediseñar modelo de datos y estados antes de desarrollar.

Crear prototipo funcional rápido para validar con usuarios.

Priorizar módulos por valor y riesgo.

Planificar migración de datos y formación.

Definir métricas de éxito: reducción de errores, trazabilidad, tiempo y uso.

Documentar roadmap de modernización.

Taller: convertir proceso Excel en aplicación OpenXava con flujo y reporting.

Diseñar aplicaciones de gestión interna con clientes, productos, contratos, expedientes, tareas y facturación.

Separar módulos por proceso y responsabilidad.

Evitar construir un ERP monolítico sin límites de dominio.

Crear vistas por perfil y tarea.

Gestionar datos maestros, transacciones y reporting.

Integrar acciones de aprobación, cierre, generación y seguimiento.

Controlar permisos y trazabilidad.

Diseñar mantenimiento por módulos.

Documentar límites funcionales y evolución.

Taller: crear backoffice departamental con catálogo, operaciones y dashboard.

Separar dominio, servicios, integración, infraestructura y presentación generada.

Evitar que entidades se conviertan en clases gigantes sin cohesión.

Crear servicios de aplicación para casos complejos.

Mantener reglas de negocio cerca del modelo cuando aportan claridad.

Diseñar paquetes por dominio y no solo por tipo técnico.

Evitar acoplamiento excesivo a detalles de UI.

Preparar pruebas de lógica independiente.

Documentar decisiones arquitectónicas.

Revisar deuda técnica en cada release.

Taller: refactorizar aplicación OpenXava con arquitectura más mantenible.

Usar asistentes de IA para generar entidades, validaciones, acciones, tests y documentación con revisión humana.

Aprovechar la estructura del proyecto para dar contexto claro a la IA.

Evitar aceptar código generado sin validar reglas, seguridad y compatibilidad OpenXava.

Preparar prompts técnicos para crear módulos, vistas y acciones.

Revisar riesgos de datos sensibles al usar herramientas de IA.

Crear criterios de calidad para código generado.

Usar IA para explicar errores, generar tests o proponer refactorizaciones.

Mantener trazabilidad de cambios importantes.

Documentar patrones internos para usar IA con OpenXava.

Taller: crear módulo asistido por IA y revisarlo con checklist técnico.

Diseñar formación por perfil funcional: administración, soporte, dirección, técnicos o usuarios de consulta.

Evitar formar a todos con el mismo recorrido si cada rol usa módulos distintos.

Crear guías rápidas por proceso.

Preparar datos de práctica similares a la realidad.

Recoger feedback de usuarios tras piloto.

Medir adopción mediante uso, incidencias y calidad de datos.

Crear usuarios clave por área.

Documentar dudas frecuentes dentro de la aplicación o manual interno.

Planificar sesiones de refuerzo tras despliegue.

Taller: diseñar plan de adopción para nueva aplicación OpenXava.

Definir ownership de módulos, entidades, permisos, informes, integraciones y despliegues.

Crear proceso de solicitud de cambios funcionales.

Evitar añadir campos y acciones sin revisar impacto de dominio.

Mantener inventario de aplicaciones OpenXava.

Revisar calidad de datos, rendimiento, seguridad y soporte periódicamente.

Gestionar versiones, dependencias, parches y vulnerabilidades.

Documentar estándares internos de desarrollo OpenXava.

Integrar gobierno con arquitectura, seguridad y negocio.

Medir valor entregado por aplicación.

Taller: crear modelo de gobierno para portfolio OpenXava corporativo.

Usar OpenXava solo como generador CRUD sin pensar en dominio, reglas ni procesos.

Crear entidades con demasiadas responsabilidades, campos ambiguos y relaciones innecesarias.

Copiar datos de Excel sin limpiar ni normalizar.

Conceder permisos amplios para evitar definir roles correctamente.

Añadir acciones personalizadas sin transacciones, validaciones ni mensajes claros.

Desplegar sin pruebas, sin backups, sin migraciones y sin rollback.

Ignorar rendimiento de listados con muchas relaciones.

Personalizar demasiado la UI hasta perder productividad del framework.

Activar IA o reporting sin revisar permisos y datos sensibles.

Taller: auditar una aplicación OpenXava mal diseñada y convertirla en solución mantenible.

Evaluar procesos candidatos: Excel, Access, backoffice, inventarios, expedientes, catálogos y ERPs departamentales.

Identificar quick wins con alto valor, baja complejidad y usuarios disponibles para validar.

Priorizar aplicaciones por impacto, riesgo, integraciones, datos, urgencia y mantenimiento futuro.

Definir stack estándar: Java, OpenXava, base de datos, seguridad, despliegue, CI/CD y observabilidad.

Crear piloto con un módulo funcional completo.

Medir tiempo de entrega, calidad de datos, adopción, incidencias y ahorro operativo.

Establecer guía interna de modelado, seguridad, vistas, acciones e integración.

Preparar formación de desarrolladores y usuarios clave.

Crear plan a 30, 60, 90 y 180 días.

Taller: construir roadmap OpenXava para modernizar aplicaciones internas de una organización.

Definir una aplicación empresarial completa con usuarios, procesos, entidades, estados, permisos, informes e integraciones.

Crear proyecto OpenXava con Maven, estructura limpia, repositorio Git, configuración local y base de datos de laboratorio.

Modelar dominio con JPA: entidades, relaciones, validaciones, herencia, catálogos, estados y reglas de negocio.

Diseñar vistas, listados, filtros, colecciones, referencias, acciones y controladores orientados al trabajo real del usuario.

Implementar ciclo de vida funcional con acciones de aprobación, rechazo, cierre, generación de documento o cambio de estado.

Configurar seguridad por roles, módulos, acciones y datos sensibles, incluyendo matriz de permisos y pruebas.

Añadir dashboard, informe, exportación o consulta avanzada para dirección y seguimiento operativo.

Integrar un servicio externo o API ficticia, gestionando errores, timeouts, trazabilidad y validación de datos.

Preparar despliegue con Maven, Tomcat o Docker, configuración por entorno, logs, pruebas smoke y checklist de producción.

Presentar roadmap final con arquitectura, módulos, seguridad, datos, reporting, CI/CD, operación, riesgos y evolución futura.