diff --git a/.gitignore b/.gitignore
index c798e560d..c38484457 100644
--- a/.gitignore
+++ b/.gitignore
@@ -86,4 +86,7 @@ conductor_ports.lock
 line_item_*_response.json
 
 # Test database files (PostgreSQL test databases)
-test_*
+# Only ignore database files/dirs, not test_*.py files
+test_*.db
+test_*.db-*
+test_*[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]/
diff --git a/CLAUDE.md b/CLAUDE.md
index caae603f1..c313adf81 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -2,16 +2,30 @@
 
 ## 🚨 CRITICAL ARCHITECTURE PATTERNS
 
-### Database JSON Fields Pattern (SQLAlchemy 2.0)
-**🚨 MANDATORY**: All JSON columns MUST use `JSONType` for cross-database compatibility.
+### PostgreSQL-Only Architecture
+**🚨 DECISION**: This codebase uses PostgreSQL exclusively. No SQLite support.
+
+**Why:**
+- Production uses PostgreSQL exclusively
+- SQLite hides bugs (different JSONB behavior, no connection pooling, single-threaded)
+- "No fallbacks - if it's in our control, make it work" (core principle)
+- One database. One source of truth. No hidden bugs.
+
+**What this means:**
+- All tests require PostgreSQL container (run via `./run_all_tests.sh ci`)
+- `db_config.py` only supports PostgreSQL connections
+- Unit tests should mock database access, not use real connections
+- Integration tests require `ADCP_TEST_DB_URL` or will skip
+
+**Migration note:** We removed SQLite support to eliminate cross-database bugs. If you see SQLite references in old docs/code, they're outdated.
+
+---
 
-**The Problem:**
-- SQLite stores JSON as text strings → requires manual `json.loads()`
-- PostgreSQL uses native JSONB → returns Python dicts/lists automatically
-- This inconsistency causes bugs (e.g., iterating over strings character-by-character)
+### Database JSON Fields Pattern (SQLAlchemy 2.0)
+**🚨 MANDATORY**: All JSON columns MUST use `JSONType` for PostgreSQL JSONB handling.
 
 **The Solution: JSONType**
-We have a custom `JSONType` TypeDecorator that handles this automatically:
+We have a custom `JSONType` TypeDecorator for PostgreSQL JSONB:
 
 ```python
 # ✅ CORRECT - Use JSONType for ALL JSON columns
@@ -165,7 +179,7 @@ def create_media_buy_raw(promoted_offering: str, ...) -> CreateMediaBuyResponse:
 **Your Deployment**: You can host this anywhere that supports:
 - Docker containers (recommended)
 - Python 3.11+
-- PostgreSQL (production) or SQLite (dev/testing)
+- PostgreSQL (production and testing)
 - We'll support your deployment approach as best we can
 
 ### Git Workflow - MANDATORY (Reference Implementation)
@@ -386,13 +400,16 @@ docker-compose down
 
 ### Testing
 ```bash
-# Run all tests
-uv run pytest
+# Recommended: Full test suite with PostgreSQL (matches CI/production)
+./run_all_tests.sh ci
+
+# Fast iteration during development (skips database tests)
+./run_all_tests.sh quick
 
-# By category
-uv run pytest tests/unit/
-uv run pytest tests/integration/
-uv run pytest tests/e2e/
+# Manual pytest commands
+uv run pytest tests/unit/           # Unit tests only
+uv run pytest tests/integration/    # Integration tests (needs database)
+uv run pytest tests/e2e/            # E2E tests (needs database)
 
 # With coverage
 uv run pytest --cov=. --cov-report=html
@@ -593,31 +610,33 @@ If the hook isn't installed or you want to update it:
 
 **Test Modes:**
 
-**CI Mode (runs automatically on push):**
+**CI Mode (DEFAULT - runs automatically on push):**
 - Starts PostgreSQL container automatically (postgres:15)
 - Runs ALL tests including database-dependent tests
-- Exactly matches GitHub Actions environment
+- Exactly matches GitHub Actions and production environment
 - Catches database issues before CI does
 - Automatically cleans up container
+- ~3-5 minutes
 
 **Quick Mode (for fast development iteration):**
 - Fast validation: unit tests + integration tests (no database)
-- Skips database-dependent tests
+- Skips database-dependent tests (marked with `@pytest.mark.requires_db`)
 - Good for rapid testing during development
-- Run manually: `./run_all_tests.sh quick`
-
-**Full Mode (comprehensive, no Docker):**
-- All tests with SQLite instead of PostgreSQL
-- Good for development without Docker
-- Run manually: `./run_all_tests.sh full`
+- ~1 minute
 
 **Command Reference:**
 ```bash
-./run_all_tests.sh ci      # Like CI (PostgreSQL container) - USE THIS!
-./run_all_tests.sh quick   # Fast pre-push validation (automatic)
-./run_all_tests.sh full    # Full suite (SQLite, no Docker)
+./run_all_tests.sh         # CI mode (default) - PostgreSQL container
+./run_all_tests.sh ci      # CI mode (explicit) - USE THIS before pushing!
+./run_all_tests.sh quick   # Quick mode - fast iteration
 ```
 
+**Why PostgreSQL-only?**
+- Production uses PostgreSQL exclusively
+- SQLite hides bugs (different JSONB behavior, no connection pooling, single-threaded)
+- "No fallbacks - if it's in our control, make it work" (core principle)
+- One database. One source of truth. No hidden bugs.
+
 See `docs/testing/` for detailed patterns and case studies.
 
 ## Pre-Commit Hooks
diff --git a/run_all_tests.sh b/run_all_tests.sh
index 25b08a54b..93f42d97f 100755
--- a/run_all_tests.sh
+++ b/run_all_tests.sh
@@ -20,13 +20,9 @@ BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 
 # Determine test mode
-MODE=${1:-full}  # Default to full if no argument
-USE_DOCKER=${USE_DOCKER:-false}  # Set USE_DOCKER=true to run with PostgreSQL
+MODE=${1:-ci}  # Default to ci if no argument
 
 echo "🧪 Running tests in '$MODE' mode..."
-if [ "$USE_DOCKER" = "true" ]; then
-    echo -e "${BLUE}🐳 Docker mode enabled - using PostgreSQL container${NC}"
-fi
 echo ""
 
 # Docker setup function (like CI does)
@@ -197,70 +193,25 @@ if [ "$MODE" == "ci" ]; then
     exit 0
 fi
 
-# Full mode: all tests
-if [ "$MODE" == "full" ]; then
-    echo "📦 Step 1/4: Validating imports..."
-
-    # Check all critical imports
-    if ! uv run python -c "from src.core.tools import get_products_raw, create_media_buy_raw, get_media_buy_delivery_raw, sync_creatives_raw, list_creatives_raw, list_creative_formats_raw, list_authorized_properties_raw" 2>/dev/null; then
-        echo -e "${RED}❌ Import validation failed!${NC}"
-        exit 1
-    fi
-
-    if ! uv run python -c "from src.core.main import _get_products_impl, _create_media_buy_impl, _get_media_buy_delivery_impl, _sync_creatives_impl, _list_creatives_impl, _list_creative_formats_impl, _list_authorized_properties_impl" 2>/dev/null; then
-        echo -e "${RED}❌ Import validation failed!${NC}"
-        exit 1
-    fi
-
-    echo -e "${GREEN}✅ Imports validated${NC}"
-    echo ""
-
-    echo "🧪 Step 2/4: Running unit tests..."
-    if ! uv run pytest tests/unit/ -x --tb=short; then
-        echo -e "${RED}❌ Unit tests failed!${NC}"
-        exit 1
-    fi
-    echo -e "${GREEN}✅ Unit tests passed${NC}"
-    echo ""
-
-    echo "🔗 Step 3/4: Running integration tests..."
-    if ! uv run pytest tests/integration/ -x --tb=short; then
-        echo -e "${RED}❌ Integration tests failed!${NC}"
-        exit 1
-    fi
-    echo -e "${GREEN}✅ Integration tests passed${NC}"
-    echo ""
-
-    echo "🌍 Step 4/4: Running e2e tests..."
-    if ! uv run pytest tests/e2e/ -x --tb=short; then
-        echo -e "${RED}❌ E2E tests failed!${NC}"
-        exit 1
-    fi
-    echo -e "${GREEN}✅ E2E tests passed${NC}"
-    echo ""
-
-    echo -e "${GREEN}✅ All tests passed!${NC}"
-    exit 0
-fi
-
 # Unknown mode
 echo -e "${RED}❌ Unknown test mode: $MODE${NC}"
 echo ""
-echo "Usage: ./run_all_tests.sh [quick|ci|full]"
+echo "Usage: ./run_all_tests.sh [quick|ci]"
 echo ""
 echo "Modes:"
 echo "  quick  - Unit tests + integration tests (no database)"
-echo "           Fast validation for pre-push hook (~1 min)"
+echo "           Fast validation for rapid iteration (~1 min)"
+echo "           Skips database-dependent tests"
 echo ""
-echo "  ci     - Like GitHub Actions: PostgreSQL container + all tests"
+echo "  ci     - Full test suite with PostgreSQL (DEFAULT)"
 echo "           Runs unit + integration + e2e with real database (~3-5 min)"
 echo "           Automatically starts/stops PostgreSQL container"
-echo ""
-echo "  full   - All tests with SQLite (no container needed)"
-echo "           Unit + integration + e2e tests (~3-5 min)"
+echo "           Matches production environment and GitHub Actions"
 echo ""
 echo "Examples:"
-echo "  ./run_all_tests.sh quick      # Fast pre-push validation"
-echo "  ./run_all_tests.sh ci         # Test like CI does (with PostgreSQL)"
-echo "  ./run_all_tests.sh full       # Full test suite (SQLite)"
+echo "  ./run_all_tests.sh            # Run CI mode (default, recommended)"
+echo "  ./run_all_tests.sh quick      # Fast iteration during development"
+echo "  ./run_all_tests.sh ci         # Explicit CI mode (same as default)"
+echo ""
+echo "💡 Tip: Use 'quick' for rapid development, 'ci' before pushing to catch all bugs"
 exit 1
diff --git a/src/core/database/database_session.py b/src/core/database/database_session.py
index a12edabfa..9dc8e1ad3 100644
--- a/src/core/database/database_session.py
+++ b/src/core/database/database_session.py
@@ -5,6 +5,8 @@
 management across the entire application.
 """
 
+import logging
+import os
 from collections.abc import Generator
 from contextlib import contextmanager
 from typing import Any
@@ -15,41 +17,73 @@
 
 from src.core.database.db_config import DatabaseConfig
 
-# Create engine and session factory with production-ready settings
-connection_string = DatabaseConfig.get_connection_string()
-
-# Configure engine with appropriate pooling and retry settings
-if "postgresql" in connection_string:
-    # PostgreSQL production settings
-    engine = create_engine(
-        connection_string,
-        pool_size=10,  # Base connections in pool
-        max_overflow=20,  # Additional connections beyond pool_size
-        pool_timeout=30,  # Seconds to wait for connection
-        pool_recycle=3600,  # Recycle connections after 1 hour
-        pool_pre_ping=True,  # Test connections before use
-        echo=False,  # Set to True for SQL logging in debug
-    )
-else:
-    # SQLite settings (development) - SQLite doesn't support all pool options
-    engine = create_engine(
-        connection_string,
-        pool_pre_ping=True,
-        echo=False,
-    )
-
-SessionLocal = sessionmaker(bind=engine)
-import logging
-
 logger = logging.getLogger(__name__)
 
-# Thread-safe session factory
-db_session = scoped_session(SessionLocal)
+# Module-level globals for lazy initialization
+_engine = None
+_session_factory = None
+_scoped_session = None
 
 
 def get_engine():
-    """Get the current database engine."""
-    return engine
+    """Get or create the database engine (lazy initialization)."""
+    global _engine, _session_factory, _scoped_session
+
+    if _engine is None:
+        # In test mode without DATABASE_URL, we should NOT create a real connection
+        # Unit tests should mock database access, not use real connections
+        if os.environ.get("ADCP_TESTING") and not os.environ.get("DATABASE_URL"):
+            raise RuntimeError(
+                "Unit tests should not create real database connections. "
+                "Either mock get_db_session() or set DATABASE_URL for integration tests. "
+                "Use @pytest.mark.requires_db for integration tests."
+            )
+
+        # Get connection string from config
+        connection_string = DatabaseConfig.get_connection_string()
+
+        if "postgresql" not in connection_string:
+            raise ValueError("Only PostgreSQL is supported. Use DATABASE_URL=postgresql://...")
+
+        # Create engine with production-ready settings
+        _engine = create_engine(
+            connection_string,
+            pool_size=10,  # Base connections in pool
+            max_overflow=20,  # Additional connections beyond pool_size
+            pool_timeout=30,  # Seconds to wait for connection
+            pool_recycle=3600,  # Recycle connections after 1 hour
+            pool_pre_ping=True,  # Test connections before use
+            echo=False,  # Set to True for SQL logging in debug
+            connect_args={"connect_timeout": 5} if os.environ.get("ADCP_TESTING") else {},  # Fast timeout for tests
+        )
+
+        # Create session factory
+        _session_factory = sessionmaker(bind=_engine)
+        _scoped_session = scoped_session(_session_factory)
+
+    return _engine
+
+
+def reset_engine():
+    """Reset engine for testing - closes existing connections and clears global state."""
+    global _engine, _session_factory, _scoped_session
+
+    if _scoped_session is not None:
+        _scoped_session.remove()
+        _scoped_session = None
+
+    if _engine is not None:
+        _engine.dispose()
+        _engine = None
+
+    _session_factory = None
+
+
+def get_scoped_session():
+    """Get the scoped session factory (lazy initialization)."""
+    # Calling get_engine() ensures all globals are initialized
+    get_engine()
+    return _scoped_session
 
 
 @contextmanager
@@ -67,14 +101,15 @@ def get_db_session() -> Generator[Session, None, None]:
     The session will automatically rollback on exception and
     always be properly closed. Connection errors are logged with more detail.
     """
-    session = db_session()
+    scoped = get_scoped_session()
+    session = scoped()
     try:
         yield session
     except (OperationalError, DisconnectionError) as e:
         logger.error(f"Database connection error: {e}")
         session.rollback()
         # Remove session from registry to force reconnection
-        db_session.remove()
+        scoped.remove()
         raise
     except SQLAlchemyError as e:
         logger.error(f"Database error: {e}")
@@ -82,7 +117,7 @@ def get_db_session() -> Generator[Session, None, None]:
         raise
     finally:
         session.close()
-        db_session.remove()
+        scoped.remove()
 
 
 def execute_with_retry(func, max_retries: int = 3, retry_on: tuple = (OperationalError, DisconnectionError)) -> Any:
@@ -115,7 +150,8 @@ def execute_with_retry(func, max_retries: int = 3, retry_on: tuple = (Operationa
                 wait_time = 0.5 * (2**attempt)
                 logger.info(f"Waiting {wait_time}s before retry...")
                 time.sleep(wait_time)
-                db_session.remove()  # Clear the session registry
+                scoped = get_scoped_session()
+                scoped.remove()  # Clear the session registry
                 continue
             raise
         except SQLAlchemyError as e:
@@ -142,7 +178,8 @@ def __init__(self):
     def session(self) -> Session:
         """Get or create a session."""
         if self._session is None:
-            self._session = db_session()
+            scoped = get_scoped_session()
+            self._session = scoped()
         return self._session
 
     def commit(self):
@@ -163,7 +200,8 @@ def close(self):
         """Close and cleanup the session."""
         if self._session:
             self._session.close()
-            db_session.remove()
+            scoped = get_scoped_session()
+            scoped.remove()
             self._session = None
 
     def __enter__(self):
diff --git a/src/core/database/db_config.py b/src/core/database/db_config.py
index ba0aaf594..79858398a 100644
--- a/src/core/database/db_config.py
+++ b/src/core/database/db_config.py
@@ -1,144 +1,103 @@
-"""Database configuration with support for multiple backends."""
+"""Database configuration - PostgreSQL only.
+
+Production exclusively uses PostgreSQL. No SQLite support.
+This aligns with our principle: "No fallbacks - if it's in our control, make it work."
+"""
 
 import os
-import sqlite3
 from typing import Any
 from urllib.parse import urlparse
 
 
 class DatabaseConfig:
-    """Flexible database configuration supporting SQLite and PostgreSQL."""
+    """PostgreSQL database configuration."""
 
     @staticmethod
     def get_db_config() -> dict[str, Any]:
-        """Get database configuration from environment or defaults."""
+        """Get PostgreSQL configuration from environment."""
 
-        # Support DATABASE_URL for easy deployment (Heroku, Railway, etc.)
+        # Support DATABASE_URL for easy deployment (Heroku, Railway, Fly.io, etc.)
         database_url = os.environ.get("DATABASE_URL")
         if database_url:
             return DatabaseConfig._parse_database_url(database_url)
 
-        # Individual environment variables
-        db_type = os.environ.get("DB_TYPE", "sqlite").lower()
-
-        if db_type == "sqlite":
-            # Use persistent directory for SQLite
-            data_dir = os.environ.get("DATA_DIR", os.path.expanduser("~/.adcp"))
-            os.makedirs(data_dir, exist_ok=True)
-
-            return {
-                "type": "sqlite",
-                "path": os.path.join(data_dir, "adcp.db"),
-                "check_same_thread": False,  # Allow multi-threaded access
-            }
-
-        elif db_type == "postgresql":
-            return {
-                "type": "postgresql",
-                "host": os.environ.get("DB_HOST", "localhost"),
-                "port": int(os.environ.get("DB_PORT", "5432")),
-                "database": os.environ.get("DB_NAME", "adcp"),
-                "user": os.environ.get("DB_USER", "adcp"),
-                "password": os.environ.get("DB_PASSWORD", ""),
-                "sslmode": os.environ.get("DB_SSLMODE", "prefer"),
-            }
-
-        else:
-            raise ValueError(f"Unsupported database type: {db_type}. Use 'sqlite' or 'postgresql'")
+        # Individual environment variables (fallback)
+        return {
+            "type": "postgresql",
+            "host": os.environ.get("DB_HOST", "localhost"),
+            "port": int(os.environ.get("DB_PORT", "5432")),
+            "database": os.environ.get("DB_NAME", "adcp"),
+            "user": os.environ.get("DB_USER", "adcp"),
+            "password": os.environ.get("DB_PASSWORD", ""),
+            "sslmode": os.environ.get("DB_SSLMODE", "prefer"),
+        }
 
     @staticmethod
     def _parse_database_url(url: str) -> dict[str, Any]:
         """Parse DATABASE_URL into configuration dict."""
         parsed = urlparse(url)
 
-        if parsed.scheme == "sqlite":
-            path = parsed.path.lstrip("/")
-            # Ensure directory exists for SQLite database file
-            if path:
-                db_dir = os.path.dirname(path)
-                if db_dir:
-                    os.makedirs(db_dir, exist_ok=True)
-            return {"type": "sqlite", "path": path, "check_same_thread": False}
-
-        elif parsed.scheme in ["postgres", "postgresql"]:
-            return {
-                "type": "postgresql",
-                "host": parsed.hostname,
-                "port": parsed.port or 5432,
-                "database": parsed.path.lstrip("/"),
-                "user": parsed.username,
-                "password": parsed.password or "",
-                "sslmode": "require" if "sslmode=require" in url else "prefer",
-            }
+        if parsed.scheme not in ["postgres", "postgresql"]:
+            raise ValueError(
+                f"Unsupported database scheme: {parsed.scheme}. "
+                f"Only PostgreSQL is supported. Use 'postgresql://' URLs."
+            )
 
-        else:
-            raise ValueError(f"Unsupported database scheme: {parsed.scheme}. Use 'sqlite' or 'postgresql'")
+        return {
+            "type": "postgresql",
+            "host": parsed.hostname,
+            "port": parsed.port or 5432,
+            "database": parsed.path.lstrip("/"),
+            "user": parsed.username,
+            "password": parsed.password or "",
+            "sslmode": "require" if "sslmode=require" in url else "prefer",
+        }
 
     @staticmethod
     def get_connection_string() -> str:
         """Get connection string for SQLAlchemy."""
         config = DatabaseConfig.get_db_config()
 
-        if config["type"] == "sqlite":
-            return f"sqlite:///{config['path']}"
-
-        elif config["type"] == "postgresql":
-            password = config["password"]
-            if password:
-                auth = f"{config['user']}:{password}"
-            else:
-                auth = config["user"]
-
-            return (
-                f"postgresql://{auth}@{config['host']}:{config['port']}"
-                f"/{config['database']}?sslmode={config['sslmode']}"
-            )
-
+        password = config["password"]
+        if password:
+            auth = f"{config['user']}:{password}"
         else:
-            raise ValueError(f"Unsupported database type: {config['type']}")
+            auth = config["user"]
+
+        return (
+            f"postgresql://{auth}@{config['host']}:{config['port']}"
+            f"/{config['database']}?sslmode={config['sslmode']}"
+        )
 
 
 class DatabaseConnection:
-    """Database connection wrapper supporting multiple backends."""
+    """PostgreSQL database connection wrapper."""
 
     def __init__(self):
         self.config = DatabaseConfig.get_db_config()
         self.connection = None
 
     def connect(self):
-        """Connect to database based on configuration."""
-        if self.config["type"] == "sqlite":
-            self.connection = sqlite3.connect(self.config["path"], check_same_thread=self.config["check_same_thread"])
-            # Enable Row objects instead of tuples
-            self.connection.row_factory = sqlite3.Row
-            # Enable foreign keys for SQLite
-            self.connection.execute("PRAGMA foreign_keys = ON")
-
-        elif self.config["type"] == "postgresql":
-            import psycopg2
-            import psycopg2.extras
-
-            self.connection = psycopg2.connect(
-                host=self.config["host"],
-                port=self.config["port"],
-                database=self.config["database"],
-                user=self.config["user"],
-                password=self.config["password"],
-                sslmode=self.config["sslmode"],
-                cursor_factory=psycopg2.extras.DictCursor,
-            )
+        """Connect to PostgreSQL database."""
+        import psycopg2
+        import psycopg2.extras
+
+        self.connection = psycopg2.connect(
+            host=self.config["host"],
+            port=self.config["port"],
+            database=self.config["database"],
+            user=self.config["user"],
+            password=self.config["password"],
+            sslmode=self.config["sslmode"],
+            cursor_factory=psycopg2.extras.DictCursor,
+        )
 
         return self.connection
 
     def execute(self, query: str, params: tuple | None = None):
-        """Execute a query with proper parameter substitution."""
+        """Execute a query with parameter substitution."""
         cursor = self.connection.cursor()
 
-        # Convert parameter placeholders based on database type
-        if self.config["type"] == "postgresql" and "?" in query:
-            # Convert SQLite-style ? to %s for PostgreSQL
-            query = query.replace("?", "%s")
-
         if params:
             cursor.execute(query, params)
         else:
@@ -171,7 +130,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
 
 def get_db_connection() -> DatabaseConnection:
-    """Get a database connection using current configuration."""
+    """Get a PostgreSQL database connection using current configuration."""
     conn = DatabaseConnection()
     conn.connect()
     return conn
diff --git a/tests/conftest.py b/tests/conftest.py
index 1414ad6cd..2b53fe640 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -8,6 +8,7 @@
 import os
 import sys
 import tempfile
+import unittest
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
@@ -84,16 +85,36 @@ def test_db_path():
             pass  # Ignore cleanup errors
 
 
-@pytest.fixture(autouse=True)
-def test_environment(monkeypatch):
+@pytest.fixture(autouse=True, scope="function")
+def test_environment(monkeypatch, request):
     """Configure test environment variables without global pollution."""
     # Set testing flags
     monkeypatch.setenv("ADCP_TESTING", "true")
     monkeypatch.setenv("ADCP_AUTH_TEST_MODE", "true")  # Enable test mode for auth
 
-    # Set default test values if not already configured
-    if "DATABASE_URL" not in os.environ:
-        monkeypatch.setenv("DATABASE_URL", "sqlite:///:memory:")
+    # Check if this is an integration test that needs the database
+    is_integration_test = "integration" in str(request.fspath)
+    adcp_test_db_url = os.environ.get("ADCP_TEST_DB_URL")
+
+    # Check if this is a unittest.TestCase (which manages its own DATABASE_URL)
+    # Pytest calls these as "UnitTestCase" in the node hierarchy
+    is_unittest_class = (
+        hasattr(request, "cls") and request.cls is not None and issubclass(request.cls, unittest.TestCase)
+    )
+
+    # IMPORTANT: Unit tests should NEVER use real database connections
+    # Remove database-related env vars UNLESS:
+    # 1. This is an integration test with ADCP_TEST_DB_URL set (pytest fixtures), OR
+    # 2. This is a unittest.TestCase class (manages its own DATABASE_URL in setUpClass)
+    should_preserve_db = is_integration_test and (adcp_test_db_url or is_unittest_class)
+
+    if not should_preserve_db:
+        if "DATABASE_URL" in os.environ:
+            monkeypatch.delenv("DATABASE_URL", raising=False)
+        if "TEST_DATABASE_URL" in os.environ:
+            monkeypatch.delenv("TEST_DATABASE_URL", raising=False)
+        if "ADCP_TEST_DB_URL" in os.environ:
+            monkeypatch.delenv("ADCP_TEST_DB_URL", raising=False)
 
     # Set test API keys and credentials
     monkeypatch.setenv("GEMINI_API_KEY", os.environ.get("GEMINI_API_KEY", "test_key_for_mocking"))
@@ -102,7 +123,16 @@ def test_environment(monkeypatch):
     monkeypatch.setenv("SUPER_ADMIN_EMAILS", os.environ.get("SUPER_ADMIN_EMAILS", "test@example.com"))
 
     yield
-    # Cleanup happens automatically with monkeypatch
+
+    # Cleanup: Reset engine to ensure clean state for next test
+    # This prevents test isolation issues from module-level state
+    try:
+        from src.core.database.database_session import reset_engine
+
+        reset_engine()
+    except Exception:
+        # Ignore errors during cleanup (e.g., if module not yet loaded)
+        pass
 
 
 # NOTE: db_session fixture is now imported from conftest_db.py
diff --git a/tests/conftest_db.py b/tests/conftest_db.py
index 631cf331f..c23e4396c 100644
--- a/tests/conftest_db.py
+++ b/tests/conftest_db.py
@@ -13,10 +13,20 @@
 
 @pytest.fixture(scope="session")
 def test_database_url():
-    """Create a test database URL."""
-    # Use TEST_DATABASE_URL if set (for local testing), otherwise DATABASE_URL (for CI),
-    # otherwise default to in-memory SQLite
-    return os.environ.get("TEST_DATABASE_URL") or os.environ.get("DATABASE_URL", "sqlite:///:memory:")
+    """Get PostgreSQL test database URL.
+
+    REQUIRES: PostgreSQL container running (via run_all_tests.sh ci)
+    """
+    # Use TEST_DATABASE_URL if set, otherwise DATABASE_URL (for CI)
+    url = os.environ.get("TEST_DATABASE_URL") or os.environ.get("DATABASE_URL")
+
+    if not url:
+        pytest.skip("Tests require PostgreSQL. Run: ./run_all_tests.sh ci")
+
+    if "postgresql" not in url:
+        pytest.skip(f"Tests require PostgreSQL, got: {url.split('://')[0]}. Run: ./run_all_tests.sh ci")
+
+    return url
 
 
 @pytest.fixture(scope="session")
@@ -24,9 +34,9 @@ def test_database(test_database_url):
     """Create and initialize test database once per session."""
     # Set the database URL for the application
     os.environ["DATABASE_URL"] = test_database_url
-    os.environ["DB_TYPE"] = "sqlite" if "sqlite" in test_database_url else "postgresql"
+    os.environ["DB_TYPE"] = "postgresql"
 
-    # Import all models FIRST (needed for both in-memory and PostgreSQL)
+    # Import all models FIRST
     from sqlalchemy import create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
 
@@ -63,26 +73,26 @@ def test_database(test_database_url):
     # This ensures we use the correct DATABASE_URL set above
     engine = create_engine(test_database_url, echo=False)
 
-    # Run migrations if not in-memory
-    if ":memory:" not in test_database_url:
-        import subprocess
-
-        result = subprocess.run(
-            ["python3", "scripts/ops/migrate.py"], capture_output=True, text=True, cwd=Path(__file__).parent.parent
-        )
-        if result.returncode != 0:
-            pytest.skip(f"Migration failed: {result.stderr}")
-    else:
-        # For in-memory database, create tables directly (migrations don't work with :memory:)
-        Base.metadata.create_all(engine)
-
-    # Update the global database session to use this engine (for BOTH in-memory and PostgreSQL)
-    # This ensures all tests use the correct test database, not the stale module-level engine
+    # Run migrations for PostgreSQL
+    import subprocess
+
+    result = subprocess.run(
+        ["python3", "scripts/ops/migrate.py"], capture_output=True, text=True, cwd=Path(__file__).parent.parent
+    )
+    if result.returncode != 0:
+        pytest.skip(f"Migration failed: {result.stderr}")
+
+    # Reset any existing engine and force initialization with test database
+    from src.core.database.database_session import reset_engine
+
+    reset_engine()
+
+    # Now update the globals to use our test engine
     import src.core.database.database_session as db_session_module
 
-    db_session_module.engine = engine
-    db_session_module.SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-    db_session_module.db_session = scoped_session(db_session_module.SessionLocal)
+    db_session_module._engine = engine
+    db_session_module._session_factory = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    db_session_module._scoped_session = scoped_session(db_session_module._session_factory)
 
     # Initialize with test data
     from scripts.setup.init_database import init_db
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index 399231cb3..073023259 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -20,63 +20,53 @@
 
 @pytest.fixture(scope="function")  # Changed to function scope for better isolation
 def integration_db():
-    """Provide an isolated database for each integration test.
+    """Provide an isolated PostgreSQL database for each integration test.
 
-    Uses PostgreSQL when ADCP_TEST_DB_URL is set (CI mode), otherwise falls back to SQLite.
-    PostgreSQL is preferred for integration tests because:
-    - Matches production environment
+    REQUIRES: PostgreSQL container running (via run_all_tests.sh ci)
+    - ADCP_TEST_DB_URL must be set (e.g., postgresql://adcp_user:test_password@localhost:5433/adcp_test)
+    - Matches production environment exactly
     - Better multi-process support (fixes mcp_server tests)
     - Consistent JSONB behavior
     """
-    import tempfile
     import uuid
 
     # Save original DATABASE_URL
     original_url = os.environ.get("DATABASE_URL")
     original_db_type = os.environ.get("DB_TYPE")
 
-    # Check if we should use PostgreSQL (CI mode)
+    # Require PostgreSQL - no SQLite fallback
     postgres_url = os.environ.get("ADCP_TEST_DB_URL")
+    if not postgres_url:
+        pytest.skip("Integration tests require PostgreSQL. Run: ./run_all_tests.sh ci")
 
-    if postgres_url:
-        # PostgreSQL mode - create unique database per test
-        unique_db_name = f"test_{uuid.uuid4().hex[:8]}"
-        db_url = f"{postgres_url.rsplit('/', 1)[0]}/{unique_db_name}"
-
-        # Create the test database
-        import psycopg2
-        from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT
-
-        # Connect to default database to create our test database
-        base_url = postgres_url.rsplit("/", 1)[0]
-        conn_params = {
-            "host": "localhost",
-            "port": 5433,  # Default from run_all_tests.sh
-            "user": "adcp_user",
-            "password": "test_password",
-            "database": "postgres",  # Connect to default db first
-        }
+    # PostgreSQL mode - create unique database per test
+    unique_db_name = f"test_{uuid.uuid4().hex[:8]}"
 
-        conn = psycopg2.connect(**conn_params)
-        conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
-        cur = conn.cursor()
+    # Create the test database
+    import psycopg2
+    from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT
 
-        try:
-            cur.execute(f'CREATE DATABASE "{unique_db_name}"')
-        finally:
-            cur.close()
-            conn.close()
-
-        os.environ["DATABASE_URL"] = f"postgresql://adcp_user:test_password@localhost:5433/{unique_db_name}"
-        os.environ["DB_TYPE"] = "postgresql"
-        db_path = unique_db_name  # For cleanup reference
-    else:
-        # SQLite mode (fallback for quick local testing)
-        with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
-            db_path = f.name
+    conn_params = {
+        "host": "localhost",
+        "port": 5433,  # Default from run_all_tests.sh
+        "user": "adcp_user",
+        "password": "test_password",
+        "database": "postgres",  # Connect to default db first
+    }
+
+    conn = psycopg2.connect(**conn_params)
+    conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
+    cur = conn.cursor()
 
-        os.environ["DATABASE_URL"] = f"sqlite:///{db_path}"
-        os.environ["DB_TYPE"] = "sqlite"
+    try:
+        cur.execute(f'CREATE DATABASE "{unique_db_name}"')
+    finally:
+        cur.close()
+        conn.close()
+
+    os.environ["DATABASE_URL"] = f"postgresql://adcp_user:test_password@localhost:5433/{unique_db_name}"
+    os.environ["DB_TYPE"] = "postgresql"
+    db_path = unique_db_name  # For cleanup reference
 
     # Create the database without running migrations
     # (migrations are for production, tests create tables directly)
@@ -92,7 +82,7 @@ def integration_db():
     # (in case the module import doesn't trigger class definition)
     _ = (Context, WorkflowStep, ObjectWorkflowMapping)
 
-    engine = create_engine(f"sqlite:///{db_path}", echo=False)
+    engine = create_engine(f"postgresql://adcp_user:test_password@localhost:5433/{unique_db_name}", echo=False)
 
     # Ensure all model classes are imported and registered with Base.metadata
     # Import order matters - some models may not be registered if imported too early
@@ -153,19 +143,17 @@ def integration_db():
     # Create all tables directly (no migrations)
     Base.metadata.create_all(bind=engine, checkfirst=True)
 
-    # Update the global database session to point to the test database
-    # This is necessary because many parts of the code use the global db_session
-    from src.core.database import database_session
+    # Reset engine and update globals to point to the test database
+    from src.core.database.database_session import reset_engine
 
-    # Save the original values
-    original_engine = database_session.engine
-    original_session_local = database_session.SessionLocal
-    original_db_session = database_session.db_session
+    reset_engine()
 
-    # Replace with test database
-    database_session.engine = engine
-    database_session.SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-    database_session.db_session = scoped_session(database_session.SessionLocal)
+    # Now update the globals to use our test engine
+    import src.core.database.database_session as db_session_module
+
+    db_session_module._engine = engine
+    db_session_module._session_factory = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    db_session_module._scoped_session = scoped_session(db_session_module._session_factory)
 
     # Reset context manager singleton so it uses the new database session
     # This is critical because ContextManager caches a session reference
@@ -175,10 +163,8 @@ def integration_db():
 
     yield db_path
 
-    # Restore original database session
-    database_session.engine = original_engine
-    database_session.SessionLocal = original_session_local
-    database_session.db_session = original_db_session
+    # Reset engine to clean up test database connections
+    reset_engine()
 
     # Reset context manager singleton again to avoid stale references
     src.core.context_manager._context_manager_instance = None
@@ -197,33 +183,25 @@ def integration_db():
     elif "DB_TYPE" in os.environ:
         del os.environ["DB_TYPE"]
 
-    # Remove temporary database
-    if postgres_url:
-        # Drop PostgreSQL test database
-        try:
-            conn = psycopg2.connect(**conn_params)
-            conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
-            cur = conn.cursor()
-            # Terminate connections to the test database
-            cur.execute(
-                f"""
-                SELECT pg_terminate_backend(pg_stat_activity.pid)
-                FROM pg_stat_activity
-                WHERE pg_stat_activity.datname = '{db_path}'
-                AND pid <> pg_backend_pid()
-                """
-            )
-            cur.execute(f'DROP DATABASE IF EXISTS "{db_path}"')
-            cur.close()
-            conn.close()
-        except Exception:
-            pass  # Ignore cleanup errors
-    else:
-        # Remove SQLite file
-        try:
-            os.unlink(db_path)
-        except Exception:
-            pass  # Ignore cleanup errors
+    # Drop PostgreSQL test database
+    try:
+        conn = psycopg2.connect(**conn_params)
+        conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
+        cur = conn.cursor()
+        # Terminate connections to the test database
+        cur.execute(
+            f"""
+            SELECT pg_terminate_backend(pg_stat_activity.pid)
+            FROM pg_stat_activity
+            WHERE pg_stat_activity.datname = '{db_path}'
+            AND pid <> pg_backend_pid()
+            """
+        )
+        cur.execute(f'DROP DATABASE IF EXISTS "{db_path}"')
+        cur.close()
+        conn.close()
+    except Exception:
+        pass  # Ignore cleanup errors
 
 
 @pytest.fixture
diff --git a/tests/unit/test_ai_provider_bug.py b/tests/integration/test_ai_provider_bug.py
similarity index 98%
rename from tests/unit/test_ai_provider_bug.py
rename to tests/integration/test_ai_provider_bug.py
index ae81541ed..c1101d295 100644
--- a/tests/unit/test_ai_provider_bug.py
+++ b/tests/integration/test_ai_provider_bug.py
@@ -17,7 +17,7 @@
 from product_catalog_providers.ai import AIProductCatalog
 
 
-async def test_ai_provider_bug():
+async def test_ai_provider_bug(integration_db):
     """Test if the AI provider has Product validation issues."""
 
     print("🔍 Testing AI provider for Product validation bug...")
diff --git a/tests/unit/test_context_persistence.py b/tests/integration/test_context_persistence.py
similarity index 86%
rename from tests/unit/test_context_persistence.py
rename to tests/integration/test_context_persistence.py
index 1782714f0..a526981f4 100644
--- a/tests/unit/test_context_persistence.py
+++ b/tests/integration/test_context_persistence.py
@@ -3,43 +3,28 @@
 
 import os
 import sys
-import tempfile
 from datetime import UTC, datetime
 
 from rich.console import Console
-from sqlalchemy import create_engine
 
 # Add parent directory to path
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 from src.core.context_manager import ContextManager
-from src.core.database.models import Base
 
 console = Console()
 
 
-def test_simplified_context():
+def test_simplified_context(integration_db):
     """Test the simplified context system."""
 
     console.print("[bold blue]Testing Simplified Context Persistence[/bold blue]")
     console.print("=" * 50)
 
-    # Create a temporary database for testing
-    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as tf:
-        test_db_path = tf.name
+    # Initialize context manager (will use the integration_db fixture)
+    ctx_manager = ContextManager()
 
     try:
-        # Create engine and tables
-        engine = create_engine(f"sqlite:///{test_db_path}")
-        Base.metadata.create_all(engine)
-
-        # Update the global db_session to use our test database
-        from src.core.database.database_session import db_session
-
-        db_session.configure(bind=engine)
-
-        # Initialize context manager (will use the configured db_session)
-        ctx_manager = ContextManager()
 
         # Test 1: Create a simple context for async operation
         console.print("\n[yellow]Test 1: Creating context for async operation[/yellow]")
@@ -156,14 +141,9 @@ def test_simplified_context():
         raise
 
     finally:
-        # Clean up database session
-        ctx_manager.close()
-        db_session.remove()
-
-        # Clean up temporary database
-        if os.path.exists(test_db_path):
-            os.unlink(test_db_path)
-            console.print(f"\n[dim]Cleaned up test database: {test_db_path}[/dim]")
+        # Clean up context manager
+        if "ctx_manager" in locals():
+            ctx_manager.close()
 
 
 if __name__ == "__main__":
diff --git a/tests/integration/test_dashboard_reliability.py b/tests/integration/test_dashboard_reliability.py
index eb07cfae8..49e0157ec 100644
--- a/tests/integration/test_dashboard_reliability.py
+++ b/tests/integration/test_dashboard_reliability.py
@@ -140,7 +140,7 @@ def test_dashboard_audit_log_integration(self, authenticated_admin_client, test_
             assert "success" in activity["metadata"]
 
     @pytest.mark.requires_db
-    def test_dashboard_service_caching_works(self, test_tenant):
+    def test_dashboard_service_caching_works(self, integration_db, test_tenant):
         """Test that dashboard service correctly caches tenant lookups."""
         service = DashboardService(test_tenant.tenant_id)
 
@@ -236,7 +236,7 @@ class TestLegacyCompatibility:
     """Test that changes maintain compatibility with existing functionality."""
 
     @pytest.mark.requires_db
-    def test_audit_log_format_compatibility(self, test_audit_log):
+    def test_audit_log_format_compatibility(self, integration_db, test_audit_log):
         """Test that audit log format is compatible with activity stream."""
         from src.admin.blueprints.activity_stream import format_activity_from_audit_log
 
@@ -250,7 +250,7 @@ def test_audit_log_format_compatibility(self, test_audit_log):
         assert "type" in activity
 
     @pytest.mark.requires_db
-    def test_media_buy_relationships_still_work(self, test_media_buy, test_principal):
+    def test_media_buy_relationships_still_work(self, integration_db, test_media_buy, test_principal):
         """Test that media buy relationships work after model cleanup."""
         # Should be able to access principal
         assert test_media_buy.principal is not None
diff --git a/tests/integration/test_database_health.py b/tests/integration/test_database_health.py
index 764b78809..3d1fb7a6b 100644
--- a/tests/integration/test_database_health.py
+++ b/tests/integration/test_database_health.py
@@ -26,7 +26,7 @@ def test_real_database_health_check(self):
         assert health["status"] in ["healthy", "unhealthy", "warning", "error"]
 
     @pytest.mark.requires_db
-    def test_real_table_existence_checks(self):
+    def test_real_table_existence_checks(self, integration_db):
         """Test table existence checks against real database."""
         # These tables should always exist in test database
         assert check_table_exists("tenants") is True
@@ -36,7 +36,7 @@ def test_real_table_existence_checks(self):
         assert check_table_exists("definitely_nonexistent_table_12345") is False
 
     @pytest.mark.requires_db
-    def test_real_table_info_audit_logs(self):
+    def test_real_table_info_audit_logs(self, integration_db):
         """Test getting real table info for audit_logs."""
         info = get_table_info("audit_logs")
 
diff --git a/tests/integration/test_database_health_integration.py b/tests/integration/test_database_health_integration.py
index c3f56a03c..5ab6c8e72 100644
--- a/tests/integration/test_database_health_integration.py
+++ b/tests/integration/test_database_health_integration.py
@@ -25,7 +25,7 @@ class TestDatabaseHealthIntegration:
     # Note: Using conftest_db fixtures instead of custom temp_database
     # This ensures proper test isolation and database setup
 
-    def test_health_check_with_complete_database(self, test_tenant):
+    def test_health_check_with_complete_database(self, integration_db, test_tenant):
         """Test health check against a complete, properly migrated database."""
         # test_tenant fixture provides a functional database with test data
 
@@ -51,7 +51,7 @@ def test_health_check_with_complete_database(self, test_tenant):
         assert isinstance(health["schema_issues"], list)
         assert isinstance(health["recommendations"], list)
 
-    def test_health_check_with_missing_tables(self):
+    def test_health_check_with_missing_tables(self, integration_db):
         """Test health check detects missing tables correctly."""
         # Use a mock to simulate missing tables without actually dropping them
         from unittest.mock import patch
@@ -81,7 +81,7 @@ def test_health_check_with_missing_tables(self):
                 assert health["status"] == "unhealthy", "Should report unhealthy status"
                 assert len(health["schema_issues"]) > 0, "Should report schema issues"
 
-    def test_health_check_with_extra_tables(self, clean_db):
+    def test_health_check_with_extra_tables(self, integration_db, clean_db):
         """Test health check detects extra/deprecated tables."""
         # Add an extra table that shouldn't exist
         from src.core.database.database_session import engine
@@ -98,7 +98,7 @@ def test_health_check_with_extra_tables(self, clean_db):
         # Should detect extra table
         assert "deprecated_old_table" in health["extra_tables"], "Should detect extra table"
 
-    def test_health_check_database_access_errors(self):
+    def test_health_check_database_access_errors(self, integration_db):
         """Test health check handles database access errors gracefully."""
         # Mock the database session to raise a connection error
         from unittest.mock import MagicMock, patch
@@ -124,7 +124,7 @@ def test_health_check_database_access_errors(self):
             error_found = any("health check failed" in issue.lower() for issue in health["schema_issues"])
             assert error_found, f"Should include database connection error in issues: {health['schema_issues']}"
 
-    def test_health_check_migration_status_detection(self, clean_db):
+    def test_health_check_migration_status_detection(self, integration_db, clean_db):
         """Test that health check correctly detects migration status."""
         # The health check should detect current migration version
         health = check_database_health()
@@ -137,7 +137,7 @@ def test_health_check_migration_status_detection(self, clean_db):
         if health["migration_status"]:
             assert len(health["migration_status"]) > 0, "Migration status should not be empty string"
 
-    def test_print_health_report_integration(self, clean_db, capsys):
+    def test_print_health_report_integration(self, integration_db, clean_db, capsys):
         """Test health report printing with real health check data."""
         # Run real health check
         health = check_database_health()
@@ -156,7 +156,7 @@ def test_print_health_report_integration(self, clean_db, capsys):
         # Should be properly formatted
         assert "Database Health Status:" in captured.out, "Should have header"
 
-    def test_health_check_with_real_schema_validation(self, test_tenant, test_product):
+    def test_health_check_with_real_schema_validation(self, integration_db, test_tenant, test_product):
         """Test health check validates actual database schema against expected schema."""
         # test_tenant and test_product fixtures provide test data
 
@@ -176,7 +176,7 @@ def test_health_check_with_real_schema_validation(self, test_tenant, test_produc
             assert product_count >= 1, "Should have at least one product"
 
     @pytest.mark.requires_db
-    def test_health_check_performance_with_real_database(self, clean_db):
+    def test_health_check_performance_with_real_database(self, integration_db, clean_db):
         """Test that health check completes in reasonable time with real database."""
         import time
 
@@ -208,7 +208,7 @@ def test_health_check_performance_with_real_database(self, clean_db):
         # Should still return valid results
         assert "status" in health, "Should return valid health report even with larger dataset"
 
-    def test_health_check_table_existence_validation(self, test_tenant):
+    def test_health_check_table_existence_validation(self, integration_db, test_tenant):
         """Test that health check validates existence of all required tables."""
         # Get list of tables that should exist
 
diff --git a/tests/integration/test_get_products_database_integration.py b/tests/integration/test_get_products_database_integration.py
index 7dfdc4d63..566d90ba6 100644
--- a/tests/integration/test_get_products_database_integration.py
+++ b/tests/integration/test_get_products_database_integration.py
@@ -679,8 +679,9 @@ class TestParallelTestExecution:
     """Tests for parallel test execution with isolated databases."""
 
     @pytest.mark.asyncio
+    @pytest.mark.requires_db
     @pytest.mark.parametrize("test_id", [f"parallel_{i:02d}" for i in range(5)])
-    async def test_parallel_database_isolation(self, test_id):
+    async def test_parallel_database_isolation(self, integration_db, test_id):
         """Test that parallel tests can run with isolated database state."""
         tenant_id = f"parallel_test_{test_id}"
 
@@ -750,8 +751,9 @@ async def test_parallel_database_isolation(self, test_id):
                 session.commit()
 
     @pytest.mark.integration
+    @pytest.mark.requires_db
     @pytest.mark.slow
-    def test_database_connection_pooling_efficiency(self):
+    def test_database_connection_pooling_efficiency(self, integration_db):
         """Test that connection pooling works efficiently under load."""
         results = []
         start_time = time.time()
diff --git a/tests/integration/test_health_route_migration.py b/tests/integration/test_health_route_migration.py
index 369a7ffb0..9768ec3b4 100644
--- a/tests/integration/test_health_route_migration.py
+++ b/tests/integration/test_health_route_migration.py
@@ -8,7 +8,7 @@
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
 
-def test_health_routes_in_refactored_app():
+def test_health_routes_in_refactored_app(integration_db):
     """Test that both health routes work in the refactored app."""
     from src.admin.app import create_app
 
@@ -29,7 +29,7 @@ def test_health_routes_in_refactored_app():
     print("✅ Both health routes work in refactored app!")
 
 
-def test_health_routes_in_original_app():
+def test_health_routes_in_original_app(integration_db):
     """Test that health routes still work in original app for comparison."""
     from src.admin.app import create_app
 
diff --git a/tests/unit/test_list_creative_formats_params.py b/tests/integration/test_list_creative_formats_params.py
similarity index 76%
rename from tests/unit/test_list_creative_formats_params.py
rename to tests/integration/test_list_creative_formats_params.py
index a952d2ddb..eeb676c95 100644
--- a/tests/unit/test_list_creative_formats_params.py
+++ b/tests/integration/test_list_creative_formats_params.py
@@ -1,6 +1,20 @@
-"""Test that list_creative_formats accepts and uses filter parameters."""
+"""Integration tests for list_creative_formats filtering parameters.
 
-from src.core.schemas import ListCreativeFormatsRequest
+These are integration tests because they:
+1. Use real database queries (FORMAT_REGISTRY + CreativeFormat table)
+2. Exercise the full implementation stack (tools.py → main.py → database)
+3. Test tenant resolution and audit logging
+4. Validate actual filtering logic with real data
+
+Per architecture guidelines: "Integration over Mocking - Use real DB, mock only external services"
+"""
+
+from datetime import UTC, datetime
+from unittest.mock import patch
+
+from src.core.schemas import Format, ListCreativeFormatsRequest
+from src.core.tool_context import ToolContext
+from src.core.tools import list_creative_formats_raw
 
 
 def test_list_creative_formats_request_minimal():
@@ -29,19 +43,12 @@ def test_list_creative_formats_request_with_all_params():
     assert req.format_ids == ["video_16x9", "video_4x3"]
 
 
-def test_filtering_by_type():
+def test_filtering_by_type(integration_db, sample_tenant):
     """Test that type filter works correctly."""
-    from datetime import UTC, datetime
-    from unittest.mock import patch
-
-    from src.core.schemas import Format
-    from src.core.tool_context import ToolContext
-    from src.core.tools import list_creative_formats_raw
-
     # Create real ToolContext
     context = ToolContext(
         context_id="test",
-        tenant_id="test_tenant",
+        tenant_id=sample_tenant["tenant_id"],
         principal_id="test_principal",
         tool_name="list_creative_formats",
         request_timestamp=datetime.now(UTC),
@@ -49,8 +56,8 @@ def test_filtering_by_type():
         testing_context={},
     )
 
-    # Mock get_current_tenant to return a test tenant
-    with patch("src.core.main.get_current_tenant", return_value={"tenant_id": "test_tenant"}):
+    # Mock tenant resolution to return our test tenant
+    with patch("src.core.main.get_current_tenant", return_value=sample_tenant):
         # Test filtering by type
         req = ListCreativeFormatsRequest(type="video")
         response = list_creative_formats_raw(req, context)
@@ -69,19 +76,12 @@ def test_filtering_by_type():
         assert len(formats) > 0, "Should have at least some video formats"
 
 
-def test_filtering_by_standard_only():
+def test_filtering_by_standard_only(integration_db, sample_tenant):
     """Test that standard_only filter works correctly."""
-    from datetime import UTC, datetime
-    from unittest.mock import patch
-
-    from src.core.schemas import Format
-    from src.core.tool_context import ToolContext
-    from src.core.tools import list_creative_formats_raw
-
     # Create real ToolContext
     context = ToolContext(
         context_id="test",
-        tenant_id="test_tenant",
+        tenant_id=sample_tenant["tenant_id"],
         principal_id="test_principal",
         tool_name="list_creative_formats",
         request_timestamp=datetime.now(UTC),
@@ -89,8 +89,8 @@ def test_filtering_by_standard_only():
         testing_context={},
     )
 
-    # Mock get_current_tenant to return a test tenant
-    with patch("src.core.main.get_current_tenant", return_value={"tenant_id": "test_tenant"}):
+    # Mock tenant resolution to return our test tenant
+    with patch("src.core.main.get_current_tenant", return_value=sample_tenant):
         # Test filtering by standard_only
         req = ListCreativeFormatsRequest(standard_only=True)
         response = list_creative_formats_raw(req, context)
@@ -108,19 +108,12 @@ def test_filtering_by_standard_only():
         assert len(formats) > 0, "Should have at least some standard formats"
 
 
-def test_filtering_by_format_ids():
+def test_filtering_by_format_ids(integration_db, sample_tenant):
     """Test that format_ids filter works correctly."""
-    from datetime import UTC, datetime
-    from unittest.mock import patch
-
-    from src.core.schemas import Format
-    from src.core.tool_context import ToolContext
-    from src.core.tools import list_creative_formats_raw
-
     # Create real ToolContext
     context = ToolContext(
         context_id="test",
-        tenant_id="test_tenant",
+        tenant_id=sample_tenant["tenant_id"],
         principal_id="test_principal",
         tool_name="list_creative_formats",
         request_timestamp=datetime.now(UTC),
@@ -128,8 +121,8 @@ def test_filtering_by_format_ids():
         testing_context={},
     )
 
-    # Mock get_current_tenant to return a test tenant
-    with patch("src.core.main.get_current_tenant", return_value={"tenant_id": "test_tenant"}):
+    # Mock tenant resolution to return our test tenant
+    with patch("src.core.main.get_current_tenant", return_value=sample_tenant):
         # Test filtering by specific format IDs
         target_ids = ["display_300x250", "display_728x90"]
         req = ListCreativeFormatsRequest(format_ids=target_ids)
@@ -150,19 +143,12 @@ def test_filtering_by_format_ids():
         assert len(formats) > 0, "Should return at least one format if they exist"
 
 
-def test_filtering_combined():
+def test_filtering_combined(integration_db, sample_tenant):
     """Test that multiple filters work together."""
-    from datetime import UTC, datetime
-    from unittest.mock import patch
-
-    from src.core.schemas import Format
-    from src.core.tool_context import ToolContext
-    from src.core.tools import list_creative_formats_raw
-
     # Create real ToolContext
     context = ToolContext(
         context_id="test",
-        tenant_id="test_tenant",
+        tenant_id=sample_tenant["tenant_id"],
         principal_id="test_principal",
         tool_name="list_creative_formats",
         request_timestamp=datetime.now(UTC),
@@ -170,8 +156,8 @@ def test_filtering_combined():
         testing_context={},
     )
 
-    # Mock get_current_tenant to return a test tenant
-    with patch("src.core.main.get_current_tenant", return_value={"tenant_id": "test_tenant"}):
+    # Mock tenant resolution to return our test tenant
+    with patch("src.core.main.get_current_tenant", return_value=sample_tenant):
         # Test combining type and standard_only filters
         req = ListCreativeFormatsRequest(type="display", standard_only=True)
         response = list_creative_formats_raw(req, context)
@@ -186,3 +172,4 @@ def test_filtering_combined():
 
         # All returned formats should match both filters
         assert all(f.type == "display" and f.is_standard for f in formats), "All formats should be display AND standard"
+        assert len(formats) > 0, "Should have at least some display standard formats"
diff --git a/tests/integration/test_mcp_tool_roundtrip_validation.py b/tests/integration/test_mcp_tool_roundtrip_validation.py
index 39563d766..bdb92b1ed 100644
--- a/tests/integration/test_mcp_tool_roundtrip_validation.py
+++ b/tests/integration/test_mcp_tool_roundtrip_validation.py
@@ -135,7 +135,9 @@ def real_products_in_db(self, test_tenant_id) -> list[ProductModel]:
 
         return created_products
 
-    def test_get_products_real_object_roundtrip_conversion_isolated(self, test_tenant_id, real_products_in_db):
+    def test_get_products_real_object_roundtrip_conversion_isolated(
+        self, integration_db, test_tenant_id, real_products_in_db
+    ):
         """
         Test Product roundtrip conversion with REAL objects to catch conversion issues.
 
@@ -204,7 +206,9 @@ def test_get_products_real_object_roundtrip_conversion_isolated(self, test_tenan
         assert display_product.format_ids == ["display_300x250", "display_728x90"]
         assert video_product.format_ids == ["video_15s", "video_30s"]
 
-    def test_get_products_with_testing_hooks_roundtrip_isolated(self, test_tenant_id, real_products_in_db):
+    def test_get_products_with_testing_hooks_roundtrip_isolated(
+        self, integration_db, test_tenant_id, real_products_in_db
+    ):
         """
         Test Product roundtrip conversion with testing hooks to catch the EXACT conversion issue.
 
diff --git a/tests/integration/test_mcp_tools_audit.py b/tests/integration/test_mcp_tools_audit.py
index 5871d406d..9bd3930d5 100644
--- a/tests/integration/test_mcp_tools_audit.py
+++ b/tests/integration/test_mcp_tools_audit.py
@@ -76,7 +76,7 @@ def test_tenant_id(self):
             session.execute(delete(Tenant).where(Tenant.tenant_id == tenant_id))
             session.commit()
 
-    def test_get_media_buy_delivery_roundtrip_safety(self, test_tenant_id):
+    def test_get_media_buy_delivery_roundtrip_safety(self, integration_db, test_tenant_id):
         """
         Audit get_media_buy_delivery for roundtrip conversion safety.
 
diff --git a/tests/integration/test_product_deletion.py b/tests/integration/test_product_deletion.py
index 49c733542..39d66002d 100644
--- a/tests/integration/test_product_deletion.py
+++ b/tests/integration/test_product_deletion.py
@@ -390,7 +390,7 @@ def test_environment_super_admin_check(self):
             assert is_super_admin("env-admin@example.com") is True
             assert is_super_admin("not-admin@example.com") is False
 
-    def test_database_fallback_super_admin_check(self, setup_super_admin_config):
+    def test_database_fallback_super_admin_check(self, integration_db, setup_super_admin_config):
         """Test that database is used as fallback when environment variables are not set."""
         from src.admin.utils import is_super_admin
 
diff --git a/tests/integration/test_schema_database_mapping.py b/tests/integration/test_schema_database_mapping.py
index eb06c23d4..aa02ce3bf 100644
--- a/tests/integration/test_schema_database_mapping.py
+++ b/tests/integration/test_schema_database_mapping.py
@@ -71,7 +71,7 @@ def test_product_schema_database_field_alignment(self):
             assert field in schema_fields, f"Critical field '{field}' missing from Product schema"
             assert field in db_columns, f"Critical field '{field}' missing from ProductModel database"
 
-    def test_database_field_access_validation(self):
+    def test_database_field_access_validation(self, integration_db):
         """Test that all database fields can be accessed without AttributeError."""
         # Create a test tenant and product
         tenant_id = "test_field_access"
@@ -138,7 +138,7 @@ def test_principal_schema_database_alignment(self):
 
         assert not missing_db_fields, f"Principal schema fields missing from database: {missing_db_fields}"
 
-    def test_schema_to_database_conversion_safety(self):
+    def test_schema_to_database_conversion_safety(self, integration_db):
         """Test that schema-to-database conversion only uses existing fields."""
         # This simulates the conversion logic in DatabaseProductCatalog
         tenant_id = "test_conversion_safety"
@@ -259,7 +259,7 @@ def test_pydantic_model_field_access_patterns(self):
         with pytest.raises(AttributeError):
             _ = product.non_existent_field
 
-    def test_database_json_field_handling(self):
+    def test_database_json_field_handling(self, integration_db):
         """Test that JSON fields in database are handled correctly in schema conversion."""
         tenant_id = "test_json_handling"
 
@@ -311,7 +311,7 @@ def test_database_json_field_handling(self):
             session.delete(tenant)
             session.commit()
 
-    def test_schema_validation_with_database_data(self):
+    def test_schema_validation_with_database_data(self, integration_db):
         """Test that data from database can be validated against Pydantic schemas."""
         tenant_id = "test_schema_validation"
 
diff --git a/tests/integration/test_self_service_signup.py b/tests/integration/test_self_service_signup.py
index 857817a76..545f34645 100644
--- a/tests/integration/test_self_service_signup.py
+++ b/tests/integration/test_self_service_signup.py
@@ -23,7 +23,7 @@
 class TestSelfServiceSignupFlow:
     """Test self-service tenant signup flow."""
 
-    def test_landing_page_accessible_without_auth(self, client):
+    def test_landing_page_accessible_without_auth(self, integration_db, client):
         """Test that landing page is accessible without authentication."""
         response = client.get("/signup")
         assert response.status_code == 200
@@ -66,7 +66,7 @@ def test_onboarding_wizard_renders_with_authenticated_user(self, client):
         assert b"Publisher Information" in response.data
         assert b"Ad Server Integration" in response.data  # Changed from "Select Your Ad Server" for GAM-only signup
 
-    def test_provision_tenant_mock_adapter(self, client):
+    def test_provision_tenant_mock_adapter(self, integration_db, client):
         """Test tenant provisioning with mock adapter."""
         with client.session_transaction() as sess:
             sess["signup_flow"] = True
@@ -112,7 +112,7 @@ def test_provision_tenant_mock_adapter(self, client):
             db_session.delete(tenant)
             db_session.commit()
 
-    def test_provision_tenant_kevel_adapter_with_credentials(self, client):
+    def test_provision_tenant_kevel_adapter_with_credentials(self, integration_db, client):
         """Test tenant provisioning with Kevel adapter and credentials."""
         with client.session_transaction() as sess:
             sess["signup_flow"] = True
@@ -153,7 +153,7 @@ def test_provision_tenant_kevel_adapter_with_credentials(self, client):
             db_session.delete(tenant)
             db_session.commit()
 
-    def test_provision_tenant_gam_adapter_without_oauth(self, client):
+    def test_provision_tenant_gam_adapter_without_oauth(self, integration_db, client):
         """Test tenant provisioning with GAM adapter (to be configured later)."""
         with client.session_transaction() as sess:
             sess["signup_flow"] = True
@@ -192,7 +192,7 @@ def test_provision_tenant_gam_adapter_without_oauth(self, client):
             db_session.delete(tenant)
             db_session.commit()
 
-    def test_subdomain_uniqueness_validation(self, client):
+    def test_subdomain_uniqueness_validation(self, integration_db, client):
         """Test that duplicate subdomains are rejected."""
         # Create an existing tenant
         with get_db_session() as db_session:
@@ -257,7 +257,7 @@ def test_reserved_subdomain_rejection(self, client):
             assert response.status_code == 200
             assert b"reserved" in response.data.lower()
 
-    def test_signup_completion_page_renders(self, client):
+    def test_signup_completion_page_renders(self, integration_db, client):
         """Test that signup completion page renders with tenant information."""
         # Create a test tenant
         with get_db_session() as db_session:
@@ -318,7 +318,7 @@ def test_oauth_callback_redirects_to_onboarding_for_signup_flow(self, client):
             assert response.status_code == 302
             assert "/signup/onboarding" in response.headers["Location"]
 
-    def test_session_cleanup_after_provisioning(self, client):
+    def test_session_cleanup_after_provisioning(self, integration_db, client):
         """Test that signup session flags are cleared after provisioning."""
         with client.session_transaction() as sess:
             sess["signup_flow"] = True
diff --git a/tests/unit/test_session_json_validation.py b/tests/integration/test_session_json_validation.py
similarity index 95%
rename from tests/unit/test_session_json_validation.py
rename to tests/integration/test_session_json_validation.py
index 91337fa55..94b575af0 100644
--- a/tests/unit/test_session_json_validation.py
+++ b/tests/integration/test_session_json_validation.py
@@ -1,16 +1,13 @@
 """Test standardized session management and JSON validation."""
 
-import os
-import tempfile
 from datetime import UTC, datetime
 
 import pytest
-from sqlalchemy import create_engine, select
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy import select
 
 # Import our new utilities
 from src.core.database.database_session import DatabaseManager, get_db_session, get_or_404, get_or_create
-from src.core.database.models import Base, Context, Principal, Product, Tenant, WorkflowStep
+from src.core.database.models import Context, Principal, Product, Tenant, WorkflowStep
 from src.core.json_validators import (
     CommentModel,
     CreativeFormatModel,
@@ -23,27 +20,12 @@
 
 # Test fixtures
 @pytest.fixture
-def test_db():
-    """Create a temporary test database."""
-    # Create a temporary database
-    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
-        db_path = f.name
+def test_db(integration_db):
+    """Use PostgreSQL test database for session management tests."""
+    # integration_db fixture provides the database, just return the engine
+    from src.core.database.database_session import get_engine
 
-    # Create engine and tables
-    engine = create_engine(f"sqlite:///{db_path}")
-    Base.metadata.create_all(engine)
-
-    # Update SessionLocal for tests
-    from src.core.database.database_session import db_session
-
-    _ = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-    db_session.configure(bind=engine)
-
-    yield engine
-
-    # Cleanup
-    db_session.remove()
-    os.unlink(db_path)
+    yield get_engine()
 
 
 class TestSessionManagement:
diff --git a/tests/integration/test_virtual_host_integration.py b/tests/integration/test_virtual_host_integration.py
index 3757de700..919e92739 100644
--- a/tests/integration/test_virtual_host_integration.py
+++ b/tests/integration/test_virtual_host_integration.py
@@ -50,7 +50,7 @@ def __init__(self, headers):
             assert header_value is not None
             assert header_value in ["test1.com", "test2.com", "test3.com"]
 
-    def test_virtual_host_function_integration(self):
+    def test_virtual_host_function_integration(self, integration_db):
         """Test that virtual host lookup function handles non-existent domains gracefully."""
         # This is a real integration test - calls the actual function
         # with a domain that shouldn't exist
diff --git a/tests/smoke/test_database_migrations.py b/tests/smoke/test_database_migrations.py
index a7e96bf21..f022c5086 100644
--- a/tests/smoke/test_database_migrations.py
+++ b/tests/smoke/test_database_migrations.py
@@ -55,8 +55,14 @@ def test_migrations_can_run_on_empty_db(self, test_database):
                 os.unlink(db_path)
 
     @pytest.mark.smoke
+    @pytest.mark.skip_ci
     def test_migrations_are_idempotent(self):
-        """Test that running migrations twice doesn't break."""
+        """Test that running migrations twice doesn't break.
+
+        NOTE: Skipped in CI as it requires SQLite which is not supported in
+        PostgreSQL-only architecture. Run manually for local migration testing.
+        """
+        pytest.skip("SQLite no longer supported - use PostgreSQL for migration testing")
         with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as tmp:
             db_path = tmp.name
 
diff --git a/tests/smoke/test_smoke_critical_paths.py b/tests/smoke/test_smoke_critical_paths.py
index 92a231222..93cf8d249 100644
--- a/tests/smoke/test_smoke_critical_paths.py
+++ b/tests/smoke/test_smoke_critical_paths.py
@@ -219,8 +219,13 @@ class TestDatabaseConnectivity:
     """Test database connectivity and basic operations."""
 
     @pytest.mark.smoke
+    @pytest.mark.skip_ci
     def test_database_connection(self):
-        """Test that we can connect to the database."""
+        """Test that we can connect to the database.
+
+        NOTE: Skipped in CI as it requires DATABASE_URL to be set.
+        This is a manual smoke test for production deployments.
+        """
         from src.core.database.database_session import get_db_session
 
         with get_db_session() as session:
diff --git a/tests/unit/conftest.py b/tests/unit/conftest.py
index 595d823a9..2fb1a75de 100644
--- a/tests/unit/conftest.py
+++ b/tests/unit/conftest.py
@@ -13,9 +13,13 @@
 @pytest.fixture(autouse=True)
 def mock_all_external_dependencies():
     """Automatically mock all external dependencies for unit tests."""
-    # Mock database connections
+    # Mock database connections - create a proper context manager mock
+    mock_session = MagicMock()
+    mock_session.__enter__ = MagicMock(return_value=mock_session)
+    mock_session.__exit__ = MagicMock(return_value=None)
+
     with patch("src.core.database.database_session.get_db_session") as mock_db:
-        mock_db.return_value = MagicMock()
+        mock_db.return_value = mock_session
 
         # Mock external services
         with patch("google.generativeai.configure"):
diff --git a/tests/unit/test_auth_removal_simple.py b/tests/unit/test_auth_removal_simple.py
index 50c126a76..beab2e7fc 100644
--- a/tests/unit/test_auth_removal_simple.py
+++ b/tests/unit/test_auth_removal_simple.py
@@ -6,15 +6,15 @@
 
 from unittest.mock import Mock, patch
 
-# Test the helper function that changed
-from src.core.main import get_principal_from_context
-
 
 class TestAuthRemovalChanges:
     """Simple tests for the core changes made."""
 
     def test_get_principal_from_context_returns_none_without_auth(self):
         """Test that get_principal_from_context returns None when no auth provided."""
+        # Lazy import to avoid triggering load_config() at module import time
+        from src.core.main import get_principal_from_context
+
         context = Mock(spec=["meta"])  # Limit to only meta attribute
         context.meta = {}  # Empty meta, no headers
 
@@ -24,6 +24,9 @@ def test_get_principal_from_context_returns_none_without_auth(self):
 
     def test_get_principal_from_context_works_with_auth(self):
         """Test that get_principal_from_context still works with auth."""
+        # Lazy import to avoid triggering load_config() at module import time
+        from src.core.main import get_principal_from_context
+
         context = Mock(spec=["meta"])  # Limit to only meta attribute
         context.meta = {"headers": {"x-adcp-auth": "test-token"}}
 
diff --git a/tests/unit/test_dashboard_service.py b/tests/unit/test_dashboard_service.py
index ed8f6b5f8..fada12487 100644
--- a/tests/unit/test_dashboard_service.py
+++ b/tests/unit/test_dashboard_service.py
@@ -177,17 +177,3 @@ def test_health_check_unhealthy(self, mock_get_db):
 
         assert health["status"] == "unhealthy"
         assert "Database connection failed" in health["error"]
-
-
-class TestDashboardServiceIntegration:
-    """Integration tests for DashboardService with real database."""
-
-    # Note: Integration tests moved to integration test suite for better database coverage
-
-    @pytest.mark.requires_db
-    def test_error_handling_invalid_tenant(self):
-        """Test error handling for invalid tenant."""
-        service = DashboardService("nonexistent_tenant")
-
-        with pytest.raises(ValueError, match="not found"):
-            service.get_dashboard_metrics()
diff --git a/tests/unit/test_direct_get_products.py b/tests/unit/test_direct_get_products.py
index 2f495b1c4..6f89fb118 100644
--- a/tests/unit/test_direct_get_products.py
+++ b/tests/unit/test_direct_get_products.py
@@ -13,12 +13,12 @@
 # Enable debug logging
 logging.basicConfig(level=logging.DEBUG)
 
-from src.core.main import get_products
-from src.core.tool_context import ToolContext
-
 
 async def test_direct_get_products():
     """Test the get_products function directly."""
+    # Lazy imports to avoid triggering load_config() at module import time
+    from src.core.main import get_products
+    from src.core.tool_context import ToolContext
 
     print("Testing direct get_products call...")