diff --git a/astro.config.mjs b/astro.config.mjs
index d59e758..1b19b5b 100644
--- a/astro.config.mjs
+++ b/astro.config.mjs
@@ -7,6 +7,12 @@ export default defineConfig({
   adapter: cloudflare(),
   integrations: [react()],
   vite: {
+    build: {
+      sourcemap: false,
+    },
+    optimizeDeps: {
+      include: ["@tabler/icons-react"],
+    },
     resolve: {
       alias: {
         "@cdransf": "node_modules/@cdransf",
diff --git a/src/pages/posts/[...page].astro b/src/pages/posts/[...page].astro
index d38eb4b..395d6e1 100644
--- a/src/pages/posts/[...page].astro
+++ b/src/pages/posts/[...page].astro
@@ -49,7 +49,7 @@ const pagination = {
             </time>
           </div>
           <h3>
-            <a href={post.slug}>{post.title}</a>
+            <a href={post.url}>{post.title}</a>
           </h3>
           <p set:html={md(post.description)}></p>
         </article>
diff --git a/src/utils/data/activity.js b/src/utils/data/activity.js
index b4d91e3..427de8a 100644
--- a/src/utils/data/activity.js
+++ b/src/utils/data/activity.js
@@ -1,24 +1,24 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
+let cachedActivity = null;
+
 export async function fetchActivity() {
-  try {
-    const { data, error } = await supabase
-      .from('optimized_all_activity')
-      .select('feed');
+  if (import.meta.env.MODE === "development" && cachedActivity)
+    return cachedActivity;
 
-    if (error) {
-      console.error('Error fetching activity data:', error);
-      return [];
-    }
+  const { data, error } = await supabase
+    .from("optimized_all_activity")
+    .select("feed");
 
-    const [{ feed } = {}] = data || [];
-    return feed?.filter((item) => item.feed !== null) || [];
-  } catch (error) {
-    console.error('Unexpected error fetching activity data:', error);
-    return [];
-  }
-}
\ No newline at end of file
+  if (error) return [];
+  const [{ feed } = {}] = data || [];
+  const filteredFeed = feed?.filter((item) => item.feed !== null) || [];
+
+  if (import.meta.env.MODE === "development") cachedActivity = filteredFeed;
+
+  return filteredFeed;
+};
diff --git a/src/utils/data/albumReleases.js b/src/utils/data/albumReleases.js
index 363988b..37cb246 100644
--- a/src/utils/data/albumReleases.js
+++ b/src/utils/data/albumReleases.js
@@ -5,39 +5,34 @@ const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
+let cachedAlbumReleases = null;
+
 export async function fetchAlbumReleases() {
-  try {
-    const today = DateTime.utc().startOf('day').toSeconds();
+  if (import.meta.env.MODE === 'development' && cachedAlbumReleases) return cachedAlbumReleases;
 
-    const { data, error } = await supabase
-      .from('optimized_album_releases')
-      .select('*');
+  const today = DateTime.utc().startOf('day').toSeconds();
 
-    if (error) {
-      console.error('Error fetching album releases:', error);
-      return { all: [], upcoming: [] };
-    }
+  const { data, error } = await supabase
+    .from('optimized_album_releases')
+    .select('*');
 
-    const all = data
-      .map((album) => {
-        const releaseDate = DateTime.fromSeconds(album.release_timestamp)
-          .toUTC()
-          .startOf('day');
+  if (error) return { all: [], upcoming: [] };
 
-        return {
-          ...album,
-          description: album.artist.description,
-          date: releaseDate.toLocaleString(DateTime.DATE_FULL),
-          timestamp: releaseDate.toSeconds(),
-        };
-      })
-      .sort((a, b) => a.timestamp - b.timestamp);
+  const all = data
+    .map((album) => {
+      const releaseDate = DateTime.fromSeconds(album.release_timestamp).toUTC().startOf('day');
+      return {
+        ...album,
+        description: album.artist.description,
+        date: releaseDate.toLocaleString(DateTime.DATE_FULL),
+        timestamp: releaseDate.toSeconds(),
+      };
+    })
+    .sort((a, b) => a.timestamp - b.timestamp);
 
-    const upcoming = all.filter((album) => album.release_timestamp > today);
+  const upcoming = all.filter((album) => album.release_timestamp > today);
 
-    return { all, upcoming };
-  } catch (error) {
-    console.error('Unexpected error processing album releases:', error);
-    return { all: [], upcoming: [] };
-  }
-}
\ No newline at end of file
+  if (import.meta.env.MODE === 'development') cachedAlbumReleases = { all, upcoming };
+
+  return { all, upcoming };
+};
\ No newline at end of file
diff --git a/src/utils/data/artists.js b/src/utils/data/artists.js
index bd1c940..b5482dc 100644
--- a/src/utils/data/artists.js
+++ b/src/utils/data/artists.js
@@ -1,38 +1,40 @@
-import { createClient } from '@supabase/supabase-js';
-import { parseCountryField } from '@utils/helpers.js';
+import { createClient } from "@supabase/supabase-js";
+import { parseCountryField } from "@utils/helpers.js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
 
-export async function fetchArtists(){
+let cachedArtists = null;
+
+export async function fetchArtists() {
+  if (import.meta.env.MODE === "development" && cachedArtists)
+    return cachedArtists;
+
+  const PAGE_SIZE = 1000;
   let artists = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_artists')
-      .select('*')
+      .from("optimized_artists")
+      .select("*")
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
-      console.error('Error fetching artists:', error);
-      break;
-    }
+    if (error) break;
 
-    // Process and concatenate artists data
     artists = artists.concat(
       data.map((artist) => ({
         ...artist,
-        country: parseCountryField(artist['country']),
+        country: parseCountryField(artist["country"]),
       }))
     );
 
-    // Break if no more data
     if (data.length < PAGE_SIZE) break;
     rangeStart += PAGE_SIZE;
   }
 
+  if (import.meta.env.MODE === "development") cachedArtists = artists;
+
   return artists;
-};
\ No newline at end of file
+};
diff --git a/src/utils/data/blogroll.js b/src/utils/data/blogroll.js
index d8f5fc7..5d0441d 100644
--- a/src/utils/data/blogroll.js
+++ b/src/utils/data/blogroll.js
@@ -1,22 +1,28 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
+let cachedBlogroll = null;
+
 export async function fetchBlogroll() {
+  if (import.meta.env.MODE === "development" && cachedBlogroll)
+    return cachedBlogroll;
+
   const { data, error } = await supabase
-    .from('authors')
-    .select('*')
-    .eq('blogroll', true)
-    .order('name', { ascending: true });
+    .from("authors")
+    .select("*")
+    .eq("blogroll", true)
+    .order("name", { ascending: true });
 
-  if (error) {
-    console.error('Error fetching authors for the blogroll:', error);
-    return [];
-  }
+  if (error) return [];
 
-  return data.sort((a, b) =>
+  const sortedData = data.sort((a, b) =>
     a.name.toLowerCase().localeCompare(b.name.toLowerCase())
   );
-};
\ No newline at end of file
+
+  if (import.meta.env.MODE === "development") cachedBlogroll = sortedData;
+
+  return sortedData;
+};
diff --git a/src/utils/data/books.js b/src/utils/data/books.js
index cd3e7c5..a693225 100644
--- a/src/utils/data/books.js
+++ b/src/utils/data/books.js
@@ -1,25 +1,26 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedBooks = null;
 
 export async function fetchBooks() {
+  if (import.meta.env.MODE === "development" && cachedBooks) return cachedBooks;
+
+  const PAGE_SIZE = 1000;
   let books = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_books')
-      .select('*')
-      .order('date_finished', { ascending: false })
+      .from("optimized_books")
+      .select("*")
+      .order("date_finished", { ascending: false })
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
-      console.error('Error fetching books:', error);
-      break;
-    }
+    if (error) break;
 
     books = books.concat(data);
     if (data.length < PAGE_SIZE) break;
@@ -39,12 +40,17 @@ export async function fetchBooks() {
   const sortedByYear = Object.values(years).filter((year) => year.value > 2017);
   const currentYear = new Date().getFullYear();
   const booksForCurrentYear =
-    sortedByYear.find((yearGroup) => yearGroup.value === currentYear)?.data || [];
+    sortedByYear.find((yearGroup) => yearGroup.value === currentYear)?.data ||
+    [];
 
-  return {
+  const result = {
     all: books,
     years: sortedByYear,
     currentYear: booksForCurrentYear,
     feed: books.filter((book) => book.feed),
   };
-};
\ No newline at end of file
+
+  if (import.meta.env.MODE === "development") cachedBooks = result;
+
+  return result;
+};
diff --git a/src/utils/data/concerts.js b/src/utils/data/concerts.js
index 8b67982..301115f 100644
--- a/src/utils/data/concerts.js
+++ b/src/utils/data/concerts.js
@@ -1,32 +1,38 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedConcerts = null;
 
 export async function fetchConcertsData() {
+  if (import.meta.env.MODE === "development" && cachedConcerts)
+    return cachedConcerts;
+
+  const PAGE_SIZE = 1000;
   let concerts = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_concerts')
-      .select('*')
+      .from("optimized_concerts")
+      .select("*")
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
-      console.error('Error fetching concerts:', error);
-      break;
-    }
+    if (error) break;
 
     concerts = concerts.concat(data);
     if (data.length < PAGE_SIZE) break;
     rangeStart += PAGE_SIZE;
   }
 
-  return concerts.map((concert) => ({
+  const result = concerts.map((concert) => ({
     ...concert,
     artist: concert.artist || { name: concert.artist_name_string, url: null },
   }));
-};
\ No newline at end of file
+
+  if (import.meta.env.MODE === "development") cachedConcerts = result;
+
+  return result;
+};
diff --git a/src/utils/data/genres.js b/src/utils/data/genres.js
index fc1f1c5..fd0d7a4 100644
--- a/src/utils/data/genres.js
+++ b/src/utils/data/genres.js
@@ -1,18 +1,19 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-export async function fetchGenres() {
-  const { data, error } = await supabase
-    .from('optimized_genres')
-    .select('*');
+let cachedGenres = null;
 
-  if (error) {
-    console.error('Error fetching genres with artists:', error);
-    return [];
-  }
+export async function fetchGenres() {
+  if (import.meta.env.MODE === "development" && cachedGenres)
+    return cachedGenres;
+
+  const { data, error } = await supabase.from("optimized_genres").select("*");
+
+  if (error) return [];
+  if (import.meta.env.MODE === "development") cachedGenres = data;
 
   return data;
-};
\ No newline at end of file
+};
diff --git a/src/utils/data/globals.js b/src/utils/data/globals.js
index 80f1750..f33d644 100644
--- a/src/utils/data/globals.js
+++ b/src/utils/data/globals.js
@@ -1,19 +1,23 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
+let cachedGlobals = null;
+
 export async function fetchGlobals() {
+  const isDev = import.meta.env.MODE === "development";
+
+  if (isDev && cachedGlobals) return cachedGlobals;
+
   const { data, error } = await supabase
-    .from('optimized_globals')
-    .select('*')
+    .from("optimized_globals")
+    .select("*")
     .single();
 
-  if (error) {
-    console.error('Error fetching globals:', error);
-    return {};
-  }
+  if (error) return {};
+  if (isDev) cachedGlobals = data;
 
   return data;
-}
+};
diff --git a/src/utils/data/links.js b/src/utils/data/links.js
index e73cc15..e67870f 100644
--- a/src/utils/data/links.js
+++ b/src/utils/data/links.js
@@ -1,31 +1,33 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedLinks = null;
 
 export async function fetchLinks() {
+  if (import.meta.env.MODE === "development" && cachedLinks) return cachedLinks;
+
+  const PAGE_SIZE = 1000;
   let links = [];
   let page = 0;
   let fetchMore = true;
 
   while (fetchMore) {
     const { data, error } = await supabase
-      .from('optimized_links')
-      .select('*')
+      .from("optimized_links")
+      .select("*")
       .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
 
-    if (error) {
-      console.error('Error fetching links:', error);
-      return links;
-    }
-
+    if (error) return links;
     if (data.length < PAGE_SIZE) fetchMore = false;
 
     links = links.concat(data);
     page++;
   }
 
+  if (import.meta.env.MODE === "development") cachedLinks = links;
+
   return links;
-};
\ No newline at end of file
+};
diff --git a/src/utils/data/movies.js b/src/utils/data/movies.js
index 10f0967..38dfa60 100644
--- a/src/utils/data/movies.js
+++ b/src/utils/data/movies.js
@@ -1,25 +1,27 @@
-import { createClient } from '@supabase/supabase-js';
-import { DateTime } from 'luxon';
+import { createClient } from "@supabase/supabase-js";
+import { DateTime } from "luxon";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedMovies = null;
 
 export async function fetchMovies() {
+  if (import.meta.env.MODE === "development" && cachedMovies)
+    return cachedMovies;
+
+  const PAGE_SIZE = 1000;
   let movies = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_movies')
-      .select('*')
+      .from("optimized_movies")
+      .select("*")
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
-      console.error('Error fetching movies:', error);
-      break;
-    }
+    if (error) break;
 
     movies = movies.concat(data);
     if (data.length < PAGE_SIZE) break;
@@ -27,16 +29,22 @@ export async function fetchMovies() {
   }
 
   const year = DateTime.now().year;
-  const favoriteMovies = movies.filter(movie => movie.favorite);
+  const favoriteMovies = movies.filter((movie) => movie.favorite);
   const recentlyWatchedMovies = movies.filter(
-    movie => movie.last_watched && year - DateTime.fromISO(movie.last_watched).year <= 3
+    (movie) =>
+      movie.last_watched &&
+      year - DateTime.fromISO(movie.last_watched).year <= 3
   );
 
-  return {
+  const result = {
     movies,
-    watchHistory: movies.filter(movie => movie.last_watched),
+    watchHistory: movies.filter((movie) => movie.last_watched),
     recentlyWatched: recentlyWatchedMovies,
     favorites: favoriteMovies.sort((a, b) => a.title.localeCompare(b.title)),
-    feed: movies.filter(movie => movie.feed),
+    feed: movies.filter((movie) => movie.feed),
   };
-};
\ No newline at end of file
+
+  if (import.meta.env.MODE === "development") cachedMovies = result;
+
+  return result;
+};
diff --git a/src/utils/data/music.js b/src/utils/data/music.js
index 3f00c95..dca1773 100644
--- a/src/utils/data/music.js
+++ b/src/utils/data/music.js
@@ -1,11 +1,17 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedMusicData = null;
 
 export async function fetchMusicData() {
+  if (import.meta.env.MODE === "development" && cachedMusicData)
+    return cachedMusicData;
+
+  const PAGE_SIZE = 1000;
+
   const fetchDataFromView = async (viewName) => {
     let rows = [];
     let rangeStart = 0;
@@ -13,18 +19,12 @@ export async function fetchMusicData() {
     while (true) {
       const { data, error } = await supabase
         .from(viewName)
-        .select('*')
+        .select("*")
         .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-      if (error) {
-        console.error(`Error fetching data from view ${viewName}:`, error);
-        break;
-      }
-
-      if (data.length === 0) break;
+      if (error || data.length === 0) break;
 
       rows = [...rows, ...data];
-
       if (data.length < PAGE_SIZE) break;
       rangeStart += PAGE_SIZE;
     }
@@ -32,48 +32,51 @@ export async function fetchMusicData() {
     return rows;
   };
 
-  try {
-    const [
-      recentTracks,
-      weekTracks,
-      weekArtists,
-      weekAlbums,
-      weekGenres,
-      monthTracks,
-      monthArtists,
-      monthAlbums,
-      monthGenres,
-    ] = await Promise.all([
-      fetchDataFromView('recent_tracks'),
-      fetchDataFromView('week_tracks'),
-      fetchDataFromView('week_artists'),
-      fetchDataFromView('week_albums'),
-      fetchDataFromView('week_genres'),
-      fetchDataFromView('month_tracks'),
-      fetchDataFromView('month_artists'),
-      fetchDataFromView('month_albums'),
-      fetchDataFromView('month_genres'),
-    ]);
+  const [
+    recentTracks,
+    weekTracks,
+    weekArtists,
+    weekAlbums,
+    weekGenres,
+    monthTracks,
+    monthArtists,
+    monthAlbums,
+    monthGenres,
+  ] = await Promise.all([
+    fetchDataFromView("recent_tracks"),
+    fetchDataFromView("week_tracks"),
+    fetchDataFromView("week_artists"),
+    fetchDataFromView("week_albums"),
+    fetchDataFromView("week_genres"),
+    fetchDataFromView("month_tracks"),
+    fetchDataFromView("month_artists"),
+    fetchDataFromView("month_albums"),
+    fetchDataFromView("month_genres"),
+  ]);
 
-    return {
-      recent: recentTracks,
-      week: {
-        tracks: weekTracks,
-        artists: weekArtists,
-        albums: weekAlbums,
-        genres: weekGenres,
-        totalTracks: weekTracks.reduce((acc, track) => acc + track.plays, 0).toLocaleString('en-US'),
-      },
-      month: {
-        tracks: monthTracks,
-        artists: monthArtists,
-        albums: monthAlbums,
-        genres: monthGenres,
-        totalTracks: monthTracks.reduce((acc, track) => acc + track.plays, 0).toLocaleString('en-US'),
-      },
-    };
-  } catch (error) {
-    console.error('Error fetching and processing music data:', error);
-    return {};
-  }
-};
\ No newline at end of file
+  const result = {
+    recent: recentTracks,
+    week: {
+      tracks: weekTracks,
+      artists: weekArtists,
+      albums: weekAlbums,
+      genres: weekGenres,
+      totalTracks: weekTracks
+        .reduce((acc, track) => acc + track.plays, 0)
+        .toLocaleString("en-US"),
+    },
+    month: {
+      tracks: monthTracks,
+      artists: monthArtists,
+      albums: monthAlbums,
+      genres: monthGenres,
+      totalTracks: monthTracks
+        .reduce((acc, track) => acc + track.plays, 0)
+        .toLocaleString("en-US"),
+    },
+  };
+
+  if (import.meta.env.MODE === "development") cachedMusicData = result;
+
+  return result;
+};
diff --git a/src/utils/data/nav.js b/src/utils/data/nav.js
index 5a678e6..e259ee4 100644
--- a/src/utils/data/nav.js
+++ b/src/utils/data/nav.js
@@ -1,39 +1,39 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = import.meta.env.SUPABASE_URL
-const SUPABASE_KEY = import.meta.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = import.meta.env.SUPABASE_URL;
+const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+let cachedNavigation = null;
 
 export async function fetchNavigation() {
-  const { data, error } = await supabase
-    .from('optimized_navigation')
-    .select('*')
+  if (import.meta.env.MODE === "development" && cachedNavigation)
+    return cachedNavigation;
 
-  if (error) {
-    console.error('Error fetching navigation data:', error)
-    return {}
-  }
+  const { data, error } = await supabase
+    .from("optimized_navigation")
+    .select("*");
+  if (error) return {};
 
   const menu = data.reduce((acc, item) => {
     const menuItem = {
-      title: item['title'] || item['page_title'],
-      permalink: item['permalink'] || item ['page_permalink'],
-      icon: item['icon'],
-      sort: item['sort']
-    }
+      title: item["title"] || item["page_title"],
+      permalink: item["permalink"] || item["page_permalink"],
+      icon: item["icon"],
+      sort: item["sort"],
+    };
 
-    if (!acc[item['menu_location']]) {
-      acc[item['menu_location']] = [menuItem]
-    } else {
-      acc[item['menu_location']].push(menuItem)
-    }
+    if (!acc[item["menu_location"]]) acc[item["menu_location"]] = [menuItem];
+    else acc[item["menu_location"]].push(menuItem);
 
-    return acc
-  }, {})
+    return acc;
+  }, {});
 
-  Object.keys(menu).forEach(location => {
-    menu[location].sort((a, b) => a['sort'] - b['sort'])
-  })
+  Object.keys(menu).forEach((location) => {
+    menu[location].sort((a, b) => a["sort"] - b["sort"]);
+  });
 
-  return menu
-}
\ No newline at end of file
+  if (import.meta.env.MODE === "development") cachedNavigation = menu;
+
+  return menu;
+};
diff --git a/src/utils/data/nowPlaying.js b/src/utils/data/nowPlaying.js
index f2fbca2..836143a 100644
--- a/src/utils/data/nowPlaying.js
+++ b/src/utils/data/nowPlaying.js
@@ -1,24 +1,31 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = import.meta.env.SUPABASE_URL
-const SUPABASE_KEY = import.meta.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = import.meta.env.SUPABASE_URL;
+const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+let cachedNowPlaying = null;
 
 export async function fetchNowPlaying() {
+  if (import.meta.env.MODE === "development" && cachedNowPlaying)
+    return cachedNowPlaying;
+
   const { data, error } = await supabase
-    .from('optimized_latest_listen')
-    .select('*')
-    .single()
+    .from("optimized_latest_listen")
+    .select("*")
+    .single();
+  if (error) return {};
 
-  if (error) {
-    console.error('Error fetching the latest track:', error)
-    return {}
-  }
+  const genreEmoji = data.genre_emoji;
+  const emoji = data.artist_emoji || genreEmoji;
 
-  const genreEmoji = data.genre_emoji
-  const emoji = data.artist_emoji || genreEmoji
+  const result = {
+    content: `${emoji || "🎧"} ${
+      data.track_name
+    } by <a href="https://coryd.dev${data.url}">${data.artist_name}</a>`,
+  };
 
-  return {
-    content: `${emoji || '🎧'} ${data.track_name} by <a href="https://coryd.dev${data.url}">${data.artist_name}</a>`,
-  }
-}
\ No newline at end of file
+  if (import.meta.env.MODE === "development") cachedNowPlaying = result;
+
+  return result;
+};
diff --git a/src/utils/data/pages.js b/src/utils/data/pages.js
index 795e619..e9a79ac 100644
--- a/src/utils/data/pages.js
+++ b/src/utils/data/pages.js
@@ -1,16 +1,18 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-export async function fetchPages() {
-  const { data, error } = await supabase.from('optimized_pages').select('*');
+let cachedPages = null;
 
-  if (error) {
-    console.error('Error fetching pages:', error);
-    return [];
-  }
+export async function fetchPages() {
+  if (import.meta.env.MODE === "development" && cachedPages) return cachedPages;
+
+  const { data, error } = await supabase.from("optimized_pages").select("*");
+  if (error) return [];
+
+  if (import.meta.env.MODE === "development") cachedPages = data;
 
   return data;
-}
\ No newline at end of file
+};
diff --git a/src/utils/data/posts.js b/src/utils/data/posts.js
index 770137f..3025e31 100644
--- a/src/utils/data/posts.js
+++ b/src/utils/data/posts.js
@@ -1,32 +1,35 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = import.meta.env['SUPABASE_URL']
-const SUPABASE_KEY = import.meta.env['SUPABASE_KEY']
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = import.meta.env["SUPABASE_URL"];
+const SUPABASE_KEY = import.meta.env["SUPABASE_KEY"];
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+let cachedPosts = null;
 
 export async function fetchAllPosts() {
-  let posts = []
-  let page = 0
-  let fetchMore = true
+  if (import.meta.env.MODE === "development" && cachedPosts) return cachedPosts;
+
+  const PAGE_SIZE = 1000;
+  let posts = [];
+  let page = 0;
+  let fetchMore = true;
 
   while (fetchMore) {
     const { data, error } = await supabase
-      .from('optimized_posts')
-      .select('*')
-      .order('date', { ascending: false })
-      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1)
+      .from("optimized_posts")
+      .select("*")
+      .order("date", { ascending: false })
+      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
 
-    if (error) {
-      console.error('Error fetching posts:', error)
-      return posts
-    }
+    if (error) return posts;
 
-    if (data.length < PAGE_SIZE) fetchMore = false
+    if (data.length < PAGE_SIZE) fetchMore = false;
 
-    posts = posts.concat(data)
-    page++
+    posts = posts.concat(data);
+    page++;
   }
 
-  return posts
-}
\ No newline at end of file
+  if (import.meta.env.MODE === "development") cachedPosts = posts;
+
+  return posts;
+};
diff --git a/src/utils/data/robots.js b/src/utils/data/robots.js
index a64ebac..1654058 100644
--- a/src/utils/data/robots.js
+++ b/src/utils/data/robots.js
@@ -1,29 +1,35 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 500;
+
+let cachedRobots = null;
 
 export async function fetchAllRobots() {
+  if (import.meta.env.MODE === "development" && cachedRobots)
+    return cachedRobots;
+
+  const PAGE_SIZE = 500;
   let robots = [];
   let from = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('robots')
-      .select('user_agent')
+      .from("robots")
+      .select("user_agent")
       .range(from, from + PAGE_SIZE - 1);
 
-    if (error) {
-      console.error('Error fetching robot data:', error);
-      return [];
-    }
+    if (error) return [];
 
     robots = robots.concat(data);
     if (data.length < PAGE_SIZE) break;
     from += PAGE_SIZE;
   }
 
-  return robots.map((robot) => robot['user_agent']).sort();
-};
\ No newline at end of file
+  const result = robots.map((robot) => robot["user_agent"]).sort();
+
+  if (import.meta.env.MODE === "development") cachedRobots = result;
+
+  return result;
+};
diff --git a/src/utils/data/search.js b/src/utils/data/search.js
deleted file mode 100644
index c779e91..0000000
--- a/src/utils/data/search.js
+++ /dev/null
@@ -1,19 +0,0 @@
-import { createClient } from '@supabase/supabase-js'
-
-const SUPABASE_URL = import.meta.env.SUPABASE_URL
-const SUPABASE_KEY = import.meta.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-
-export async function fetchSearchIndex() {
-  const { data, error } = await supabase
-    .from('optimized_search_index')
-    .select('search_index')
-
-  if (error) {
-    console.error('Error fetching search index data:', error)
-    return []
-  }
-
-  const [{ search_index } = {}] = data
-  return search_index || []
-}
\ No newline at end of file
diff --git a/src/utils/data/syndication.js b/src/utils/data/syndication.js
index 291f262..652d41b 100644
--- a/src/utils/data/syndication.js
+++ b/src/utils/data/syndication.js
@@ -1,20 +1,24 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-export default async function fetchSyndication() {
-  const { data, error } = await supabase
-    .from('optimized_syndication')
-    .select('syndication');
+let cachedSyndication = null;
 
-  if (error) {
-    console.error('Error fetching syndication data:', error);
-    return [];
-  }
+export default async function fetchSyndication() {
+  if (import.meta.env.MODE === "development" && cachedSyndication)
+    return cachedSyndication;
+
+  const { data, error } = await supabase
+    .from("optimized_syndication")
+    .select("syndication");
+  if (error) return [];
 
   const [{ syndication } = {}] = data;
+  const result = syndication?.filter((item) => item.syndication !== null) || [];
 
-  return syndication?.filter((item) => item.syndication !== null) || [];
-}
\ No newline at end of file
+  if (import.meta.env.MODE === "development") cachedSyndication = result;
+
+  return result;
+};
diff --git a/src/utils/data/tv.js b/src/utils/data/tv.js
index 109612d..01a6deb 100644
--- a/src/utils/data/tv.js
+++ b/src/utils/data/tv.js
@@ -1,46 +1,53 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedShows = null;
 
 export const fetchShows = async () => {
+  if (import.meta.env.MODE === "development" && cachedShows) return cachedShows;
+
+  const PAGE_SIZE = 1000;
   let shows = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_shows')
-      .select('*')
+      .from("optimized_shows")
+      .select("*")
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
-      console.error('Error fetching shows:', error);
-      break;
-    }
+    if (error) break;
 
     shows = shows.concat(data);
     if (data.length < PAGE_SIZE) break;
     rangeStart += PAGE_SIZE;
   }
 
-  const watchedShows = shows.filter(show => show['last_watched_at'] !== null);
-  const episodes = watchedShows.map(show => ({
-    title: show['episode']['title'],
-    year: show['year'],
-    formatted_episode: show['episode']['formatted_episode'],
-    url: show['episode']['url'],
-    image: show['episode']['image'],
-    backdrop: show['episode']['backdrop'],
-    last_watched_at: show['episode']['last_watched_at'],
-    grid: show['grid'],
-    type: 'tv'
+  const watchedShows = shows.filter((show) => show["last_watched_at"] !== null);
+  const episodes = watchedShows.map((show) => ({
+    title: show["episode"]["title"],
+    year: show["year"],
+    formatted_episode: show["episode"]["formatted_episode"],
+    url: show["episode"]["url"],
+    image: show["episode"]["image"],
+    backdrop: show["episode"]["backdrop"],
+    last_watched_at: show["episode"]["last_watched_at"],
+    grid: show["grid"],
+    type: "tv",
   }));
 
-  return {
+  const result = {
     shows,
     recentlyWatched: episodes.slice(0, 225),
-    favorites: shows.filter(show => show.favorite).sort((a, b) => a.title.localeCompare(b.title)),
+    favorites: shows
+      .filter((show) => show.favorite)
+      .sort((a, b) => a.title.localeCompare(b.title)),
   };
-};
\ No newline at end of file
+
+  if (import.meta.env.MODE === "development") cachedShows = result;
+
+  return result;
+};