diff --git a/stress/README.rst b/stress/README.rst
index 1667e31..d935289 100644
--- a/stress/README.rst
+++ b/stress/README.rst
@@ -17,7 +17,7 @@
 controlling rate of fire and stuff like that.
 
 This test framework is designed to stress test a Nova cluster. Hence,
-you must have a working Nova cluster.
+you must have a working Nova cluster with rate limiting turned off.
 
 Environment
 ------------
@@ -34,12 +34,16 @@
   controller=<hostname for calling nova-manage>
   max_instances=<limit on instances that will be created>
 
+Also, make sure to set
+
+log_level=CRITICAL
+
+so that the API client does not log failed calls which are expected while
+running stress tests.
+
 The stress test needs the top-level tempest directory to be on PYTHONPATH
 if you are not using nosetests to run.
 
-For real stress, you need to remove "ratelimit" from the pipeline in
-api-paste.ini.
-
 
 Running the sample test
 -----------------------
