diff --git a/cmd/root.go b/cmd/root.go
index f287621e7..9f7c1ba79 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -66,6 +66,14 @@ func rootCmd() *cobra.Command {
 			FlagDefault: "http://localhost:3000",
 			Required:    true,
 		},
+		// env-file flag is already handled in main.go, but it needs to be also defined here because Cobra doesn't allow unknown flags.
+		{
+			Name:      "env-file",
+			Usage:     "Path to environment file to load (e.g., \"dev/.env.https-testnet\"). Supports absolute and relative paths. Defaults to \".env\" if not specified.",
+			OptType:   types.String,
+			ConfigKey: &globalOptions.EnvFile,
+			Required:  false,
+		},
 		cmdUtils.NetworkPassphrase(&globalOptions.NetworkPassphrase),
 	}
 
diff --git a/cmd/utils/env_loader.go b/cmd/utils/env_loader.go
new file mode 100644
index 000000000..ea2601cfa
--- /dev/null
+++ b/cmd/utils/env_loader.go
@@ -0,0 +1,89 @@
+package utils
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/joho/godotenv"
+)
+
+const (
+	envFileFlag   = "--env-file"
+	envFileEnvVar = "ENV_FILE"
+)
+
+// LoadEnvFile loads environment variables from a file.
+// Priority: --env-file flag > ENV_FILE environment variable > .env in working directory
+func LoadEnvFile() error {
+	envFilePath := determineEnvFilePath()
+
+	if envFilePath != "" {
+		return loadExplicitEnvFile(envFilePath)
+	}
+
+	return loadDefaultEnvFile()
+}
+
+// determineEnvFilePath determines the path to the env file based on priority.
+func determineEnvFilePath() string {
+	if path := parseEnvFileFlag(); path != "" {
+		return toAbsolutePath(path)
+	}
+
+	if path := os.Getenv(envFileEnvVar); path != "" {
+		return toAbsolutePath(path)
+	}
+
+	return ""
+}
+
+// parseEnvFileFlag checks command-line arguments for the --env-file flag.
+func parseEnvFileFlag() string {
+	for i, arg := range os.Args {
+		if arg == envFileFlag && i+1 < len(os.Args) {
+			return os.Args[i+1]
+		}
+		if strings.HasPrefix(arg, envFileFlag+"=") {
+			return strings.TrimPrefix(arg, envFileFlag+"=")
+		}
+	}
+	return ""
+}
+
+// toAbsolutePath converts a relative path to an absolute path.
+func toAbsolutePath(path string) string {
+	if path == "" || filepath.IsAbs(path) {
+		return path
+	}
+
+	absPath, err := filepath.Abs(path)
+	if err != nil {
+		return path
+	}
+	return absPath
+}
+
+// loadExplicitEnvFile loads environment variables from the specified file.
+func loadExplicitEnvFile(path string) error {
+	if err := godotenv.Load(path); err != nil {
+		return fmt.Errorf("loading env file %s: %w", path, err)
+	}
+	return nil
+}
+
+// loadDefaultEnvFile loads environment variables from the default .env file.
+func loadDefaultEnvFile() error {
+	err := godotenv.Load()
+	if err == nil {
+		return nil
+	}
+
+	if errors.Is(err, os.ErrNotExist) {
+		return nil
+	}
+
+	return fmt.Errorf("loading .env file: %w", err)
+}
diff --git a/cmd/utils/env_loader_test.go b/cmd/utils/env_loader_test.go
new file mode 100644
index 000000000..fca34fc9b
--- /dev/null
+++ b/cmd/utils/env_loader_test.go
@@ -0,0 +1,353 @@
+package utils
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_toAbsolutePath(t *testing.T) {
+	cwd, err := os.Getwd()
+	require.NoError(t, err)
+
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "empty string returns empty",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "absolute path unchanged",
+			input:    "/etc/config/.env",
+			expected: "/etc/config/.env",
+		},
+		{
+			name:     "relative path converted to absolute",
+			input:    "config/.env",
+			expected: filepath.Join(cwd, "config/.env"),
+		},
+		{
+			name:     "dot relative path converted",
+			input:    "./config/.env",
+			expected: filepath.Join(cwd, "config/.env"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := toAbsolutePath(tt.input)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func Test_parseEnvFileFlag(t *testing.T) {
+	tests := []struct {
+		name     string
+		args     []string
+		expected string
+	}{
+		{
+			name:     "no flag present",
+			args:     []string{"app", "serve"},
+			expected: "",
+		},
+		{
+			name:     "flag with space separator",
+			args:     []string{"app", "--env-file", "/path/to/.env", "serve"},
+			expected: "/path/to/.env",
+		},
+		{
+			name:     "flag with equals separator",
+			args:     []string{"app", "--env-file=/path/to/.env", "serve"},
+			expected: "/path/to/.env",
+		},
+		{
+			name:     "flag at end with space separator",
+			args:     []string{"app", "serve", "--env-file", "/path/to/.env"},
+			expected: "/path/to/.env",
+		},
+		{
+			name:     "flag at end with equals separator",
+			args:     []string{"app", "serve", "--env-file=/path/to/.env"},
+			expected: "/path/to/.env",
+		},
+		{
+			name:     "flag with missing value at end",
+			args:     []string{"app", "serve", "--env-file"},
+			expected: "",
+		},
+		{
+			name:     "similar flag name ignored",
+			args:     []string{"app", "--env-file-path", "/path/to/.env"},
+			expected: "",
+		},
+		{
+			name:     "empty value with equals",
+			args:     []string{"app", "--env-file="},
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			originalArgs := os.Args
+			t.Cleanup(func() { os.Args = originalArgs })
+
+			os.Args = tt.args
+			result := parseEnvFileFlag()
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func Test_determineEnvFilePath(t *testing.T) {
+	cwd, err := os.Getwd()
+	require.NoError(t, err)
+
+	tests := []struct {
+		name     string
+		args     []string
+		envVar   string
+		expected string
+	}{
+		{
+			name:     "nothing set returns empty",
+			args:     []string{"app"},
+			envVar:   "",
+			expected: "",
+		},
+		{
+			name:     "flag takes precedence over env var",
+			args:     []string{"app", "--env-file", "/flag/path/.env"},
+			envVar:   "/env/path/.env",
+			expected: "/flag/path/.env",
+		},
+		{
+			name:     "env var used when no flag",
+			args:     []string{"app"},
+			envVar:   "/env/path/.env",
+			expected: "/env/path/.env",
+		},
+		{
+			name:     "relative flag path converted to absolute",
+			args:     []string{"app", "--env-file", "config/.env"},
+			envVar:   "",
+			expected: filepath.Join(cwd, "config/.env"),
+		},
+		{
+			name:     "relative env var path converted to absolute",
+			args:     []string{"app"},
+			envVar:   "config/.env",
+			expected: filepath.Join(cwd, "config/.env"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			originalArgs := os.Args
+			t.Cleanup(func() { os.Args = originalArgs })
+			os.Args = tt.args
+
+			if tt.envVar != "" {
+				t.Setenv(envFileEnvVar, tt.envVar)
+			}
+
+			result := determineEnvFilePath()
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func Test_loadExplicitEnvFile(t *testing.T) {
+	t.Run("loads valid env file", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		envPath := filepath.Join(tmpDir, ".env")
+		err := os.WriteFile(envPath, []byte("TEST_VAR=hello\n"), 0o644)
+		require.NoError(t, err)
+
+		t.Cleanup(func() {
+			err = os.Unsetenv("TEST_VAR")
+			require.NoError(t, err)
+		})
+
+		err = loadExplicitEnvFile(envPath)
+
+		assert.NoError(t, err)
+		assert.Equal(t, "hello", os.Getenv("TEST_VAR"))
+	})
+
+	t.Run("returns error for nonexistent file", func(t *testing.T) {
+		err := loadExplicitEnvFile("/nonexistent/path/.env")
+
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "loading env file")
+		assert.Contains(t, err.Error(), "/nonexistent/path/.env")
+	})
+
+	t.Run("returns error for malformed file", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		envPath := filepath.Join(tmpDir, ".env")
+		err := os.WriteFile(envPath, []byte("INVALID LINE WITHOUT EQUALS\n"), 0o644)
+		require.NoError(t, err)
+
+		err = loadExplicitEnvFile(envPath)
+		// godotenv is lenient, so this may not error - adjust based on actual behavior
+		// The key point is we're testing the error path exists
+		if err != nil {
+			assert.Contains(t, err.Error(), "loading env file")
+		}
+	})
+}
+
+func Test_loadDefaultEnvFile(t *testing.T) {
+	t.Run("succeeds when no .env file exists", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		originalWd, err := os.Getwd()
+		require.NoError(t, err)
+		require.NoError(t, os.Chdir(tmpDir))
+		t.Cleanup(func() {
+			err = os.Chdir(originalWd)
+			require.NoError(t, err)
+		})
+
+		err = loadDefaultEnvFile()
+
+		assert.NoError(t, err)
+	})
+
+	t.Run("loads .env file when present", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		envPath := filepath.Join(tmpDir, ".env")
+		err := os.WriteFile(envPath, []byte("DEFAULT_VAR=world\n"), 0o644)
+		require.NoError(t, err)
+
+		originalWd, err := os.Getwd()
+		require.NoError(t, err)
+		require.NoError(t, os.Chdir(tmpDir))
+		t.Cleanup(func() {
+			err = os.Chdir(originalWd)
+			require.NoError(t, err)
+
+			err = os.Unsetenv("DEFAULT_VAR")
+			require.NoError(t, err)
+		})
+
+		err = loadDefaultEnvFile()
+
+		assert.NoError(t, err)
+		assert.Equal(t, "world", os.Getenv("DEFAULT_VAR"))
+	})
+}
+
+func Test_LoadEnvFile(t *testing.T) {
+	t.Run("uses flag path when provided", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		envPath := filepath.Join(tmpDir, "custom.env")
+		err := os.WriteFile(envPath, []byte("FLAG_VAR=from_flag\n"), 0o644)
+		require.NoError(t, err)
+
+		originalArgs := os.Args
+		t.Cleanup(func() {
+			os.Args = originalArgs
+			err = os.Unsetenv("FLAG_VAR")
+			require.NoError(t, err)
+		})
+		os.Args = []string{"app", "--env-file", envPath}
+
+		err = LoadEnvFile()
+
+		assert.NoError(t, err)
+		assert.Equal(t, "from_flag", os.Getenv("FLAG_VAR"))
+	})
+
+	t.Run("uses env var path when no flag", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		envPath := filepath.Join(tmpDir, "envvar.env")
+		err := os.WriteFile(envPath, []byte("ENVVAR_VAR=from_envvar\n"), 0o644)
+		require.NoError(t, err)
+
+		originalArgs := os.Args
+		t.Cleanup(func() {
+			os.Args = originalArgs
+			err = os.Unsetenv("ENVVAR_VAR")
+			require.NoError(t, err)
+		})
+		os.Args = []string{"app"}
+		t.Setenv(envFileEnvVar, envPath)
+
+		err = LoadEnvFile()
+
+		assert.NoError(t, err)
+		assert.Equal(t, "from_envvar", os.Getenv("ENVVAR_VAR"))
+	})
+
+	t.Run("falls back to default .env", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		envPath := filepath.Join(tmpDir, ".env")
+		err := os.WriteFile(envPath, []byte("DEFAULT_FALLBACK=from_default\n"), 0o644)
+		require.NoError(t, err)
+
+		originalArgs := os.Args
+		originalWd, err := os.Getwd()
+		require.NoError(t, err)
+		require.NoError(t, os.Chdir(tmpDir))
+		t.Cleanup(func() {
+			os.Args = originalArgs
+			err = os.Chdir(originalWd)
+			require.NoError(t, err)
+
+			err = os.Unsetenv("DEFAULT_FALLBACK")
+			require.NoError(t, err)
+		})
+		os.Args = []string{"app"}
+
+		err = LoadEnvFile()
+
+		assert.NoError(t, err)
+		assert.Equal(t, "from_default", os.Getenv("DEFAULT_FALLBACK"))
+	})
+
+	t.Run("returns error for explicit nonexistent path", func(t *testing.T) {
+		originalArgs := os.Args
+		t.Cleanup(func() { os.Args = originalArgs })
+		os.Args = []string{"app", "--env-file", "/nonexistent/.env"}
+
+		err := LoadEnvFile()
+
+		assert.Error(t, err)
+	})
+
+	t.Run("flag takes precedence over env var", func(t *testing.T) {
+		tmpDir := t.TempDir()
+
+		flagEnvPath := filepath.Join(tmpDir, "flag.env")
+		err := os.WriteFile(flagEnvPath, []byte("PRECEDENCE_TEST=from_flag\n"), 0o644)
+		require.NoError(t, err)
+
+		envVarEnvPath := filepath.Join(tmpDir, "envvar.env")
+		err = os.WriteFile(envVarEnvPath, []byte("PRECEDENCE_TEST=from_envvar\n"), 0o644)
+		require.NoError(t, err)
+
+		originalArgs := os.Args
+		t.Cleanup(func() {
+			os.Args = originalArgs
+			err = os.Unsetenv("PRECEDENCE_TEST")
+			require.NoError(t, err)
+		})
+		os.Args = []string{"app", "--env-file", flagEnvPath}
+		t.Setenv(envFileEnvVar, envVarEnvPath)
+
+		err = LoadEnvFile()
+
+		assert.NoError(t, err)
+		assert.Equal(t, "from_flag", os.Getenv("PRECEDENCE_TEST"))
+	})
+}
diff --git a/cmd/utils/global_options.go b/cmd/utils/global_options.go
index 27785bf12..835eec97b 100644
--- a/cmd/utils/global_options.go
+++ b/cmd/utils/global_options.go
@@ -17,6 +17,7 @@ type GlobalOptionsType struct {
 	BaseURL           string
 	SDPUIBaseURL      string
 	NetworkPassphrase string
+	EnvFile           string
 }
 
 // PopulateCrashTrackerOptions populates the CrastTrackerOptions from the global options.
diff --git a/dev/.env.example b/dev/.env.example
index 76b987355..4d89b2fda 100644
--- a/dev/.env.example
+++ b/dev/.env.example
@@ -70,6 +70,13 @@ TENANT_XLM_BOOTSTRAP_AMOUNT=5
 # Whether to run in single-tenant mode.
 SINGLE_TENANT_MODE=false
 
+# Default tenant Configuration (used for default tenant creation)
+# --------------------------
+DEFAULT_TENANT_OWNER_EMAIL="default@default.local"
+DEFAULT_TENANT_OWNER_FIRST_NAME="Default"
+DEFAULT_TENANT_OWNER_LAST_NAME="Owner"
+DEFAULT_TENANT_DISTRIBUTION_ACCOUNT_TYPE="DISTRIBUTION_ACCOUNT.STELLAR.ENV"
+
 # Scheduler Configuration
 # -----------------------
 # Interval in seconds for the receiver invitation job.
diff --git a/dev/README.md b/dev/README.md
index e1ef2d3ef..b47492046 100644
--- a/dev/README.md
+++ b/dev/README.md
@@ -108,20 +108,68 @@ DISTRIBUTION_ACCOUNT_ENCRYPTION_PASSPHRASE=SDDWY3N3DSTR6SNCZTECOW6PNUIPOHDTMLKVW
 
 ### Start Local Environment
 
+There are three ways to run the SDP:
+
+#### Option 1: Using the Setup Wizard (Recommended)
+
 Start all services and provision sample tenants using the setup wizard:
 ```sh
 make setup
 ```
 
 The setup wizard will:
-1. Create or select an `.env` configuration
+1. Create or select an `.env` configuration under the `dev/` directory
 2. Generate Stellar accounts if needed (with testnet funding)
 3. Optionally launch the Docker environment immediately
-4. Initialize tenants and test users
+4. Optionally initialize tenants and test users
 
 For existing configurations, you can launch directly by selecting from available `.env` files in the `dev/` directory.
 
-Volumes and data isolation
+#### Option 2: Using Docker Compose Directly
+
+If you already have a configured `.env` file, you can start the services directly:
+
+```sh
+cd dev
+docker compose up -d
+```
+
+To stop the services:
+```sh
+docker compose down
+```
+
+#### Option 3: Running Locally with Go (Development)
+
+For local development outside Docker, run from the repo root:
+
+```sh
+go run main.go serve \
+  --env-file ./dev/.env.https-testnet \
+  --database-url "postgres://postgres@localhost:5432/sdp_mtn?sslmode=disable"
+```
+
+You can also run the TSS by using the `tss` command instead of `serve`.
+
+```sh 
+go run main.go tss \
+  --env-file ./dev/.env.https-testnet \
+  --database-url "postgres://postgres@localhost:5432/sdp_mtn?sslmode=disable"
+```
+
+**Important Notes:**
+- Use `--env-file` to specify which configuration to load (e.g., `./dev/.env.https-testnet`)
+- Override `--database-url` to use `localhost:5432` instead of `db:5432` (Docker hostname)
+- Ensure PostgreSQL is running locally and accessible on port 5432
+
+You can also use the `ENV_FILE` and `DATABASE_URL` environment variables instead of the flags:
+```sh
+ENV_FILE=./dev/.env.https-testnet \
+DATABASE_URL="postgres://postgres@localhost:5432/sdp_mtn?sslmode=disable" \
+  go run main.go serve
+```
+
+**Volumes and Data Isolation**
 
 - The Postgres volumes are network-scoped using the pattern `${COMPOSE_PROJECT_NAME}_postgres-db-${NETWORK_TYPE}` and `${COMPOSE_PROJECT_NAME}_postgres-ap-db-${NETWORK_TYPE}`. Compose reads `NETWORK_TYPE` from `dev/.env`.
 - Compose project name is automatically derived from the setup name (e.g., `sdp-testnet`, `sdp-mainnet1`).
diff --git a/main.go b/main.go
index 4d6b946e4..828f4b022 100644
--- a/main.go
+++ b/main.go
@@ -4,11 +4,11 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/joho/godotenv"
 	"github.com/sirupsen/logrus"
 	"github.com/stellar/go-stellar-sdk/support/log"
 
 	"github.com/stellar/stellar-disbursement-platform-backend/cmd"
+	cmdUtils "github.com/stellar/stellar-disbursement-platform-backend/cmd/utils"
 )
 
 // Version is the official version of this application. Whenever it's changed
@@ -20,8 +20,9 @@ const Version = "5.0.0"
 var GitCommit string
 
 func main() {
-	if err := godotenv.Load(); err != nil {
-		log.Debug("No .env file found")
+	if err := cmdUtils.LoadEnvFile(); err != nil {
+		fmt.Fprintf(os.Stderr, "Error loading environment file: %v\n", err)
+		os.Exit(1)
 	}
 
 	preConfigureLogger()
diff --git a/tools/sdp-setup/internal/config/env.go b/tools/sdp-setup/internal/config/env.go
index 42a068d9a..1a6128480 100644
--- a/tools/sdp-setup/internal/config/env.go
+++ b/tools/sdp-setup/internal/config/env.go
@@ -218,7 +218,8 @@ func Load(path string) (Config, error) {
 
 // Write writes the environment configuration to a file using godotenv
 func Write(cfg Config, path string) error {
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+	envConfigDir := filepath.Dir(path)
+	if err := os.MkdirAll(envConfigDir, 0o755); err != nil {
 		return fmt.Errorf("creating directory for %s: %w", path, err)
 	}
 
@@ -227,7 +228,8 @@ func Write(cfg Config, path string) error {
 		singleTenantModeStr = "false"
 	}
 
-	envMap := map[string]string{
+	// 1. Start with the configuration values we want to set
+	configMap := map[string]string{
 		"NETWORK_TYPE":                               cfg.NetworkType,
 		"NETWORK_PASSPHRASE":                         cfg.NetworkPassphrase,
 		"HORIZON_URL":                                cfg.HorizonURL,
@@ -244,14 +246,31 @@ func Write(cfg Config, path string) error {
 		"USE_HTTPS":                                  strconv.FormatBool(cfg.UseHTTPS),
 		"SDP_UI_BASE_URL":                            cfg.FrontendBaseURL("localhost"),
 		"BASE_URL":                                   "http://localhost:8000",
+		"DATABASE_URL":                               fmt.Sprintf("postgres://postgres@db:5432/%s?sslmode=disable", cfg.DatabaseName),
 	}
 
 	if cfg.NetworkType == "pubnet" {
-		envMap["TENANT_XLM_BOOTSTRAP_AMOUNT"] = "1"
-		envMap["NUM_CHANNEL_ACCOUNTS"] = "1"
+		configMap["TENANT_XLM_BOOTSTRAP_AMOUNT"] = "1"
+		configMap["NUM_CHANNEL_ACCOUNTS"] = "1"
 	}
 
-	if err := godotenv.Write(envMap, path); err != nil {
+	// 2. Load .env.example to use as a base
+	examplePath := filepath.Join(envConfigDir, ".env.example")
+
+	finalMap := make(map[string]string)
+
+	if exampleMap, err := godotenv.Read(examplePath); err == nil {
+		finalMap = exampleMap
+	} else {
+		fmt.Printf("Note: Could not load %s, generating minimal config\n", examplePath)
+	}
+
+	// 3. Override with our configuration values
+	for k, v := range configMap {
+		finalMap[k] = v
+	}
+
+	if err := godotenv.Write(finalMap, path); err != nil {
 		return fmt.Errorf("writing env file %s: %w", path, err)
 	}