diff --git a/beta/src/content/learn/queueing-a-series-of-state-updates.md b/beta/src/content/learn/queueing-a-series-of-state-updates.md
index 4144d3623..4cecbc7e1 100644
--- a/beta/src/content/learn/queueing-a-series-of-state-updates.md
+++ b/beta/src/content/learn/queueing-a-series-of-state-updates.md
@@ -1,23 +1,23 @@
 ---
-title: Queueing a Series of State Updates
+title: Poner en cola una serie de actualizaciones del estado
 ---
 
 <Intro>
 
-Setting a state variable will queue another render. But sometimes you might want to perform multiple operations on the value before queueing the next render. To do this, it helps to understand how React batches state updates.
+Al asignar una variable de estado se pondrá en cola otro renderizado. Pero a veces, es posible que quieras realizar varias operaciones antes de poner en cola el siguiente renderizado. Para hacer esto, nos ayuda entender cómo React realiza las actualizaciones de estado por lotes.
 
 </Intro>
 
 <YouWillLearn>
 
-* What "batching" is and how React uses it to process multiple state updates
-* How to apply several updates to the same state variable in a row
+* Qué es "la actualización por lotes (_batching_)" y cómo lo utiliza React para procesar múltiples actualizaciones del estado
+* Cómo aplicar varias actualizaciones a la misma variable de estado de forma consecutiva
 
 </YouWillLearn>
 
-## React batches state updates {/*react-batches-state-updates*/}
+## React actualiza el estado por lotes {/*react-batches-state-updates*/}
 
-You might expect that clicking the "+3" button will increment the counter three times because it calls `setNumber(number + 1)` three times:
+Podrías esperar que al hacer clic en el botón "+3" el contador se incremente tres veces porque llama a `setNumber(number + 1)` tres veces:
 
 <Sandpack>
 
@@ -47,7 +47,7 @@ h1 { display: inline-block; margin: 10px; width: 30px; text-align: center; }
 
 </Sandpack>
 
-However, as you might recall from the previous section, [each render's state values are fixed](/learn/state-as-a-snapshot#rendering-takes-a-snapshot-in-time), so the value of `number` inside the first render's event handler is always `0`, no matter how many times you call `setNumber(1)`:
+Sin embargo, como se puede recordar de la sección anterior, [los valores del estado de cada renderizado son fijos](/learn/state-as-a-snapshot#rendering-takes-a-snapshot-in-time), por lo que el valor de `number` dentro del manejador de eventos del primer renderizado siempre es `0`, sin importar cuántas veces se llame a `setNumber(1)`:
 
 ```js
 setNumber(0 + 1);
@@ -55,21 +55,21 @@ setNumber(0 + 1);
 setNumber(0 + 1);
 ```
 
-But there is one other factor at work here to discuss. **React waits until *all* code in the event handlers has run before processing your state updates.** This is why the re-render only happens *after* all these `setNumber()` calls.
+Pero hay otro factor a analizar aquí. **React espera a que *todo* el código de los manejadores de eventos se haya ejecutado antes de procesar tus actualizaciones de estado.** Por ello, el rerenderizado sólo se produce *después* de todas las llamadas `setNumber()`.
 
-This might remind you of a waiter taking an order at the restaurant. A waiter doesn't run to the kitchen at the mention of your first dish! Instead, they let you finish your order, let you make changes to it, and even take orders from other people at the table.
+Esto puede recordarte a un camarero que toma nota de un pedido en un restaurante. ¡El camarero no corre a la cocina al mencionar tu primer plato! En cambio, te deja terminar tu pedido, te permite hacerle cambios e incluso toma nota de los pedidos de las otras personas en la mesa.
 
-<Illustration src="/images/docs/illustrations/i_react-batching.png"  alt="An elegant cursor at a restaurant places and order multiple times with React, playing the part of the waiter. After she calls setState() multiple times, the waiter writes down the last one she requested as her final order." />
+<Illustration src="/images/docs/illustrations/i_react-batching.png"  alt="Un elegante cursor en un restaurante hace un pedido varias veces con React, que interpreta el papel de camarero. Después de que ella llama a setState() múltiples veces, el camarero anota lo último que ella pidió como su pedido final." />
 
-This lets you update multiple state variables--even from multiple components--without triggering too many [re-renders.](/learn/render-and-commit#re-renders-when-state-updates) But this also means that the UI won't be updated until _after_ your event handler, and any code in it, completes. This behavior, also known as **batching,** makes your React app run much faster. It also avoids dealing with confusing "half-finished" renders where only some of the variables have been updated.
+Esto te permite actualizar múltiples variables del estado -incluso de múltiples componentes- sin realizar demasiados [rerenderizados.](/learn/render-and-commit#re-renders-when-state-updates) Pero esto también significa que la UI no se actualizará hasta _después_ de que tu manejador de eventos, y cualquier código en él, se complete. Este comportamiento, también conocido como **batching**, hace que tu aplicación de React se ejecute mucho más rápido. También evita tener que lidiar con confusos renderizados "a medio terminar" en los que sólo se han actualizado algunas de las variables.
 
-**React does not batch across *multiple* intentional events like clicks**--each click is handled separately. Rest assured that React only does batching when it's generally safe to do. This ensures that, for example, if the first button click disables a form, the second click would not submit it again.
+**React no agrupa *múltiples* eventos intencionados como los clics** --cada clic se maneja por separado. Puedes estar seguro de que React sólo actualizará por lotes cuando sea seguro hacerlo. Esto garantiza que, por ejemplo, si el primer clic del botón desactiva un formulario, el segundo clic no lo enviará de nuevo.
 
-## Updating the same state variable multiple times before the next render {/*updating-the-same-state-variable-multiple-times-before-the-next-render*/}
+## Actualización de la misma variable de estado varias veces antes del siguiente renderizado {/*updating-the-same-state-variable-multiple-times-before-the-next-render*/}
 
-It is an uncommon use case, but if you would like to update the same state variable multiple times before the next render, instead of passing the *next state value* like `setNumber(number + 1)`, you can pass a *function* that calculates the next state based on the previous one in the queue, like `setNumber(n => n + 1)`. It is a way to tell React to "do something with the state value" instead of just replacing it.
+Es un caso de uso poco común, pero si quieres actualizar la misma variable de estado varias veces antes del siguiente renderizado, en lugar de pasar el *siguiente valor de estado* como `setNumber(number + 1)`, puedes pasar una *función* que calcule el siguiente estado basado en el anterior en la cola, como `setNumber(n => n + 1)`. Es una forma de decirle a React que "haga algo con el valor del estado" en lugar de simplemente reemplazarlo.
 
-Try incrementing the counter now:
+Intenta incrementar el contador ahora:
 
 <Sandpack>
 
@@ -99,10 +99,10 @@ h1 { display: inline-block; margin: 10px; width: 30px; text-align: center; }
 
 </Sandpack>
 
-Here, `n => n + 1` is called an **updater function.** When you pass it to a state setter:
+Aquí, `n => n + 1` se la llama una **función de actualización.** Cuando la pasas a una asignación de estado:
 
-1. React queues this function to be processed after all the other code in the event handler has run.
-2. During the next render, React goes through the queue and gives you the final updated state.
+1. React pone en cola esta función para que se procese después de que se haya ejecutado el resto del código del manejador de eventos.
+2. Durante el siguiente renderizado, React recorre la cola y te da el estado final actualizado.
 
 ```js
 setNumber(n => n + 1);
@@ -110,26 +110,26 @@ setNumber(n => n + 1);
 setNumber(n => n + 1);
 ```
 
-Here's how React works through these lines of code while executing the event handler:
+Así es como funciona React a través de estas líneas de código mientras se ejecuta el manejador de eventos:
 
-1. `setNumber(n => n + 1)`: `n => n + 1` is a function. React adds it to a queue.
-1. `setNumber(n => n + 1)`: `n => n + 1` is a function. React adds it to a queue.
-1. `setNumber(n => n + 1)`: `n => n + 1` is a function. React adds it to a queue.
+1. `setNumber(n => n + 1)`: `n => n + 1` es una función. React la añade a la cola.
+2. `setNumber(n => n + 1)`: `n => n + 1` es una función. React la añade a la cola.
+3. `setNumber(n => n + 1)`: `n => n + 1` es una función. React la añade a la cola.
 
-When you call `useState` during the next render, React goes through the queue. The previous `number` state was `0`, so that's what React passes to the first updater function as the `n` argument. Then React takes the return value of your previous updater function and passes it to the next updater as `n`, and so on:
+Cuando llamas a `useState` durante el siguiente renderizado, React recorre la cola. El estado anterior `number` era `0`, así que eso es lo que React pasa a la primera función actualizadora como el argumento `n`. Luego React toma el valor de retorno de su función actualizadora anterior y lo pasa al siguiente actualizador como `n`, y así sucesivamente:
 
-|  queued update | `n` | returns |
+|  actualización en cola | `n` | devuelve |
 |--------------|---------|-----|
 | `n => n + 1` | `0` | `0 + 1 = 1` |
 | `n => n + 1` | `1` | `1 + 1 = 2` |
 | `n => n + 1` | `2` | `2 + 1 = 3` |
 
-React stores `3` as the final result and returns it from `useState`.
+React almacena `3` como resultado final y lo devuelve desde `useState`.
 
-This is why clicking "+3" in the above example correctly increments the value by 3.
-### What happens if you update state after replacing it {/*what-happens-if-you-update-state-after-replacing-it*/}
+Por eso, al hacer clic en "+3" en el ejemplo anterior, el valor se incrementa correctamente en 3.
+### ¿Qué ocurre si se actualiza el estado después de sustituirlo? {/*what-happens-if-you-update-state-after-replacing-it*/}
 
-What about this event handler? What do you think `number` will be in the next render?
+¿Qué pasa con este manejador de eventos? ¿Qué valor crees que tendrá `number` en el próximo renderizado?
 
 ```js
 <button onClick={() => {
@@ -165,25 +165,25 @@ h1 { display: inline-block; margin: 10px; width: 30px; text-align: center; }
 
 </Sandpack>
 
-Here's what this event handler tells React to do:
+Esto es lo que este manejador de eventos le dice a React que haga:
 
-1. `setNumber(number + 5)`: `number` is `0`, so `setNumber(0 + 5)`. React adds *"replace with `5`"* to its queue.
-2. `setNumber(n => n + 1)`: `n => n + 1` is an updater function. React adds *that function* to its queue.
+1. `setNumber(number + 5)`: `number` es `0`, así que `setNumber(0 + 5)`. React añade *"reemplazar con `5`"* a su cola.
+2. `setNumber(n => n + 1)`: `n => n + 1` es una función de actualización. React añade *esa función* a su cola.
 
-During the next render, React goes through the state queue:
+Durante el siguiente renderizado, React recorre la cola de estados:
 
-|   queued update       | `n` | returns |
+|   actualización en cola       | `n` | devuelve |
 |--------------|---------|-----|
-| "replace with `5`" | `0` (unused) | `5` |
+| "reemplaza con `5`" | `0` (sin usar) | `5` |
 | `n => n + 1` | `5` | `5 + 1 = 6` |
 
-React stores `6` as the final result and returns it from `useState`. 
+React almacena `6` como resultado final y lo devuelve desde `useState`. 
 
-> You may have noticed that `setState(x)` actually works like `setState(n => x)`, but `n` is unused!
+> Te habrás dado cuenta de que `setState(x)` en realidad funciona como `setState(n => x)`, ¡pero `n` no se utiliza!
 
-### What happens if you replace state after updating it {/*what-happens-if-you-replace-state-after-updating-it*/}
+### ¿Qué ocurre si se sustituye el estado después de actualizarlo? {/*what-happens-if-you-replace-state-after-updating-it*/}
 
-Let's try one more example. What do you think `number` will be in the next render?
+Probemos un ejemplo más. ¿Qué valor crees que tendrá "number" en el próximo renderizado?
 
 ```js
 <button onClick={() => {
@@ -221,32 +221,32 @@ h1 { display: inline-block; margin: 10px; width: 30px; text-align: center; }
 
 </Sandpack>
 
-Here's how React works through these lines of code while executing this event handler:
+Así es como funciona React a través de estas líneas de código mientras se ejecuta este manejador de eventos:
 
-1. `setNumber(number + 5)`: `number` is `0`, so `setNumber(0 + 5)`. React adds *"replace with `5`"* to its queue.
-2. `setNumber(n => n + 1)`: `n => n + 1` is an updater function. React adds *that function* to its queue.
-3. `setNumber(42)`: React adds *"replace with `42`"* to its queue.
+1. `setNumber(number + 5)`: `number` es `0`, así que `setNumber(0 + 5)`. React añade *"reemplazar con `5`"* a su cola.
+2. `setNumber(n => n + 1)`: `n => n + 1` es una función de actualización. React añade *esa función* a su cola.
+3. `setNumber(42)`: React añade *"reemplazar con `42`"* a su cola.
 
-During the next render, React goes through the state queue:
+Durante el siguiente renderizado, React recorre la cola de estados:
 
-|   queued update       | `n` | returns |
+|   actualización en cola       | `n` | devuelve |
 |--------------|---------|-----|
-| "replace with `5`" | `0` (unused) | `5` |
+| "reemplaza con `5`" | `0` (sin usar) | `5` |
 | `n => n + 1` | `5` | `5 + 1 = 6` |
-| "replace with `42`" | `6` (unused) | `42` |
+| "reemplaza con `42`" | `6` (sin usar) | `42` |
 
-Then React stores `42` as the final result and returns it from `useState`.
+Entonces React almacena `42` como resultado final y lo devuelve desde `useState`.
 
-To summarize, here's how you can think of what you're passing to the `setNumber` state setter:
+Para resumir, así es como puedes pensar en lo que estás pasando a la función de asignación de estado `setNumber`:
 
-* **An updater function** (e.g. `n => n + 1`) gets added to the queue.
-* **Any other value** (e.g. number `5`) adds "replace with `5`" to the queue, ignoring what's already queued.
+* **Una función de actualización** (p.ej. `n => n + 1`) se añade a la cola.
+* **Cualquier otro valor** (p.ej. number `5`) añade "reemplazar con `5`" a la cola, ignorando lo que ya está en cola.
 
-After the event handler completes, React will trigger a re-render. During the re-render, React will process the queue. Updater functions run during rendering, so **updater functions must be [pure](/learn/keeping-components-pure)** and only *return* the result. Don't try to set state from inside of them or run other side effects. In Strict Mode, React will run each updater function twice (but discard the second result) to help you find mistakes.
+Después de que el manejador de eventos se complete, React lanzará un rerenderizado. Durante el rerenderizado, React procesará la cola. Las funciones de actualización se ejecutan durante el renderizado, por lo que **las funciones de actualización deben ser [puras](/learn/keeping-components-pure)** y sólo *devuelven* el resultado. No intentes establecer el estado desde dentro de ellas o ejecutar otros efectos secundarios. En modo estricto, React ejecutará cada función de actualización dos veces (pero descartará el segundo resultado) para ayudarte a encontrar errores.
 
-### Naming conventions {/*naming-conventions*/}
+### Convenciones de nomenclatura {/*naming-conventions*/}
 
-It's common to name the updater function argument by the first letters of the corresponding state variable:
+Es habitual nombrar el argumento de la función de actualización por las primeras letras de la variable de estado correspondiente:
 
 ```js
 setEnabled(e => !e);
@@ -254,13 +254,13 @@ setLastName(ln => ln.reverse());
 setFriendCount(fc => fc * 2);
 ```
 
-If you prefer more verbose code, another common convention is to repeat the full state variable name, like `setEnabled(enabled => !enabled)`, or to use a prefix like `setEnabled(prevEnabled => !prevEnabled)`.
+Si prefieres un código más detallado, otra opción habitual es repetir el nombre completo de la variable del estado, como `setEnabled(enabled => !enabled)`, o utilizar un prefijo como `setEnabled(prevEnabled => !prevEnabled)`.
 
 <Recap>
 
-* Setting state does not change the variable in the existing render, but it requests a new render.
-* React processes state updates after event handlers have finished running. This is called batching.
-* To update some state multiple times in one event, you can use `setNumber(n => n + 1)` updater function.
+* Establecer el estado no cambia la variable en el renderizado existente, pero si solicita un nuevo renderizado.
+* React procesa las actualizaciones de estado después de que los manejadores de eventos hayan terminado de ejecutarse. Esto se llama _batching_.
+* Para actualizar algún estado varias veces en un evento, puedes utilizar la función de actualización `setNumber(n => n + 1)`.
 
 </Recap>
 
@@ -268,13 +268,13 @@ If you prefer more verbose code, another common convention is to repeat the full
 
 <Challenges>
 
-#### Fix a request counter {/*fix-a-request-counter*/}
+#### Fijar un contador de peticiones {/*fix-a-request-counter*/}
 
-You're working on an art marketplace app that lets the user submit multiple orders for an art item at the same time. Each time the user presses the "Buy" button, the "Pending" counter should increase by one. After three seconds, the "Pending" counter should decrease, and the "Completed" counter should increase.
+Estás trabajando en una aplicación de comercialización de arte que permite al usuario enviar varios pedidos de un artículo de arte al mismo tiempo. Cada vez que el usuario pulsa el botón "Buy", el contador de "Pending" debería aumentar en uno. Después de tres segundos, el contador de "Pending" debería disminuir y el de "Completed" debería aumentar.
 
-However, the "Pending" counter does not behave as intended. When you press "Buy", it decreases to `-1` (which should not be possible!). And if you click fast twice, both counters seem to behave unpredictably.
+Sin embargo, el contador de "Pending" no se comporta como está previsto. Al pulsar "Comprar", disminuye a `-1` (¡lo que no debería ser posible!). Y si pulsas rápido dos veces, ambos contadores parecen comportarse de forma imprevisible.
 
-Why does this happen? Fix both counters.
+¿Por qué ocurre esto? Arregla ambos contadores.
 
 <Sandpack>
 
@@ -318,7 +318,7 @@ function delay(ms) {
 
 <Solution>
 
-Inside the `handleClick` event handler, the values of `pending` and `completed` correspond to what they were at the time of the click event. For the first render, `pending` was `0`, so `setPending(pending - 1)` becomes `setPending(-1)`, which is wrong. Since you want to *increment* or *decrement* the counters, rather than set them to a concrete value determined during the click, you can instead pass the updater functions:
+Dentro del manejador de eventos `handleClick`, los valores de `pending` y `completed` corresponden a lo que eran en el momento del evento de clic. Para el primer renderizado, `pending` era `0`, por lo que `setPending(pending - 1)` se convierte en `setPending(-1)`, lo cual es incorrecto. Como quieres *incrementar* o *disminuir* los contadores, en lugar de establecerlos a un valor concreto determinado durante el clic, puedes pasar las funciones de actualización:
 
 <Sandpack>
 
@@ -360,23 +360,23 @@ function delay(ms) {
 
 </Sandpack>
 
-This ensures that when you increment or decrement a counter, you do it in relation to its *latest* state rather than what the state was at the time of the click.
+Esto asegura que cuando se incrementa o disminuye un contador, se hace con relación a su *último* estado y no al valor del estado en el momento del clic.
 
 </Solution>
 
-#### Implement the state queue yourself {/*implement-the-state-queue-yourself*/}
+#### Implementa la cola de estado tú mismo {/*implement-the-state-queue-yourself*/}
 
-In this challenge, you will reimplement a tiny part of React from scratch! It's not as hard as it sounds.
+¡En este reto, reimplementarás una pequeña parte de React desde cero! No es tan difícil como parece.
 
-Scroll through the sandbox preview. Notice that it shows **four test cases.** They correspond to the examples you've seen earlier on this page. Your task is to implement the `getFinalState` function so that it returns the correct result for each of those cases. If you implement it correctly, all four tests should pass.
+Desplázate por la vista previa del _sandbox_. Observa que muestra **cuatro casos de prueba.** Se corresponden con los ejemplos que has visto antes en esta página. Tu tarea es implementar la función `getFinalState` para que devuelva el resultado correcto para cada uno de esos casos. Si la implementas correctamente, las cuatro pruebas deberían pasar.
 
-You will receive two arguments: `baseState` is the initial state (like `0`), and the `queue` is an array which contains a mix of numbers (like `5`) and updater functions (like `n => n + 1`) in the order they were added.
+Recibirás dos argumentos: `baseState` es el estado inicial (como `0`), y la `queue` es un array que contiene una mezcla de números (como `5`) y funciones de actualización (como `n => n + 1`) en el orden en que fueron añadidas.
 
-Your task is to return the final state, just like the tables on this page show!
+Tu tarea es devolver el estado final, ¡tal y como muestran las tablas de esta página!
 
 <Hint>
 
-If you're feeling stuck, start with this code structure:
+Si te sientes atascado, empieza con esta estructura de código:
 
 ```js
 export function getFinalState(baseState, queue) {
@@ -394,7 +394,7 @@ export function getFinalState(baseState, queue) {
 }
 ```
 
-Fill out the missing lines!
+¡Rellena las líneas que faltan!
 
 </Hint>
 
@@ -491,7 +491,7 @@ function TestCase({
 
 <Solution>
 
-This is the exact algorithm described on this page that React uses to calculate the final state:
+Este es el algoritmo exacto descrito en esta página que React utiliza para calcular el estado final:
 
 <Sandpack>
 
@@ -592,8 +592,8 @@ function TestCase({
 
 </Sandpack>
 
-Now you know how this part of React works!
+¡Ahora ya sabes cómo funciona esta parte de React!
 
 </Solution>
 
-</Challenges>
\ No newline at end of file
+</Challenges>