diff --git a/test-suite/README.md b/test-suite/README.md
index 7dce62b289..21af1d6b6c 100644
--- a/test-suite/README.md
+++ b/test-suite/README.md
@@ -30,29 +30,131 @@ KMS can be configured to two modes:
 The test suite offers a unified CLI for all operations:
 
 ```sh
-
 cd test-suite/fhevm
+
 # Deploy the entire stack
 ./fhevm-cli deploy
+# WIP: Build images locally (when private registry not available)
+./fhevm-cli deploy --build
 
-# Run specific tests
-./fhevm-cli test input-proof
-# Trivial
-./fhevm-cli test user-decryption
-# Trivial
-./fhevm-cli test public-decryption
-./fhevm-cli test erc20
-
-# Upgrade a specific service
+# Run blockchain integration tests
+./fhevm-cli test input-proof        # Test input proofs
+./fhevm-cli test user-decryption    # Test user decryptions
+./fhevm-cli test public-decryption  # Test public decryptions  
+./fhevm-cli test erc20              # Test ERC20 operations
+./fhevm-cli test debug              # Debug mode testing
+
+# Database connector testing (runs gateway-stress via fhevm-cli wrapper)
+./fhevm-cli db-test --track-responses            # Test with all DB URLs from config
+./fhevm-cli db-test --duration 60s -t mixed      # Run for 60s with mixed requests
+./fhevm-cli db-test -b 100 --clear-db            # Batch size 100, clear DB first
+
+# Upgrade specific services
+./fhevm-cli upgrade host
+./fhevm-cli upgrade gateway
+./fhevm-cli upgrade connector
 ./fhevm-cli upgrade coprocessor
+./fhevm-cli upgrade relayer
+./fhevm-cli upgrade test-suite
 
-# View logs
-./fhevm-cli logs relayer
+# View logs for any service
+./fhevm-cli logs [SERVICE]
 
-# Clean up
+# Clean up all containers and volumes
 ./fhevm-cli clean
 ```
 
+### Database Connector Testing
+
+The `fhevm-cli db-test` command provides database-level stress testing:
+
+```sh
+# Implemented options:
+-n, --num-connectors NUM  # Number of DB URLs to use from config
+-t, --type TYPE           # Request type: public, user, or mixed
+-b, --batch-size SIZE     # Requests per batch
+--duration TIME           # Test duration (e.g., 30s, 5m, 1h)
+-i, --interval TIME       # Batch interval (e.g., 1s, 500ms, 2s)
+-c, --config FILE         # Path to custom config file
+--track-responses         # Enable response tracking
+--clear-db                # Clear DB tables before test
+
+# Examples:
+./fhevm-cli db-test --clear-db --track-responses         # Clear DB, then test with tracking
+./fhevm-cli db-test -n 2 -t mixed                        # Test 2 DBs with mixed requests
+./fhevm-cli db-test --duration 60s -i 500ms              # 60s test, 500ms intervals
+./fhevm-cli db-test -c custom.toml -b 100 --clear-db     # Custom config, clear DB, batch 100
+
+# Default config: test-suite/gateway-stress/config/config.toml
+```
+
+### Advanced Gateway Stress Testing
+
+For more control, use the standalone `gateway-stress` tool directly (in `test-suite/gateway-stress`):
+
+1. **Blockchain-based testing** - Sends actual transactions through the blockchain
+2. **Database-level testing** - Directly inserts requests into PostgreSQL for focused DB testing
+
+#### Blockchain-based Testing
+Sends decryption requests through the blockchain (requires deployed contracts):
+
+```sh
+cd test-suite/gateway-stress
+
+# Build the tool first
+cargo build --release
+
+# Send public decryption transactions
+./target/release/gateway-stress public
+
+# Send user decryption transactions  
+./target/release/gateway-stress user
+
+# Note: 'mixed' mode is not yet implemented
+```
+
+#### Database-level Testing  
+Bypasses blockchain and directly inserts into PostgreSQL databases:
+
+```sh
+cd test-suite/gateway-stress
+
+# Build the tool
+cargo build --release
+
+# Basic database test with default settings from config
+./target/release/gateway-stress db-connector
+
+# Override test duration and request type
+./target/release/gateway-stress db-connector --duration 60s --request-type public
+
+# Enable response tracking to verify sync across databases
+./target/release/gateway-stress db-connector --track-responses --batch-size 1000
+
+# Use custom configuration
+./target/release/gateway-stress --config custom-config.toml db-connector
+```
+
+#### Prerequisites
+- Rust toolchain (for building gateway-stress)
+- For blockchain testing: Deployed FHEVM contracts and configured ct_handles
+- For database testing: Running PostgreSQL with credentials in `config/config.toml`
+
+#### DB Connector Options
+- `--request-type <TYPE>` - Request type: `public`, `user`, or `mixed`
+- `--duration <TIME>` - Test duration (e.g., `30s`, `5m`, `1h`) 
+- `--batch-size <NUM>` - Requests per batch (for load control)
+- `--track-responses` - Monitor response processing and sync status
+
+#### Configuration File
+The tool reads from a TOML configuration file (default: `config/config.toml`):
+- Database connection strings
+- Batch intervals and sizes
+- Connection pool settings
+- Request generation parameters
+
+See `gateway-stress/README.md` for detailed configuration examples.
+
 ### WIP - Forcing Local Builds (`--build`)
 
 ⚠️ **IMPORTANT: THIS FEATURE IS STILL A WORK IN PROGRESS!** ⚠️
diff --git a/test-suite/fhevm/docker-compose/test-suite-docker-compose.yml b/test-suite/fhevm/docker-compose/test-suite-docker-compose.yml
index d21879b879..528a318355 100644
--- a/test-suite/fhevm/docker-compose/test-suite-docker-compose.yml
+++ b/test-suite/fhevm/docker-compose/test-suite-docker-compose.yml
@@ -14,3 +14,28 @@ services:
       - ../env/staging/.env.test-suite.local
     command:
       - tail -f /dev/null
+  
+  # Gateway stress test with db-connector subcommand
+  gateway-stress-db:
+    container_name: fhevm-gateway-stress-db
+    image: ghcr.io/zama-ai/fhevm/gateway-stress:${TEST_SUITE_VERSION}
+    build:
+      context: ../../..
+      dockerfile: test-suite/gateway-stress/Dockerfile
+    env_file:
+      - ../env/staging/.env.connector.local  # Reuse connector env for DB connection
+    environment:
+      RUST_LOG: ${RUST_LOG:-gateway_stress=info}
+    command:
+      - db-connector
+      - --connectors
+      - "${DB_TEST_CONNECTORS:-1}"
+      - --track-responses
+      - --duration
+      - "${DB_TEST_DURATION:-30s}"
+      - --batch-size
+      - "${DB_TEST_BATCH:-10}"
+      - --request-type
+      - "${DB_TEST_TYPE:-mixed}"
+    profiles:
+      - db-test
diff --git a/test-suite/fhevm/fhevm-cli b/test-suite/fhevm/fhevm-cli
index 9674a77c08..28d196fe26 100755
--- a/test-suite/fhevm/fhevm-cli
+++ b/test-suite/fhevm/fhevm-cli
@@ -51,6 +51,7 @@ function usage {
   echo -e "${BOLD}${LIGHT_BLUE}Commands:${RESET}"
   echo -e "  ${YELLOW}deploy${RESET} ${CYAN}[--build]${RESET}    WIP: Deploy the full fhevm stack (optionally rebuild images)"
   echo -e "  ${YELLOW}test${RESET} ${CYAN}[TYPE]${RESET}         Run tests (input-proof|user-decryption|public-decryption|erc20|debug)"
+  echo -e "  ${YELLOW}db-test${RESET} ${CYAN}[OPTIONS]${RESET}   Test N database connectors with direct insertions"
   echo -e "  ${YELLOW}upgrade${RESET} ${CYAN}[SERVICE]${RESET}   Upgrade specific service (host|gateway|connector|coprocessor|relayer|test-suite)"
   echo -e "  ${YELLOW}clean${RESET}               Remove all containers and volumes"
   echo -e "  ${YELLOW}logs${RESET} ${CYAN}[SERVICE]${RESET}      View logs for a specific service"
@@ -69,6 +70,7 @@ function usage {
   echo -e "  ${PURPLE}./fhevm-cli test user-decryption ${RESET}"
   echo -e "  ${PURPLE}./fhevm-cli test public-decryption -n staging${RESET}"
   echo -e "  ${PURPLE}./fhevm-cli test erc20${RESET}"
+  echo -e "  ${PURPLE}./fhevm-cli db-test -n 3 --track-responses${RESET}"
   echo -e "  ${PURPLE}./fhevm-cli upgrade coprocessor${RESET}"
   echo -e "${BLUE}============================================================${RESET}"
 }
@@ -209,6 +211,140 @@ case $COMMAND in
     fi
     ;;
 
+  db-test)
+    print_logo
+    echo -e "${LIGHT_BLUE}${BOLD}[DB-TEST] Running DB Connector Test...${RESET}"
+    
+    # Check if running with docker-compose or locally
+    USE_DOCKER=false
+    USE_LOCAL=false
+    
+    # Parse first argument to determine mode
+    if [[ "$1" == "--docker" ]] || [[ "$1" == "-d" ]]; then
+      USE_DOCKER=true
+      shift
+    elif [[ "$1" == "--local" ]] || [[ "$1" == "-l" ]]; then
+      USE_LOCAL=true
+      shift
+    else
+      # Default to docker if stack is running
+      if docker ps | grep -q "kms-connector-db"; then
+        USE_DOCKER=true
+        echo -e "${YELLOW}[INFO] Detected running docker stack, using docker mode${RESET}"
+      else
+        USE_LOCAL=true
+        echo -e "${YELLOW}[INFO] No docker stack detected, using local mode${RESET}"
+      fi
+    fi
+    
+    if [ "$USE_DOCKER" = true ]; then
+      # Run using docker-compose
+      echo -e "${BLUE}[INFO] Running DB test in Docker environment${RESET}"
+      
+      # Build environment variables for docker-compose
+      COMPOSE_ENV=""
+      while (( "$#" )); do
+        case "$1" in
+          -n|--connectors)
+            COMPOSE_ENV="$COMPOSE_ENV DB_TEST_CONNECTORS=$2"
+            shift 2
+            ;;
+          --duration)
+            COMPOSE_ENV="$COMPOSE_ENV DB_TEST_DURATION=$2"
+            shift 2
+            ;;
+          -b|--batch-size)
+            COMPOSE_ENV="$COMPOSE_ENV DB_TEST_BATCH=$2"
+            shift 2
+            ;;
+          -t|--type)
+            COMPOSE_ENV="$COMPOSE_ENV DB_TEST_TYPE=$2"
+            shift 2
+            ;;
+          *)
+            shift
+            ;;
+        esac
+      done
+      
+      # Run the test service using existing test-suite docker-compose
+      eval "$COMPOSE_ENV docker compose -p fhevm -f ${SCRIPT_DIR}/docker-compose/test-suite-docker-compose.yml --profile db-test run --rm gateway-stress-db"
+    else
+      # Run locally with cargo
+      GATEWAY_STRESS_DIR="${SCRIPT_DIR}/../gateway-stress"
+      
+      if [ ! -d "$GATEWAY_STRESS_DIR" ]; then
+        echo -e "${RED}[ERROR]${RESET} ${BOLD}gateway-stress directory not found at: $GATEWAY_STRESS_DIR${RESET}"
+        exit 1
+      fi
+      
+      cd "$GATEWAY_STRESS_DIR"
+      CMD="cargo run -- db-connector"
+    
+    # Parse arguments for db-test
+    while (( "$#" )); do
+      case "$1" in
+        -n|--num-connectors)
+          CMD="$CMD --num-connectors $2"
+          shift 2
+          ;;
+        -t|--type)
+          CMD="$CMD --request-type $2"
+          shift 2
+          ;;
+        -b|--batch-size)
+          CMD="$CMD --batch-size $2"
+          shift 2
+          ;;
+        --duration)
+          CMD="$CMD --duration $2"
+          shift 2
+          ;;
+        -i|--interval)
+          CMD="$CMD --interval $2"
+          shift 2
+          ;;
+        -c|--config)
+          CMD="$CMD --config $2"
+          shift 2
+          ;;
+        --track-responses)
+          CMD="$CMD --track-responses"
+          shift
+          ;;
+        --clear-db)
+          CMD="$CMD --clear-db"
+          shift
+          ;;
+        *)
+          echo -e "${RED}[ERROR]${RESET} ${BOLD}Unknown option: $1${RESET}"
+          echo ""
+          echo -e "${BOLD}DB-Test Options:${RESET}"
+          echo -e "  ${CYAN}-n, --num-connectors NUM${RESET} Number of DB URLs to use"
+          echo -e "  ${CYAN}-t, --type TYPE${RESET}          Request type: public, user, or mixed"
+          echo -e "  ${CYAN}-b, --batch-size SIZE${RESET}    Requests per batch"
+          echo -e "  ${CYAN}--duration TIME${RESET}          Test duration (e.g., 30s, 5m)"
+          echo -e "  ${CYAN}-i, --interval TIME${RESET}      Batch interval (e.g., 1s, 500ms)"
+          echo -e "  ${CYAN}-c, --config FILE${RESET}        Path to config file"
+          echo -e "  ${CYAN}--track-responses${RESET}        Enable response tracking"
+          echo -e "  ${CYAN}--clear-db${RESET}               Clear DB tables before test"
+          exit 1
+          ;;
+      esac
+    done
+    
+      echo -e "${YELLOW}Executing: $CMD${RESET}"
+      eval $CMD
+      
+      if [ $? -eq 0 ]; then
+        echo -e "${GREEN}${BOLD}[SUCCESS] DB Connector Test completed successfully!${RESET}"
+      else
+        echo -e "${RED}${BOLD}[FAILURE] DB Connector Test failed${RESET}"
+        exit 1
+      fi
+    fi
+    ;;
+
   help|-h|--help)
     usage
     exit 0
diff --git a/test-suite/gateway-stress/Cargo.lock b/test-suite/gateway-stress/Cargo.lock
index 6b21b72c8b..2304f4037d 100644
--- a/test-suite/gateway-stress/Cargo.lock
+++ b/test-suite/gateway-stress/Cargo.lock
@@ -85,6 +85,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
  "cfg-if",
+ "getrandom 0.3.3",
  "once_cell",
  "version_check",
  "zerocopy",
@@ -640,7 +641,7 @@ dependencies = [
  "alloy-json-abi",
  "alloy-sol-macro-input",
  "const-hex",
- "heck",
+ "heck 0.5.0",
  "indexmap 2.10.0",
  "proc-macro-error2",
  "proc-macro2",
@@ -659,7 +660,7 @@ dependencies = [
  "alloy-json-abi",
  "const-hex",
  "dunce",
- "heck",
+ "heck 0.5.0",
  "macro-string",
  "proc-macro2",
  "quote",
@@ -1196,6 +1197,15 @@ dependencies = [
  "rustc_version 0.4.1",
 ]
 
+[[package]]
+name = "atoi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -1862,6 +1872,9 @@ name = "bitflags"
 version = "2.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a65b545ab31d687cff52899d4890855fec459eb6afe0da6417b8a18da87aa29"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "bitvec"
@@ -2087,7 +2100,7 @@ version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
  "syn 2.0.106",
@@ -2173,7 +2186,7 @@ checksum = "aa4092bf3922a966e2bd74640b80f36c73eaa7251a4fd0fbcda1f8a4de401352"
 dependencies = [
  "pathdiff",
  "serde",
- "toml",
+ "toml 0.9.5",
  "winnow",
 ]
 
@@ -2339,6 +2352,15 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
@@ -2600,6 +2622,12 @@ dependencies = [
  "syn 2.0.106",
 ]
 
+[[package]]
+name = "dotenvy"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
+
 [[package]]
 name = "downcast"
 version = "0.11.0"
@@ -2789,6 +2817,23 @@ dependencies = [
  "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "etcetera"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "136d1b5283a1ab77bd9257427ffd09d8667ced0570b6f938942bc7568ed5b943"
+dependencies = [
+ "cfg-if",
+ "home",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "event-listener"
+version = "2.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+
 [[package]]
 name = "fastrand"
 version = "2.3.0"
@@ -2879,6 +2924,17 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
+[[package]]
+name = "flume"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "spin",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -2960,6 +3016,17 @@ dependencies = [
  "futures-util",
 ]
 
+[[package]]
+name = "futures-intrusive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"
+dependencies = [
+ "futures-core",
+ "lock_api",
+ "parking_lot",
+]
+
 [[package]]
 name = "futures-io"
 version = "0.3.31"
@@ -3083,13 +3150,17 @@ dependencies = [
  "fhevm_gateway_bindings 0.1.0-rc14 (git+https://github.com/zama-ai/fhevm.git?tag=v0.8.0)",
  "futures",
  "gateway-sdk",
+ "hex",
  "humantime",
  "humantime-serde",
  "indicatif",
+ "rand 0.8.5",
  "rustls 0.23.31",
  "serde",
  "serde_json",
+ "sqlx",
  "tokio",
+ "toml 0.8.23",
  "tracing",
  "tracing-subscriber",
 ]
@@ -3241,6 +3312,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
  "ahash",
+ "allocator-api2",
 ]
 
 [[package]]
@@ -3255,6 +3327,24 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "hashlink"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
+dependencies = [
+ "hashbrown 0.14.5",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -3291,6 +3381,15 @@ dependencies = [
  "arrayvec",
 ]
 
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac",
+]
+
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -3988,6 +4087,28 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
+[[package]]
+name = "libredox"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
+dependencies = [
+ "bitflags",
+ "libc",
+ "redox_syscall",
+]
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4e226dcd58b4be396f7bd3c20da8fdee2911400705297ba7d2d7cc2c30f716"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.4.15"
@@ -4531,9 +4652,9 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.8.1"
+version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1db05f56d34358a8b1066f67cbb203ee3e7ed2ba674a6263a1d5ec6db2204323"
+checksum = "21e0a3a33733faeaf8651dfee72dd0f388f0c8e5ad496a3478fa5a922f49cfa8"
 dependencies = [
  "memchr",
  "thiserror 2.0.12",
@@ -4623,6 +4744,12 @@ dependencies = [
  "spki 0.7.3",
 ]
 
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
 [[package]]
 name = "poly1305"
 version = "0.8.0"
@@ -4808,7 +4935,7 @@ version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "itertools 0.14.0",
  "log",
  "multimap",
@@ -5763,6 +5890,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "1.0.0"
@@ -5968,7 +6104,7 @@ version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1961e2ef424c1424204d3a5d6975f934f56b6d50ff5732382d84ebf460e147f7"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
  "syn 2.0.106",
@@ -5999,6 +6135,9 @@ name = "spin"
 version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
 
 [[package]]
 name = "spki"
@@ -6020,6 +6159,213 @@ dependencies = [
  "der 0.7.10",
 ]
 
+[[package]]
+name = "sqlformat"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bba3a93db0cc4f7bdece8bb09e77e2e785c20bfebf79eb8340ed80708048790"
+dependencies = [
+ "nom 7.1.3",
+ "unicode_categories",
+]
+
+[[package]]
+name = "sqlx"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9a2ccff1a000a5a59cd33da541d9f2fdcd9e6e8229cc200565942bff36d0aaa"
+dependencies = [
+ "sqlx-core",
+ "sqlx-macros",
+ "sqlx-mysql",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+]
+
+[[package]]
+name = "sqlx-core"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24ba59a9342a3d9bab6c56c118be528b27c9b60e490080e9711a04dccac83ef6"
+dependencies = [
+ "ahash",
+ "atoi",
+ "byteorder",
+ "bytes",
+ "crc",
+ "crossbeam-queue",
+ "either",
+ "event-listener",
+ "futures-channel",
+ "futures-core",
+ "futures-intrusive",
+ "futures-io",
+ "futures-util",
+ "hashlink",
+ "hex",
+ "indexmap 2.10.0",
+ "log",
+ "memchr",
+ "once_cell",
+ "paste",
+ "percent-encoding",
+ "rustls 0.21.12",
+ "rustls-pemfile",
+ "serde",
+ "serde_json",
+ "sha2",
+ "smallvec",
+ "sqlformat",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "url",
+ "webpki-roots 0.25.4",
+]
+
+[[package]]
+name = "sqlx-macros"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea40e2345eb2faa9e1e5e326db8c34711317d2b5e08d0d5741619048a803127"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "sqlx-core",
+ "sqlx-macros-core",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "sqlx-macros-core"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5833ef53aaa16d860e92123292f1f6a3d53c34ba8b1969f152ef1a7bb803f3c8"
+dependencies = [
+ "dotenvy",
+ "either",
+ "heck 0.4.1",
+ "hex",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "sha2",
+ "sqlx-core",
+ "sqlx-mysql",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+ "syn 1.0.109",
+ "tempfile",
+ "tokio",
+ "url",
+]
+
+[[package]]
+name = "sqlx-mysql"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ed31390216d20e538e447a7a9b959e06ed9fc51c37b514b46eb758016ecd418"
+dependencies = [
+ "atoi",
+ "base64 0.21.7",
+ "bitflags",
+ "byteorder",
+ "bytes",
+ "crc",
+ "digest 0.10.7",
+ "dotenvy",
+ "either",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "generic-array",
+ "hex",
+ "hkdf",
+ "hmac",
+ "itoa",
+ "log",
+ "md-5",
+ "memchr",
+ "once_cell",
+ "percent-encoding",
+ "rand 0.8.5",
+ "rsa",
+ "serde",
+ "sha1",
+ "sha2",
+ "smallvec",
+ "sqlx-core",
+ "stringprep",
+ "thiserror 1.0.69",
+ "tracing",
+ "whoami",
+]
+
+[[package]]
+name = "sqlx-postgres"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c824eb80b894f926f89a0b9da0c7f435d27cdd35b8c655b114e58223918577e"
+dependencies = [
+ "atoi",
+ "base64 0.21.7",
+ "bitflags",
+ "byteorder",
+ "crc",
+ "dotenvy",
+ "etcetera",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "hex",
+ "hkdf",
+ "hmac",
+ "home",
+ "itoa",
+ "log",
+ "md-5",
+ "memchr",
+ "once_cell",
+ "rand 0.8.5",
+ "serde",
+ "serde_json",
+ "sha2",
+ "smallvec",
+ "sqlx-core",
+ "stringprep",
+ "thiserror 1.0.69",
+ "tracing",
+ "whoami",
+]
+
+[[package]]
+name = "sqlx-sqlite"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b244ef0a8414da0bed4bb1910426e890b19e5e9bccc27ada6b797d05c55ae0aa"
+dependencies = [
+ "atoi",
+ "flume",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-intrusive",
+ "futures-util",
+ "libsqlite3-sys",
+ "log",
+ "percent-encoding",
+ "serde",
+ "sqlx-core",
+ "tracing",
+ "url",
+ "urlencoding",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
@@ -6044,6 +6390,17 @@ dependencies = [
  "rand 0.8.5",
 ]
 
+[[package]]
+name = "stringprep"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+ "unicode-properties",
+]
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -6065,7 +6422,7 @@ version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
  "rustversion",
@@ -6522,6 +6879,18 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "toml"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+dependencies = [
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.11",
+ "toml_edit",
+]
+
 [[package]]
 name = "toml"
 version = "0.9.5"
@@ -6529,7 +6898,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75129e1dc5000bfbaa9fee9d1b21f974f9fbad9daec557a521ee6e080825f6e8"
 dependencies = [
  "serde",
- "serde_spanned",
+ "serde_spanned 1.0.0",
  "toml_datetime 0.7.0",
  "toml_parser",
  "winnow",
@@ -6540,6 +6909,9 @@ name = "toml_datetime"
 version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "toml_datetime"
@@ -6557,7 +6929,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
  "indexmap 2.10.0",
+ "serde",
+ "serde_spanned 0.6.9",
  "toml_datetime 0.6.11",
+ "toml_write",
  "winnow",
 ]
 
@@ -6570,6 +6945,12 @@ dependencies = [
  "winnow",
 ]
 
+[[package]]
+name = "toml_write"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+
 [[package]]
 name = "tonic-build"
 version = "0.13.1"
@@ -6797,6 +7178,12 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.18"
@@ -6812,6 +7199,18 @@ dependencies = [
  "tinyvec",
 ]
 
+[[package]]
+name = "unicode-properties"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
 [[package]]
 name = "unicode-width"
 version = "0.2.1"
@@ -6824,6 +7223,12 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "unicode_categories"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
+
 [[package]]
 name = "unit-prefix"
 version = "0.5.1"
@@ -6941,6 +7346,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -6992,6 +7403,12 @@ dependencies = [
  "wit-bindgen-rt",
 ]
 
+[[package]]
+name = "wasite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
+
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.100"
@@ -7099,6 +7516,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-roots"
+version = "0.25.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
+
 [[package]]
 name = "webpki-roots"
 version = "0.26.11"
@@ -7129,6 +7552,16 @@ dependencies = [
  "rustix 0.38.44",
 ]
 
+[[package]]
+name = "whoami"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4a4db5077702ca3015d3d02d74974948aba2ad9e12ab7df718ee64ccd7e97d"
+dependencies = [
+ "libredox",
+ "wasite",
+]
+
 [[package]]
 name = "wide"
 version = "0.7.33"
@@ -7263,6 +7696,15 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -7290,6 +7732,21 @@ dependencies = [
  "windows-targets 0.53.3",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -7332,6 +7789,12 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
@@ -7344,6 +7807,12 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
@@ -7356,6 +7825,12 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
@@ -7380,6 +7855,12 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
@@ -7392,6 +7873,12 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
@@ -7404,6 +7891,12 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
@@ -7416,6 +7909,12 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
diff --git a/test-suite/gateway-stress/Cargo.toml b/test-suite/gateway-stress/Cargo.toml
index 92e2af2050..ac668239ef 100644
--- a/test-suite/gateway-stress/Cargo.toml
+++ b/test-suite/gateway-stress/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "gateway-stress"
 version = "0.1.0"
-edition = "2024"
+edition = "2021"
 
 [dependencies]
 fhevm_gateway_bindings = { git = "https://github.com/zama-ai/fhevm.git", tag = "v0.8.0", default-features = false }
@@ -45,3 +45,9 @@ tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", default-features = true, features = [
     "env-filter",
 ] }
+
+# Database dependencies
+sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "migrate"] }
+toml = "0.8"
+hex = "0.4"
+rand = "0.8"
diff --git a/test-suite/gateway-stress/README.md b/test-suite/gateway-stress/README.md
index b2d686c882..cb21fd6a14 100644
--- a/test-suite/gateway-stress/README.md
+++ b/test-suite/gateway-stress/README.md
@@ -1,7 +1,6 @@
 # Gateway Stress-Test Tool
 
-A simple tool to send a configurable number of parallel decryption requests (public or user
-decrypts at the time of writing), at a given frequency and for a specified duration.
+A tool to perform stress testing on the Gateway by sending parallel decryption requests (public or user decrypts) at a given frequency and for a specified duration. Additionally, it can perform direct database connector testing to verify synchronization across multiple database instances.
 
 ## Configuration
 
@@ -48,6 +47,32 @@ cargo run -- -c config/config.toml user
 
 Note that the `mixed` command of the CLI is not implemented yet.
 
+### DB Connector Testing
+
+The tool includes a `db-connector` subcommand for testing direct database insertions and synchronization:
+
+```bash
+# Run with configuration file (recommended)
+./gateway-stress -c config/config.toml db-connector
+
+# Run with response tracking
+./gateway-stress -c config/config.toml db-connector --track-responses
+
+# Override specific parameters for CI/testing
+./gateway-stress -c config/config.toml db-connector --duration 5m --batch-size 100
+
+# Override request type for specific scenario testing
+./gateway-stress -c config/config.toml db-connector --request-type public
+```
+
+The DB configuration is defined in the `[db_connector]` section of `config.toml`. 
+CLI arguments are used only to override specific parameters for CI or testing scenarios.
+
+The test will:
+- Insert decryption requests directly into configured database(s)
+- Optionally track response synchronization across all configured databases
+- Report statistics on sync rates and missing responses
+
 ## Tracing
 
 This tool aims to output only essential information regarding the status of the test. The main
diff --git a/test-suite/gateway-stress/config/config.toml b/test-suite/gateway-stress/config/config.toml
index 053a0cdb72..63402e9c36 100644
--- a/test-suite/gateway-stress/config/config.toml
+++ b/test-suite/gateway-stress/config/config.toml
@@ -71,3 +71,22 @@ private_key = "3f45b129a7fd099146e9fe63851a71646231f7743c712695f3b2d2bf0e41c774"
 # region = "us-east-1"
 # Optional: AWS endpoint URL for KMS (for testing or custom endpoints)
 # endpoint = "https://kms.us-east-1.amazonaws.com"
+
+## DB Connector Test Configuration
+## Used when running: ./gateway-stress -c config.toml db-connector
+[db_connector]
+# Database URLs for testing (add more for multi-connector testing)
+database_urls = [
+    "postgresql://postgres:postgres@localhost:5432/kms-connector"
+    # "postgresql://postgres:postgres@localhost:5433/kms-connector-2",
+]
+
+# Default test parameters (can be overridden via CLI)
+request_type = "mixed"        # public, user, or mixed
+duration = "30s"              # Test duration
+batch_size = 10               # Requests per batch
+batch_interval = "1s"         # Interval between batches
+
+# Connection pool settings
+pool_size = 10
+connection_timeout = 30
diff --git a/test-suite/gateway-stress/src/app.rs b/test-suite/gateway-stress/src/app.rs
index fd7e8c9d68..05abd226cb 100644
--- a/test-suite/gateway-stress/src/app.rs
+++ b/test-suite/gateway-stress/src/app.rs
@@ -4,6 +4,7 @@ use crate::{
         wallet::Wallet,
     },
     config::Config,
+    db_manager::{DbManager, DbConnectorConfig, DecryptionRequestType},
     decryption::{
         EVENT_LISTENER_POLLING, init_public_decryption_response_listener,
         init_user_decryption_response_listener, public_decryption_burst, user_decryption_burst,
@@ -22,6 +23,7 @@ use fhevm_gateway_bindings::decryption::Decryption::{self, DecryptionInstance};
 use gateway_sdk::{FhevmSdk, FhevmSdkBuilder};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use std::sync::{Arc, Once};
+use std::time::Duration;
 use tokio::{
     task::JoinSet,
     time::{Instant, interval},
@@ -46,6 +48,7 @@ pub struct App {
 
     /// The wallet used to send the requests to the Gateway.
     wallet: Wallet,
+    
 
     /// The fhevm rust sdk used to compute the EIP712 for UserDecryptions.
     sdk: Arc<FhevmSdk>,
@@ -62,7 +65,9 @@ impl App {
         });
 
         let wallet = Wallet::from_config(&config).await?;
-        let gateway_url = &config.gateway_url;
+        let gateway_url = config.gateway_url
+            .as_ref()
+            .ok_or_else(|| anyhow!("gateway_url is required for blockchain testing"))?;
         let provider = NonceManagedProvider::new(
             ProviderBuilder::new()
                 .disable_recommended_fillers()
@@ -74,15 +79,22 @@ impl App {
             wallet.address(),
         );
         info!("Successfully connected to the Gateway");
-        let decryption_contract = Decryption::new(config.decryption_address, provider);
+        let decryption_address = config.decryption_address
+            .ok_or_else(|| anyhow!("decryption_address is required for blockchain testing"))?;
+        let decryption_contract = Decryption::new(decryption_address, provider);
 
+        let gateway_chain_id = config.gateway_chain_id
+            .ok_or_else(|| anyhow!("gateway_chain_id is required for blockchain testing"))?;
+        let host_chain_id = config.host_chain_id
+            .ok_or_else(|| anyhow!("host_chain_id is required for blockchain testing"))?;
+            
         let sdk = Arc::new(
             FhevmSdkBuilder::new()
-                .with_gateway_chain_id(config.gateway_chain_id)
-                .with_decryption_contract(&config.decryption_address.to_string())
+                .with_gateway_chain_id(gateway_chain_id)
+                .with_decryption_contract(&decryption_address.to_string())
                 .with_acl_contract(&Address::ZERO.to_string())
                 .with_input_verification_contract(&Address::ZERO.to_string())
-                .with_host_chain_id(config.host_chain_id)
+                .with_host_chain_id(host_chain_id)
                 .build()?,
         );
 
@@ -102,7 +114,7 @@ impl App {
         tokio::time::sleep(EVENT_LISTENER_POLLING).await; // Sleep for listener to be ready
 
         let session_start = Instant::now();
-        let mut interval = interval(self.config.tests_interval);
+        let mut interval = interval(self.config.tests_interval.unwrap_or(Duration::from_secs(1)));
         let mut burst_tasks = JoinSet::new();
         let mut burst_index = 1;
         loop {
@@ -110,7 +122,7 @@ impl App {
                 interval.tick().await;
             }
 
-            if session_start.elapsed() > self.config.tests_duration {
+            if session_start.elapsed() > self.config.tests_duration.unwrap_or(Duration::from_secs(60)) {
                 break;
             }
 
@@ -141,7 +153,7 @@ impl App {
         info!(
             "Handled all burst in {:.2}s. Throughput: {:.2} tps",
             elapsed,
-            (self.config.parallel_requests * (burst_index - 1) as u32) as f64 / elapsed
+            (self.config.parallel_requests.unwrap_or(1) * (burst_index - 1) as u32) as f64 / elapsed
         );
         Ok(())
     }
@@ -154,7 +166,7 @@ impl App {
         tokio::time::sleep(EVENT_LISTENER_POLLING).await; // Sleep for listener to be ready
 
         let session_start = Instant::now();
-        let mut interval = interval(self.config.tests_interval);
+        let mut interval = interval(self.config.tests_interval.unwrap_or(Duration::from_secs(1)));
         let mut burst_tasks = JoinSet::new();
         let mut burst_index = 1;
         loop {
@@ -162,7 +174,7 @@ impl App {
                 interval.tick().await;
             }
 
-            if session_start.elapsed() > self.config.tests_duration {
+            if session_start.elapsed() > self.config.tests_duration.unwrap_or(Duration::from_secs(60)) {
                 break;
             }
 
@@ -192,11 +204,165 @@ impl App {
         info!(
             "Handled all burst in {:.2}s. Throughput: {:.2} tps",
             elapsed,
-            (self.config.parallel_requests * (burst_index - 1) as u32) as f64 / elapsed
+            (self.config.parallel_requests.unwrap_or(1) * (burst_index - 1) as u32) as f64 / elapsed
         );
         Ok(())
     }
 
+    /// Run DB connector stress test using direct database insertions (standalone, no gateway connection)
+    pub async fn db_connector_stress_test_standalone(
+        config: Config,
+        args: crate::cli::DbConnectorArgs,
+    ) -> anyhow::Result<()> {
+        use humantime::parse_duration;
+        use std::time::{Duration, Instant};
+        use tokio::time::interval;
+        
+        info!("Starting DB connector test");
+        
+        // Load config from specified file or use provided config
+        let config = if let Some(config_path) = args.config {
+            info!("Loading config from: {:?}", config_path);
+            Config::from_env_and_file(Some(config_path))?
+        } else {
+            config
+        };
+        
+        // Get DB configuration from config file or use defaults
+        let db_config = config.db_connector.as_ref()
+            .ok_or_else(|| anyhow!("Missing [db_connector] section in config file"))?;
+        
+        // Initialize DB manager with configured databases
+        let mut configs = Vec::new();
+        let database_urls = &db_config.database_urls;
+        
+        // Use -n to limit number of databases if specified
+        let num_to_use = args.num_connectors.unwrap_or(database_urls.len());
+        let urls_to_use = &database_urls[..num_to_use.min(database_urls.len())];
+        
+        for url in urls_to_use {
+            let mut config = DbConnectorConfig::new(url.clone());
+            config.pool_size = db_config.pool_size.map(|s| s as u32);
+            config.connection_timeout = db_config.connection_timeout;
+            configs.push(config);
+        }
+        
+        info!("Using {} database(s) out of {} configured", configs.len(), database_urls.len());
+        let db_manager = DbManager::new(configs).await?;
+        
+        // Health check
+        info!("Performing health check...");
+        let health_results = db_manager.health_check().await?;
+        if !health_results[0] {
+            return Err(anyhow!("Database is not healthy"));
+        }
+        info!("Database is healthy!");
+        
+        // Clear databases if requested
+        if args.clear_db {
+            info!("Clearing database tables before test...");
+            db_manager.clear_databases().await?;
+            info!("Database tables cleared");
+        }
+        
+        // Use config defaults, override with CLI args if provided
+        let request_type_str = args.request_type
+            .unwrap_or_else(|| db_config.request_type.clone());
+        
+        let request_type = match request_type_str.as_str() {
+            "public" => DecryptionRequestType::Public,
+            "user" => DecryptionRequestType::User,
+            "mixed" => DecryptionRequestType::Mixed,
+            _ => return Err(anyhow!("Invalid request type: {}", request_type_str)),
+        };
+        
+        // Use config durations, can be overridden by CLI
+        let test_duration = if let Some(duration_str) = args.duration {
+            parse_duration(&duration_str)?
+        } else {
+            db_config.duration
+        };
+        
+        // Parse interval override
+        let batch_interval = if let Some(interval_str) = args.interval {
+            parse_duration(&interval_str)?
+        } else {
+            db_config.batch_interval
+        };
+        
+        let batch_size = args.batch_size.unwrap_or(db_config.batch_size);
+        
+        // Create progress tracker
+        let progress_tracker = MultiProgress::new();
+        let style = ProgressStyle::with_template(
+            "{spinner:.green} [{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}",
+        )?;
+        
+        let progress_bar = progress_tracker.add(
+            ProgressBar::new(100)
+                .with_message("DB Connector Test Progress")
+                .with_style(style),
+        );
+        
+        info!("Starting test for {:?}", test_duration);
+        info!("Inserting {} requests every {:?}", batch_size, batch_interval);
+        
+        let start_time = Instant::now();
+        let mut interval = interval(batch_interval);
+        let mut total_inserted = 0;
+        
+        // Main test loop
+        while start_time.elapsed() < test_duration {
+            interval.tick().await;
+            
+            // Insert batch of requests
+            let request_ids = db_manager
+                .insert_requests(request_type, batch_size)
+                .await?;
+            
+            total_inserted += request_ids.len();
+            let elapsed_percent = (start_time.elapsed().as_secs() as f64 / test_duration.as_secs() as f64 * 100.0) as u64;
+            progress_bar.set_position(elapsed_percent.min(100));
+            progress_bar.set_message(format!("Inserted {} requests", total_inserted));
+            
+            // Track responses if enabled
+            if args.track_responses {
+                db_manager.track_responses().await?;
+                let stats = db_manager.get_stats().await;
+                info!(
+                    "Sync status - Fully synced: {}/{} ({:.1}%)",
+                    stats.fully_synced,
+                    stats.total_requests,
+                    (stats.fully_synced as f64 / stats.total_requests.max(1) as f64) * 100.0
+                );
+            }
+        }
+        
+        progress_bar.finish_with_message(format!("Test completed - {} requests inserted", total_inserted));
+        
+        // Final response tracking
+        if args.track_responses {
+            info!("Waiting 5 seconds for final responses...");
+            tokio::time::sleep(Duration::from_secs(5)).await;
+            
+            db_manager.track_responses().await?;
+            let stats = db_manager.get_stats().await;
+            
+            info!("\n=== Final Results ===");
+            info!("Total requests inserted: {}", total_inserted);
+            info!("Fully synced across all connectors: {}", stats.fully_synced);
+            info!("Partially synced: {}", stats.partially_synced);
+            info!("Missing from all: {}", stats.missing);
+            
+            for (i, count) in stats.responses_by_connector.iter().enumerate() {
+                info!("Connector {}: {} responses", i, count);
+            }
+        }
+        
+        info!("DB Connector test completed successfully!");
+        Ok(())
+    }
+    
     /// Create progress bars to track a burst of requests sent to the Gateway.
     ///
     /// - One is used to track when requests are received by the Gateway (tx receipt was received).
@@ -214,14 +380,14 @@ impl App {
         let prefix = format!("Burst #{burst_index}");
 
         let requests_pb = progress_tracker.add(
-            ProgressBar::new(self.config.parallel_requests.into())
+            ProgressBar::new(self.config.parallel_requests.unwrap_or(1).into())
                 .with_prefix(prefix.clone())
                 .with_message("Sending requests...")
                 .with_style(style.clone()),
         );
         let responses_pb = progress_tracker.insert_after(
             &requests_pb,
-            ProgressBar::new(self.config.parallel_requests.into())
+            ProgressBar::new(self.config.parallel_requests.unwrap_or(1).into())
                 .with_prefix(prefix)
                 .with_message("Waiting responses...")
                 .with_style(style),
diff --git a/test-suite/gateway-stress/src/blockchain/wallet.rs b/test-suite/gateway-stress/src/blockchain/wallet.rs
index 89070b892e..5f0ca117e2 100644
--- a/test-suite/gateway-stress/src/blockchain/wallet.rs
+++ b/test-suite/gateway-stress/src/blockchain/wallet.rs
@@ -30,17 +30,17 @@ impl Wallet {
     pub async fn from_config(config: &Config) -> anyhow::Result<Self> {
         if let Some(aws_config) = &config.aws_kms_config {
             debug!("Building wallet using AWS KMS configuration...");
-            Self::from_aws_kms(aws_config.clone(), Some(config.gateway_chain_id)).await
+            Self::from_aws_kms(aws_config.clone(), config.gateway_chain_id).await
         } else if let Some(mnemonic) = &config.mnemonic {
             debug!("Building wallet using mnemonic...");
             Self::from_mnemonic_with_index(
                 mnemonic,
                 config.mnemonic_index,
-                Some(config.gateway_chain_id),
+                config.gateway_chain_id,
             )
         } else if let Some(private_key) = &config.private_key {
             debug!("Building wallet using private key...");
-            Self::from_private_key_str(private_key, Some(config.gateway_chain_id))
+            Self::from_private_key_str(private_key, config.gateway_chain_id)
         } else {
             Err(anyhow!(
                 "Either aws_kms or private_key should be configured"
diff --git a/test-suite/gateway-stress/src/cli.rs b/test-suite/gateway-stress/src/cli.rs
index 448990bf6b..8940a6e2e9 100644
--- a/test-suite/gateway-stress/src/cli.rs
+++ b/test-suite/gateway-stress/src/cli.rs
@@ -1,4 +1,4 @@
-use clap::{Parser, Subcommand, command};
+use clap::{Args, Parser, Subcommand, command};
 use std::path::PathBuf;
 
 #[derive(Parser)]
@@ -30,4 +30,46 @@ pub enum Subcommands {
 
     /// Perform tests with mixed decryptions (both public and user)
     Mixed,
+    
+    /// Test database connectors with direct insertions
+    DbConnector(DbConnectorArgs),
+}
+
+#[derive(Args, Debug)]
+pub struct DbConnectorArgs {
+    /// Path to configuration file (overrides default location)
+    #[arg(short = 'c', long)]
+    pub config: Option<PathBuf>,
+    
+    /// Override request type (public, user, or mixed)
+    /// Default comes from config file
+    #[arg(short = 't', long = "request-type")]
+    pub request_type: Option<String>,
+    
+    /// Override test duration (e.g., "30s", "5m", "1h")
+    /// Default comes from config file
+    #[arg(long)]
+    pub duration: Option<String>,
+    
+    /// Override batch size for CI/load testing scenarios
+    /// Default comes from config file
+    #[arg(short = 'b', long)]
+    pub batch_size: Option<usize>,
+    
+    /// Override batch interval (e.g., "1s", "500ms")
+    /// Default comes from config file
+    #[arg(short = 'i', long)]
+    pub interval: Option<String>,
+    
+    /// Number of database URLs to use from config (default: all)
+    #[arg(short = 'n', long)]
+    pub num_connectors: Option<usize>,
+    
+    /// Enable response tracking (useful for CI verification)
+    #[arg(long)]
+    pub track_responses: bool,
+    
+    /// Clear database tables before starting test
+    #[arg(long)]
+    pub clear_db: bool,
 }
diff --git a/test-suite/gateway-stress/src/config.rs b/test-suite/gateway-stress/src/config.rs
index 759acceaaf..89b1926e8f 100644
--- a/test-suite/gateway-stress/src/config.rs
+++ b/test-suite/gateway-stress/src/config.rs
@@ -5,27 +5,42 @@ use std::{path::Path, str::FromStr, time::Duration};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Config {
-    pub gateway_url: String,
-    pub host_chain_id: u64,
-    pub gateway_chain_id: u64,
-    pub decryption_address: Address,
+    pub gateway_url: Option<String>,
+    pub host_chain_id: Option<u64>,
+    pub gateway_chain_id: Option<u64>,
+    pub decryption_address: Option<Address>,
     pub private_key: Option<String>,
     pub mnemonic: Option<String>,
     #[serde(default = "default_mnemonic_index")]
     pub mnemonic_index: usize,
     pub aws_kms_config: Option<AwsKmsConfig>,
-    #[serde(deserialize_with = "parse_ct_handles")]
+    #[serde(default, deserialize_with = "parse_ct_handles_option")]
     pub user_ct_handles: Vec<FixedBytes<32>>,
-    #[serde(deserialize_with = "parse_ct_handles")]
+    #[serde(default, deserialize_with = "parse_ct_handles_option")]
     pub public_ct_handles: Vec<FixedBytes<32>>,
-    pub allowed_contract: Address,
-    pub parallel_requests: u32,
-    #[serde(with = "humantime_serde")]
-    pub tests_duration: Duration,
-    #[serde(with = "humantime_serde")]
-    pub tests_interval: Duration,
+    pub allowed_contract: Option<Address>,
+    pub parallel_requests: Option<u32>,
+    #[serde(with = "humantime_serde::option")]
+    pub tests_duration: Option<Duration>,
+    #[serde(with = "humantime_serde::option")]
+    pub tests_interval: Option<Duration>,
     #[serde(default)]
     pub sequential: bool,
+    /// DB connector configuration
+    pub db_connector: Option<DbConnectorTestConfig>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct DbConnectorTestConfig {
+    pub database_urls: Vec<String>,
+    pub request_type: String,
+    #[serde(with = "humantime_serde")]
+    pub duration: Duration,
+    pub batch_size: usize,
+    #[serde(with = "humantime_serde")]
+    pub batch_interval: Duration,
+    pub pool_size: Option<usize>,
+    pub connection_timeout: Option<u64>,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -64,14 +79,13 @@ fn default_mnemonic_index() -> usize {
     0
 }
 
-fn parse_ct_handles<'de, D>(d: D) -> Result<Vec<FixedBytes<32>>, D::Error>
+fn parse_ct_handles_option<'de, D>(d: D) -> Result<Vec<FixedBytes<32>>, D::Error>
 where
     D: Deserializer<'de>,
 {
-    let ct_handles = Vec::<String>::deserialize(d)?
+    let opt = Option::<Vec<String>>::deserialize(d)?;
+    Ok(opt.unwrap_or_default()
         .iter()
-        .map(|h| FixedBytes::from_str(h.as_str()).expect("Invalid handle: {h}"))
-        .collect();
-
-    Ok(ct_handles)
+        .filter_map(|h| FixedBytes::from_str(h.as_str()).ok())
+        .collect())
 }
diff --git a/test-suite/gateway-stress/src/db_manager/config.rs b/test-suite/gateway-stress/src/db_manager/config.rs
new file mode 100644
index 0000000000..f3aaaf5fe4
--- /dev/null
+++ b/test-suite/gateway-stress/src/db_manager/config.rs
@@ -0,0 +1,33 @@
+use serde::{Deserialize, Serialize};
+
+/// Configuration for a single database connector
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct DbConnectorConfig {
+    /// Database URL (PostgreSQL)
+    pub database_url: String,
+    
+    /// Optional name for this connector (for identification in logs)
+    pub name: Option<String>,
+    
+    /// Connection pool settings
+    pub pool_size: Option<u32>,
+    
+    /// Connection timeout in seconds
+    pub connection_timeout: Option<u64>,
+    
+    /// Enable SSL/TLS for database connection
+    pub ssl_mode: Option<String>,
+}
+
+impl DbConnectorConfig {
+    /// Create a new connector configuration
+    pub fn new(database_url: String) -> Self {
+        Self {
+            database_url,
+            name: None,
+            pool_size: Some(10),
+            connection_timeout: Some(30),
+            ssl_mode: None,
+        }
+    }
+}
diff --git a/test-suite/gateway-stress/src/db_manager/connector.rs b/test-suite/gateway-stress/src/db_manager/connector.rs
new file mode 100644
index 0000000000..0eda5e7628
--- /dev/null
+++ b/test-suite/gateway-stress/src/db_manager/connector.rs
@@ -0,0 +1,226 @@
+use super::config::DbConnectorConfig;
+use super::request_builder::DecryptionRequest;
+use anyhow::Result;
+use fhevm_gateway_bindings::decryption::Decryption::{PublicDecryptionRequest, UserDecryptionRequest};
+use sqlx::{postgres::PgPoolOptions, Pool, Postgres, Row};
+use std::time::Duration;
+use tracing::{debug, info};
+
+/// Database connector for handling decryption requests
+pub struct DbConnector {
+    pool: Pool<Postgres>,
+    name: String,
+}
+
+impl DbConnector {
+    /// Create a new database connector
+    pub async fn new(config: DbConnectorConfig, index: usize) -> Result<Self> {
+        let name = config
+            .name
+            .clone()
+            .unwrap_or_else(|| format!("connector_{}", index));
+        
+        info!("Connecting to database {} ({})", name, index);
+        
+        let pool = PgPoolOptions::new()
+            .max_connections(config.pool_size.unwrap_or(10))
+            .acquire_timeout(Duration::from_secs(config.connection_timeout.unwrap_or(30)))
+            .connect(&config.database_url)
+            .await?;
+        
+        info!("Successfully connected to database {}", name);
+        
+        Ok(Self { pool, name })
+    }
+    
+    /// Check database connectivity
+    pub async fn health_check(&self) -> Result<()> {
+        sqlx::query("SELECT 1")
+            .fetch_one(&self.pool)
+            .await?;
+        Ok(())
+    }
+    
+    /// Clear decryption request and response tables
+    pub async fn clear_tables(&self) -> Result<()> {
+        info!("Clearing database tables for connector {}", self.name);
+        
+        // Clear request tables
+        sqlx::query("DELETE FROM public_decryption_requests")
+            .execute(&self.pool)
+            .await?;
+            
+        sqlx::query("DELETE FROM user_decryption_requests")
+            .execute(&self.pool)
+            .await?;
+            
+        // Clear response tables (if they exist)
+        let _ = sqlx::query("DELETE FROM public_decryption_responses")
+            .execute(&self.pool)
+            .await;
+            
+        let _ = sqlx::query("DELETE FROM user_decryption_responses")
+            .execute(&self.pool)
+            .await;
+            
+        info!("Database tables cleared for connector {}", self.name);
+        Ok(())
+    }
+    
+    /// Insert a decryption request into the database
+    pub async fn insert_request(&self, request: DecryptionRequest) -> Result<()> {
+        match request {
+            DecryptionRequest::Public(req) => {
+                self.insert_public_request(req).await?;
+            }
+            DecryptionRequest::User(req) => {
+                self.insert_user_request(req).await?;
+            }
+        }
+        Ok(())
+    }
+    
+    /// Insert a public decryption request
+    async fn insert_public_request(&self, request: PublicDecryptionRequest) -> Result<()> {
+        // Convert to the same format used by KMS connector
+        // Using LITTLE ENDIAN for consistency with actual implementation
+        let sns_ciphertexts_db: Vec<serde_json::Value> = request.snsCtMaterials.iter().map(|m| {
+            serde_json::json!({
+                "ct_handle": hex::encode(m.ctHandle.as_slice()),
+                "key_id": hex::encode(m.keyId.to_le_bytes::<32>()), // LITTLE ENDIAN!
+                "sns_ciphertext_digest": hex::encode(m.snsCiphertextDigest.as_slice()),
+                "coprocessor_tx_sender_addresses": m.coprocessorTxSenderAddresses.iter()
+                    .map(|addr| hex::encode(addr.as_slice()))
+                    .collect::<Vec<_>>()
+            })
+        }).collect();
+        
+        // Note: The actual KMS connector inserts directly with the composite type
+        // We need to match the exact format. The tables don't have under_process or created_at in VALUES
+        // as these have defaults in the schema
+        let query = r#"
+            INSERT INTO public_decryption_requests 
+            VALUES ($1, $2::sns_ciphertext_material[], $3)
+            ON CONFLICT DO NOTHING
+        "#;
+        
+        // Use LITTLE ENDIAN for decryptionId to match KMS connector
+        let decryption_id_bytes = request.decryptionId.to_le_bytes::<32>().to_vec();
+        sqlx::query(query)
+            .bind(&decryption_id_bytes)
+            .bind(serde_json::to_string(&sns_ciphertexts_db)?)
+            .bind(request.extraData.as_ref())
+            .execute(&self.pool)
+            .await?;
+        
+        debug!("Inserted public decryption request {} to {}", 
+            hex::encode(&decryption_id_bytes), self.name);
+        
+        Ok(())
+    }
+    
+    /// Insert a user decryption request
+    async fn insert_user_request(&self, request: UserDecryptionRequest) -> Result<()> {
+        // Convert to the same format used by KMS connector
+        // Using LITTLE ENDIAN for consistency with actual implementation
+        let sns_ciphertexts_db: Vec<serde_json::Value> = request.snsCtMaterials.iter().map(|m| {
+            serde_json::json!({
+                "ct_handle": hex::encode(m.ctHandle.as_slice()),
+                "key_id": hex::encode(m.keyId.to_le_bytes::<32>()), // LITTLE ENDIAN!
+                "sns_ciphertext_digest": hex::encode(m.snsCiphertextDigest.as_slice()),
+                "coprocessor_tx_sender_addresses": m.coprocessorTxSenderAddresses.iter()
+                    .map(|addr| hex::encode(addr.as_slice()))
+                    .collect::<Vec<_>>()
+            })
+        }).collect();
+        
+        // Match the exact format used by KMS connector
+        let query = r#"
+            INSERT INTO user_decryption_requests 
+            VALUES ($1, $2::sns_ciphertext_material[], $3, $4, $5)
+            ON CONFLICT DO NOTHING
+        "#;
+        
+        // Use LITTLE ENDIAN for decryptionId to match KMS connector
+        let decryption_id_bytes = request.decryptionId.to_le_bytes::<32>().to_vec();
+        sqlx::query(query)
+            .bind(&decryption_id_bytes)
+            .bind(serde_json::to_string(&sns_ciphertexts_db)?)
+            .bind(request.userAddress.as_slice())
+            .bind(request.publicKey.as_ref())
+            .bind(request.extraData.as_ref())
+            .execute(&self.pool)
+            .await?;
+        
+        debug!("Inserted user decryption request {} to {}", 
+            hex::encode(&decryption_id_bytes), self.name);
+        
+        Ok(())
+    }
+    
+    /// Fetch decryption responses for specific request IDs
+    pub async fn fetch_responses_for_requests(&self, request_ids: &[String]) -> Result<Vec<String>> {
+        let mut response_ids = Vec::new();
+        
+        if request_ids.is_empty() {
+            return Ok(response_ids);
+        }
+        
+        // Convert request IDs to bytes for SQL query
+        let id_bytes: Vec<Vec<u8>> = request_ids.iter()
+            .filter_map(|id| hex::decode(id).ok())
+            .collect();
+        
+        if id_bytes.is_empty() {
+            return Ok(response_ids);
+        }
+        
+        // Fetch public decryption responses for our specific IDs
+        for id_batch in id_bytes.chunks(100) { // Process in batches to avoid too large queries
+            let placeholders: Vec<String> = (1..=id_batch.len())
+                .map(|i| format!("${}", i))
+                .collect();
+            let public_query = format!(
+                "SELECT decryption_id FROM public_decryption_responses WHERE decryption_id IN ({})",
+                placeholders.join(",")
+            );
+            
+            let mut query = sqlx::query(&public_query);
+            for id in id_batch {
+                query = query.bind(id);
+            }
+            
+            let public_rows = query.fetch_all(&self.pool).await?;
+            
+            for row in public_rows {
+                let id: Vec<u8> = row.get("decryption_id");
+                response_ids.push(hex::encode(id));
+            }
+            
+            // Also check user decryption responses
+            let user_query = format!(
+                "SELECT decryption_id FROM user_decryption_responses WHERE decryption_id IN ({})",
+                placeholders.join(",")
+            );
+            
+            let mut query = sqlx::query(&user_query);
+            for id in id_batch {
+                query = query.bind(id);
+            }
+            
+            let user_rows = query.fetch_all(&self.pool).await?;
+            
+            for row in user_rows {
+                let id: Vec<u8> = row.get("decryption_id");
+                response_ids.push(hex::encode(id));
+            }
+        }
+        
+        debug!("Fetched {} responses from {} for {} requests", 
+               response_ids.len(), self.name, request_ids.len());
+        
+        Ok(response_ids)
+    }
+    
+}
+
diff --git a/test-suite/gateway-stress/src/db_manager/mod.rs b/test-suite/gateway-stress/src/db_manager/mod.rs
new file mode 100644
index 0000000000..e31c361c74
--- /dev/null
+++ b/test-suite/gateway-stress/src/db_manager/mod.rs
@@ -0,0 +1,127 @@
+pub mod config;
+pub mod connector;
+pub mod request_builder;
+pub mod response_tracker;
+
+use anyhow::Result;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+pub use config::DbConnectorConfig;
+pub use connector::DbConnector;
+pub use request_builder::RequestBuilder;
+pub use response_tracker::ResponseTracker;
+
+/// Manager for handling multiple database connectors
+pub struct DbManager {
+    connectors: Vec<Arc<DbConnector>>,
+    request_builder: RequestBuilder,
+    response_tracker: Arc<RwLock<ResponseTracker>>,
+    /// Keep track of all inserted request IDs for this test run
+    inserted_request_ids: Arc<RwLock<Vec<String>>>,
+}
+
+impl DbManager {
+    /// Create a new DbManager with N connectors
+    pub async fn new(configs: Vec<DbConnectorConfig>) -> Result<Self> {
+        let mut connectors = Vec::new();
+        
+        for (index, config) in configs.iter().enumerate() {
+            let connector = DbConnector::new(config.clone(), index).await?;
+            connectors.push(Arc::new(connector));
+        }
+        
+        Ok(Self {
+            connectors,
+            request_builder: RequestBuilder::new(),
+            response_tracker: Arc::new(RwLock::new(
+                ResponseTracker::new(configs.len())
+            )),
+            inserted_request_ids: Arc::new(RwLock::new(Vec::new())),
+        })
+    }
+    /// Insert a batch of decryption requests across all connectors
+    pub async fn insert_requests(
+        &self,
+        request_type: DecryptionRequestType,
+        count: usize,
+    ) -> Result<Vec<String>> {
+        let requests = self.request_builder.build_requests(request_type, count)?;
+        let mut request_ids = Vec::new();
+        
+        for request in &requests {
+            for connector in &self.connectors {
+                connector.insert_request(request.clone()).await?;
+            }
+            request_ids.push(request.id().to_string());
+        }
+        
+        // Track the inserted requests
+        let mut tracker = self.response_tracker.write().await;
+        tracker.register_requests(request_ids.clone());
+        
+        // Also keep track of all IDs for this test run
+        let mut all_ids = self.inserted_request_ids.write().await;
+        all_ids.extend(request_ids.clone());
+        
+        Ok(request_ids)
+    }
+    
+    /// Track responses across all connectors
+    pub async fn track_responses(&self) -> Result<()> {
+        // Get the list of request IDs we're tracking
+        let request_ids = self.inserted_request_ids.read().await;
+        
+        let mut tracker = self.response_tracker.write().await;
+        
+        for (index, connector) in self.connectors.iter().enumerate() {
+            // Only fetch responses for the requests we inserted
+            let responses = connector.fetch_responses_for_requests(&request_ids).await?;
+            tracker.update_responses(index, responses);
+        }
+        
+        Ok(())
+    }
+    
+    /// Get tracking statistics
+    pub async fn get_stats(&self) -> ResponseStats {
+        let tracker = self.response_tracker.read().await;
+        tracker.get_stats()
+    }
+    
+    /// Check connectivity for all connectors
+    pub async fn health_check(&self) -> Result<Vec<bool>> {
+        let mut results = Vec::new();
+        
+        for connector in &self.connectors {
+            let healthy = connector.health_check().await.is_ok();
+            results.push(healthy);
+        }
+        
+        Ok(results)
+    }
+    
+    /// Clear database tables for all connectors
+    pub async fn clear_databases(&self) -> Result<()> {
+        for connector in &self.connectors {
+            connector.clear_tables().await?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum DecryptionRequestType {
+    Public,
+    User,
+    Mixed,
+}
+
+#[derive(Debug, Clone)]
+pub struct ResponseStats {
+    pub total_requests: usize,
+    pub responses_by_connector: Vec<usize>,
+    pub fully_synced: usize,
+    pub partially_synced: usize,
+    pub missing: usize,
+}
diff --git a/test-suite/gateway-stress/src/db_manager/request_builder.rs b/test-suite/gateway-stress/src/db_manager/request_builder.rs
new file mode 100644
index 0000000000..04d8216714
--- /dev/null
+++ b/test-suite/gateway-stress/src/db_manager/request_builder.rs
@@ -0,0 +1,210 @@
+use crate::db_manager::DecryptionRequestType;
+use alloy::primitives::{Address, Bytes, FixedBytes, U256};
+use anyhow::Result;
+use fhevm_gateway_bindings::decryption::Decryption::{
+    PublicDecryptionRequest, SnsCiphertextMaterial, UserDecryptionRequest,
+};
+use rand::{thread_rng, Rng};
+use std::time::SystemTime;
+
+/// Builder for creating different types of decryption requests
+pub struct RequestBuilder {
+    counter: std::sync::atomic::AtomicU64,
+}
+
+impl RequestBuilder {
+    /// Create a new request builder
+    pub fn new() -> Self {
+        Self {
+            counter: std::sync::atomic::AtomicU64::new(0),
+        }
+    }
+    
+    /// Build a batch of decryption requests
+    pub fn build_requests(
+        &self,
+        request_type: DecryptionRequestType,
+        count: usize,
+    ) -> Result<Vec<DecryptionRequest>> {
+        let mut requests = Vec::new();
+        
+        for _ in 0..count {
+            let request = match request_type {
+                DecryptionRequestType::Public => {
+                    DecryptionRequest::Public(self.build_public_request()?)
+                }
+                DecryptionRequestType::User => {
+                    DecryptionRequest::User(self.build_user_request()?)
+                }
+                DecryptionRequestType::Mixed => {
+                    // 50/50 distribution for mixed mode
+                    if thread_rng().gen_bool(0.5) {
+                        DecryptionRequest::Public(self.build_public_request()?)
+                    } else {
+                        DecryptionRequest::User(self.build_user_request()?)
+                    }
+                }
+            };
+            requests.push(request);
+        }
+        
+        Ok(requests)
+    }
+    
+    /// Build a single public decryption request
+    fn build_public_request(&self) -> Result<PublicDecryptionRequest> {
+        // Generate a unique decryption ID as U256
+        let id_bytes = self.generate_unique_id();
+        let mut id_array = [0u8; 32];
+        id_array[..id_bytes.len().min(32)].copy_from_slice(&id_bytes[..id_bytes.len().min(32)]);
+        let decryption_id = U256::from_be_bytes(id_array);
+        
+        // Generate mock SNS ciphertext materials (1-3 materials per request)
+        let num_materials = rand::thread_rng().gen_range(1..=3);
+        let mut sns_ct_materials = Vec::new();
+        
+        for i in 0..num_materials {
+            // Generate random bytes for each field
+            let mut ct_handle = [0u8; 32];
+            let mut sns_digest = [0u8; 32];
+            thread_rng().fill(&mut ct_handle);
+            thread_rng().fill(&mut sns_digest);
+            
+            sns_ct_materials.push(SnsCiphertextMaterial {
+                ctHandle: FixedBytes::from(ct_handle),
+                keyId: U256::from(i + 1), // Simple key ID
+                snsCiphertextDigest: FixedBytes::from(sns_digest),
+                coprocessorTxSenderAddresses: vec![{
+                    let bytes: [u8; 20] = self.generate_random_bytes(20).try_into().unwrap();
+                    Address::from(bytes)
+                }],
+            });
+        }
+        
+        // Generate extra data as Bytes
+        let extra_data_vec = self.generate_extra_data();
+        let extra_data = Bytes::from(extra_data_vec);
+        
+        Ok(PublicDecryptionRequest {
+            decryptionId: decryption_id,
+            snsCtMaterials: sns_ct_materials,
+            extraData: extra_data,
+        })
+    }
+    
+    /// Build a single user decryption request
+    fn build_user_request(&self) -> Result<UserDecryptionRequest> {
+        // Generate a unique decryption ID as U256
+        let id_bytes = self.generate_unique_id();
+        let mut id_array = [0u8; 32];
+        id_array[..id_bytes.len().min(32)].copy_from_slice(&id_bytes[..id_bytes.len().min(32)]);
+        let decryption_id = U256::from_be_bytes(id_array);
+        
+        // Generate mock SNS ciphertext materials (1-3 materials per request)
+        let num_materials = rand::thread_rng().gen_range(1..=3);
+        let mut sns_ct_materials = Vec::new();
+        
+        for i in 0..num_materials {
+            // Generate random bytes for each field
+            let mut ct_handle = [0u8; 32];
+            let mut sns_digest = [0u8; 32];
+            thread_rng().fill(&mut ct_handle);
+            thread_rng().fill(&mut sns_digest);
+            
+            sns_ct_materials.push(SnsCiphertextMaterial {
+                ctHandle: FixedBytes::from(ct_handle),
+                keyId: U256::from(i + 1), // Simple key ID
+                snsCiphertextDigest: FixedBytes::from(sns_digest),
+                coprocessorTxSenderAddresses: vec![{
+                    let bytes: [u8; 20] = self.generate_random_bytes(20).try_into().unwrap();
+                    Address::from(bytes)
+                }],
+            });
+        }
+        
+        // Generate user address
+        let user_addr_bytes: [u8; 20] = self.generate_random_bytes(20).try_into().unwrap();
+        let user_address = Address::from(user_addr_bytes);
+        
+        // Generate public key as Bytes (33 bytes for compressed secp256k1)
+        let public_key_vec = self.generate_random_bytes(33);
+        let public_key = Bytes::from(public_key_vec);
+        
+        // Generate extra data as Bytes
+        let extra_data_vec = self.generate_extra_data();
+        let extra_data = Bytes::from(extra_data_vec);
+        
+        Ok(UserDecryptionRequest {
+            decryptionId: decryption_id,
+            snsCtMaterials: sns_ct_materials,
+            userAddress: user_address,
+            publicKey: public_key,
+            extraData: extra_data,
+        })
+    }
+    
+    /// Generate a unique ID for a decryption request
+    fn generate_unique_id(&self) -> Vec<u8> {
+        let counter = self
+            .counter
+            .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        
+        let timestamp = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos() as u64;
+        
+        let mut id = Vec::new();
+        id.extend_from_slice(&timestamp.to_be_bytes());
+        id.extend_from_slice(&counter.to_be_bytes());
+        
+        // Add some random bytes
+        let mut rng = thread_rng();
+        let size = rng.gen_range(64..256);
+        let mut random_bytes = vec![0u8; size];
+        rng.fill(&mut random_bytes[..]);
+        id.extend_from_slice(&random_bytes);
+        
+        id
+    }
+    
+    /// Generate random bytes of specified size
+    fn generate_random_bytes(&self, size: usize) -> Vec<u8> {
+        let mut rng = thread_rng();
+        let mut bytes = vec![0u8; size];
+        rng.fill(&mut bytes[..]);
+        bytes
+    }
+    
+    /// Generate extra data
+    fn generate_extra_data(&self) -> Vec<u8> {
+        let mut rng = thread_rng();
+        let size = rng.gen_range(16..64);
+        let mut data = vec![0u8; size];
+        rng.fill(&mut data[..]);
+        data
+    }
+}
+
+impl Default for RequestBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Represents a decryption request that can be either public or user type
+#[derive(Debug, Clone)]
+pub enum DecryptionRequest {
+    Public(PublicDecryptionRequest),
+    User(UserDecryptionRequest),
+}
+
+impl DecryptionRequest {
+    /// Get the ID of the request as a hex string
+    pub fn id(&self) -> String {
+        match self {
+            DecryptionRequest::Public(req) => hex::encode(req.decryptionId.to_le_bytes::<32>()),
+            DecryptionRequest::User(req) => hex::encode(req.decryptionId.to_le_bytes::<32>()),
+        }
+    }
+}
diff --git a/test-suite/gateway-stress/src/db_manager/response_tracker.rs b/test-suite/gateway-stress/src/db_manager/response_tracker.rs
new file mode 100644
index 0000000000..334372a530
--- /dev/null
+++ b/test-suite/gateway-stress/src/db_manager/response_tracker.rs
@@ -0,0 +1,110 @@
+use crate::db_manager::ResponseStats;
+use std::collections::{HashMap, HashSet};
+use tracing::debug;
+
+/// Tracks decryption responses across multiple connectors
+pub struct ResponseTracker {
+    /// All request IDs we're tracking
+    all_requests: HashSet<String>,
+    
+    /// Map of request ID to set of connector indexes that have the response
+    responses: HashMap<String, HashSet<usize>>,
+    
+    /// Number of connectors we're tracking
+    connector_count: usize,
+    
+    /// Current statistics
+    stats: ResponseStats,
+}
+
+impl ResponseTracker {
+    /// Create a new response tracker for N connectors
+    pub fn new(connector_count: usize) -> Self {
+        Self {
+            connector_count,
+            responses: HashMap::new(),
+            all_requests: HashSet::new(),
+            stats: ResponseStats {
+                total_requests: 0,
+                responses_by_connector: vec![0; connector_count],
+                fully_synced: 0,
+                partially_synced: 0,
+                missing: 0,
+            },
+        }
+    }
+    
+    /// Register requests that were inserted
+    pub fn register_requests(&mut self, request_ids: Vec<String>) {
+        for id in request_ids {
+            self.all_requests.insert(id.clone());
+            self.responses.entry(id).or_default();
+        }
+        self.stats.total_requests = self.all_requests.len();
+    }
+    
+    /// Update responses from a specific connector
+    pub fn update_responses(&mut self, connector_index: usize, response_ids: Vec<String>) {
+        debug!(
+            "Updating responses from connector {}: {} responses",
+            connector_index,
+            response_ids.len()
+        );
+        
+        for id in response_ids {
+            self.responses
+                .entry(id)
+                .or_default()
+                .insert(connector_index);
+        }
+        
+        self.update_stats();
+    }
+    
+    /// Update internal statistics
+    fn update_stats(&mut self) {
+        let mut fully_synced = 0;
+        let mut partially_synced = 0;
+        let mut missing = 0;
+        let mut responses_by_connector = vec![0; self.connector_count];
+        
+        for request_id in &self.all_requests {
+            if let Some(connectors) = self.responses.get(request_id) {
+                let count = connectors.len();
+                
+                // Count responses per connector
+                for &connector_idx in connectors {
+                    if connector_idx < self.connector_count {
+                        responses_by_connector[connector_idx] += 1;
+                    }
+                }
+                
+                if count == self.connector_count {
+                    fully_synced += 1;
+                } else if count > 0 {
+                    partially_synced += 1;
+                } else {
+                    missing += 1;
+                }
+            } else {
+                missing += 1;
+            }
+        }
+        
+        self.stats.fully_synced = fully_synced;
+        self.stats.partially_synced = partially_synced;
+        self.stats.missing = missing;
+        self.stats.responses_by_connector = responses_by_connector;
+    }
+    
+    /// Get current statistics
+    pub fn get_stats(&self) -> ResponseStats {
+        ResponseStats {
+            total_requests: self.stats.total_requests,
+            fully_synced: self.stats.fully_synced,
+            partially_synced: self.stats.partially_synced,
+            missing: self.stats.missing,
+            responses_by_connector: self.stats.responses_by_connector.clone(),
+        }
+    }
+}
diff --git a/test-suite/gateway-stress/src/decryption/mod.rs b/test-suite/gateway-stress/src/decryption/mod.rs
index ddf80a47f8..2e46c55d16 100644
--- a/test-suite/gateway-stress/src/decryption/mod.rs
+++ b/test-suite/gateway-stress/src/decryption/mod.rs
@@ -27,15 +27,15 @@ where
     trace!("Receipt details: {receipt:?}");
 
     for log in receipt.inner.logs().iter() {
-        if let Some(first_topic) = log.topics().first()
-            && first_topic == &event_hash
-        {
-            let decryption_id = decode_fn(log.data())?;
-            debug!(
-                ?receipt.transaction_hash,
-                "Decryption #{decryption_id} has been accepted on the Gateway!"
-            );
-            return Ok(decryption_id);
+        if let Some(first_topic) = log.topics().first() {
+            if first_topic == &event_hash {
+                let decryption_id = decode_fn(log.data())?;
+                debug!(
+                    ?receipt.transaction_hash,
+                    "Decryption #{decryption_id} has been accepted on the Gateway!"
+                );
+                return Ok(decryption_id);
+            }
         }
     }
 
diff --git a/test-suite/gateway-stress/src/decryption/public.rs b/test-suite/gateway-stress/src/decryption/public.rs
index b658e01af8..bcaa5ac214 100644
--- a/test-suite/gateway-stress/src/decryption/public.rs
+++ b/test-suite/gateway-stress/src/decryption/public.rs
@@ -61,7 +61,7 @@ pub async fn public_decryption_burst<P, S>(
     );
 
     let mut requests_tasks = JoinSet::new();
-    for index in 0..config.parallel_requests {
+    for index in 0..config.parallel_requests.unwrap_or(1) {
         requests_tasks.spawn(send_public_decryption(
             index,
             decryption_contract.clone(),
@@ -70,7 +70,7 @@ pub async fn public_decryption_burst<P, S>(
         ));
     }
 
-    for _ in 0..config.parallel_requests {
+    for _ in 0..config.parallel_requests.unwrap_or(1) {
         requests_tasks.join_next().await;
         requests_pb.inc(1);
     }
@@ -192,7 +192,7 @@ where
 
     let mut received_id_guard = RECEIVED_RESPONSES_IDS.lock().await;
     let mut listener_guard = response_listener.lock().await;
-    for _ in 0..config.parallel_requests {
+    for _ in 0..config.parallel_requests.unwrap_or(1) {
         let Some(id) = id_receiver.recv().await else {
             return Err(anyhow!(
                 "Request id channel #{burst_index} was closed unexpectedly"
@@ -224,9 +224,9 @@ where
     progress_bar.finish_with_message(format!(
         "Handled burst #{} of {} in {:.2}s. Throughput: {:.2} tps",
         burst_index,
-        config.parallel_requests,
+        config.parallel_requests.unwrap_or(1),
         elapsed,
-        config.parallel_requests as f64 / elapsed
+        config.parallel_requests.unwrap_or(1) as f64 / elapsed
     ));
 
     Ok(())
diff --git a/test-suite/gateway-stress/src/decryption/user.rs b/test-suite/gateway-stress/src/decryption/user.rs
index 81e0670e99..3e6069166c 100644
--- a/test-suite/gateway-stress/src/decryption/user.rs
+++ b/test-suite/gateway-stress/src/decryption/user.rs
@@ -70,7 +70,7 @@ pub async fn user_decryption_burst<P, S>(
     );
 
     let mut requests_tasks = JoinSet::new();
-    for index in 0..config.parallel_requests {
+    for index in 0..config.parallel_requests.unwrap_or(1) {
         requests_tasks.spawn(
             send_user_decryption(
                 index,
@@ -84,7 +84,7 @@ pub async fn user_decryption_burst<P, S>(
         );
     }
 
-    for _ in 0..config.parallel_requests {
+    for _ in 0..config.parallel_requests.unwrap_or(1) {
         requests_tasks.join_next().await;
         requests_pb.inc(1);
     }
@@ -135,7 +135,7 @@ async fn send_user_decryption_inner<P: Provider>(
                 .iter()
                 .map(|h| CtHandleContractPair {
                     ctHandle: *h,
-                    contractAddress: config.allowed_contract,
+                    contractAddress: config.allowed_contract.unwrap_or(Address::ZERO),
                 })
                 .collect(),
             RequestValidity {
@@ -143,8 +143,8 @@ async fn send_user_decryption_inner<P: Provider>(
                 durationDays: U256::from(DURATION_DAYS),
             },
             ContractsInfo {
-                chainId: U256::from(config.host_chain_id),
-                addresses: vec![config.allowed_contract],
+                chainId: U256::from(config.host_chain_id.unwrap_or(0)),
+                addresses: vec![config.allowed_contract.unwrap_or(Address::ZERO)],
             },
             user_addr,
             hex::decode(RAND_PUBLIC_KEY)?.into(),
@@ -206,8 +206,8 @@ pub fn generate_eip712(
     config: &Config,
     timestamp: u64,
 ) -> anyhow::Result<Eip712Result> {
-    let allowed_contract = config.allowed_contract;
-    let private_key = config.private_key.clone().unwrap();
+    let allowed_contract = config.allowed_contract.unwrap_or(Address::ZERO);
+    let private_key = config.private_key.clone().unwrap_or_default();
 
     // Spawn in new thread otherwise panic because it blocks the async runtime
     std::thread::spawn(move || {
@@ -263,7 +263,7 @@ where
 
     let mut received_id_guard = RECEIVED_RESPONSES_IDS.lock().await;
     let mut listener_guard = response_listener.lock().await;
-    for _ in 0..config.parallel_requests {
+    for _ in 0..config.parallel_requests.unwrap_or(1) {
         let Some(id) = id_receiver.recv().await else {
             return Err(anyhow!(
                 "Request id channel #{burst_index} was closed unexpectedly"
@@ -293,9 +293,9 @@ where
     progress_bar.finish_with_message(format!(
         "Handled burst #{} of {} in {:.2}s. Throughput: {:.2} tps",
         burst_index,
-        config.parallel_requests,
+        config.parallel_requests.unwrap_or(1),
         elapsed,
-        config.parallel_requests as f64 / elapsed
+        config.parallel_requests.unwrap_or(1) as f64 / elapsed
     ));
 
     Ok(())
diff --git a/test-suite/gateway-stress/src/main.rs b/test-suite/gateway-stress/src/main.rs
index 7f017f2be3..0ef8b8a3e9 100644
--- a/test-suite/gateway-stress/src/main.rs
+++ b/test-suite/gateway-stress/src/main.rs
@@ -2,6 +2,7 @@ mod app;
 mod blockchain;
 mod cli;
 mod config;
+mod db_manager;
 mod decryption;
 
 use crate::{
@@ -13,7 +14,6 @@ use clap::Parser;
 use std::process::ExitCode;
 use tracing::{error, info};
 use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
-
 #[tokio::main]
 async fn main() -> ExitCode {
     init_tracing();
@@ -26,27 +26,46 @@ async fn main() -> ExitCode {
 
 async fn run() -> anyhow::Result<()> {
     let cli = Cli::parse();
-    let mut config = Config::from_env_and_file(cli.config)?;
+    
+    // Use default config path if none specified
+    let config_path = cli.config.or_else(|| {
+        std::path::PathBuf::from("config/config.toml").exists()
+            .then_some(std::path::PathBuf::from("config/config.toml"))
+    });
+    
+    let mut config = Config::from_env_and_file(config_path)?;
 
     // Override some fields of the config by the CLI
     if cli.sequential {
         config.sequential = cli.sequential;
     }
     if let Some(parallel) = cli.parallel {
-        config.parallel_requests = parallel;
+        config.parallel_requests = Some(parallel);
     }
 
     info!("Config: {config:?}");
-    let app = App::connect(config).await?;
+    
     match cli.subcommand {
-        Subcommands::Public => app.public_decryption_stress_test().await?,
-        Subcommands::User => app.user_decryption_stress_test().await?,
-        _ => todo!(),
+        Subcommands::DbConnector(args) => {
+            // For DB connector testing, we don't need to connect to the gateway
+            App::db_connector_stress_test_standalone(config, args).await?
+        }
+        _ => {
+            // For blockchain testing, we need gateway connection
+            let app = App::connect(config).await?;
+            match cli.subcommand {
+                Subcommands::Public => app.public_decryption_stress_test().await?,
+                Subcommands::User => app.user_decryption_stress_test().await?,
+                Subcommands::Mixed => todo!("Mixed mode not implemented yet"),
+                _ => unreachable!(),
+            }
+        }
     }
 
     Ok(())
 }
 
+
 fn init_tracing() {
     tracing_subscriber::registry()
         .with(fmt::layer())