Free tools Windows power users keep installed
One-click scans. No signup required.
In Next.js 15’s App Router, pages and layouts are Server Components by default; use Client Components only where browser interaction is needed. React Server Components (RSC) are a rendering and module-boundary architecture, not another name for server-side rendering (SSR). The key is to place small client boundaries deliberately, understand what crosses them, and handle caching and authorization as separate concerns.
What are React Server Components?
React Server Components render in an environment separate from the client application. Depending on the app, that environment may be a build machine or a server handling a request. In Next.js, the framework coordinates rendering by route segment and produces a React Server Component Payload (RSC Payload) from the server-rendered tree. React’s Server Components reference explains the component model; Next.js’s component guide describes how the App Router applies it.
RSC and SSR describe different things. RSC concerns where component logic runs and what representation is passed between server and client. SSR means producing HTML on the server. Next.js can use the RSC result and Client Components to prerender HTML, so a Client Component may still be rendered on the server for the initial page load. “Client Component” does not mean “never runs on the server.”
There is no use server directive for declaring a Server Component. React documents that use server marks Server Functions, which are a different mechanism.
How do the server and client boundaries work?
In the App Router, layouts and pages are Server Components unless a client boundary is introduced. Server Components are a natural place for route framing, data access, and UI that does not need browser APIs or interaction. A Client Component is appropriate when code needs state, event handlers, effects, custom hooks, or browser features such as window and localStorage.
use client marks a module boundary
Put 'use client' at the top of the smallest practical entry module that needs client behavior. The marked module and the modules it imports join the client module graph and can contribute JavaScript sent to the browser. Marking a large layout or application subtree can pull more code into that graph than necessary.
The directive does not turn every component in the application into a Client Component. A Server Component can render a Client Component, but a Client Component should not import a Server Component and expect the browser to execute it as server code.
Compose server-rendered content into client UI
A Server Component can render server-side content and pass the result to a Client Component through children or another prop. For example, a server-fetched cart can be placed inside a stateful modal. The client controls the modal; it does not import and run the server component. Props crossing the boundary must be serializable by React.
Recommended Free Tools
Rank #2
- Sign Size: 4" X 18"
- Perfect Gift – Good for decorating a work space or hanging in a den, this novelty sign makes a great gift for anyone
- Quick & Easy Mount – Comes with pre-cut mounting holes for hanging
- Indoor/Outdoor Use – Printed with ultra durable inks for a scratch resistant finish that will last for years
- Proudly Made In The USA – Buy with confidence from an American owned and operated company! SignMission Items are produced in our state-of-the-art facility in West Palm Beach, Florida
Context and third-party components
Server Components cannot read React context. A provider can be implemented in a Client Component and rendered by a Server Component; client descendants can then consume that context. Next.js recommends placing providers as deep in the tree as practical, leaving more surrounding UI in the server-rendered portion. A third-party component that uses hooks or browser features but does not declare 'use client' at its package entry may need a small local Client Component wrapper.
What happens on the first load and on later navigation?
The RSC Payload represents the rendered server tree, includes placeholders and references for Client Components, and carries props passed across the boundary. On an initial load, Next.js uses the payload together with HTML to reconcile the server and client trees. The HTML provides a preview; JavaScript then hydrates Client Components by attaching their event handlers.
For later navigation, Next.js uses RSC payloads rather than downloading and rerunning the original Server Component implementation in the browser. Payloads may be prefetched or cached as part of navigation behavior. This distinction matters when reasoning about client JavaScript: server component implementation stays on the server, while the browser receives the rendered representation and the client code needed for interactive components.
How should you choose which components run on the client?
| Concern | Server Component | Client Component |
|---|---|---|
| Typical role | Layouts, pages, data access, and UI without browser interaction | Interactive controls and UI that needs browser-side behavior |
| State and event handlers | Not where client-side state or browser event handling belongs | Use for state, event handlers, effects, and custom hooks |
| Browser APIs | Cannot rely on browser globals such as window or localStorage |
Use when browser APIs are required |
| Client JavaScript | Implementation remains outside the client module graph | Marked module and its imports enter the client graph |
| Data and secrets | Can access data sources and keep secrets out of client code; access still requires authorization | Do not place secrets in client code |
| Boundary cost | Rendered output and serializable props can cross to the client | Boundary imports can expand the browser bundle |
A practical design is to leave the page and most of its data-backed structure on the server, then isolate the specific control that needs interaction. For instance, render a product’s descriptive content on the server and make only its quantity selector a Client Component. The goal is not to minimize client code at any cost: a boundary should still be understandable and fit the component’s responsibilities.
Rank #3
- 【Dual 23.8" Folding Screen: Double Efficiency, Save Space】 Dual monitor 4K deliver doubled workspace instantly! Eliminate window switching – collaborate with documents, code, and previews side-by-side for soaring productivity. Fold to reclaim valuable desk space in seconds.🚨Note: Due to its large size/weight, it is not recommended to carry it out for use.
- 【Pro Color + 4K Detail: Powerhouse for Creation & Entertainment】 Both screens feature 100% sRGB wide color gamut + UHD 3840×2160 resolution! Experience precise color reproduction, razor-sharp clarity, and exquisite detail. Perfect for designers color-grading, editors previewing footage, or gamers enjoying movies – dual-screen visuals redefine excellence. 🚨Note: Your device must support 4K resolution to achieve 4K picture quality.
- 【Driver-Free Setup: Plug & Play! Multi-Mode Freedom】 No drivers needed – truly plug and play! Seamlessly compatible with macOS & Windows. Instantly switch between three modes: Extend (dual-screen workflow), Duplicate (mirrored display), or Combine (ultra-wide canvas). Transition effortlessly between work and play.
- 【Flip to Share: Unlock a New Vision for Collaboration】 180° folding lets you find the perfect viewing angle. 315° flip mode turn the screen towards colleagues, activate "Duplicate Mode", and share your screen in real-time. Face-to-face collaboration has never been this intuitive and efficient.
- 【Reliable After-sales Support】 Enjoy 30-day no-questions-asked returns + 18-month full warranty! Backed by reliable quality assurance and dedicated support, explore the limitless possibilities of your 23.8-inch folding 23.8" inch dual monitor 4k with complete peace of mind.
What changed about caching in Next.js 15?
Next.js 15 changed several defaults, so older advice that treats all App Router output and data as cached by default can mislead. The Next.js team announced the release on October 21, 2024, and described the change from cached-by-default to uncached-by-default for GET Route Handlers and the Client Router Cache. The Next.js 15 release announcement summarizes the change; the version 15 caching guide is the relevant reference for that major version.
| Cache layer | What it stores | Where and how long | Next.js 15 behavior described in the guide |
|---|---|---|---|
| Request Memoization | Function results reused within a server request/render lifecycle | Within that request/render lifecycle | Do not confuse this request-scoped reuse with persistence across requests. |
| Data Cache | Data results | Persists across requests and deployments, subject to revalidation | Its behavior is separate from whether a route’s rendered output is cached. |
| Full Route Cache | Rendered HTML and RSC Payload for routes | Route-level stored output | Evaluate it separately from data and client-side navigation caching. |
| Router Cache | RSC Payload used by the client during navigation | Client-side navigation cache | Page-segment staleTime is zero by default; shared layouts and back/forward navigation retain particular caching behavior. |
In Next.js 15, fetch requests and GET Route Handlers are uncached by default. That does not mean every cache layer is disabled: opting in or out of one layer does not determine the behavior of the others. Decide which artifact should be reused, for how long, and under what revalidation conditions instead of treating “the cache” as a single switch.
This article describes Next.js 15 behavior. The current unversioned component guide was updated August 25, 2026, while the version 15 caching guide was updated July 3, 2025. For a later major version, use that version’s documentation rather than assuming these defaults still apply.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Does server rendering make a route secure?
No. Keeping data access and secrets on the server can prevent those implementation details from entering client code, but server execution does not authenticate or authorize a user by itself. Next.js security guidance warns that URL parameters and headers may be attacker-controlled. Check access when reading protected data; do not infer permission from a route name or a parameter such as ?isAdmin=true. See Next.js’s security guidance.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesRank #4
- [Tri-Mode Connection & Multi-Device Switching] The wireless gaming mouse features 2.4G wireless, Bluetooth 5.0, and USB-C wired connections to fit all usage scenarios. Whether you need a stable wired gaming mouse for competitive play, a wireless mouse for laptop daily use, or a portable bluetooth mouse for laptop multi-tasking, this computer mouse works perfectly. It supports saving up to 4 devices and one-touch switching, making it an ideal mouse for MacBook Air for office, study and gaming.
- [59g Ultra-Lightweight & Anti-Slip Ergonomic Design] Engineered for all-day comfort, this lightweight gaming mouse adopts premium materials and optimized structure to cut the weight down to only 59g. It effectively reduces hand fatigue during long work hours and extended gaming sessions. Equipped with 6 non-slip stickers, the wireless mouse offers a stable and firm grip. Designed as a practical mouse for laptop and MacBook, it delivers precise control for both daily work and intense gaming.
- [800mAh Rechargeable Battery & Long Service Life] Built with an 800mAh rechargeable battery, this wireless mouse provides up to 20 days of endurance with 5 hours of daily use. It automatically enters sleep after 1 minute of inactivity and supports wake-up via movement or clicks to save power. You can recharge it with the USB-C cable.Boasting a 10-million-click lifespan, this wireless gaming mouse maintains sensitivity and stability, serving as a daily computer mouse and professional gaming gear.
- [Adjustable DPI & Polling Rate for Precise Control] This high-performance usb c mouse comes with 6 adjustable DPI levels ranging from 800 to 12000 (default 1600) and 4 polling rate options from 125Hz to 1000Hz. You can switch sensitivity instantly via the bottom button or customize settings through the driver. It ensures ultra-smooth cursor movement, fast response and accurate tracking. Whether for delicate office editing or high-speed gaming operations, this wireless mouse for laptop meets all precision control demands.
- [Programmable Buttons & Universal Compatibility] Equipped with 6 fully programmable buttons with macro support, this bluetooth mouse allows you to customize shortcut commands and complex gaming actions to boost working and gaming efficiency. It supports mainstream systems including Windows, Mac OS, Linux and Android. Fully compatible with desktops, laptops and MacBooks, it works perfectly as a daily computer mouse, dedicated mouse for MacBook Air and practical wireless gaming mouse for diverse daily and gaming needs.
Validate and authorize mutations at the operation
React calls functions marked with 'use server' Server Functions. A framework-created reference lets a client request that a Server Function run. When it is passed through an action prop or called in an action context, it is a Server Action. The terms are related but not interchangeable; React explains the distinction in its Server Functions reference.
Exported Server Action functions can be invoked by clients, so treat their arguments as untrusted. Validate input and enforce authorization inside the operation, including when the UI already appears to limit who can call it. Rendering should read data, not perform mutations; use the mutation mechanism for writes and recheck permissions where the data is accessed.
- Authenticate the current user and verify their permission for the specific record or operation.
- Validate all action arguments, including IDs and values originating from forms or URLs.
- Apply the same authorization checks to reads as well as writes.
- Do not treat a hidden control, route segment, or client-side check as an access-control boundary.
Do Server Components make an app faster?
They can reduce JavaScript delivered to browsers when component implementation stays on the server, and Next.js identifies progressive streaming as a capability. Neither benefit guarantees that an application will be faster in every configuration. Client-boundary size, data latency, request waterfalls, rendering strategy, caching, and deployment all affect the result. Measure the actual application before making a numeric performance claim; no attributable performance statistic is established by the official sources linked here.
For implementation details that vary by version, start with the Next.js component guide and consult the versioned cache documentation for the release you deploy.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
