diff --git a/src/lc-compliance/simple_capture.cpp b/src/lc-compliance/simple_capture.cpp
index bb173ef1f71a..598c5aebe033 100644
--- a/src/lc-compliance/simple_capture.cpp
+++ b/src/lc-compliance/simple_capture.cpp
@@ -249,3 +249,51 @@ void SimpleCaptureUnbalanced::requestComplete(Request *request)
 	if (camera_->queueRequest(request))
 		loop_->exit(-EINVAL);
 }
+
+/* SimpleCaptureOverflow */
+
+SimpleCaptureOverflow::SimpleCaptureOverflow(std::shared_ptr<Camera> camera)
+	: SimpleCapture(camera)
+{
+}
+
+Results::Result SimpleCaptureOverflow::capture()
+{
+	Results::Result ret = start();
+	if (ret.first != Results::Pass)
+		return ret;
+
+	Stream *stream = config_->at(0).stream();
+	const std::vector<std::unique_ptr<FrameBuffer>> &buffers = allocator_->buffers(stream);
+
+	captureCount_ = 0;
+	captureLimit_ = buffers.size();
+
+	std::vector<std::unique_ptr<libcamera::Request>> requests;
+	ret = queueRequests(stream, requests, buffers);
+	if (ret.first != Results::Pass)
+		return ret;
+
+	runCaptureSession();
+
+	if (captureCount_ != captureLimit_)
+		return { Results::Fail, "Got " + std::to_string(captureCount_) +
+			" request, wanted " + std::to_string(captureLimit_) };
+
+	return { Results::Pass, "Overflow capture of " +
+		std::to_string(captureLimit_) + " requests" };
+}
+
+void SimpleCaptureOverflow::requestComplete([[maybe_unused]] Request *request)
+{
+	captureCompleted();
+}
+
+Results::Result SimpleCaptureOverflow::allocateBuffers(unsigned int count)
+{
+	Stream *stream = config_->at(0).stream();
+	if (allocator_->allocate(stream, count) < 0)
+		return { Results::Fail, "Failed to allocate buffers" };
+
+	return { Results::Pass, "Allocated buffers" };
+}
diff --git a/src/lc-compliance/simple_capture.h b/src/lc-compliance/simple_capture.h
index 8d0f94f0c3e5..3b818c640477 100644
--- a/src/lc-compliance/simple_capture.h
+++ b/src/lc-compliance/simple_capture.h
@@ -72,4 +72,16 @@ private:
 	void requestComplete(libcamera::Request *request) override;
 };
 
+class SimpleCaptureOverflow : public SimpleCapture
+{
+public:
+	SimpleCaptureOverflow(std::shared_ptr<libcamera::Camera> camera);
+
+	Results::Result allocateBuffers(unsigned int count);
+	Results::Result capture();
+
+private:
+	void requestComplete(libcamera::Request *request) override;
+};
+
 #endif /* __LC_COMPLIANCE_SIMPLE_CAPTURE_H__ */
diff --git a/src/lc-compliance/single_stream.cpp b/src/lc-compliance/single_stream.cpp
index 649291c7bb73..7035d9cf5df5 100644
--- a/src/lc-compliance/single_stream.cpp
+++ b/src/lc-compliance/single_stream.cpp
@@ -12,6 +12,23 @@
 
 using namespace libcamera;
 
+static const unsigned int MAX_SIMULTANEOUS_REQUESTS = 8;
+
+Results::Result testRequestOverflow(std::shared_ptr<Camera> camera,
+				   StreamRole role, unsigned int numRequests)
+{
+	SimpleCaptureOverflow capture(camera);
+
+	Results::Result ret = capture.configure(role);
+	if (ret.first != Results::Pass)
+		return ret;
+	capture.allocateBuffers(numRequests);
+	if (ret.first != Results::Pass)
+		return ret;
+
+	return capture.capture();
+}
+
 Results::Result testRequestBalance(std::shared_ptr<Camera> camera,
 				   StreamRole role, unsigned int startCycles,
 				   unsigned int numRequests)
@@ -61,7 +78,7 @@ Results testSingleStream(std::shared_ptr<Camera> camera)
 	};
 	static const std::vector<unsigned int> numRequests = { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
 
-	Results results(numRequests.size() * roles.size() * 3);
+	Results results(numRequests.size() * roles.size() * 3 + roles.size());
 
 	for (const auto &role : roles) {
 		std::cout << "= Test role " << role.first << std::endl;
@@ -97,6 +114,18 @@ Results testSingleStream(std::shared_ptr<Camera> camera)
 		std::cout << "* Test unbalanced stop" << std::endl;
 		for (unsigned int num : numRequests)
 			results.add(testRequestUnbalance(camera, role.second, num));
+
+		/*
+		 * Test overflowing pipeline with requests
+		 *
+		 * Makes sure that the camera supports receiving a large number
+		 * of requests at once. Example failure is a camera that doesn't
+		 * check if there are available resources (free internal
+		 * buffers, free buffers in the video devices) before handling a
+		 * request.
+		 */
+		std::cout << "* Test overflowing requests" << std::endl;
+		results.add(testRequestOverflow(camera, role.second, MAX_SIMULTANEOUS_REQUESTS));
 	}
 
 	return results;