The client

Our client is a leading French digital bank and consumer finance provider, serving millions of customers with credit products, split payments, and financing solutions. As part of a major modernization initiative, the bank runs its core credit operations on Basikon, an API-first, cloud-native SaaS platform for credit and leasing management.

With customer-facing journeys like credit applications, document submission, and payment processing all flowing through APIs, performance is not a nice-to-have. It is a direct driver of conversion, compliance, and customer trust.

The challenge

The bank's engineering teams shipped frequently, but had no systematic way to answer a critical question: did this release make our APIs slower?

  • No performance baseline. API response times were not tracked release-over-release, so regressions surfaced only when customers felt them.
  • Business-critical API surface. Registration, document upload, credit applications, repayment schedules, installments, and payments: every degraded endpoint translated directly into lost applications and revenue.
  • Complex third-party integration. Core credit workflows depended on integrations with the Basikon platform, meaning performance issues could originate on either side of the integration boundary and needed to be pinpointed quickly.
  • Manual, ad-hoc testing. Load tests were run sporadically and by hand, with no repeatable process tied to the release cycle.
  • Limited failure visibility. When APIs misbehaved under load, error details were lost. There was no durable record of what failed, with which payloads, and when.

    • The bank needed performance testing delivered as a continuous, automated service, woven into their CI/CD pipeline rather than bolted on as an occasional exercise.

    Engagement scope

    Looming Tech delivered end-to-end performance engineering as a managed service:

  • API performance and load test suite covering the full credit lifecycle
  • CI/CD-integrated test execution on Kubernetes
  • Monitoring and regression detection dashboards
  • Data-driven functional validation of API contracts
  • Automated error logging and diagnostics

    • The engagement was staffed by a focused team of k6 performance test engineers, QA automation engineers, a DevOps engineer, and a project manager.

    Tech stack

  • Load and performance testing: k6 (Grafana k6)
  • Monitoring and dashboards: Grafana, Dynatrace
  • CI/CD: GitLab CI/CD pipelines
  • Test execution: Kubernetes pods (containerized test runners)
  • Error logging and diagnostics: MongoDB (k6 integration)
  • Target platform: REST APIs, Basikon credit and leasing platform integrations

    • How we built it

    Performance test suite for the full credit lifecycle

    We designed k6 test scenarios covering every business-critical API in the customer journey:

  • Customer registration and onboarding flows
  • Document upload endpoints handling files under concurrent load
  • Credit application submission and processing
  • Repayment schedules and installments calculation and retrieval
  • Payment processing APIs

    • Each scenario modeled realistic traffic patterns: ramp-ups, sustained load, and spike profiles, so results reflected how the APIs behave under genuine production-like conditions, including the round-trips to the Basikon platform that sit at the heart of the credit workflows.

    CI/CD-integrated execution on Kubernetes

    Performance testing only delivers value when it runs continuously. We integrated the entire suite into the bank's GitLab CI/CD pipelines:

  • Tests executed in dedicated Kubernetes pods, spun up on demand for each run
  • Runs triggered automatically after every deployment, turning performance validation into a standard release gate
  • Isolated, reproducible test environments ensured results were comparable run-over-run

    • Regression detection and monitoring

    Raw numbers are meaningless without context. We built the observability layer that turned test output into decisions:

  • Grafana dashboards visualizing response times, throughput, and error rates per API and per release
  • Dynatrace correlation to see how load translated into resource consumption and traces on the platform side
  • Release-over-release comparison: every post-deploy run was checked against previous baselines, so a slower endpoint was flagged immediately, not discovered by customers weeks later

    • Performance tests as functional validation

    We extended the k6 suites beyond load generation into data-driven functional testing. For APIs accepting complex inputs, such as application forms with multiple data types, the suites exercised the full range of valid and invalid values, verifying both correctness and performance in a single pass. One test investment, two quality signals.

    Automated error diagnostics with MongoDB

    To eliminate "it failed but we don't know why," we integrated k6 with MongoDB to persist detailed error logs from every run. Whenever an API returned errors under load, the failing requests, payloads, and responses were captured automatically, giving developers an immediate, queryable trail for root-cause analysis instead of trying to reproduce failures by hand.

    Outcome and impact

    Through this engagement, the bank achieved:

  • Continuous performance assurance: every deployment is automatically validated against performance baselines before issues can reach customers
  • Early regression detection: slowdowns in business-critical APIs, from applications to payments and installments, are caught within the release cycle, not in production
  • Full credit-lifecycle coverage: from registration to repayment, every customer-facing API and its Basikon integration is under systematic test
  • Faster root-cause analysis: persistent error logging in MongoDB turned opaque failures into queryable diagnostics
  • Double-duty test investment: the same suites validate both performance and functional correctness of API contracts
  • Repeatable, scalable process: Kubernetes-based execution means test capacity scales on demand with zero manual setup

    • Summary

    By delivering performance and load testing as a fully automated, CI/CD-integrated service, Looming Tech gave a leading French consumer finance provider something most engineering organizations lack: a reliable, continuous answer to "is this release fast enough to ship?"

    This engagement demonstrates how modern tooling — k6, Grafana, Dynatrace, and Kubernetes — combined with disciplined test engineering can turn performance from an occasional fire drill into a routine, automated quality gate.

    Whether you need load testing for high-stakes financial APIs, CI/CD-integrated performance gates, or full test automation as a service, our team brings deep expertise in performance engineering. Get in touch and let's make sure your next release is your fastest one.

    100% of deployments automatically load-tested