I Cut My Next.js + Supabase App Load Time by 73% - Here Are the 5 Techniques That Actually Worked#

Last month, our SaaS dashboard was embarrassingly slow. 4.2 seconds to load the main page. Users were complaining. Conversion rates were tanking.

Today? 1.1 seconds. 73% faster.

Here's exactly what worked (and what didn't).

The Problem: Death by a Thousand Database Calls#

Our dashboard showed user projects, team members, recent activity, and notifications. Sounds simple, right?

Wrong.

Each component was making its own database calls. The projects list fetched projects, then made separate calls for each project's stats. The activity feed loaded events, then fetched user details for each event.

Classic N+1 query problem, but worse.

Technique #1: Strategic Data Fetching Consolidation#

Before: 47 database calls to load the dashboard After: 3 database calls

The fix wasn't fancy. We consolidated related data into single queries using Supabase's nested select syntax:

// ❌ Before: Multiple separate calls
const projects = await supabase.from('projects').select('*')
const stats = await Promise.all(
  projects.map(p => supabase.from('project_stats').select('*').eq('project_id', p.id))
)

// ✅ After: Single consolidated call
const projects = await supabase
  .from('projects')
  .select(`
    *,
    project_stats(*),
    team_members(count),
    recent_activity:activities(*, user:users(name, avatar_url))
  `)
  .limit(10)

Result: Dashboard load time dropped from 4.2s to 2.8s (33% improvement)

Technique #2: Aggressive Caching with Smart Invalidation#

Most dashboard data doesn't change every second. We implemented a three-tier caching strategy:

// Static data: Cache indefinitely
const categories = await supabase
  .from('categories')
  .select('*')
  .cache({ revalidate: false })

// Semi-static data: Cache with revalidation
const userProjects = await supabase
  .from('projects')
  .select('*')
  .eq('user_id', userId)
  .cache({ revalidate: 300 }) // 5 minutes

// Dynamic data: Cache briefly
const notifications = await supabase
  .from('notifications')
  .select('*')
  .eq('user_id', userId)
  .cache({ revalidate: 30 }) // 30 seconds

We also added smart cache invalidation using Supabase's realtime subscriptions:

// Invalidate cache when data changes
supabase
  .channel('projects')
  .on('postgres_changes', 
    { event: '*', schema: 'public', table: 'projects' },
    () => {
      // Invalidate projects cache
      router.refresh()
    }
  )
  .subscribe()

Result: Load time dropped to 1.8s (another 36% improvement)

Technique #3: Bundle Size Surgery#

Our JavaScript bundle was massive. 847KB of compressed JS for a dashboard that should be lightweight.

The culprits:

• Moment.js (67KB) - replaced with date-fns (12KB)
• Lodash (entire library) - replaced with individual functions
• Chart.js (45KB) - replaced with lightweight Recharts
• Unused Supabase features - tree-shook the client

// ❌ Before: Importing entire libraries
import moment from 'moment'
import _ from 'lodash'
import { createClient } from '@supabase/supabase-js'

// ✅ After: Surgical imports
import { format, parseISO } from 'date-fns'
import { debounce, groupBy } from 'lodash-es'
import { createBrowserClient } from '@supabase/ssr'

Result: Bundle size dropped from 847KB to 312KB. Load time: 1.4s (22% improvement)

Technique #4: Image Optimization That Actually Works#

We had profile pictures, project thumbnails, and file previews scattered throughout the dashboard. All unoptimized.

The game-changer was Supabase's image transformation API combined with Next.js Image component:

// ❌ Before: Full-resolution images
<img src={`${supabaseUrl}/storage/v1/object/public/avatars/${user.avatar}`} />

// ✅ After: Optimized with transformations
<Image
  src={`${supabaseUrl}/storage/v1/render/image/public/avatars/${user.avatar}?width=64&height=64&quality=85`}
  width={64}
  height={64}
  alt={user.name}
  priority={index < 3} // Prioritize above-the-fold images
/>

For file previews, we implemented lazy loading with intersection observer:

const [isVisible, setIsVisible] = useState(false)
const imgRef = useRef<HTMLImageElement>(null)

useEffect(() => {
  const observer = new IntersectionObserver(
    ([entry]) => {
      if (entry.isIntersecting) {
        setIsVisible(true)
        observer.disconnect()
      }
    },
    { threshold: 0.1 }
  )

  if (imgRef.current) observer.observe(imgRef.current)
  return () => observer.disconnect()
}, [])

Result: Load time dropped to 1.2s (14% improvement)

Technique #5: Database Connection Pooling#

This one's subtle but crucial for production apps. We were hitting Supabase's connection limits during peak usage, causing timeouts.

The fix was enabling connection pooling in Supabase and optimizing our client configuration:

// Enable connection pooling in Supabase Dashboard
// Database → Settings → Connection Pooling → Enable

// Use pooled connection string
const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
  {
    db: {
      schema: 'public',
    },
    auth: {
      persistSession: true,
      autoRefreshToken: true,
    },
    global: {
      headers: { 'x-my-custom-header': 'my-app-name' },
    },
  }
)

We also implemented connection cleanup in our API routes:

// app/api/dashboard/route.ts
export async function GET() {
  const supabase = createClient()
  
  try {
    const data = await supabase.from('projects').select('*')
    return Response.json(data)
  } finally {
    // Cleanup happens automatically with Supabase client
    // But ensure no hanging promises
  }
}

Result: Final load time: 1.1s (8% improvement)

The One Thing That Didn't Work#

Server-side rendering everything.

We tried moving all data fetching to the server, thinking it would be faster. It wasn't. The server-side rendering time increased, and we lost the benefits of client-side caching.

The sweet spot was hybrid: server-render the initial page structure, then hydrate with cached client-side data.

Quick Win You Can Implement Today#

Add this to your Supabase queries right now:

// Add .limit() to prevent accidentally fetching thousands of rows
const projects = await supabase
  .from('projects')
  .select('*')
  .limit(50) // ← Add this
  .order('created_at', { ascending: false })

I've seen apps accidentally fetch 10,000+ rows because they forgot pagination. This simple addition prevents that.

The Results#

• Load time: 4.2s → 1.1s (73% faster)
• First Contentful Paint: 2.1s → 0.8s
• Largest Contentful Paint: 3.8s → 1.3s
• Cumulative Layout Shift: 0.15 → 0.02
• User complaints: Daily → Zero in 3 weeks

What's Next?#

These optimizations bought us time, but we're not stopping here. Next up:

• Edge caching with Vercel's Edge Runtime
• Database query optimization with custom indexes
• Real-time updates without polling

Want the complete performance audit checklist? I've documented every step of this optimization process in our comprehensive performance guide.

For more advanced techniques, check out our guides on Supabase caching strategies and database optimization.

What's the slowest part of your Next.js + Supabase app? Let me know in the comments - I might have a solution.