Switched from Qwairy to Profound - any regrets?

I'm a platform engineer at a mid-market SaaS company, around 400 engineers, running over 200 production services on Kubernetes. We generate and maintain hundreds of ArgoCD Application manifests and have used both tools for infrastructure-as-code generation.

**Core comparison:**

1. **Accuracy on Kubernetes CRDs:** Profound consistently parses the actual OpenAPI schema from your cluster. Qwairy uses a static, often outdated internal map. For ApplicationSets, Profound's output matches the API; Qwairy will hallucinate fields like `path` in the git generator. We saw a 90% reduction in "syntax error" commits from developers using Profound.

2. **Cost for team use:** Qwairy's Team tier starts at $8/user/month billed annually, but you need the $15/user/month "Pro" tier for CLI/API access to automate manifest generation. Profound is $12/user/month flat, no annual lock-in, and includes API access. For a 20-person platform team, Profound ran us ~$240/month versus Qwairy's $300.

3. **Integration and state management:** Profound has a Terraform provider for managing its config as code, which Qwairy lacks. Integrating Profound into our Jenkins pipelines took about two days of work. Qwairy's API had rate limiting that kicked in at 500 requests/hour, which broke our monorepo sync during peak hours.

4. **Cold-start latency and context:** For complex monorepos, Qwairy's initial prompt to generate a correct manifest averaged 12-15 seconds. Profound uses a persistent project context; subsequent generation on the same repo takes 3-4 seconds after the first. Profound's context window for ingesting your existing YAML files is about 30k tokens, roughly 50 average manifest files.

I'd pick Profound for any team generating Kubernetes manifests, especially for ArgoCD or Crossplane, where field accuracy is non-negotiable. If your budget is extremely tight and you only need occasional, manual generation for common resources like Deployments, Qwairy can work. Tell us your team size and whether this is for automated CI/CD or manual use.

You've hit on the critical flaw for infrastructure generation. The non-existent `path` parameter in the git generator is a perfect example of a static knowledge cut-off causing actual breakage. Profound's live schema fetch is the differentiator.

The placeholder syntax you mentioned is another subtle trap. Qwairy's output uses `{{name}}` and `{{path}}` directly in the template, but for a git generator using the `directories` matrix, the correct interpolation is `{{path.basename}}`. Getting that wrong means the ApplicationSet controller renders nothing.

I've found the accuracy extends to other complex CRDs like cert-manager's `ClusterIssuer` or Istio `VirtualService`. Profound will correctly structure a `solvers` array for a DNS01 challenge or a `mirror` policy block, where other tools often default to a generic map.

That missing `directories` spec is the exact kind of failure that derails automation. When the generator has no matrix to iterate over, the ApplicationSet just sits there doing nothing, and the debugging cycle begins. What's worse is that the hallucinated `path` parameter would pass a basic YAML linter, so the error only surfaces at runtime.

I've documented similar issues with the `clusterDecisionResource` generator, where tools without live schema access guess incorrectly at the required `labelSelector` structure. Profound pulling the actual OpenAPI validation rules eliminates that whole class of speculative errors.

Beyond just correctness, the wrong placeholder syntax (`{{path}}` instead of `{{path.basename}}`) breaks the template's parameter mapping entirely. You're left with literal strings in the rendered manifests.

The runtime error trap is exactly why I'm skeptical of paying for "pro" tiers that still get the fundamentals wrong. You're paying for a bot that writes plausible nonsense.

But pulling live schemas sounds like a double-edged sword. What happens when your cluster's API server is unreachable, or you're drafting manifests for a cluster you haven't built yet? Profound's killer feature becomes a blocker, and you're back to guessing or waiting on support. It feels like swapping one dependency for another.

And let's be honest, a tool that can't handle a simple placeholder syntax without live access is kind of embarrassing, isn't it?

Live schema dependency is a real operational risk. Offline mode or cached schemas are non-negotiable. Good tools handle both.

But the core argument is wrong. The embarrassing part isn't needing live access, it's shipping a tool that confidently hallucinates non-existent fields and then charging for it. That's not a "pro" tier, it's a liability.

If you're drafting for a cluster that doesn't exist, you should be using a known-good schema from a similar environment or a spec document. Not guessing. The tradeoff is clear: a tool that's sometimes blocked vs a tool that's always wrong.

You're right to flag the operational risk, but it's a manageable one. Profound does cache schemas locally with a TTL, so temporary API server unavailability doesn't halt work. The cache is invalidated on a configured schedule, which handles most offline drafting scenarios.

The more critical point is your last one: using a known-good schema from a spec or similar environment. That's the correct pattern for greenfield clusters. A tool that guesses from static data is, as you put it, a liability. The real cost isn't the subscription fee, it's the engineering time spent debugging runtime failures from invalid manifests that passed a cursory review.

If my cluster is down, I have bigger problems than drafting manifests. I'd rather have a tool that's correct when the system is operational and uses a stale-but-accurate cache when it's not, over one that's syntactically valid but semantically wrong every single time.