A security scan of your own code, with proof for every finding

Secrets in the code, dependencies with known flaws, risky patterns and configuration that opens too much. Our scan reads your repository, with read access only, and points to the file and line of every finding.

Updated

What the scan looks for

A fixed set of well-known open-source scanners, each at a fixed version, so the same code always gives the same result. No AI is involved in this step.

  • Passwords, keys and tokens in the code, and in the history of your default branch: including what was removed long ago
  • Dependencies with a known vulnerability, and packages known to be malicious, from your lockfiles
  • Risky patterns in Python, JavaScript and TypeScript, such as SQL built from loose text or input that ends up in a shell command
  • Dockerfiles and the configuration of Kubernetes, Helm and Terraform
  • Runtimes and frameworks that no longer get security updates

What you get back

For every finding: what it is, where it is, how serious it is and what you can do about it. You see it in your workspace in layers: the traffic light for the board, what it means for product and operations, and for developers the file and the line.

A secret we find is never shown and never sent to an AI model. We advise you to replace it, even when it only remains in the history.

What the scan doesn't do

The scan only reads. It doesn't run your code, doesn't touch your servers or your database, and changes nothing in your repository. We don't attack or penetration-test your running site: this is a look into the code you can repeat on every new version.

Why on every new version

With AI, new code arrives faster, and so does a new dependency or a forgotten key. That's why the scan belongs with every new version of your code, not with an audit once a year. With continuous checks it runs again as soon as there is new code.

Questions we often get

Which scanners do you use?

Well-known open-source scanners: gitleaks for secrets, osv-scanner for vulnerable and malicious dependencies, semgrep and bandit for risky code, and hadolint and trivy for Dockerfiles and configuration. Each at a fixed version.

Is this a penetration test?

No. A penetration test attacks your running application. We read the code and the configuration. That finds different things, and it can run again on every new version.

Couldn't we run those scanners ourselves?

You could, and many teams do part of it. We run them at a fixed version, put the results with their evidence in one view for every role, and set them next to your tests, your documentation and your architecture.

What happens to a secret you find?

We report where it is, without showing the value, and advise you to replace it. It never goes to an AI model.

Sign up for the pilot

The pilot is by invitation. Sign up, we check whether your application fits and email you. You connect your repository with read access only, the first check starts by itself, you see what is checked and what is proven, and then we ask what it is worth to you. Have a question first? Ask it in the message below.

Our team

Reads every sign-up and every question

Our team reads what you send and answers by email. A conversation only happens if you ask for one: with the people who do the work, not a salesperson.

We only use your details to respond to your sign-up. The website doesn't keep your request.