As engineers, we often live in YAML, Dockerfiles, Terraform modules, and Helm charts. We design infrastructure with the precision of a surgeon—yet somehow, collaboration around this infrastructure feels like medieval surgery. Messy. Manual. Painful.

When I first got a look at Layer5 Kanvas (docs), I felt like I was stepping into the future.

The Problem We All Know Too Well

DevOps tooling is powerful, but let’s be honest: it’s not collaborative. Tools like Kubernetes, Helm, and Terraform are optimized for automation and scale—but not for human collaboration. When you need to work on infra-as-code with someone else, the workflow looks like this:

• Open VS Code.
• Share a screen on Zoom.
• Hope your teammate understands your tab indentation religion.
• Commit.
• Push.
• Wait for CI.
• Realize someone’s change clobbered yours.

What’s worse: visual tools exist, but they’re often read-only, over-simplified, or disconnected from your real codebase. That’s not collaboration—that’s compromise.

Enter Kanvas: DevOps Meets Multiplayer Design

Kanvas is Google Docs for infrastructure and Kubernetes ops—but it’s more than that.

Kanvas provides a real-time, multiplayer canvas where engineers, platform teams, and even product folks can collaborate visually and operationally. You’re not looking at diagrams that get stale in 2 hours. You’re working on live deployments, live configurations, and live environments. It’s WYSIWYG for infrastructure.

What Makes Kanvas Different

• Live Infra Modeling: Drag-and-drop Kubernetes resources, service meshes, policies, cloud services—all modeled in real time.
• Source of Truth Integration: Connect Kanvas to your GitHub repo, Helm charts, or Terraform modules. Edits on the canvas can sync back to code, so you’re never out of sync.
• Multi-user Collaboration: Just like Figma or Google Docs, you see who’s on the canvas, who’s editing what, and you can co-edit clusters and workloads live.
• Context-Rich Views: Hover on a service, and you don’t get a static label—you get live logs, metrics, config diffs, and Git blame.
• Simulation & Preview: Want to see the effect of scaling a deployment or adding a policy? Simulate before committing.

Use Cases I Love

• Platform Teams & SREs: When designing multi-tenant infra or onboarding new microservices, Kanvas acts like a collaborative control tower.
• Developer Enablement: Developers can explore and tweak their service deployments without digging through thousands of lines of YAML.
• Architectural Reviews: In our team, we use Kanvas to run infra reviews the same way designers run Figma critiques.

Under the Hood

If you’re curious about the tech (I always am), Kanvas is built with:

• Kubernetes-native APIs, using Layer5’s own Meshery as the execution engine.
• WebAssembly-based modeling, making the frontend fast and powerful.
• CRD sync and diffing, so you can compare what’s in Git vs. what’s in your cluster.

The Future Is Composable, Visual, and Multiplayer

Kanvas isn’t just about pretty visuals. It’s about operational clarity. It’s about making infrastructure a shared experience—not just a shell script behind a CI pipeline.

If you’ve ever struggled with team onboarding, infra reviews, or debugging a broken service mesh deployment, you know the pain. Kanvas brings order to the chaos—with the intelligence of a DevOps tool and the usability of a design platform.

We built Kanvas because we were tired of juggling a dozen tools just to understand one deployment. It’s still early, but I’m genuinely excited about what’s coming next.

—

TL;DR: Kanvas is multiplayer DevOps. Real-time collaboration, infra-as-code fidelity, and visual context—all in one canvas. Try it. Break it. Build with it. And let us know what you think.

---

Would you like to tailor this post for a specific platform (e.g., Medium, Dev.to, Layer5 blog)? Or include images/screenshots or CTAs?