Course contentsShow
← React
Lesson 1662 of 2,39640. Server-Side RenderingFree lesson

Preventing Mismatches: Best Practices

Establishing patterns to avoid hydration errors: deterministic rendering, deferred side effects, and testing.

Preventing Mismatches: Best Practices

What you'll learn: How to structure your code to avoid hydration mismatches before they happen.

Now that you've seen the common causes and fixes for hydration errors, let's establish patterns that prevent these issues systematically.

The Three Pillars of Hydration Safety

1. Deterministic Rendering

Your server and client renders must produce identical output given the same props. Avoid anything non-deterministic in your initial render:

// ❌ Bad: Random values during render
function BadComponent() {
  const id = Math.random();
  return <div id={id}>Content</div>;
}

// ✅ Good: Generate in useEffect or pass as prop
function GoodComponent({ id }) {
  return <div id={id}>Content</div>;
}

2. Defer Side Effects

Anything that depends on the browser environment must wait until after hydration:

function SafeComponent() {
  const [mounted, setMounted] = useState(false);

  useEffect(() => {
    setMounted(true);
  }, []);

  // Now it's safe to use browser-only features
  if (!mounted) return <div>Loading...</div>;
  
  return <div>Width: {window.innerWidth}px</div>;
}

Think of it like this: the server is sending a blueprint, and the client must build exactly the same structure first before adding interactive features.

3. Test with SSR Enabled

Don't wait for production to discover mismatches. Run your development environment with SSR active, and consider automated tests that render both server and client versions to catch discrepancies.

The Golden Rule

If you can't guarantee a value will be identical on server and client during the initial render, move it to useEffect or use the two-pass pattern.

Key Takeaway: Prevent hydration errors by ensuring deterministic rendering, deferring browser-dependent code to useEffect, and testing with SSR enabled—catching issues during development is far easier than debugging them in production.