Building AI-Native Platform Engineering Systems

AI agents, platform intelligence, DevEx, observability, and secure platform engineering

Build AI-Native Platforms with Real Demos, Hands-On Workflows & Proven Patterns

In Collaboration with FAUN.dev() : FAUN.dev() - Where engineers from GitHub, Netflix, and Shopify go to stay ahead - fast.

Most platform teams today aren’t struggling with tooling they’re struggling with scale, complexity, and growing expectations.

AI is changing what’s possible. But adding AI on top of your platform without rethinking architecture, workflows, and governance usually creates more problems than it solves.

This workshop is designed for those who already operate cloud-native platforms and now need to evolve them into AI-native platforms deliberately, safely, and with clear business value.

Many platform teams are now asking the same questions:

• How do we introduce AI into internal platforms without weakening governance?

• How do we increase team autonomy without losing operational control?

• What does an AI-native platform actually look like in practice?

• How do developer portals, golden paths, telemetry, and AI agents fit together?

• How do we design self-service experiences that are both usable and secure?

• How do we evolve from cloud-native platform engineering to AI-native platform operations without creating unnecessary risk?

This cohort is built to answer those questions with practical patterns, architectural thinking, and implementation guidance.

This hands-on cohort covers:

• AI-native architecture & platform design
• Backstage developer portals & self-service platforms
• OpenChoreo application delivery workflows
• CI/CD automation, platform orchestration & golden paths
• Policy-as-code, governance & guardrails
• Telemetry, observability & platform intelligence
  

Who should attend:
Platform Engineers, Cloud Engineers, DevOps Engineers, SREs, Architects, Tech Leads, and Engineering Leaders building scalable, secure, self-service platforms

What you’ll walk away with

• A clear understanding of how platform engineering is evolving into AI-native systems, and what changes for your architecture and teams
• The ability to design AI-enabled platform architectures, including data, telemetry, and control layers
• Practical exposure to modern platform tools and patterns (e.g., internal developer portals, OpenChoreo, Crossplane) and how they fit together
• Hands-on insights into using LLMs (like Claude) in DevOps and platform workflows, including automation via tools like Kiro/Kiro-cli
• A working approach to building self-service platforms and golden paths that improve developer experience without losing control
• A deep understanding of secure-by-default AI platforms, including guardrails, trust boundaries, and real risks (OWASP LLM Top 10)
• Strategies to implement governance, policy, and control for AI systems, preventing misuse, jailbreaks, and unsafe automation
• A practical framework to define your AI-native platform roadmap and connect it to developer productivity and business outcomes
  

What makes this workshop different

• Not another “here’s a tool” session, this is how it all fits together in production
  We walk through the full path from architecture → developer experience → operations → governance, so you can see how decisions in one layer impact everything else (and where things typically break).
• AI isn’t bolted on — it’s treated as part of your platform design
  Instead of “AI for DevOps” demos, this shows how AI changes your platform architecture, workflows, and team responsibilities — and what you’ll need to rethink to make it work safely.
• Built around real platform patterns you’ll actually implement
  We focus on things you’re likely already considering or struggling with: Internal Developer Platforms, golden paths, control planes (e.g. Crossplane), and how AI fits into those systems without adding chaos.
• Security, guardrails, and governance are first-class — not an afterthought
  We go deep into where things can go wrong: trust boundaries, OWASP LLM risks, agent permissions, and how to design guardrails that won’t block your teams but still keep you out of trouble.
• Observability isn’t just dashboards — it’s how you trust AI in your system
  Learn how to use telemetry to understand, debug, and control AI-driven behavior — so you’re not flying blind when something unexpected happens.
• Designed for people who will have to run and defend this in production
  This is for DevOps engineers, SREs, and platform teams who will be on the hook when things fail — not just experimenting, but making decisions others depend on.
• Focused on the “what happens after the demo” problem
  We explicitly cover how to move from prototype → production, what to keep, what to rethink, and where teams usually get stuck or make costly mistakes.
• You leave with a clearer call on what to do next — not just ideas
  By the end, you’ll be able to assess where your platform stands today and what a realistic, low-risk path toward AI-native capabilities actually looks like.
  

🎁 Bonus: Get a free e-book of Platform Engineering for Architects — a practical guide to designing internal developer platforms, improving software delivery, and building self-service cloud-native systems