Replicated

One trend we’re increasingly hearing across the industry: enterprise AI companies are becoming more concerned about self-hosted software being reverse engineered within customer environments. As more vendors deploy AI into customer-owned infrastructure, protecting model IP and proprietary technology is becoming just as critical as enabling self-hosted deployment itself. This is exactly the challenge we’re focused on solving at Replicated. In AI, the application itself often represents the company’s core IP, from model weights and fine-tuning approaches to inference and orchestration logic, making exposure inside customer environments a much higher-stakes risk than traditional enterprise software. We’re seeing vendors use Replicated to respond with patterns like signed images, license enforcement, and more controlled delivery architectures that help verify authenticity, limit unauthorized distribution, and maintain stronger control over proprietary technology in self-hosted deployments.

VIBE CODED APPS ARE NOT SECURE. I REPEAT. VIBE CODED APPS ARE NOT SECURE. AI can help teams ship software faster than ever. But speed without controls creates a massive security gap, especially when software is deployed into customer environments. The reality is that many AI-generated apps: - skip proper auth and RBAC - expose secrets - lack auditability - ignore infrastructure hardening - ship with insecure defaults - bypass deployment review processes entirely And the problem gets much bigger in enterprise and on-prem environments, where customers expect security, compliance, isolation, and operational control from day one. This is exactly why deployment infrastructure matters. At Replicated, we spend a lot of time thinking about how vendors can safely deliver modern applications into customer-controlled environments: - standardized deployment workflows - secure distribution - policy enforcement - repeatable installs - visibility into what’s actually running - enterprise-ready operational controls AI might accelerate app creation. But enterprises still need trusted ways to deploy and operate that software securely.

“One man year.” That’s what GitGuardian estimated it would take to rebuild everything they get from Replicated. Not just installation, but telemetry, operational tooling, deployment workflows, and all the infrastructure around delivering enterprise software to customers. So instead of rebuilding all of that internally, their team stays focused on the product itself. Romain Jouhannet Charles Brossollet

What enterprise apps aren’t self-hosted, but you’d like them to be? We’re trying to better understand where the self-hosted industry is right now. There are a ton of tools out there, but it can still be hard to figure out where the biggest gaps are across the ecosystem. We’d love to hear: ➡️ What enterprise apps or tools do you wish were self-hosted? ➡️ Are there specific products or broader categories that feel underserved? ➡️ Why would you want those products self-hosted? (security, compliance, control, procurement requirements, etc.) Thanks in advance!

Your team shouldn’t have to constantly monitor dashboards to know when something important happens across customer environments. That’s why we’re excited to announce that our new Event Notifications feature is now Generally Available for Replicated vendors 🎉 With Event Notifications, software vendors can automatically: • Get alerted to critical events in real time • Route notifications to the right teams and systems • Reduce manual operational overhead • Trigger automated workflows based on customer activity The result: faster response times, better visibility into customer environments, and less time spent reacting after issues escalate. As enterprise deployments grow more complex, especially across on-prem, air-gapped, and customer-managed environments, proactive visibility becomes essential. Not using Replicated yet, but need better visibility and automation for enterprise software delivery? Request a demo to see what’s possible. 📖 Learn more about Event Notifications: https://lnkd.in/ezm9KPtc 👉 Request a demo: https://lnkd.in/gNhFtavk

If your AI product touches sensitive customer data, your customers will care where it runs. Self-hosted AI is becoming table stakes for enterprise adoption.

We spend a lot of time talking about models, but not as much about the compute they run on. As our CTO, Marc Campbell, points out, once you move beyond simple tasks, agent workflows depend on fast, reliable environments to run. That starts to change the shape of the stack. Instead of a single app backed by infrastructure, you now have many environments spinning up per task, each one part of the system itself. Feels like we’re still early in figuring out what that layer should look like. Great discussion with Ivan Burazin (Daytona) and Benjie D. (Shipyard) on where this is heading.

Many teams struggle to answer a simple but critical question: 👉 When was our software actually delivered to the customer? Not when the contract was signed. Not when the invoice was sent. When the software was in their hands and usable. For a lot of teams, this is where lifecycle tracking quietly falls apart, not just identifying “delivery,” but connecting every step from signup to real usage in one place. And that distinction matters, especially for revenue recognition under ASC 606, where timing and performance obligations need to reflect reality. It gets even harder when you’re dealing with: • Trials running in customer environments • On-prem or air-gapped deployments • Usage that doesn’t happen in your cloud Because now, the data you need lives across systems, and the lifecycle becomes fragmented. Amber Alston breaks down how to track the full customer lifecycle, from signup to revenue recognition, and how teams are using Replicated to connect delivery and usage to revenue in practice. 👉 Read the full article: https://lnkd.in/g_hjv2kf

Most teams underestimate what it takes to support an on-prem product. The hard part isn’t deployment. It’s losing visibility after. Once your software is running inside a customer’s environment, you don’t get logs, access, or easy debugging. Just tickets that say: “something’s broken.” GitGuardian had to figure out how to support customers without ever logging into their systems. Using Replicated, they built a model that actually works: ✅ customers generate meaningful diagnostics themselves ✅ support bundles are structured and actionable ✅ support data feeds directly back into improving the product This is the part most enterprise-ready conversations skip. It’s not just about how you ship software. It’s about how you support it when you can’t see it. jeremy COTINEAU from GitGuardian breaks down how they approached this: https://lnkd.in/gAKXyqnn

Self-hosted trials should be some of your highest signal for your sales team. But most aren’t. Not because users aren’t interested, but because you can’t see what’s actually happening. Who’s deploying? How far are they getting? Is this real evaluation, or just light exploration? That’s what tells your sales team who’s actually evaluating and when to engage. In SaaS, you’d have that visibility. In on-prem, air-gapped, and VPC environments, you usually don’t. So every trial ends up looking the same. That’s the gap. Replicated gives you insight into what’s actually happening inside real customer deployments, so your sales team can finally tell the difference between a cold lead and a real opportunity. That’s how you turn trials into revenue signals.👇 https://lnkd.in/gc2kP2dQ