Back to all case studies
CASE STUDY Security Testing

How We Turned a Vague Request to “Sort Out Security” Into a Measurable Code and Infrastructure Scanning Process for a UK Insurtech

A UK insurtech building applications for insurers and brokers came to us with a general request to “sort out security”. We translated it into a first, measurable step: code and infrastructure scanning built into the development process. Within 6 weeks the process was running, critical and high vulnerabilities were fixed within 2 months, and no new ones appeared over the following 3 months.

Read the Full Story
CLIENT CONTEXT

Who the client is and the challenge they brought to us

Industry

The client is a UK insurtech that builds applications for insurers and insurance intermediaries. The applications process personal data and policy data of end customers. The environment runs in the public cloud, and new versions reach production frequently.

The Challenge

The client wanted someone to “sort out security” but could not say exactly what it needed. The need came from the regulatory expectations of the insurance sector, insurers’ requirements for technology suppliers, data protection and reputation. Until then, testing had been occasional, and vulnerabilities surfaced just before or after a release.

What Was at Stake

A leak of policy data would mean losing the trust of the insurers on which the client’s whole business depends. Vulnerabilities found at the last minute delayed releases and frustrated the product team. Insurers were increasingly asking for evidence of regular testing in supplier assessments.

OUR APPROACH

6 weeks to a running process, followed by ongoing care

  1. From a General Request to a First Step

    We started by talking with the board and product team about what worried them: customer data leaks, delayed releases and questions from insurers. On that basis we proposed the first step offering the most value at this stage: systematic scanning built into development, rather than a one-off penetration test.

  2. A Pipeline With SAST, DAST and SCA

    We defined a pipeline with static code analysis (SAST), testing of the running application (DAST) and analysis of third-party libraries (SCA). Critical and high vulnerabilities stop a deployment before it reaches production. Security became part of developers’ daily work rather than a gate at the end.

  3. Tool Selection Against the Client’s Criteria

    We compared several code analysis and application testing tools against the client’s programming languages and technology stack, integration with the existing CI/CD, false positive rates and licence cost. The decision rested on the comparison, not on a tool’s popularity.

  4. Configuration and the Whole Infrastructure

    We tuned the rules to the client’s code and reduced false positives so developers would trust the results instead of ignoring them. Scanning also covered the cloud environment, containers and infrastructure-as-code configuration.

  5. Fixing Vulnerabilities in Context

    We introduced scoring tailored to the client’s context: the same vulnerability has one priority in an application handling policy data and another in an internal tool. The team fixed first what genuinely threatened customers and reputation. Dozens of critical and high vulnerabilities were fixed within 2 months.

  6. Continuous Care of the Process

    New applications, services and environments are brought into scanning as they appear, without a separate project. For 3 months after launch, no new critical or high vulnerability appeared. The client shows insurers its regular scanning reports as evidence in supplier assessments.

RESULTS & SUCCESS METRICS

Concrete figures showing the impact of the engagement

  • 6 weeks to a running scanning process
  • 2 months to fix critical and high vulnerabilities
  • 0 new critical or high vulnerabilities over 3 months
  • ~60% fewer false positives after rule tuning
  • 3 types of analysis in the pipeline: SAST, DAST, SCA
  • 100% of code and infrastructure covered by scanning

The board turned a general concern into a process with a measurable result and has evidence for insurers. Financially, vulnerabilities are fixed during development, when a fix is cheapest, rather than after release. The product team no longer loses releases at the last minute, and scoring tells it what to fix first.

What Our Client Says

Feedback from the client's team after the engagement

"Security used to feel like a brake at the end of the sprint: someone found a problem just before release and everything slipped. Now vulnerabilities show up while we work, when a fix takes moments. Scoring told us what to fix first, and it is tailored to our applications rather than a generic scale from a tool. There are so few false positives that the team takes the results seriously. We release faster than before scanning was introduced, not slower."

Product Manager UK insurtech company

"We came with a general need because we did not know where to start. Patronusec turned it into a concrete plan with a first step we could measure. Today, when an insurer asks about the security of our applications, we show reports from regular scanning, not statements. That gives us calm in customer conversations and real protection for our reputation. Instead of a promise of security, we have a process that works every day."

Area Director UK insurtech company
Frequently Asked Questions

Answers to the questions people in a similar position ask us

With a conversation about what worries it, and a first step that gives a measurable result. For software companies, this is often scanning built into the CI/CD process. It delivers quick results and data for later decisions, such as when to commission penetration tests.

SAST analyses source code without running the application, DAST tests the running application from the outside, and SCA checks for vulnerabilities in third-party libraries. Each finds different problems, so they work best together. Built into the pipeline, they catch vulnerabilities before deployment.

By tuning rules to the code and technology stack and introducing scoring that reflects the application’s context. In this project, false positives fell by around 60%. As a result, developers trust the findings rather than ignoring them.
START THE CONVERSATION

Facing a Similar Challenge?

Want vulnerabilities to surface during development, not after release? Let’s talk about building vulnerability scanning into your delivery process.

Free 20-min scoping call
No obligation
Senior assessor not sales