Adopt React Compiler with a test for the work it changes
React Compiler 1.0 has a documented stable release. Evaluate rendering performance separately from Server Function integration and server-side authorisation.

React Compiler is a build-time optimisation tool. Adopting it is a decision about how an application performs rendering work; adopting Server Functions changes how client code can request work on the server.
Those changes deserve separate acceptance tests. A faster component update does not establish that a server mutation has the right authorisation checks. Keeping the decisions separate also makes a failed rollout easier to diagnose.
The compiler has a stable release history
The React team released React Compiler 1.0 on 7 October 2025. Describing its state in late 2025 as approximately version 1.0 understates a documented stable release. The exact compiler version used by your build should still be recorded in the dependency lockfile.
The release describes automatic optimisation of components and Hooks through memoisation. A cached computation can be reused when its relevant inputs remain unchanged. This can reduce repeated rendering work while the component keeps the same intended behaviour.
The compiler introduction identifies update performance as its main focus. It works on React components and Hooks, with boundaries to what it can optimise. An application can still be slow because it waits for a network request or sends too much data to the browser.
Find the slow interaction before selecting the intervention. A list that repeatedly recalculates expensive derived values is a different case from a form waiting for a remote database. Measure the part the proposed change can affect.
Compare the same interaction under the same conditions
Start with a reproducible input and the production build configuration. Record the interaction's behaviour before enabling the compiler for the intended scope. A comparison made with different data or different device conditions can attribute an unrelated change to the compiler.
After enabling it, confirm that the relevant components are actually being compiled. A successful build proves that the build completed. It leaves the scope of the optimisation to be inspected through the compiler's diagnostics and the application's behaviour.
Test for correctness as well as speed. An interaction that appears faster because a required update no longer occurs is a regression. Check what the user sees after a state change, particularly where a third-party component participates in the interaction.
Keep the measured result specific. If one editing screen improves, describe that screen and its tested workload. A percentage reported by another team gives no measurement for your own product.
Manual memoisation remains a performance decision
React's useMemo reference says the compiler reduces the need for manual useMemo calls. It also describes memoisation as a performance optimisation. Correctness should follow the component's data flow without depending on the cache being retained indefinitely.
That is a reason to review an existing useMemo before deleting it. Establish what work it was intended to avoid, then check whether the compiled path covers that work. A dependency on object identity may reveal a wider design issue that deserves its own change.
Avoid combining compiler adoption with a repository-wide memoisation cleanup. Keeping the first change small gives a regression a narrower set of possible causes. Remove a redundant optimisation when the evidence for that specific removal is visible.
The compiler's value comes from the work it saves under the application's actual update pattern. Counting deleted Hook calls is a code-change metric, with no automatic relationship to the user's experience.
Server Functions introduce a network boundary
React's Server Functions documentation explains how client code calls an asynchronous function executed on the server through framework support. It also distinguishes Server Functions from the narrower use of those functions in Actions.
This capability depends on the framework or bundler integration. Enabling a rendering compiler alone does not create that server execution path. A client-only application can evaluate compiler adoption independently of a move to a Server Components framework.
The use server security guidance says arguments are controlled by the client and mutations require authorisation. A hidden button in the interface is insufficient to decide whether a user may change a server record. The function needs to check the authenticated user's permission for the requested operation.
For a form mutation, test an unauthorised request against the actual server function. Also test an authenticated user attempting to change a record they do not own. The acceptance result should follow the server's permission rule, regardless of what the normal interface displays.
Use current package advisories for the deployed stack
React's 14 October 2026 Server Components advisory describes another remote-code-execution issue affecting specified react-server-dom packages. It identifies patched versions and conditions affecting exposure. A patch list copied from December 2025 cannot account for that later advisory.
Identify the packages actually deployed through your framework, then follow the current patch mapping for that stack. Updating only an application-level React version string can leave the relevant server dependency unchanged in the build artifact.
A compiler rollout and a server-security update can both be necessary, with separate evidence for completion. Record the compiler's measured interaction result. Verify the server package update in the deployed dependency set, then test the application's affected behaviour.
Make the next React change answer one specific question. If the goal is less repeated rendering work, measure that work. If the goal is a server mutation, test its permission boundary. Each decision becomes easier to review when its evidence matches what the change actually does.