How is Traverse different from microservices?
They solve different problems. Microservices decompose large systems into independently deployable network services. Traverse runs business logic in-process as a WASM binary, with no network hop involved.
With microservices, you split a monolith into separate services that communicate over HTTP or a message bus. Each service owns its data and can be deployed independently. The tradeoff is operational complexity and latency at every service boundary.
With Traverse, you define a business capability once as a WASM binary governed by a contract. That binary runs wherever you load it: browser, edge worker, cloud function, AI pipeline. No separate process. No network call. No cold start.
| Dimension | Microservices | Traverse |
|---|---|---|
| Communication model | Network (HTTP, gRPC, message bus) | In-process function call |
| Deployment unit | Independently deployed service with its own process | WASM binary loaded into the host runtime |
| Contracts | API specs (OpenAPI, Protobuf) documented separately | Machine-readable contract enforced at runtime |
| Audit trail | Distributed logs across services | Structured trace artifact per execution |
| Latency | Network round-trip per call | Microseconds, in-process |
| Portability | Service runs on a specific host or container | Same binary runs on browser, edge, and cloud |
When to use microservices
Use microservices when you need independent scaling, independent deployments, team autonomy, or strong data isolation. They are the right answer for breaking up a large monolith.
When to use Traverse
Use Traverse when you need the same business logic to run correctly in multiple environments. Pricing rules. Eligibility checks. Validation logic. Rules that today live slightly differently in the browser, the API, and the billing worker.
They compose
Traverse and microservices are not alternatives. Your microservice can use Traverse internally to execute governed business logic. The service handles the network boundary. Traverse handles the rule execution inside it. That combination gives you independent deployment and governed, portable logic at the same time.
See the full comparison at Traverse vs Microservices.