Curso de PlatformOps (Platform Operations)

Definir la plataforma como producto con usuarios internos, necesidades, roadmap, soporte y métricas de éxito.

Identificar usuarios de la plataforma: desarrolladores, tech leads, SRE, seguridad, QA, datos, soporte y managers.

Crear propuesta de valor: reducir fricción, acelerar entregas, estandarizar, proteger y simplificar operaciones.

Diferenciar capacidades obligatorias, opcionales, experimentales y fuera de alcance.

Diseñar backlog de plataforma con criterios de impacto, adopción, riesgo, coste y esfuerzo.

Definir owners de capacidades: CI/CD, cloud, Kubernetes, observabilidad, seguridad, plantillas y documentación.

Establecer canales de feedback, soporte, priorización y comunicación con equipos consumidores.

Evitar construir capacidades que nadie usa o que duplican herramientas existentes.

Medir éxito con adopción, satisfacción, reducción de tickets, tiempo de provisión y lead time.

Taller: diseñar ficha de producto para una plataforma interna corporativa.

Definir objetivos estratégicos de PlatformOps: autonomía, seguridad, escalabilidad, eficiencia y experiencia de desarrollo.

Diseñar el modelo operativo: equipo central, equipos federados, platform champions y responsables por dominio.

Separar responsabilidades entre plataforma, desarrollo, seguridad, SRE, cloud, FinOps y negocio.

Crear procesos ligeros para nuevas capacidades, soporte, cambios, excepciones y deprecaciones.

Definir niveles de servicio internos para capacidades críticas de la plataforma.

Diseñar modelo de guardia o soporte para componentes como CI/CD, GitOps, clústeres y observabilidad.

Establecer flujos de comunicación para incidentes, mantenimientos, cambios y nuevas versiones.

Evitar que PlatformOps se convierta en nuevo cuello de botella para desarrollo.

Crear mapa de capacidades actuales y capacidades objetivo.

Taller: construir modelo operativo PlatformOps para una organización multi-equipo.

Diferenciar Internal Developer Platform de Internal Developer Portal.

Diseñar una plataforma que orquesta capacidades reales y un portal que actúa como interfaz unificada.

Identificar capacidades clave: crear servicios, solicitar entornos, desplegar, consultar documentación y revisar salud.

Evitar portales que solo muestran enlaces sin resolver problemas de operación.

Conectar portal con repositorios, CI/CD, GitOps, observabilidad, cloud, Kubernetes, ITSM y documentación.

Diseñar navegación orientada a tareas habituales de los desarrolladores.

Crear experiencias de autoservicio con formularios, plantillas, permisos y validaciones.

Integrar resultados de la plataforma en una vista única: owner, estado, versión, SLO, coste y documentación.

Definir ownership del portal, roadmap, plugins, soporte y métricas.

Taller: diseñar arquitectura lógica de una IDP con portal de desarrollador.

Crear catálogo central de servicios, APIs, librerías, jobs, pipelines, bases de datos, componentes y documentación.

Definir metadatos mínimos: owner, equipo, sistema, entorno, criticidad, lenguaje, repositorio y contacto.

Relacionar servicios con dependencias, SLOs, dashboards, runbooks, costes y datos sensibles.

Establecer modelos de ownership claros y actualizados.

Integrar catálogo con repositorios mediante archivos declarativos.

Evitar servicios huérfanos, duplicados o sin responsable técnico.

Crear vistas para desarrollo, plataforma, seguridad, soporte, arquitectura y dirección.

Mantener catálogo vivo mediante validaciones, automatización y revisiones periódicas.

Usar scorecards para evaluar salud, seguridad, documentación y madurez de cada servicio.

Taller: diseñar entidad de catálogo para un ecosistema de microservicios.

Explicar qué es un golden path y cómo reduce carga cognitiva para los equipos.

Diseñar flujos recomendados para crear APIs, workers, frontends, jobs, librerías o servicios de datos.

Crear plantillas con repositorio, estructura base, CI/CD, observabilidad, seguridad y documentación.

Incluir buenas prácticas por defecto sin impedir personalización responsable.

Definir cuándo un golden path es obligatorio, recomendado o experimental.

Gestionar versiones de plantillas y migraciones para servicios ya creados.

Medir adopción de plantillas y detectar equipos que prefieren caminos alternativos.

Evitar golden paths rígidos que no cubren casos reales y terminan siendo ignorados.

Recoger feedback para mejorar plantillas con problemas encontrados en producción.

Taller: diseñar golden path para un microservicio backend corporativo.

Diseñar flujos de creación de servicios desde portal, CLI o pipeline.

Generar repositorio, estructura, README, pipeline, Dockerfile, Helm chart, manifests y documentación inicial.

Configurar ownership, catálogo, métricas, dashboards y alertas desde el primer commit.

Añadir controles de seguridad, escaneo, secretos y políticas base.

Crear entornos iniciales de desarrollo, staging y producción de forma controlada.

Registrar automáticamente el nuevo servicio en catálogo, ITSM y observabilidad.

Evitar servicios creados a mano sin estándares mínimos.

Permitir variantes según lenguaje, framework, criticidad o tipo de workload.

Diseñar flujo de aprobación si el servicio requiere recursos costosos o datos sensibles.

Taller: crear diseño de scaffolder para un servicio corporativo listo para operar.

Diseñar autoservicio para crear entornos, namespaces, bases de datos, colas, buckets, secretos y permisos.

Definir límites por equipo, entorno, coste, región, criticidad y tipo de recurso.

Automatizar provisión con IaC, orquestadores de plataforma o APIs internas.

Integrar solicitudes con aprobaciones cuando el riesgo lo exige.

Registrar quién solicita, qué se crea, cuánto cuesta, qué caducidad tiene y quién lo mantiene.

Evitar recursos huérfanos mediante expiración, owner obligatorio y limpieza automática.

Crear entornos efímeros para pull requests, pruebas, demos o QA.

Controlar destrucción segura y backup si el recurso contiene datos.

Medir tiempo de provisión y reducción de tickets.

Taller: diseñar flujo de autoservicio para entorno de desarrollo completo.

Operar Kubernetes como capa común para aplicaciones, workloads, servicios internos y herramientas de plataforma.

Gestionar namespaces, quotas, limits, network policies, service accounts, ingress y storage classes.

Diseñar estándares de despliegue para equipos de desarrollo.

Ofrecer abstracciones que simplifiquen Kubernetes sin ocultar lo necesario para operar.

Integrar clústeres con GitOps, observabilidad, secretos, políticas y CI/CD.

Gestionar upgrades, compatibilidad, nodos, controladores, add-ons y componentes compartidos.

Evitar que cada equipo configure Kubernetes de forma distinta y no mantenible.

Crear runbooks para fallos de pods, deployments, ingress, DNS, storage y recursos.

Medir salud de clústeres y workloads desde la plataforma.

Taller: definir baseline Kubernetes para equipos consumidores de plataforma.

Integrar cuentas, suscripciones, proyectos y landing zones dentro del modelo de plataforma.

Ofrecer patrones aprobados para redes, IAM, almacenamiento, bases de datos, serverless y conectividad.

Definir límites de autoservicio en cloud para evitar costes, exposición pública o configuraciones inseguras.

Aplicar etiquetas, ownership, presupuestos y políticas desde la provisión.

Crear módulos reutilizables para recursos cloud frecuentes.

Conectar cloud con catálogo de servicios y dashboards de coste.

Diseñar procesos de alta y baja de entornos cloud.

Evitar que equipos creen recursos manuales fuera del modelo de plataforma.

Integrar cloud provider con IaC, CI/CD, secretos y observabilidad.

Taller: diseñar oferta de recursos cloud autoservicio para equipos de desarrollo.

Usar IaC para provisionar recursos de forma repetible, auditable y segura.

Comparar Terraform, OpenTofu, Pulumi, Bicep, CloudFormation y Crossplane según contexto.

Crear módulos y componentes reutilizables para recursos comunes.

Separar configuración de plataforma, configuración de aplicación y configuración de entorno.

Gestionar estados, dependencias, variables, secretos y entornos.

Validar cambios mediante plan, pull request, políticas y pruebas.

Detectar drift entre estado declarado y estado real.

Automatizar provisión desde portal o pipeline sin perder trazabilidad.

Evitar módulos excesivamente genéricos o difíciles de mantener.

Taller: diseñar módulo de plataforma para base de datos o cola gestionada.

Ofrecer pipelines estándar para build, test, scan, empaquetado, despliegue y rollback.

Crear plantillas reutilizables para distintos lenguajes, frameworks y tipos de servicio.

Separar CI, CD, validaciones de seguridad y promoción entre entornos.

Integrar pipelines con repositorios, registry, GitOps, catálogo y observabilidad.

Controlar secrets, permisos, runners, agentes y credenciales de despliegue.

Medir duración, fallos, frecuencia de despliegue y experiencia del usuario.

Evitar pipelines copiados manualmente y difíciles de actualizar.

Diseñar mecanismos de actualización centralizada de plantillas.

Incorporar gates de calidad sin bloquear innecesariamente a los equipos.

Taller: definir pipeline estándar de plataforma para microservicio cloud-native.

Integrar GitOps para mantener estado deseado de aplicaciones y plataforma.

Operar Argo CD, Flux o herramientas equivalentes dentro del modelo PlatformOps.

Diseñar repositorios de configuración para aplicaciones, entornos, clústeres y componentes compartidos.

Gestionar promoción entre entornos mediante pull requests y revisiones.

Detectar drift, recursos degradados y diferencias entre Git y el clúster.

Automatizar rollback mediante revert, versión anterior o promoción controlada.

Establecer permisos para sync, self-heal, prune y cambios productivos.

Conectar estado GitOps con catálogo, dashboards, ChatOps y alertas.

Evitar auto-sync peligroso sin validaciones en entornos críticos.

Taller: diseñar flujo GitOps operativo para una plataforma multi-entorno.

Diseñar gestión centralizada de secretos para aplicaciones y componentes de plataforma.

Integrar secret managers, vaults, External Secrets, Sealed Secrets o servicios cloud equivalentes.

Gestionar permisos de usuarios, workloads, pipelines, bots, controladores y cuentas de servicio.

Aplicar mínimo privilegio y separación de funciones.

Rotar credenciales, certificados, tokens y claves de acceso.

Evitar secretos en repositorios, logs, variables expuestas o canales de chat.

Auditar accesos a secretos y cambios de permisos.

Crear flujos de autoservicio para permisos temporales con aprobación.

Integrar identidad con SSO, grupos corporativos y RBAC de plataforma.

Taller: diseñar modelo de secretos y permisos para plataforma interna.

Integrar seguridad en plantillas, pipelines, IaC, Kubernetes, cloud y portal.

Usar políticas como código para validar imágenes, recursos, permisos, redes, etiquetas y configuración.

Aplicar OPA, Gatekeeper, Kyverno, Checkov, Conftest o herramientas equivalentes según entorno.

Crear guardrails preventivos sin convertir la plataforma en un sistema rígido.

Gestionar excepciones documentadas con owner, fecha, riesgo y plan de remediación.

Integrar escaneo de dependencias, contenedores, IaC y secretos.

Bloquear configuraciones peligrosas antes de producción.

Publicar resultados de seguridad en catálogo y scorecards.

Coordinar plataforma con SecOps, compliance y arquitectura.

Taller: diseñar política de seguridad para despliegues Kubernetes y cloud.

Definir observabilidad mínima para todo servicio creado desde la plataforma.

Integrar métricas, logs, trazas, eventos, dashboards y alertas desde las plantillas.

Usar OpenTelemetry, Prometheus, Grafana, Loki, Tempo, Elastic o plataformas equivalentes.

Crear vistas por servicio, equipo, entorno, versión, despliegue y SLO.

Diseñar dashboards para desarrolladores, SRE, plataforma, soporte y dirección técnica.

Incorporar enlaces a observabilidad desde el catálogo de servicios.

Evitar dashboards duplicados, sin owner o desconectados de incidentes.

Medir salud de componentes de plataforma: portal, CI/CD, GitOps, registry, clústeres y runners.

Crear alertas accionables sobre fallos de capacidades internas.

Taller: diseñar observabilidad estándar para plataforma y servicios consumidores.

Definir SLIs y SLOs para capacidades de plataforma y servicios consumidores.

Medir disponibilidad, latencia, errores, tiempo de provisión, éxito de despliegues y uso de capacidades.

Crear scorecards de servicios con seguridad, documentación, ownership, observabilidad y fiabilidad.

Publicar scorecards en el portal para fomentar mejora continua.

Evitar scorecards punitivos que los equipos perciben como burocracia.

Usar scorecards para priorizar asistencia de plataforma y deuda técnica.

Relacionar salud del servicio con incidentes, cambios, coste y adopción.

Definir umbrales mínimos para producción.

Crear reportes ejecutivos de madurez por equipo y plataforma.

Taller: diseñar scorecard corporativo de salud de servicios.

Medir developer experience mediante encuestas, entrevistas, métricas de uso y análisis de fricción.

Identificar puntos de dolor: entornos lentos, documentación dispersa, permisos, despliegues, observabilidad o soporte.

Diseñar interfaces simples para tareas frecuentes sin esconder información crítica.

Reducir decisiones repetitivas mediante plantillas, defaults seguros y golden paths.

Crear documentación orientada a tareas: crear servicio, desplegar, observar, escalar, depurar y retirar.

Medir tiempo de onboarding, tiempo hasta primer despliegue y tiempo de provisión.

Evitar abstracciones que impiden a los equipos entender qué ocurre en producción.

Incorporar feedback continuo en el roadmap de plataforma.

Crear comunidades internas, office hours y canales de ayuda.

Taller: detectar fricciones de desarrollo y convertirlas en mejoras de plataforma.

Diseñar modelo de soporte para usuarios de la plataforma.

Clasificar solicitudes: dudas, incidencias, mejoras, excepciones, permisos y nuevos recursos.

Crear canales de soporte, SLAs internos, escalados y base de conocimiento.

Reducir tickets repetitivos mediante autoservicio, documentación, ChatOps y runbooks.

Integrar plataforma con ITSM, Jira, ServiceNow, Azure DevOps o herramientas equivalentes.

Registrar incidentes de plataforma y problemas recurrentes.

Crear reporting de tickets por capacidad, equipo, causa, tiempo de resolución y satisfacción.

Evitar que el equipo de plataforma sea soporte manual permanente para tareas automatizables.

Convertir incidencias repetidas en backlog de producto plataforma.

Taller: diseñar flujo de soporte PlatformOps con autoservicio y escalado.

Usar Teams, Slack u otras herramientas para consultar estado, alertas, despliegues y soporte de plataforma.

Crear comandos seguros para consultar catálogo, pipelines, GitOps, clústeres, costes o salud de servicios.

Publicar alertas accionables sobre fallos de capacidades internas.

Integrar ChatOps con ITSM, CI/CD, observabilidad, GitOps y runbooks.

Solicitar aprobaciones de cambios o recursos desde chat sin saltarse controles.

Registrar acciones con usuario, canal, comando, resultado y sistema afectado.

Evitar comandos peligrosos sobre producción sin RBAC y confirmación.

Crear canales de incidente para problemas de plataforma.

Usar resúmenes de guardia y comunicación operativa.

Taller: diseñar flujo ChatOps para incidencia de plataforma o despliegue bloqueado.

Asignar costes por equipo, servicio, entorno, clúster, namespace, pipeline y capacidad compartida.

Integrar tags, labels, cost allocation y budgets desde plantillas y módulos.

Detectar recursos huérfanos, entornos efímeros no eliminados y workloads sobredimensionados.

Crear dashboards de coste para equipos consumidores y dirección técnica.

Optimizar runners, clústeres, bases de datos, storage, observabilidad y tráfico.

Aplicar políticas de apagado, expiración, right-sizing y limpieza automática.

Relacionar coste con valor, adopción, criticidad y fiabilidad.

Evitar que el autoservicio dispare gasto sin límites ni ownership.

Incorporar coste como señal dentro del catálogo y scorecards.

Taller: diseñar modelo FinOps para una IDP con Kubernetes y cloud.

Gestionar herramientas comunes: repositorios, registry, CI/CD, GitOps, observabilidad, vault, portal, runners y scanners.

Definir owners, versiones, backups, upgrades, SLOs y mantenimiento de cada herramienta.

Monitorizar salud y capacidad de componentes internos de plataforma.

Gestionar upgrades de herramientas sin romper equipos consumidores.

Documentar dependencias entre componentes compartidos.

Crear planes de continuidad para caída de CI/CD, Git, registry, portal o clúster.

Evitar single points of failure dentro de la propia plataforma.

Revisar licencias, usuarios, permisos y costes de herramientas SaaS.

Mantener roadmap de actualizaciones y retirada de herramientas obsoletas.

Taller: crear matriz operativa de herramientas compartidas de plataforma.

Diseñar estrategia de entornos: local, dev, test, staging, preproducción, producción y sandbox.

Crear entornos efímeros por pull request, rama, demo o validación temporal.

Automatizar creación, actualización y eliminación de entornos.

Controlar datos de prueba, anonimización, permisos y costes.

Evitar entornos permanentes infrautilizados.

Alinear configuración entre entornos sin copiar manualmente valores.

Integrar entornos con CI/CD, GitOps, observabilidad y catálogo.

Definir límites de uso y caducidad para sandboxes.

Crear reportes de entornos activos, coste, owner y fecha de expiración.

Taller: diseñar flujo de entorno efímero gobernado para equipos de desarrollo.

Integrar gestión de APIs dentro del modelo PlatformOps.

Definir estándares de autenticación, rate limiting, versionado, documentación y publicación de APIs.

Operar gateways, ingress controllers, API gateways y service mesh.

Gestionar certificados, mTLS, rutas, canary, retries, timeouts y circuit breakers.

Observar tráfico entre servicios y dependencias.

Controlar exposición interna y externa de servicios.

Publicar APIs en catálogo con owner, contrato, documentación y métricas.

Evitar que cada equipo exponga APIs con criterios distintos.

Coordinar conectividad con seguridad, redes, cloud y arquitectura.

Taller: diseñar patrón estándar para publicar APIs internas y externas.

Integrar capacidades de datos, ML e IA en la plataforma interna.

Ofrecer plantillas para jobs, pipelines de datos, notebooks productivos, APIs de inferencia y RAG.

Gestionar acceso a datos, secretos, permisos, costes y observabilidad.

Coordinar plataforma con DataOps, MLOps, ModelOps y gobierno de datos.

Crear catálogo de datasets, modelos, jobs y servicios analíticos.

Controlar entornos con GPU, embeddings, bases vectoriales, colas y almacenamiento.

Evitar que equipos de IA creen plataformas paralelas sin seguridad ni operación.

Añadir evaluación, trazabilidad y coste para aplicaciones generativas.

Preparar golden paths para asistentes internos, pipelines batch y servicios de inferencia.

Taller: diseñar capacidad de IA autoservicio dentro de una plataforma corporativa.

Integrar controles de supply chain en la plataforma desde el inicio.

Gestionar SBOM, firma de artefactos, provenance, escaneo y políticas de imágenes.

Controlar dependencias, contenedores, paquetes, registries y artefactos internos.

Aplicar validaciones antes de desplegar en Kubernetes o cloud.

Bloquear imágenes sin firma, vulnerabilidades críticas o procedencia desconocida.

Revisar permisos de pipelines, runners y repositorios.

Integrar SLSA, Cosign, Sigstore u otros enfoques cuando encajen con la organización.

Publicar estado de seguridad en scorecards y catálogo.

Gestionar excepciones con caducidad y plan de remediación.

Taller: diseñar flujo de seguridad de artefactos para servicios corporativos.

Traducir requisitos corporativos y regulatorios en controles de plataforma.

Registrar quién crea, cambia, despliega, aprueba y opera cada servicio.

Auditar permisos, cambios, despliegues, secretos, políticas, costes y excepciones.

Generar evidencias automáticas para auditoría y compliance.

Definir retención de logs, cambios, artefactos, aprobaciones y documentación.

Integrar plataforma con GRC, SIEM, ITSM y sistemas de reporting.

Gestionar excepciones de seguridad o arquitectura con owner y fecha de revisión.

Evitar auditorías manuales basadas en capturas o documentación desactualizada.

Publicar estado de cumplimiento por servicio y equipo.

Taller: diseñar matriz de controles de plataforma para entorno regulado.

Definir qué es un incidente de plataforma y cómo afecta a múltiples equipos.

Crear runbooks para caída de portal, CI/CD, GitOps, registry, clúster, vault o monitorización.

Establecer SLOs internos para capacidades críticas de plataforma.

Diseñar guardias, escalados, canales de incidente y comunicación a equipos consumidores.

Preparar backups, restauración y disaster recovery de herramientas compartidas.

Probar recuperación de componentes críticos de forma periódica.

Registrar timeline, impacto, causa raíz y acciones postmortem.

Evitar que la plataforma sea un punto único de fallo no gestionado.

Medir MTTR, incidentes repetidos, indisponibilidad y satisfacción de usuarios internos.

Taller: simular incidente de plataforma y diseñar respuesta completa.

Diseñar plan de adopción para que los equipos usen la plataforma de forma progresiva.

Identificar early adopters, equipos críticos, resistencias y casos de alto valor.

Crear documentación, demos, sesiones internas, office hours y canales de feedback.

Comunicar cambios de plataforma con calendario, impacto y guías de migración.

Acompañar a equipos que migran desde procesos manuales o herramientas propias.

Evitar imponer la plataforma sin resolver necesidades reales de los equipos.

Medir adopción por uso de plantillas, servicios registrados, despliegues y tickets reducidos.

Crear champions internos por área o producto.

Usar casos de éxito para reforzar adopción.

Taller: diseñar plan de adopción PlatformOps para tres equipos piloto.

Definir KPIs de plataforma: adopción, satisfacción, lead time, tiempo de provisión, disponibilidad y coste.

Medir DORA metrics y relacionarlas con capacidades de plataforma.

Analizar reducción de tickets, reducción de tiempo de onboarding y reutilización de plantillas.

Crear reporting de salud por servicio, equipo, capacidad y entorno.

Medir uso real de portal, catálogo, golden paths, pipelines y autoservicio.

Publicar dashboards para dirección técnica, plataforma, seguridad y equipos consumidores.

Evitar métricas vanidosas que no mejoran decisiones.

Relacionar inversión en plataforma con resultados de negocio y productividad.

Revisar métricas periódicamente para ajustar roadmap.

Taller: diseñar cuadro de mando ejecutivo de PlatformOps.

Construir una plataforma sin escuchar a los equipos consumidores.

Crear un portal bonito que no resuelve autoservicio real.

Abstraer tanto la infraestructura que los desarrolladores no pueden diagnosticar problemas.

Convertir el equipo de plataforma en nuevo equipo de tickets.

Crear plantillas rígidas que no se actualizan ni se adaptan a casos reales.

Ignorar seguridad, costes, compliance y ownership hasta que el problema escala.

Usar demasiadas herramientas sin integrarlas ni gobernarlas.

Medir solo despliegues y no satisfacción, fiabilidad, coste o reducción de fricción.

Permitir shadow platforms por falta de capacidades oficiales.

Taller: analizar antipatrones y definir controles para evitarlos.

Evaluar madurez actual: herramientas, procesos, soporte, autoservicio, seguridad, observabilidad y adopción.

Identificar quick wins: catálogo, plantillas, documentación, pipelines estándar, scorecards y soporte centralizado.

Priorizar capacidades según impacto, dolor de equipos, riesgo, coste y esfuerzo.

Definir fases: visibilidad, estandarización, autoservicio, gobierno, optimización y plataforma como producto.

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

Establecer owners, métricas, entregables y criterios de éxito por fase.

Diseñar pilotos con equipos concretos antes de escalar toda la organización.

Planificar migración desde herramientas y procesos existentes.

Incorporar feedback y revisión continua del roadmap.

Taller: construir roadmap PlatformOps para una organización con varios equipos de desarrollo.

Definir una organización con equipos de desarrollo, cloud, Kubernetes, CI/CD, observabilidad, seguridad y procesos manuales.

Diseñar modelo PlatformOps con plataforma como producto, usuarios internos, roadmap, soporte y métricas.

Crear arquitectura de IDP con portal, catálogo, golden paths, scaffolding, CI/CD, GitOps, IaC y observabilidad.

Definir catálogo de servicios con ownership, scorecards, documentación, SLOs, coste, seguridad y dependencias.

Diseñar flujos de autoservicio para crear servicios, entornos, recursos cloud, permisos y despliegues.

Incorporar seguridad con secretos, RBAC, políticas como código, supply chain, compliance y auditoría.

Preparar modelo FinOps con etiquetado, presupuestos, costes por equipo, limpieza automática y dashboards.

Definir operación diaria con soporte, ITSM, ChatOps, incidentes, runbooks, continuidad y gestión de herramientas compartidas.

Construir roadmap de implantación con quick wins, pilotos, riesgos, owners, métricas y adopción.

Presentar el modelo final justificando arquitectura, gobierno, experiencia de desarrollo, seguridad, costes y próximos pasos.