Cache invalidation strategies in NextJS - Step-by-Step Execution

Concept Flow - Cache invalidation strategies

Start: Data Cached

↓

Check Cache Validity

↓

Use Cache

↓

Fetch Fresh Data

↓

Update Cache

↓

End

This flow shows how cache is checked for validity, used if valid, or invalidated and refreshed if not.

Execution Sample

NextJS

export async function getStaticProps() {
  const data = await fetchData()
  return {
    props: { data },
    revalidate: 10,
  }
}

This Next.js code fetches data at build time and sets cache to revalidate every 10 seconds.

Execution Table

Step	Action	Cache State	Condition	Result
1	Initial build	Cache empty	No cache	Fetch data and cache it
2	Request at 5s	Cache valid	5 < 10 seconds	Use cached data
3	Request at 12s	Cache expired	12 > 10 seconds	Invalidate cache and fetch fresh data
4	Request at 15s	Cache valid	3 seconds since last fetch < 10	Use cached data
5	Request at 25s	Cache expired	10 seconds since last fetch	Invalidate cache and fetch fresh data
6	End	Cache updated	N/A	Stop

💡 Cache is invalidated and refreshed when time since last fetch exceeds revalidate period (10 seconds).

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
cacheTimestamp	null	0s (build time)	0s (still valid)	12s (updated)	12s (valid)	25s (updated)	25s
cacheData	null	data fetched	data reused	data refreshed	data reused	data refreshed	data refreshed

Key Moments - 2 Insights

Why does the cache get invalidated at 12 seconds but not at 5 seconds?

Because the revalidate time is 10 seconds, at 5 seconds the cache is still valid (5 < 10), but at 12 seconds it is expired (12 > 10), so it triggers invalidation and data refresh as shown in execution_table rows 2 and 3.

What happens to the cache data after invalidation?

After invalidation, fresh data is fetched and the cache is updated with new data and timestamp, as seen in execution_table rows 3 and 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the cache state at step 4?

A Cache valid

B Cache expired

C Cache empty

D Cache invalidated

💡 Hint

Check the 'Cache State' column for step 4 in the execution_table.

At which step does the cache get invalidated for the first time?

A Step 2

B Step 3

C Step 1

D Step 5

💡 Hint

Look for the first 'Cache expired' and 'Invalidate cache' action in the execution_table.

If the revalidate time changed to 20 seconds, when would the cache invalidate next after step 1?

A At 12 seconds

B At 5 seconds

C At 25 seconds

D At 21 seconds

💡 Hint

Compare the revalidate time with the timestamps in variable_tracker to find when cache expires.

Concept Snapshot

Cache Invalidation Strategies in Next.js:
- Use revalidate in getStaticProps to set cache lifetime.
- Cache is valid until revalidate seconds pass.
- After expiry, cache is invalidated and fresh data fetched.
- This keeps data fresh without rebuilding every request.
- Helps balance speed and data accuracy.

Full Transcript

This visual execution shows how Next.js cache invalidation works using the revalidate property in getStaticProps. Initially, data is fetched and cached at build time. Subsequent requests within the revalidate period use cached data. Once the revalidate time passes, the cache is invalidated and fresh data is fetched and cached again. This cycle repeats to keep data fresh while improving performance by avoiding unnecessary fetches. Variables like cacheTimestamp and cacheData track cache freshness and content. Key moments clarify why cache is used or refreshed at specific times. Quiz questions test understanding of cache state changes and timing.

Practice

1. In Next.js, which method allows you to update static pages after a certain time interval to keep data fresh without rebuilding the entire site?

easy

A. getServerSideProps without caching

B. Manually clearing browser cache

C. Using client-side useEffect to fetch data

D. getStaticProps with revalidate

Solution

1. Step 1: Understand Next.js data fetching methods

   getStaticProps generates static pages at build time, but with revalidate, it can update pages after a set interval.

2. Step 2: Compare with other methods

   getServerSideProps fetches fresh data on every request but does not use caching or revalidation intervals.

3. Final Answer:

   getStaticProps with revalidate -> Option D

4. Quick Check:

   Incremental Static Regeneration = getStaticProps + revalidate [OK]

Hint: Remember: revalidate updates static pages periodically [OK]

Common Mistakes:

• Confusing getServerSideProps with revalidation
• Thinking client-side fetching is cache invalidation
• Assuming manual browser cache clearing affects server cache

2. Which of the following is the correct way to set a revalidation time of 10 seconds in getStaticProps?

easy

A. return { props: {}, revalidate: 10 }

B. return { props: {}, revalidateTime: 10 }

C. return { props: {}, cache: 10 }

D. return { props: {}, refresh: 10 }

Solution

1. Step 1: Recall the correct property name for revalidation

   The Next.js documentation specifies revalidate as the property to set seconds for incremental static regeneration.

2. Step 2: Check the return object structure

   The return object from getStaticProps must include props and optionally revalidate with a number value.

3. Final Answer:

   return { props: {}, revalidate: 10 } -> Option A

4. Quick Check:

   Property name is revalidate [OK]

Hint: Use exact property name 'revalidate' in return object [OK]

Common Mistakes:

• Using incorrect property names like 'revalidateTime' or 'refresh'
• Placing revalidate outside the return object
• Setting revalidate as a string instead of a number

3. Consider this Next.js code snippet:

export async function getStaticProps() {
  return {
    props: { time: Date.now() },
    revalidate: 5
  };
}

What will happen if you visit this page multiple times within 5 seconds?

medium

A. The page will throw an error due to Date.now() in getStaticProps

B. The page will show the same timestamp for all visits within 5 seconds

C. The page will update the timestamp on every visit

D. The page will never update the timestamp

Solution

1. Step 1: Understand revalidate behavior

   The revalidate: 5 means Next.js will regenerate the page at most every 5 seconds.

2. Step 2: Predict output within 5 seconds

   Within 5 seconds, the cached page is served, so the timestamp remains the same for all visits.

3. Final Answer:

   The page will show the same timestamp for all visits within 5 seconds -> Option B

4. Quick Check:

   Revalidate interval caches page for 5 seconds [OK]

Hint: Revalidate caches page until interval expires [OK]

Common Mistakes:

• Assuming timestamp updates on every visit
• Thinking Date.now() causes errors in static props
• Believing revalidate disables caching

4. You wrote this code in Next.js:

export async function getStaticProps() {
  return {
    props: { data: await fetchData() },
    revalidate: '10'
  };
}

Why does this cause a problem?

medium

A. Because revalidate must be a number, not a string

B. Because fetchData cannot be awaited in getStaticProps

C. Because props must be a function, not an object

D. Because revalidate cannot be used with getStaticProps

Solution

1. Step 1: Check the type of revalidate

   The revalidate property expects a number representing seconds, not a string.

2. Step 2: Understand impact of wrong type

   Passing a string causes Next.js to throw a type error or ignore the revalidation, breaking cache invalidation.

3. Final Answer:

   revalidate must be a number, not a string -> Option A

4. Quick Check:

   Revalidate value type = number [OK]

Hint: Use number type for revalidate seconds [OK]

Common Mistakes:

• Passing revalidate as a string
• Thinking async/await is disallowed in getStaticProps
• Confusing props structure requirements

5. You want to always serve fresh data on every request in Next.js without caching. Which method should you use and why?

hard

A. Use getStaticProps without revalidate

B. Use getStaticProps with revalidate: 0

C. Use getServerSideProps because it runs on every request

D. Use client-side fetching only with useEffect

Solution

1. Step 1: Identify method for fresh data every request

   getServerSideProps runs on the server for every page request, ensuring fresh data.

2. Step 2: Compare with static methods

   getStaticProps generates static pages at build time or with revalidation intervals, so it does not guarantee fresh data every request.

3. Final Answer:

   Use getServerSideProps because it runs on every request -> Option C

4. Quick Check:

   Fresh data every request = getServerSideProps [OK]

Hint: Always fresh data? Use getServerSideProps [OK]

Common Mistakes:

• Using revalidate: 0 expecting no caching
• Relying only on client-side fetching for SEO
• Confusing static and server-side methods