New in Marketplace: 1-click deploy for RAGFlow, Temporal IO, and Suricata IDS. All with auto-scaling and managed backups.

Shipping a marketplace app is mostly about owning day two

Adding apps to a marketplace sounds simple if you think the work ends at install time. It does not. Customers do not just want YAML wrapped in a nicer button. They want a sane operating experience after deployment.

That is why every serious marketplace addition starts with the same question for us: what would we need to automate so this feels production-ready on day one and maintainable on day two?

RAGFlow, Temporal IO, and Suricata made sense together because each one is operationally valuable and non-trivial to run well without platform help.

Packaging is the easy part. Operational defaults are the real product

For every marketplace app, we define:

• Base deployment topology
• Storage and backup behavior
• Scaling policy defaults
• Health checks and monitoring
• Upgrade path and rollback posture

This matters because installation success is not the same as product success. A deployment that comes up once and then leaves the customer holding all the operational complexity is not finished.

Our goal is that teams can adopt a complex workload quickly without inheriting an undefined operations burden.

Why these three apps

Each app solved a different class of customer demand we were seeing repeatedly.

RAGFlow

Teams wanted a retrieval stack that could move from prototype to internal production use without weeks of assembly work. The main friction points were ingestion setup, storage decisions, and making sure the deployment could scale with query load.

Temporal IO

Customers loved Temporal conceptually but hesitated because cluster operations, persistence, and upgrade handling were intimidating. We saw an opportunity to package the power of durable workflows with stronger operational guardrails out of the box.

Suricata IDS

Security teams wanted better visibility and detection coverage without spending weeks on packaging, rule distribution, and observability plumbing. Suricata is valuable, but the supporting operational work is where adoption often stalls.

Managed backups and scaling cannot be optional extras

The reason we highlight auto-scaling and backups in the launch copy is that they separate a demo install from a platform offering.

For stateful or semi-stateful apps, customers need confidence that:

• Data is protected by default
• Capacity can expand predictably
• Monitoring exists before the first problem
• Updates do not require relearning the underlying stack

That framing changes how we build marketplace releases. We are not publishing manifests. We are publishing an operating envelope.

The internal quality bar is "fewer surprise responsibilities"

When a team clicks deploy, they should not discover hidden responsibilities after the fact. If a workload needs special storage classes, unusual ingress handling, or non-obvious secret rotation steps, that needs to be encoded or clearly surfaced up front.

The best marketplace experience reduces surprise responsibilities:

• Clear prerequisites
• Clear resource expectations
• Clear ownership boundaries between customer and platform
• Clear support path when something deviates from the norm

If we cannot explain those pieces cleanly, the app is not ready no matter how impressive the logo looks in the catalog.

Marketplace quality compounds over time

Every app we package teaches us something reusable about backups, scaling rules, alerting templates, and upgrade workflows. That means the catalog gets stronger as we add more software, provided we stay disciplined about shared operational patterns.

This launch is part of that compounding effect. The value is not just three new buttons. It is a tighter platform model for shipping opinionated, production-friendly application experiences.

What happens next

We are continuing to expand the catalog, but we are doing it selectively. The right additions are not just popular tools. They are tools where platform automation meaningfully reduces the customer's operational burden.

That standard keeps the marketplace useful. The goal is not volume. The goal is to make complex software feel deployable without pretending it is simple.