pinpole was built by cloud engineers who spent years designing infrastructure on instinct, deploying on hope, and discovering the real cost after the fact. Every post-mortem looked the same. We always said the same thing. We should have caught that earlier.
Between 2014 and 2024, our founding team collectively designed and deployed cloud infrastructure for dozens of companies — from early Series A startups with a single AWS account to multi-cloud platforms running across three providers simultaneously. We used every tool in the standard stack: draw.io for diagrams, the AWS pricing calculator for cost estimates, Terraform for deployment, and k6 or Locust for load testing once infrastructure was live.
Every single time, the workflow looked the same. You sketch the architecture. You price it manually, service by service, vendor calculator by vendor calculator. You ship it. And then the real world arrives — a traffic spike, a misconfigured concurrency limit, an RDS instance that should have been Aurora Serverless, a NAT Gateway that turns out to cost more than the workload it's routing. You find out after the fact.
The tools weren't bad. draw.io is fine. The AWS pricing calculator is fine. k6 is excellent. But they were disconnected. Your diagram didn't know about your cost model. Your cost model didn't know about your traffic pattern. Your load test didn't run until the infrastructure existed. There was no single moment where you could see all three together — before you committed.
We always thought the same thing after every incident, every overrun, every re-architecture sprint: there should be a way to see this coming.
A media platform's read pattern changed at launch when users hit "refresh" on a leaderboard every three seconds instead of every thirty. The pricing model had assumed the calmer pattern. The architecture had no DAX layer. Month one: $22,000 over budget. Post-mortem note: "Should have modelled the pessimistic read frequency."
cost overrunA monolith broke into seventeen services. Each was load tested in isolation. Under coordinated load, the inter-service fan-out produced a timeout cascade that took down the checkout flow every time a flash sale hit. The architecture diagram was beautiful. Nobody had ever run a simulation through it as a system.
latency cascadeA Series B company moved data pipelines to GCP while keeping APIs on AWS and identity on Azure. Three teams. Three vendor calculators. Zero unified view. Month one cloud bill was 40% above the combined forecast. Each team's estimate had been individually correct. Nobody had modelled the egress traffic between clouds.
egress blindspotDuring a post-mortem for a Lambda cold start incident, one of our co-founders said it out loud for the hundredth time. This time someone wrote it on the whiteboard and circled it. We started prototyping two weeks later. The question wasn't "is this technically possible?" — it was "why doesn't this exist yet?"
the ideaThe first working prototype let you drop AWS nodes on a canvas, connect them, and run a synthetic RPS sweep. It was rough. The cost model was incomplete. But the moment you could watch a Lambda node turn amber at 1,200 RPS and see a cost projection update in real time — we knew we had something. Every engineer we showed it to said the same thing: "I wish I'd had this two years ago."
first working buildWe expanded the canvas to AWS, Azure, and GCP. Added AI-driven architecture recommendations trained on production incident patterns. Built deploy-to-cloud that converts a validated canvas into Terraform. Closed our first paying teams. Now every engineer who uses pinpole gets to skip the post-mortem we wrote ourselves.
pinpole today"The defining characteristic of the engineer we built this for isn't their job title. It's a specific kind of scar: they've deployed infrastructure that turned out to be wrong, expensive to fix, and embarrassing to explain. They're not looking for another diagram tool. They're looking for a way to catch that mistake before it happens."
— pinpole founding teamEvery feature we ship must make pre-deployment validation more complete, more accurate, or more accessible. This is the core thesis and we don't dilute it.
We built pinpole on the same patterns we ran in production — serverless fan-outs, multi-region failover, cloud-native data pipelines. Toy examples don't ship.
Cost estimation isn't a feature. It's infrastructure honesty. Architecture decisions have financial consequences and engineers deserve to see them before deployment.
89% of growth-stage companies run multi-cloud. We don't favour a provider. AWS, Azure, and GCP sit on the same canvas with the same simulation fidelity.
Infrastructure decisions made on guesswork are a systems failure, not a personal one. pinpole exists to give engineers the data to make decisions they can defend.
We show you what will happen. We surface the risks. We quantify the cost. What you do with that information is yours. pinpole advises. It doesn't decide.
Twelve years in cloud infrastructure — AWS Solutions Architect Professional, GCP Professional Cloud Architect. Previously Staff Engineer at two Series B fintech companies. Built and operated cloud platforms that processed $2B in annual transaction volume. Has been in more post-mortems than he can count, and started writing pinpole's first prototype after one too many cost overruns that should have been preventable.
Ten years building distributed systems simulation and load testing tooling. Led platform engineering at a Series C SaaS company through a 40× traffic scale event. Designed pinpole's simulation engine from first principles — the goal was a model that generates the same recommendations a senior architect would give after reviewing the traffic data, not a toy.
Design your architecture on the canvas. Run it against real traffic patterns — steady state, spike, flash sale. See the bottlenecks, the cost, and the risks before a single dollar is spent on provisioned resources. Free tier. No credit card.