Coming soon · private beta 2026

See where your architecture breaks before you build it.

Draw the system on a canvas, push traffic through it, and watch the bottleneck appear. Deterministic, explainable, no infrastructure required.

One email when the beta opens.

checkout-platform

production · eu-west-1

Clients not set

HTTPS

app tier

api-gateway pool 64

async

payments-jobs workers 8

reads

postgres conns 40

model draft · not run seed 0x5F3A

A model is four things.

No hidden defaults in the engine. A result is only ever as strong as assumptions you can see and argue with.

node: A service, worker, queue or datastore, with the limits it really has.
path: The route a request takes, including the calls that fan out.
traffic: Arrival rate and request mix over the length of the run.
seed: The number that makes the run repeatable, down to the millisecond.

checkout.model draft contract

service api-gateway
  concurrency   64
  service_time  p50 8ms  p99 40ms
  timeout       250ms
  retries       1

queue payments-jobs
  workers       8
  max_depth     5000

datastore postgres-primary
  connections   40
  service_time  p50 3ms   p99 20ms

traffic checkout
  arrival       2000 rps for 60s
  path          gateway -> payments
                        -> postgres

seed 0x5F3A

Three runs, one decision.

A sale is coming and traffic will be five times a normal day. Which part gives out first, and what is the cheapest fix?

run 001 passing

Baseline traffic

LOAD: 400 rps
P99: 74 ms
WORST NODE: db 0.36

Comfortable everywhere, and it tells you nothing about the headroom left.

run 002 failing

Five times the traffic

LOAD: 2 000 rps
P99: 812 ms
WORST NODE: db 0.98

The database saturates first. Gateway timeouts fire and 4.1 percent of requests drop.

run 003 passing

One replica, smaller pool

LOAD: 2 000 rps
P99: 96 ms
WORST NODE: db 0.61

Reads move to a replica and the pool stops queueing work it cannot finish.

The answer was not more application servers. It was one read replica and a smaller pool, found in three runs instead of one incident.

BACKEND ENGINEERS

Sanity check a design before the sprint starts, and find out whether the timeout you picked saves you or drops traffic.

ARCHITECTS AND LEADS

Bring a reproducible run to the design review instead of an opinion.

PEOPLE LEARNING THIS

Backpressure and cascading failure are easier to believe once you have watched them happen on your own diagram.

A load test needs the system. A simulation only needs the diagram.

Before anything exists

Answer capacity questions on day one, from a diagram, with no environment to stand up.

Deterministic

Same model and seed give the same numbers, so a result can be diffed and reviewed.

Explainable

Every number traces back to an assumption you set, not a black box.

Macroscape does not replace production load testing. It is the cheap pass you make first.

Where it stands today.

IN PROGRESS

Simulation contract

Model format for nodes, paths and traffic
The metrics every run returns
Determinism and seeding rules

Deterministic engine over the contract
Queues, concurrency, timeouts, retries
Reproducible run reports

LATER

Visual editor

Canvas topology builder
Side by side run comparison
Templates for common patterns

Built in the open. Follow along.

The simulation contract, the engine and the open questions all live on GitHub.

View on GitHub