Modify Node.js scaling considerations

Author: kraigb

articles/azure-functions/functions-best-practices.md

@@ -81,20 +81,17 @@ Don't use verbose logging in production code, which has a negative performance i
 
 ### Use async code but avoid blocking calls
 
-Asynchronous programming is a recommended best practice.
+Asynchronous programming is a recommended best practice, especially when blocking I/O operations are involved.
 
 In C#, always avoid referencing the `Result` property or calling `Wait` method on a `Task` instance. This approach can lead to thread exhaustion.
 
 [!INCLUDE [HTTP client best practices](../../includes/functions-http-client-best-practices.md)]
 
 ### Use multiple worker processes
 
-For single-threaded runtimes like Python and Node.js, you can improve performance by using two additional methods:
+By default, any host instance for Functions uses a single worker process. To improve performance, especially with single-threaded runtimes like Python, use the [FUNCTIONS_WORKER_PROCESS_COUNT](functions-app-settings.md#functions_worker_process_count) to increase the number of worker processes per host (up to 10). Azure Functions then tries to evenly distribute simultaneous function invocations across these workers. 
 
-- Use async functions for blocking I/O operations.
-- Use the [FUNCTIONS_WORKER_PROCESS_COUNT](functions-app-settings.md#functions_worker_process_count) to increase the number of worker processes per host (up to 10).
-
-For more information, see [Azure Functions Python developer guide - Scaling and concurrency](functions-reference-python.md#scaling-and-concurrency) and [Azure Functions Node.js developer guide - Scaling and concurrency](functions-reference-node.md#scaling-and-concurrency).
+The FUNCTIONS_WORKER_PROCESS_COUNT applies to each host that Functions creates when scaling out your application to meet demand. 
 
 ### Receive messages in batch whenever possible
 

articles/azure-functions/functions-reference-node.md

@@ -406,28 +406,7 @@ When you work with HTTP triggers, you can access the HTTP request and response o
 
 By default, Azure Functions automatically monitors the load on your application and creates additional host instances for Node.js as needed. Functions uses built-in (not user configurable) thresholds for different trigger types to decide when to add instances, such the age of messages and queue size for QueueTrigger. For more information, see [How the consumption and premium plans work](functions-scale.md#how-the-consumption-and-premium-plans-work).
 
-This scaling behavior is sufficient for many applications. Applications with any of the following characteristics, however, may not scale as effectively:
-
-- The application needs to handle many concurrent invocations.
-- The application processes a large number of I/O events.
-- The application is I/O bound.
-
-In such cases, you can improve performance further by employing async patterns and by using multiple language worker processes.
-
-### Async
-
-Because Node.js is a single-threaded runtime, a host instance for Node.js can process only one function invocation at a time. For applications that process a large number of I/O events and/or is I/O bound, you can improve performance by running functions asynchronously.
-
-To run a function asynchronously, use the `async function` statement (available in Node.js 8 or later, which requires version 2.x of the Functions runtime).
-
-```javascript
-async function myAsyncFunction(args) {
-    // Code that uses await, etc.
-    ...
-}
-```
-
-### Use multiple language worker processes
+This scaling behavior is sufficient for many Node.js applications. For CPU-bound applications, you can improve performance further by using multiple language worker processes.
 
 By default, every Functions host instance has a single language worker process. You can increase the number of worker processes per host (up to 10) by using the [FUNCTIONS_WORKER_PROCESS_COUNT](functions-app-settings.md#functions_worker_process_count) application setting. Azure Functions then tries to evenly distribute simultaneous function invocations across these workers. 
 

articles/azure-functions/functions-scale.md

@@ -158,7 +158,7 @@ Different triggers may also have different scaling limits as well as documented
 
 There are many aspects of a function app that will impact how well it will scale, including host configuration, runtime footprint, and resource efficiency.  For more information, see the [scalability section of the performance considerations article](functions-best-practices.md#scalability-best-practices). You should also be aware of how connections behave as your function app scales. For more information, see [How to manage connections in Azure Functions](manage-connections.md).
 
-For additional information on scaling in Python and Node.js, which are single-threaded runtimes, see [Azure Functions Python developer guide - Scaling and concurrency](functions-reference-python.md#scaling-and-concurrency) and [Azure Functions Node.js developer guide - Scaling and concurrency](functions-reference-node.md#scaling-and-concurrency).
+For additional information on scaling in Python and Node.js, see [Azure Functions Python developer guide - Scaling and concurrency](functions-reference-python.md#scaling-and-concurrency) and [Azure Functions Node.js developer guide - Scaling and concurrency](functions-reference-node.md#scaling-and-concurrency).
 
 ### Billing model