Journey Lanes

Product

One model of your product’s journeys, from code to production

Journey Lanes builds a catalog from your code and API descriptions, turns user journeys into flows with a lane per role, and runs them against a mock or your environments: by hand, on an interval, and after every deploy. The same flows serve journey testing, API flow testing, chain testing across services, access audits and synthetic monitoring.

Sources are scanned into flows, which run against the mock backend or a live environment, are checked, and keep running under monitoring and from CI. Code, OpenAPI, GraphQL gRPC, reflection Scan and catalog Flow per role Mock backend Live environment Checks Monitoring Deploy hook

Sources and scanning

Endpoints, records, roles and pages read from your repositories and API descriptions, scanned again every day.

  • GitHub, GitLab and Bitbucket, connected or by token
  • OpenAPI 3.0 and 3.1, Swagger 2.0, GraphQL, gRPC
  • Frameworks from Express to Spring Boot read from source
  • API changes found by a daily rescan

Flows and AI

Journeys drawn from plain language, tours per role, and steps set up from the code behind them.

  • Descriptions in English, Dutch and German
  • Tours of what one role may and may not do
  • Help me: a call set up from its code
  • Explain this failure on a failed step

Mock backend

A backend per project, built from your entities, with tokens and data scoped per role and tenant.

  • Keycloak-shaped sign-in
  • REST, GraphQL and gRPC answers
  • The access policy enforced
  • Mock data per flow, with starting data

Live environments

The same flows against your test, acceptance or production environments, signed in like your users.

  • Sign-in presets for common identity providers
  • Two-factor codes, passkeys and single sign-on
  • Uploads, waits, retries and clean-up steps
  • Writes and load tests off until you allow them

Checks, audits and load tests

Assertions on every step, an access audit across roles and tenants, and load tests that check what landed.

  • Status, timing and field checks
  • Cross-tenant and unauthenticated probes
  • Error rate, p95 and integrity after load
  • Two environments compared step by step

Monitoring and alerts

Flows on an interval, with one alert when they start failing and one when they recover.

  • Pass rate and p50/p95 per flow
  • Email, Microsoft Teams, Slack and webhooks
  • Alerts for API changes that break flows
  • Alerts when a saved sign-in stops working

CI and exports

Flows after every deploy from your pipeline, and flows out of Journey Lanes as Playwright, Postman or flow files.

  • A deploy hook with its own token
  • GitHub commit statuses
  • Playwright tests and Postman collections
  • Flow files that import again

Relay agent

For environments and code hosts behind a firewall or VPN: a small agent in your network that dials out and calls only the hosts you list.

  • Outbound WebSocket on port 443
  • Allow list and read-only mode on your side

Integrations

Code hosts, API description formats, frameworks, identity providers, alert channels and CI, with how each connects.

  • One table per kind
  • What needs a token, what connects with a click

Organizations, projects and roles

Organizations hold projects, the people who work on them, code host connections and relay agents. In a project, viewers see flows, runs and audits; editors also add code, edit and run flows; owners also manage members, environments and alert channels. Invites go by email, and people outside a project get a plain “not found”.

The people who run this installation get no access to your projects unless your organization invites them.

Repository scanning
What the scanners read, code host connections and API descriptions.
Flows from a description
Lanes per role, steps that call scanned endpoints, checks the description promises.
Tours per role
Everything one role may do, plus a few things it may not.
Building by hand
The endpoints menu, bodies, references and undo.
Help me
A call set up from the code behind it.
Saved roles and reuse
Sign-ins set up once, steps copied between flows.
Mock backend
OIDC sign-in, REST, GraphQL and gRPC over your entities.
Runs and step checks
What a run does, step by step.
Live environments
Sign-in types, presets and the opt-ins for writes and load.
Flows that make their own data
Run values, test inboxes, accounts made during the run.
Monitoring and alerts
Intervals, channels and when alerts go out.
Deploy checks
Flows after every deploy, with a commit status.
Load tests
One step repeated, with integrity checks afterwards.
Access audit
Every role against every endpoint and tenant.

See it on your own code

Connect a repository or add an OpenAPI document, and describe the journey you worry about most.

Create an account See how it works