Tidy up commit

Author: franrob-projects

src/pages/docs/platform/integrations/queues.mdx

@@ -80,15 +80,15 @@ A [Dead Letter Queue](#deadletter) is automatically created. It stores messages
 
 ### Modifying queues <a id="modify"/>
 
-Queues can't be changed after creation - they're immutable. If you need different settings, you'll need to create a new queue and migrate.
+Queues cannot be modified after creation - they are immutable. Different settings require creating a new queue and migrating.
 
-This includes limits like TTL and max length. Even if you upgrade your Ably account, existing queues keep the limits they were created with. You'll need to replace them to get the higher limits from your new plan.
+This includes limits like TTL and max length. Even after upgrading an Ably account, existing queues retain the limits they were created with. Replacement is required to get the higher limits from a new plan.
 
-Here's how to switch to a new queue:
+Steps to switch to a new queue:
 
-1. Create a new queue with your desired settings
-2. Update your consumers to subscribe to both the old and new queues
-3. Change your queue rules to route messages to the new queue
+1. Create a new queue with the desired settings
+2. Update consumers to subscribe to both the old and new queues
+3. Change queue rules to route messages to the new queue
 4. Wait for the old queue to drain completely
 5. Delete the old queue once empty
 

src/pages/docs/platform/integrations/webhooks/index.mdx

@@ -94,13 +94,13 @@ The back off for consecutively failing requests will increase until it reaches 6
 
 ## Message ordering <a id="ordering"/>
 
-Webhooks don't always preserve message order the same way Ably channels do. It depends on how you've set up your webhook.
+Webhooks do not always preserve message order the same way Ably channels do. This depends on the webhook configuration.
 
-With batched webhooks, messages stay in order as long as they're from the same publisher on the same channel. If a batch fails and gets retried, newer messages get included but they'll still be in the right order. Messages from different regions might arrive in separate batches, but that's fine since ordering is per-publisher anyway.
+Batched webhooks preserve message order when messages are from the same publisher on the same channel. If a batch fails and gets retried, newer messages are included while maintaining correct order. Messages from different regions might arrive in separate batches, maintaining per-publisher ordering.
 
-Single request webhooks can't guarantee order. Each message fires off its own HTTP request, and there's no telling which one arrives first. If your server supports HTTP/2 though, you get ordering back because requests get pipelined down one connection.
+Single request webhooks cannot guarantee order. Each message triggers its own HTTP request, and arrival order is not predictable. HTTP/2 server support can restore ordering through request pipelining over a single connection.
 
-One gotcha: if you're publishing via REST (not realtime), you lose ordering guarantees even with batching on. That's because REST uses a connection pool where requests can finish out of order.
+Publishing via REST (not realtime) removes ordering guarantees even with batching enabled, as REST uses a connection pool where requests can complete out of order.
 
 Given the various potential combinations of enveloped, batched, and message sources, it's helpful to understand what to expect in different scenarios.
 

src/pages/docs/platform/integrations/webhooks/lambda.mdx

@@ -110,6 +110,6 @@ Then ensure the checkbox for the policy is selected.
 
 Ably invokes Lambda functions asynchronously using the `event` invocation type. When a function returns an error, AWS Lambda automatically retries the execution up to two more times with delays between attempts (1 minute, then 2 minutes).
 
-This means your Lambda function might occasionally run multiple times for the same Ably event. Design your functions to handle this - either make them idempotent or check for duplicate processing.
+Lambda functions might run multiple times for the same Ably event. Design functions to handle this by making them idempotent or checking for duplicate processing.
 
 You can configure retry behavior in your AWS Lambda console under the function's asynchronous invocation settings. See the [AWS Lambda documentation](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#invocation-async-errors) for details on adjusting retry settings.