Supabase Local Development: Complete Workflow Guide

Modern web development demands robust local environments that mirror production while enabling rapid iteration. Supabase, the open-source Firebase alternative, provides a comprehensive local development stack that brings the full power of PostgreSQL, real-time subscriptions, authentication, and serverless functions to your development machine. This guide covers everything you need to establish a professional Supabase local development workflow that scales from solo projects to enterprise teams.

For those new to Supabase, our Getting Started guide provides the foundational knowledge needed before diving into local development workflows.

Getting Started with the Supabase CLI

The Supabase CLI is your command-line interface for managing local Supabase projects, handling migrations, and orchestrating the complete development stack. Unlike Firebase's limited local emulation, Supabase provides a fully functional PostgreSQL database and all services running locally in Docker containers.

Installation Methods

Supabase supports multiple installation methods to accommodate different development environments and preferences:

macOS (Homebrew):

brew install supabase/tap/supabase

Windows (Scoop):

scoop bucket add supabase https://github.com/supabase/scoop-bucket.git
scoop install supabase

Linux (Package Manager):

# Debian/Ubuntu
curl -L https://github.com/supabase/cli/releases/latest/download/supabase_linux_amd64.tar.gz | tar xz
sudo mv supabase /usr/local/bin/

# Or via Docker (universal)
docker pull supabase/cli:latest

Node.js (Universal):

npx supabase --help
# Requires Node.js 20 or higher

Development Tip

For the best development experience, we recommend installing the Supabase CLI directly on your system rather than using Docker or npx. This provides faster command execution and better integration with your development tools.

Initial Project Setup

Setting up a new Supabase project locally is straightforward:

# Create a new project directory
mkdir my-supabase-project
cd my-supabase-project

# Initialize Supabase project
supabase init

# Start the local development stack
supabase start

The supabase init command creates a complete project structure:

my-supabase-project/
├── supabase/
│   ├── config.toml          # Local configuration
│   ├── functions/           # Edge Functions
│   ├── migrations/          # Database migrations
│   ├── seed.sql            # Initial seed data
│   └── tests/              # Database tests
├── .gitignore
└── README.md

After starting, Supabase provides local service URLs:

Studio: http://localhost:54323 (Admin dashboard)
API: http://localhost:54321
Database: postgresql://postgres:postgres@localhost:54322/postgres

Docker-Based Development Stack

Supabase leverages Docker to create a complete, isolated development environment that closely matches production infrastructure. This Docker-based approach ensures consistency across development machines and eliminates the "works on my machine" problem.

Understanding the Local Stack

When you run supabase start, the CLI orchestrates multiple Docker services:

PostgreSQL Database: Full PostgreSQL 15+ instance with extensions
Supabase Studio: React-based admin dashboard for visual database management
GoTrue Authentication: JWT-based authentication service
REST API Gateway: Auto-generated REST API with filtering and pagination
Real-time Subscription Server: WebSocket server for live data updates
PostgREST: Automatic REST API generation from database schema
Kong API Gateway: Request routing and middleware
Storage Service: File storage with authentication integration

Each service runs in its own Docker container with properly configured networking and volume persistence, allowing you to develop with confidence that your local environment behaves like production. For more details on database architecture, see our Supabase Database guide.

Service Management

The Supabase CLI provides comprehensive service management commands:

# Start all services
supabase start

# Start with specific configuration
supabase start --workdir ./custom-workdir

# Check service status
supabase status

# Stop all services
supabase stop

# Stop and remove all data (fresh start)
supabase stop --no-backup

# View service logs
supabase logs db
supabase logs auth
supabase logs realtime

For development efficiency, you can start services selectively:

# Start only database and Studio
supabase start --exclude=storage,functions

# Restart specific services without full stop/start
supabase restart

Resource Management

The complete Supabase stack requires approximately 2-4GB of RAM. On machines with limited resources, consider stopping unused services or adjusting Docker memory allocation in Docker Desktop settings.

Database Migrations and Schema Management

Supabase provides a robust migration system that enables declarative database schema management, version control integration, and team collaboration. This approach eliminates manual schema changes and ensures consistent database states across environments.

Creating and Managing Migrations

The migration workflow is straightforward and familiar to developers coming from other database tools:

# Create a new migration
supabase migration new create_users_table

# This creates: supabase/migrations/20240101000000_create_users_table.sql

Each migration file should contain both up and down operations:

-- supabase/migrations/20240101000000_create_users_table.sql
-- Migration: Create users table
-- Description: Adds user accounts with authentication integration

CREATE TABLE users (
  id uuid DEFAULT gen_random_uuid() PRIMARY KEY,
  email varchar(255) UNIQUE NOT NULL,
  full_name text,
  avatar_url text,
  created_at timestamp with time zone DEFAULT now(),
  updated_at timestamp with time zone DEFAULT now()
);

-- Enable Row Level Security
ALTER TABLE users ENABLE ROW LEVEL SECURITY;

-- Create index for performance
CREATE INDEX users_email_idx ON users(email);

-- Add table comments for documentation
COMMENT ON TABLE users IS 'User accounts with authentication integration';

Applying and Testing Migrations

Apply migrations locally and test them before deployment:

# Reset database with all migrations applied
supabase db reset

# Apply specific migration
supabase migration up 20240101000000

# Rollback migration (requires explicit down migration)
supabase migration down 20240101000000

# Generate schema diff for debugging
supabase db diff

Schema Synchronization with Remote Projects

Link your local project to a remote Supabase project for seamless deployment:

# Link to remote project
supabase link --project-ref your-project-ref

# Push local schema changes to remote
supabase db push

# Pull remote schema changes locally
supabase db pull --schema=public

Best Practice

Always test migrations in a staging environment before applying to production. Use `supabase db push --dry-run` to preview changes without executing them.

Database Seeding and Test Data

Effective local development requires realistic test data. Supabase provides flexible seeding capabilities that support various development scenarios from minimal test datasets to comprehensive development environments.

Creating Seed Data

The primary seeding approach uses SQL files in your project:

-- supabase/seed.sql
-- Development seed data

-- Create users
INSERT INTO users (email, full_name, avatar_url) VALUES
  ('[email protected]', 'John Doe', 'https://api.dicebear.com/7.x/avataaars/svg?seed=John'),
  ('[email protected]', 'Jane Smith', 'https://api.dicebear.com/7.x/avataaars/svg?seed=Jane'),
  ('[email protected]', 'Admin User', 'https://api.dicebear.com/7.x/avataaars/svg?seed=Admin');

-- Create sample posts with relationships
INSERT INTO posts (title, content, user_id, published) VALUES
  ('Getting Started with Supabase', 'Supabase makes backend development simple...',
   (SELECT id FROM users WHERE email = '[email protected]'), true),
  ('Advanced PostgreSQL Features', 'PostgreSQL offers powerful capabilities...',
   (SELECT id FROM users WHERE email = '[email protected]'), true),
  ('Draft Post', 'This is still being written...',
   (SELECT id FROM users WHERE email = '[email protected]'), false);

-- Create categories
INSERT INTO categories (name, description) VALUES
  ('Technology', 'Technical articles and tutorials'),
  ('Development', 'Software development insights'),
  ('Database', 'Database design and optimization');

Apply seed data during database reset:

supabase db reset --linked  # Includes seed data

Advanced Seeding Strategies

For more complex seeding scenarios, implement environment-specific strategies:

-- supabase/seed_dev.sql  -- Development environment
INSERT INTO users (email, full_name) VALUES
  ('[email protected]', 'Developer Test User'),
  ('[email protected]', 'QA Test User');

-- supabase/seed_staging.sql  -- Staging environment
INSERT INTO users (email, full_name) VALUES
  ('[email protected]', 'Staging User');

-- supabase/seed_production.sql  -- Production (minimal)
-- Typically empty or contains only essential system data

Use shell scripts to apply environment-specific seeds:

#!/bin/bash
# scripts/seed.sh

ENV=${1:-development}
SEED_FILE="supabase/seed_${ENV}.sql"

if [ -f "$SEED_FILE" ]; then
  psql $DATABASE_URL -f "$SEED_FILE"
  echo "Applied $SEED_FILE"
else
  echo "Seed file $SEED_FILE not found"
fi

Data Privacy and Synthetic Data

Never use real production data in local development. Instead, create realistic synthetic data:

-- Generate fake but realistic data
INSERT INTO users (email, full_name, created_at) VALUES
  (concat('user', i, '@', array['gmail', 'yahoo', 'outlook'][floor(random()*3)+1], '.com'),
   concat('User ', i),
   now() - (random() * 365 || ' days')::interval)
FROM generate_series(1, 100) AS i;

Testing Strategies and Frameworks

Comprehensive testing is crucial for maintaining data integrity and application reliability. Supabase supports multiple testing approaches, from database-level unit tests to full integration tests.

SQL Testing with pgTAP

pgTAP is a PostgreSQL unit testing framework that integrates seamlessly with Supabase:

# Install pgTAP extension
supabase db reset
supabase migration new install_pgtap

-- supabase/migrations/install_pgtap.sql
CREATE EXTENSION IF NOT EXISTS pgtap;

Write comprehensive database tests:

-- supabase/tests/test_users.sql
\i pgtap.sql

-- Test table existence
SELECT has_table('users', 'Users table should exist');

-- Test column properties
SELECT has_column('users', 'email', 'Email column should exist');
SELECT col_type_is('users', 'email', 'character varying', 'Email should be varchar');
SELECT col_not_null('users', 'email', 'Email should not be nullable');
SELECT col_is_unique('users', 'email', 'Email should be unique');

-- Test constraints
SELECT has_check('users', 'users_email_check', 'Email format should be validated');

-- Test RLS policies
SELECT col_has_rls('users', 'Users table should have RLS enabled');

-- Test data
SELECT results_eq(
  $$ SELECT COUNT(*) FROM users WHERE email LIKE '%@example.com' $$,
  $$ SELECT 3 $$,
  'Should have 3 example.com users'
);

-- Test triggers
SELECT has_trigger('users', 'users_updated_at_trigger', 'Updated at trigger should exist');

-- Performance test
SELECT performs_within(
  $$ SELECT COUNT(*) FROM users $$,
  100,
  'User count query should complete within 100ms'
);

Run tests with the Supabase CLI:

# Run all database tests
supabase test db

# Run specific test file
supabase test db --file supabase/tests/test_users.sql

# Run tests with verbose output
supabase test db --verbose

Application-Layer Testing

Test database interactions from your application code:

// tests/integration/users.test.js

const supabase = createClient(
  process.env.SUPABASE_URL,
  process.env.SUPABASE_SERVICE_KEY
);

beforeAll(async () => {
  // Setup test database
  await supabase.rpc('reset_test_data');
});

beforeEach(async () => {
  // Clean up between tests
  await supabase.from('users').delete().neq('id', '00000000-0000-0000-0000-000000000000');
});

test('should create user with valid email', async () => {
  const userData = {
    email: '[email protected]',
    full_name: 'Test User'
  };

  const { data, error } = await supabase
    .from('users')
    .insert(userData)
    .select()
    .single();

  expect(error).toBeNull();
  expect(data).toMatchObject(userData);
  expect(data.id).toBeDefined();
});

test('should reject duplicate email', async () => {
  const userData = {
    email: '[email protected]',
    full_name: 'User 1'
  };

  // Insert first user
  await supabase.from('users').insert(userData);

  // Attempt to insert duplicate
  const { data, error } = await supabase
    .from('users')
    .insert(userData)
    .select();

  expect(error).not.toBeNull();
  expect(error.code).toBe('23505'); // Unique violation
});

test('should enforce email format validation', async () => {
  const { data, error } = await supabase
    .from('users')
    .insert({
      email: 'invalid-email',
      full_name: 'Invalid User'
    })
    .select();

  expect(error).not.toBeNull();
  expect(error.message).toContain('check constraint');
});

Testing Row Level Security (RLS)

Test security policies to ensure proper data access controls:

-- supabase/tests/test_rls.sql
\i pgtap.sql

-- Setup test authentication
SELECT set_config('request.jwt.claim.sub', 'user-1', true);

-- Test user can only access their own data
SELECT results_eq(
  $$ SELECT COUNT(*) FROM profiles WHERE user_id = current_setting('app.current_user_id') $$,
  $$ SELECT 1 $$,
  'User should only access their own profile'
);

-- Test user cannot access others' data
SELECT results_eq(
  $$ SELECT COUNT(*) FROM profiles WHERE user_id != current_setting('app.current_user_id') $$,
  $$ SELECT 0 $$,
  'User should not access others'' profiles'
);

-- Test admin bypass
SELECT set_config('request.jwt.claim.role', 'service_role', true);
SELECT performs_within(
  $$ SELECT COUNT(*) FROM profiles $$,
  100,
  'Admin should access all profiles quickly'
);

For comprehensive RLS implementation guidance, see our Row Level Security guide.

CI/CD Integration and Automation

Supabase integrates seamlessly with modern CI/CD pipelines, enabling automated testing, migration deployment, and environment management. This automation ensures consistent deployments and reduces manual errors.

GitHub Actions Setup

Create a comprehensive GitHub Actions workflow:

# .github/workflows/supabase.yml
name: Supabase CI/CD

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: postgres
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 5432:5432

    steps:
      - uses: actions/checkout@v4

      - uses: supabase/setup-cli@v1
        with:
          version: latest

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Start Supabase
        run: |
          supabase init
          supabase start
        env:
          SUPABASE_DB_PASSWORD: postgres

      - name: Run database migrations
        run: supabase db reset

      - name: Run database tests
        run: supabase test db

      - name: Run application tests
        run: npm test
        env:
          SUPABASE_URL: http://localhost:54321
          SUPABASE_ANON_KEY: ${{ env.SUPABASE_ANON_KEY }}

  deploy:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'

    steps:
      - uses: actions/checkout@v4

      - uses: supabase/setup-cli@v1
        with:
          version: latest

      - name: Link to Supabase project
        run: supabase link --project-ref ${{ secrets.SUPABASE_PROJECT_REF }}
        env:
          SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }}

      - name: Generate migration diff
        run: supabase db diff --schema public --use-migra
        id: migration

      - name: Apply migrations
        if: steps.migration.outputs.diff != ''
        run: supabase db push

      - name: Deploy Edge Functions
        run: supabase functions deploy --all
        env:
          SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }}

Configure necessary GitHub repository secrets:

SUPABASE_ACCESS_TOKEN: Your Supabase access token
SUPABASE_PROJECT_REF: Project reference from Supabase dashboard
SUPABASE_DB_PASSWORD: Database password for automated access

Environment Management Strategy

Implement a robust multi-environment strategy:

# Development (local)
supabase init
supabase start

# Staging (shared team environment)
supabase link --project-ref staging-project-ref
supabase db push --schema=public

# Production (production environment)
supabase link --project-ref production-project-ref
supabase db push --schema=public --dry-run  # Always dry-run first

Create environment-specific configuration files:

# supabase/config.toml
[api]
port = 54321
schema = "public"
extra_search_path = ["public", "extensions"]

[db]
port = 54322
shadow_port = 54320
major_version = 15

[studio]
port = 54323

[ingest]
port = 54324

[storage]
port = 54325
file_size_limit = "50MiB"

[functions]
port = 54326
verify_jwt = false

[analytics]
port = 54327

Deployment Automation Best Practices

Implement safe deployment practices to minimize risks:

#!/bin/bash
# scripts/deploy.sh

set -e

ENV=${1:-production}
PROJECT_REF=${2}

# Pre-deployment checks
echo "Running pre-deployment checks..."

# Validate migration files
supabase migration validate

# Run full test suite
npm run test

# Generate migration preview
supabase db diff --schema=public --use-migra > migration-preview.sql

# Show migration preview for review
echo "=== Migration Preview ==="
cat migration-preview.sql

# Confirm deployment
read -p "Deploy to $ENV? (y/N): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
  echo "Deployment cancelled."
  exit 1
fi

# Link to target environment
supabase link --project-ref $PROJECT_REF

# Create backup before deployment
supabase db backup --file backup-$(date +%Y%m%d-%H%M%S).sql

# Apply migrations
supabase db push

# Deploy Edge Functions
supabase functions deploy --all

echo "Deployment to $ENV completed successfully!"

Edge Functions Local Development

Supabase Edge Functions bring serverless compute capabilities to your local development environment, enabling you to build API endpoints, webhooks, and backend logic using Deno runtime with TypeScript support.

Local Function Development

Create and develop Edge Functions locally:

# Create new Edge Function
supabase functions new process-payment

# Start local Edge Functions server
supabase functions serve

# This starts a Deno runtime on port 54326

Edge Function structure:

// supabase/functions/process-payment/index.ts

const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
}

serve(async (req) => {
  // Handle CORS preflight
  if (req.method === 'OPTIONS') {
    return new Response('ok', { headers: corsHeaders })
  }

  try {
    const { payment_data } = await req.json()

    // Validate input
    if (!payment_data || !payment_data.amount || !payment_data.customer_id) {
      throw new Error('Missing required payment data')
    }

    // Initialize Supabase client
    const supabaseClient = createClient(
      Deno.env.get('SUPABASE_URL') ?? '',
      Deno.env.get('SUPABASE_ANON_KEY') ?? '',
      {
        global: {
          headers: { Authorization: req.headers.get('Authorization')! },
        },
      }
    )

    // Verify user authentication
    const { data: { user }, error: authError } = await supabaseClient.auth.getUser()
    if (authError || !user) {
      throw new Error('Unauthorized')
    }

    // Process payment (integration with payment processor)
    const paymentResult = await processPayment(payment_data)

    // Record transaction in database
    const { data: transaction, error: dbError } = await supabaseClient
      .from('transactions')
      .insert({
        user_id: user.id,
        amount: payment_data.amount,
        status: paymentResult.status,
        payment_processor_id: paymentResult.id,
        created_at: new Date().toISOString()
      })
      .select()
      .single()

    if (dbError) {
      throw dbError
    }

    return new Response(
      JSON.stringify({
        success: true,
        transaction_id: transaction.id,
        status: paymentResult.status
      }),
      {
        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
        status: 200
      }
    )

  } catch (error) {
    console.error('Payment processing error:', error)

    return new Response(
      JSON.stringify({
        success: false,
        error: error.message
      }),
      {
        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
        status: 400
      }
    )
  }
})

async function processPayment(data: any) {
  // Integration with payment processor (Stripe, PayPal, etc.)
  // This is a mock implementation
  return {
    id: `pay_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
    status: 'success',
    amount: data.amount
  }
}

Testing Edge Functions

Test your Edge Functions comprehensively:

// tests/edge-functions/process-payment.test.ts

// Import the function

Deno.test('process-payment function handles valid requests', async () => {
  const mockReq = new Request('http://localhost:54326/functions/v1/process-payment', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer mock-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      payment_data: {
        amount: 10000,
        customer_id: 'cust_123',
        payment_method: 'card'
      }
    })
  })

  const response = await handler(mockReq)
  const data = await response.json()

  assertEquals(response.status, 200)
  assertEquals(data.success, true)
  assertExists(data.transaction_id)
})

Deno.test('process-payment function rejects invalid data', async () => {
  const mockReq = new Request('http://localhost:54326/functions/v1/process-payment', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer mock-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      payment_data: {
        // Missing required fields
      }
    })
  })

  const response = await handler(mockReq)
  const data = await response.json()

  assertEquals(response.status, 400)
  assertEquals(data.success, false)
  assertExists(data.error)
})

Run Edge Function tests:

# Run specific function tests
supabase functions test process-payment

# Run all function tests
supabase functions test

# Deploy functions to production
supabase functions deploy process-payment

For comprehensive Edge Functions development, see our Edge Functions guide.

Best Practices and Workflows

Establishing effective development workflows and best practices ensures team productivity, code quality, and system reliability. These recommendations are based on real-world experience with Supabase projects across various scales.

Development Workflow Recommendations

Implement a daily development workflow that maximizes productivity:

Morning Setup:

# Start with clean state
supabase stop --no-backup
supabase start

# Apply latest migrations
supabase db reset

# Verify service health
supabase status

Feature Development:

# Create feature branch
git checkout -b feature/user-authentication

# Create migration for changes
supabase migration new add_user_profiles

# Develop and test locally
supabase test db
npm test

Pre-Commit Checklist:

# Run full test suite
npm run test:ci

# Check for SQL formatting issues
supabase migration fix

# Verify migration reversibility
supabase migration down --dry-run

Team Collaboration Strategies

Effective team coordination is crucial for database changes:

Team Coordination

Use pull requests for all migration changes. Include screenshots of schema changes, explain the business rationale, and provide rollback instructions in migration comments.

Migration Naming Convention:

YYYYMMDDHHMMSS_brief_description.sql
20240101120000_create_user_profiles.sql
20240101120001_add_user_indexes.sql
20240101120002_implement_rls_policies.sql

Collaboration Workflow:

Schema Change Planning:
- Document changes in design documents
- Review impact on existing applications
- Plan migration dependencies
Migration Development:
- Write both up and down migrations
- Include comprehensive comments
- Test with various data scenarios
Code Review Process:
- Review migration SQL for potential issues
- Verify RLS policies are correct
- Check performance implications
Testing Strategy:
- Unit tests for business logic
- Integration tests for API changes
- Performance tests for schema changes

Troubleshooting Common Issues

Docker Resource Conflicts:

# Check port availability
netstat -tulpn | grep :54322

# Clear Docker resources if needed
docker system prune -f
docker volume prune -f

# Restart with clean state
supabase stop --no-backup
supabase start

Migration Failures:

# Identify failing migration
supabase migration list

# Check migration logs
supabase logs db

# Fix and retry specific migration
supabase migration up

Authentication Issues Locally:

# Check JWT secret configuration
supabase config show

# Reset local authentication
supabase db reset

# Verify local JWT token generation
supabase auth generate-jwt

Performance Debugging:

-- Check slow queries
SELECT query, mean_time, calls
FROM pg_stat_statements
ORDER BY mean_time DESC
LIMIT 10;

-- Analyze table sizes
SELECT
  schemaname,
  tablename,
  pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as size
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC;

-- Check index usage
SELECT
  schemaname,
  tablename,
  indexname,
  idx_scan,
  idx_tup_read,
  idx_tup_fetch
FROM pg_stat_user_indexes
ORDER BY idx_scan DESC;

Advanced Configuration Tips

Custom PostgreSQL Configuration:

# supabase/config.toml
[db]
port = 54322
major_version = 15

# Custom PostgreSQL settings
[db.settings]
shared_buffers = "256MB"
effective_cache_size = "1GB"
maintenance_work_mem = "64MB"
checkpoint_completion_target = 0.9
wal_buffers = "16MB"
default_statistics_target = 100
random_page_cost = 1.1
effective_io_concurrency = 200

Performance Optimization for Development:

-- Create development-specific indexes
CREATE INDEX CONCURRENTLY users_email_idx ON users(email);
CREATE INDEX CONCURRENTLY posts_created_at_idx ON posts(created_at DESC);

-- Configure autovacuum for development
ALTER TABLE users SET (autovacuum_vacuum_scale_factor = 0.1);
ALTER TABLE posts SET (autovacuum_vacuum_scale_factor = 0.1);

-- Monitor performance
SELECT * FROM pg_stat_activity WHERE state = 'active';

Integration with Development Tools:

VS Code Extensions:

PostgreSQL extension for database management
Docker extension for container visualization
GitLens for better Git integration

IDE Configuration:

// .vscode/settings.json
{
  "sqltools.connections": [
    {
      "name": "Supabase Local",
      "driver": "PostgreSQL",
      "host": "localhost",
      "port": 54322,
      "database": "postgres",
      "username": "postgres",
      "password": "postgres"
    }
  ],
  "files.exclude": {
    "**/supabase/.branches": true,
    "**/supabase/.temp": true
  }
}

Conclusion

Supabase local development provides a comprehensive, production-like environment that enables rapid iteration while maintaining data consistency and team collaboration. By implementing the workflows and best practices outlined in this guide, development teams can leverage Supabase's powerful features—including the CLI, Docker-based stack, automated testing, and CI/CD integration—to build scalable applications with confidence.

The key to successful Supabase development lies in establishing proper workflows from the beginning: use migrations for all schema changes, implement comprehensive testing strategies, automate deployments with CI/CD, and maintain clear documentation for team collaboration. With these practices in place, Supabase becomes a powerful alternative to Firebase that offers the full capabilities of PostgreSQL with modern development conveniences.

For teams transitioning from other backend platforms or those building new applications, Supabase's local development environment provides the foundation for building robust, scalable applications with a developer experience that rivals any modern development toolchain. Our comprehensive Supabase vs Firebase comparison can help teams make informed decisions about their backend platform choice.

Looking to integrate Supabase with your web development projects? Our Web Development Services can help you build robust, scalable applications using modern backend technologies.

Supabase Local Development Guide (2025)