Overview

A backend application may work correctly during normal development and functional testing, but its real behavior becomes clearer when multiple requests arrive simultaneously.
As part of my ShopEase e-commerce backend project, I performed high-concurrency load testing using k6 to evaluate how the application handled increasing request loads.
The objective was to simulate concurrent users, generate a significant number of HTTP requests, and observe whether the backend could continue responding successfully during the test execution.
This testing milestone helped me move beyond checking whether individual APIs work and start evaluating backend behavior under concurrent traffic.
Project Architecture
ShopEase is a full-stack e-commerce application built around a Java and Spring Boot backend.
The testing environment used a containerized backend setup involving:
Java & Spring Boot: Backend application and REST API processing.
MySQL: Relational database for application data.
Redis: Caching layer.
Docker: Containerized infrastructure.
k6: Load testing and traffic simulation.
The purpose of this test was to evaluate the backend under concurrent request execution within this environment.
Why High-Concurrency Testing?
Functional testing generally verifies whether an API returns the expected response for a given request.
However, it does not necessarily reveal how the application behaves when hundreds of virtual users send requests at the same time.
Some important questions I wanted to investigate were:
Can the backend continue processing requests as concurrency increases?
Does the application return successful HTTP responses during the test?
Are there dropped connections or server crashes?
Can the application handle a substantial number of requests during a short testing window?
These questions motivated the use of k6 for load testing.
Load Testing with k6
I used k6 to simulate concurrent virtual users against the ShopEase backend.
The test was configured with a gradual ramp-up period, allowing the number of virtual users to increase rather than immediately applying the maximum load.
Test Configuration
Parameter
Test Result
Testing Tool
k6
Maximum Virtual Users
1,000
Ramp-up Duration
3 minutes
Total Requests
15,946+
Reported Success Rate
100%
HTTP Response
200 OK
Reported Dropped Connections
0
Server Crashes
0
The test reached up to 1,000 concurrent Virtual Users and generated more than 15,946 requests during execution.
Test Results
The observed results were:
- Concurrent Virtual Users
The test simulated up to 1,000 virtual users, creating concurrent request traffic against the backend.
- Request Processing
More than 15,946 requests were processed during the test execution.
- Successful HTTP Responses
The reported success rate was 100%, with successful HTTP 200 responses.
- Connection Stability
No dropped connections were reported during the execution.
- Server Stability
No server crashes were observed during the test.
These results provided a useful indication of how the current ShopEase setup behaved under the tested workload.
What I Learned
This exercise helped me understand that performance testing involves more than simply sending a large number of requests.
Some important concepts I explored include:
Virtual Users (VUs): How load testing tools simulate concurrent users.
Concurrency: How multiple requests can be processed during overlapping execution periods.
Ramp-up: Why gradually increasing load is useful when observing application behavior.
HTTP Success Rate: How successful responses can be tracked during a test.
Backend Resilience: Why server stability and connection handling matter under load.
Performance Testing: Why functional correctness and performance behavior need separate evaluation.
It also reinforced the importance of measuring application behavior instead of assuming that a backend can handle increased traffic simply because its APIs work correctly.
Important Scope and Limitations
The results represent one load-testing execution in the tested environment.
A 100% reported success rate does not automatically establish production readiness or guarantee that the application can sustain 1,000 concurrent users indefinitely.
A more complete performance evaluation would also require additional measurements, including:
Average response time.
p90 and p95 latency.
p99 latency.
Requests per second (RPS).
CPU and memory utilization.
JVM performance and garbage collection.
Database connection pool utilization.
MySQL query performance.
Redis behavior under increasing load.
These measurements would help identify bottlenecks and provide a more complete picture of the system's performance.
What's Next?
The next stage of performance testing for ShopEase will focus on deeper analysis rather than only request success.
Planned areas of investigation include:
Response-time distribution and latency analysis.
Database connection pool monitoring.
JVM resource utilization.
Identifying potential bottlenecks.
Longer-duration stress and endurance testing.
Comparing performance across different load profiles.
Conclusion
This load-testing exercise was an important step in the development of ShopEase.
Using k6, I simulated up to 1,000 concurrent Virtual Users and processed 15,946+ requests, with a reported 100% success rate and no reported dropped connections or server crashes during the test.
More importantly, this exercise helped me understand how to evaluate backend behavior under concurrent workloads and why measurable performance testing is an essential part of backend engineering.
Project: ShopEase
Backend: https://github.com/Shitanshu686/shopping-app-backend
Frontend: https://github.com/Shitanshu686/shopping-app

Top comments (0)