Case study

CloudStack Canvas: built, run, and retired on purpose.

CloudStack Canvas was a software product of our own, offered online: a user drew a cloud system as a diagram, and it produced the code to build that system. We designed it, deployed it and operated it on AWS. We retired it because AI coding agents had made its core job a commodity and keeping it running would have cost more than it could earn. This page is what we would want to read about any firm asking us to trust it with a build.

The facts
What it was
A multi-tenant SaaS product: draw an AWS architecture on a canvas, get infrastructure code that deploys.
In production
36 production deploys
Stack
Next.js and React, PostgreSQL, Stripe billing, organizations and seats, on AWS: ECS Fargate, RDS, an application load balancer, infrastructure as code throughout
Engine
50 AWS service types certified against the CloudFormation linter and real deploys; about 8,900 automated tests; 150 deploy-time rules learned from templates that linted clean and still failed
Retired
On purpose, when AI coding agents made its core job a commodity
What it did

A user drew an architecture (VPCs, subnets, databases, queues, functions, load balancers) on a canvas that understood how AWS services connect. The engine turned the drawing into CloudFormation that deployed, with the IAM permissions derived from the connections rather than written by hand. Teams had organizations, seats and subscription billing. An import lane read existing templates back onto the canvas.

The hard part was never the drawing. It was the 150 rules that separate a template that passes the linter from one that actually deploys, each learned from a real failure in a real account. That knowledge did not retire with the product; it is in every environment we build now.

What it taught us

Four things we now apply to every client.

Generation is a commodity now. Judgment is not.

By the time we retired it, a coding agent with a model behind it could produce and deploy the same infrastructure code faster than a diagram tool, and with fewer defects. What the agent did not know was whether the design was right for the client, what the auditor would ask, and which of five options paid back. That is the work we sell.

Count before you commit, and count again before you continue.

We set a runway with a number to hit. When the number was out of reach for a reason that was not going to change, we stopped. The same rule applies to every build we scope: a baseline first, a checkpoint with a stop condition, and no sunk-cost arguments.

Running something is different from building it.

Thirty-six production deploys, a database outage that we recovered from by restoring and replaying migrations, a secrets rotation, a billing webhook that lied to us once. Every practice on this site (identity for every user, logging for every action, backups you can restore from) is one we needed ourselves.

The handover list is what we would have wanted.

Source code, infrastructure definitions, a runbook and the account in the owner’s name. When we retired the product we took a final database snapshot, scaled the service to zero and kept the domain, in that order. A client leaving us should have the same clean exit.

What this means for your project

We have made the buy-or-build call about our own product.

When a discovery sprint ends with "buy the subscription that exists," that advice comes from people who retired their own software for the same reason. When a sprint ends with "build," it comes with a baseline, a checkpoint and a stop condition, because we have used all three. And when we hand over an application, the list is the one we wrote for ourselves: code, infrastructure, runbook, account.

Tell us what you are deciding.

Buy, build or connect what you have. A discovery sprint answers it in writing, and we reply within one business day.