Spring Boot File Upload Performance Test: Real Load Test Results at 7,500 RPM
We benchmarked Spring Boot file upload performance using FiloraFS-Lite under increasing traffic up to 7,500 RPM to measure latency, throughput, CPU usage, memory behavior, and real scalability limits.
Quick Answer
The Spring Boot file upload system stayed stable up to 7,500 RPM with zero HTTP failures, but latency degraded sharply above roughly 6,300 RPM. The biggest bottleneck was large MP4 delivery, not the API layer itself.
Backend systems often look fast during development because they are tested with small payloads and low concurrency.
Real production traffic is different.
File uploads, video downloads, concurrent requests, and bandwidth pressure expose bottlenecks very quickly.
To understand the real limits of our system, we ran multiple load tests and a full ramp test against a Spring Boot file upload system using a TypeScript load runner.
The goal was simple:
- Measure throughput under increasing load
- Track P95 latency degradation
- Monitor CPU and memory behavior
- Identify bottlenecks before production traffic does
Spring Boot File Upload Test Setup
The backend under test was Spring Boot file upload boilerplate FiloraFS-Lite , our lightweight Spring Boot file-service boilerplate designed for rapid setup and local file storage experimentation.
FiloraFS-Lite includes ready-to-use APIs for:
- File upload
- File download
- Metadata lookup
- File listing
- Delete operations
The goal was to benchmark how this boilerplate behaves under sustained and increasing traffic before introducing production-grade optimizations like object storage, CDN delivery, and distributed file serving.
The ramp test gradually increased traffic from 500 RPM to 7,500 RPM while collecting:
- P95 latency
- Actual throughput
- CPU usage
- Memory usage
- Endpoint behavior
- File-type latency
Spring Boot Load Test Summary
| Metric | Result |
|---|---|
| Total requests | 134,517 |
| Peak RPM tested | 7,500 RPM |
| Peak P95 latency | 1,878 ms |
| HTTP failures | 0 |
| Average CPU | 35.4% |
| Main bottleneck | MP4/video downloads |
Spring Boot Latency Breakdown Under Load
The system stayed comfortable during lower traffic levels.
From 500 RPM to around 5,100 RPM, the service mostly maintained P95 latency below 500 ms.
After roughly 5,700 RPM, latency began rising aggressively.
Once traffic crossed around 6,300 RPM, P95 exceeded 1 second and the user experience became visibly slow.
Practical operating zone
Based on the test results, the most practical production operating zone is roughly 5,000 to 5,500 RPM if the target P95 latency is around 500 to 600 ms.
Spring Boot Throughput Under Increasing Load
One of the strongest findings from the test was stability.
Even at high traffic levels, the backend continued responding successfully without HTTP failures.
The service survived:
- 134,000+ requests
- 200 concurrent workers
- 7,500 RPM target traffic
- mixed file workloads
That matters because many systems fail long before latency becomes the main problem.
Here, the backend degraded gradually instead of collapsing.
The Real Spring Boot Performance Bottleneck
The biggest insight from the test is that the bottleneck was not:
- Spring Boot controllers
- metadata APIs
- listing APIs
- delete operations
The real bottleneck was large MP4 file delivery.
The file-type breakdown made the problem very clear:
| File type | P95 latency | Observation |
|---|---|---|
| 4 ms | Very fast | |
| PNG | 338 ms | Moderate |
| MP4 | 1707 ms | Main bottleneck |
This is expected behavior for large media delivery.
Video files create pressure on:
- Disk IO
- Network throughput
- Buffering
- JVM memory
- Thread handling
CPU Usage During the Spring Boot Load Test
CPU usage increased with traffic as expected, but CPU alone was not the main issue.
The bigger pressure came from IO and file streaming behavior.
Average CPU usage stayed around 35%, which means the application was not purely compute-bound.
Memory Usage During the Performance Test
Memory usage increased gradually during heavier ramp stages and peaked around 126 MB.
The test does not prove a memory leak, but it does show that large media delivery creates noticeable buffering and memory pressure.
What This Spring Boot Performance Test Actually Shows
The most important takeaway is this:
Spring Boot handled the application logic well. The real scaling challenge came from serving large media files directly through the backend.
That means the long-term production architecture should separate:
- Business APIs
- Authentication
- Metadata handling
- Media delivery
Instead of streaming large MP4 files directly from Spring Boot, a production-ready Spring Boot file upload architecture should move file delivery to:
- S3-compatible object storage
- Cloudflare R2
- AWS S3
- CDN delivery
- Nginx static serving
- Signed URLs
Frequently Asked Questions
How well does Spring Boot handle file uploads under load?
Based on this benchmark, Spring Boot handled file upload and file-serving workloads surprisingly well under sustained traffic. The FiloraFS-Lite test completed more than 134,000 requests with zero HTTP failures while scaling up to 7,500 RPM. Application logic, authentication, and metadata APIs remained stable. The main degradation came from large media delivery rather than Spring Boot request handling itself.
How many requests can a Spring Boot file upload API handle?
In this specific benchmark, the Spring Boot file upload API remained stable up to 7,500 RPM, but practical performance depends on workload type, file size, infrastructure, storage strategy, and network constraints. For this test, the most realistic operating zone was around 5,000 to 5,500 RPM where P95 latency stayed within an acceptable range for production-like responsiveness.
Is Spring Boot suitable for production file storage systems?
Yes, Spring Boot is a strong choice for production file storage systems when used for API orchestration, authentication, metadata management, access control, and business logic. However, serving large files directly from the application is usually not ideal at scale. Production systems typically pair Spring Boot with object storage like AWS S3 or Cloudflare R2, CDN delivery, and signed URLs for better scalability.
What caused the biggest bottleneck in this benchmark?
The biggest bottleneck was large MP4 file delivery. Small files like PDFs were served extremely fast, while large video responses pushed latency much higher. This created pressure on disk IO, network throughput, buffering, and thread handling. The benchmark showed that the scaling limit was media delivery architecture, not the Spring Boot API layer itself.
If you are building a production Spring Boot file upload system, separating media delivery from API logic becomes critical.
Need production-grade file infrastructure?
This benchmark was conducted on FiloraFS-Lite, a lightweight starter built for experimentation and rapid setup. If you need JWT auth, S3 storage, secure file access, streaming, and production-ready architecture, FiloraFS-Pro is the next step.
Explore FiloraFS-ProBuilt for real production workloads
Final thoughts
The backend survived 7,500 RPM without HTTP failures, which is a strong stability signal.
But the test also exposed the real scalability boundary: media-heavy workloads, especially MP4 delivery.
That is exactly why performance testing matters.
It is not just about proving the system works.
It is about discovering where architecture decisions start becoming bottlenecks before production traffic finds them first.