React Next 2026 in Tel Aviv is one of the largest React-focused conferences in Europe and the Middle East, bringing together developers from across the region. The 2026 edition took place on June 17–18 and included dedicated sessions on identifier management in React 19 and Next.js 15 applications. UUID v7 patterns — particularly server action generation, optimistic UI, and Zustand store integration — were recurring topics across both days. See ReactConf 2025 for the earlier foundational sessions on hydration safety.

Event details

ConferenceReact Next 2026
DateJune 17–18, 2026
LocationTel Aviv, Israel
FocusUUID v7 in React 19 and Next.js 15 — server actions, optimistic UI, hydration safety

Session: The hydration problem and why server actions solve it

React 19 server actions run exclusively on the server — any call to uuidv7() inside a 'use server' function is guaranteed to execute only once, on the server, with no client-side counterpart:

// app/actions/orders.ts
'use server';

import { v7 as uuidv7 } from 'uuid';
import { db } from '@/lib/db';
import { orders } from '@/lib/schema';

export async function createOrder(formData: FormData) {
  const id = uuidv7(); // always server-side — zero hydration risk

  const order = {
    id,
    customerId: formData.get('customerId') as string,
    productId:  formData.get('productId')  as string,
    quantity:   Number(formData.get('quantity')),
    total:      Number(formData.get('total')),
  };

  await db.insert(orders).values(order);
  return { orderId: id };
}
// app/orders/new/page.tsx — Client Component using the server action
'use client';

import { createOrder } from '../actions/orders';
import { useTransition } from 'react';

export default function NewOrderPage() {
  const [isPending, startTransition] = useTransition();

  return (
    <form action={(fd) => startTransition(() => createOrder(fd))}>
      <input name="customerId" required placeholder="Customer ID" />
      <input name="productId"  required placeholder="Product ID" />
      <input name="quantity"   type="number" min="1" required />
      <input name="total"      type="number" step="0.01" required />
      <button disabled={isPending}>
        {isPending ? 'Creating…' : 'Create Order'}
      </button>
    </form>
  );
}

The uuid npm package is never bundled into the client JavaScript bundle — tree-shaking eliminates it entirely because the only import is inside a 'use server' file. See UUID in React and Next.js.

Session: Optimistic UI with UUID v7 client IDs

For interactions that need immediate UI feedback before the server confirms, the sessions presented a safe optimistic pattern using client-side UUID v7 as a temporary local key:

'use client';

import { v7 as uuidv7 } from 'uuid';
import { useOptimistic, useTransition } from 'react';
import { createOrder } from '../actions/orders';

interface Order {
  id:       string;
  total:    number;
  status:   'pending' | 'confirmed' | 'failed';
}

export function OrderList({ initialOrders }: { initialOrders: Order[] }) {
  const [isPending, startTransition] = useTransition();
  const [optimisticOrders, addOptimisticOrder] = useOptimistic(
    initialOrders,
    (current, newOrder: Order) => [...current, newOrder],
  );

  async function handleSubmit(formData: FormData) {
    const localId    = uuidv7(); // client-generated — used for optimistic display only
    const total      = Number(formData.get('total'));

    startTransition(async () => {
      // 1. Immediately show in UI with local ID
      addOptimisticOrder({ id: localId, total, status: 'pending' });

      // 2. Server assigns canonical ID — local ID is replaced after revalidation
      await createOrder(formData);
    });
  }

  return (
    <ul>
      {optimisticOrders.map(order => (
        <li key={order.id}>
          {order.id.slice(0, 8)}… — £{order.total} — {order.status}
        </li>
      ))}
    </ul>
  );
}

The local UUID v7 is used only as a key for React’s list reconciliation — the server-authoritative ID replaces it after revalidatePath. See UUID as Idempotency Keys for the pattern of sending the client UUID v7 to the server for idempotent creation.

Session: UUID v7 in Zustand stores

Client-only Zustand stores are safe for UUID generation — they never run during SSR:

// stores/cartStore.ts
import { create } from 'zustand';
import { persist } from 'zustand/middleware';
import { v7 as uuidv7 } from 'uuid';

interface CartItem {
  id:        string;
  productId: string;
  quantity:  number;
  price:     number;
}

interface CartStore {
  items:      CartItem[];
  addItem:    (productId: string, quantity: number, price: number) => string;
  removeItem: (id: string) => void;
  total:      () => number;
}

export const useCartStore = create<CartStore>()(
  persist(
    (set, get) => ({
      items: [],
      addItem: (productId, quantity, price) => {
        const id = uuidv7(); // client-only — Zustand never SSRs
        set(s => ({ items: [...s.items, { id, productId, quantity, price }] }));
        return id;
      },
      removeItem: (id) => set(s => ({ items: s.items.filter(i => i.id !== id) })),
      total:      () => get().items.reduce((sum, i) => sum + i.price * i.quantity, 0),
    }),
    { name: 'cart-storage' },
  ),
);

UUID v7’s time ordering gives localStorage-persisted cart items a natural chronological sort order without a separate addedAt timestamp. See UUID v7 for the timestamp bit layout.

Session: Server Component passing UUID to Client Component

// app/checkout/page.tsx — Server Component
import { v7 as uuidv7 } from 'uuid';
import { CheckoutForm } from './CheckoutForm';

export default async function CheckoutPage() {
  // Generate idempotency key server-side — stable for this page load
  const idempotencyKey = uuidv7();

  return (
    <main>
      <h1>Checkout</h1>
      {/* Pass as prop — serialised across server/client boundary */}
      <CheckoutForm idempotencyKey={idempotencyKey} />
    </main>
  );
}
// app/checkout/CheckoutForm.tsx — Client Component
'use client';

interface Props { idempotencyKey: string }

export function CheckoutForm({ idempotencyKey }: Props) {
  async function handleCheckout(formData: FormData) {
    const res = await fetch('/api/checkout', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Idempotency-Key': idempotencyKey, // server-generated UUID v7
      },
      body: JSON.stringify(Object.fromEntries(formData)),
    });
    // ...
  }

  return <form action={handleCheckout}>{/* … */}</form>;
}

The idempotency key pattern ensures that duplicate form submissions (double-clicks, retries) do not create duplicate orders at the API layer. See UUID as Idempotency Keys.

Attendee tips

  1. Never call uuidv7() in a component body — use server actions, useRef, or useEffect instead.
  2. The uuid package tree-shakes — importing v7 in a 'use server' file adds zero bytes to the client bundle.
  3. Optimistic ID vs server ID — use the client UUID v7 only as a React key; let the server assign the canonical database ID.
  4. Zustand is always client-only — UUID generation in Zustand actions is always safe.
  5. Idempotency keys — generate server-side in a Server Component for the most reliable pattern; the same key is passed down to all form submissions on that page load.

Further reading

External references

Frequently asked questions

Why does calling uuidv7() inside a React component body cause hydration errors?

uuidv7() called in the component body runs on both the server (during SSR) and on the client (during hydration). Because UUID generation is non-deterministic, the server and client produce different values — React's reconciler detects the mismatch and logs a hydration warning, and in strict mode it may throw. The fix is to generate UUIDs either entirely on the server (server actions, server components, API routes) or inside useRef on the client so the value is stable across re-renders. See UUID in React and Next.js.

How do I pass a server-generated UUID v7 to a client component in Next.js?

Generate the UUID in a Next.js Server Component or server action, then pass it as a prop to the Client Component. In the App Router, any async Server Component can call uuidv7() and pass the result as a serialisable string prop — Next.js serialises it across the server/client boundary automatically. Client Components receive the value as a stable prop and should store it in useState with the server value as the initial state. See the code example in the session summary below.

Is it safe to generate UUID v7 inside a React useEffect hook?

Yes — useEffect only runs on the client, never during SSR, so there is no hydration mismatch risk. This pattern is suitable for client-only IDs such as local draft keys or optimistic update identifiers that never reach the server. For IDs that are inserted into a database or sent in API requests, generate on the server instead — server-generated IDs provide a single authoritative value and avoid the need for server-side UUID re-validation. See UUID Generation Strategies.