The FlowGuardians Suite
AccessGuard
Available nowIncluded in FlowGuard

Check that each user can do only what they should

One forgotten access rule can let a basic user open an admin screen or see another customer's records. Your build stays green, because the tests sign in as one user who can do everything.

AccessGuard reads the access rules in your code, runs the same journey as each of your test logins, and shows where the running application allowed or refused something the code says it should not.

Why access mistakes reach production

Code review sees the rules and tests see the behaviour, but nothing compares the two.

The code says one thing

A controller is marked for administrators only. A code review checks that the marking is there, but nobody checks that the running application actually refuses everyone else.

Tests run as one user

Most end-to-end tests sign in with a single account, usually one that can do everything. A screen that is wrongly open to a basic user passes every one of them.

Nobody knows what was checked

When an auditor asks which roles were tested against which features, the answer is usually a spreadsheet someone filled in by hand months ago.

How it works

FlowGuard already scans your code and runs your journeys. AccessGuard adds the logins and the comparison.

01

Read the rules in your code

During the codebase scan, AccessGuard lists every permission your back end declares: the roles and policies on each ASP.NET Core endpoint, plus your own permission attributes once you tell it how they are written.

Each permission is linked to the endpoints it protects.

02

Run the journey as each login

For each environment you add the logins to test with: a username, a password kept in FlowGuard's secret store, and the role that login has. A suite then runs one journey as each login side by side, and you mark whether each should get through or be refused.

The same journey, the same steps, different users.

03

Compare what happened

Every run already records the requests the browser sent and what the server answered. AccessGuard matches those requests to the endpoints from step 1 and compares, for each login, what it reached with what it should have reached.

Every finding names the endpoints behind it.

What it finds

Each finding is judged on the whole run, with the endpoints listed as evidence, so a shared call like the sign-in page does not raise a finding on its own.

Let in when it should not be

  • A login that should be refused completed the whole journey
  • An endpoint that requires one role answered successfully to a run signed in with a different role

Refused when it should not be

  • A login that should get through was refused by the server (HTTP 403)
  • The server refused a request on an endpoint where the code declares no access rule, so the rule lives somewhere the team may not know about

Never tested

  • A permission your code declares that no journey has ever exercised
  • How many of your application's permissions any journey has reached, so coverage is a counted number

An Access page for each application

When an auditor asks which roles were tested against which features, this page is the answer, built from real runs.

Permissions by login

For each test login and environment: which permissions its journeys reached, which were refused, and which it never touched.

Permissions by module

The same evidence grouped by the parts of your application, so each team can see its own area.

Findings on the run

Each suite run shows its logins as columns, with the endpoints each one reached and any finding marked on the row.

What was read

Every answer says which sources it used: the code, the runs, or both. If no journey has run yet, the page says nothing has been checked rather than showing a clean result.

What it does not claim

These are the limits of what AccessGuard checks today.

  • It reads access rules from ASP.NET Core (.NET) back ends today. Other frameworks need their own reader, which we add per customer.
  • It only knows what your journeys touch. A permission no journey reaches is reported as untested, never as safe.
  • A 401 (not signed in) is not counted as an access refusal. Only a 403 (signed in, not allowed) is.
  • It never tries to break in, and it never changes your users, roles or permissions. It signs in with the logins you give it and records what happens.
  • It needs a codebase scan of the application before it can link requests to permissions.

Where it runs

AccessGuard is part of FlowGuard, so it runs wherever your FlowGuard journeys run.

Part of FlowGuard

AccessGuard uses FlowGuard's codebase scan, journeys and runs. There is nothing extra to install, and its pages sit next to your flows.

Passwords stay in the vault

Test logins point at secrets in FlowGuard's secret store. Flows never contain the password itself.

Runs where FlowGuard runs

Journeys run on our cloud runners or on the agent inside your own network, so applications that are not on the internet can be checked too.

Included in FlowGuard

Try it on your own application

If you'd like to try it, create a free workspace, scan your code and add two test logins with different roles. If you would rather see it on a call first, book a demo.