diff --git a/apps/dokploy/__test__/compose/domain/labels.test.ts b/apps/dokploy/__test__/compose/domain/labels.test.ts
index 9a75e0a845..d287acf21c 100644
--- a/apps/dokploy/__test__/compose/domain/labels.test.ts
+++ b/apps/dokploy/__test__/compose/domain/labels.test.ts
@@ -21,6 +21,7 @@ describe("createDomainLabels", () => {
 		previewDeploymentId: "",
 		internalPath: "/",
 		stripPath: false,
+		networkId: null,
 	};
 
 	it("should create basic labels for web entrypoint", async () => {
diff --git a/apps/dokploy/__test__/drop/drop.test.ts b/apps/dokploy/__test__/drop/drop.test.ts
index 6e9940d6d7..30243256c5 100644
--- a/apps/dokploy/__test__/drop/drop.test.ts
+++ b/apps/dokploy/__test__/drop/drop.test.ts
@@ -71,6 +71,7 @@ const baseApp: ApplicationNested = {
 	previewPort: 3000,
 	previewLimit: 0,
 	previewWildcard: "",
+	previewNetworkIds: null,
 	environment: {
 		env: "",
 		isDefault: false,
@@ -151,6 +152,7 @@ const baseApp: ApplicationNested = {
 	dockerContextPath: null,
 	rollbackActive: false,
 	stopGracePeriodSwarm: null,
+	customNetworkIds: null,
 	ulimitsSwarm: null,
 };
 
diff --git a/apps/dokploy/__test__/network/compose-networks.test.ts b/apps/dokploy/__test__/network/compose-networks.test.ts
new file mode 100644
index 0000000000..93708ebb56
--- /dev/null
+++ b/apps/dokploy/__test__/network/compose-networks.test.ts
@@ -0,0 +1,309 @@
+import type { ComposeSpecification } from "@dokploy/server";
+import {
+	addAppNameToRootNetwork,
+	addAppNameToServiceNetworks,
+	addCustomNetworksToCompose,
+} from "@dokploy/server/utils/docker/collision/root-network";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { parse } from "yaml";
+
+// Mock the database
+vi.mock("@dokploy/server/db", () => ({
+	db: {
+		query: {
+			networks: {
+				findMany: vi.fn(),
+			},
+		},
+	},
+}));
+
+import { db } from "@dokploy/server/db";
+
+describe("addAppNameToRootNetwork", () => {
+	it("adds external network to compose", () => {
+		const compose: ComposeSpecification = {
+			services: {
+				web: {
+					image: "nginx",
+				},
+			},
+		};
+
+		const result = addAppNameToRootNetwork(compose, "dokploy-network");
+
+		expect(result.networks).toBeDefined();
+		expect(result.networks?.["dokploy-network"]).toEqual({
+			name: "dokploy-network",
+			external: true,
+		});
+	});
+
+	it("preserves existing networks", () => {
+		const compose = parse(`
+services:
+  web:
+    image: nginx
+networks:
+  frontend:
+    driver: bridge
+`) as ComposeSpecification;
+
+		const result = addAppNameToRootNetwork(compose, "dokploy-network");
+
+		expect(result.networks?.frontend).toBeDefined();
+		expect(result.networks?.["dokploy-network"]).toEqual({
+			name: "dokploy-network",
+			external: true,
+		});
+	});
+
+	it("initializes networks object if undefined", () => {
+		const compose: ComposeSpecification = {
+			services: {
+				web: { image: "nginx" },
+			},
+		};
+
+		const result = addAppNameToRootNetwork(compose, "test-network");
+
+		expect(result.networks).toBeDefined();
+		expect(result.networks?.["test-network"]).toBeDefined();
+	});
+});
+
+describe("addAppNameToServiceNetworks", () => {
+	it("adds network to services with array format", () => {
+		const services = {
+			web: {
+				image: "nginx",
+				networks: ["frontend", "backend"],
+			},
+			api: {
+				image: "node",
+				networks: ["backend"],
+			},
+		};
+
+		const result = addAppNameToServiceNetworks(services, "dokploy-network");
+
+		expect(result.web.networks).toContain("dokploy-network");
+		expect(result.web.networks).toContain("frontend");
+		expect(result.web.networks).toContain("backend");
+		expect(result.api.networks).toContain("dokploy-network");
+		expect(result.api.networks).toContain("backend");
+	});
+
+	it("adds network to services with object format", () => {
+		const services = {
+			web: {
+				image: "nginx",
+				networks: {
+					frontend: {
+						aliases: ["web-alias"],
+					},
+				},
+			},
+		};
+
+		const result = addAppNameToServiceNetworks(services, "dokploy-network");
+
+		expect(result.web.networks).toHaveProperty("dokploy-network");
+		expect(result.web.networks).toHaveProperty("frontend");
+	});
+
+	it("handles services without networks", () => {
+		const services = {
+			web: {
+				image: "nginx",
+			},
+			api: {
+				image: "node",
+			},
+		};
+
+		const result = addAppNameToServiceNetworks(services, "dokploy-network");
+
+		expect(result.web.networks).toEqual(["dokploy-network"]);
+		expect(result.api.networks).toEqual(["dokploy-network"]);
+	});
+
+	it("does not duplicate network if already present (array format)", () => {
+		const services = {
+			web: {
+				image: "nginx",
+				networks: ["dokploy-network", "frontend"],
+			},
+		};
+
+		const result = addAppNameToServiceNetworks(services, "dokploy-network");
+
+		const webNetworks = result.web.networks as string[];
+		const count = webNetworks.filter((n) => n === "dokploy-network").length;
+		expect(count).toBe(1);
+	});
+
+	it("handles mixed network formats across services", () => {
+		const services = {
+			web: {
+				image: "nginx",
+				networks: ["frontend"],
+			},
+			api: {
+				image: "node",
+				networks: {
+					backend: {},
+				},
+			},
+			worker: {
+				image: "worker",
+			},
+		};
+
+		const result = addAppNameToServiceNetworks(services, "dokploy-network");
+
+		expect(Array.isArray(result.web.networks)).toBe(true);
+		expect((result.web.networks as string[]).includes("dokploy-network")).toBe(
+			true,
+		);
+
+		expect(typeof result.api.networks).toBe("object");
+		expect(result.api.networks).toHaveProperty("dokploy-network");
+
+		expect(result.worker.networks).toEqual(["dokploy-network"]);
+	});
+});
+
+describe("addCustomNetworksToCompose (with mocked DB)", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("adds custom networks from DB to compose", async () => {
+		const mockNetworks = [
+			{ networkId: "net-1", networkName: "custom-net-1" },
+			{ networkId: "net-2", networkName: "custom-net-2" },
+		];
+
+		vi.mocked(db.query.networks.findMany).mockResolvedValue(mockNetworks);
+
+		const compose: ComposeSpecification = {
+			services: {
+				web: { image: "nginx" },
+			},
+		};
+
+		const result = await addCustomNetworksToCompose(compose, [
+			"net-1",
+			"net-2",
+		]);
+
+		expect(result.networks).toBeDefined();
+		expect(result.networks?.["custom-net-1"]).toEqual({
+			name: "custom-net-1",
+			external: true,
+		});
+		expect(result.networks?.["custom-net-2"]).toEqual({
+			name: "custom-net-2",
+			external: true,
+		});
+	});
+
+	it("adds custom networks to all services", async () => {
+		const mockNetworks = [{ networkId: "net-1", networkName: "prod-network" }];
+
+		vi.mocked(db.query.networks.findMany).mockResolvedValue(mockNetworks);
+
+		const compose: ComposeSpecification = {
+			services: {
+				web: { image: "nginx", networks: ["frontend"] },
+				api: { image: "node" },
+			},
+		};
+
+		const result = await addCustomNetworksToCompose(compose, ["net-1"]);
+
+		expect(
+			(result.services?.web?.networks as string[]).includes("prod-network"),
+		).toBe(true);
+		expect(
+			(result.services?.api?.networks as string[]).includes("prod-network"),
+		).toBe(true);
+	});
+
+	it("handles empty custom networks array", async () => {
+		vi.mocked(db.query.networks.findMany).mockResolvedValue([]);
+
+		const compose: ComposeSpecification = {
+			services: {
+				web: { image: "nginx" },
+			},
+		};
+
+		const result = await addCustomNetworksToCompose(compose, []);
+
+		expect(result.networks).toBeDefined();
+		expect(Object.keys(result.networks || {}).length).toBe(0);
+	});
+
+	it("preserves existing compose networks", async () => {
+		const mockNetworks = [{ networkId: "net-1", networkName: "custom-net" }];
+
+		vi.mocked(db.query.networks.findMany).mockResolvedValue(mockNetworks);
+
+		const compose = parse(`
+services:
+  web:
+    image: nginx
+networks:
+  frontend:
+    driver: bridge
+`) as ComposeSpecification;
+
+		const result = await addCustomNetworksToCompose(compose, ["net-1"]);
+
+		expect(result.networks?.frontend).toBeDefined();
+		expect(result.networks?.["custom-net"]).toBeDefined();
+	});
+
+	it("initializes networks if undefined", async () => {
+		const mockNetworks = [{ networkId: "net-1", networkName: "test-net" }];
+
+		vi.mocked(db.query.networks.findMany).mockResolvedValue(mockNetworks);
+
+		const compose: ComposeSpecification = {
+			services: {
+				web: { image: "nginx" },
+			},
+		};
+
+		const result = await addCustomNetworksToCompose(compose, ["net-1"]);
+
+		expect(result.networks).toBeDefined();
+		expect(result.networks?.["test-net"]).toBeDefined();
+	});
+
+	it("handles services with object network format", async () => {
+		const mockNetworks = [{ networkId: "net-1", networkName: "custom-net" }];
+
+		vi.mocked(db.query.networks.findMany).mockResolvedValue(mockNetworks);
+
+		const compose: ComposeSpecification = {
+			services: {
+				web: {
+					image: "nginx",
+					networks: {
+						frontend: {
+							aliases: ["web"],
+						},
+					},
+				},
+			},
+		};
+
+		const result = await addCustomNetworksToCompose(compose, ["net-1"]);
+
+		expect(result.services?.web?.networks).toHaveProperty("custom-net");
+		expect(result.services?.web?.networks).toHaveProperty("frontend");
+	});
+});
diff --git a/apps/dokploy/__test__/network/domain-network-validation.test.ts b/apps/dokploy/__test__/network/domain-network-validation.test.ts
new file mode 100644
index 0000000000..9cb203f2f0
--- /dev/null
+++ b/apps/dokploy/__test__/network/domain-network-validation.test.ts
@@ -0,0 +1,398 @@
+import { TRPCError } from "@trpc/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock database
+vi.mock("@dokploy/server/db", () => ({
+	db: {
+		query: {
+			networks: {
+				findFirst: vi.fn(),
+			},
+			applications: {
+				findFirst: vi.fn(),
+			},
+			compose: {
+				findFirst: vi.fn(),
+			},
+			domains: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+		},
+	},
+}));
+
+const { db } = await import("@dokploy/server/db");
+
+const { createDomain } = await import("@dokploy/server/services/domain");
+const { findNetworkById } = await import("@dokploy/server/services/network");
+
+vi.mock("@dokploy/server/services/network", () => ({
+	findNetworkById: vi.fn(),
+	connectTraefikToResourceNetworks: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@dokploy/server/services/application", () => ({
+	findApplicationById: vi.fn(),
+}));
+
+vi.mock("@dokploy/server/utils/traefik/domain", () => ({
+	manageDomain: vi.fn().mockResolvedValue(undefined),
+}));
+
+describe("Domain Network Validation", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Default mocks for successful scenarios
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-1",
+			name: "Production Network",
+			networkName: "prod-network",
+			internal: false,
+			serverId: "server-1",
+			server: { name: "Test Server", serverId: "server-1" },
+		} as any);
+
+		vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+			applicationId: "app-1",
+			customNetworkIds: ["net-1", "net-2"],
+			serverId: "server-1",
+			server: { name: "Test Server", serverId: "server-1" },
+		} as any);
+
+		vi.mocked(findNetworkById).mockImplementation(async (id: string) => {
+			if (id === "net-1") {
+				return {
+					networkId: "net-1",
+					name: "Production Network",
+					networkName: "prod-network",
+					internal: false,
+					serverId: "server-1",
+					server: { name: "Test Server", serverId: "server-1" },
+				} as any;
+			}
+			if (id === "net-2") {
+				return {
+					networkId: "net-2",
+					name: "Staging Network",
+					networkName: "staging-network",
+					internal: false,
+					serverId: "server-1",
+					server: { name: "Test Server", serverId: "server-1" },
+				} as any;
+			}
+			throw new TRPCError({ code: "NOT_FOUND", message: "Network not found" });
+		});
+	});
+
+	describe("createDomain - Multiple networks validation", () => {
+		it("prevents creating domain with different network than existing domains (application)", async () => {
+			// Mock existing domain with net-1
+			vi.mocked(db.query.domains.findMany).mockResolvedValue([
+				{
+					domainId: "domain-1",
+					applicationId: "app-1",
+					networkId: "net-1",
+					host: "prod.example.com",
+				},
+			] as any);
+
+			// Mock DB transaction
+			const mockTx = {
+				insert: vi.fn().mockReturnValue({
+					values: vi.fn().mockReturnValue({
+						returning: vi.fn().mockResolvedValue([
+							{
+								domainId: "domain-2",
+								applicationId: "app-1",
+								networkId: "net-2",
+								host: "staging.example.com",
+							},
+						]),
+					}),
+				}),
+			};
+			vi.mocked(db as any).transaction = vi
+				.fn()
+				.mockImplementation((callback) => callback(mockTx));
+
+			// Try to create domain with net-2
+			await expect(
+				createDomain({
+					applicationId: "app-1",
+					networkId: "net-2",
+					host: "staging.example.com",
+					https: true,
+					port: null,
+					path: null,
+					serviceName: null,
+					domainType: "application",
+				} as any),
+			).rejects.toThrow(
+				'This application already has domain "prod.example.com" using network "Production Network". All domains must use the same network due to Docker/Traefik limitations. Please use "Production Network" for all domains.',
+			);
+		});
+
+		it("prevents creating domain with different network than existing domains (compose)", async () => {
+			// Mock compose instead of application
+			vi.mocked(db.query.applications.findFirst).mockResolvedValue(
+				undefined as any,
+			);
+			vi.mocked(db.query.compose.findFirst).mockResolvedValue({
+				composeId: "compose-1",
+				customNetworkIds: ["net-1", "net-2"],
+				serverId: "server-1",
+				server: { name: "Test Server", serverId: "server-1" },
+			} as any);
+
+			// Mock existing domain with net-1
+			vi.mocked(db.query.domains.findMany).mockResolvedValue([
+				{
+					domainId: "domain-1",
+					composeId: "compose-1",
+					networkId: "net-1",
+					host: "prod.example.com",
+				},
+			] as any);
+
+			// Mock DB transaction
+			const mockTx = {
+				insert: vi.fn().mockReturnValue({
+					values: vi.fn().mockReturnValue({
+						returning: vi.fn().mockResolvedValue([
+							{
+								domainId: "domain-2",
+								composeId: "compose-1",
+								networkId: "net-2",
+								host: "staging.example.com",
+							},
+						]),
+					}),
+				}),
+			};
+			vi.mocked(db as any).transaction = vi
+				.fn()
+				.mockImplementation((callback) => callback(mockTx));
+
+			// Try to create domain with net-2
+			await expect(
+				createDomain({
+					composeId: "compose-1",
+					networkId: "net-2",
+					host: "staging.example.com",
+					https: true,
+					port: null,
+					path: null,
+					serviceName: null,
+					domainType: "compose",
+				} as any),
+			).rejects.toThrow(
+				'This compose already has domain "prod.example.com" using network "Production Network". All domains must use the same network due to Docker/Traefik limitations. Please use "Production Network" for all domains.',
+			);
+		});
+
+		it("allows creating domain with same network as existing domains", async () => {
+			// Mock existing domain with net-1
+			vi.mocked(db.query.domains.findMany).mockResolvedValue([
+				{
+					domainId: "domain-1",
+					applicationId: "app-1",
+					networkId: "net-1",
+					host: "prod.example.com",
+				},
+			] as any);
+
+			// Mock findApplicationById
+			const { findApplicationById } = await import(
+				"@dokploy/server/services/application"
+			);
+			vi.mocked(findApplicationById).mockResolvedValue({
+				applicationId: "app-1",
+				serverId: "server-1",
+			} as any);
+
+			// Mock DB transaction to succeed
+			const mockTx = {
+				insert: vi.fn().mockReturnValue({
+					values: vi.fn().mockReturnValue({
+						returning: vi.fn().mockResolvedValue([
+							{
+								domainId: "domain-2",
+								applicationId: "app-1",
+								networkId: "net-1",
+								host: "prod2.example.com",
+							},
+						]),
+					}),
+				}),
+			};
+			vi.mocked(db as any).transaction = vi
+				.fn()
+				.mockImplementation((callback) => callback(mockTx));
+
+			// This should succeed - same network
+			const result = await createDomain({
+				applicationId: "app-1",
+				networkId: "net-1",
+				host: "prod2.example.com",
+				https: true,
+				port: null,
+				path: null,
+				serviceName: null,
+				domainType: "application",
+			} as any);
+
+			expect(result).toBeDefined();
+			expect(result.networkId).toBe("net-1");
+		});
+
+		it("allows creating domain with no network when other domains have no network", async () => {
+			// Mock existing domain with no network
+			vi.mocked(db.query.domains.findMany).mockResolvedValue([
+				{
+					domainId: "domain-1",
+					applicationId: "app-1",
+					networkId: null,
+					host: "default.example.com",
+				},
+			] as any);
+
+			// Mock findApplicationById
+			const { findApplicationById } = await import(
+				"@dokploy/server/services/application"
+			);
+			vi.mocked(findApplicationById).mockResolvedValue({
+				applicationId: "app-1",
+				serverId: "server-1",
+			} as any);
+
+			// Mock DB transaction to succeed
+			const mockTx = {
+				insert: vi.fn().mockReturnValue({
+					values: vi.fn().mockReturnValue({
+						returning: vi.fn().mockResolvedValue([
+							{
+								domainId: "domain-2",
+								applicationId: "app-1",
+								networkId: null,
+								host: "default2.example.com",
+							},
+						]),
+					}),
+				}),
+			};
+			vi.mocked(db as any).transaction = vi
+				.fn()
+				.mockImplementation((callback) => callback(mockTx));
+
+			// This should succeed - both use default network
+			const result = await createDomain({
+				applicationId: "app-1",
+				networkId: null,
+				host: "default2.example.com",
+				https: true,
+				port: null,
+				path: null,
+				serviceName: null,
+				domainType: "application",
+			} as any);
+
+			expect(result).toBeDefined();
+			expect(result.networkId).toBeNull();
+		});
+	});
+
+	describe("updateDomain - Single domain network change", () => {
+		it("allows changing network of the only domain without conflict error", async () => {
+			const { updateDomain } = await import("@dokploy/server/services/domain");
+
+			// Mock existing single domain with net-1
+			vi.mocked(db.query.domains.findFirst).mockResolvedValue({
+				domainId: "domain-1",
+				applicationId: "app-1",
+				networkId: "net-1",
+				host: "local-nginx-47i56k-c87c1a.traefik.me",
+			} as any);
+
+			// Mock findDomainsByApplicationId to return the single domain
+			vi.mocked(db.query.domains.findMany).mockResolvedValue([
+				{
+					domainId: "domain-1",
+					applicationId: "app-1",
+					networkId: "net-1",
+					host: "local-nginx-47i56k-c87c1a.traefik.me",
+				},
+			] as any);
+
+			// Mock findApplicationById
+			const { findApplicationById } = await import(
+				"@dokploy/server/services/application"
+			);
+			vi.mocked(findApplicationById).mockResolvedValue({
+				applicationId: "app-1",
+				serverId: "server-1",
+			} as any);
+
+			// Mock network query to include net-2
+			vi.mocked(findNetworkById).mockImplementation(async (id: string) => {
+				if (id === "net-1") {
+					return {
+						networkId: "net-1",
+						name: "Preprod",
+						networkName: "preprod-network",
+						internal: false,
+						serverId: "server-1",
+						server: { name: "Test Server", serverId: "server-1" },
+					} as any;
+				}
+				if (id === "net-2") {
+					return {
+						networkId: "net-2",
+						name: "Dev",
+						networkName: "dev-network",
+						internal: false,
+						serverId: "server-1",
+						server: { name: "Test Server", serverId: "server-1" },
+					} as any;
+				}
+				throw new TRPCError({
+					code: "NOT_FOUND",
+					message: "Network not found",
+				});
+			});
+
+			// Update application mock to include net-2 in customNetworkIds
+			vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+				applicationId: "app-1",
+				customNetworkIds: ["net-1", "net-2"],
+				serverId: "server-1",
+				server: { name: "Test Server", serverId: "server-1" },
+			} as any);
+
+			// Mock DB update to succeed
+			vi.mocked(db as any).update = vi.fn().mockReturnValue({
+				set: vi.fn().mockReturnValue({
+					where: vi.fn().mockReturnValue({
+						returning: vi.fn().mockResolvedValue([
+							{
+								domainId: "domain-1",
+								applicationId: "app-1",
+								networkId: "net-2",
+								host: "local-nginx-47i56k-c87c1a.traefik.me",
+							},
+						]),
+					}),
+				}),
+			});
+
+			// This should succeed - changing the network of the only domain
+			const result = await updateDomain("domain-1", {
+				networkId: "net-2",
+			});
+
+			expect(result).toBeDefined();
+			expect(result.networkId).toBe("net-2");
+		});
+	});
+});
diff --git a/apps/dokploy/__test__/network/network-service.test.ts b/apps/dokploy/__test__/network/network-service.test.ts
new file mode 100644
index 0000000000..faa09c0e53
--- /dev/null
+++ b/apps/dokploy/__test__/network/network-service.test.ts
@@ -0,0 +1,700 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock Docker utilities first
+vi.mock("@dokploy/server/utils/docker/network-utils", () => ({
+	createDockerNetwork: vi.fn().mockResolvedValue({ id: "docker-net-123" }),
+	removeDockerNetwork: vi.fn().mockResolvedValue(undefined),
+	dockerNetworkExists: vi.fn().mockResolvedValue(false),
+	inspectDockerNetwork: vi
+		.fn()
+		.mockResolvedValue({ Id: "docker-net-123", Name: "test-network" }),
+	listDockerNetworks: vi.fn().mockResolvedValue([]),
+	ensureTraefikConnectedToNetwork: vi.fn().mockResolvedValue(undefined),
+	ensureTraefikDisconnectedFromNetwork: vi.fn().mockResolvedValue(undefined),
+}));
+
+// Mock database
+vi.mock("@dokploy/server/db", () => ({
+	db: {
+		query: {
+			networks: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+			applications: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+			compose: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+			postgres: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+			mysql: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+			mariadb: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+			mongo: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+			redis: {
+				findFirst: vi.fn(),
+				findMany: vi.fn(),
+			},
+			organization: {
+				findFirst: vi.fn(),
+			},
+			projects: {
+				findFirst: vi.fn(),
+			},
+		},
+		insert: vi.fn(() => ({
+			values: vi.fn(() => ({
+				returning: vi.fn().mockResolvedValue([
+					{
+						networkId: "net-123",
+						name: "Test Network",
+						networkName: "test-network",
+						driver: "bridge",
+						organizationId: "org-1",
+					},
+				]),
+			})),
+		})),
+		update: vi.fn(() => ({
+			set: vi.fn(() => ({
+				where: vi.fn(() => ({
+					returning: vi.fn().mockResolvedValue([
+						{
+							networkId: "net-123",
+							name: "Updated Network",
+						},
+					]),
+				})),
+			})),
+		})),
+		delete: vi.fn(() => ({
+			where: vi.fn(() => ({
+				returning: vi.fn().mockResolvedValue([
+					{
+						networkId: "net-123",
+						name: "Deleted Network",
+					},
+				]),
+			})),
+		})),
+	},
+}));
+
+import { db } from "@dokploy/server/db";
+import {
+	assignNetworkToResource,
+	connectTraefikToResourceNetworks,
+	createNetwork,
+	deleteNetwork,
+	importOrphanedNetworks,
+	removeNetworkFromResource,
+	syncNetworks,
+	updateNetwork,
+} from "@dokploy/server/services/network";
+import {
+	dockerNetworkExists,
+	ensureTraefikConnectedToNetwork,
+	ensureTraefikDisconnectedFromNetwork,
+	inspectDockerNetwork,
+	listDockerNetworks,
+	removeDockerNetwork,
+} from "@dokploy/server/utils/docker/network-utils";
+
+describe("createNetwork", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue(null);
+		vi.mocked(dockerNetworkExists).mockResolvedValue(false);
+	});
+
+	it("creates network with Docker and DB", async () => {
+		const input = {
+			name: "My Network",
+			networkName: "my-network",
+			driver: "bridge" as const,
+			organizationId: "org-1",
+		};
+
+		const result = await createNetwork(input);
+
+		expect(result.networkId).toBe("net-123");
+		expect(result.name).toBe("Test Network");
+		expect(dockerNetworkExists).toHaveBeenCalledWith("my-network", undefined);
+		expect(inspectDockerNetwork).toHaveBeenCalled();
+	});
+
+	it("throws on duplicate network name in organization", async () => {
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "existing-net",
+			networkName: "existing-network",
+			organizationId: "org-1",
+		} as any);
+
+		const input = {
+			name: "Duplicate",
+			networkName: "existing-network",
+			organizationId: "org-1",
+		};
+
+		await expect(createNetwork(input)).rejects.toThrow("already exists");
+	});
+
+	it("throws when Docker network already exists", async () => {
+		vi.mocked(dockerNetworkExists).mockResolvedValue(true);
+
+		const input = {
+			name: "Test",
+			networkName: "existing-docker-net",
+			organizationId: "org-1",
+		};
+
+		await expect(createNetwork(input)).rejects.toThrow(
+			"Docker network 'existing-docker-net' already exists",
+		);
+	});
+
+	it("creates network with IPAM configuration", async () => {
+		const input = {
+			name: "IPAM Network",
+			networkName: "ipam-net",
+			organizationId: "org-1",
+			subnet: "172.20.0.0/16",
+			gateway: "172.20.0.1",
+			ipRange: "172.20.10.0/24",
+		};
+
+		await createNetwork(input);
+
+		expect(inspectDockerNetwork).toHaveBeenCalled();
+	});
+});
+
+describe("updateNetwork", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-123",
+			name: "Original Network",
+			organizationId: "org-1",
+			project: null,
+			server: null,
+		} as any);
+	});
+
+	it("updates network metadata", async () => {
+		const updates = {
+			name: "Updated Name",
+			description: "New description",
+		};
+
+		const result = await updateNetwork("net-123", updates);
+
+		expect(result.name).toBe("Updated Network");
+		expect(db.update).toHaveBeenCalled();
+	});
+});
+
+describe("deleteNetwork", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-123",
+			networkName: "test-network",
+			serverId: null,
+			project: null,
+			server: null,
+		} as any);
+
+		// Mock isNetworkInUse checks - must return undefined for unused
+		vi.mocked(db.query.applications.findMany).mockResolvedValue([]);
+		vi.mocked(db.query.compose.findMany).mockResolvedValue([]);
+		vi.mocked(db.query.postgres.findMany).mockResolvedValue([]);
+		vi.mocked(db.query.mysql.findMany).mockResolvedValue([]);
+		vi.mocked(db.query.mariadb.findMany).mockResolvedValue([]);
+		vi.mocked(db.query.mongo.findMany).mockResolvedValue([]);
+		vi.mocked(db.query.redis.findMany).mockResolvedValue([]);
+
+		// Mock inspectDockerNetwork for container check
+		vi.mocked(inspectDockerNetwork).mockResolvedValue({
+			Id: "docker-net-123",
+			Name: "test-network",
+			Containers: {},
+		} as any);
+	});
+
+	it("deletes unused network", async () => {
+		const result = await deleteNetwork("net-123");
+
+		expect(result.name).toBe("Deleted Network");
+		expect(removeDockerNetwork).toHaveBeenCalledWith("test-network", null);
+		expect(db.delete).toHaveBeenCalled();
+	});
+
+	it("throws when network is in use by application", async () => {
+		vi.mocked(db.query.applications.findMany).mockResolvedValue([
+			{
+				applicationId: "app-1",
+				customNetworkIds: ["net-123"],
+			} as any,
+		]);
+
+		await expect(deleteNetwork("net-123")).rejects.toThrow(
+			"Cannot delete network that is in use",
+		);
+	});
+
+	it("continues deletion if Docker removal fails", async () => {
+		vi.mocked(removeDockerNetwork).mockRejectedValue(new Error("Docker error"));
+
+		await expect(deleteNetwork("net-123")).rejects.toThrow(
+			"Failed to remove Docker network",
+		);
+	});
+});
+
+describe("assignNetworkToResource", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-123",
+			networkName: "test-network",
+			driver: "bridge",
+			project: null,
+			server: null,
+		} as any);
+	});
+
+	it("assigns bridge network to compose (docker-compose mode)", async () => {
+		vi.mocked(db.query.compose.findFirst).mockResolvedValue({
+			composeId: "compose-1",
+			customNetworkIds: [],
+			composeType: "docker-compose",
+		} as any);
+
+		const result = await assignNetworkToResource(
+			"net-123",
+			"compose-1",
+			"compose",
+		);
+
+		expect(result.success).toBe(true);
+		// Traefik connection is deferred until a domain is added
+		expect(ensureTraefikConnectedToNetwork).not.toHaveBeenCalled();
+	});
+
+	it("throws when assigning bridge network to swarm service", async () => {
+		vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+			applicationId: "app-1",
+			customNetworkIds: [],
+		} as any);
+
+		await expect(
+			assignNetworkToResource("net-123", "app-1", "application"),
+		).rejects.toThrow("requires an overlay network");
+	});
+
+	it("allows overlay network for swarm services", async () => {
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-123",
+			networkName: "overlay-net",
+			driver: "overlay",
+			project: null,
+			server: null,
+		} as any);
+
+		vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+			applicationId: "app-1",
+			customNetworkIds: [],
+		} as any);
+
+		const result = await assignNetworkToResource(
+			"net-123",
+			"app-1",
+			"application",
+		);
+
+		expect(result.success).toBe(true);
+	});
+
+	it("throws when network already assigned", async () => {
+		vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+			applicationId: "app-1",
+			customNetworkIds: ["net-123"],
+		} as any);
+
+		await expect(
+			assignNetworkToResource("net-123", "app-1", "application"),
+		).rejects.toThrow("already assigned");
+	});
+
+	it("does not connect Traefik on network assignment (deferred until domain is added)", async () => {
+		vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+			applicationId: "app-1",
+			customNetworkIds: [],
+			serverId: "server-1",
+		} as any);
+
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-123",
+			networkName: "overlay-net",
+			driver: "overlay",
+			serverId: "server-1",
+			project: null,
+			server: { name: "Test Server", serverId: "server-1" },
+		} as any);
+
+		await assignNetworkToResource("net-123", "app-1", "application");
+
+		// Traefik connection is deferred until a domain is added to the resource
+		expect(ensureTraefikConnectedToNetwork).not.toHaveBeenCalled();
+	});
+});
+
+describe("removeNetworkFromResource", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-123",
+			networkName: "test-network",
+			serverId: "server-1",
+			project: null,
+			server: null,
+		} as any);
+
+		vi.mocked(db.query.applications.findMany).mockResolvedValue([]);
+		vi.mocked(db.query.compose.findMany).mockResolvedValue([]);
+	});
+
+	it("removes network from resource", async () => {
+		vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+			applicationId: "app-1",
+			customNetworkIds: ["net-123", "net-456"],
+		} as any);
+
+		const result = await removeNetworkFromResource(
+			"net-123",
+			"app-1",
+			"application",
+		);
+
+		expect(result.success).toBe(true);
+		expect(db.update).toHaveBeenCalled();
+	});
+
+	it("disconnects Traefik when no resources with domains use network", async () => {
+		vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+			applicationId: "app-1",
+			customNetworkIds: ["net-123"],
+		} as any);
+
+		await removeNetworkFromResource("net-123", "app-1", "application");
+
+		expect(ensureTraefikDisconnectedFromNetwork).toHaveBeenCalledWith(
+			"test-network",
+			"server-1",
+		);
+	});
+
+	it("keeps Traefik connected when other resources with domains use network", async () => {
+		vi.mocked(db.query.applications.findFirst).mockResolvedValue({
+			applicationId: "app-1",
+			customNetworkIds: ["net-123"],
+		} as any);
+
+		vi.mocked(db.query.applications.findMany).mockResolvedValue([
+			{
+				applicationId: "app-2",
+				customNetworkIds: ["net-123"],
+				domains: [{ domainId: "domain-1" }],
+			} as any,
+		]);
+
+		await removeNetworkFromResource("net-123", "app-1", "application");
+
+		expect(ensureTraefikDisconnectedFromNetwork).not.toHaveBeenCalled();
+	});
+});
+
+describe("syncNetworks", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("detects missing networks (in DB, not in Docker)", async () => {
+		vi.mocked(listDockerNetworks).mockResolvedValue([]);
+		vi.mocked(db.query.networks.findMany).mockResolvedValue([
+			{
+				networkId: "net-1",
+				networkName: "missing-network",
+			} as any,
+		]);
+
+		const result = await syncNetworks();
+
+		expect(result.missing).toEqual(["missing-network"]);
+		expect(result.orphaned).toEqual([]);
+	});
+
+	it("detects orphaned networks (in Docker, not in DB)", async () => {
+		vi.mocked(listDockerNetworks).mockResolvedValue([
+			{
+				Name: "orphan-network",
+				Id: "docker-123",
+				Labels: { "com.dokploy.organization.id": "org-1" },
+			} as any,
+		]);
+		vi.mocked(db.query.networks.findMany).mockResolvedValue([]);
+
+		const result = await syncNetworks();
+
+		expect(result.missing).toEqual([]);
+		expect(result.orphaned).toEqual(["orphan-network"]);
+	});
+
+	it("ignores Docker networks without Dokploy labels", async () => {
+		vi.mocked(listDockerNetworks).mockResolvedValue([
+			{
+				Name: "bridge",
+				Id: "bridge-id",
+				Labels: {},
+			} as any,
+		]);
+		vi.mocked(db.query.networks.findMany).mockResolvedValue([]);
+
+		const result = await syncNetworks();
+
+		expect(result.orphaned).toEqual([]);
+	});
+
+	it("detects both missing and orphaned networks", async () => {
+		vi.mocked(listDockerNetworks).mockResolvedValue([
+			{
+				Name: "orphan-1",
+				Id: "docker-1",
+				Labels: { "com.dokploy.organization.id": "org-1" },
+			} as any,
+		]);
+		vi.mocked(db.query.networks.findMany).mockResolvedValue([
+			{
+				networkId: "net-1",
+				networkName: "missing-1",
+			} as any,
+		]);
+
+		const result = await syncNetworks();
+
+		expect(result.missing).toEqual(["missing-1"]);
+		expect(result.orphaned).toEqual(["orphan-1"]);
+	});
+});
+
+describe("importOrphanedNetworks", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue(null);
+	});
+
+	it("imports Docker networks with Dokploy labels", async () => {
+		vi.mocked(listDockerNetworks).mockResolvedValue([
+			{
+				Name: "custom-network",
+				Id: "docker-456",
+				Driver: "bridge",
+				Labels: {
+					"com.dokploy.organization.id": "org-1",
+					"com.dokploy.network.name": "Custom Network",
+				},
+			} as any,
+		]);
+
+		vi.mocked(inspectDockerNetwork).mockResolvedValue({
+			Id: "docker-456",
+			Attachable: true,
+			Internal: false,
+			IPAM: {
+				Config: [
+					{
+						Subnet: "172.20.0.0/16",
+						Gateway: "172.20.0.1",
+					},
+				],
+			},
+		} as any);
+
+		// Mock organization exists
+		vi.mocked(db.query.organization.findFirst).mockResolvedValue({
+			id: "org-1",
+			name: "Test Org",
+		} as any);
+
+		const result = await importOrphanedNetworks();
+
+		expect(result.imported).toHaveLength(1);
+		expect(result.errors).toHaveLength(0);
+	});
+
+	it("skips networks without Dokploy organization label", async () => {
+		vi.mocked(listDockerNetworks).mockResolvedValue([
+			{
+				Name: "bridge",
+				Id: "bridge-id",
+				Labels: {},
+			} as any,
+		]);
+
+		const result = await importOrphanedNetworks();
+
+		expect(result.imported).toHaveLength(0);
+		expect(result.errors).toHaveLength(0);
+	});
+
+	it("skips networks already in DB", async () => {
+		vi.mocked(listDockerNetworks).mockResolvedValue([
+			{
+				Name: "existing-network",
+				Id: "docker-789",
+				Labels: { "com.dokploy.organization.id": "org-1" },
+			} as any,
+		]);
+
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-1",
+			networkName: "existing-network",
+		} as any);
+
+		const result = await importOrphanedNetworks();
+
+		expect(result.imported).toHaveLength(0);
+	});
+
+	it("handles import errors gracefully", async () => {
+		vi.mocked(listDockerNetworks).mockResolvedValue([
+			{
+				Name: "error-network",
+				Id: "docker-error",
+				Labels: { "com.dokploy.organization.id": "org-1" },
+			} as any,
+		]);
+
+		vi.mocked(inspectDockerNetwork).mockRejectedValue(
+			new Error("Inspect failed"),
+		);
+
+		const result = await importOrphanedNetworks();
+
+		expect(result.imported).toHaveLength(0);
+		expect(result.errors).toHaveLength(1);
+		expect(result.errors[0]?.networkName).toBe("error-network");
+	});
+});
+
+describe("connectTraefikToResourceNetworks", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("connects Traefik to specific domain network when domainNetworkId is provided", async () => {
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-1",
+			networkName: "custom-network",
+			internal: false,
+		} as any);
+
+		await connectTraefikToResourceNetworks(
+			"app-1",
+			"application",
+			undefined,
+			"net-1",
+		);
+
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenCalledTimes(1);
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenCalledWith(
+			"custom-network",
+			undefined,
+		);
+	});
+
+	it("connects to dokploy-network when no domainNetworkId is provided", async () => {
+		await connectTraefikToResourceNetworks(
+			"app-1",
+			"application",
+			undefined,
+			null,
+		);
+
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenCalledTimes(1);
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenCalledWith(
+			"dokploy-network",
+			undefined,
+		);
+	});
+
+	it("falls back to dokploy-network when domain network is internal", async () => {
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-1",
+			networkName: "internal-network",
+			internal: true,
+		} as any);
+
+		await connectTraefikToResourceNetworks(
+			"app-1",
+			"application",
+			undefined,
+			"net-1",
+		);
+
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenCalledTimes(1);
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenCalledWith(
+			"dokploy-network",
+			undefined,
+		);
+	});
+
+	it("continues on Traefik connection errors and falls back to dokploy-network", async () => {
+		vi.mocked(db.query.networks.findFirst).mockResolvedValue({
+			networkId: "net-1",
+			networkName: "custom-network",
+			internal: false,
+		} as any);
+
+		vi.mocked(ensureTraefikConnectedToNetwork).mockRejectedValueOnce(
+			new Error("Connection failed"),
+		);
+
+		await expect(
+			connectTraefikToResourceNetworks(
+				"app-1",
+				"application",
+				undefined,
+				"net-1",
+			),
+		).resolves.not.toThrow();
+
+		// Should be called twice: once for custom-network (fails), once for fallback
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenCalledTimes(2);
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenNthCalledWith(
+			1,
+			"custom-network",
+			undefined,
+		);
+		expect(ensureTraefikConnectedToNetwork).toHaveBeenNthCalledWith(
+			2,
+			"dokploy-network",
+			undefined,
+		);
+	});
+});
diff --git a/apps/dokploy/__test__/network/schema.test.ts b/apps/dokploy/__test__/network/schema.test.ts
new file mode 100644
index 0000000000..e716aaef95
--- /dev/null
+++ b/apps/dokploy/__test__/network/schema.test.ts
@@ -0,0 +1,326 @@
+import {
+	apiAssignNetworkToResource,
+	apiCreateNetwork,
+	apiRemoveNetworkFromResource,
+	apiUpdateNetwork,
+} from "@dokploy/server/db/schema";
+import { describe, expect, it } from "vitest";
+
+describe("Network Schema Validation", () => {
+	describe("apiCreateNetwork", () => {
+		it("validates correct network creation with all fields", () => {
+			const validNetwork = {
+				name: "My Production Network",
+				description: "Network for production services",
+				networkName: "prod-network",
+				driver: "bridge" as const,
+				subnet: "172.20.0.0/16",
+				gateway: "172.20.0.1",
+				ipRange: "172.20.10.0/24",
+				attachable: true,
+				internal: false,
+				organizationId: "org-123",
+				projectId: "proj-456",
+				serverId: "server-789",
+			};
+
+			expect(() => apiCreateNetwork.parse(validNetwork)).not.toThrow();
+		});
+
+		it("validates minimal required fields", () => {
+			const minimalNetwork = {
+				name: "Test Network",
+				networkName: "test-net",
+				organizationId: "org-123",
+			};
+
+			expect(() => apiCreateNetwork.parse(minimalNetwork)).not.toThrow();
+		});
+
+		it("validates overlay driver", () => {
+			const overlayNetwork = {
+				name: "Swarm Network",
+				networkName: "swarm-net",
+				driver: "overlay" as const,
+				organizationId: "org-123",
+			};
+
+			expect(() => apiCreateNetwork.parse(overlayNetwork)).not.toThrow();
+		});
+
+		describe("networkName validation", () => {
+			it("accepts valid network names", () => {
+				const validNames = [
+					"simple",
+					"with-hyphens",
+					"with_underscores",
+					"with.dots",
+					"AlphaNumerics123",
+					"a1b2c3",
+				];
+
+				for (const name of validNames) {
+					expect(() =>
+						apiCreateNetwork.parse({
+							name: "Test",
+							networkName: name,
+							organizationId: "org-1",
+						}),
+					).not.toThrow();
+				}
+			});
+
+			it("rejects network names starting with non-alphanumeric", () => {
+				const invalidNames = ["-starts-with-hyphen", "_starts-with-underscore"];
+
+				for (const name of invalidNames) {
+					expect(() =>
+						apiCreateNetwork.parse({
+							name: "Test",
+							networkName: name,
+							organizationId: "org-1",
+						}),
+					).toThrow();
+				}
+			});
+
+			it("rejects empty network name", () => {
+				expect(() =>
+					apiCreateNetwork.parse({
+						name: "Test",
+						networkName: "",
+						organizationId: "org-1",
+					}),
+				).toThrow();
+			});
+
+			it("rejects network name exceeding 63 characters", () => {
+				const longName = "a".repeat(64);
+				expect(() =>
+					apiCreateNetwork.parse({
+						name: "Test",
+						networkName: longName,
+						organizationId: "org-1",
+					}),
+				).toThrow();
+			});
+		});
+
+		describe("subnet validation (CIDR)", () => {
+			it("accepts valid CIDR formats", () => {
+				const validSubnets = [
+					"172.20.0.0/16",
+					"10.0.0.0/8",
+					"192.168.1.0/24",
+					"172.31.0.0/20",
+					"10.10.10.0/32",
+				];
+
+				for (const subnet of validSubnets) {
+					expect(() =>
+						apiCreateNetwork.parse({
+							name: "Test",
+							networkName: "test-net",
+							subnet,
+							organizationId: "org-1",
+						}),
+					).not.toThrow();
+				}
+			});
+
+			it("rejects invalid CIDR formats", () => {
+				const invalidSubnets = [
+					"172.20.0.0", // Missing CIDR notation
+					"172.20.0.0/33", // Invalid CIDR range (max 32)
+					"256.0.0.0/16", // Invalid IP (256)
+					"172.20/16", // Incomplete IP
+					"not-an-ip/16",
+				];
+
+				for (const subnet of invalidSubnets) {
+					expect(() =>
+						apiCreateNetwork.parse({
+							name: "Test",
+							networkName: "test-net",
+							subnet,
+							organizationId: "org-1",
+						}),
+					).toThrow();
+				}
+			});
+		});
+
+		describe("gateway validation (IPv4)", () => {
+			it("accepts valid IPv4 addresses", () => {
+				const validGateways = [
+					"172.20.0.1",
+					"10.0.0.1",
+					"192.168.1.1",
+					"255.255.255.255",
+					"0.0.0.0",
+				];
+
+				for (const gateway of validGateways) {
+					expect(() =>
+						apiCreateNetwork.parse({
+							name: "Test",
+							networkName: "test-net",
+							gateway,
+							organizationId: "org-1",
+						}),
+					).not.toThrow();
+				}
+			});
+
+			it("rejects invalid IPv4 addresses", () => {
+				const invalidGateways = [
+					"256.0.0.1", // Octet > 255
+					"172.20.0", // Incomplete
+					"172.20.0.1.5", // Extra octet
+					"not-an-ip",
+					"172.20.0.1/24", // CIDR notation (not allowed for gateway)
+				];
+
+				for (const gateway of invalidGateways) {
+					expect(() =>
+						apiCreateNetwork.parse({
+							name: "Test",
+							networkName: "test-net",
+							gateway,
+							organizationId: "org-1",
+						}),
+					).toThrow();
+				}
+			});
+		});
+
+		describe("ipRange validation (CIDR)", () => {
+			it("accepts valid IP range CIDR", () => {
+				const validRanges = ["172.20.10.0/24", "10.0.1.0/28", "192.168.1.0/26"];
+
+				for (const ipRange of validRanges) {
+					expect(() =>
+						apiCreateNetwork.parse({
+							name: "Test",
+							networkName: "test-net",
+							ipRange,
+							organizationId: "org-1",
+						}),
+					).not.toThrow();
+				}
+			});
+
+			it("rejects invalid IP range formats", () => {
+				const invalidRanges = ["172.20.10.0", "not-a-range", "256.0.0.0/24"];
+
+				for (const ipRange of invalidRanges) {
+					expect(() =>
+						apiCreateNetwork.parse({
+							name: "Test",
+							networkName: "test-net",
+							ipRange,
+							organizationId: "org-1",
+						}),
+					).toThrow();
+				}
+			});
+		});
+	});
+
+	describe("apiUpdateNetwork", () => {
+		it("validates partial network update", () => {
+			const partialUpdate = {
+				networkId: "net-123",
+				name: "Updated Name",
+				description: "Updated description",
+			};
+
+			expect(() => apiUpdateNetwork.parse(partialUpdate)).not.toThrow();
+		});
+
+		it("requires networkId", () => {
+			const missingId = {
+				name: "Updated Name",
+			};
+
+			expect(() => apiUpdateNetwork.parse(missingId)).toThrow();
+		});
+	});
+
+	describe("apiAssignNetworkToResource", () => {
+		it("validates correct assignment", () => {
+			const validAssignment = {
+				networkId: "net-123",
+				resourceId: "app-456",
+				resourceType: "application" as const,
+			};
+
+			expect(() =>
+				apiAssignNetworkToResource.parse(validAssignment),
+			).not.toThrow();
+		});
+
+		it("validates all resource types", () => {
+			const resourceTypes = [
+				"application",
+				"compose",
+				"postgres",
+				"mysql",
+				"mariadb",
+				"mongo",
+				"redis",
+			] as const;
+
+			for (const resourceType of resourceTypes) {
+				expect(() =>
+					apiAssignNetworkToResource.parse({
+						networkId: "net-1",
+						resourceId: "res-1",
+						resourceType,
+					}),
+				).not.toThrow();
+			}
+		});
+
+		it("rejects invalid resource type", () => {
+			expect(() =>
+				apiAssignNetworkToResource.parse({
+					networkId: "net-1",
+					resourceId: "res-1",
+					resourceType: "invalid-type",
+				}),
+			).toThrow();
+		});
+
+		it("requires all fields", () => {
+			expect(() =>
+				apiAssignNetworkToResource.parse({
+					networkId: "net-1",
+					resourceId: "res-1",
+				}),
+			).toThrow();
+		});
+	});
+
+	describe("apiRemoveNetworkFromResource", () => {
+		it("validates correct removal", () => {
+			const validRemoval = {
+				networkId: "net-123",
+				resourceId: "app-456",
+				resourceType: "application" as const,
+			};
+
+			expect(() =>
+				apiRemoveNetworkFromResource.parse(validRemoval),
+			).not.toThrow();
+		});
+
+		it("requires all fields", () => {
+			expect(() =>
+				apiRemoveNetworkFromResource.parse({
+					networkId: "net-1",
+				}),
+			).toThrow();
+		});
+	});
+});
diff --git a/apps/dokploy/__test__/traefik/traefik.test.ts b/apps/dokploy/__test__/traefik/traefik.test.ts
index 9121dc8a1f..e98b7d6844 100644
--- a/apps/dokploy/__test__/traefik/traefik.test.ts
+++ b/apps/dokploy/__test__/traefik/traefik.test.ts
@@ -48,6 +48,7 @@ const baseApp: ApplicationNested = {
 	previewLimit: 0,
 	previewCustomCertResolver: null,
 	previewWildcard: "",
+	previewNetworkIds: null,
 	environmentId: "",
 	environment: {
 		env: "",
@@ -125,6 +126,7 @@ const baseApp: ApplicationNested = {
 	username: null,
 	dockerContextPath: null,
 	stopGracePeriodSwarm: null,
+	customNetworkIds: null,
 	ulimitsSwarm: null,
 };
 
@@ -145,6 +147,7 @@ const baseDomain: Domain = {
 	previewDeploymentId: "",
 	internalPath: "/",
 	stripPath: false,
+	networkId: null,
 };
 
 const baseRedirect: Redirect = {
diff --git a/apps/dokploy/components/dashboard/application/domains/handle-domain.tsx b/apps/dokploy/components/dashboard/application/domains/handle-domain.tsx
index 6af0e1e8c9..a0cd0666bb 100644
--- a/apps/dokploy/components/dashboard/application/domains/handle-domain.tsx
+++ b/apps/dokploy/components/dashboard/application/domains/handle-domain.tsx
@@ -66,6 +66,7 @@ export const domain = z
 		customCertResolver: z.string().optional(),
 		serviceName: z.string().optional(),
 		domainType: z.enum(["application", "compose", "preview"]).optional(),
+		networkId: z.string().nullable().optional(),
 	})
 	.superRefine((input, ctx) => {
 		if (input.https && !input.certificateType) {
@@ -188,6 +189,17 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 		},
 	);
 
+	const { data: availableNetworks, isLoading: isLoadingNetworks } =
+		api.network.getResourceNetworksForDomain.useQuery(
+			{
+				resourceId: id,
+				resourceType: type,
+			},
+			{
+				enabled: !!id,
+			},
+		);
+
 	const form = useForm<Domain>({
 		resolver: zodResolver(domain),
 		defaultValues: {
@@ -201,6 +213,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 			customCertResolver: undefined,
 			serviceName: undefined,
 			domainType: type,
+			networkId: null,
 		},
 		mode: "onChange",
 	});
@@ -224,6 +237,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 				customCertResolver: data?.customCertResolver || undefined,
 				serviceName: data?.serviceName || undefined,
 				domainType: data?.domainType || type,
+				networkId: data?.networkId ?? null, // Keep null as is for proper Select handling
 			});
 		}
 
@@ -238,10 +252,33 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 				certificateType: undefined,
 				customCertResolver: undefined,
 				domainType: type,
+				networkId: null,
 			});
 		}
 	}, [form, data, isLoading, domainId]);
 
+	useEffect(() => {
+		if (
+			!domainId &&
+			!isLoadingNetworks &&
+			availableNetworks &&
+			availableNetworks.length > 0
+		) {
+			const currentNetworkId = form.getValues("networkId");
+
+			if (currentNetworkId === null) {
+				const firstNetwork = availableNetworks[0];
+				if (firstNetwork) {
+					const networkValue =
+						firstNetwork.networkId === "default"
+							? null
+							: firstNetwork.networkId;
+					form.setValue("networkId", networkValue);
+				}
+			}
+		}
+	}, [domainId, isLoadingNetworks, availableNetworks, form]);
+
 	// Separate effect for handling custom cert resolver validation
 	useEffect(() => {
 		if (certificateType === "custom") {
@@ -484,6 +521,57 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 										</div>
 									)}
 								</div>
+								<FormField
+									control={form.control}
+									name="networkId"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Routing Network (Optional)</FormLabel>
+											<Select
+												onValueChange={(value) => {
+													// Convert "default" back to null for the form (database stores null, not undefined)
+													const newValue = value === "default" ? null : value;
+													field.onChange(newValue);
+												}}
+												value={field.value ?? "default"}
+											>
+												<FormControl>
+													<SelectTrigger>
+														<SelectValue placeholder="Default (dokploy-network)" />
+													</SelectTrigger>
+												</FormControl>
+												<SelectContent>
+													{isLoadingNetworks ? (
+														<SelectItem value="loading" disabled>
+															Loading networks...
+														</SelectItem>
+													) : availableNetworks &&
+														availableNetworks.length > 0 ? (
+														availableNetworks.map((network) => (
+															<SelectItem
+																key={network.networkId}
+																value={network.networkId}
+															>
+																{network.name} ({network.networkName})
+															</SelectItem>
+														))
+													) : (
+														<SelectItem value="none" disabled>
+															No networks available
+														</SelectItem>
+													)}
+												</SelectContent>
+											</Select>
+											<FormDescription>
+												Select which network Traefik should use to route traffic
+												to this domain. Only non-internal networks available to
+												this {type} are shown.
+											</FormDescription>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+
 								<FormField
 									control={form.control}
 									name="host"
diff --git a/apps/dokploy/components/dashboard/application/domains/show-domains.tsx b/apps/dokploy/components/dashboard/application/domains/show-domains.tsx
index 1fd3d82e90..c9194764a6 100644
--- a/apps/dokploy/components/dashboard/application/domains/show-domains.tsx
+++ b/apps/dokploy/components/dashboard/application/domains/show-domains.tsx
@@ -14,6 +14,7 @@ import Link from "next/link";
 import { useState } from "react";
 import { toast } from "sonner";
 import { DialogAction } from "@/components/shared/dialog-action";
+import { Alert, AlertDescription } from "@/components/ui/alert";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import {
@@ -95,6 +96,16 @@ export const ShowDomains = ({ id, type }: Props) => {
 				},
 			);
 
+	const { data: assignedNetworks } = api.network.getResourceNetworks.useQuery({
+		resourceId: id,
+		resourceType: type,
+	});
+
+	const hasOnlyInternalNetworks =
+		assignedNetworks &&
+		assignedNetworks.length > 0 &&
+		assignedNetworks.every((n) => n.internal);
+
 	const { mutateAsync: validateDomain } =
 		api.domain.validateDomain.useMutation();
 	const { mutateAsync: deleteDomain, isLoading: isRemoving } =
@@ -158,7 +169,18 @@ export const ShowDomains = ({ id, type }: Props) => {
 						)}
 					</div>
 				</CardHeader>
-				<CardContent className="flex w-full flex-row gap-4">
+				<CardContent className="flex w-full flex-col gap-4">
+					{hasOnlyInternalNetworks && data && data.length > 0 && (
+						<Alert variant="destructive">
+							<InfoIcon className="h-4 w-4" />
+							<AlertDescription>
+								This {type} has custom networks assigned, but they are all
+								internal. Domains will not be accessible because Traefik cannot
+								connect to internal networks. Go to the Network tab and assign
+								at least one non-internal network.
+							</AlertDescription>
+						</Alert>
+					)}
 					{isLoadingDomains ? (
 						<div className="flex w-full flex-row gap-4 min-h-[40vh] justify-center items-center">
 							<Loader2 className="size-5 animate-spin text-muted-foreground" />
@@ -298,6 +320,25 @@ export const ShowDomains = ({ id, type }: Props) => {
 														</Tooltip>
 													</TooltipProvider>
 
+													<TooltipProvider>
+														<Tooltip>
+															<TooltipTrigger asChild>
+																<Badge variant="secondary">
+																	<InfoIcon className="size-3 mr-1" />
+																	Network:{" "}
+																	{item.network?.name ||
+																		"Default (dokploy-network)"}
+																</Badge>
+															</TooltipTrigger>
+															<TooltipContent>
+																<p>
+																	Network used by Traefik for routing to this
+																	domain
+																</p>
+															</TooltipContent>
+														</Tooltip>
+													</TooltipProvider>
+
 													<TooltipProvider>
 														<Tooltip>
 															<TooltipTrigger asChild>
diff --git a/apps/dokploy/components/dashboard/application/preview-deployments/add-preview-domain.tsx b/apps/dokploy/components/dashboard/application/preview-deployments/add-preview-domain.tsx
index bb9321a51b..82a48a29e8 100644
--- a/apps/dokploy/components/dashboard/application/preview-deployments/add-preview-domain.tsx
+++ b/apps/dokploy/components/dashboard/application/preview-deployments/add-preview-domain.tsx
@@ -82,6 +82,17 @@ export const AddPreviewDomain = ({
 	const { mutateAsync: generateDomain, isLoading: isLoadingGenerate } =
 		api.domain.generateDomain.useMutation();
 
+	const { data: availableNetworks, isLoading: isLoadingNetworks } =
+		api.network.getAllNetworksByServer.useQuery(
+			{
+				serverId: previewDeployment?.application?.serverId ?? null,
+				resourceType: "application",
+			},
+			{
+				enabled: previewDeployment?.application !== undefined,
+			},
+		);
+
 	const form = useForm<Domain>({
 		resolver: zodResolver(domain),
 	});
@@ -97,6 +108,7 @@ export const AddPreviewDomain = ({
 				path: data?.path || undefined,
 				port: data?.port || undefined,
 				customCertResolver: data?.customCertResolver || undefined,
+				networkId: data?.networkId ?? null,
 			});
 		}
 
@@ -155,6 +167,55 @@ export const AddPreviewDomain = ({
 					>
 						<div className="flex flex-col gap-4">
 							<div className="flex flex-col gap-2">
+								<FormField
+									control={form.control}
+									name="networkId"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Network</FormLabel>
+											<Select
+												onValueChange={(value) => {
+													field.onChange(value === "default" ? null : value);
+												}}
+												value={field.value || "default"}
+											>
+												<FormControl>
+													<SelectTrigger>
+														<SelectValue placeholder="Select a network" />
+													</SelectTrigger>
+												</FormControl>
+												<SelectContent>
+													<SelectItem value="default">
+														Default (dokploy-network)
+													</SelectItem>
+													{isLoadingNetworks ? (
+														<SelectItem value="loading" disabled>
+															Loading networks...
+														</SelectItem>
+													) : availableNetworks &&
+														availableNetworks.length > 0 ? (
+														availableNetworks.map((network) => (
+															<SelectItem
+																key={network.networkId}
+																value={network.networkId}
+															>
+																{network.name} ({network.networkName})
+																{network.internal && " (Internal)"}
+															</SelectItem>
+														))
+													) : null}
+												</SelectContent>
+											</Select>
+											<FormDescription>
+												Select which network Traefik should use to route traffic
+												to this domain. Must be one of the networks configured
+												in the preview deployment settings.
+											</FormDescription>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+
 								<FormField
 									control={form.control}
 									name="host"
diff --git a/apps/dokploy/components/dashboard/application/preview-deployments/show-preview-settings.tsx b/apps/dokploy/components/dashboard/application/preview-deployments/show-preview-settings.tsx
index f8e6fab68a..a7b3e1fd00 100644
--- a/apps/dokploy/components/dashboard/application/preview-deployments/show-preview-settings.tsx
+++ b/apps/dokploy/components/dashboard/application/preview-deployments/show-preview-settings.tsx
@@ -52,6 +52,7 @@ const schema = z
 		port: z.number(),
 		previewLimit: z.number(),
 		previewLabels: z.array(z.string()).optional(),
+		previewNetworkIds: z.array(z.string()).optional(),
 		previewHttps: z.boolean(),
 		previewPath: z.string(),
 		previewCertificateType: z.enum(["letsencrypt", "none", "custom"]),
@@ -85,6 +86,17 @@ export const ShowPreviewSettings = ({ applicationId }: Props) => {
 
 	const { data, refetch } = api.application.one.useQuery({ applicationId });
 
+	const { data: availableNetworks, isLoading: isLoadingNetworks } =
+		api.network.getAllNetworksByServer.useQuery(
+			{
+				serverId: data?.serverId ?? null,
+				resourceType: "application",
+			},
+			{
+				enabled: data !== undefined,
+			},
+		);
+
 	const form = useForm<Schema>({
 		defaultValues: {
 			env: "",
@@ -92,6 +104,7 @@ export const ShowPreviewSettings = ({ applicationId }: Props) => {
 			port: 3000,
 			previewLimit: 3,
 			previewLabels: [],
+			previewNetworkIds: [],
 			previewHttps: false,
 			previewPath: "/",
 			previewCertificateType: "none",
@@ -117,6 +130,7 @@ export const ShowPreviewSettings = ({ applicationId }: Props) => {
 				wildcardDomain: data.previewWildcard || "*.traefik.me",
 				port: data.previewPort || 3000,
 				previewLabels: data.previewLabels || [],
+				previewNetworkIds: data.previewNetworkIds || [],
 				previewLimit: data.previewLimit || 3,
 				previewHttps: data.previewHttps || false,
 				previewPath: data.previewPath || "/",
@@ -136,6 +150,7 @@ export const ShowPreviewSettings = ({ applicationId }: Props) => {
 			previewWildcard: formData.wildcardDomain,
 			previewPort: formData.port,
 			previewLabels: formData.previewLabels,
+			previewNetworkIds: formData.previewNetworkIds,
 			applicationId,
 			previewLimit: formData.previewLimit,
 			previewHttps: formData.previewHttps,
@@ -321,6 +336,60 @@ export const ShowPreviewSettings = ({ applicationId }: Props) => {
 											</FormItem>
 										)}
 									/>
+									<FormField
+										control={form.control}
+										name="previewNetworkIds"
+										render={({ field }) => (
+											<FormItem>
+												<FormLabel>Preview Networks</FormLabel>
+												<FormDescription>
+													Select networks that preview deployments will use.
+													Leave empty to inherit all networks from the
+													application.
+												</FormDescription>
+												<div className="flex flex-wrap gap-2">
+													{isLoadingNetworks ? (
+														<div>Loading networks...</div>
+													) : availableNetworks &&
+														availableNetworks.length > 0 ? (
+														availableNetworks.map((network) => (
+															<Badge
+																key={network.networkId}
+																variant={
+																	field.value?.includes(network.networkId)
+																		? "default"
+																		: "outline"
+																}
+																className="cursor-pointer"
+																onClick={() => {
+																	const current = field.value || [];
+																	if (current.includes(network.networkId)) {
+																		field.onChange(
+																			current.filter(
+																				(id) => id !== network.networkId,
+																			),
+																		);
+																	} else {
+																		field.onChange([
+																			...current,
+																			network.networkId,
+																		]);
+																	}
+																}}
+															>
+																{network.name} ({network.networkName})
+															</Badge>
+														))
+													) : (
+														<p className="text-sm text-muted-foreground">
+															No compatible networks available on this server.
+														</p>
+													)}
+												</div>
+												<FormMessage />
+											</FormItem>
+										)}
+									/>
 									<FormField
 										control={form.control}
 										name="previewHttps"
diff --git a/apps/dokploy/components/dashboard/compose/advanced/add-isolation.tsx b/apps/dokploy/components/dashboard/compose/advanced/add-isolation.tsx
deleted file mode 100644
index 5b6e041544..0000000000
--- a/apps/dokploy/components/dashboard/compose/advanced/add-isolation.tsx
+++ /dev/null
@@ -1,241 +0,0 @@
-import { zodResolver } from "@hookform/resolvers/zod";
-import { AlertTriangle, Loader2 } from "lucide-react";
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { AlertBlock } from "@/components/shared/alert-block";
-import { CodeEditor } from "@/components/shared/code-editor";
-import { Button } from "@/components/ui/button";
-import {
-	Card,
-	CardContent,
-	CardDescription,
-	CardHeader,
-	CardTitle,
-} from "@/components/ui/card";
-import {
-	Dialog,
-	DialogContent,
-	DialogDescription,
-	DialogHeader,
-	DialogTitle,
-} from "@/components/ui/dialog";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-} from "@/components/ui/form";
-
-import { Switch } from "@/components/ui/switch";
-import { api } from "@/utils/api";
-
-interface Props {
-	composeId: string;
-}
-
-// Schema for Isolated Deployment
-const isolatedSchema = z.object({
-	isolatedDeployment: z.boolean().optional(),
-});
-
-type IsolatedSchema = z.infer<typeof isolatedSchema>;
-
-export const IsolatedDeploymentTab = ({ composeId }: Props) => {
-	const utils = api.useUtils();
-	const [compose, setCompose] = useState<string>("");
-	const [isPreviewLoading, setIsPreviewLoading] = useState<boolean>(false);
-	const { mutateAsync, error, isError } =
-		api.compose.isolatedDeployment.useMutation();
-
-	const [isOpenPreview, setIsOpenPreview] = useState<boolean>(false);
-
-	const { mutateAsync: updateCompose } = api.compose.update.useMutation();
-
-	const { data, refetch } = api.compose.one.useQuery(
-		{ composeId },
-		{ enabled: !!composeId },
-	);
-
-	const form = useForm<IsolatedSchema>({
-		defaultValues: {
-			isolatedDeployment: false,
-		},
-		resolver: zodResolver(isolatedSchema),
-	});
-
-	useEffect(() => {
-		if (data) {
-			form.reset({
-				isolatedDeployment: data?.isolatedDeployment || false,
-			});
-		}
-	}, [form, form.reset, form.formState.isSubmitSuccessful, data]);
-
-	const onSubmit = async (formData: IsolatedSchema) => {
-		await updateCompose({
-			composeId,
-			isolatedDeployment: formData?.isolatedDeployment || false,
-		})
-			.then(async (_data) => {
-				await refetch();
-				toast.success("Compose updated");
-			})
-			.catch(() => {
-				toast.error("Error updating the compose");
-			});
-	};
-
-	const generatePreview = async () => {
-		setIsOpenPreview(true);
-		setIsPreviewLoading(true);
-		try {
-			await mutateAsync({
-				composeId,
-				suffix: data?.appName || "",
-			}).then(async (data) => {
-				await utils.project.all.invalidate();
-				setCompose(data);
-			});
-		} catch {
-			toast.error("Error generating preview");
-			setIsOpenPreview(false);
-		} finally {
-			setIsPreviewLoading(false);
-		}
-	};
-
-	return (
-		<Card className="bg-background">
-			<CardHeader>
-				<CardTitle className="text-xl">Enable Isolated Deployment</CardTitle>
-				<CardDescription>
-					Configure isolated deployment to the compose file.
-					<div className="text-sm text-muted-foreground flex flex-col gap-2">
-						<span>
-							This feature creates an isolated environment for your deployment
-							by adding unique prefixes to all resources. It establishes a
-							dedicated network based on your compose file's name, ensuring your
-							services run in isolation. This prevents conflicts when running
-							multiple instances of the same template or services with identical
-							names.
-						</span>
-						<div className="space-y-4">
-							<div>
-								<h4 className="font-medium mb-2">
-									Resources that will be isolated:
-								</h4>
-								<ul className="list-disc list-inside">
-									<li>Docker networks</li>
-								</ul>
-							</div>
-						</div>
-					</div>
-				</CardDescription>
-			</CardHeader>
-			<CardContent>
-				<div className="space-y-4">
-					{isError && <AlertBlock type="error">{error?.message}</AlertBlock>}
-					<Form {...form}>
-						<form
-							onSubmit={form.handleSubmit(onSubmit)}
-							id="isolated-deployment-form"
-							className="grid w-full gap-4"
-						>
-							{isError && (
-								<div className="flex flex-row gap-4 rounded-lg items-center bg-red-50 p-2 dark:bg-red-950">
-									<AlertTriangle className="text-red-600 dark:text-red-400" />
-									<span className="text-sm text-red-600 dark:text-red-400">
-										{error?.message}
-									</span>
-								</div>
-							)}
-
-							<div className="flex flex-col lg:flex-col gap-4 w-full">
-								<div>
-									<FormField
-										control={form.control}
-										name="isolatedDeployment"
-										render={({ field }) => (
-											<FormItem className="mt-4 flex flex-row items-center justify-between rounded-lg border p-3 shadow-sm">
-												<div className="space-y-0.5">
-													<FormLabel>
-														Enable Isolated Deployment ({data?.appName})
-													</FormLabel>
-													<FormDescription>
-														Enable isolated deployment to the compose file.
-													</FormDescription>
-												</div>
-												<FormControl>
-													<Switch
-														checked={field.value}
-														onCheckedChange={field.onChange}
-													/>
-												</FormControl>
-											</FormItem>
-										)}
-									/>
-								</div>
-
-								<div className="flex flex-col lg:flex-row gap-4 w-full items-end justify-end">
-									<Button
-										form="isolated-deployment-form"
-										type="submit"
-										className="lg:w-fit"
-										isLoading={form.formState.isSubmitting}
-									>
-										Save
-									</Button>
-								</div>
-							</div>
-
-							<div className="flex flex-col lg:flex-row gap-4 w-full items-end justify-end">
-								<Button
-									onClick={generatePreview}
-									isLoading={isPreviewLoading}
-									variant="secondary"
-									className="lg:w-fit"
-								>
-									Preview Compose
-								</Button>
-								<Dialog open={isOpenPreview} onOpenChange={setIsOpenPreview}>
-									<DialogContent className="sm:max-w-6xl max-h-[80vh]">
-										<DialogHeader>
-											<DialogTitle>Isolated Deployment Preview</DialogTitle>
-											<DialogDescription>
-												Preview of the compose file with isolated deployment
-												configuration
-											</DialogDescription>
-										</DialogHeader>
-										<div className="flex flex-col gap-4 overflow-auto">
-											{isPreviewLoading ? (
-												<div className="flex flex-col items-center justify-center py-12 gap-4">
-													<Loader2 className="w-8 h-8 animate-spin text-muted-foreground" />
-													<p className="text-muted-foreground">
-														Generating compose preview...
-													</p>
-												</div>
-											) : (
-												<pre>
-													<CodeEditor
-														value={compose || ""}
-														language="yaml"
-														readOnly
-														height="60vh"
-													/>
-												</pre>
-											)}
-										</div>
-									</DialogContent>
-								</Dialog>
-							</div>
-						</form>
-					</Form>
-				</div>
-			</CardContent>
-		</Card>
-	);
-};
diff --git a/apps/dokploy/components/dashboard/network/assign-network-to-resource.tsx b/apps/dokploy/components/dashboard/network/assign-network-to-resource.tsx
new file mode 100644
index 0000000000..2721a26416
--- /dev/null
+++ b/apps/dokploy/components/dashboard/network/assign-network-to-resource.tsx
@@ -0,0 +1,352 @@
+import { Info, Network, Plus, X } from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+import { Alert, AlertDescription } from "@/components/ui/alert";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+	Card,
+	CardContent,
+	CardDescription,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import {
+	Command,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+} from "@/components/ui/command";
+import {
+	Popover,
+	PopoverContent,
+	PopoverTrigger,
+} from "@/components/ui/popover";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { api } from "@/utils/api";
+
+interface Props {
+	resourceId: string;
+	resourceType:
+		| "application"
+		| "compose"
+		| "postgres"
+		| "mysql"
+		| "mariadb"
+		| "mongo"
+		| "redis";
+	composeType?: "docker-compose" | "stack";
+	showCard?: boolean;
+}
+
+const getResourceTypeName = (type: Props["resourceType"]): string => {
+	const names: Record<Props["resourceType"], string> = {
+		application: "application",
+		compose: "compose service",
+		postgres: "database",
+		mysql: "database",
+		mariadb: "database",
+		mongo: "database",
+		redis: "database",
+	};
+	return names[type];
+};
+
+const isSwarmResource = (
+	type: Props["resourceType"],
+	composeType?: Props["composeType"],
+): boolean => {
+	if (type === "compose") {
+		return composeType === "stack";
+	}
+	return true;
+};
+
+export const AssignNetworkToResource = ({
+	resourceId,
+	resourceType,
+	composeType,
+	showCard = false,
+}: Props) => {
+	const [open, setOpen] = useState(false);
+	const utils = api.useUtils();
+
+	const { data: availableNetworks } = api.network.allForResource.useQuery({
+		resourceType,
+		resourceId,
+		composeType,
+	});
+
+	const { data: assignedNetworks } = api.network.getResourceNetworks.useQuery({
+		resourceId,
+		resourceType,
+	});
+
+	const { data: resourceDomains } =
+		resourceType === "application"
+			? api.domain.byApplicationId.useQuery({ applicationId: resourceId })
+			: resourceType === "compose"
+				? api.domain.byComposeId.useQuery({ composeId: resourceId })
+				: { data: [] };
+
+	const hasDomains = resourceDomains && resourceDomains.length > 0;
+
+	const { mutateAsync: assignNetwork, isLoading: isAssigning } =
+		api.network.assignToResource.useMutation();
+
+	const { mutateAsync: removeNetwork, isLoading: isRemoving } =
+		api.network.removeFromResource.useMutation();
+
+	const assignedNetworkIds = assignedNetworks?.map((n) => n.networkId) || [];
+
+	const availableToAssign = availableNetworks?.filter(
+		(network) => !assignedNetworkIds.includes(network.networkId),
+	);
+
+	const wouldBeAllInternal = (networkIdToAssign: string): boolean => {
+		const currentAssignedNetworks = assignedNetworks || [];
+		const networkToAssign = availableNetworks?.find(
+			(n) => n.networkId === networkIdToAssign,
+		);
+
+		if (!networkToAssign) return false;
+
+		const allNetworksAfterAssign = [
+			...currentAssignedNetworks,
+			networkToAssign,
+		];
+
+		return allNetworksAfterAssign.every((n) => n.internal);
+	};
+
+	const handleAssign = async (networkId: string) => {
+		try {
+			await assignNetwork({
+				networkId,
+				resourceId,
+				resourceType,
+			});
+
+			toast.success("Network assigned successfully");
+			await utils.network.getResourceNetworks.invalidate({
+				resourceId,
+				resourceType,
+			});
+			setOpen(false);
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : "Failed to assign network";
+			toast.error(message);
+		}
+	};
+
+	const handleRemove = async (networkId: string) => {
+		try {
+			await removeNetwork({
+				networkId,
+				resourceId,
+				resourceType,
+			});
+
+			toast.success("Network removed successfully");
+			await utils.network.getResourceNetworks.invalidate({
+				resourceId,
+				resourceType,
+			});
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : "Failed to remove network";
+			toast.error(message);
+		}
+	};
+
+	const resourceTypeName = getResourceTypeName(resourceType);
+	const isSwarm = isSwarmResource(resourceType, composeType);
+	const isDatabaseType = [
+		"postgres",
+		"mysql",
+		"mariadb",
+		"mongo",
+		"redis",
+	].includes(resourceType);
+
+	const content = (
+		<div className="space-y-4">
+			{isSwarm && (
+				<Alert>
+					<Info className="h-4 w-4" />
+					<AlertDescription>
+						{isDatabaseType ? "Databases" : "Applications"} are deployed as
+						Docker Swarm services and can only use <strong>overlay</strong>{" "}
+						networks. Only overlay networks are shown below.
+					</AlertDescription>
+				</Alert>
+			)}
+
+			{resourceType === "compose" && composeType === "docker-compose" && (
+				<Alert>
+					<Info className="h-4 w-4" />
+					<AlertDescription>
+						This compose service uses <strong>docker-compose</strong> mode and
+						can use both <strong>bridge</strong> and <strong>overlay</strong>{" "}
+						networks.
+					</AlertDescription>
+				</Alert>
+			)}
+
+			<div className="flex items-center justify-between">
+				<div>
+					<h3 className="text-sm font-medium">Custom Networks</h3>
+					<p className="text-sm text-muted-foreground">
+						Assign this {resourceTypeName} to custom networks for isolation
+					</p>
+				</div>
+				<Popover open={open} onOpenChange={setOpen}>
+					<PopoverTrigger asChild>
+						<Button size="sm" disabled={!availableToAssign?.length}>
+							<Plus className="mr-2 h-4 w-4" />
+							Assign Network
+						</Button>
+					</PopoverTrigger>
+					<PopoverContent className="w-[300px] p-0" align="end">
+						<Command>
+							<CommandInput placeholder="Search networks..." />
+							<CommandEmpty>No networks found.</CommandEmpty>
+							<CommandGroup>
+								<ScrollArea className="h-[200px]">
+									{availableToAssign?.map((network) => {
+										const showWarning =
+											hasDomains && wouldBeAllInternal(network.networkId);
+
+										return (
+											<CommandItem
+												key={network.networkId}
+												value={network.name}
+												onSelect={() => handleAssign(network.networkId)}
+												className="cursor-pointer"
+											>
+												<Network className="mr-2 h-4 w-4" />
+												<div className="flex-1">
+													<div className="font-medium">{network.name}</div>
+													<div className="text-xs text-muted-foreground">
+														{network.networkName} • {network.driver}
+														{network.internal && " (internal)"}
+														{network.server && ` • ${network.server.name}`}
+													</div>
+													{showWarning && (
+														<div className="text-xs text-amber-600 dark:text-amber-400 mt-1">
+															Warning: This will make all networks internal.
+															Domains will be inaccessible.
+														</div>
+													)}
+												</div>
+											</CommandItem>
+										);
+									})}
+								</ScrollArea>
+							</CommandGroup>
+						</Command>
+					</PopoverContent>
+				</Popover>
+			</div>
+
+			{hasDomains &&
+				assignedNetworks &&
+				assignedNetworks.length > 0 &&
+				assignedNetworks.every((n) => n.internal) && (
+					<Alert variant="destructive">
+						<Info className="h-4 w-4" />
+						<AlertDescription>
+							This {resourceTypeName} has {resourceDomains?.length || 0}{" "}
+							domain(s) but all assigned networks are internal. Domains will not
+							be accessible because Traefik cannot connect to internal networks.
+							Assign at least one non-internal network to make domains
+							accessible.
+						</AlertDescription>
+					</Alert>
+				)}
+
+			{assignedNetworks && assignedNetworks.length > 0 ? (
+				<>
+					<div className="flex flex-wrap gap-2">
+						{assignedNetworks.map((network) => (
+							<Badge
+								key={network.networkId}
+								variant="secondary"
+								className="group flex items-center gap-2 pr-1"
+							>
+								<Network className="h-3 w-3" />
+								<span>{network.name}</span>
+								<button
+									type="button"
+									onClick={() => handleRemove(network.networkId)}
+									disabled={isRemoving}
+									className="ml-1 rounded-sm opacity-70 transition-opacity hover:opacity-100 disabled:opacity-50"
+								>
+									<X className="h-3 w-3" />
+								</button>
+							</Badge>
+						))}
+					</div>
+					{isDatabaseType ? (
+						<div className="rounded-lg border border-blue-200 bg-blue-50 dark:border-blue-900 dark:bg-blue-950 p-3">
+							<p className="text-sm text-blue-900 dark:text-blue-100">
+								<strong>Network Isolation Active:</strong> This database is
+								disconnected from{" "}
+								<code className="relative rounded bg-blue-100 dark:bg-blue-900 px-[0.3rem] py-[0.2rem] font-mono text-xs">
+									dokploy-network
+								</code>{" "}
+								and only accessible through the custom networks assigned above.
+							</p>
+							<p className="text-xs text-blue-800 dark:text-blue-200 mt-2">
+								This enhances security by limiting connectivity to explicitly
+								allowed networks only.
+							</p>
+						</div>
+					) : (
+						<p className="text-sm text-muted-foreground">
+							This {resourceTypeName} will not be connected to{" "}
+							<code className="relative rounded bg-muted px-[0.3rem] py-[0.2rem] font-mono text-xs">
+								dokploy-network
+							</code>{" "}
+							and will only use the networks assigned above.
+						</p>
+					)}
+				</>
+			) : (
+				<div className="flex items-center gap-2 rounded-lg border border-dashed p-4 text-sm text-muted-foreground">
+					<Network className="h-4 w-4" />
+					<span>
+						No custom networks assigned. This {resourceTypeName} will use the
+						default dokploy-network.
+					</span>
+				</div>
+			)}
+
+			{!availableNetworks || availableNetworks.length === 0 ? (
+				<div className="rounded-lg border border-dashed p-4">
+					<p className="text-sm text-muted-foreground">
+						No custom networks available. Create a network first.
+					</p>
+				</div>
+			) : null}
+		</div>
+	);
+
+	if (showCard) {
+		return (
+			<Card className="bg-background">
+				<CardHeader>
+					<CardTitle>Network Configuration</CardTitle>
+					<CardDescription>
+						Manage network connectivity for this {resourceTypeName}
+					</CardDescription>
+				</CardHeader>
+				<CardContent>{content}</CardContent>
+			</Card>
+		);
+	}
+
+	return content;
+};
diff --git a/apps/dokploy/components/dashboard/network/create-network.tsx b/apps/dokploy/components/dashboard/network/create-network.tsx
new file mode 100644
index 0000000000..ae14527f68
--- /dev/null
+++ b/apps/dokploy/components/dashboard/network/create-network.tsx
@@ -0,0 +1,424 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Network } from "lucide-react";
+import { useState } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import { AlertBlock } from "@/components/shared/alert-block";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import {
+	Form,
+	FormControl,
+	FormDescription,
+	FormField,
+	FormItem,
+	FormLabel,
+	FormMessage,
+} from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { api } from "@/utils/api";
+
+const IPV4_REGEX =
+	/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+const CIDR_REGEX =
+	/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/(?:[0-9]|[1-2][0-9]|3[0-2])$/;
+
+const CreateNetworkSchema = z.object({
+	name: z.string().min(1, {
+		message: "Name is required",
+	}),
+	networkName: z
+		.string()
+		.min(1, { message: "Network name is required" })
+		.max(63, { message: "Network name must be 63 characters or less" })
+		.regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/, {
+			message:
+				"Network name must start with alphanumeric and contain only alphanumeric, underscore, period, or hyphen",
+		}),
+	description: z.string().optional(),
+	driver: z.enum(["bridge", "overlay"]),
+	subnet: z
+		.string()
+		.regex(CIDR_REGEX, "Invalid subnet format (e.g., 172.20.0.0/16)")
+		.optional()
+		.or(z.literal("")),
+	gateway: z
+		.string()
+		.regex(IPV4_REGEX, "Invalid gateway IP address")
+		.optional()
+		.or(z.literal("")),
+	ipRange: z
+		.string()
+		.regex(CIDR_REGEX, "Invalid IP range format")
+		.optional()
+		.or(z.literal("")),
+	internal: z.boolean().default(false),
+	encrypted: z.boolean().default(false),
+	serverId: z.string().nullable().optional(),
+});
+
+type CreateNetwork = z.infer<typeof CreateNetworkSchema>;
+
+interface Props {
+	projectId?: string | null;
+}
+
+export const CreateNetwork = ({ projectId }: Props) => {
+	const [visible, setVisible] = useState(false);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const utils = api.useUtils();
+
+	const { mutateAsync, isLoading } = api.network.create.useMutation();
+	const { data: servers } = api.server.all.useQuery();
+
+	const form = useForm<CreateNetwork>({
+		defaultValues: {
+			name: "",
+			networkName: "",
+			description: "",
+			driver: "bridge",
+			subnet: "",
+			gateway: "",
+			ipRange: "",
+			internal: false,
+			encrypted: false,
+			serverId: null,
+		},
+		resolver: zodResolver(CreateNetworkSchema),
+	});
+
+	const onSubmit = async (data: CreateNetwork) => {
+		setErrorMessage(null);
+		try {
+			await mutateAsync({
+				...data,
+				projectId: projectId || undefined,
+				serverId:
+					data.serverId === null ? undefined : data.serverId || undefined,
+				subnet: data.subnet || undefined,
+				gateway: data.gateway || undefined,
+				ipRange: data.ipRange || undefined,
+			});
+
+			toast.success("Network created successfully");
+			await utils.network.all.invalidate();
+			form.reset();
+			setVisible(false);
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : "Failed to create network";
+			setErrorMessage(message);
+			console.error("Failed to create network:", error);
+		}
+	};
+
+	const handleOpenChange = (open: boolean) => {
+		setVisible(open);
+		if (!open) {
+			setErrorMessage(null);
+			form.reset();
+		}
+	};
+
+	return (
+		<Dialog open={visible} onOpenChange={handleOpenChange}>
+			<DialogTrigger asChild>
+				<Button>
+					<Network className="h-4 w-4" />
+					Create Network
+				</Button>
+			</DialogTrigger>
+			<DialogContent className="max-h-screen overflow-y-auto sm:max-w-2xl">
+				<DialogHeader>
+					<DialogTitle>Create Custom Network</DialogTitle>
+					<DialogDescription>
+						Create an isolated Docker network for your services
+					</DialogDescription>
+				</DialogHeader>
+
+				{errorMessage && <AlertBlock type="error">{errorMessage}</AlertBlock>}
+
+				<Form {...form}>
+					<form
+						onSubmit={form.handleSubmit(onSubmit)}
+						className="grid w-full gap-4"
+					>
+						<div className="grid gap-4">
+							<FormField
+								control={form.control}
+								name="name"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Name</FormLabel>
+										<FormControl>
+											<Input
+												placeholder="Production Network"
+												{...field}
+												autoComplete="off"
+											/>
+										</FormControl>
+										<FormDescription>
+											A friendly name for this network
+										</FormDescription>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
+							<FormField
+								control={form.control}
+								name="networkName"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Docker Network Name</FormLabel>
+										<FormControl>
+											<Input
+												placeholder="prod-network"
+												{...field}
+												autoComplete="off"
+											/>
+										</FormControl>
+										<FormDescription>
+											The actual Docker network name (lowercase, alphanumeric,
+											dashes, dots, underscores)
+										</FormDescription>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
+							<FormField
+								control={form.control}
+								name="description"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Description</FormLabel>
+										<FormControl>
+											<Textarea
+												placeholder="Network for production services..."
+												{...field}
+											/>
+										</FormControl>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
+							<FormField
+								control={form.control}
+								name="driver"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Driver</FormLabel>
+										<Select
+											onValueChange={field.onChange}
+											defaultValue={field.value}
+										>
+											<FormControl>
+												<SelectTrigger>
+													<SelectValue placeholder="Select a driver" />
+												</SelectTrigger>
+											</FormControl>
+											<SelectContent>
+												<SelectItem value="bridge">
+													Bridge (Single Host)
+												</SelectItem>
+												<SelectItem value="overlay">
+													Overlay (Swarm Mode)
+												</SelectItem>
+											</SelectContent>
+										</Select>
+										<FormDescription>
+											Bridge for single-host, Overlay for multi-host (Swarm)
+										</FormDescription>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
+							{servers && servers.length > 0 && (
+								<FormField
+									control={form.control}
+									name="serverId"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Target Server</FormLabel>
+											<Select
+												onValueChange={(value) =>
+													field.onChange(value === "local" ? null : value)
+												}
+												defaultValue={field.value || "local"}
+											>
+												<FormControl>
+													<SelectTrigger>
+														<SelectValue placeholder="Select target server" />
+													</SelectTrigger>
+												</FormControl>
+												<SelectContent>
+													<SelectItem value="local">
+														Local Server (Dokploy)
+													</SelectItem>
+													{servers.map((server) => (
+														<SelectItem
+															key={server.serverId}
+															value={server.serverId}
+														>
+															{server.name} ({server.ipAddress})
+														</SelectItem>
+													))}
+												</SelectContent>
+											</Select>
+											<FormDescription>
+												Choose where to create this Docker network
+											</FormDescription>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							)}
+
+							<div className="grid gap-4 md:grid-cols-2">
+								<FormField
+									control={form.control}
+									name="subnet"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Subnet (Optional)</FormLabel>
+											<FormControl>
+												<Input
+													placeholder="172.28.0.0/16"
+													{...field}
+													autoComplete="off"
+												/>
+											</FormControl>
+											<FormDescription>CIDR notation</FormDescription>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+
+								<FormField
+									control={form.control}
+									name="gateway"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Gateway (Optional)</FormLabel>
+											<FormControl>
+												<Input
+													placeholder="172.28.0.1"
+													{...field}
+													autoComplete="off"
+												/>
+											</FormControl>
+											<FormDescription>Gateway IP</FormDescription>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							</div>
+
+							<FormField
+								control={form.control}
+								name="ipRange"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>IP Range (Optional)</FormLabel>
+										<FormControl>
+											<Input
+												placeholder="172.28.5.0/24"
+												{...field}
+												autoComplete="off"
+											/>
+										</FormControl>
+										<FormDescription>
+											Allocate IPs from a sub-range
+										</FormDescription>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
+							<div className="space-y-4 rounded-lg border p-4">
+								<h4 className="font-medium">Advanced Options</h4>
+
+								<FormField
+									control={form.control}
+									name="internal"
+									render={({ field }) => (
+										<FormItem className="flex flex-row items-center justify-between">
+											<div className="space-y-0.5">
+												<FormLabel>Internal</FormLabel>
+												<FormDescription>
+													Internal network isolated from external access.
+												</FormDescription>
+											</div>
+											<FormControl>
+												<Switch
+													checked={field.value}
+													onCheckedChange={field.onChange}
+												/>
+											</FormControl>
+										</FormItem>
+									)}
+								/>
+
+								<FormField
+									control={form.control}
+									name="encrypted"
+									render={({ field }) => (
+										<FormItem className="flex flex-row items-center justify-between">
+											<div className="space-y-0.5">
+												<FormLabel>Encrypted</FormLabel>
+												<FormDescription>
+													Encrypt network traffic between nodes (Overlay only)
+												</FormDescription>
+											</div>
+											<FormControl>
+												<Switch
+													checked={field.value}
+													onCheckedChange={field.onChange}
+													disabled={form.watch("driver") !== "overlay"}
+												/>
+											</FormControl>
+										</FormItem>
+									)}
+								/>
+							</div>
+						</div>
+
+						<DialogFooter>
+							<Button
+								type="button"
+								variant="secondary"
+								onClick={() => handleOpenChange(false)}
+							>
+								Cancel
+							</Button>
+							<Button type="submit" isLoading={isLoading}>
+								Create Network
+							</Button>
+						</DialogFooter>
+					</form>
+				</Form>
+			</DialogContent>
+		</Dialog>
+	);
+};
diff --git a/apps/dokploy/components/dashboard/network/delete-network.tsx b/apps/dokploy/components/dashboard/network/delete-network.tsx
new file mode 100644
index 0000000000..954ef66634
--- /dev/null
+++ b/apps/dokploy/components/dashboard/network/delete-network.tsx
@@ -0,0 +1,83 @@
+import { Trash2 } from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+import { AlertBlock } from "@/components/shared/alert-block";
+import {
+	AlertDialog,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+	AlertDialogTrigger,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import { DropdownMenuItem } from "@/components/ui/dropdown-menu";
+import { api } from "@/utils/api";
+
+interface Props {
+	networkId: string;
+}
+
+export const DeleteNetwork = ({ networkId }: Props) => {
+	const [isOpen, setIsOpen] = useState(false);
+	const utils = api.useUtils();
+
+	const { mutateAsync, isLoading, error, isError } =
+		api.network.delete.useMutation();
+
+	const handleDelete = async () => {
+		try {
+			await mutateAsync({ networkId });
+			toast.success("Network deleted successfully");
+			await utils.network.all.invalidate();
+			setIsOpen(false);
+		} catch (error) {
+			console.error("Failed to delete network:", error);
+		}
+	};
+
+	return (
+		<AlertDialog open={isOpen} onOpenChange={setIsOpen}>
+			<AlertDialogTrigger asChild>
+				<DropdownMenuItem
+					className="text-destructive focus:text-destructive"
+					onSelect={(e) => {
+						e.preventDefault();
+						setIsOpen(true);
+					}}
+				>
+					<Trash2 className="mr-2 h-4 w-4" />
+					Delete
+				</DropdownMenuItem>
+			</AlertDialogTrigger>
+			<AlertDialogContent>
+				<AlertDialogHeader>
+					<AlertDialogTitle>Delete Network</AlertDialogTitle>
+					<AlertDialogDescription>
+						Are you sure you want to delete this network? This action cannot be
+						undone.
+					</AlertDialogDescription>
+				</AlertDialogHeader>
+
+				{isError && (
+					<AlertBlock type="error">
+						{error?.message || "Failed to delete network"}
+					</AlertBlock>
+				)}
+
+				<AlertDialogFooter>
+					<AlertDialogCancel disabled={isLoading}>Cancel</AlertDialogCancel>
+					<Button
+						variant="destructive"
+						onClick={handleDelete}
+						isLoading={isLoading}
+					>
+						Delete Network
+					</Button>
+				</AlertDialogFooter>
+			</AlertDialogContent>
+		</AlertDialog>
+	);
+};
diff --git a/apps/dokploy/components/dashboard/network/index.tsx b/apps/dokploy/components/dashboard/network/index.tsx
new file mode 100644
index 0000000000..4b2265170c
--- /dev/null
+++ b/apps/dokploy/components/dashboard/network/index.tsx
@@ -0,0 +1,5 @@
+export { AssignNetworkToResource } from "./assign-network-to-resource";
+export { CreateNetwork } from "./create-network";
+export { DeleteNetwork } from "./delete-network";
+export { NetworkList } from "./network-list";
+export { UpdateNetwork } from "./update-network";
diff --git a/apps/dokploy/components/dashboard/network/network-list.tsx b/apps/dokploy/components/dashboard/network/network-list.tsx
new file mode 100644
index 0000000000..6d0bb185cd
--- /dev/null
+++ b/apps/dokploy/components/dashboard/network/network-list.tsx
@@ -0,0 +1,169 @@
+import {
+	AlertTriangle,
+	Globe,
+	Lock,
+	Network,
+	Server,
+	Settings,
+} from "lucide-react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+	Card,
+	CardContent,
+	CardDescription,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuLabel,
+	DropdownMenuSeparator,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { api } from "@/utils/api";
+import { DeleteNetwork } from "./delete-network";
+import { UpdateNetwork } from "./update-network";
+
+export const NetworkList = () => {
+	const { data: networks, isLoading } = api.network.all.useQuery();
+
+	if (isLoading) {
+		return (
+			<div className="flex h-32 items-center justify-center">
+				<div className="text-sm text-muted-foreground">Loading networks...</div>
+			</div>
+		);
+	}
+
+	if (!networks || networks.length === 0) {
+		return (
+			<Card className="bg-background">
+				<CardHeader>
+					<CardTitle>No Networks</CardTitle>
+					<CardDescription>
+						Create a custom network to isolate your services
+					</CardDescription>
+				</CardHeader>
+				<CardContent>
+					<div className="flex flex-col items-center justify-center space-y-4 py-8">
+						<Network className="h-16 w-16 text-muted-foreground" />
+						<p className="text-center text-sm text-muted-foreground">
+							Custom networks allow you to control which services can
+							communicate with each other
+						</p>
+					</div>
+				</CardContent>
+			</Card>
+		);
+	}
+
+	return (
+		<div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
+			{networks.map((network) => (
+				<Card key={network.networkId} className="relative bg-background">
+					<CardHeader className="pb-3">
+						<div className="flex items-start justify-between">
+							<div className="flex items-center gap-2">
+								<Network className="h-4 w-4 text-muted-foreground" />
+								<CardTitle className="text-base">{network.name}</CardTitle>
+							</div>
+							<DropdownMenu>
+								<DropdownMenuTrigger asChild>
+									<Button variant="ghost" size="icon" className="h-8 w-8">
+										<Settings className="h-4 w-4" />
+									</Button>
+								</DropdownMenuTrigger>
+								<DropdownMenuContent align="end">
+									<DropdownMenuLabel>Actions</DropdownMenuLabel>
+									<DropdownMenuSeparator />
+									<UpdateNetwork network={network} />
+									<DeleteNetwork networkId={network.networkId} />
+								</DropdownMenuContent>
+							</DropdownMenu>
+						</div>
+					</CardHeader>
+					<CardContent className="space-y-2">
+						<div className="space-y-1">
+							<div className="flex items-center gap-2 text-sm">
+								<Server className="h-3 w-3 text-muted-foreground" />
+								<code className="rounded bg-muted px-1.5 py-0.5 text-xs">
+									{network.networkName}
+								</code>
+							</div>
+
+							{network.description && (
+								<p className="text-sm text-muted-foreground line-clamp-2">
+									{network.description}
+								</p>
+							)}
+						</div>
+
+						<div className="flex flex-wrap gap-2">
+							<Badge variant="outline" className="text-xs">
+								{network.driver}
+							</Badge>
+
+							{network.server ? (
+								<Badge variant="secondary" className="text-xs">
+									<Server className="mr-1 h-3 w-3" />
+									{network.server.name}
+								</Badge>
+							) : (
+								<Badge variant="outline" className="text-xs">
+									<Server className="mr-1 h-3 w-3" />
+									Local Server
+								</Badge>
+							)}
+
+							{network.internal && (
+								<Badge variant="outline" className="text-xs">
+									<AlertTriangle className="mr-1 h-3 w-3" />
+									Internal
+								</Badge>
+							)}
+
+							{!network.internal && (
+								<Badge variant="outline" className="text-xs">
+									<Globe className="mr-1 h-3 w-3" />
+									External
+								</Badge>
+							)}
+
+							{network.encrypted && network.driver === "overlay" && (
+								<Badge variant="outline" className="text-xs">
+									<Lock className="mr-1 h-3 w-3" />
+									Encrypted
+								</Badge>
+							)}
+						</div>
+
+						{network.subnet && (
+							<div className="pt-2 text-xs text-muted-foreground">
+								<div className="flex items-center gap-1">
+									<span className="font-medium">Subnet:</span>
+									<code className="rounded bg-muted px-1 py-0.5">
+										{network.subnet}
+									</code>
+								</div>
+								{network.gateway && (
+									<div className="flex items-center gap-1">
+										<span className="font-medium">Gateway:</span>
+										<code className="rounded bg-muted px-1 py-0.5">
+											{network.gateway}
+										</code>
+									</div>
+								)}
+							</div>
+						)}
+
+						<div className="pt-2 text-xs text-muted-foreground">
+							Created {new Date(network.createdAt).toLocaleDateString()}
+						</div>
+					</CardContent>
+				</Card>
+			))}
+		</div>
+	);
+};
diff --git a/apps/dokploy/components/dashboard/network/sync-networks.tsx b/apps/dokploy/components/dashboard/network/sync-networks.tsx
new file mode 100644
index 0000000000..7b7cfb474a
--- /dev/null
+++ b/apps/dokploy/components/dashboard/network/sync-networks.tsx
@@ -0,0 +1,258 @@
+import { AlertCircle, CheckCircle2, Download, RefreshCw } from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import { api } from "@/utils/api";
+
+export const SyncNetworks = () => {
+	const [open, setOpen] = useState(false);
+	const [syncResult, setSyncResult] = useState<{
+		missing: string[];
+		orphaned: string[];
+	} | null>(null);
+	const [silentSync, setSilentSync] = useState(false);
+
+	const utils = api.useUtils();
+
+	const { mutate: syncNetworks, isLoading } =
+		api.network.syncNetworks.useMutation({
+			onSuccess: (data) => {
+				setSyncResult(data);
+
+				if (!silentSync) {
+					if (data.missing.length === 0 && data.orphaned.length === 0) {
+						toast.success("Networks are in sync", {
+							description: "All networks are properly synchronized with Docker",
+						});
+					} else {
+						toast.warning("Sync issues detected", {
+							description: `Found ${data.missing.length} missing and ${data.orphaned.length} orphaned networks`,
+						});
+					}
+				}
+
+				setSilentSync(false);
+				utils.network.all.invalidate();
+			},
+			onError: (error) => {
+				setSilentSync(false);
+				toast.error("Sync failed", {
+					description: error.message || "Failed to synchronize networks",
+				});
+			},
+		});
+
+	const { mutate: importOrphanedNetworks, isLoading: isImporting } =
+		api.network.importOrphanedNetworks.useMutation({
+			onSuccess: (data) => {
+				const { imported, errors } = data;
+
+				if (imported.length > 0) {
+					toast.success(`Imported ${imported.length} network(s)`, {
+						description: `Successfully imported: ${imported.map((n) => n.name).join(", ")}`,
+					});
+				}
+
+				if (errors.length > 0) {
+					toast.error(`Failed to import ${errors.length} network(s)`, {
+						description: errors
+							.map((e) => `${e.networkName}: ${e.error}`)
+							.join(", "),
+					});
+				}
+
+				// Re-run sync silently to update the results
+				setSilentSync(true);
+				syncNetworks({ serverId: null });
+				utils.network.all.invalidate();
+			},
+			onError: (error) => {
+				toast.error("Import failed", {
+					description: error.message || "Failed to import orphaned networks",
+				});
+			},
+		});
+
+	const handleSync = () => {
+		syncNetworks({ serverId: null });
+	};
+
+	const handleImportOrphaned = () => {
+		importOrphanedNetworks({ serverId: null });
+	};
+
+	const handleClose = () => {
+		setOpen(false);
+		setSyncResult(null);
+	};
+
+	return (
+		<Dialog open={open} onOpenChange={setOpen}>
+			<DialogTrigger asChild>
+				<Button variant="outline" className="gap-2">
+					<RefreshCw className="h-4 w-4" />
+					Sync Networks
+				</Button>
+			</DialogTrigger>
+			<DialogContent className="max-w-2xl">
+				<DialogHeader>
+					<DialogTitle>Synchronize Networks</DialogTitle>
+					<DialogDescription>
+						Check for inconsistencies between Dokploy database and Docker
+						networks
+					</DialogDescription>
+				</DialogHeader>
+
+				<div className="space-y-4">
+					{!syncResult && (
+						<div className="space-y-3">
+							<p className="text-sm text-muted-foreground">
+								This will compare networks in the Dokploy database with Docker
+								networks and identify any discrepancies:
+							</p>
+							<ul className="space-y-3 text-sm">
+								<li className="flex items-start gap-2">
+									<AlertCircle className="mt-0.5 h-4 w-4 flex-shrink-0 text-destructive" />
+									<div>
+										<div className="font-medium">Missing Networks</div>
+										<div className="text-muted-foreground text-xs">
+											Networks in database but not in Docker
+										</div>
+									</div>
+								</li>
+								<li className="flex items-start gap-2">
+									<AlertCircle className="mt-0.5 h-4 w-4 flex-shrink-0 text-amber-500" />
+									<div>
+										<div className="font-medium">Orphaned Networks</div>
+										<div className="text-muted-foreground text-xs">
+											Networks in Docker but not in database
+										</div>
+									</div>
+								</li>
+							</ul>
+						</div>
+					)}
+
+					{syncResult && (
+						<div className="space-y-4">
+							{syncResult.missing.length === 0 &&
+							syncResult.orphaned.length === 0 ? (
+								<Alert>
+									<CheckCircle2 className="h-4 w-4" />
+									<AlertTitle>All synchronized</AlertTitle>
+									<AlertDescription>
+										All networks are properly synchronized between Dokploy and
+										Docker
+									</AlertDescription>
+								</Alert>
+							) : (
+								<>
+									{syncResult.missing.length > 0 && (
+										<Alert variant="destructive">
+											<AlertCircle className="h-4 w-4" />
+											<AlertTitle>
+												Missing Networks ({syncResult.missing.length})
+											</AlertTitle>
+											<AlertDescription className="mt-2">
+												<p className="mb-2 text-sm">
+													Networks in database but not in Docker:
+												</p>
+												<ul className="list-inside list-disc space-y-1 mb-3">
+													{syncResult.missing.map((network) => (
+														<li key={network} className="font-mono text-xs">
+															{network}
+														</li>
+													))}
+												</ul>
+												<p className="text-xs text-muted-foreground">
+													Delete from Dokploy or recreate in Docker
+												</p>
+											</AlertDescription>
+										</Alert>
+									)}
+
+									{syncResult.orphaned.length > 0 && (
+										<Alert>
+											<AlertCircle className="h-4 w-4" />
+											<AlertTitle>
+												Orphaned Networks ({syncResult.orphaned.length})
+											</AlertTitle>
+											<AlertDescription className="mt-2">
+												<p className="mb-2 text-sm">
+													Networks in Docker but not in database:
+												</p>
+												<ul className="list-inside list-disc space-y-1 mb-3">
+													{syncResult.orphaned.map((network) => (
+														<li key={network} className="font-mono text-xs">
+															{network}
+														</li>
+													))}
+												</ul>
+												<div className="flex items-center justify-end gap-2">
+													<Button
+														size="sm"
+														onClick={handleImportOrphaned}
+														disabled={isImporting}
+														className="gap-2"
+													>
+														{isImporting ? (
+															<>
+																<RefreshCw className="h-3 w-3 animate-spin" />
+																Importing...
+															</>
+														) : (
+															<>
+																<Download className="h-3 w-3" />
+																Import All
+															</>
+														)}
+													</Button>
+												</div>
+											</AlertDescription>
+										</Alert>
+									)}
+								</>
+							)}
+						</div>
+					)}
+
+					<div className="flex justify-end gap-2">
+						{syncResult ? (
+							<Button onClick={handleClose} variant="outline">
+								Close
+							</Button>
+						) : (
+							<>
+								<Button onClick={handleClose} variant="outline">
+									Cancel
+								</Button>
+								<Button onClick={handleSync} disabled={isLoading}>
+									{isLoading ? (
+										<>
+											<RefreshCw className="mr-2 h-4 w-4 animate-spin" />
+											Syncing...
+										</>
+									) : (
+										<>
+											<RefreshCw className="mr-2 h-4 w-4" />
+											Run Sync
+										</>
+									)}
+								</Button>
+							</>
+						)}
+					</div>
+				</div>
+			</DialogContent>
+		</Dialog>
+	);
+};
diff --git a/apps/dokploy/components/dashboard/network/update-network.tsx b/apps/dokploy/components/dashboard/network/update-network.tsx
new file mode 100644
index 0000000000..2545427d9b
--- /dev/null
+++ b/apps/dokploy/components/dashboard/network/update-network.tsx
@@ -0,0 +1,176 @@
+import type { DokployNetwork } from "@dokploy/server";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Edit } from "lucide-react";
+import { useState } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import { AlertBlock } from "@/components/shared/alert-block";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import { DropdownMenuItem } from "@/components/ui/dropdown-menu";
+import {
+	Form,
+	FormControl,
+	FormDescription,
+	FormField,
+	FormItem,
+	FormLabel,
+	FormMessage,
+} from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+import { api } from "@/utils/api";
+
+const UpdateNetworkSchema = z.object({
+	name: z.string().min(1, {
+		message: "Name is required",
+	}),
+	description: z.string().optional(),
+});
+
+type UpdateNetwork = z.infer<typeof UpdateNetworkSchema>;
+
+interface Props {
+	network: DokployNetwork;
+}
+
+export const UpdateNetwork = ({ network }: Props) => {
+	const [visible, setVisible] = useState(false);
+	const utils = api.useUtils();
+
+	const { mutateAsync, isLoading, error, isError } =
+		api.network.update.useMutation();
+
+	const form = useForm<UpdateNetwork>({
+		defaultValues: {
+			name: network.name,
+			description: network.description || "",
+		},
+		resolver: zodResolver(UpdateNetworkSchema),
+	});
+
+	const onSubmit = async (data: UpdateNetwork) => {
+		try {
+			await mutateAsync({
+				networkId: network.networkId,
+				...data,
+			});
+
+			toast.success("Network updated successfully");
+			await utils.network.all.invalidate();
+			setVisible(false);
+		} catch (error) {
+			console.error("Failed to update network:", error);
+		}
+	};
+
+	return (
+		<Dialog open={visible} onOpenChange={setVisible}>
+			<DialogTrigger asChild>
+				<DropdownMenuItem
+					onSelect={(e) => {
+						e.preventDefault();
+						setVisible(true);
+					}}
+				>
+					<Edit className="mr-2 h-4 w-4" />
+					Edit
+				</DropdownMenuItem>
+			</DialogTrigger>
+			<DialogContent className="sm:max-w-lg">
+				<DialogHeader>
+					<DialogTitle>Update Network</DialogTitle>
+					<DialogDescription>
+						Update the network settings (network name and driver cannot be
+						changed)
+					</DialogDescription>
+				</DialogHeader>
+
+				{isError && <AlertBlock type="error">{error?.message}</AlertBlock>}
+
+				<Form {...form}>
+					<form
+						onSubmit={form.handleSubmit(onSubmit)}
+						className="grid w-full gap-4"
+					>
+						<div className="grid gap-4">
+							<div className="rounded-lg border bg-muted/50 p-3">
+								<div className="space-y-1">
+									<div className="text-sm font-medium">Docker Network Name</div>
+									<code className="text-sm text-muted-foreground">
+										{network.networkName}
+									</code>
+								</div>
+								<div className="mt-2 space-y-1">
+									<div className="text-sm font-medium">Driver</div>
+									<div className="text-sm text-muted-foreground">
+										{network.driver}
+									</div>
+								</div>
+								<p className="mt-2 text-xs text-muted-foreground">
+									These fields cannot be changed after creation
+								</p>
+							</div>
+
+							<FormField
+								control={form.control}
+								name="name"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Name</FormLabel>
+										<FormControl>
+											<Input placeholder="Production Network" {...field} />
+										</FormControl>
+										<FormDescription>
+											A friendly name for this network
+										</FormDescription>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
+							<FormField
+								control={form.control}
+								name="description"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Description</FormLabel>
+										<FormControl>
+											<Textarea
+												placeholder="Network for production services..."
+												{...field}
+											/>
+										</FormControl>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+						</div>
+
+						<DialogFooter>
+							<Button
+								type="button"
+								variant="secondary"
+								onClick={() => setVisible(false)}
+							>
+								Cancel
+							</Button>
+							<Button type="submit" isLoading={isLoading}>
+								Update Network
+							</Button>
+						</DialogFooter>
+					</form>
+				</Form>
+			</DialogContent>
+		</Dialog>
+	);
+};
diff --git a/apps/dokploy/components/dashboard/project/networks-tab.tsx b/apps/dokploy/components/dashboard/project/networks-tab.tsx
new file mode 100644
index 0000000000..c031310b44
--- /dev/null
+++ b/apps/dokploy/components/dashboard/project/networks-tab.tsx
@@ -0,0 +1,37 @@
+import {
+	Card,
+	CardContent,
+	CardDescription,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import { CreateNetwork } from "../network/create-network";
+import { NetworkList } from "../network/network-list";
+
+interface Props {
+	projectId?: string;
+}
+
+export const NetworksTab = ({ projectId }: Props) => {
+	return (
+		<div className="space-y-4">
+			<Card>
+				<CardHeader>
+					<div className="flex items-center justify-between">
+						<div>
+							<CardTitle>Custom Networks</CardTitle>
+							<CardDescription>
+								Manage Docker networks for service isolation and communication
+								control
+							</CardDescription>
+						</div>
+						<CreateNetwork projectId={projectId} />
+					</div>
+				</CardHeader>
+				<CardContent>
+					<NetworkList />
+				</CardContent>
+			</Card>
+		</div>
+	);
+};
diff --git a/apps/dokploy/components/dashboard/shared/show-database-advanced-settings.tsx b/apps/dokploy/components/dashboard/shared/show-database-advanced-settings.tsx
index 024ddb9680..25e77bba96 100644
--- a/apps/dokploy/components/dashboard/shared/show-database-advanced-settings.tsx
+++ b/apps/dokploy/components/dashboard/shared/show-database-advanced-settings.tsx
@@ -1,5 +1,6 @@
 import { ShowResources } from "@/components/dashboard/application/advanced/show-resources";
 import { ShowVolumes } from "@/components/dashboard/application/advanced/volumes/show-volumes";
+import { AssignNetworkToResource } from "@/components/dashboard/network/assign-network-to-resource";
 import { ShowCustomCommand } from "@/components/dashboard/postgres/advanced/show-custom-command";
 import { ShowClusterSettings } from "../application/advanced/cluster/show-cluster-settings";
 import { RebuildDatabase } from "./rebuild-database";
@@ -15,6 +16,7 @@ export const ShowDatabaseAdvancedSettings = ({ id, type }: Props) => {
 			<ShowCustomCommand id={id} type={type} />
 			<ShowClusterSettings id={id} type={type} />
 			<ShowVolumes id={id} type={type} />
+			<AssignNetworkToResource resourceId={id} resourceType={type} showCard />
 			<ShowResources id={id} type={type} />
 			<RebuildDatabase id={id} type={type} />
 		</div>
diff --git a/apps/dokploy/components/layouts/side.tsx b/apps/dokploy/components/layouts/side.tsx
index 4b3354ed84..cd24388b99 100644
--- a/apps/dokploy/components/layouts/side.tsx
+++ b/apps/dokploy/components/layouts/side.tsx
@@ -23,6 +23,7 @@ import {
 	Loader2,
 	LogIn,
 	type LucideIcon,
+	Network,
 	Package,
 	PieChart,
 	Server,
@@ -145,6 +146,12 @@ const MENU: Menu = {
 			url: "/dashboard/projects",
 			icon: Folder,
 		},
+		{
+			isSingle: true,
+			title: "Networks",
+			url: "/dashboard/networks",
+			icon: Network,
+		},
 		{
 			isSingle: true,
 			title: "Monitoring",
diff --git a/apps/dokploy/components/shared/compose-spec.json b/apps/dokploy/components/shared/compose-spec.json
index 92036daa5c..865ed59939 100644
--- a/apps/dokploy/components/shared/compose-spec.json
+++ b/apps/dokploy/components/shared/compose-spec.json
@@ -803,7 +803,7 @@
 				"internal": { "type": ["boolean", "string"] },
 				"enable_ipv4": { "type": ["boolean", "string"] },
 				"enable_ipv6": { "type": ["boolean", "string"] },
-				"attachable": { "type": ["boolean", "string"] },
+				"encrypted": { "type": ["boolean", "string"] },
 				"labels": { "$ref": "#/definitions/list_or_dict" }
 			},
 			"additionalProperties": false,
diff --git a/apps/dokploy/drizzle/0146_secret_randall_flagg.sql b/apps/dokploy/drizzle/0146_secret_randall_flagg.sql
new file mode 100644
index 0000000000..167196bcaa
--- /dev/null
+++ b/apps/dokploy/drizzle/0146_secret_randall_flagg.sql
@@ -0,0 +1,33 @@
+CREATE TYPE "public"."networkDriver" AS ENUM('bridge', 'overlay');--> statement-breakpoint
+CREATE TABLE "network" (
+	"networkId" text PRIMARY KEY NOT NULL,
+	"name" text NOT NULL,
+	"description" text,
+	"networkName" text NOT NULL,
+	"driver" "networkDriver" DEFAULT 'bridge' NOT NULL,
+	"subnet" text,
+	"gateway" text,
+	"ipRange" text,
+	"internal" boolean DEFAULT false NOT NULL,
+	"encrypted" boolean DEFAULT false NOT NULL,
+	"dockerNetworkId" text,
+	"createdAt" text NOT NULL,
+	"projectId" text,
+	"organizationId" text NOT NULL,
+	"serverId" text
+);
+--> statement-breakpoint
+ALTER TABLE "application" ADD COLUMN "previewNetworkIds" text[];--> statement-breakpoint
+ALTER TABLE "application" ADD COLUMN "customNetworkIds" text[];--> statement-breakpoint
+ALTER TABLE "compose" ADD COLUMN "customNetworkIds" text[];--> statement-breakpoint
+ALTER TABLE "domain" ADD COLUMN "networkId" text;--> statement-breakpoint
+ALTER TABLE "mariadb" ADD COLUMN "customNetworkIds" text[];--> statement-breakpoint
+ALTER TABLE "mongo" ADD COLUMN "customNetworkIds" text[];--> statement-breakpoint
+ALTER TABLE "mysql" ADD COLUMN "customNetworkIds" text[];--> statement-breakpoint
+ALTER TABLE "postgres" ADD COLUMN "customNetworkIds" text[];--> statement-breakpoint
+ALTER TABLE "redis" ADD COLUMN "customNetworkIds" text[];--> statement-breakpoint
+ALTER TABLE "network" ADD CONSTRAINT "network_projectId_project_projectId_fk" FOREIGN KEY ("projectId") REFERENCES "public"."project"("projectId") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "network" ADD CONSTRAINT "network_organizationId_organization_id_fk" FOREIGN KEY ("organizationId") REFERENCES "public"."organization"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "network" ADD CONSTRAINT "network_serverId_server_serverId_fk" FOREIGN KEY ("serverId") REFERENCES "public"."server"("serverId") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "domain" ADD CONSTRAINT "domain_networkId_network_networkId_fk" FOREIGN KEY ("networkId") REFERENCES "public"."network"("networkId") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "compose" DROP COLUMN "isolatedDeployment";
\ No newline at end of file
diff --git a/apps/dokploy/drizzle/meta/0146_snapshot.json b/apps/dokploy/drizzle/meta/0146_snapshot.json
new file mode 100644
index 0000000000..de01e83f55
--- /dev/null
+++ b/apps/dokploy/drizzle/meta/0146_snapshot.json
@@ -0,0 +1,7674 @@
+{
+  "id": "6e7e062f-f375-47ae-9f4d-b6bb1b4c93d4",
+  "prevId": "ec86a5ad-8776-483e-a003-346d32f65089",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.account": {
+      "name": "account",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token_expires_at": {
+          "name": "access_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is2FAEnabled": {
+          "name": "is2FAEnabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resetPasswordToken": {
+          "name": "resetPasswordToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resetPasswordExpiresAt": {
+          "name": "resetPasswordExpiresAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "confirmationToken": {
+          "name": "confirmationToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "confirmationExpiresAt": {
+          "name": "confirmationExpiresAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "account_user_id_user_id_fk": {
+          "name": "account_user_id_user_id_fk",
+          "tableFrom": "account",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.apikey": {
+      "name": "apikey",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "start": {
+          "name": "start",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refill_interval": {
+          "name": "refill_interval",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refill_amount": {
+          "name": "refill_amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_refill_at": {
+          "name": "last_refill_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rate_limit_enabled": {
+          "name": "rate_limit_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rate_limit_time_window": {
+          "name": "rate_limit_time_window",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rate_limit_max": {
+          "name": "rate_limit_max",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "request_count": {
+          "name": "request_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remaining": {
+          "name": "remaining",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_request": {
+          "name": "last_request",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permissions": {
+          "name": "permissions",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "apikey_user_id_user_id_fk": {
+          "name": "apikey_user_id_user_id_fk",
+          "tableFrom": "apikey",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.invitation": {
+      "name": "invitation",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "inviter_id": {
+          "name": "inviter_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "invitation_organization_id_organization_id_fk": {
+          "name": "invitation_organization_id_organization_id_fk",
+          "tableFrom": "invitation",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organization_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "invitation_inviter_id_user_id_fk": {
+          "name": "invitation_inviter_id_user_id_fk",
+          "tableFrom": "invitation",
+          "tableTo": "user",
+          "columnsFrom": [
+            "inviter_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.member": {
+      "name": "member",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_default": {
+          "name": "is_default",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canCreateProjects": {
+          "name": "canCreateProjects",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canAccessToSSHKeys": {
+          "name": "canAccessToSSHKeys",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canCreateServices": {
+          "name": "canCreateServices",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canDeleteProjects": {
+          "name": "canDeleteProjects",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canDeleteServices": {
+          "name": "canDeleteServices",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canAccessToDocker": {
+          "name": "canAccessToDocker",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canAccessToAPI": {
+          "name": "canAccessToAPI",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canAccessToGitProviders": {
+          "name": "canAccessToGitProviders",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canAccessToTraefikFiles": {
+          "name": "canAccessToTraefikFiles",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canDeleteEnvironments": {
+          "name": "canDeleteEnvironments",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "canCreateEnvironments": {
+          "name": "canCreateEnvironments",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "accesedProjects": {
+          "name": "accesedProjects",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "ARRAY[]::text[]"
+        },
+        "accessedEnvironments": {
+          "name": "accessedEnvironments",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "ARRAY[]::text[]"
+        },
+        "accesedServices": {
+          "name": "accesedServices",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "ARRAY[]::text[]"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "member_organization_id_organization_id_fk": {
+          "name": "member_organization_id_organization_id_fk",
+          "tableFrom": "member",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organization_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "member_user_id_user_id_fk": {
+          "name": "member_user_id_user_id_fk",
+          "tableFrom": "member",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.organization": {
+      "name": "organization",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "logo": {
+          "name": "logo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "organization_owner_id_user_id_fk": {
+          "name": "organization_owner_id_user_id_fk",
+          "tableFrom": "organization",
+          "tableTo": "user",
+          "columnsFrom": [
+            "owner_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "organization_slug_unique": {
+          "name": "organization_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.two_factor": {
+      "name": "two_factor",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "secret": {
+          "name": "secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "backup_codes": {
+          "name": "backup_codes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "two_factor_user_id_user_id_fk": {
+          "name": "two_factor_user_id_user_id_fk",
+          "tableFrom": "two_factor",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.verification": {
+      "name": "verification",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.ai": {
+      "name": "ai",
+      "schema": "",
+      "columns": {
+        "aiId": {
+          "name": "aiId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "apiUrl": {
+          "name": "apiUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "apiKey": {
+          "name": "apiKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "isEnabled": {
+          "name": "isEnabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "ai_organizationId_organization_id_fk": {
+          "name": "ai_organizationId_organization_id_fk",
+          "tableFrom": "ai",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.application": {
+      "name": "application",
+      "schema": "",
+      "columns": {
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewEnv": {
+          "name": "previewEnv",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "watchPaths": {
+          "name": "watchPaths",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewBuildArgs": {
+          "name": "previewBuildArgs",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewBuildSecrets": {
+          "name": "previewBuildSecrets",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewLabels": {
+          "name": "previewLabels",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewWildcard": {
+          "name": "previewWildcard",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewPort": {
+          "name": "previewPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 3000
+        },
+        "previewHttps": {
+          "name": "previewHttps",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "previewPath": {
+          "name": "previewPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'/'"
+        },
+        "certificateType": {
+          "name": "certificateType",
+          "type": "certificateType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'none'"
+        },
+        "previewCustomCertResolver": {
+          "name": "previewCustomCertResolver",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewNetworkIds": {
+          "name": "previewNetworkIds",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewLimit": {
+          "name": "previewLimit",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 3
+        },
+        "isPreviewDeploymentsActive": {
+          "name": "isPreviewDeploymentsActive",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "previewRequireCollaboratorPermissions": {
+          "name": "previewRequireCollaboratorPermissions",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "rollbackActive": {
+          "name": "rollbackActive",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "buildArgs": {
+          "name": "buildArgs",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "buildSecrets": {
+          "name": "buildSecrets",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryReservation": {
+          "name": "memoryReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryLimit": {
+          "name": "memoryLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuReservation": {
+          "name": "cpuReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuLimit": {
+          "name": "cpuLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subtitle": {
+          "name": "subtitle",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "args": {
+          "name": "args",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refreshToken": {
+          "name": "refreshToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sourceType": {
+          "name": "sourceType",
+          "type": "sourceType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'github'"
+        },
+        "cleanCache": {
+          "name": "cleanCache",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "repository": {
+          "name": "repository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "owner": {
+          "name": "owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "buildPath": {
+          "name": "buildPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'/'"
+        },
+        "triggerType": {
+          "name": "triggerType",
+          "type": "triggerType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'push'"
+        },
+        "autoDeploy": {
+          "name": "autoDeploy",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabProjectId": {
+          "name": "gitlabProjectId",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabRepository": {
+          "name": "gitlabRepository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabOwner": {
+          "name": "gitlabOwner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabBranch": {
+          "name": "gitlabBranch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabBuildPath": {
+          "name": "gitlabBuildPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'/'"
+        },
+        "gitlabPathNamespace": {
+          "name": "gitlabPathNamespace",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaRepository": {
+          "name": "giteaRepository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaOwner": {
+          "name": "giteaOwner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaBranch": {
+          "name": "giteaBranch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaBuildPath": {
+          "name": "giteaBuildPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'/'"
+        },
+        "bitbucketRepository": {
+          "name": "bitbucketRepository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketRepositorySlug": {
+          "name": "bitbucketRepositorySlug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketOwner": {
+          "name": "bitbucketOwner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketBranch": {
+          "name": "bitbucketBranch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketBuildPath": {
+          "name": "bitbucketBuildPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'/'"
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dockerImage": {
+          "name": "dockerImage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "registryUrl": {
+          "name": "registryUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customGitUrl": {
+          "name": "customGitUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customGitBranch": {
+          "name": "customGitBranch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customGitBuildPath": {
+          "name": "customGitBuildPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customGitSSHKeyId": {
+          "name": "customGitSSHKeyId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enableSubmodules": {
+          "name": "enableSubmodules",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "dockerfile": {
+          "name": "dockerfile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dockerContextPath": {
+          "name": "dockerContextPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dockerBuildStage": {
+          "name": "dockerBuildStage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dropBuildPath": {
+          "name": "dropBuildPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "healthCheckSwarm": {
+          "name": "healthCheckSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "restartPolicySwarm": {
+          "name": "restartPolicySwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "placementSwarm": {
+          "name": "placementSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updateConfigSwarm": {
+          "name": "updateConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rollbackConfigSwarm": {
+          "name": "rollbackConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "modeSwarm": {
+          "name": "modeSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "labelsSwarm": {
+          "name": "labelsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "networkSwarm": {
+          "name": "networkSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stopGracePeriodSwarm": {
+          "name": "stopGracePeriodSwarm",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customNetworkIds": {
+          "name": "customNetworkIds",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "endpointSpecSwarm": {
+          "name": "endpointSpecSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ulimitsSwarm": {
+          "name": "ulimitsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "replicas": {
+          "name": "replicas",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "applicationStatus": {
+          "name": "applicationStatus",
+          "type": "applicationStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "buildType": {
+          "name": "buildType",
+          "type": "buildType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'nixpacks'"
+        },
+        "railpackVersion": {
+          "name": "railpackVersion",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'0.15.4'"
+        },
+        "herokuVersion": {
+          "name": "herokuVersion",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'24'"
+        },
+        "publishDirectory": {
+          "name": "publishDirectory",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "isStaticSpa": {
+          "name": "isStaticSpa",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createEnvFile": {
+          "name": "createEnvFile",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "registryId": {
+          "name": "registryId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rollbackRegistryId": {
+          "name": "rollbackRegistryId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "environmentId": {
+          "name": "environmentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "githubId": {
+          "name": "githubId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabId": {
+          "name": "gitlabId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaId": {
+          "name": "giteaId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketId": {
+          "name": "bitbucketId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "buildServerId": {
+          "name": "buildServerId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "buildRegistryId": {
+          "name": "buildRegistryId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "application_customGitSSHKeyId_ssh-key_sshKeyId_fk": {
+          "name": "application_customGitSSHKeyId_ssh-key_sshKeyId_fk",
+          "tableFrom": "application",
+          "tableTo": "ssh-key",
+          "columnsFrom": [
+            "customGitSSHKeyId"
+          ],
+          "columnsTo": [
+            "sshKeyId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "application_registryId_registry_registryId_fk": {
+          "name": "application_registryId_registry_registryId_fk",
+          "tableFrom": "application",
+          "tableTo": "registry",
+          "columnsFrom": [
+            "registryId"
+          ],
+          "columnsTo": [
+            "registryId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "application_rollbackRegistryId_registry_registryId_fk": {
+          "name": "application_rollbackRegistryId_registry_registryId_fk",
+          "tableFrom": "application",
+          "tableTo": "registry",
+          "columnsFrom": [
+            "rollbackRegistryId"
+          ],
+          "columnsTo": [
+            "registryId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "application_environmentId_environment_environmentId_fk": {
+          "name": "application_environmentId_environment_environmentId_fk",
+          "tableFrom": "application",
+          "tableTo": "environment",
+          "columnsFrom": [
+            "environmentId"
+          ],
+          "columnsTo": [
+            "environmentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "application_githubId_github_githubId_fk": {
+          "name": "application_githubId_github_githubId_fk",
+          "tableFrom": "application",
+          "tableTo": "github",
+          "columnsFrom": [
+            "githubId"
+          ],
+          "columnsTo": [
+            "githubId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "application_gitlabId_gitlab_gitlabId_fk": {
+          "name": "application_gitlabId_gitlab_gitlabId_fk",
+          "tableFrom": "application",
+          "tableTo": "gitlab",
+          "columnsFrom": [
+            "gitlabId"
+          ],
+          "columnsTo": [
+            "gitlabId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "application_giteaId_gitea_giteaId_fk": {
+          "name": "application_giteaId_gitea_giteaId_fk",
+          "tableFrom": "application",
+          "tableTo": "gitea",
+          "columnsFrom": [
+            "giteaId"
+          ],
+          "columnsTo": [
+            "giteaId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "application_bitbucketId_bitbucket_bitbucketId_fk": {
+          "name": "application_bitbucketId_bitbucket_bitbucketId_fk",
+          "tableFrom": "application",
+          "tableTo": "bitbucket",
+          "columnsFrom": [
+            "bitbucketId"
+          ],
+          "columnsTo": [
+            "bitbucketId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "application_serverId_server_serverId_fk": {
+          "name": "application_serverId_server_serverId_fk",
+          "tableFrom": "application",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "application_buildServerId_server_serverId_fk": {
+          "name": "application_buildServerId_server_serverId_fk",
+          "tableFrom": "application",
+          "tableTo": "server",
+          "columnsFrom": [
+            "buildServerId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "application_buildRegistryId_registry_registryId_fk": {
+          "name": "application_buildRegistryId_registry_registryId_fk",
+          "tableFrom": "application",
+          "tableTo": "registry",
+          "columnsFrom": [
+            "buildRegistryId"
+          ],
+          "columnsTo": [
+            "registryId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "application_appName_unique": {
+          "name": "application_appName_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "appName"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.backup": {
+      "name": "backup",
+      "schema": "",
+      "columns": {
+        "backupId": {
+          "name": "backupId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "schedule": {
+          "name": "schedule",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "database": {
+          "name": "database",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serviceName": {
+          "name": "serviceName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "destinationId": {
+          "name": "destinationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "keepLatestCount": {
+          "name": "keepLatestCount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "backupType": {
+          "name": "backupType",
+          "type": "backupType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'database'"
+        },
+        "databaseType": {
+          "name": "databaseType",
+          "type": "databaseType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "composeId": {
+          "name": "composeId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "postgresId": {
+          "name": "postgresId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mariadbId": {
+          "name": "mariadbId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mysqlId": {
+          "name": "mysqlId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mongoId": {
+          "name": "mongoId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "userId": {
+          "name": "userId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "backup_destinationId_destination_destinationId_fk": {
+          "name": "backup_destinationId_destination_destinationId_fk",
+          "tableFrom": "backup",
+          "tableTo": "destination",
+          "columnsFrom": [
+            "destinationId"
+          ],
+          "columnsTo": [
+            "destinationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "backup_composeId_compose_composeId_fk": {
+          "name": "backup_composeId_compose_composeId_fk",
+          "tableFrom": "backup",
+          "tableTo": "compose",
+          "columnsFrom": [
+            "composeId"
+          ],
+          "columnsTo": [
+            "composeId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "backup_postgresId_postgres_postgresId_fk": {
+          "name": "backup_postgresId_postgres_postgresId_fk",
+          "tableFrom": "backup",
+          "tableTo": "postgres",
+          "columnsFrom": [
+            "postgresId"
+          ],
+          "columnsTo": [
+            "postgresId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "backup_mariadbId_mariadb_mariadbId_fk": {
+          "name": "backup_mariadbId_mariadb_mariadbId_fk",
+          "tableFrom": "backup",
+          "tableTo": "mariadb",
+          "columnsFrom": [
+            "mariadbId"
+          ],
+          "columnsTo": [
+            "mariadbId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "backup_mysqlId_mysql_mysqlId_fk": {
+          "name": "backup_mysqlId_mysql_mysqlId_fk",
+          "tableFrom": "backup",
+          "tableTo": "mysql",
+          "columnsFrom": [
+            "mysqlId"
+          ],
+          "columnsTo": [
+            "mysqlId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "backup_mongoId_mongo_mongoId_fk": {
+          "name": "backup_mongoId_mongo_mongoId_fk",
+          "tableFrom": "backup",
+          "tableTo": "mongo",
+          "columnsFrom": [
+            "mongoId"
+          ],
+          "columnsTo": [
+            "mongoId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "backup_userId_user_id_fk": {
+          "name": "backup_userId_user_id_fk",
+          "tableFrom": "backup",
+          "tableTo": "user",
+          "columnsFrom": [
+            "userId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "backup_appName_unique": {
+          "name": "backup_appName_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "appName"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bitbucket": {
+      "name": "bitbucket",
+      "schema": "",
+      "columns": {
+        "bitbucketId": {
+          "name": "bitbucketId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "bitbucketUsername": {
+          "name": "bitbucketUsername",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketEmail": {
+          "name": "bitbucketEmail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "appPassword": {
+          "name": "appPassword",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "apiToken": {
+          "name": "apiToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketWorkspaceName": {
+          "name": "bitbucketWorkspaceName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitProviderId": {
+          "name": "gitProviderId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "bitbucket_gitProviderId_git_provider_gitProviderId_fk": {
+          "name": "bitbucket_gitProviderId_git_provider_gitProviderId_fk",
+          "tableFrom": "bitbucket",
+          "tableTo": "git_provider",
+          "columnsFrom": [
+            "gitProviderId"
+          ],
+          "columnsTo": [
+            "gitProviderId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.certificate": {
+      "name": "certificate",
+      "schema": "",
+      "columns": {
+        "certificateId": {
+          "name": "certificateId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "certificateData": {
+          "name": "certificateData",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "privateKey": {
+          "name": "privateKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "certificatePath": {
+          "name": "certificatePath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "autoRenew": {
+          "name": "autoRenew",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "certificate_organizationId_organization_id_fk": {
+          "name": "certificate_organizationId_organization_id_fk",
+          "tableFrom": "certificate",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "certificate_serverId_server_serverId_fk": {
+          "name": "certificate_serverId_server_serverId_fk",
+          "tableFrom": "certificate",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "certificate_certificatePath_unique": {
+          "name": "certificate_certificatePath_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "certificatePath"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.compose": {
+      "name": "compose",
+      "schema": "",
+      "columns": {
+        "composeId": {
+          "name": "composeId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "composeFile": {
+          "name": "composeFile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "refreshToken": {
+          "name": "refreshToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sourceType": {
+          "name": "sourceType",
+          "type": "sourceTypeCompose",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'github'"
+        },
+        "composeType": {
+          "name": "composeType",
+          "type": "composeType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'docker-compose'"
+        },
+        "repository": {
+          "name": "repository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "owner": {
+          "name": "owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "autoDeploy": {
+          "name": "autoDeploy",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabProjectId": {
+          "name": "gitlabProjectId",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabRepository": {
+          "name": "gitlabRepository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabOwner": {
+          "name": "gitlabOwner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabBranch": {
+          "name": "gitlabBranch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabPathNamespace": {
+          "name": "gitlabPathNamespace",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketRepository": {
+          "name": "bitbucketRepository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketRepositorySlug": {
+          "name": "bitbucketRepositorySlug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketOwner": {
+          "name": "bitbucketOwner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketBranch": {
+          "name": "bitbucketBranch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaRepository": {
+          "name": "giteaRepository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaOwner": {
+          "name": "giteaOwner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaBranch": {
+          "name": "giteaBranch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customGitUrl": {
+          "name": "customGitUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customGitBranch": {
+          "name": "customGitBranch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customGitSSHKeyId": {
+          "name": "customGitSSHKeyId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "enableSubmodules": {
+          "name": "enableSubmodules",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "composePath": {
+          "name": "composePath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'./docker-compose.yml'"
+        },
+        "suffix": {
+          "name": "suffix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "randomize": {
+          "name": "randomize",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "isolatedDeploymentsVolume": {
+          "name": "isolatedDeploymentsVolume",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "triggerType": {
+          "name": "triggerType",
+          "type": "triggerType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'push'"
+        },
+        "composeStatus": {
+          "name": "composeStatus",
+          "type": "applicationStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "customNetworkIds": {
+          "name": "customNetworkIds",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "environmentId": {
+          "name": "environmentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "watchPaths": {
+          "name": "watchPaths",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "githubId": {
+          "name": "githubId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitlabId": {
+          "name": "gitlabId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bitbucketId": {
+          "name": "bitbucketId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "giteaId": {
+          "name": "giteaId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "compose_customGitSSHKeyId_ssh-key_sshKeyId_fk": {
+          "name": "compose_customGitSSHKeyId_ssh-key_sshKeyId_fk",
+          "tableFrom": "compose",
+          "tableTo": "ssh-key",
+          "columnsFrom": [
+            "customGitSSHKeyId"
+          ],
+          "columnsTo": [
+            "sshKeyId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "compose_environmentId_environment_environmentId_fk": {
+          "name": "compose_environmentId_environment_environmentId_fk",
+          "tableFrom": "compose",
+          "tableTo": "environment",
+          "columnsFrom": [
+            "environmentId"
+          ],
+          "columnsTo": [
+            "environmentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "compose_githubId_github_githubId_fk": {
+          "name": "compose_githubId_github_githubId_fk",
+          "tableFrom": "compose",
+          "tableTo": "github",
+          "columnsFrom": [
+            "githubId"
+          ],
+          "columnsTo": [
+            "githubId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "compose_gitlabId_gitlab_gitlabId_fk": {
+          "name": "compose_gitlabId_gitlab_gitlabId_fk",
+          "tableFrom": "compose",
+          "tableTo": "gitlab",
+          "columnsFrom": [
+            "gitlabId"
+          ],
+          "columnsTo": [
+            "gitlabId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "compose_bitbucketId_bitbucket_bitbucketId_fk": {
+          "name": "compose_bitbucketId_bitbucket_bitbucketId_fk",
+          "tableFrom": "compose",
+          "tableTo": "bitbucket",
+          "columnsFrom": [
+            "bitbucketId"
+          ],
+          "columnsTo": [
+            "bitbucketId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "compose_giteaId_gitea_giteaId_fk": {
+          "name": "compose_giteaId_gitea_giteaId_fk",
+          "tableFrom": "compose",
+          "tableTo": "gitea",
+          "columnsFrom": [
+            "giteaId"
+          ],
+          "columnsTo": [
+            "giteaId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "compose_serverId_server_serverId_fk": {
+          "name": "compose_serverId_server_serverId_fk",
+          "tableFrom": "compose",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.deployment": {
+      "name": "deployment",
+      "schema": "",
+      "columns": {
+        "deploymentId": {
+          "name": "deploymentId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "deploymentStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'running'"
+        },
+        "logPath": {
+          "name": "logPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pid": {
+          "name": "pid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "composeId": {
+          "name": "composeId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "isPreviewDeployment": {
+          "name": "isPreviewDeployment",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "previewDeploymentId": {
+          "name": "previewDeploymentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "startedAt": {
+          "name": "startedAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "finishedAt": {
+          "name": "finishedAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "errorMessage": {
+          "name": "errorMessage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scheduleId": {
+          "name": "scheduleId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "backupId": {
+          "name": "backupId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rollbackId": {
+          "name": "rollbackId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "volumeBackupId": {
+          "name": "volumeBackupId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "buildServerId": {
+          "name": "buildServerId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "deployment_applicationId_application_applicationId_fk": {
+          "name": "deployment_applicationId_application_applicationId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deployment_composeId_compose_composeId_fk": {
+          "name": "deployment_composeId_compose_composeId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "compose",
+          "columnsFrom": [
+            "composeId"
+          ],
+          "columnsTo": [
+            "composeId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deployment_serverId_server_serverId_fk": {
+          "name": "deployment_serverId_server_serverId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deployment_previewDeploymentId_preview_deployments_previewDeploymentId_fk": {
+          "name": "deployment_previewDeploymentId_preview_deployments_previewDeploymentId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "preview_deployments",
+          "columnsFrom": [
+            "previewDeploymentId"
+          ],
+          "columnsTo": [
+            "previewDeploymentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deployment_scheduleId_schedule_scheduleId_fk": {
+          "name": "deployment_scheduleId_schedule_scheduleId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "schedule",
+          "columnsFrom": [
+            "scheduleId"
+          ],
+          "columnsTo": [
+            "scheduleId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deployment_backupId_backup_backupId_fk": {
+          "name": "deployment_backupId_backup_backupId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "backup",
+          "columnsFrom": [
+            "backupId"
+          ],
+          "columnsTo": [
+            "backupId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deployment_rollbackId_rollback_rollbackId_fk": {
+          "name": "deployment_rollbackId_rollback_rollbackId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "rollback",
+          "columnsFrom": [
+            "rollbackId"
+          ],
+          "columnsTo": [
+            "rollbackId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deployment_volumeBackupId_volume_backup_volumeBackupId_fk": {
+          "name": "deployment_volumeBackupId_volume_backup_volumeBackupId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "volume_backup",
+          "columnsFrom": [
+            "volumeBackupId"
+          ],
+          "columnsTo": [
+            "volumeBackupId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deployment_buildServerId_server_serverId_fk": {
+          "name": "deployment_buildServerId_server_serverId_fk",
+          "tableFrom": "deployment",
+          "tableTo": "server",
+          "columnsFrom": [
+            "buildServerId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.destination": {
+      "name": "destination",
+      "schema": "",
+      "columns": {
+        "destinationId": {
+          "name": "destinationId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "accessKey": {
+          "name": "accessKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "secretAccessKey": {
+          "name": "secretAccessKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "bucket": {
+          "name": "bucket",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "region": {
+          "name": "region",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "endpoint": {
+          "name": "endpoint",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "destination_organizationId_organization_id_fk": {
+          "name": "destination_organizationId_organization_id_fk",
+          "tableFrom": "destination",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.domain": {
+      "name": "domain",
+      "schema": "",
+      "columns": {
+        "domainId": {
+          "name": "domainId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "host": {
+          "name": "host",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "https": {
+          "name": "https",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "port": {
+          "name": "port",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 3000
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'/'"
+        },
+        "serviceName": {
+          "name": "serviceName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "domainType": {
+          "name": "domainType",
+          "type": "domainType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'application'"
+        },
+        "uniqueConfigKey": {
+          "name": "uniqueConfigKey",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "composeId": {
+          "name": "composeId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customCertResolver": {
+          "name": "customCertResolver",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "previewDeploymentId": {
+          "name": "previewDeploymentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "certificateType": {
+          "name": "certificateType",
+          "type": "certificateType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'none'"
+        },
+        "internalPath": {
+          "name": "internalPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'/'"
+        },
+        "stripPath": {
+          "name": "stripPath",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "networkId": {
+          "name": "networkId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "domain_composeId_compose_composeId_fk": {
+          "name": "domain_composeId_compose_composeId_fk",
+          "tableFrom": "domain",
+          "tableTo": "compose",
+          "columnsFrom": [
+            "composeId"
+          ],
+          "columnsTo": [
+            "composeId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "domain_applicationId_application_applicationId_fk": {
+          "name": "domain_applicationId_application_applicationId_fk",
+          "tableFrom": "domain",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "domain_previewDeploymentId_preview_deployments_previewDeploymentId_fk": {
+          "name": "domain_previewDeploymentId_preview_deployments_previewDeploymentId_fk",
+          "tableFrom": "domain",
+          "tableTo": "preview_deployments",
+          "columnsFrom": [
+            "previewDeploymentId"
+          ],
+          "columnsTo": [
+            "previewDeploymentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "domain_networkId_network_networkId_fk": {
+          "name": "domain_networkId_network_networkId_fk",
+          "tableFrom": "domain",
+          "tableTo": "network",
+          "columnsFrom": [
+            "networkId"
+          ],
+          "columnsTo": [
+            "networkId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.environment": {
+      "name": "environment",
+      "schema": "",
+      "columns": {
+        "environmentId": {
+          "name": "environmentId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "projectId": {
+          "name": "projectId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "isDefault": {
+          "name": "isDefault",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "environment_projectId_project_projectId_fk": {
+          "name": "environment_projectId_project_projectId_fk",
+          "tableFrom": "environment",
+          "tableTo": "project",
+          "columnsFrom": [
+            "projectId"
+          ],
+          "columnsTo": [
+            "projectId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.git_provider": {
+      "name": "git_provider",
+      "schema": "",
+      "columns": {
+        "gitProviderId": {
+          "name": "gitProviderId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "providerType": {
+          "name": "providerType",
+          "type": "gitProviderType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'github'"
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "userId": {
+          "name": "userId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "git_provider_organizationId_organization_id_fk": {
+          "name": "git_provider_organizationId_organization_id_fk",
+          "tableFrom": "git_provider",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "git_provider_userId_user_id_fk": {
+          "name": "git_provider_userId_user_id_fk",
+          "tableFrom": "git_provider",
+          "tableTo": "user",
+          "columnsFrom": [
+            "userId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.gitea": {
+      "name": "gitea",
+      "schema": "",
+      "columns": {
+        "giteaId": {
+          "name": "giteaId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "giteaUrl": {
+          "name": "giteaUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'https://gitea.com'"
+        },
+        "giteaInternalUrl": {
+          "name": "giteaInternalUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "redirect_uri": {
+          "name": "redirect_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "client_secret": {
+          "name": "client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitProviderId": {
+          "name": "gitProviderId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scopes": {
+          "name": "scopes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'repo,repo:status,read:user,read:org'"
+        },
+        "last_authenticated_at": {
+          "name": "last_authenticated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "gitea_gitProviderId_git_provider_gitProviderId_fk": {
+          "name": "gitea_gitProviderId_git_provider_gitProviderId_fk",
+          "tableFrom": "gitea",
+          "tableTo": "git_provider",
+          "columnsFrom": [
+            "gitProviderId"
+          ],
+          "columnsTo": [
+            "gitProviderId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.github": {
+      "name": "github",
+      "schema": "",
+      "columns": {
+        "githubId": {
+          "name": "githubId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "githubAppName": {
+          "name": "githubAppName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "githubAppId": {
+          "name": "githubAppId",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "githubClientId": {
+          "name": "githubClientId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "githubClientSecret": {
+          "name": "githubClientSecret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "githubInstallationId": {
+          "name": "githubInstallationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "githubPrivateKey": {
+          "name": "githubPrivateKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "githubWebhookSecret": {
+          "name": "githubWebhookSecret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitProviderId": {
+          "name": "gitProviderId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "github_gitProviderId_git_provider_gitProviderId_fk": {
+          "name": "github_gitProviderId_git_provider_gitProviderId_fk",
+          "tableFrom": "github",
+          "tableTo": "git_provider",
+          "columnsFrom": [
+            "gitProviderId"
+          ],
+          "columnsTo": [
+            "gitProviderId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.gitlab": {
+      "name": "gitlab",
+      "schema": "",
+      "columns": {
+        "gitlabId": {
+          "name": "gitlabId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "gitlabUrl": {
+          "name": "gitlabUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'https://gitlab.com'"
+        },
+        "gitlabInternalUrl": {
+          "name": "gitlabInternalUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "application_id": {
+          "name": "application_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "redirect_uri": {
+          "name": "redirect_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "secret": {
+          "name": "secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "group_name": {
+          "name": "group_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gitProviderId": {
+          "name": "gitProviderId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "gitlab_gitProviderId_git_provider_gitProviderId_fk": {
+          "name": "gitlab_gitProviderId_git_provider_gitProviderId_fk",
+          "tableFrom": "gitlab",
+          "tableTo": "git_provider",
+          "columnsFrom": [
+            "gitProviderId"
+          ],
+          "columnsTo": [
+            "gitProviderId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.mariadb": {
+      "name": "mariadb",
+      "schema": "",
+      "columns": {
+        "mariadbId": {
+          "name": "mariadbId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "databaseName": {
+          "name": "databaseName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "databaseUser": {
+          "name": "databaseUser",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "databasePassword": {
+          "name": "databasePassword",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rootPassword": {
+          "name": "rootPassword",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dockerImage": {
+          "name": "dockerImage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "args": {
+          "name": "args",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryReservation": {
+          "name": "memoryReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryLimit": {
+          "name": "memoryLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuReservation": {
+          "name": "cpuReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuLimit": {
+          "name": "cpuLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "externalPort": {
+          "name": "externalPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationStatus": {
+          "name": "applicationStatus",
+          "type": "applicationStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "healthCheckSwarm": {
+          "name": "healthCheckSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "restartPolicySwarm": {
+          "name": "restartPolicySwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "placementSwarm": {
+          "name": "placementSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updateConfigSwarm": {
+          "name": "updateConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rollbackConfigSwarm": {
+          "name": "rollbackConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "modeSwarm": {
+          "name": "modeSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "labelsSwarm": {
+          "name": "labelsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "networkSwarm": {
+          "name": "networkSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stopGracePeriodSwarm": {
+          "name": "stopGracePeriodSwarm",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customNetworkIds": {
+          "name": "customNetworkIds",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "endpointSpecSwarm": {
+          "name": "endpointSpecSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ulimitsSwarm": {
+          "name": "ulimitsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "replicas": {
+          "name": "replicas",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "environmentId": {
+          "name": "environmentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "mariadb_environmentId_environment_environmentId_fk": {
+          "name": "mariadb_environmentId_environment_environmentId_fk",
+          "tableFrom": "mariadb",
+          "tableTo": "environment",
+          "columnsFrom": [
+            "environmentId"
+          ],
+          "columnsTo": [
+            "environmentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mariadb_serverId_server_serverId_fk": {
+          "name": "mariadb_serverId_server_serverId_fk",
+          "tableFrom": "mariadb",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "mariadb_appName_unique": {
+          "name": "mariadb_appName_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "appName"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.mongo": {
+      "name": "mongo",
+      "schema": "",
+      "columns": {
+        "mongoId": {
+          "name": "mongoId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "databaseUser": {
+          "name": "databaseUser",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "databasePassword": {
+          "name": "databasePassword",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dockerImage": {
+          "name": "dockerImage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "args": {
+          "name": "args",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryReservation": {
+          "name": "memoryReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryLimit": {
+          "name": "memoryLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuReservation": {
+          "name": "cpuReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuLimit": {
+          "name": "cpuLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "externalPort": {
+          "name": "externalPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationStatus": {
+          "name": "applicationStatus",
+          "type": "applicationStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "healthCheckSwarm": {
+          "name": "healthCheckSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "restartPolicySwarm": {
+          "name": "restartPolicySwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "placementSwarm": {
+          "name": "placementSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updateConfigSwarm": {
+          "name": "updateConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rollbackConfigSwarm": {
+          "name": "rollbackConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "modeSwarm": {
+          "name": "modeSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "labelsSwarm": {
+          "name": "labelsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "networkSwarm": {
+          "name": "networkSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stopGracePeriodSwarm": {
+          "name": "stopGracePeriodSwarm",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customNetworkIds": {
+          "name": "customNetworkIds",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "endpointSpecSwarm": {
+          "name": "endpointSpecSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ulimitsSwarm": {
+          "name": "ulimitsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "replicas": {
+          "name": "replicas",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "environmentId": {
+          "name": "environmentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "replicaSets": {
+          "name": "replicaSets",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "mongo_environmentId_environment_environmentId_fk": {
+          "name": "mongo_environmentId_environment_environmentId_fk",
+          "tableFrom": "mongo",
+          "tableTo": "environment",
+          "columnsFrom": [
+            "environmentId"
+          ],
+          "columnsTo": [
+            "environmentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mongo_serverId_server_serverId_fk": {
+          "name": "mongo_serverId_server_serverId_fk",
+          "tableFrom": "mongo",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "mongo_appName_unique": {
+          "name": "mongo_appName_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "appName"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.mount": {
+      "name": "mount",
+      "schema": "",
+      "columns": {
+        "mountId": {
+          "name": "mountId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "mountType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "hostPath": {
+          "name": "hostPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "volumeName": {
+          "name": "volumeName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filePath": {
+          "name": "filePath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "serviceType": {
+          "name": "serviceType",
+          "type": "serviceType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'application'"
+        },
+        "mountPath": {
+          "name": "mountPath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "postgresId": {
+          "name": "postgresId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mariadbId": {
+          "name": "mariadbId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mongoId": {
+          "name": "mongoId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mysqlId": {
+          "name": "mysqlId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "redisId": {
+          "name": "redisId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "composeId": {
+          "name": "composeId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "mount_applicationId_application_applicationId_fk": {
+          "name": "mount_applicationId_application_applicationId_fk",
+          "tableFrom": "mount",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mount_postgresId_postgres_postgresId_fk": {
+          "name": "mount_postgresId_postgres_postgresId_fk",
+          "tableFrom": "mount",
+          "tableTo": "postgres",
+          "columnsFrom": [
+            "postgresId"
+          ],
+          "columnsTo": [
+            "postgresId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mount_mariadbId_mariadb_mariadbId_fk": {
+          "name": "mount_mariadbId_mariadb_mariadbId_fk",
+          "tableFrom": "mount",
+          "tableTo": "mariadb",
+          "columnsFrom": [
+            "mariadbId"
+          ],
+          "columnsTo": [
+            "mariadbId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mount_mongoId_mongo_mongoId_fk": {
+          "name": "mount_mongoId_mongo_mongoId_fk",
+          "tableFrom": "mount",
+          "tableTo": "mongo",
+          "columnsFrom": [
+            "mongoId"
+          ],
+          "columnsTo": [
+            "mongoId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mount_mysqlId_mysql_mysqlId_fk": {
+          "name": "mount_mysqlId_mysql_mysqlId_fk",
+          "tableFrom": "mount",
+          "tableTo": "mysql",
+          "columnsFrom": [
+            "mysqlId"
+          ],
+          "columnsTo": [
+            "mysqlId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mount_redisId_redis_redisId_fk": {
+          "name": "mount_redisId_redis_redisId_fk",
+          "tableFrom": "mount",
+          "tableTo": "redis",
+          "columnsFrom": [
+            "redisId"
+          ],
+          "columnsTo": [
+            "redisId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mount_composeId_compose_composeId_fk": {
+          "name": "mount_composeId_compose_composeId_fk",
+          "tableFrom": "mount",
+          "tableTo": "compose",
+          "columnsFrom": [
+            "composeId"
+          ],
+          "columnsTo": [
+            "composeId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.mysql": {
+      "name": "mysql",
+      "schema": "",
+      "columns": {
+        "mysqlId": {
+          "name": "mysqlId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "databaseName": {
+          "name": "databaseName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "databaseUser": {
+          "name": "databaseUser",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "databasePassword": {
+          "name": "databasePassword",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rootPassword": {
+          "name": "rootPassword",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dockerImage": {
+          "name": "dockerImage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "args": {
+          "name": "args",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryReservation": {
+          "name": "memoryReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryLimit": {
+          "name": "memoryLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuReservation": {
+          "name": "cpuReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuLimit": {
+          "name": "cpuLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "externalPort": {
+          "name": "externalPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationStatus": {
+          "name": "applicationStatus",
+          "type": "applicationStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "healthCheckSwarm": {
+          "name": "healthCheckSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "restartPolicySwarm": {
+          "name": "restartPolicySwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "placementSwarm": {
+          "name": "placementSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updateConfigSwarm": {
+          "name": "updateConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rollbackConfigSwarm": {
+          "name": "rollbackConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "modeSwarm": {
+          "name": "modeSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "labelsSwarm": {
+          "name": "labelsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "networkSwarm": {
+          "name": "networkSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stopGracePeriodSwarm": {
+          "name": "stopGracePeriodSwarm",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customNetworkIds": {
+          "name": "customNetworkIds",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "endpointSpecSwarm": {
+          "name": "endpointSpecSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ulimitsSwarm": {
+          "name": "ulimitsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "replicas": {
+          "name": "replicas",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "environmentId": {
+          "name": "environmentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "mysql_environmentId_environment_environmentId_fk": {
+          "name": "mysql_environmentId_environment_environmentId_fk",
+          "tableFrom": "mysql",
+          "tableTo": "environment",
+          "columnsFrom": [
+            "environmentId"
+          ],
+          "columnsTo": [
+            "environmentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "mysql_serverId_server_serverId_fk": {
+          "name": "mysql_serverId_server_serverId_fk",
+          "tableFrom": "mysql",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "mysql_appName_unique": {
+          "name": "mysql_appName_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "appName"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.network": {
+      "name": "network",
+      "schema": "",
+      "columns": {
+        "networkId": {
+          "name": "networkId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "networkName": {
+          "name": "networkName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "driver": {
+          "name": "driver",
+          "type": "networkDriver",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'bridge'"
+        },
+        "subnet": {
+          "name": "subnet",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gateway": {
+          "name": "gateway",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ipRange": {
+          "name": "ipRange",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "internal": {
+          "name": "internal",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "encrypted": {
+          "name": "encrypted",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "dockerNetworkId": {
+          "name": "dockerNetworkId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "projectId": {
+          "name": "projectId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "network_projectId_project_projectId_fk": {
+          "name": "network_projectId_project_projectId_fk",
+          "tableFrom": "network",
+          "tableTo": "project",
+          "columnsFrom": [
+            "projectId"
+          ],
+          "columnsTo": [
+            "projectId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "network_organizationId_organization_id_fk": {
+          "name": "network_organizationId_organization_id_fk",
+          "tableFrom": "network",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "network_serverId_server_serverId_fk": {
+          "name": "network_serverId_server_serverId_fk",
+          "tableFrom": "network",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.custom": {
+      "name": "custom",
+      "schema": "",
+      "columns": {
+        "customId": {
+          "name": "customId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "endpoint": {
+          "name": "endpoint",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "headers": {
+          "name": "headers",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.discord": {
+      "name": "discord",
+      "schema": "",
+      "columns": {
+        "discordId": {
+          "name": "discordId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "webhookUrl": {
+          "name": "webhookUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "decoration": {
+          "name": "decoration",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email": {
+      "name": "email",
+      "schema": "",
+      "columns": {
+        "emailId": {
+          "name": "emailId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "smtpServer": {
+          "name": "smtpServer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "smtpPort": {
+          "name": "smtpPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "fromAddress": {
+          "name": "fromAddress",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "toAddress": {
+          "name": "toAddress",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.gotify": {
+      "name": "gotify",
+      "schema": "",
+      "columns": {
+        "gotifyId": {
+          "name": "gotifyId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "serverUrl": {
+          "name": "serverUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appToken": {
+          "name": "appToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 5
+        },
+        "decoration": {
+          "name": "decoration",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.lark": {
+      "name": "lark",
+      "schema": "",
+      "columns": {
+        "larkId": {
+          "name": "larkId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "webhookUrl": {
+          "name": "webhookUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notification": {
+      "name": "notification",
+      "schema": "",
+      "columns": {
+        "notificationId": {
+          "name": "notificationId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appDeploy": {
+          "name": "appDeploy",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "appBuildError": {
+          "name": "appBuildError",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "databaseBackup": {
+          "name": "databaseBackup",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "volumeBackup": {
+          "name": "volumeBackup",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "dokployRestart": {
+          "name": "dokployRestart",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "dockerCleanup": {
+          "name": "dockerCleanup",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "serverThreshold": {
+          "name": "serverThreshold",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "notificationType": {
+          "name": "notificationType",
+          "type": "notificationType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slackId": {
+          "name": "slackId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "telegramId": {
+          "name": "telegramId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "discordId": {
+          "name": "discordId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "emailId": {
+          "name": "emailId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resendId": {
+          "name": "resendId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gotifyId": {
+          "name": "gotifyId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ntfyId": {
+          "name": "ntfyId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customId": {
+          "name": "customId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "larkId": {
+          "name": "larkId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pushoverId": {
+          "name": "pushoverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "teamsId": {
+          "name": "teamsId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "notification_slackId_slack_slackId_fk": {
+          "name": "notification_slackId_slack_slackId_fk",
+          "tableFrom": "notification",
+          "tableTo": "slack",
+          "columnsFrom": [
+            "slackId"
+          ],
+          "columnsTo": [
+            "slackId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_telegramId_telegram_telegramId_fk": {
+          "name": "notification_telegramId_telegram_telegramId_fk",
+          "tableFrom": "notification",
+          "tableTo": "telegram",
+          "columnsFrom": [
+            "telegramId"
+          ],
+          "columnsTo": [
+            "telegramId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_discordId_discord_discordId_fk": {
+          "name": "notification_discordId_discord_discordId_fk",
+          "tableFrom": "notification",
+          "tableTo": "discord",
+          "columnsFrom": [
+            "discordId"
+          ],
+          "columnsTo": [
+            "discordId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_emailId_email_emailId_fk": {
+          "name": "notification_emailId_email_emailId_fk",
+          "tableFrom": "notification",
+          "tableTo": "email",
+          "columnsFrom": [
+            "emailId"
+          ],
+          "columnsTo": [
+            "emailId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_resendId_resend_resendId_fk": {
+          "name": "notification_resendId_resend_resendId_fk",
+          "tableFrom": "notification",
+          "tableTo": "resend",
+          "columnsFrom": [
+            "resendId"
+          ],
+          "columnsTo": [
+            "resendId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_gotifyId_gotify_gotifyId_fk": {
+          "name": "notification_gotifyId_gotify_gotifyId_fk",
+          "tableFrom": "notification",
+          "tableTo": "gotify",
+          "columnsFrom": [
+            "gotifyId"
+          ],
+          "columnsTo": [
+            "gotifyId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_ntfyId_ntfy_ntfyId_fk": {
+          "name": "notification_ntfyId_ntfy_ntfyId_fk",
+          "tableFrom": "notification",
+          "tableTo": "ntfy",
+          "columnsFrom": [
+            "ntfyId"
+          ],
+          "columnsTo": [
+            "ntfyId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_customId_custom_customId_fk": {
+          "name": "notification_customId_custom_customId_fk",
+          "tableFrom": "notification",
+          "tableTo": "custom",
+          "columnsFrom": [
+            "customId"
+          ],
+          "columnsTo": [
+            "customId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_larkId_lark_larkId_fk": {
+          "name": "notification_larkId_lark_larkId_fk",
+          "tableFrom": "notification",
+          "tableTo": "lark",
+          "columnsFrom": [
+            "larkId"
+          ],
+          "columnsTo": [
+            "larkId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_pushoverId_pushover_pushoverId_fk": {
+          "name": "notification_pushoverId_pushover_pushoverId_fk",
+          "tableFrom": "notification",
+          "tableTo": "pushover",
+          "columnsFrom": [
+            "pushoverId"
+          ],
+          "columnsTo": [
+            "pushoverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_teamsId_teams_teamsId_fk": {
+          "name": "notification_teamsId_teams_teamsId_fk",
+          "tableFrom": "notification",
+          "tableTo": "teams",
+          "columnsFrom": [
+            "teamsId"
+          ],
+          "columnsTo": [
+            "teamsId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "notification_organizationId_organization_id_fk": {
+          "name": "notification_organizationId_organization_id_fk",
+          "tableFrom": "notification",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.ntfy": {
+      "name": "ntfy",
+      "schema": "",
+      "columns": {
+        "ntfyId": {
+          "name": "ntfyId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "serverUrl": {
+          "name": "serverUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "topic": {
+          "name": "topic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "accessToken": {
+          "name": "accessToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 3
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.pushover": {
+      "name": "pushover",
+      "schema": "",
+      "columns": {
+        "pushoverId": {
+          "name": "pushoverId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "userKey": {
+          "name": "userKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "apiToken": {
+          "name": "apiToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "retry": {
+          "name": "retry",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expire": {
+          "name": "expire",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.resend": {
+      "name": "resend",
+      "schema": "",
+      "columns": {
+        "resendId": {
+          "name": "resendId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "apiKey": {
+          "name": "apiKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "fromAddress": {
+          "name": "fromAddress",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "toAddress": {
+          "name": "toAddress",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.slack": {
+      "name": "slack",
+      "schema": "",
+      "columns": {
+        "slackId": {
+          "name": "slackId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "webhookUrl": {
+          "name": "webhookUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel": {
+          "name": "channel",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.teams": {
+      "name": "teams",
+      "schema": "",
+      "columns": {
+        "teamsId": {
+          "name": "teamsId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "webhookUrl": {
+          "name": "webhookUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.telegram": {
+      "name": "telegram",
+      "schema": "",
+      "columns": {
+        "telegramId": {
+          "name": "telegramId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "botToken": {
+          "name": "botToken",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "chatId": {
+          "name": "chatId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "messageThreadId": {
+          "name": "messageThreadId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.patch": {
+      "name": "patch",
+      "schema": "",
+      "columns": {
+        "patchId": {
+          "name": "patchId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "patchType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'update'"
+        },
+        "filePath": {
+          "name": "filePath",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updatedAt": {
+          "name": "updatedAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "composeId": {
+          "name": "composeId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "patch_applicationId_application_applicationId_fk": {
+          "name": "patch_applicationId_application_applicationId_fk",
+          "tableFrom": "patch",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "patch_composeId_compose_composeId_fk": {
+          "name": "patch_composeId_compose_composeId_fk",
+          "tableFrom": "patch",
+          "tableTo": "compose",
+          "columnsFrom": [
+            "composeId"
+          ],
+          "columnsTo": [
+            "composeId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "patch_filepath_application_unique": {
+          "name": "patch_filepath_application_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "filePath",
+            "applicationId"
+          ]
+        },
+        "patch_filepath_compose_unique": {
+          "name": "patch_filepath_compose_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "filePath",
+            "composeId"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.port": {
+      "name": "port",
+      "schema": "",
+      "columns": {
+        "portId": {
+          "name": "portId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "publishedPort": {
+          "name": "publishedPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "publishMode": {
+          "name": "publishMode",
+          "type": "publishModeType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'host'"
+        },
+        "targetPort": {
+          "name": "targetPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "protocol": {
+          "name": "protocol",
+          "type": "protocolType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "port_applicationId_application_applicationId_fk": {
+          "name": "port_applicationId_application_applicationId_fk",
+          "tableFrom": "port",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.postgres": {
+      "name": "postgres",
+      "schema": "",
+      "columns": {
+        "postgresId": {
+          "name": "postgresId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "databaseName": {
+          "name": "databaseName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "databaseUser": {
+          "name": "databaseUser",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "databasePassword": {
+          "name": "databasePassword",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dockerImage": {
+          "name": "dockerImage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "args": {
+          "name": "args",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryReservation": {
+          "name": "memoryReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "externalPort": {
+          "name": "externalPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryLimit": {
+          "name": "memoryLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuReservation": {
+          "name": "cpuReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuLimit": {
+          "name": "cpuLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationStatus": {
+          "name": "applicationStatus",
+          "type": "applicationStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "healthCheckSwarm": {
+          "name": "healthCheckSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "restartPolicySwarm": {
+          "name": "restartPolicySwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "placementSwarm": {
+          "name": "placementSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updateConfigSwarm": {
+          "name": "updateConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rollbackConfigSwarm": {
+          "name": "rollbackConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "modeSwarm": {
+          "name": "modeSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "labelsSwarm": {
+          "name": "labelsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "networkSwarm": {
+          "name": "networkSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stopGracePeriodSwarm": {
+          "name": "stopGracePeriodSwarm",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customNetworkIds": {
+          "name": "customNetworkIds",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "endpointSpecSwarm": {
+          "name": "endpointSpecSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ulimitsSwarm": {
+          "name": "ulimitsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "replicas": {
+          "name": "replicas",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "environmentId": {
+          "name": "environmentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "postgres_environmentId_environment_environmentId_fk": {
+          "name": "postgres_environmentId_environment_environmentId_fk",
+          "tableFrom": "postgres",
+          "tableTo": "environment",
+          "columnsFrom": [
+            "environmentId"
+          ],
+          "columnsTo": [
+            "environmentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "postgres_serverId_server_serverId_fk": {
+          "name": "postgres_serverId_server_serverId_fk",
+          "tableFrom": "postgres",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "postgres_appName_unique": {
+          "name": "postgres_appName_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "appName"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.preview_deployments": {
+      "name": "preview_deployments",
+      "schema": "",
+      "columns": {
+        "previewDeploymentId": {
+          "name": "previewDeploymentId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pullRequestId": {
+          "name": "pullRequestId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pullRequestNumber": {
+          "name": "pullRequestNumber",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pullRequestURL": {
+          "name": "pullRequestURL",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pullRequestTitle": {
+          "name": "pullRequestTitle",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pullRequestCommentId": {
+          "name": "pullRequestCommentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "previewStatus": {
+          "name": "previewStatus",
+          "type": "applicationStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "domainId": {
+          "name": "domainId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expiresAt": {
+          "name": "expiresAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "preview_deployments_applicationId_application_applicationId_fk": {
+          "name": "preview_deployments_applicationId_application_applicationId_fk",
+          "tableFrom": "preview_deployments",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "preview_deployments_domainId_domain_domainId_fk": {
+          "name": "preview_deployments_domainId_domain_domainId_fk",
+          "tableFrom": "preview_deployments",
+          "tableTo": "domain",
+          "columnsFrom": [
+            "domainId"
+          ],
+          "columnsTo": [
+            "domainId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "preview_deployments_appName_unique": {
+          "name": "preview_deployments_appName_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "appName"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.project": {
+      "name": "project",
+      "schema": "",
+      "columns": {
+        "projectId": {
+          "name": "projectId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_organizationId_organization_id_fk": {
+          "name": "project_organizationId_organization_id_fk",
+          "tableFrom": "project",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.redirect": {
+      "name": "redirect",
+      "schema": "",
+      "columns": {
+        "redirectId": {
+          "name": "redirectId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "regex": {
+          "name": "regex",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "replacement": {
+          "name": "replacement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permanent": {
+          "name": "permanent",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "uniqueConfigKey": {
+          "name": "uniqueConfigKey",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "redirect_applicationId_application_applicationId_fk": {
+          "name": "redirect_applicationId_application_applicationId_fk",
+          "tableFrom": "redirect",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.redis": {
+      "name": "redis",
+      "schema": "",
+      "columns": {
+        "redisId": {
+          "name": "redisId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dockerImage": {
+          "name": "dockerImage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "args": {
+          "name": "args",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryReservation": {
+          "name": "memoryReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "memoryLimit": {
+          "name": "memoryLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuReservation": {
+          "name": "cpuReservation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cpuLimit": {
+          "name": "cpuLimit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "externalPort": {
+          "name": "externalPort",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "applicationStatus": {
+          "name": "applicationStatus",
+          "type": "applicationStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        },
+        "healthCheckSwarm": {
+          "name": "healthCheckSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "restartPolicySwarm": {
+          "name": "restartPolicySwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "placementSwarm": {
+          "name": "placementSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updateConfigSwarm": {
+          "name": "updateConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rollbackConfigSwarm": {
+          "name": "rollbackConfigSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "modeSwarm": {
+          "name": "modeSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "labelsSwarm": {
+          "name": "labelsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "networkSwarm": {
+          "name": "networkSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stopGracePeriodSwarm": {
+          "name": "stopGracePeriodSwarm",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "customNetworkIds": {
+          "name": "customNetworkIds",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "endpointSpecSwarm": {
+          "name": "endpointSpecSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ulimitsSwarm": {
+          "name": "ulimitsSwarm",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "replicas": {
+          "name": "replicas",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "environmentId": {
+          "name": "environmentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "redis_environmentId_environment_environmentId_fk": {
+          "name": "redis_environmentId_environment_environmentId_fk",
+          "tableFrom": "redis",
+          "tableTo": "environment",
+          "columnsFrom": [
+            "environmentId"
+          ],
+          "columnsTo": [
+            "environmentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "redis_serverId_server_serverId_fk": {
+          "name": "redis_serverId_server_serverId_fk",
+          "tableFrom": "redis",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "redis_appName_unique": {
+          "name": "redis_appName_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "appName"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.registry": {
+      "name": "registry",
+      "schema": "",
+      "columns": {
+        "registryId": {
+          "name": "registryId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "registryName": {
+          "name": "registryName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "imagePrefix": {
+          "name": "imagePrefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "registryUrl": {
+          "name": "registryUrl",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "selfHosted": {
+          "name": "selfHosted",
+          "type": "RegistryType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'cloud'"
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "registry_organizationId_organization_id_fk": {
+          "name": "registry_organizationId_organization_id_fk",
+          "tableFrom": "registry",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.rollback": {
+      "name": "rollback",
+      "schema": "",
+      "columns": {
+        "rollbackId": {
+          "name": "rollbackId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "deploymentId": {
+          "name": "deploymentId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "version": {
+          "name": "version",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "fullContext": {
+          "name": "fullContext",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rollback_deploymentId_deployment_deploymentId_fk": {
+          "name": "rollback_deploymentId_deployment_deploymentId_fk",
+          "tableFrom": "rollback",
+          "tableTo": "deployment",
+          "columnsFrom": [
+            "deploymentId"
+          ],
+          "columnsTo": [
+            "deploymentId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.schedule": {
+      "name": "schedule",
+      "schema": "",
+      "columns": {
+        "scheduleId": {
+          "name": "scheduleId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cronExpression": {
+          "name": "cronExpression",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serviceName": {
+          "name": "serviceName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "shellType": {
+          "name": "shellType",
+          "type": "shellType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'bash'"
+        },
+        "scheduleType": {
+          "name": "scheduleType",
+          "type": "scheduleType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'application'"
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "script": {
+          "name": "script",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "composeId": {
+          "name": "composeId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "userId": {
+          "name": "userId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "schedule_applicationId_application_applicationId_fk": {
+          "name": "schedule_applicationId_application_applicationId_fk",
+          "tableFrom": "schedule",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "schedule_composeId_compose_composeId_fk": {
+          "name": "schedule_composeId_compose_composeId_fk",
+          "tableFrom": "schedule",
+          "tableTo": "compose",
+          "columnsFrom": [
+            "composeId"
+          ],
+          "columnsTo": [
+            "composeId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "schedule_serverId_server_serverId_fk": {
+          "name": "schedule_serverId_server_serverId_fk",
+          "tableFrom": "schedule",
+          "tableTo": "server",
+          "columnsFrom": [
+            "serverId"
+          ],
+          "columnsTo": [
+            "serverId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "schedule_userId_user_id_fk": {
+          "name": "schedule_userId_user_id_fk",
+          "tableFrom": "schedule",
+          "tableTo": "user",
+          "columnsFrom": [
+            "userId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.security": {
+      "name": "security",
+      "schema": "",
+      "columns": {
+        "securityId": {
+          "name": "securityId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "security_applicationId_application_applicationId_fk": {
+          "name": "security_applicationId_application_applicationId_fk",
+          "tableFrom": "security",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "security_username_applicationId_unique": {
+          "name": "security_username_applicationId_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "username",
+            "applicationId"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.server": {
+      "name": "server",
+      "schema": "",
+      "columns": {
+        "serverId": {
+          "name": "serverId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ipAddress": {
+          "name": "ipAddress",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "port": {
+          "name": "port",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'root'"
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enableDockerCleanup": {
+          "name": "enableDockerCleanup",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serverStatus": {
+          "name": "serverStatus",
+          "type": "serverStatus",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        },
+        "serverType": {
+          "name": "serverType",
+          "type": "serverType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'deploy'"
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "sshKeyId": {
+          "name": "sshKeyId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metricsConfig": {
+          "name": "metricsConfig",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"server\":{\"type\":\"Remote\",\"refreshRate\":60,\"port\":4500,\"token\":\"\",\"urlCallback\":\"\",\"cronJob\":\"\",\"retentionDays\":2,\"thresholds\":{\"cpu\":0,\"memory\":0}},\"containers\":{\"refreshRate\":60,\"services\":{\"include\":[],\"exclude\":[]}}}'::jsonb"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "server_organizationId_organization_id_fk": {
+          "name": "server_organizationId_organization_id_fk",
+          "tableFrom": "server",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "server_sshKeyId_ssh-key_sshKeyId_fk": {
+          "name": "server_sshKeyId_ssh-key_sshKeyId_fk",
+          "tableFrom": "server",
+          "tableTo": "ssh-key",
+          "columnsFrom": [
+            "sshKeyId"
+          ],
+          "columnsTo": [
+            "sshKeyId"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.session_temp": {
+      "name": "session_temp",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "impersonated_by": {
+          "name": "impersonated_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_organization_id": {
+          "name": "active_organization_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "session_temp_user_id_user_id_fk": {
+          "name": "session_temp_user_id_user_id_fk",
+          "tableFrom": "session_temp",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "session_temp_token_unique": {
+          "name": "session_temp_token_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "token"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.ssh-key": {
+      "name": "ssh-key",
+      "schema": "",
+      "columns": {
+        "sshKeyId": {
+          "name": "sshKeyId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "privateKey": {
+          "name": "privateKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "publicKey": {
+          "name": "publicKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "lastUsedAt": {
+          "name": "lastUsedAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "organizationId": {
+          "name": "organizationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "ssh-key_organizationId_organization_id_fk": {
+          "name": "ssh-key_organizationId_organization_id_fk",
+          "tableFrom": "ssh-key",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organizationId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sso_provider": {
+      "name": "sso_provider",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "oidc_config": {
+          "name": "oidc_config",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "saml_config": {
+          "name": "saml_config",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "domain": {
+          "name": "domain",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "sso_provider_user_id_user_id_fk": {
+          "name": "sso_provider_user_id_user_id_fk",
+          "tableFrom": "sso_provider",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "sso_provider_organization_id_organization_id_fk": {
+          "name": "sso_provider_organization_id_organization_id_fk",
+          "tableFrom": "sso_provider",
+          "tableTo": "organization",
+          "columnsFrom": [
+            "organization_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sso_provider_provider_id_unique": {
+          "name": "sso_provider_provider_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "provider_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user": {
+      "name": "user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "firstName": {
+          "name": "firstName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "lastName": {
+          "name": "lastName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "isRegistered": {
+          "name": "isRegistered",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "expirationDate": {
+          "name": "expirationDate",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "two_factor_enabled": {
+          "name": "two_factor_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned": {
+          "name": "banned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_reason": {
+          "name": "ban_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_expires": {
+          "name": "ban_expires",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'user'"
+        },
+        "enablePaidFeatures": {
+          "name": "enablePaidFeatures",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "allowImpersonation": {
+          "name": "allowImpersonation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "enableEnterpriseFeatures": {
+          "name": "enableEnterpriseFeatures",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "licenseKey": {
+          "name": "licenseKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "isValidEnterpriseLicense": {
+          "name": "isValidEnterpriseLicense",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "stripeCustomerId": {
+          "name": "stripeCustomerId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stripeSubscriptionId": {
+          "name": "stripeSubscriptionId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "serversQuantity": {
+          "name": "serversQuantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "trustedOrigins": {
+          "name": "trustedOrigins",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "user_email_unique": {
+          "name": "user_email_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "email"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.volume_backup": {
+      "name": "volume_backup",
+      "schema": "",
+      "columns": {
+        "volumeBackupId": {
+          "name": "volumeBackupId",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "volumeName": {
+          "name": "volumeName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serviceType": {
+          "name": "serviceType",
+          "type": "serviceType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'application'"
+        },
+        "appName": {
+          "name": "appName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "serviceName": {
+          "name": "serviceName",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "turnOff": {
+          "name": "turnOff",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "cronExpression": {
+          "name": "cronExpression",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "keepLatestCount": {
+          "name": "keepLatestCount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applicationId": {
+          "name": "applicationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "postgresId": {
+          "name": "postgresId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mariadbId": {
+          "name": "mariadbId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mongoId": {
+          "name": "mongoId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mysqlId": {
+          "name": "mysqlId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "redisId": {
+          "name": "redisId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "composeId": {
+          "name": "composeId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "destinationId": {
+          "name": "destinationId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "volume_backup_applicationId_application_applicationId_fk": {
+          "name": "volume_backup_applicationId_application_applicationId_fk",
+          "tableFrom": "volume_backup",
+          "tableTo": "application",
+          "columnsFrom": [
+            "applicationId"
+          ],
+          "columnsTo": [
+            "applicationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "volume_backup_postgresId_postgres_postgresId_fk": {
+          "name": "volume_backup_postgresId_postgres_postgresId_fk",
+          "tableFrom": "volume_backup",
+          "tableTo": "postgres",
+          "columnsFrom": [
+            "postgresId"
+          ],
+          "columnsTo": [
+            "postgresId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "volume_backup_mariadbId_mariadb_mariadbId_fk": {
+          "name": "volume_backup_mariadbId_mariadb_mariadbId_fk",
+          "tableFrom": "volume_backup",
+          "tableTo": "mariadb",
+          "columnsFrom": [
+            "mariadbId"
+          ],
+          "columnsTo": [
+            "mariadbId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "volume_backup_mongoId_mongo_mongoId_fk": {
+          "name": "volume_backup_mongoId_mongo_mongoId_fk",
+          "tableFrom": "volume_backup",
+          "tableTo": "mongo",
+          "columnsFrom": [
+            "mongoId"
+          ],
+          "columnsTo": [
+            "mongoId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "volume_backup_mysqlId_mysql_mysqlId_fk": {
+          "name": "volume_backup_mysqlId_mysql_mysqlId_fk",
+          "tableFrom": "volume_backup",
+          "tableTo": "mysql",
+          "columnsFrom": [
+            "mysqlId"
+          ],
+          "columnsTo": [
+            "mysqlId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "volume_backup_redisId_redis_redisId_fk": {
+          "name": "volume_backup_redisId_redis_redisId_fk",
+          "tableFrom": "volume_backup",
+          "tableTo": "redis",
+          "columnsFrom": [
+            "redisId"
+          ],
+          "columnsTo": [
+            "redisId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "volume_backup_composeId_compose_composeId_fk": {
+          "name": "volume_backup_composeId_compose_composeId_fk",
+          "tableFrom": "volume_backup",
+          "tableTo": "compose",
+          "columnsFrom": [
+            "composeId"
+          ],
+          "columnsTo": [
+            "composeId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "volume_backup_destinationId_destination_destinationId_fk": {
+          "name": "volume_backup_destinationId_destination_destinationId_fk",
+          "tableFrom": "volume_backup",
+          "tableTo": "destination",
+          "columnsFrom": [
+            "destinationId"
+          ],
+          "columnsTo": [
+            "destinationId"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.webServerSettings": {
+      "name": "webServerSettings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "serverIp": {
+          "name": "serverIp",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "certificateType": {
+          "name": "certificateType",
+          "type": "certificateType",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'none'"
+        },
+        "https": {
+          "name": "https",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "host": {
+          "name": "host",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "letsEncryptEmail": {
+          "name": "letsEncryptEmail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sshPrivateKey": {
+          "name": "sshPrivateKey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enableDockerCleanup": {
+          "name": "enableDockerCleanup",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "logCleanupCron": {
+          "name": "logCleanupCron",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'0 0 * * *'"
+        },
+        "metricsConfig": {
+          "name": "metricsConfig",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"server\":{\"type\":\"Dokploy\",\"refreshRate\":60,\"port\":4500,\"token\":\"\",\"retentionDays\":2,\"cronJob\":\"\",\"urlCallback\":\"\",\"thresholds\":{\"cpu\":0,\"memory\":0}},\"containers\":{\"refreshRate\":60,\"services\":{\"include\":[],\"exclude\":[]}}}'::jsonb"
+        },
+        "cleanupCacheApplications": {
+          "name": "cleanupCacheApplications",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "cleanupCacheOnPreviews": {
+          "name": "cleanupCacheOnPreviews",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "cleanupCacheOnCompose": {
+          "name": "cleanupCacheOnCompose",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.buildType": {
+      "name": "buildType",
+      "schema": "public",
+      "values": [
+        "dockerfile",
+        "heroku_buildpacks",
+        "paketo_buildpacks",
+        "nixpacks",
+        "static",
+        "railpack"
+      ]
+    },
+    "public.sourceType": {
+      "name": "sourceType",
+      "schema": "public",
+      "values": [
+        "docker",
+        "git",
+        "github",
+        "gitlab",
+        "bitbucket",
+        "gitea",
+        "drop"
+      ]
+    },
+    "public.backupType": {
+      "name": "backupType",
+      "schema": "public",
+      "values": [
+        "database",
+        "compose"
+      ]
+    },
+    "public.databaseType": {
+      "name": "databaseType",
+      "schema": "public",
+      "values": [
+        "postgres",
+        "mariadb",
+        "mysql",
+        "mongo",
+        "web-server"
+      ]
+    },
+    "public.composeType": {
+      "name": "composeType",
+      "schema": "public",
+      "values": [
+        "docker-compose",
+        "stack"
+      ]
+    },
+    "public.sourceTypeCompose": {
+      "name": "sourceTypeCompose",
+      "schema": "public",
+      "values": [
+        "git",
+        "github",
+        "gitlab",
+        "bitbucket",
+        "gitea",
+        "raw"
+      ]
+    },
+    "public.deploymentStatus": {
+      "name": "deploymentStatus",
+      "schema": "public",
+      "values": [
+        "running",
+        "done",
+        "error",
+        "cancelled"
+      ]
+    },
+    "public.domainType": {
+      "name": "domainType",
+      "schema": "public",
+      "values": [
+        "compose",
+        "application",
+        "preview"
+      ]
+    },
+    "public.gitProviderType": {
+      "name": "gitProviderType",
+      "schema": "public",
+      "values": [
+        "github",
+        "gitlab",
+        "bitbucket",
+        "gitea"
+      ]
+    },
+    "public.mountType": {
+      "name": "mountType",
+      "schema": "public",
+      "values": [
+        "bind",
+        "volume",
+        "file"
+      ]
+    },
+    "public.serviceType": {
+      "name": "serviceType",
+      "schema": "public",
+      "values": [
+        "application",
+        "postgres",
+        "mysql",
+        "mariadb",
+        "mongo",
+        "redis",
+        "compose"
+      ]
+    },
+    "public.networkDriver": {
+      "name": "networkDriver",
+      "schema": "public",
+      "values": [
+        "bridge",
+        "overlay"
+      ]
+    },
+    "public.notificationType": {
+      "name": "notificationType",
+      "schema": "public",
+      "values": [
+        "slack",
+        "telegram",
+        "discord",
+        "email",
+        "resend",
+        "gotify",
+        "ntfy",
+        "pushover",
+        "custom",
+        "lark",
+        "teams"
+      ]
+    },
+    "public.patchType": {
+      "name": "patchType",
+      "schema": "public",
+      "values": [
+        "create",
+        "update",
+        "delete"
+      ]
+    },
+    "public.protocolType": {
+      "name": "protocolType",
+      "schema": "public",
+      "values": [
+        "tcp",
+        "udp"
+      ]
+    },
+    "public.publishModeType": {
+      "name": "publishModeType",
+      "schema": "public",
+      "values": [
+        "ingress",
+        "host"
+      ]
+    },
+    "public.RegistryType": {
+      "name": "RegistryType",
+      "schema": "public",
+      "values": [
+        "selfHosted",
+        "cloud"
+      ]
+    },
+    "public.scheduleType": {
+      "name": "scheduleType",
+      "schema": "public",
+      "values": [
+        "application",
+        "compose",
+        "server",
+        "dokploy-server"
+      ]
+    },
+    "public.shellType": {
+      "name": "shellType",
+      "schema": "public",
+      "values": [
+        "bash",
+        "sh"
+      ]
+    },
+    "public.serverStatus": {
+      "name": "serverStatus",
+      "schema": "public",
+      "values": [
+        "active",
+        "inactive"
+      ]
+    },
+    "public.serverType": {
+      "name": "serverType",
+      "schema": "public",
+      "values": [
+        "deploy",
+        "build"
+      ]
+    },
+    "public.applicationStatus": {
+      "name": "applicationStatus",
+      "schema": "public",
+      "values": [
+        "idle",
+        "running",
+        "done",
+        "error"
+      ]
+    },
+    "public.certificateType": {
+      "name": "certificateType",
+      "schema": "public",
+      "values": [
+        "letsencrypt",
+        "none",
+        "custom"
+      ]
+    },
+    "public.triggerType": {
+      "name": "triggerType",
+      "schema": "public",
+      "values": [
+        "push",
+        "tag"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
\ No newline at end of file
diff --git a/apps/dokploy/drizzle/meta/_journal.json b/apps/dokploy/drizzle/meta/_journal.json
index b09199e7f0..fb88d85568 100644
--- a/apps/dokploy/drizzle/meta/_journal.json
+++ b/apps/dokploy/drizzle/meta/_journal.json
@@ -1023,6 +1023,13 @@
       "when": 1771447229358,
       "tag": "0145_remarkable_titania",
       "breakpoints": true
+    },
+    {
+      "idx": 146,
+      "version": "7",
+      "when": 1771536782167,
+      "tag": "0146_secret_randall_flagg",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/apps/dokploy/pages/dashboard/networks.tsx b/apps/dokploy/pages/dashboard/networks.tsx
new file mode 100644
index 0000000000..19baa4f380
--- /dev/null
+++ b/apps/dokploy/pages/dashboard/networks.tsx
@@ -0,0 +1,107 @@
+import { validateRequest } from "@dokploy/server/lib/auth";
+import { createServerSideHelpers } from "@trpc/react-query/server";
+import type {
+	GetServerSidePropsContext,
+	InferGetServerSidePropsType,
+} from "next";
+import Head from "next/head";
+import type { ReactElement } from "react";
+import superjson from "superjson";
+import { CreateNetwork } from "@/components/dashboard/network/create-network";
+import { NetworkList } from "@/components/dashboard/network/network-list";
+import { SyncNetworks } from "@/components/dashboard/network/sync-networks";
+import { DashboardLayout } from "@/components/layouts/dashboard-layout";
+import { BreadcrumbSidebar } from "@/components/shared/breadcrumb-sidebar";
+import {
+	Card,
+	CardContent,
+	CardDescription,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import { appRouter } from "@/server/api/root";
+
+const NetworksPage = (
+	_props: InferGetServerSidePropsType<typeof getServerSideProps>,
+) => {
+	return (
+		<div className="pb-10">
+			<Head>
+				<title>Networks | Dokploy</title>
+			</Head>
+			<div className="w-full">
+				<Card className="h-full bg-sidebar p-2.5 rounded-xl">
+					<div className="rounded-xl bg-background shadow-md space-y-4">
+						<Card className="bg-background">
+							<CardHeader className="p-4 sm:p-6">
+								<div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
+									<div className="space-y-1 flex-1">
+										<CardTitle>Custom Networks</CardTitle>
+										<CardDescription>
+											Manage Docker networks for service isolation and
+											communication control across your organization
+										</CardDescription>
+									</div>
+									<div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:gap-2 flex-shrink-0">
+										<SyncNetworks />
+										<CreateNetwork />
+									</div>
+								</div>
+							</CardHeader>
+							<CardContent>
+								<NetworkList />
+							</CardContent>
+						</Card>
+					</div>
+				</Card>
+			</div>
+		</div>
+	);
+};
+
+export default NetworksPage;
+NetworksPage.getLayout = (page: ReactElement) => {
+	return <DashboardLayout>{page}</DashboardLayout>;
+};
+
+export async function getServerSideProps(ctx: GetServerSidePropsContext) {
+	const { req, res } = ctx;
+	const { user, session } = await validateRequest(req);
+	if (!user) {
+		return {
+			redirect: {
+				permanent: true,
+				destination: "/",
+			},
+		};
+	}
+
+	const helpers = createServerSideHelpers({
+		router: appRouter,
+		ctx: {
+			req,
+			res,
+			db: null,
+			session,
+			user,
+		},
+		transformer: superjson,
+	});
+
+	try {
+		await helpers.network.all.prefetch();
+
+		return {
+			props: {
+				trpcState: helpers.dehydrate(),
+			},
+		};
+	} catch {
+		return {
+			redirect: {
+				permanent: false,
+				destination: "/dashboard/projects",
+			},
+		};
+	}
+}
diff --git a/apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/application/[applicationId].tsx b/apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/application/[applicationId].tsx
index c17f92052a..823f01a826 100644
--- a/apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/application/[applicationId].tsx
+++ b/apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/application/[applicationId].tsx
@@ -34,6 +34,7 @@ import { ShowVolumeBackups } from "@/components/dashboard/application/volume-bac
 import { DeleteService } from "@/components/dashboard/compose/delete-service";
 import { ContainerFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-container-monitoring";
 import { ContainerPaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-container-monitoring";
+import { AssignNetworkToResource } from "@/components/dashboard/network/assign-network-to-resource";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { BreadcrumbSidebar } from "@/components/shared/breadcrumb-sidebar";
 import { StatusTooltip } from "@/components/shared/status-tooltip";
@@ -378,6 +379,11 @@ const Service = (
 											<ShowBuildServer applicationId={applicationId} />
 											<ShowResources id={applicationId} type="application" />
 											<ShowVolumes id={applicationId} type="application" />
+											<AssignNetworkToResource
+												resourceId={applicationId}
+												resourceType="application"
+												showCard
+											/>
 											<ShowRedirects applicationId={applicationId} />
 											<ShowSecurity applicationId={applicationId} />
 											<ShowPorts applicationId={applicationId} />
diff --git a/apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/compose/[composeId].tsx b/apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/compose/[composeId].tsx
index 3b731ee08b..702d51c260 100644
--- a/apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/compose/[composeId].tsx
+++ b/apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/compose/[composeId].tsx
@@ -21,7 +21,6 @@ import { ShowPatches } from "@/components/dashboard/application/patches/show-pat
 import { ShowSchedules } from "@/components/dashboard/application/schedules/show-schedules";
 import { ShowVolumeBackups } from "@/components/dashboard/application/volume-backups/show-volume-backups";
 import { AddCommandCompose } from "@/components/dashboard/compose/advanced/add-command";
-import { IsolatedDeploymentTab } from "@/components/dashboard/compose/advanced/add-isolation";
 import { DeleteService } from "@/components/dashboard/compose/delete-service";
 import { ShowGeneralCompose } from "@/components/dashboard/compose/general/show";
 import { ShowDockerLogsCompose } from "@/components/dashboard/compose/logs/show";
@@ -30,6 +29,7 @@ import { UpdateCompose } from "@/components/dashboard/compose/update-compose";
 import { ShowBackups } from "@/components/dashboard/database/backups/show-backups";
 import { ComposeFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-compose-monitoring";
 import { ComposePaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-compose-monitoring";
+import { AssignNetworkToResource } from "@/components/dashboard/network/assign-network-to-resource";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { BreadcrumbSidebar } from "@/components/shared/breadcrumb-sidebar";
 import { StatusTooltip } from "@/components/shared/status-tooltip";
@@ -376,7 +376,12 @@ const Service = (
 											<AddCommandCompose composeId={composeId} />
 											<ShowVolumes id={composeId} type="compose" />
 											<ShowImport composeId={composeId} />
-											<IsolatedDeploymentTab composeId={composeId} />
+											<AssignNetworkToResource
+												resourceId={composeId}
+												resourceType="compose"
+												composeType={data?.composeType}
+												showCard
+											/>
 										</div>
 									</TabsContent>
 								</Tabs>
diff --git a/apps/dokploy/server/api/root.ts b/apps/dokploy/server/api/root.ts
index f123fde854..c4deb3593e 100644
--- a/apps/dokploy/server/api/root.ts
+++ b/apps/dokploy/server/api/root.ts
@@ -20,6 +20,7 @@ import { mariadbRouter } from "./routers/mariadb";
 import { mongoRouter } from "./routers/mongo";
 import { mountRouter } from "./routers/mount";
 import { mysqlRouter } from "./routers/mysql";
+import { networkRouter } from "./routers/network";
 import { notificationRouter } from "./routers/notification";
 import { organizationRouter } from "./routers/organization";
 import { patchRouter } from "./routers/patch";
@@ -66,6 +67,7 @@ export const appRouter = createTRPCRouter({
 	deployment: deploymentRouter,
 	previewDeployment: previewDeploymentRouter,
 	mounts: mountRouter,
+	network: networkRouter,
 	certificates: certificateRouter,
 	settings: settingsRouter,
 	security: securityRouter,
diff --git a/apps/dokploy/server/api/routers/ai.ts b/apps/dokploy/server/api/routers/ai.ts
index ff2d1ee8a8..727ea21695 100644
--- a/apps/dokploy/server/api/routers/ai.ts
+++ b/apps/dokploy/server/api/routers/ai.ts
@@ -248,7 +248,6 @@ export const aiRouter = createTRPCRouter({
 				name: input.name,
 				sourceType: "raw",
 				appName: `${projectName}-${generatePassword(6)}`,
-				isolatedDeployment: true,
 				environmentId: input.environmentId,
 			});
 
diff --git a/apps/dokploy/server/api/routers/compose.ts b/apps/dokploy/server/api/routers/compose.ts
index 665b6770b7..606b4c6d8f 100644
--- a/apps/dokploy/server/api/routers/compose.ts
+++ b/apps/dokploy/server/api/routers/compose.ts
@@ -18,6 +18,8 @@ import {
 	findGitProviderById,
 	findProjectById,
 	findServerById,
+	findUserById,
+	generateFullComposePreview,
 	getComposeContainer,
 	getWebServerSettings,
 	IS_CLOUD,
@@ -383,24 +385,6 @@ export const composeRouter = createTRPCRouter({
 			}
 			return await randomizeComposeFile(input.composeId, input.suffix);
 		}),
-	isolatedDeployment: protectedProcedure
-		.input(apiRandomizeCompose)
-		.mutation(async ({ input, ctx }) => {
-			const compose = await findComposeById(input.composeId);
-			if (
-				compose.environment.project.organizationId !==
-				ctx.session.activeOrganizationId
-			) {
-				throw new TRPCError({
-					code: "UNAUTHORIZED",
-					message: "You are not authorized to randomize this compose",
-				});
-			}
-			return await randomizeIsolatedDeploymentComposeFile(
-				input.composeId,
-				input.suffix,
-			);
-		}),
 	getConvertedCompose: protectedProcedure
 		.input(apiFindCompose)
 		.query(async ({ input, ctx }) => {
@@ -642,7 +626,6 @@ export const composeRouter = createTRPCRouter({
 				name: input.id,
 				sourceType: "raw",
 				appName: appName,
-				isolatedDeployment: true,
 			});
 
 			if (ctx.user.role === "member") {
@@ -962,7 +945,6 @@ export const composeRouter = createTRPCRouter({
 					composeFile: templateData.compose,
 					sourceType: "raw",
 					env: processedTemplate.envs?.join("\n"),
-					isolatedDeployment: true,
 				});
 
 				if (processedTemplate.mounts && processedTemplate.mounts.length > 0) {
diff --git a/apps/dokploy/server/api/routers/domain.ts b/apps/dokploy/server/api/routers/domain.ts
index 861c3b9b6f..788396ed4d 100644
--- a/apps/dokploy/server/api/routers/domain.ts
+++ b/apps/dokploy/server/api/routers/domain.ts
@@ -1,5 +1,6 @@
 import {
 	createDomain,
+	disconnectTraefikFromResourceNetworks,
 	findApplicationById,
 	findComposeById,
 	findDomainById,
@@ -10,9 +11,10 @@ import {
 	generateTraefikMeDomain,
 	getWebServerSettings,
 	manageDomain,
+	mechanizeDockerContainer,
 	removeDomain,
 	removeDomainById,
-	updateDomainById,
+	updateDomain,
 	validateDomain,
 } from "@dokploy/server";
 import { TRPCError } from "@trpc/server";
@@ -26,6 +28,53 @@ import {
 	apiUpdateDomain,
 } from "@/server/db/schema";
 
+type AuthorizationContext = {
+	activeOrganizationId: string;
+};
+
+const validateDomainAccess = async (
+	domainId: string,
+	ctx: AuthorizationContext,
+): Promise<void> => {
+	const domain = await findDomainById(domainId);
+
+	if (domain.applicationId) {
+		const application = await findApplicationById(domain.applicationId);
+		if (
+			application.environment.project.organizationId !==
+			ctx.activeOrganizationId
+		) {
+			throw new TRPCError({
+				code: "UNAUTHORIZED",
+				message: "You are not authorized to access this application",
+			});
+		}
+	} else if (domain.composeId) {
+		const compose = await findComposeById(domain.composeId);
+		if (
+			compose.environment.project.organizationId !== ctx.activeOrganizationId
+		) {
+			throw new TRPCError({
+				code: "UNAUTHORIZED",
+				message: "You are not authorized to access this compose",
+			});
+		}
+	} else if (domain.previewDeploymentId) {
+		const previewDeployment = await findPreviewDeploymentById(
+			domain.previewDeploymentId,
+		);
+		if (
+			previewDeployment.application.environment.project.organizationId !==
+			ctx.activeOrganizationId
+		) {
+			throw new TRPCError({
+				code: "UNAUTHORIZED",
+				message: "You are not authorized to access this preview deployment",
+			});
+		}
+	}
+};
+
 export const domainRouter = createTRPCRouter({
 	create: protectedProcedure
 		.input(apiCreateDomain)
@@ -119,46 +168,11 @@ export const domainRouter = createTRPCRouter({
 	update: protectedProcedure
 		.input(apiUpdateDomain)
 		.mutation(async ({ input, ctx }) => {
-			const currentDomain = await findDomainById(input.domainId);
+			await validateDomainAccess(input.domainId, ctx.session);
 
-			if (currentDomain.applicationId) {
-				const newApp = await findApplicationById(currentDomain.applicationId);
-				if (
-					newApp.environment.project.organizationId !==
-					ctx.session.activeOrganizationId
-				) {
-					throw new TRPCError({
-						code: "UNAUTHORIZED",
-						message: "You are not authorized to access this application",
-					});
-				}
-			} else if (currentDomain.composeId) {
-				const newCompose = await findComposeById(currentDomain.composeId);
-				if (
-					newCompose.environment.project.organizationId !==
-					ctx.session.activeOrganizationId
-				) {
-					throw new TRPCError({
-						code: "UNAUTHORIZED",
-						message: "You are not authorized to access this compose",
-					});
-				}
-			} else if (currentDomain.previewDeploymentId) {
-				const newPreviewDeployment = await findPreviewDeploymentById(
-					currentDomain.previewDeploymentId,
-				);
-				if (
-					newPreviewDeployment.application.environment.project
-						.organizationId !== ctx.session.activeOrganizationId
-				) {
-					throw new TRPCError({
-						code: "UNAUTHORIZED",
-						message: "You are not authorized to access this preview deployment",
-					});
-				}
-			}
-			const result = await updateDomainById(input.domainId, input);
+			const result = await updateDomain(input.domainId, input);
 			const domain = await findDomainById(input.domainId);
+
 			if (domain.applicationId) {
 				const application = await findApplicationById(domain.applicationId);
 				await manageDomain(application, domain);
@@ -172,67 +186,41 @@ export const domainRouter = createTRPCRouter({
 				application.appName = previewDeployment.appName;
 				await manageDomain(application, domain);
 			}
+
 			return result;
 		}),
 	one: protectedProcedure.input(apiFindDomain).query(async ({ input, ctx }) => {
-		const domain = await findDomainById(input.domainId);
-		if (domain.applicationId) {
-			const application = await findApplicationById(domain.applicationId);
-			if (
-				application.environment.project.organizationId !==
-				ctx.session.activeOrganizationId
-			) {
-				throw new TRPCError({
-					code: "UNAUTHORIZED",
-					message: "You are not authorized to access this application",
-				});
-			}
-		} else if (domain.composeId) {
-			const compose = await findComposeById(domain.composeId);
-			if (
-				compose.environment.project.organizationId !==
-				ctx.session.activeOrganizationId
-			) {
-				throw new TRPCError({
-					code: "UNAUTHORIZED",
-					message: "You are not authorized to access this compose",
-				});
-			}
-		}
+		await validateDomainAccess(input.domainId, ctx.session);
 		return await findDomainById(input.domainId);
 	}),
 	delete: protectedProcedure
 		.input(apiFindDomain)
 		.mutation(async ({ input, ctx }) => {
+			await validateDomainAccess(input.domainId, ctx.session);
+
 			const domain = await findDomainById(input.domainId);
-			if (domain.applicationId) {
-				const application = await findApplicationById(domain.applicationId);
-				if (
-					application.environment.project.organizationId !==
-					ctx.session.activeOrganizationId
-				) {
-					throw new TRPCError({
-						code: "UNAUTHORIZED",
-						message: "You are not authorized to access this application",
-					});
-				}
-			} else if (domain.composeId) {
-				const compose = await findComposeById(domain.composeId);
-				if (
-					compose.environment.project.organizationId !==
-					ctx.session.activeOrganizationId
-				) {
-					throw new TRPCError({
-						code: "UNAUTHORIZED",
-						message: "You are not authorized to access this compose",
-					});
-				}
-			}
 			const result = await removeDomainById(input.domainId);
 
 			if (domain.applicationId) {
 				const application = await findApplicationById(domain.applicationId);
 				await removeDomain(application, domain.uniqueConfigKey);
+				await mechanizeDockerContainer(application);
+
+				await disconnectTraefikFromResourceNetworks(
+					domain.applicationId,
+					"application",
+					application.serverId,
+					domain.networkId,
+				);
+			} else if (domain.composeId) {
+				const compose = await findComposeById(domain.composeId);
+
+				await disconnectTraefikFromResourceNetworks(
+					domain.composeId,
+					"compose",
+					compose.serverId,
+					domain.networkId,
+				);
 			}
 
 			return result;
diff --git a/apps/dokploy/server/api/routers/network.ts b/apps/dokploy/server/api/routers/network.ts
new file mode 100644
index 0000000000..f10e571edb
--- /dev/null
+++ b/apps/dokploy/server/api/routers/network.ts
@@ -0,0 +1,364 @@
+import {
+	assignNetworkToResource,
+	createNetwork,
+	deleteNetwork,
+	findNetworkById,
+	findNetworksByOrganizationId,
+	findNetworksByOrganizationIdAndServerId,
+	findResourceById,
+	getAllNetworksByServer,
+	getResourceNetworks,
+	importOrphanedNetworks,
+	listServerNetworks,
+	removeNetworkFromResource,
+	syncNetworks,
+	updateNetwork,
+} from "@dokploy/server";
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "@/server/api/trpc";
+import {
+	apiCreateNetwork,
+	apiFindOneNetwork,
+	apiRemoveNetwork,
+	apiUpdateNetwork,
+} from "@/server/db/schema";
+
+const RESOURCE_TYPE_ENUM = z.enum([
+	"application",
+	"compose",
+	"postgres",
+	"mysql",
+	"mariadb",
+	"mongo",
+	"redis",
+] as const);
+
+const RESOURCE_TYPE_WITH_PREVIEW_ENUM = z.enum([
+	"application",
+	"compose",
+	"postgres",
+	"mysql",
+	"mariadb",
+	"mongo",
+	"redis",
+	"preview",
+] as const);
+
+const handleTRPCError = (
+	error: unknown,
+	message: string,
+	logMessage: string,
+) => {
+	console.error(logMessage, error);
+	if (error instanceof TRPCError) {
+		throw error;
+	}
+	throw new TRPCError({
+		code: "INTERNAL_SERVER_ERROR",
+		message,
+		cause: error,
+	});
+};
+
+const verifyNetworkAccess = async (
+	networkId: string,
+	organizationId: string,
+) => {
+	const network = await findNetworkById(networkId);
+
+	if (network.organizationId !== organizationId) {
+		throw new TRPCError({
+			code: "FORBIDDEN",
+			message: "You do not have access to this network",
+		});
+	}
+
+	return network;
+};
+
+export const networkRouter = createTRPCRouter({
+	create: protectedProcedure
+		.input(apiCreateNetwork)
+		.mutation(async ({ input, ctx }) => {
+			const networkInput = {
+				...input,
+				organizationId: ctx.session.activeOrganizationId,
+			};
+
+			try {
+				return await createNetwork(networkInput);
+			} catch (error) {
+				handleTRPCError(
+					error,
+					"Failed to create network",
+					"Error creating network:",
+				);
+			}
+		}),
+
+	one: protectedProcedure.input(apiFindOneNetwork).query(async ({ input }) => {
+		return await findNetworkById(input.networkId);
+	}),
+
+	all: protectedProcedure.query(async ({ ctx }) => {
+		return await findNetworksByOrganizationId(ctx.session.activeOrganizationId);
+	}),
+
+	allForResource: protectedProcedure
+		.input(
+			z.object({
+				resourceType: RESOURCE_TYPE_ENUM,
+				resourceId: z.string().min(1),
+				composeType: z.enum(["docker-compose", "stack"]).optional(),
+			}),
+		)
+		.query(async ({ input, ctx }) => {
+			const resource = await findResourceById(
+				input.resourceId,
+				input.resourceType,
+			);
+			const resourceServerId = resource.serverId || null;
+
+			const networks = await findNetworksByOrganizationIdAndServerId(
+				ctx.session.activeOrganizationId,
+				resourceServerId,
+			);
+
+			if (
+				input.resourceType === "compose" &&
+				input.composeType === "docker-compose"
+			) {
+				return networks;
+			}
+
+			return networks.filter((network) => network.driver === "overlay");
+		}),
+
+	update: protectedProcedure
+		.input(apiUpdateNetwork)
+		.mutation(async ({ input, ctx }) => {
+			await verifyNetworkAccess(
+				input.networkId,
+				ctx.session.activeOrganizationId,
+			);
+
+			try {
+				return await updateNetwork(input.networkId, input);
+			} catch (error) {
+				handleTRPCError(
+					error,
+					"Failed to update network",
+					"Error updating network:",
+				);
+			}
+		}),
+
+	delete: protectedProcedure
+		.input(apiRemoveNetwork)
+		.mutation(async ({ input, ctx }) => {
+			await verifyNetworkAccess(
+				input.networkId,
+				ctx.session.activeOrganizationId,
+			);
+
+			try {
+				return await deleteNetwork(input.networkId);
+			} catch (error) {
+				handleTRPCError(
+					error,
+					"Failed to delete network",
+					"Error deleting network:",
+				);
+			}
+		}),
+
+	assignToResource: protectedProcedure
+		.input(
+			z.object({
+				networkId: z.string().min(1),
+				resourceId: z.string().min(1),
+				resourceType: RESOURCE_TYPE_ENUM,
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			await verifyNetworkAccess(
+				input.networkId,
+				ctx.session.activeOrganizationId,
+			);
+
+			try {
+				return await assignNetworkToResource(
+					input.networkId,
+					input.resourceId,
+					input.resourceType,
+				);
+			} catch (error) {
+				handleTRPCError(
+					error,
+					"Failed to assign network to resource",
+					"Error assigning network to resource:",
+				);
+			}
+		}),
+
+	removeFromResource: protectedProcedure
+		.input(
+			z.object({
+				networkId: z.string().min(1),
+				resourceId: z.string().min(1),
+				resourceType: RESOURCE_TYPE_ENUM,
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			await verifyNetworkAccess(
+				input.networkId,
+				ctx.session.activeOrganizationId,
+			);
+
+			try {
+				return await removeNetworkFromResource(
+					input.networkId,
+					input.resourceId,
+					input.resourceType,
+				);
+			} catch (error) {
+				handleTRPCError(
+					error,
+					"Failed to remove network from resource",
+					"Error removing network from resource:",
+				);
+			}
+		}),
+
+	getResourceNetworks: protectedProcedure
+		.input(
+			z.object({
+				resourceId: z.string().min(1),
+				resourceType: RESOURCE_TYPE_WITH_PREVIEW_ENUM,
+			}),
+		)
+		.query(async ({ input }) => {
+			return await getResourceNetworks(input.resourceId, input.resourceType);
+		}),
+
+	getResourceNetworksForDomain: protectedProcedure
+		.input(
+			z.object({
+				resourceId: z.string().min(1),
+				resourceType: RESOURCE_TYPE_WITH_PREVIEW_ENUM,
+			}),
+		)
+		.query(async ({ input }) => {
+			const resource = await findResourceById(
+				input.resourceId,
+				input.resourceType,
+			);
+
+			let customNetworkIds: string[];
+			if (input.resourceType === "preview") {
+				const previewResource = resource as any;
+				customNetworkIds = Array.from(
+					previewResource.application?.previewNetworkIds ||
+						previewResource.application?.customNetworkIds ||
+						[],
+				);
+			} else {
+				customNetworkIds = Array.from(resource.customNetworkIds || []);
+			}
+
+			const networks = await getResourceNetworks(
+				input.resourceId,
+				input.resourceType,
+			);
+
+			// Filter out internal networks - Traefik cannot connect to internal networks
+			const availableNetworks = networks.filter((network) => !network.internal);
+
+			// If resource has no custom networks, dokploy-network is available by default
+			// Return a special "default" entry that will be converted to null in the frontend
+			if (customNetworkIds.length === 0) {
+				return [
+					{
+						networkId: "default",
+						name: "Default",
+						networkName: "dokploy-network",
+						description: "Default Dokploy network",
+						driver: "bridge" as const,
+						internal: false,
+						encrypted: false,
+						subnet: null,
+						gateway: null,
+						ipRange: null,
+						organizationId: "",
+						projectId: null,
+						serverId: null,
+						dockerNetworkId: null,
+						createdAt: new Date().toISOString(),
+					},
+					...availableNetworks,
+				];
+			}
+
+			// If resource has custom networks, only show those
+			return availableNetworks;
+		}),
+
+	listAvailableForOrganization: protectedProcedure.query(async ({ ctx }) => {
+		return await findNetworksByOrganizationId(ctx.session.activeOrganizationId);
+	}),
+
+	listServerNetworks: protectedProcedure
+		.input(
+			z.object({
+				serverId: z.string().nullable().optional(),
+			}),
+		)
+		.query(async ({ input }) => {
+			return await listServerNetworks(input.serverId);
+		}),
+
+	getAllNetworksByServer: protectedProcedure
+		.input(
+			z.object({
+				serverId: z.string().nullable(),
+				resourceType: z.enum(["application", "compose"]),
+				composeType: z.enum(["docker-compose", "stack"]).optional(),
+			}),
+		)
+		.query(async ({ input }) => {
+			return await getAllNetworksByServer(
+				input.serverId,
+				input.resourceType,
+				input.composeType,
+			);
+		}),
+
+	syncNetworks: protectedProcedure
+		.input(
+			z.object({
+				serverId: z.string().nullable().optional(),
+			}),
+		)
+		.mutation(async ({ input }) => {
+			return await syncNetworks(input.serverId);
+		}),
+
+	importOrphanedNetworks: protectedProcedure
+		.input(
+			z.object({
+				serverId: z.string().nullable().optional(),
+			}),
+		)
+		.mutation(async ({ input }) => {
+			try {
+				return await importOrphanedNetworks(input.serverId);
+			} catch (error) {
+				handleTRPCError(
+					error,
+					"Failed to import orphaned networks",
+					"Error importing orphaned networks:",
+				);
+			}
+		}),
+});
diff --git a/apps/dokploy/server/api/routers/project.ts b/apps/dokploy/server/api/routers/project.ts
index c25fdd4a5f..d2e121cf2e 100644
--- a/apps/dokploy/server/api/routers/project.ts
+++ b/apps/dokploy/server/api/routers/project.ts
@@ -219,28 +219,91 @@ export const projectRouter = createTRPCRouter({
 									applications.applicationId,
 									accessedServices,
 								),
+								columns: {
+									applicationId: true,
+									appName: true,
+									name: true,
+									description: true,
+									createdAt: true,
+									applicationStatus: true,
+									serverId: true,
+								},
 								with: { domains: true },
 							},
 							mariadb: {
 								where: buildServiceFilter(mariadb.mariadbId, accessedServices),
+								columns: {
+									mariadbId: true,
+									appName: true,
+									name: true,
+									description: true,
+									createdAt: true,
+									applicationStatus: true,
+									serverId: true,
+								},
 							},
 							mongo: {
 								where: buildServiceFilter(mongo.mongoId, accessedServices),
+								columns: {
+									mongoId: true,
+									appName: true,
+									name: true,
+									description: true,
+									createdAt: true,
+									applicationStatus: true,
+									serverId: true,
+								},
 							},
 							mysql: {
 								where: buildServiceFilter(mysql.mysqlId, accessedServices),
+								columns: {
+									mysqlId: true,
+									appName: true,
+									name: true,
+									description: true,
+									createdAt: true,
+									applicationStatus: true,
+									serverId: true,
+								},
 							},
 							postgres: {
 								where: buildServiceFilter(
 									postgres.postgresId,
 									accessedServices,
 								),
+								columns: {
+									postgresId: true,
+									appName: true,
+									name: true,
+									description: true,
+									createdAt: true,
+									applicationStatus: true,
+									serverId: true,
+								},
 							},
 							redis: {
 								where: buildServiceFilter(redis.redisId, accessedServices),
+								columns: {
+									redisId: true,
+									appName: true,
+									name: true,
+									description: true,
+									createdAt: true,
+									applicationStatus: true,
+									serverId: true,
+								},
 							},
 							compose: {
 								where: buildServiceFilter(compose.composeId, accessedServices),
+								columns: {
+									composeId: true,
+									appName: true,
+									name: true,
+									description: true,
+									createdAt: true,
+									composeStatus: true,
+									serverId: true,
+								},
 								with: { domains: true },
 							},
 						},
@@ -255,16 +318,84 @@ export const projectRouter = createTRPCRouter({
 				environments: {
 					with: {
 						applications: {
+							columns: {
+								applicationId: true,
+								appName: true,
+								name: true,
+								description: true,
+								createdAt: true,
+								applicationStatus: true,
+								serverId: true,
+							},
 							with: {
 								domains: true,
 							},
 						},
-						mariadb: true,
-						mongo: true,
-						mysql: true,
-						postgres: true,
-						redis: true,
+						mariadb: {
+							columns: {
+								mariadbId: true,
+								appName: true,
+								name: true,
+								description: true,
+								createdAt: true,
+								applicationStatus: true,
+								serverId: true,
+							},
+						},
+						mongo: {
+							columns: {
+								mongoId: true,
+								appName: true,
+								name: true,
+								description: true,
+								createdAt: true,
+								applicationStatus: true,
+								serverId: true,
+							},
+						},
+						mysql: {
+							columns: {
+								mysqlId: true,
+								appName: true,
+								name: true,
+								description: true,
+								createdAt: true,
+								applicationStatus: true,
+								serverId: true,
+							},
+						},
+						postgres: {
+							columns: {
+								postgresId: true,
+								appName: true,
+								name: true,
+								description: true,
+								createdAt: true,
+								applicationStatus: true,
+								serverId: true,
+							},
+						},
+						redis: {
+							columns: {
+								redisId: true,
+								appName: true,
+								name: true,
+								description: true,
+								createdAt: true,
+								applicationStatus: true,
+								serverId: true,
+							},
+						},
 						compose: {
+							columns: {
+								composeId: true,
+								appName: true,
+								name: true,
+								description: true,
+								createdAt: true,
+								composeStatus: true,
+								serverId: true,
+							},
 							with: {
 								domains: true,
 							},
diff --git a/apps/dokploy/server/db/validations/domain.ts b/apps/dokploy/server/db/validations/domain.ts
index 35de518c0b..4785fed2a4 100644
--- a/apps/dokploy/server/db/validations/domain.ts
+++ b/apps/dokploy/server/db/validations/domain.ts
@@ -18,6 +18,7 @@ export const domain = z
 		https: z.boolean().optional(),
 		certificateType: z.enum(["letsencrypt", "none", "custom"]).optional(),
 		customCertResolver: z.string().optional(),
+		networkId: z.string().nullable().optional(),
 	})
 	.superRefine((input, ctx) => {
 		if (input.https && !input.certificateType) {
diff --git a/packages/server/src/db/schema/application.ts b/packages/server/src/db/schema/application.ts
index 2697e8de8e..315fc7cfda 100644
--- a/packages/server/src/db/schema/application.ts
+++ b/packages/server/src/db/schema/application.ts
@@ -95,6 +95,7 @@ export const applications = pgTable("application", {
 		.notNull()
 		.default("none"),
 	previewCustomCertResolver: text("previewCustomCertResolver"),
+	previewNetworkIds: text("previewNetworkIds").array(),
 	previewLimit: integer("previewLimit").default(3),
 	isPreviewDeploymentsActive: boolean("isPreviewDeploymentsActive").default(
 		false,
@@ -174,6 +175,7 @@ export const applications = pgTable("application", {
 	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
 	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
 	stopGracePeriodSwarm: bigint("stopGracePeriodSwarm", { mode: "bigint" }),
+	customNetworkIds: text("customNetworkIds").array(),
 	endpointSpecSwarm: json("endpointSpecSwarm").$type<EndpointSpecSwarm>(),
 	ulimitsSwarm: json("ulimitsSwarm").$type<UlimitsSwarm>(),
 	//
@@ -366,8 +368,10 @@ const createSchema = createInsertSchema(applications, {
 	previewRequireCollaboratorPermissions: z.boolean().optional(),
 	watchPaths: z.array(z.string()).optional(),
 	previewLabels: z.array(z.string()).optional(),
+	previewNetworkIds: z.array(z.string()).nullable().optional(),
 	cleanCache: z.boolean().optional(),
 	stopGracePeriodSwarm: z.bigint().nullable(),
+	customNetworkIds: z.array(z.string()).nullable(),
 	endpointSpecSwarm: EndpointSpecSwarmSchema.nullable(),
 	ulimitsSwarm: UlimitsSwarmSchema.nullable(),
 });
diff --git a/packages/server/src/db/schema/compose.ts b/packages/server/src/db/schema/compose.ts
index 0c9b1ba28e..f7a1e69512 100644
--- a/packages/server/src/db/schema/compose.ts
+++ b/packages/server/src/db/schema/compose.ts
@@ -79,13 +79,13 @@ export const compose = pgTable("compose", {
 	composePath: text("composePath").notNull().default("./docker-compose.yml"),
 	suffix: text("suffix").notNull().default(""),
 	randomize: boolean("randomize").notNull().default(false),
-	isolatedDeployment: boolean("isolatedDeployment").notNull().default(false),
 	// Keep this for backward compatibility since we will not add the prefix anymore to volumes
 	isolatedDeploymentsVolume: boolean("isolatedDeploymentsVolume")
 		.notNull()
 		.default(false),
 	triggerType: triggerType("triggerType").default("push"),
 	composeStatus: applicationStatus("composeStatus").notNull().default("idle"),
+	customNetworkIds: text("customNetworkIds").array(),
 	environmentId: text("environmentId")
 		.notNull()
 		.references(() => environments.environmentId, { onDelete: "cascade" }),
@@ -164,6 +164,7 @@ const createSchema = createInsertSchema(compose, {
 	composePath: z.string().min(1),
 	composeType: z.enum(["docker-compose", "stack"]).optional(),
 	watchPaths: z.array(z.string()).optional(),
+	customNetworkIds: z.array(z.string()).nullable(),
 });
 
 export const apiCreateCompose = createSchema.pick({
diff --git a/packages/server/src/db/schema/domain.ts b/packages/server/src/db/schema/domain.ts
index 81d56b4d2a..a9bc357e3e 100644
--- a/packages/server/src/db/schema/domain.ts
+++ b/packages/server/src/db/schema/domain.ts
@@ -14,6 +14,7 @@ import { z } from "zod";
 import { domain } from "../validations/domain";
 import { applications } from "./application";
 import { compose } from "./compose";
+import { networks } from "./network";
 import { previewDeployments } from "./preview-deployments";
 import { certificateType } from "./shared";
 
@@ -53,6 +54,9 @@ export const domains = pgTable("domain", {
 	certificateType: certificateType("certificateType").notNull().default("none"),
 	internalPath: text("internalPath").default("/"),
 	stripPath: boolean("stripPath").notNull().default(false),
+	networkId: text("networkId").references(() => networks.networkId, {
+		onDelete: "set null",
+	}),
 });
 
 export const domainsRelations = relations(domains, ({ one }) => ({
@@ -68,6 +72,10 @@ export const domainsRelations = relations(domains, ({ one }) => ({
 		fields: [domains.previewDeploymentId],
 		references: [previewDeployments.previewDeploymentId],
 	}),
+	network: one(networks, {
+		fields: [domains.networkId],
+		references: [networks.networkId],
+	}),
 }));
 
 const createSchema = createInsertSchema(domains, domain._def.schema.shape);
@@ -86,6 +94,7 @@ export const apiCreateDomain = createSchema.pick({
 	previewDeploymentId: true,
 	internalPath: true,
 	stripPath: true,
+	networkId: true,
 });
 
 export const apiFindDomain = createSchema
@@ -118,5 +127,6 @@ export const apiUpdateDomain = createSchema
 		domainType: true,
 		internalPath: true,
 		stripPath: true,
+		networkId: true,
 	})
 	.merge(createSchema.pick({ domainId: true }).required());
diff --git a/packages/server/src/db/schema/index.ts b/packages/server/src/db/schema/index.ts
index fece17f02c..641b830142 100644
--- a/packages/server/src/db/schema/index.ts
+++ b/packages/server/src/db/schema/index.ts
@@ -17,6 +17,7 @@ export * from "./mariadb";
 export * from "./mongo";
 export * from "./mount";
 export * from "./mysql";
+export * from "./network";
 export * from "./notification";
 export * from "./patch";
 export * from "./port";
diff --git a/packages/server/src/db/schema/mariadb.ts b/packages/server/src/db/schema/mariadb.ts
index a2dbaa9898..052141b837 100644
--- a/packages/server/src/db/schema/mariadb.ts
+++ b/packages/server/src/db/schema/mariadb.ts
@@ -68,6 +68,7 @@ export const mariadb = pgTable("mariadb", {
 	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
 	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
 	stopGracePeriodSwarm: bigint("stopGracePeriodSwarm", { mode: "bigint" }),
+	customNetworkIds: text("customNetworkIds").array(),
 	endpointSpecSwarm: json("endpointSpecSwarm").$type<EndpointSpecSwarm>(),
 	ulimitsSwarm: json("ulimitsSwarm").$type<UlimitsSwarm>(),
 	replicas: integer("replicas").default(1).notNull(),
@@ -143,6 +144,7 @@ const createSchema = createInsertSchema(mariadb, {
 	labelsSwarm: LabelsSwarmSchema.nullable(),
 	networkSwarm: NetworkSwarmSchema.nullable(),
 	stopGracePeriodSwarm: z.bigint().nullable(),
+	customNetworkIds: z.array(z.string()).nullable(),
 	endpointSpecSwarm: EndpointSpecSwarmSchema.nullable(),
 	ulimitsSwarm: UlimitsSwarmSchema.nullable(),
 });
diff --git a/packages/server/src/db/schema/mongo.ts b/packages/server/src/db/schema/mongo.ts
index 5349823da7..9314327cf8 100644
--- a/packages/server/src/db/schema/mongo.ts
+++ b/packages/server/src/db/schema/mongo.ts
@@ -71,6 +71,7 @@ export const mongo = pgTable("mongo", {
 	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
 	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
 	stopGracePeriodSwarm: bigint("stopGracePeriodSwarm", { mode: "bigint" }),
+	customNetworkIds: text("customNetworkIds").array(),
 	endpointSpecSwarm: json("endpointSpecSwarm").$type<EndpointSpecSwarm>(),
 	ulimitsSwarm: json("ulimitsSwarm").$type<UlimitsSwarm>(),
 	replicas: integer("replicas").default(1).notNull(),
@@ -140,6 +141,7 @@ const createSchema = createInsertSchema(mongo, {
 	labelsSwarm: LabelsSwarmSchema.nullable(),
 	networkSwarm: NetworkSwarmSchema.nullable(),
 	stopGracePeriodSwarm: z.bigint().nullable(),
+	customNetworkIds: z.array(z.string()).nullable(),
 	endpointSpecSwarm: EndpointSpecSwarmSchema.nullable(),
 	ulimitsSwarm: UlimitsSwarmSchema.nullable(),
 });
diff --git a/packages/server/src/db/schema/mysql.ts b/packages/server/src/db/schema/mysql.ts
index 3f6e424b7f..85aeb9dffe 100644
--- a/packages/server/src/db/schema/mysql.ts
+++ b/packages/server/src/db/schema/mysql.ts
@@ -66,6 +66,7 @@ export const mysql = pgTable("mysql", {
 	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
 	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
 	stopGracePeriodSwarm: bigint("stopGracePeriodSwarm", { mode: "bigint" }),
+	customNetworkIds: text("customNetworkIds").array(),
 	endpointSpecSwarm: json("endpointSpecSwarm").$type<EndpointSpecSwarm>(),
 	ulimitsSwarm: json("ulimitsSwarm").$type<UlimitsSwarm>(),
 	replicas: integer("replicas").default(1).notNull(),
@@ -140,6 +141,7 @@ const createSchema = createInsertSchema(mysql, {
 	labelsSwarm: LabelsSwarmSchema.nullable(),
 	networkSwarm: NetworkSwarmSchema.nullable(),
 	stopGracePeriodSwarm: z.bigint().nullable(),
+	customNetworkIds: z.array(z.string()).nullable(),
 	endpointSpecSwarm: EndpointSpecSwarmSchema.nullable(),
 	ulimitsSwarm: UlimitsSwarmSchema.nullable(),
 });
diff --git a/packages/server/src/db/schema/network.ts b/packages/server/src/db/schema/network.ts
new file mode 100644
index 0000000000..69e4b6c27c
--- /dev/null
+++ b/packages/server/src/db/schema/network.ts
@@ -0,0 +1,160 @@
+import { relations } from "drizzle-orm";
+import { boolean, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { organization } from "./account";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { mariadb } from "./mariadb";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { postgres } from "./postgres";
+import { projects } from "./project";
+import { redis } from "./redis";
+import { server } from "./server";
+
+export const networkDriver = pgEnum("networkDriver", ["bridge", "overlay"]);
+export type NetworkDriver = (typeof networkDriver.enumValues)[number];
+
+const IPV4_REGEX =
+	/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+const CIDR_REGEX =
+	/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/(?:[0-9]|[1-2][0-9]|3[0-2])$/;
+const NETWORK_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
+
+export const networks = pgTable("network", {
+	networkId: text("networkId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	description: text("description"),
+	networkName: text("networkName").notNull(),
+	driver: networkDriver("driver").notNull().default("bridge"),
+	subnet: text("subnet"),
+	gateway: text("gateway"),
+	ipRange: text("ipRange"),
+	internal: boolean("internal").notNull().default(false),
+	encrypted: boolean("encrypted").notNull().default(false),
+	dockerNetworkId: text("dockerNetworkId"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId").references(() => projects.projectId, {
+		onDelete: "set null",
+	}),
+	organizationId: text("organizationId")
+		.notNull()
+		.references(() => organization.id, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "set null",
+	}),
+});
+
+export const networkRelations = relations(networks, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [networks.projectId],
+		references: [projects.projectId],
+	}),
+	organization: one(organization, {
+		fields: [networks.organizationId],
+		references: [organization.id],
+	}),
+	server: one(server, {
+		fields: [networks.serverId],
+		references: [server.serverId],
+	}),
+	applications: many(applications),
+	composes: many(compose),
+	postgres: many(postgres),
+	mysql: many(mysql),
+	mariadb: many(mariadb),
+	mongo: many(mongo),
+	redis: many(redis),
+}));
+
+const createSchema = createInsertSchema(networks, {
+	networkId: z.string().min(1),
+	name: z.string().min(1).max(50),
+	networkName: z
+		.string()
+		.min(1)
+		.max(63)
+		.regex(
+			NETWORK_NAME_REGEX,
+			"Network name must start with alphanumeric and contain only alphanumeric, underscore, period, or hyphen",
+		),
+	subnet: z
+		.string()
+		.regex(CIDR_REGEX, "Invalid subnet format (e.g., 172.20.0.0/16)")
+		.optional(),
+	gateway: z
+		.string()
+		.regex(IPV4_REGEX, "Invalid gateway IP address")
+		.optional(),
+	ipRange: z.string().regex(CIDR_REGEX, "Invalid IP range format").optional(),
+});
+
+export const apiCreateNetwork = createSchema
+	.pick({
+		name: true,
+		description: true,
+		networkName: true,
+		driver: true,
+		subnet: true,
+		gateway: true,
+		ipRange: true,
+		internal: true,
+		encrypted: true,
+		projectId: true,
+		organizationId: true,
+		serverId: true,
+	})
+	.extend({
+		projectId: z.string().optional(),
+		organizationId: z.string().min(1).optional(),
+	});
+
+export const apiFindOneNetwork = createSchema
+	.pick({
+		networkId: true,
+	})
+	.required();
+
+export const apiRemoveNetwork = createSchema
+	.pick({
+		networkId: true,
+	})
+	.required();
+
+export const apiUpdateNetwork = createSchema
+	.partial()
+	.extend({
+		networkId: z.string().min(1),
+	})
+	.omit({ dockerNetworkId: true, createdAt: true });
+
+const RESOURCE_TYPES = [
+	"application",
+	"compose",
+	"postgres",
+	"mysql",
+	"mariadb",
+	"mongo",
+	"redis",
+] as const;
+
+export type NetworkResourceType = (typeof RESOURCE_TYPES)[number];
+
+const networkResourceSchema = z.object({
+	networkId: z.string().min(1),
+	resourceId: z.string().min(1),
+	resourceType: z.enum(RESOURCE_TYPES),
+});
+
+export const apiAssignNetworkToResource = networkResourceSchema;
+export const apiRemoveNetworkFromResource = networkResourceSchema;
+
+export type Network = typeof networks.$inferSelect;
+export type NetworkInsert = typeof networks.$inferInsert;
diff --git a/packages/server/src/db/schema/postgres.ts b/packages/server/src/db/schema/postgres.ts
index cfd969aaa1..939b3853ef 100644
--- a/packages/server/src/db/schema/postgres.ts
+++ b/packages/server/src/db/schema/postgres.ts
@@ -66,6 +66,7 @@ export const postgres = pgTable("postgres", {
 	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
 	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
 	stopGracePeriodSwarm: bigint("stopGracePeriodSwarm", { mode: "bigint" }),
+	customNetworkIds: text("customNetworkIds").array(),
 	endpointSpecSwarm: json("endpointSpecSwarm").$type<EndpointSpecSwarm>(),
 	ulimitsSwarm: json("ulimitsSwarm").$type<UlimitsSwarm>(),
 	replicas: integer("replicas").default(1).notNull(),
@@ -134,6 +135,7 @@ const createSchema = createInsertSchema(postgres, {
 	labelsSwarm: LabelsSwarmSchema.nullable(),
 	networkSwarm: NetworkSwarmSchema.nullable(),
 	stopGracePeriodSwarm: z.bigint().nullable(),
+	customNetworkIds: z.array(z.string()).nullable(),
 	endpointSpecSwarm: EndpointSpecSwarmSchema.nullable(),
 	ulimitsSwarm: UlimitsSwarmSchema.nullable(),
 });
diff --git a/packages/server/src/db/schema/redis.ts b/packages/server/src/db/schema/redis.ts
index aa76fdbcb2..0c1979f660 100644
--- a/packages/server/src/db/schema/redis.ts
+++ b/packages/server/src/db/schema/redis.ts
@@ -65,6 +65,7 @@ export const redis = pgTable("redis", {
 	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
 	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
 	stopGracePeriodSwarm: bigint("stopGracePeriodSwarm", { mode: "bigint" }),
+	customNetworkIds: text("customNetworkIds").array(),
 	endpointSpecSwarm: json("endpointSpecSwarm").$type<EndpointSpecSwarm>(),
 	ulimitsSwarm: json("ulimitsSwarm").$type<UlimitsSwarm>(),
 	replicas: integer("replicas").default(1).notNull(),
@@ -122,6 +123,7 @@ const createSchema = createInsertSchema(redis, {
 	labelsSwarm: LabelsSwarmSchema.nullable(),
 	networkSwarm: NetworkSwarmSchema.nullable(),
 	stopGracePeriodSwarm: z.bigint().nullable(),
+	customNetworkIds: z.array(z.string()).nullable(),
 	endpointSpecSwarm: EndpointSpecSwarmSchema.nullable(),
 	ulimitsSwarm: UlimitsSwarmSchema.nullable(),
 });
diff --git a/packages/server/src/index.ts b/packages/server/src/index.ts
index 9adc9081e3..00d72649c8 100644
--- a/packages/server/src/index.ts
+++ b/packages/server/src/index.ts
@@ -26,6 +26,7 @@ export * from "./services/mariadb";
 export * from "./services/mongo";
 export * from "./services/mount";
 export * from "./services/mysql";
+export * from "./services/network";
 export * from "./services/notification";
 export * from "./services/patch";
 export * from "./services/patch-repo";
@@ -112,7 +113,6 @@ export * from "./utils/providers/docker";
 export * from "./utils/providers/git";
 export * from "./utils/providers/gitea";
 export * from "./utils/providers/github";
-export * from "./utils/providers/github";
 export * from "./utils/providers/gitlab";
 export * from "./utils/providers/raw";
 export * from "./utils/schedules/index";
diff --git a/packages/server/src/services/application.ts b/packages/server/src/services/application.ts
index 458ab34f5b..a9a8a91765 100644
--- a/packages/server/src/services/application.ts
+++ b/packages/server/src/services/application.ts
@@ -99,7 +99,11 @@ export const findApplicationById = async (applicationId: string) => {
 					project: true,
 				},
 			},
-			domains: true,
+			domains: {
+				with: {
+					network: true,
+				},
+			},
 			deployments: true,
 			mounts: true,
 			redirects: true,
@@ -417,6 +421,8 @@ export const deployPreviewApplication = async ({
 		application.env = `${application.previewEnv}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain?.host}`;
 		application.buildArgs = `${application.previewBuildArgs}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain?.host}`;
 		application.buildSecrets = `${application.previewBuildSecrets}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain?.host}`;
+		application.customNetworkIds =
+			application.previewNetworkIds || application.customNetworkIds;
 		application.rollbackActive = false;
 		application.buildRegistry = null;
 		application.rollbackRegistry = null;
@@ -536,6 +542,8 @@ export const rebuildPreviewApplication = async ({
 		application.env = `${application.previewEnv}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain?.host}`;
 		application.buildArgs = `${application.previewBuildArgs}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain?.host}`;
 		application.buildSecrets = `${application.previewBuildSecrets}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain?.host}`;
+		application.customNetworkIds =
+			application.previewNetworkIds || application.customNetworkIds;
 		application.rollbackActive = false;
 		application.buildRegistry = null;
 		application.rollbackRegistry = null;
diff --git a/packages/server/src/services/compose.ts b/packages/server/src/services/compose.ts
index 0e1fa805f0..de3b27c671 100644
--- a/packages/server/src/services/compose.ts
+++ b/packages/server/src/services/compose.ts
@@ -120,7 +120,11 @@ export const findComposeById = async (composeId: string) => {
 			},
 			deployments: true,
 			mounts: true,
-			domains: true,
+			domains: {
+				with: {
+					network: true,
+				},
+			},
 			github: true,
 			gitlab: true,
 			bitbucket: true,
diff --git a/packages/server/src/services/domain.ts b/packages/server/src/services/domain.ts
index b2e15ed914..7f379e93d2 100644
--- a/packages/server/src/services/domain.ts
+++ b/packages/server/src/services/domain.ts
@@ -1,4 +1,5 @@
 import dns from "node:dns";
+import type { WriteStream } from "node:fs";
 import { promisify } from "node:util";
 import { db } from "@dokploy/server/db";
 import { getWebServerSettings } from "@dokploy/server/services/web-server-settings";
@@ -6,14 +7,320 @@ import { generateRandomDomain } from "@dokploy/server/templates";
 import { manageDomain } from "@dokploy/server/utils/traefik/domain";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
-import { type apiCreateDomain, domains } from "../db/schema";
+import {
+	type apiCreateDomain,
+	applications,
+	compose,
+	domains,
+	previewDeployments,
+	type server,
+} from "../db/schema";
+import { findUserById } from "./admin";
 import { findApplicationById } from "./application";
 import { detectCDNProvider } from "./cdn";
+import {
+	connectTraefikToResourceNetworks,
+	disconnectTraefikFromResourceNetworks,
+	findNetworkById,
+} from "./network";
 import { findServerById } from "./server";
 
 export type Domain = typeof domains.$inferSelect;
 
+export const ensureTraefikConnectedToDomainNetworks = async (
+	applicationId: string,
+	serverId: string | null | undefined,
+	writeStream?: WriteStream,
+): Promise<void> => {
+	const domains = await findDomainsByApplicationId(applicationId);
+
+	if (domains && domains.length > 0) {
+		const domainNetworkIds = domains
+			.map((d) => d.networkId)
+			.filter((id): id is string => id !== null);
+
+		if (domainNetworkIds.length > 0) {
+			await connectTraefikToResourceNetworks(
+				applicationId,
+				"application",
+				serverId,
+				domainNetworkIds[0],
+			);
+			writeStream?.write("\n✅ Traefik connected to domain network");
+		}
+	}
+};
+
+const validateNetworkForDomain = async (
+	networkId: string,
+	resourceId: string,
+	resourceType: "application" | "compose" | "preview",
+	excludeDomainId?: string,
+): Promise<void> => {
+	const network = await findNetworkById(networkId);
+
+	// Check if network is internal
+	if (network.internal) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message:
+				"Cannot use an internal network for domain routing. Traefik cannot connect to internal networks. Please select a non-internal network or leave empty to use dokploy-network.",
+		});
+	}
+
+	// Get resource to check server and network assignment
+	let resource:
+		| (typeof applications.$inferSelect & {
+				server: typeof server.$inferSelect | null;
+		  })
+		| (typeof compose.$inferSelect & {
+				server: typeof server.$inferSelect | null;
+		  })
+		| (typeof previewDeployments.$inferSelect & {
+				application: typeof applications.$inferSelect & {
+					server: typeof server.$inferSelect | null;
+				};
+		  })
+		| undefined;
+
+	if (resourceType === "application") {
+		resource = await db.query.applications.findFirst({
+			where: eq(applications.applicationId, resourceId),
+			with: { server: true },
+		});
+	} else if (resourceType === "compose") {
+		resource = await db.query.compose.findFirst({
+			where: eq(compose.composeId, resourceId),
+			with: { server: true },
+		});
+	} else {
+		resource = await db.query.previewDeployments.findFirst({
+			where: eq(previewDeployments.previewDeploymentId, resourceId),
+			with: { application: { with: { server: true } } },
+		});
+	}
+
+	if (!resource) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: `${resourceType} not found`,
+		});
+	}
+
+	// For previews, get serverId and networks from application
+	const actualServerId =
+		resourceType === "preview"
+			? (resource as any).application?.serverId
+			: (resource as any).serverId;
+	const actualServer =
+		resourceType === "preview"
+			? (resource as any).application?.server
+			: (resource as any).server;
+
+	if (network.serverId !== actualServerId) {
+		const networkLocation = network.serverId
+			? `server "${network.server?.name || network.serverId}"`
+			: "local server";
+		const resourceLocation = actualServerId
+			? `server "${actualServer?.name || actualServerId}"`
+			: "local server";
+
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: `Network is on ${networkLocation} but ${resourceType} is on ${resourceLocation}. Both must be on the same server.`,
+		});
+	}
+
+	// For previews, check against application's previewNetworkIds
+	const customNetworkIds =
+		resourceType === "preview"
+			? Array.from(
+					(resource as any).application?.previewNetworkIds ||
+						(resource as any).application?.customNetworkIds ||
+						[],
+				)
+			: Array.from((resource as any).customNetworkIds || []);
+
+	if (!customNetworkIds.includes(networkId)) {
+		const message =
+			resourceType === "preview"
+				? `Network "${network.name}" is not allowed for preview deployments. Please configure preview networks in the application settings.`
+				: `Network "${network.name}" is not assigned to this ${resourceType}. Please assign the network to the ${resourceType} first in the Networks tab.`;
+
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message,
+		});
+	}
+
+	if (resourceType === "application") {
+		const allDomains = await findDomainsByApplicationId(resourceId);
+		const existingDomains = excludeDomainId
+			? allDomains.filter((d) => d.domainId !== excludeDomainId)
+			: allDomains;
+
+		const hasConflict = existingDomains.some((d) => d.networkId !== networkId);
+
+		if (hasConflict) {
+			const conflictingDomain = existingDomains.find(
+				(d) => d.networkId !== networkId,
+			);
+
+			if (conflictingDomain) {
+				const conflictNetworkName = conflictingDomain.networkId
+					? (await findNetworkById(conflictingDomain.networkId)).name
+					: "Default (dokploy-network)";
+				const newNetworkName = networkId
+					? network.name
+					: "Default (dokploy-network)";
+
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: `This application already has domain "${conflictingDomain.host}" using network "${conflictNetworkName}". All domains must use the same network due to Docker/Traefik limitations. Please use "${conflictNetworkName}" for all domains.`,
+				});
+			}
+		}
+	} else if (resourceType === "compose") {
+		const allDomains = await findDomainsByComposeId(resourceId);
+		const existingDomains = excludeDomainId
+			? allDomains.filter((d) => d.domainId !== excludeDomainId)
+			: allDomains;
+
+		const hasConflict = existingDomains.some((d) => d.networkId !== networkId);
+
+		if (hasConflict) {
+			const conflictingDomain = existingDomains.find(
+				(d) => d.networkId !== networkId,
+			);
+
+			if (conflictingDomain) {
+				const conflictNetworkName = conflictingDomain.networkId
+					? (await findNetworkById(conflictingDomain.networkId)).name
+					: "Default (dokploy-network)";
+
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: `This compose already has domain "${conflictingDomain.host}" using network "${conflictNetworkName}". All domains must use the same network due to Docker/Traefik limitations. Please use "${conflictNetworkName}" for all domains.`,
+				});
+			}
+		}
+	} else if (resourceType === "preview") {
+		const allDomains = await findDomainsByPreviewDeploymentId(resourceId);
+		const existingDomains = excludeDomainId
+			? allDomains.filter((d) => d.domainId !== excludeDomainId)
+			: allDomains;
+
+		const hasConflict = existingDomains.some((d) => d.networkId !== networkId);
+
+		if (hasConflict) {
+			const conflictingDomain = existingDomains.find(
+				(d) => d.networkId !== networkId,
+			);
+
+			if (conflictingDomain) {
+				const conflictNetworkName = conflictingDomain.networkId
+					? (await findNetworkById(conflictingDomain.networkId)).name
+					: "Default (dokploy-network)";
+
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: `This preview already has domain "${conflictingDomain.host}" using network "${conflictNetworkName}". All domains must use the same network due to Docker/Traefik limitations. Please use "${conflictNetworkName}" for all domains.`,
+				});
+			}
+		}
+	}
+};
+
+const validateDomainNetworkConsistency = async (
+	networkId: string | null | undefined,
+	resourceId: string,
+	resourceType: "application" | "compose" | "preview",
+	excludeDomainId?: string,
+): Promise<void> => {
+	const allDomains =
+		resourceType === "application"
+			? await findDomainsByApplicationId(resourceId)
+			: resourceType === "compose"
+				? await findDomainsByComposeId(resourceId)
+				: await findDomainsByPreviewDeploymentId(resourceId);
+
+	const existingDomains = excludeDomainId
+		? allDomains.filter((d) => d.domainId !== excludeDomainId)
+		: allDomains;
+
+	if (existingDomains.length === 0) {
+		return;
+	}
+
+	const normalizedNetworkId = networkId ?? null;
+	const hasConflict = existingDomains.some(
+		(d) => (d.networkId ?? null) !== normalizedNetworkId,
+	);
+
+	if (hasConflict) {
+		const conflictingDomain = existingDomains.find(
+			(d) => (d.networkId ?? null) !== normalizedNetworkId,
+		);
+
+		if (conflictingDomain) {
+			const conflictNetworkName = conflictingDomain.networkId
+				? (await findNetworkById(conflictingDomain.networkId)).name
+				: "Default (dokploy-network)";
+			const newNetworkName = normalizedNetworkId
+				? (await findNetworkById(normalizedNetworkId)).name
+				: "Default (dokploy-network)";
+
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: `This ${resourceType} already has domain "${conflictingDomain.host}" using network "${conflictNetworkName}". All domains must use the same network due to Docker/Traefik limitations. Please use "${conflictNetworkName}" for all domains.`,
+			});
+		}
+	}
+};
+
 export const createDomain = async (input: typeof apiCreateDomain._type) => {
+	if (input.applicationId) {
+		await validateDomainNetworkConsistency(
+			input.networkId,
+			input.applicationId,
+			"application",
+		);
+	} else if (input.composeId) {
+		await validateDomainNetworkConsistency(
+			input.networkId,
+			input.composeId,
+			"compose",
+		);
+	} else if (input.previewDeploymentId) {
+		await validateDomainNetworkConsistency(
+			input.networkId,
+			input.previewDeploymentId,
+			"preview",
+		);
+	}
+
+	if (input.networkId) {
+		if (input.applicationId) {
+			await validateNetworkForDomain(
+				input.networkId,
+				input.applicationId,
+				"application",
+			);
+		} else if (input.composeId) {
+			await validateNetworkForDomain(
+				input.networkId,
+				input.composeId,
+				"compose",
+			);
+		} else if (input.previewDeploymentId) {
+			await validateNetworkForDomain(
+				input.networkId,
+				input.previewDeploymentId,
+				"preview",
+			);
+		}
+	}
+
 	const result = await db.transaction(async (tx) => {
 		const domain = await tx
 			.insert(domains)
@@ -34,6 +341,27 @@ export const createDomain = async (input: typeof apiCreateDomain._type) => {
 		if (domain.applicationId) {
 			const application = await findApplicationById(domain.applicationId);
 			await manageDomain(application, domain);
+			await connectTraefikToResourceNetworks(
+				domain.applicationId,
+				"application",
+				application.serverId,
+				domain.networkId,
+			);
+		}
+
+		if (domain.composeId) {
+			const compose = await db.query.compose.findFirst({
+				where: (compose, { eq }) => eq(compose.composeId, domain.composeId!),
+			});
+
+			if (compose) {
+				await connectTraefikToResourceNetworks(
+					domain.composeId,
+					"compose",
+					compose.serverId,
+					domain.networkId,
+				);
+			}
 		}
 
 		return domain;
@@ -96,6 +424,7 @@ export const findDomainsByApplicationId = async (applicationId: string) => {
 		where: eq(domains.applicationId, applicationId),
 		with: {
 			application: true,
+			network: true,
 		},
 	});
 
@@ -107,13 +436,28 @@ export const findDomainsByComposeId = async (composeId: string) => {
 		where: eq(domains.composeId, composeId),
 		with: {
 			compose: true,
+			network: true,
+		},
+	});
+
+	return domainsArray;
+};
+
+export const findDomainsByPreviewDeploymentId = async (
+	previewDeploymentId: string,
+) => {
+	const domainsArray = await db.query.domains.findMany({
+		where: eq(domains.previewDeploymentId, previewDeploymentId),
+		with: {
+			previewDeployment: true,
+			network: true,
 		},
 	});
 
 	return domainsArray;
 };
 
-export const updateDomainById = async (
+const updateDomainById = async (
 	domainId: string,
 	domainData: Partial<Domain>,
 ) => {
@@ -129,6 +473,117 @@ export const updateDomainById = async (
 	return domain[0];
 };
 
+export const updateDomain = async (
+	domainId: string,
+	domainData: Partial<Domain>,
+) => {
+	const existingDomain = await findDomainById(domainId);
+
+	if (
+		domainData.networkId !== undefined &&
+		domainData.networkId !== existingDomain.networkId
+	) {
+		if (existingDomain.applicationId) {
+			await validateDomainNetworkConsistency(
+				domainData.networkId,
+				existingDomain.applicationId,
+				"application",
+				domainId,
+			);
+		} else if (existingDomain.composeId) {
+			await validateDomainNetworkConsistency(
+				domainData.networkId,
+				existingDomain.composeId,
+				"compose",
+				domainId,
+			);
+		}
+	}
+
+	if (
+		domainData.networkId !== undefined &&
+		domainData.networkId !== existingDomain.networkId
+	) {
+		if (domainData.networkId) {
+			if (existingDomain.applicationId) {
+				await validateNetworkForDomain(
+					domainData.networkId,
+					existingDomain.applicationId,
+					"application",
+					domainId,
+				);
+			} else if (existingDomain.composeId) {
+				await validateNetworkForDomain(
+					domainData.networkId,
+					existingDomain.composeId,
+					"compose",
+					domainId,
+				);
+			} else if (existingDomain.previewDeploymentId) {
+				await validateNetworkForDomain(
+					domainData.networkId,
+					existingDomain.previewDeploymentId,
+					"preview",
+					domainId,
+				);
+			}
+		}
+	}
+
+	const updatedDomain = await updateDomainById(domainId, domainData);
+
+	if (!updatedDomain) {
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: "Failed to update domain",
+		});
+	}
+
+	if (
+		domainData.networkId !== undefined &&
+		domainData.networkId !== existingDomain.networkId
+	) {
+		if (updatedDomain.applicationId) {
+			const application = await findApplicationById(
+				updatedDomain.applicationId,
+			);
+			await connectTraefikToResourceNetworks(
+				updatedDomain.applicationId,
+				"application",
+				application.serverId,
+				domainData.networkId,
+			);
+			await disconnectTraefikFromResourceNetworks(
+				updatedDomain.applicationId,
+				"application",
+				application.serverId,
+				existingDomain.networkId,
+			);
+		} else if (updatedDomain.composeId) {
+			const compose = await db.query.compose.findFirst({
+				where: (compose, { eq }) =>
+					eq(compose.composeId, updatedDomain.composeId!),
+			});
+			if (compose) {
+				await connectTraefikToResourceNetworks(
+					updatedDomain.composeId,
+					"compose",
+					compose.serverId,
+					domainData.networkId,
+				);
+				await disconnectTraefikFromResourceNetworks(
+					updatedDomain.composeId,
+					"compose",
+					compose.serverId,
+					existingDomain.networkId,
+				);
+			}
+		}
+	}
+
+	return updatedDomain;
+};
+
 export const removeDomainById = async (domainId: string) => {
 	await findDomainById(domainId);
 	const result = await db
diff --git a/packages/server/src/services/environment.ts b/packages/server/src/services/environment.ts
index 2f4ed5085b..339b10d912 100644
--- a/packages/server/src/services/environment.ts
+++ b/packages/server/src/services/environment.ts
@@ -35,37 +35,100 @@ export const findEnvironmentById = async (environmentId: string) => {
 		where: eq(environments.environmentId, environmentId),
 		with: {
 			applications: {
+				columns: {
+					applicationId: true,
+					appName: true,
+					name: true,
+					description: true,
+					createdAt: true,
+					applicationStatus: true,
+					serverId: true,
+				},
 				with: {
 					deployments: true,
 					server: true,
 				},
 			},
 			mariadb: {
+				columns: {
+					mariadbId: true,
+					appName: true,
+					name: true,
+					description: true,
+					createdAt: true,
+					applicationStatus: true,
+					serverId: true,
+				},
 				with: {
 					server: true,
 				},
 			},
 			mongo: {
+				columns: {
+					mongoId: true,
+					appName: true,
+					name: true,
+					description: true,
+					createdAt: true,
+					applicationStatus: true,
+					serverId: true,
+				},
 				with: {
 					server: true,
 				},
 			},
 			mysql: {
+				columns: {
+					mysqlId: true,
+					appName: true,
+					name: true,
+					description: true,
+					createdAt: true,
+					applicationStatus: true,
+					serverId: true,
+				},
 				with: {
 					server: true,
 				},
 			},
 			postgres: {
+				columns: {
+					postgresId: true,
+					appName: true,
+					name: true,
+					description: true,
+					createdAt: true,
+					applicationStatus: true,
+					serverId: true,
+				},
 				with: {
 					server: true,
 				},
 			},
 			redis: {
+				columns: {
+					redisId: true,
+					appName: true,
+					name: true,
+					description: true,
+					createdAt: true,
+					applicationStatus: true,
+					serverId: true,
+				},
 				with: {
 					server: true,
 				},
 			},
 			compose: {
+				columns: {
+					composeId: true,
+					appName: true,
+					name: true,
+					description: true,
+					createdAt: true,
+					composeStatus: true,
+					serverId: true,
+				},
 				with: {
 					deployments: true,
 					server: true,
diff --git a/packages/server/src/services/network.ts b/packages/server/src/services/network.ts
new file mode 100644
index 0000000000..4533fc5a80
--- /dev/null
+++ b/packages/server/src/services/network.ts
@@ -0,0 +1,993 @@
+import { db } from "@dokploy/server/db";
+import {
+	type apiCreateNetwork,
+	applications,
+	compose,
+	mariadb,
+	mongo,
+	mysql,
+	networks,
+	postgres,
+	previewDeployments,
+	redis,
+} from "@dokploy/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { and, desc, eq, inArray, isNull } from "drizzle-orm";
+import {
+	createDockerNetwork,
+	type DockerNetworkConfig,
+	dockerNetworkExists,
+	ensureTraefikConnectedToNetwork,
+	ensureTraefikDisconnectedFromNetwork,
+	inspectDockerNetwork,
+	listDockerNetworks,
+	removeDockerNetwork,
+} from "../utils/docker/network-utils";
+
+export type DokployNetwork = typeof networks.$inferSelect;
+
+export type ResourceType =
+	| "application"
+	| "compose"
+	| "postgres"
+	| "mysql"
+	| "mariadb"
+	| "mongo"
+	| "redis";
+
+export type ResourceTypeWithPreview = ResourceType | "preview";
+
+interface ResourceWithNetworks {
+	customNetworkIds?: readonly string[] | null;
+	composeType?: string;
+	serverId?: string | null;
+	server?: {
+		name: string;
+		serverId: string;
+	} | null;
+	domains?:
+		| readonly {
+				domainId: string;
+		  }[]
+		| null;
+}
+
+type NetworkImportError = {
+	networkName: string;
+	error: string;
+};
+
+type NetworkSyncResult = {
+	missing: string[];
+	orphaned: string[];
+};
+
+type NetworkImportResult = {
+	imported: DokployNetwork[];
+	errors: NetworkImportError[];
+};
+
+const RESOURCE_TABLE_MAP = {
+	application: applications,
+	compose: compose,
+	postgres: postgres,
+	mysql: mysql,
+	mariadb: mariadb,
+	mongo: mongo,
+	redis: redis,
+	preview: previewDeployments,
+} as const;
+
+const RESOURCE_QUERIES = {
+	application: (id: string) =>
+		db.query.applications.findFirst({
+			where: eq(applications.applicationId, id),
+			with: { server: true },
+		}),
+	compose: (id: string) =>
+		db.query.compose.findFirst({
+			where: eq(compose.composeId, id),
+			with: { server: true },
+		}),
+	postgres: (id: string) =>
+		db.query.postgres.findFirst({
+			where: eq(postgres.postgresId, id),
+			with: { server: true },
+		}),
+	mysql: (id: string) =>
+		db.query.mysql.findFirst({
+			where: eq(mysql.mysqlId, id),
+			with: { server: true },
+		}),
+	mariadb: (id: string) =>
+		db.query.mariadb.findFirst({
+			where: eq(mariadb.mariadbId, id),
+			with: { server: true },
+		}),
+	mongo: (id: string) =>
+		db.query.mongo.findFirst({
+			where: eq(mongo.mongoId, id),
+			with: { server: true },
+		}),
+	redis: (id: string) =>
+		db.query.redis.findFirst({
+			where: eq(redis.redisId, id),
+			with: { server: true },
+		}),
+	preview: (id: string) =>
+		db.query.previewDeployments.findFirst({
+			where: eq(previewDeployments.previewDeploymentId, id),
+			with: { application: { with: { server: true } } },
+		}),
+} as const;
+
+export const findResourceById = async (
+	resourceId: string,
+	resourceType: ResourceTypeWithPreview,
+): Promise<ResourceWithNetworks> => {
+	const resource = await RESOURCE_QUERIES[resourceType](resourceId);
+
+	if (!resource) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: `${resourceType} not found`,
+		});
+	}
+
+	return resource as ResourceWithNetworks;
+};
+
+export const createNetwork = async (
+	input: typeof apiCreateNetwork._type,
+): Promise<DokployNetwork> => {
+	if (!input.organizationId) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Organization ID is required",
+		});
+	}
+
+	try {
+		const existing = await db.query.networks.findFirst({
+			where: and(
+				eq(networks.organizationId, input.organizationId),
+				eq(networks.networkName, input.networkName),
+			),
+		});
+
+		if (existing) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: `Network with name '${input.networkName}' already exists in this organization`,
+			});
+		}
+
+		const dockerExists = await dockerNetworkExists(
+			input.networkName,
+			input.serverId,
+		);
+
+		if (dockerExists) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: `Docker network '${input.networkName}' already exists on this server`,
+			});
+		}
+
+		const networkConfig: DockerNetworkConfig = {
+			Name: input.networkName,
+			Driver: input.driver || "bridge",
+			CheckDuplicate: true,
+			Attachable: true,
+			Internal: input.internal,
+			Labels: {
+				"com.dokploy.organization.id": input.organizationId,
+				"com.dokploy.network.name": input.name,
+				...(input.projectId && { "com.dokploy.project.id": input.projectId }),
+			},
+			...(input.encrypted &&
+				input.driver === "overlay" && {
+					Options: { encrypted: "" },
+				}),
+		};
+
+		if (input.subnet || input.gateway || input.ipRange) {
+			networkConfig.IPAM = {
+				Config: [
+					{
+						Subnet: input.subnet || undefined,
+						Gateway: input.gateway || undefined,
+						IPRange: input.ipRange || undefined,
+					},
+				],
+			};
+		}
+
+		try {
+			await createDockerNetwork(networkConfig, input.serverId);
+		} catch (dockerError) {
+			const errorMessage =
+				dockerError instanceof Error
+					? dockerError.message
+					: String(dockerError);
+			console.error("Error creating Docker network:", dockerError);
+
+			if (
+				errorMessage.includes("Pool overlaps") ||
+				errorMessage.includes("pool overlaps")
+			) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: `The subnet range ${input.subnet || "provided"} overlaps with an existing Docker network. Please choose a different subnet or leave empty for automatic allocation.`,
+				});
+			}
+
+			if (errorMessage.includes("already exists")) {
+				throw new TRPCError({
+					code: "CONFLICT",
+					message:
+						"A Docker network with this configuration already exists. Please use a different network name or check existing networks.",
+				});
+			}
+
+			throw new TRPCError({
+				code: "INTERNAL_SERVER_ERROR",
+				message: `Failed to create Docker network: ${errorMessage}`,
+				cause: dockerError,
+			});
+		}
+
+		const dockerNetworkInspect = await inspectDockerNetwork(
+			input.networkName,
+			input.serverId,
+		);
+
+		const newNetwork = await db
+			.insert(networks)
+			.values({
+				name: input.name,
+				description: input.description,
+				networkName: input.networkName,
+				driver: input.driver || "bridge",
+				subnet: input.subnet,
+				gateway: input.gateway,
+				ipRange: input.ipRange,
+				internal: input.internal ?? false,
+				encrypted: input.encrypted ?? false,
+				organizationId: input.organizationId,
+				projectId: input.projectId,
+				serverId: input.serverId,
+				dockerNetworkId: dockerNetworkInspect.Id,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newNetwork) {
+			await removeDockerNetwork(input.networkName, input.serverId);
+			throw new TRPCError({
+				code: "INTERNAL_SERVER_ERROR",
+				message: "Failed to create network record",
+			});
+		}
+
+		return newNetwork;
+	} catch (error) {
+		console.error("Error creating network:", error);
+		if (error instanceof TRPCError) {
+			throw error;
+		}
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message:
+				error instanceof Error
+					? error.message
+					: "Unknown error occurred while creating network",
+			cause: error,
+		});
+	}
+};
+
+export const findNetworkById = async (networkId: string) => {
+	const network = await db.query.networks.findFirst({
+		where: eq(networks.networkId, networkId),
+		with: {
+			project: true,
+			server: true,
+		},
+	});
+
+	if (!network) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Network not found",
+		});
+	}
+
+	return network;
+};
+
+export const findNetworksByProjectId = async (projectId: string) => {
+	return await db.query.networks.findMany({
+		where: eq(networks.projectId, projectId),
+		with: {
+			server: true,
+		},
+		orderBy: desc(networks.createdAt),
+	});
+};
+
+export const findNetworksByOrganizationId = async (organizationId: string) => {
+	return await db.query.networks.findMany({
+		where: eq(networks.organizationId, organizationId),
+		with: {
+			server: true,
+			project: true,
+		},
+		orderBy: desc(networks.createdAt),
+	});
+};
+
+export const findNetworksByOrganizationIdAndServerId = async (
+	organizationId: string,
+	serverId: string | null,
+) => {
+	const whereConditions = [eq(networks.organizationId, organizationId)];
+
+	if (serverId) {
+		whereConditions.push(eq(networks.serverId, serverId));
+	} else {
+		whereConditions.push(isNull(networks.serverId));
+	}
+
+	return await db.query.networks.findMany({
+		where: and(...whereConditions),
+		with: {
+			server: true,
+			project: true,
+		},
+		orderBy: desc(networks.createdAt),
+	});
+};
+
+export const updateNetwork = async (
+	networkId: string,
+	data: Partial<DokployNetwork>,
+): Promise<DokployNetwork> => {
+	await findNetworkById(networkId);
+
+	const updated = await db
+		.update(networks)
+		.set({
+			...data,
+			networkId,
+		})
+		.where(eq(networks.networkId, networkId))
+		.returning()
+		.then((res) => res[0]);
+
+	if (!updated) {
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: "Failed to update network",
+		});
+	}
+
+	return updated;
+};
+
+const isNetworkInUse = async (networkId: string): Promise<boolean> => {
+	const [
+		allApps,
+		allCompose,
+		allPostgres,
+		allMysql,
+		allMariadb,
+		allMongo,
+		allRedis,
+	] = await Promise.all([
+		db.query.applications.findMany(),
+		db.query.compose.findMany(),
+		db.query.postgres.findMany(),
+		db.query.mysql.findMany(),
+		db.query.mariadb.findMany(),
+		db.query.mongo.findMany(),
+		db.query.redis.findMany(),
+	]);
+
+	const hasNetwork = <
+		T extends { customNetworkIds?: readonly string[] | null },
+	>(
+		resources: T[],
+	): boolean =>
+		resources.some((resource) => {
+			const networkIds = Array.from(resource.customNetworkIds || []);
+			return networkIds.includes(networkId);
+		});
+
+	const dbUsage =
+		hasNetwork(allApps) ||
+		hasNetwork(allCompose) ||
+		hasNetwork(allPostgres) ||
+		hasNetwork(allMysql) ||
+		hasNetwork(allMariadb) ||
+		hasNetwork(allMongo) ||
+		hasNetwork(allRedis);
+
+	if (dbUsage) {
+		return true;
+	}
+
+	// Check if Docker network has any containers connected
+	try {
+		const network = await findNetworkById(networkId);
+		const networkInspect = await inspectDockerNetwork(
+			network.networkName,
+			network.serverId,
+		);
+
+		const containers = networkInspect.Containers || {};
+		const hasConnectedContainers = Object.keys(containers).length > 0;
+
+		return hasConnectedContainers;
+	} catch (error) {
+		console.warn("Failed to inspect Docker network for usage check:", error);
+		return false;
+	}
+};
+
+export const deleteNetwork = async (
+	networkId: string,
+): Promise<DokployNetwork> => {
+	const network = await findNetworkById(networkId);
+
+	const inUse = await isNetworkInUse(networkId);
+
+	if (inUse) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message:
+				"Cannot delete network that is in use. Please remove it from all resources first.",
+		});
+	}
+
+	try {
+		await removeDockerNetwork(network.networkName, network.serverId);
+	} catch (error) {
+		const errorMessage =
+			error instanceof Error ? error.message : "Unknown error";
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: `Failed to remove Docker network: ${errorMessage}. The network may still be in use by containers.`,
+		});
+	}
+
+	const deleted = await db
+		.delete(networks)
+		.where(eq(networks.networkId, networkId))
+		.returning()
+		.then((res) => res[0]);
+
+	if (!deleted) {
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: "Failed to delete network record",
+		});
+	}
+
+	return deleted;
+};
+
+const validateNetworkDriverCompatibility = (
+	network: DokployNetwork,
+	resourceType: ResourceType,
+	composeType?: string,
+): void => {
+	const isSwarmService = resourceType !== "compose";
+	const isComposeStack = resourceType === "compose" && composeType === "stack";
+
+	if ((isSwarmService || isComposeStack) && network.driver !== "overlay") {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: `This ${resourceType} requires an overlay network. Bridge networks are only compatible with Docker Compose services in "docker-compose" mode.`,
+		});
+	}
+};
+
+const validateServerCompatibility = async (
+	networkId: string,
+	resourceId: string,
+	resourceType: ResourceType,
+): Promise<void> => {
+	const network = await findNetworkById(networkId);
+	const resource = await findResourceById(resourceId, resourceType);
+
+	if (network.serverId && resource.serverId !== network.serverId) {
+		const networkServerName = network.server?.name || network.serverId;
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: `Network is on server "${networkServerName}" but this ${resourceType} is on a different server. Both must be on the same server.`,
+		});
+	}
+
+	if (
+		resource.serverId &&
+		network.serverId &&
+		network.serverId !== resource.serverId
+	) {
+		const resourceServerName = resource.server?.name || resource.serverId;
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: `This ${resourceType} is on server "${resourceServerName}" but the network is on a different server. Both must be on the same server.`,
+		});
+	}
+};
+
+const checkDomainInternalNetworkConflict = async (
+	resource: ResourceWithNetworks,
+	network: DokployNetwork,
+): Promise<void> => {
+	const hasDomains =
+		Array.isArray(resource.domains) && resource.domains.length > 0;
+
+	if (!hasDomains) {
+		return;
+	}
+
+	const currentNetworkIds = Array.from(resource.customNetworkIds || []);
+	const allNetworks = await db.query.networks.findMany({
+		where: inArray(networks.networkId, [
+			...currentNetworkIds,
+			network.networkId,
+		]),
+	});
+
+	const allInternal = allNetworks.every((n) => n.internal);
+
+	if (allInternal && resource.domains) {
+		console.warn(
+			`This resource has ${resource.domains.length} domain(s) but all custom networks are internal. The domain(s) will not be accessible because Traefik cannot connect to internal networks.`,
+		);
+	}
+};
+
+export const assignNetworkToResource = async (
+	networkId: string,
+	resourceId: string,
+	resourceType: ResourceType,
+): Promise<{
+	success: boolean;
+	networkId: string;
+	resourceId: string;
+	resourceType: ResourceType;
+}> => {
+	const network = await findNetworkById(networkId);
+	const resource = await findResourceById(resourceId, resourceType);
+
+	const currentNetworkIds = Array.from(resource.customNetworkIds || []);
+
+	if (currentNetworkIds.includes(networkId)) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Network already assigned to this resource",
+		});
+	}
+
+	validateNetworkDriverCompatibility(
+		network,
+		resourceType,
+		resource.composeType,
+	);
+
+	await validateServerCompatibility(networkId, resourceId, resourceType);
+
+	await checkDomainInternalNetworkConflict(resource, network);
+
+	const updatedNetworkIds = [...currentNetworkIds, networkId];
+	const table = RESOURCE_TABLE_MAP[resourceType];
+	const idField = `${resourceType}Id` as keyof typeof table.$inferSelect;
+
+	await db
+		.update(table)
+		.set({ customNetworkIds: updatedNetworkIds } as any)
+		.where(eq(table[idField], resourceId));
+
+	return { success: true, networkId, resourceId, resourceType };
+};
+
+const isNetworkUsedByResourcesWithDomains = async (
+	networkId: string,
+): Promise<boolean> => {
+	const [allApps, allCompose, allPreviews] = await Promise.all([
+		db.query.applications.findMany({ with: { domains: true } }),
+		db.query.compose.findMany({ with: { domains: true } }),
+		db.query.previewDeployments.findMany({ with: { domain: true } }),
+	]);
+
+	const hasDomainsUsingNetwork = <
+		T extends {
+			domains?: { networkId: string | null }[];
+		},
+	>(
+		resources: T[],
+	): boolean =>
+		resources.some((resource) => {
+			if (!Array.isArray(resource.domains)) return false;
+			return resource.domains.some((domain) => domain.networkId === networkId);
+		});
+
+	const hasPreviewDomainUsingNetwork = (
+		previews: { domain: { networkId: string | null } | null }[],
+	): boolean =>
+		previews.some(
+			(preview) => preview.domain && preview.domain.networkId === networkId,
+		);
+
+	return (
+		hasDomainsUsingNetwork(allApps) ||
+		hasDomainsUsingNetwork(allCompose) ||
+		hasPreviewDomainUsingNetwork(allPreviews)
+	);
+};
+
+const disconnectTraefikFromNetworkIfNotUsed = async (
+	networkId: string,
+	networkName: string,
+	serverId?: string | null,
+): Promise<boolean> => {
+	const stillInUse = await isNetworkUsedByResourcesWithDomains(networkId);
+
+	if (!stillInUse) {
+		try {
+			await ensureTraefikDisconnectedFromNetwork(networkName, serverId);
+			console.log(`Traefik disconnected from network: ${networkName}`);
+			return true;
+		} catch (error) {
+			console.warn(
+				`Failed to disconnect Traefik from network ${networkName}:`,
+				error,
+			);
+			return false;
+		}
+	}
+
+	console.log(
+		`Network ${networkName} still in use by resources with domains, keeping Traefik connected`,
+	);
+	return false;
+};
+
+export const removeNetworkFromResource = async (
+	networkId: string,
+	resourceId: string,
+	resourceType: ResourceType,
+): Promise<{
+	success: boolean;
+	networkId: string;
+	resourceId: string;
+	resourceType: ResourceType;
+}> => {
+	const network = await findNetworkById(networkId);
+	const resource = await findResourceById(resourceId, resourceType);
+
+	const currentNetworkIds = Array.from(resource.customNetworkIds || []);
+	const updatedNetworkIds = currentNetworkIds.filter((id) => id !== networkId);
+
+	const table = RESOURCE_TABLE_MAP[resourceType];
+	const idField = `${resourceType}Id` as keyof typeof table.$inferSelect;
+
+	await db
+		.update(table)
+		.set({ customNetworkIds: updatedNetworkIds } as any)
+		.where(eq(table[idField], resourceId));
+
+	await disconnectTraefikFromNetworkIfNotUsed(
+		networkId,
+		network.networkName,
+		network.serverId,
+	);
+
+	return { success: true, networkId, resourceId, resourceType };
+};
+
+export const getResourceNetworks = async (
+	resourceId: string,
+	resourceType: ResourceTypeWithPreview,
+) => {
+	const resource = await findResourceById(resourceId, resourceType);
+
+	let networkIds: string[];
+	if (resourceType === "preview") {
+		const previewResource = resource as any;
+		networkIds = Array.from(
+			previewResource.application?.previewNetworkIds ||
+				previewResource.application?.customNetworkIds ||
+				[],
+		);
+	} else {
+		networkIds = Array.from(resource.customNetworkIds || []);
+	}
+
+	if (networkIds.length === 0) {
+		return [];
+	}
+
+	return await db.query.networks.findMany({
+		where: inArray(networks.networkId, networkIds),
+	});
+};
+
+/**
+ * Get all networks for a server that are compatible with a resource type
+ */
+export const getAllNetworksByServer = async (
+	serverId: string | null,
+	resourceType: "application" | "compose",
+	composeType?: "docker-compose" | "stack",
+): Promise<(typeof networks.$inferSelect)[]> => {
+	// Compose docker-compose can use bridge OR overlay
+	// Applications and compose stack require overlay (swarm mode)
+	const compatibleDrivers: ("bridge" | "overlay")[] =
+		resourceType === "compose" && composeType === "docker-compose"
+			? ["bridge", "overlay"]
+			: ["overlay"];
+
+	// Handle local server (null serverId) or remote server
+	const serverCondition = serverId
+		? eq(networks.serverId, serverId)
+		: isNull(networks.serverId);
+
+	return await db.query.networks.findMany({
+		where: and(
+			serverCondition,
+			inArray(networks.driver, compatibleDrivers),
+			eq(networks.internal, false), // Exclude internal networks (can't be used with domains)
+		),
+	});
+};
+
+export const listServerNetworks = async (serverId?: string | null) => {
+	return await listDockerNetworks(serverId);
+};
+
+/**
+ * Sync Dokploy networks with Docker networks
+ * This ensures the database is in sync with Docker state
+ */
+export const syncNetworks = async (
+	serverId?: string | null,
+): Promise<NetworkSyncResult> => {
+	const dockerNetworks = await listDockerNetworks(serverId);
+	const dokployNetworks = await db.query.networks.findMany({
+		where: serverId ? eq(networks.serverId, serverId) : undefined,
+	});
+
+	const synced: NetworkSyncResult = {
+		missing: [],
+		orphaned: [],
+	};
+
+	for (const dokployNetwork of dokployNetworks) {
+		const exists = dockerNetworks.some(
+			(dn) => dn.Name === dokployNetwork.networkName,
+		);
+		if (!exists) {
+			synced.missing.push(dokployNetwork.networkName);
+		}
+	}
+
+	for (const dockerNetwork of dockerNetworks) {
+		if (dockerNetwork.Labels?.["com.dokploy.organization.id"]) {
+			const exists = dokployNetworks.some(
+				(dn) => dn.networkName === dockerNetwork.Name,
+			);
+			if (!exists) {
+				synced.orphaned.push(dockerNetwork.Name);
+			}
+		}
+	}
+
+	return synced;
+};
+
+/**
+ * Import orphaned Docker networks into the database
+ * This imports networks that exist in Docker but not in the Dokploy database
+ */
+export const importOrphanedNetworks = async (
+	serverId?: string | null,
+): Promise<NetworkImportResult> => {
+	const dockerNetworks = await listDockerNetworks(serverId);
+	const imported: DokployNetwork[] = [];
+	const errors: NetworkImportError[] = [];
+
+	for (const dockerNetwork of dockerNetworks) {
+		const orgId = dockerNetwork.Labels?.["com.dokploy.organization.id"];
+		if (!orgId) continue;
+
+		const exists = await db.query.networks.findFirst({
+			where: and(
+				eq(networks.networkName, dockerNetwork.Name),
+				serverId ? eq(networks.serverId, serverId) : undefined,
+			),
+		});
+
+		if (exists) continue;
+
+		try {
+			// Verify organization exists
+			const organization = await db.query.organization.findFirst({
+				where: (organization, { eq }) => eq(organization.id, orgId),
+			});
+
+			if (!organization) {
+				errors.push({
+					networkName: dockerNetwork.Name,
+					error: `Organization with ID "${orgId}" does not exist. Network cannot be imported (orphaned network).`,
+				});
+				continue;
+			}
+
+			const projectId =
+				dockerNetwork.Labels?.["com.dokploy.project.id"] || null;
+
+			// Verify project exists if projectId is provided
+			if (projectId) {
+				const project = await db.query.projects.findFirst({
+					where: (projects, { eq }) => eq(projects.projectId, projectId),
+				});
+
+				if (!project) {
+					errors.push({
+						networkName: dockerNetwork.Name,
+						error: `Project with ID "${projectId}" does not exist. Network cannot be imported (orphaned network).`,
+					});
+					continue;
+				}
+			}
+
+			const networkInspect = await inspectDockerNetwork(
+				dockerNetwork.Name,
+				serverId,
+			);
+
+			const ipamConfig = networkInspect.IPAM?.Config?.[0];
+			const displayName =
+				dockerNetwork.Labels?.["com.dokploy.network.name"] ||
+				dockerNetwork.Name;
+			const driverType =
+				dockerNetwork.Driver === "overlay" ? "overlay" : "bridge";
+
+			const [importedNetwork] = await db
+				.insert(networks)
+				.values({
+					name: displayName,
+					networkName: dockerNetwork.Name,
+					description: `Imported from Docker on ${new Date().toISOString()}`,
+					driver: driverType,
+					dockerNetworkId: dockerNetwork.Id,
+					organizationId: orgId,
+					projectId,
+					serverId,
+					internal: networkInspect.Internal ?? false,
+					encrypted: false,
+					subnet: ipamConfig?.Subnet || null,
+					gateway: ipamConfig?.Gateway || null,
+					ipRange: ipamConfig?.IPRange || null,
+				})
+				.returning();
+
+			if (importedNetwork) {
+				imported.push(importedNetwork);
+			}
+		} catch (error) {
+			console.error(`Failed to import network ${dockerNetwork.Name}:`, error);
+			errors.push({
+				networkName: dockerNetwork.Name,
+				error: error instanceof Error ? error.message : "Unknown error",
+			});
+		}
+	}
+
+	return { imported, errors };
+};
+
+/**
+ * Connect Traefik to a specific network for domain routing
+ * This is called when a domain is added to a resource to ensure Traefik can route traffic
+ *
+ * If domainNetworkId is provided, connects Traefik to that network only.
+ * If domainNetworkId is null/undefined, connects to dokploy-network as fallback.
+ */
+export const connectTraefikToResourceNetworks = async (
+	resourceId: string,
+	resourceType: ResourceTypeWithPreview,
+	serverId?: string | null,
+	domainNetworkId?: string | null,
+): Promise<void> => {
+	try {
+		// If a specific network is selected for this domain, use only that network
+		if (domainNetworkId) {
+			const selectedNetwork = await db.query.networks.findFirst({
+				where: eq(networks.networkId, domainNetworkId),
+			});
+
+			if (!selectedNetwork) {
+				console.warn(
+					`Selected network ${domainNetworkId} not found, falling back to dokploy-network`,
+				);
+				await ensureTraefikConnectedToNetwork("dokploy-network", serverId);
+				return;
+			}
+
+			if (selectedNetwork.internal) {
+				console.warn(
+					`Selected network ${selectedNetwork.networkName} is internal. Traefik cannot connect to internal networks. Falling back to dokploy-network.`,
+				);
+				await ensureTraefikConnectedToNetwork("dokploy-network", serverId);
+				return;
+			}
+
+			console.log(
+				`Connecting Traefik to selected network: ${selectedNetwork.networkName}`,
+			);
+			await ensureTraefikConnectedToNetwork(
+				selectedNetwork.networkName,
+				serverId,
+			);
+			return;
+		}
+
+		// No network selected - use dokploy-network as default fallback
+		console.log(
+			`No network selected for ${resourceType} ${resourceId}, using dokploy-network`,
+		);
+		await ensureTraefikConnectedToNetwork("dokploy-network", serverId);
+	} catch (error) {
+		console.error(
+			`Error connecting Traefik to network for ${resourceType} ${resourceId}:`,
+			error,
+		);
+		// If all else fails, try connecting to dokploy-network
+		try {
+			await ensureTraefikConnectedToNetwork("dokploy-network", serverId);
+		} catch (fallbackError) {
+			console.error(
+				"Failed to connect to fallback dokploy-network:",
+				fallbackError,
+			);
+		}
+	}
+};
+
+/**
+ * Disconnect Traefik from a specific domain network if it's no longer used by any other domains
+ * This is called when a domain is deleted from a resource
+ */
+export const disconnectTraefikFromResourceNetworks = async (
+	resourceId: string,
+	resourceType: ResourceType,
+	serverId: string | null | undefined,
+	domainNetworkId: string | null,
+): Promise<void> => {
+	try {
+		if (domainNetworkId === null) {
+			console.log(
+				`Domain was on dokploy-network for ${resourceType} ${resourceId}, keeping Traefik connected`,
+			);
+			return;
+		}
+
+		const network = await findNetworkById(domainNetworkId);
+
+		await disconnectTraefikFromNetworkIfNotUsed(
+			domainNetworkId,
+			network.networkName,
+			serverId,
+		);
+	} catch (error) {
+		console.error(
+			`Error disconnecting Traefik from network for ${resourceType} ${resourceId}:`,
+			error,
+		);
+	}
+};
diff --git a/packages/server/src/services/preview-deployment.ts b/packages/server/src/services/preview-deployment.ts
index 1ece3bc539..86d1780887 100644
--- a/packages/server/src/services/preview-deployment.ts
+++ b/packages/server/src/services/preview-deployment.ts
@@ -17,6 +17,7 @@ import { findApplicationById } from "./application";
 import { removeDeploymentsByPreviewDeploymentId } from "./deployment";
 import { createDomain } from "./domain";
 import { type Github, getIssueComment } from "./github";
+import { connectTraefikToResourceNetworks } from "./network";
 import { getWebServerSettings } from "./web-server-settings";
 
 export type PreviewDeployment = typeof previewDeployments.$inferSelect;
@@ -135,6 +136,11 @@ export const createPreviewDeployment = async (
 	const application = await findApplicationById(schema.applicationId);
 	const appName = `preview-${application.appName}-${generatePassword(6)}`;
 
+	const previewNetworkIds =
+		application.previewNetworkIds || application.customNetworkIds || [];
+	const defaultNetworkId =
+		previewNetworkIds.length > 0 ? previewNetworkIds[0] : null;
+
 	const org = await db.query.organization.findFirst({
 		where: eq(organization.id, application.environment.project.organizationId),
 	});
@@ -186,12 +192,20 @@ export const createPreviewDeployment = async (
 		customCertResolver: application.previewCustomCertResolver,
 		domainType: "preview",
 		previewDeploymentId: previewDeployment.previewDeploymentId,
+		networkId: defaultNetworkId,
 	});
 
 	application.appName = appName;
 
 	await manageDomain(application, newDomain);
 
+	await connectTraefikToResourceNetworks(
+		previewDeployment.previewDeploymentId,
+		"preview",
+		application.serverId,
+		newDomain.networkId,
+	);
+
 	await db
 		.update(previewDeployments)
 		.set({
diff --git a/packages/server/src/services/rollbacks.ts b/packages/server/src/services/rollbacks.ts
index 00c60ebc87..d406719ba7 100644
--- a/packages/server/src/services/rollbacks.ts
+++ b/packages/server/src/services/rollbacks.ts
@@ -221,7 +221,7 @@ const rollbackApplication = async (
 		UpdateConfig,
 		Networks,
 		Ulimits,
-	} = generateConfigContainer(fullContext as ApplicationNested);
+	} = await generateConfigContainer(fullContext as ApplicationNested);
 
 	const bindsMount = generateBindMounts(mounts);
 	const envVariables = prepareEnvironmentVariables(
diff --git a/packages/server/src/services/settings.ts b/packages/server/src/services/settings.ts
index f3603a8f01..692fdc0869 100644
--- a/packages/server/src/services/settings.ts
+++ b/packages/server/src/services/settings.ts
@@ -4,11 +4,11 @@ import {
 	execAsync,
 	execAsyncRemote,
 } from "@dokploy/server/utils/process/execAsync";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNotNull } from "drizzle-orm";
 
 import semver from "semver";
 import { db } from "../db";
-import { compose } from "../db/schema";
+import { compose, networks } from "../db/schema";
 import {
 	initializeStandaloneTraefik,
 	initializeTraefikService,
@@ -457,20 +457,21 @@ export const writeTraefikSetup = async (input: TraefikOptions) => {
 };
 
 export const reconnectServicesToTraefik = async (serverId?: string) => {
-	const composeResult = await db.query.compose.findMany({
+	const networkResults = await db.query.networks.findMany({
 		where: and(
-			...(serverId ? [eq(compose.serverId, serverId)] : []),
-			eq(compose.isolatedDeployment, true),
+			...(serverId ? [eq(networks.serverId, serverId)] : []),
+			eq(networks.internal, false),
 		),
 	});
 
-	if (!composeResult) {
+	if (!networkResults || networkResults.length === 0) {
 		return;
 	}
+
 	let commands = "";
 
-	for (const compose of composeResult) {
-		commands += `docker network connect ${compose.appName} $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1\n`;
+	for (const network of networkResults) {
+		commands += `docker network connect ${network.networkName} $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1\n`;
 	}
 
 	if (serverId) {
diff --git a/packages/server/src/utils/builders/compose.ts b/packages/server/src/utils/builders/compose.ts
index 5eede59d55..80634ca80a 100644
--- a/packages/server/src/utils/builders/compose.ts
+++ b/packages/server/src/utils/builders/compose.ts
@@ -53,10 +53,8 @@ Compose Type: ${composeType} ✅`;
 	
 		cd "${projectPath}";
 
-		${compose.isolatedDeployment ? `docker network inspect ${compose.appName} >/dev/null 2>&1 || docker network create --attachable ${compose.appName}` : ""}
 		env -i PATH="$PATH" ${exportEnvCommand} docker ${command.split(" ").join(" ")} 2>&1 || { echo "Error: ❌ Docker command failed"; exit 1; }
-		${compose.isolatedDeployment ? `docker network connect ${compose.appName} $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1` : ""}
-	
+
 		echo "Docker Compose Deployed: ✅";
 	} || {
 		echo "Error: ❌ Script execution failed";
diff --git a/packages/server/src/utils/builders/index.ts b/packages/server/src/utils/builders/index.ts
index 5bf3a790e0..1a62e1bb56 100644
--- a/packages/server/src/utils/builders/index.ts
+++ b/packages/server/src/utils/builders/index.ts
@@ -111,7 +111,7 @@ export const mechanizeDockerContainer = async (
 		StopGracePeriod,
 		EndpointSpec,
 		Ulimits,
-	} = generateConfigContainer(application);
+	} = await generateConfigContainer(application);
 
 	const bindsMount = generateBindMounts(mounts);
 	const filesMount = generateFileMounts(appName, application);
diff --git a/packages/server/src/utils/databases/mariadb.ts b/packages/server/src/utils/databases/mariadb.ts
index bd3ba31f60..ef550ab22e 100644
--- a/packages/server/src/utils/databases/mariadb.ts
+++ b/packages/server/src/utils/databases/mariadb.ts
@@ -49,7 +49,7 @@ export const buildMariadb = async (mariadb: MariadbNested) => {
 		StopGracePeriod,
 		EndpointSpec,
 		Ulimits,
-	} = generateConfigContainer(mariadb);
+	} = await generateConfigContainer(mariadb);
 	const resources = calculateResources({
 		memoryLimit,
 		memoryReservation,
diff --git a/packages/server/src/utils/databases/mongo.ts b/packages/server/src/utils/databases/mongo.ts
index 6644ea5c47..4242e1f071 100644
--- a/packages/server/src/utils/databases/mongo.ts
+++ b/packages/server/src/utils/databases/mongo.ts
@@ -95,7 +95,7 @@ ${command ?? "wait $MONGOD_PID"}`;
 		StopGracePeriod,
 		EndpointSpec,
 		Ulimits,
-	} = generateConfigContainer(mongo);
+	} = await generateConfigContainer(mongo);
 
 	const resources = calculateResources({
 		memoryLimit,
diff --git a/packages/server/src/utils/databases/mysql.ts b/packages/server/src/utils/databases/mysql.ts
index f68cb42de7..8449973216 100644
--- a/packages/server/src/utils/databases/mysql.ts
+++ b/packages/server/src/utils/databases/mysql.ts
@@ -55,7 +55,7 @@ export const buildMysql = async (mysql: MysqlNested) => {
 		StopGracePeriod,
 		EndpointSpec,
 		Ulimits,
-	} = generateConfigContainer(mysql);
+	} = await generateConfigContainer(mysql);
 	const resources = calculateResources({
 		memoryLimit,
 		memoryReservation,
diff --git a/packages/server/src/utils/databases/postgres.ts b/packages/server/src/utils/databases/postgres.ts
index b6977f587d..72b2114347 100644
--- a/packages/server/src/utils/databases/postgres.ts
+++ b/packages/server/src/utils/databases/postgres.ts
@@ -48,7 +48,7 @@ export const buildPostgres = async (postgres: PostgresNested) => {
 		StopGracePeriod,
 		EndpointSpec,
 		Ulimits,
-	} = generateConfigContainer(postgres);
+	} = await generateConfigContainer(postgres);
 	const resources = calculateResources({
 		memoryLimit,
 		memoryReservation,
@@ -123,8 +123,7 @@ export const buildPostgres = async (postgres: PostgresNested) => {
 				ForceUpdate: inspect.Spec.TaskTemplate.ForceUpdate + 1,
 			},
 		});
-	} catch (error) {
-		console.log("error", error);
+	} catch {
 		await docker.createService(settings);
 	}
 };
diff --git a/packages/server/src/utils/databases/redis.ts b/packages/server/src/utils/databases/redis.ts
index fd358ee51b..6d0611623a 100644
--- a/packages/server/src/utils/databases/redis.ts
+++ b/packages/server/src/utils/databases/redis.ts
@@ -46,7 +46,7 @@ export const buildRedis = async (redis: RedisNested) => {
 		StopGracePeriod,
 		EndpointSpec,
 		Ulimits,
-	} = generateConfigContainer(redis);
+	} = await generateConfigContainer(redis);
 	const resources = calculateResources({
 		memoryLimit,
 		memoryReservation,
diff --git a/packages/server/src/utils/docker/collision.ts b/packages/server/src/utils/docker/collision.ts
index 88d20d4d80..7e735fbc85 100644
--- a/packages/server/src/utils/docker/collision.ts
+++ b/packages/server/src/utils/docker/collision.ts
@@ -1,7 +1,10 @@
 import { findComposeById } from "@dokploy/server/services/compose";
 import { stringify } from "yaml";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { addAppNameToAllServiceNames } from "./collision/root-network";
+import {
+	addAppNameToAllServiceNames,
+	addCustomNetworksToCompose,
+} from "./collision/root-network";
 import { generateRandomHash } from "./compose";
 import { addSuffixToAllVolumes } from "./compose/volume";
 import {
@@ -11,6 +14,9 @@ import {
 } from "./domain";
 import type { ComposeSpecification } from "./types";
 
+// Re-export functions from collision/root-network
+export { addCustomNetworksToCompose } from "./collision/root-network";
+
 export const addAppNameToPreventCollision = (
 	composeData: ComposeSpecification,
 	appName: string,
@@ -50,17 +56,7 @@ export const randomizeIsolatedDeploymentComposeFile = async (
 		throw new Error("Compose data not found");
 	}
 
-	const randomSuffix = suffix || compose.appName || generateRandomHash();
-
-	const newComposeFile = compose.isolatedDeployment
-		? addAppNameToPreventCollision(
-				composeData,
-				randomSuffix,
-				compose.isolatedDeploymentsVolume,
-			)
-		: composeData;
-
-	return stringify(newComposeFile);
+	return stringify(composeData);
 };
 
 export const randomizeDeployableSpecificationFile = (
@@ -78,3 +74,41 @@ export const randomizeDeployableSpecificationFile = (
 	);
 	return newComposeFile;
 };
+
+export const generateFullComposePreview = async (
+	composeId: string,
+	suffix?: string,
+) => {
+	const compose = await findComposeById(composeId);
+
+	const command = await cloneCompose(compose);
+	if (compose.serverId) {
+		await execAsyncRemote(compose.serverId, command);
+	} else {
+		await execAsync(command);
+	}
+
+	let composeData: ComposeSpecification | null;
+
+	if (compose.serverId) {
+		composeData = await loadDockerComposeRemote(compose);
+	} else {
+		composeData = await loadDockerCompose(compose);
+	}
+
+	if (!composeData) {
+		throw new Error("Compose data not found");
+	}
+
+	let newComposeFile = composeData;
+
+	// Add custom networks from customNetworkIds
+	if (compose.customNetworkIds && compose.customNetworkIds.length > 0) {
+		newComposeFile = await addCustomNetworksToCompose(
+			newComposeFile,
+			compose.customNetworkIds,
+		);
+	}
+
+	return stringify(newComposeFile);
+};
diff --git a/packages/server/src/utils/docker/collision/root-network.ts b/packages/server/src/utils/docker/collision/root-network.ts
index ed36d4bd64..c1028fd0fa 100644
--- a/packages/server/src/utils/docker/collision/root-network.ts
+++ b/packages/server/src/utils/docker/collision/root-network.ts
@@ -1,4 +1,7 @@
+import { inArray } from "drizzle-orm";
 import _ from "lodash";
+import { db } from "../../../db";
+import { networks } from "../../../db/schema";
 import type { ComposeSpecification, DefinitionsService } from "../types";
 
 export const addAppNameToRootNetwork = (
@@ -60,3 +63,65 @@ export const addAppNameToAllServiceNames = (
 
 	return updatedComposeData;
 };
+
+const addCustomNetworksToServices = (
+	services: { [key: string]: DefinitionsService },
+	networkNames: string[],
+): { [key: string]: DefinitionsService } => {
+	return _.mapValues(services, (service) => {
+		if (!service.networks) {
+			service.networks = [...networkNames];
+			return service;
+		}
+
+		if (Array.isArray(service.networks)) {
+			for (const networkName of networkNames) {
+				if (!service.networks.includes(networkName)) {
+					service.networks.push(networkName);
+				}
+			}
+		} else {
+			for (const networkName of networkNames) {
+				if (!service.networks[networkName]) {
+					service.networks[networkName] = {};
+				}
+			}
+		}
+
+		return service;
+	});
+};
+
+export const addCustomNetworksToCompose = async (
+	composeData: ComposeSpecification,
+	customNetworkIds: string[],
+): Promise<ComposeSpecification> => {
+	const updatedComposeData = { ...composeData };
+
+	if (!updatedComposeData.networks) {
+		updatedComposeData.networks = {};
+	}
+
+	// Fetch network details from DB
+	const customNetworks = await db.query.networks.findMany({
+		where: inArray(networks.networkId, customNetworkIds),
+	});
+
+	// Add each custom network to compose
+	for (const network of customNetworks) {
+		updatedComposeData.networks[network.networkName] = {
+			name: network.networkName,
+			external: true,
+		};
+	}
+
+	// Add custom networks to all services
+	if (updatedComposeData.services) {
+		updatedComposeData.services = addCustomNetworksToServices(
+			updatedComposeData.services,
+			customNetworks.map((n) => n.networkName),
+		);
+	}
+
+	return updatedComposeData;
+};
diff --git a/packages/server/src/utils/docker/domain.ts b/packages/server/src/utils/docker/domain.ts
index 86ed1e86cf..b6534817b6 100644
--- a/packages/server/src/utils/docker/domain.ts
+++ b/packages/server/src/utils/docker/domain.ts
@@ -11,7 +11,10 @@ import { cloneGiteaRepository } from "../providers/gitea";
 import { cloneGithubRepository } from "../providers/github";
 import { cloneGitlabRepository } from "../providers/gitlab";
 import { getCreateComposeFileCommand } from "../providers/raw";
-import { randomizeDeployableSpecificationFile } from "./collision";
+import {
+	addCustomNetworksToCompose,
+	randomizeDeployableSpecificationFile,
+} from "./collision";
 import { randomizeSpecificationFile } from "./compose";
 import type {
 	ComposeSpecification,
@@ -145,22 +148,35 @@ export const addDomainToCompose = async (
 		result = await loadDockerCompose(compose);
 	}
 
-	if (!result || domains.length === 0) {
+	if (!result) {
 		return null;
 	}
 
-	if (compose.isolatedDeployment) {
-		const randomized = randomizeDeployableSpecificationFile(
-			result,
-			compose.isolatedDeploymentsVolume,
-			compose.suffix || compose.appName,
-		);
-		result = randomized;
-	} else if (compose.randomize) {
+	if (compose.randomize) {
 		const randomized = randomizeSpecificationFile(result, compose.suffix);
 		result = randomized;
 	}
 
+	if (compose.customNetworkIds && compose.customNetworkIds.length > 0) {
+		result = await addCustomNetworksToCompose(result, compose.customNetworkIds);
+	}
+
+	// Ensure all composes without customNetworkIds use dokploy-network to prevent conflicts
+	// with unmanaged network {stack}_default networks
+	if (
+		(!compose.customNetworkIds || compose.customNetworkIds.length === 0) &&
+		result.services
+	) {
+		for (const serviceName in result.services) {
+			const service = result.services[serviceName];
+			if (service) {
+				service.networks = addDokployNetworkToService(service.networks);
+			}
+		}
+
+		result.networks = addDokployNetworkToRoot(result.networks);
+	}
+
 	for (const domain of domains) {
 		const { serviceName, https } = domain;
 		if (!serviceName) {
@@ -202,33 +218,56 @@ export const addDomainToCompose = async (
 				labels.unshift("traefik.enable=true");
 			}
 			labels.unshift(...httpLabels);
-			if (!compose.isolatedDeployment) {
-				if (compose.composeType === "docker-compose") {
-					if (!labels.includes("traefik.docker.network=dokploy-network")) {
-						labels.unshift("traefik.docker.network=dokploy-network");
-					}
-				} else {
-					// Stack Case
-					if (!labels.includes("traefik.swarm.network=dokploy-network")) {
-						labels.unshift("traefik.swarm.network=dokploy-network");
-					}
+
+			// Determine which network Traefik should use to reach this service
+			let traefikNetwork = "dokploy-network"; // Default
+
+			// If custom networks exist in the compose file, use one of them
+			// (Traefik will be connected to all custom networks, so any will work)
+			if (result.networks && Object.keys(result.networks).length > 0) {
+				// Find the first non-dokploy-network network
+				const networkNames = Object.keys(result.networks);
+				const customNetwork = networkNames.find(
+					(name) => name !== "dokploy-network",
+				);
+				if (customNetwork) {
+					traefikNetwork = customNetwork;
+				}
+			}
+
+			// Add the appropriate network label for Traefik
+			if (compose.composeType === "docker-compose") {
+				const networkLabel = `traefik.docker.network=${traefikNetwork}`;
+				if (
+					!labels.some(
+						(l) =>
+							typeof l === "string" && l.startsWith("traefik.docker.network="),
+					)
+				) {
+					labels.unshift(networkLabel);
+				}
+			} else {
+				// Stack Case (Swarm)
+				const networkLabel = `traefik.swarm.network=${traefikNetwork}`;
+				if (
+					!labels.some(
+						(l) =>
+							typeof l === "string" && l.startsWith("traefik.swarm.network="),
+					)
+				) {
+					labels.unshift(networkLabel);
 				}
 			}
 		}
 
-		if (!compose.isolatedDeployment) {
-			// Add the dokploy-network to the service
+		// Redundant safety check for services added after initial network setup
+		if (!compose.customNetworkIds || compose.customNetworkIds.length === 0) {
 			result.services[serviceName].networks = addDokployNetworkToService(
 				result.services[serviceName].networks,
 			);
 		}
 	}
 
-	// Add dokploy-network to the root of the compose file
-	if (!compose.isolatedDeployment) {
-		result.networks = addDokployNetworkToRoot(result.networks);
-	}
-
 	return result;
 };
 
diff --git a/packages/server/src/utils/docker/network-utils.ts b/packages/server/src/utils/docker/network-utils.ts
new file mode 100644
index 0000000000..f5f904fbaf
--- /dev/null
+++ b/packages/server/src/utils/docker/network-utils.ts
@@ -0,0 +1,343 @@
+import type { Network } from "dockerode";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getRemoteDocker } from "../servers/remote-docker";
+
+export interface IPAMConfig {
+	Subnet?: string;
+	Gateway?: string;
+	IPRange?: string;
+}
+
+export interface DockerNetworkConfig {
+	Name: string;
+	Driver: "bridge" | "overlay";
+	CheckDuplicate?: boolean;
+	Internal?: boolean;
+	Attachable?: boolean;
+	EnableIPv6?: boolean;
+	IPAM?: {
+		Config?: IPAMConfig[];
+	};
+	Labels?: Record<string, string>;
+	Options?: Record<string, string>;
+}
+
+export const createDockerNetwork = async (
+	config: DockerNetworkConfig,
+	serverId?: string | null,
+): Promise<Network> => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const network = await remoteDocker.createNetwork(
+			config as Parameters<typeof remoteDocker.createNetwork>[0],
+		);
+		return network;
+	} catch (error) {
+		console.error("Error creating Docker network:", error);
+		throw error;
+	}
+};
+
+export const removeDockerNetwork = async (
+	networkName: string,
+	serverId?: string | null,
+): Promise<void> => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const network = remoteDocker.getNetwork(networkName);
+		await network.remove();
+	} catch (error) {
+		console.error("Error removing Docker network:", error);
+		throw error;
+	}
+};
+
+export const dockerNetworkExists = async (
+	networkName: string,
+	serverId?: string | null,
+): Promise<boolean> => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const network = remoteDocker.getNetwork(networkName);
+		await network.inspect();
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+export const inspectDockerNetwork = async (
+	networkName: string,
+	serverId?: string | null,
+) => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const network = remoteDocker.getNetwork(networkName);
+		return await network.inspect();
+	} catch (error) {
+		console.error("Error inspecting Docker network:", error);
+		throw error;
+	}
+};
+
+export const listDockerNetworks = async (serverId?: string | null) => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		return await remoteDocker.listNetworks();
+	} catch (error) {
+		console.error("Error listing Docker networks:", error);
+		throw error;
+	}
+};
+
+export const connectContainerToNetwork = async (
+	networkName: string,
+	containerName: string,
+	aliases?: string[],
+	serverId?: string | null,
+): Promise<void> => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const network = remoteDocker.getNetwork(networkName);
+
+		await network.connect({
+			Container: containerName,
+			EndpointConfig: aliases
+				? {
+						Aliases: aliases,
+					}
+				: undefined,
+		});
+	} catch (error) {
+		console.error("Error connecting container to network:", error);
+		throw error;
+	}
+};
+
+export const disconnectContainerFromNetwork = async (
+	networkName: string,
+	containerName: string,
+	serverId?: string | null,
+): Promise<void> => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const network = remoteDocker.getNetwork(networkName);
+
+		await network.disconnect({
+			Container: containerName,
+			Force: false,
+		});
+	} catch (error) {
+		console.error("Error disconnecting container from network:", error);
+		throw error;
+	}
+};
+
+export const connectServiceToNetwork = async (
+	networkName: string,
+	serviceName: string,
+	serverId?: string | null,
+): Promise<void> => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const service = remoteDocker.getService(serviceName);
+		const inspect = await service.inspect();
+
+		const currentNetworks = inspect.Spec.TaskTemplate?.Networks || [];
+		const alreadyConnected = currentNetworks.some(
+			(net: { Target?: string }) => net.Target === networkName,
+		);
+
+		if (alreadyConnected) {
+			console.log(`Service ${serviceName} already connected to ${networkName}`);
+			return;
+		}
+
+		const updatedNetworks = [...currentNetworks, { Target: networkName }];
+
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...inspect.Spec,
+			TaskTemplate: {
+				...inspect.Spec.TaskTemplate,
+				Networks: updatedNetworks,
+			},
+		});
+	} catch (error) {
+		console.error("Error connecting service to network:", error);
+		throw error;
+	}
+};
+
+export const disconnectServiceFromNetwork = async (
+	networkName: string,
+	serviceName: string,
+	serverId?: string | null,
+): Promise<void> => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const service = remoteDocker.getService(serviceName);
+		const inspect = await service.inspect();
+
+		let networkId: string | undefined;
+		try {
+			const network = remoteDocker.getNetwork(networkName);
+			const networkInspect = await network.inspect();
+			networkId = networkInspect.Id;
+		} catch (error) {
+			console.warn(`Could not get network ID for ${networkName}:`, error);
+		}
+
+		const currentNetworks = inspect.Spec.TaskTemplate?.Networks || [];
+		const updatedNetworks = currentNetworks.filter(
+			(net: { Target?: string }) => {
+				return net.Target !== networkId;
+			},
+		);
+
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...inspect.Spec,
+			TaskTemplate: {
+				...inspect.Spec.TaskTemplate,
+				Networks: updatedNetworks,
+			},
+		});
+	} catch (error) {
+		console.error("Error disconnecting service from network:", error);
+		throw error;
+	}
+};
+
+export const getContainerNetworks = async (
+	containerName: string,
+	serverId?: string | null,
+): Promise<string[]> => {
+	try {
+		const remoteDocker = await getRemoteDocker(serverId);
+		const container = remoteDocker.getContainer(containerName);
+		const inspect = await container.inspect();
+
+		return Object.keys(inspect.NetworkSettings.Networks || {});
+	} catch (error) {
+		console.error("Error getting container networks:", error);
+		return [];
+	}
+};
+
+const connectTraefik = async (
+	networkName: string,
+	traefikService: string,
+	mode: "connect" | "disconnect",
+	serverId?: string | null,
+): Promise<void> => {
+	const networkExists = await dockerNetworkExists(networkName, serverId);
+	if (!networkExists) {
+		console.warn(`Network ${networkName} does not exist`);
+		return;
+	}
+
+	try {
+		const operation =
+			mode === "connect"
+				? connectServiceToNetwork
+				: disconnectServiceFromNetwork;
+		await operation(networkName, traefikService, serverId);
+		console.log(
+			`Traefik service ${mode === "connect" ? "connected to" : "disconnected from"} network ${networkName}`,
+		);
+		return;
+	} catch (swarmError) {
+		console.log("Traefik not running as service, trying container mode");
+	}
+
+	try {
+		const networks = await getContainerNetworks(traefikService, serverId);
+		const isConnected = networks.includes(networkName);
+
+		if (mode === "connect" && isConnected) {
+			console.log(`Traefik container already connected to ${networkName}`);
+			return;
+		}
+
+		if (mode === "disconnect" && !isConnected) {
+			console.log(`Traefik container already disconnected from ${networkName}`);
+			return;
+		}
+
+		if (mode === "connect") {
+			await connectContainerToNetwork(
+				networkName,
+				traefikService,
+				[],
+				serverId,
+			);
+		} else {
+			await disconnectContainerFromNetwork(
+				networkName,
+				traefikService,
+				serverId,
+			);
+		}
+
+		console.log(
+			`Traefik container ${mode === "connect" ? "connected to" : "disconnected from"} network ${networkName}`,
+		);
+	} catch (containerError) {
+		console.error(
+			`Failed to ${mode} Traefik ${mode === "connect" ? "to" : "from"} network:`,
+			containerError,
+		);
+		throw new Error(
+			`Could not ${mode} Traefik ${mode === "connect" ? "to" : "from"} network ${networkName}. Ensure Traefik is running.`,
+		);
+	}
+};
+
+export const ensureTraefikConnectedToNetwork = async (
+	networkName: string,
+	serverId?: string | null,
+): Promise<void> => {
+	try {
+		await connectTraefik(networkName, "dokploy-traefik", "connect", serverId);
+	} catch (error) {
+		console.error("Error ensuring Traefik network connection:", error);
+		throw error;
+	}
+};
+
+export const ensureTraefikDisconnectedFromNetwork = async (
+	networkName: string,
+	serverId?: string | null,
+): Promise<void> => {
+	try {
+		await connectTraefik(
+			networkName,
+			"dokploy-traefik",
+			"disconnect",
+			serverId,
+		);
+	} catch (error) {
+		console.error("Error ensuring Traefik network disconnection:", error);
+		throw error;
+	}
+};
+
+export const pruneUnusedNetworks = async (
+	serverId?: string | null,
+): Promise<void> => {
+	try {
+		const command = "docker network prune --force";
+
+		if (serverId) {
+			await execAsyncRemote(serverId, command);
+		} else {
+			await execAsync(command);
+		}
+
+		console.log("Unused Docker networks pruned");
+	} catch (error) {
+		console.error("Error pruning unused networks:", error);
+		throw error;
+	}
+};
diff --git a/packages/server/src/utils/docker/utils.ts b/packages/server/src/utils/docker/utils.ts
index 144df2c143..56d430c953 100644
--- a/packages/server/src/utils/docker/utils.ts
+++ b/packages/server/src/utils/docker/utils.ts
@@ -2,9 +2,12 @@ import fs from "node:fs";
 import path from "node:path";
 import type { Readable } from "node:stream";
 import { docker, paths } from "@dokploy/server/constants";
+import { db } from "@dokploy/server/db";
+import { networks } from "@dokploy/server/db/schema";
 import type { Compose } from "@dokploy/server/services/compose";
 import type { ContainerInfo, ResourceRequirements } from "dockerode";
 import { parse } from "dotenv";
+import { inArray } from "drizzle-orm";
 import { quote } from "shell-quote";
 import type { ApplicationNested } from "../builders";
 import type { MariadbNested } from "../databases/mariadb";
@@ -492,7 +495,220 @@ export const calculateResources = ({
 	};
 };
 
-export const generateConfigContainer = (
+const resolveTraefikNetwork = async (
+	customNetworkIds: string[] | null | undefined,
+): Promise<string> => {
+	if (!customNetworkIds || customNetworkIds.length === 0) {
+		return "dokploy-network";
+	}
+
+	const customNetworks = await db.query.networks.findMany({
+		where: inArray(networks.networkId, customNetworkIds),
+	});
+
+	return customNetworks[0]?.networkName ?? "dokploy-network";
+};
+
+/**
+ * Resolve Traefik network with priority system:
+ * 1. First non-null, non-internal domain.networkId (highest priority)
+ * 2. First non-internal custom network from customNetworkIds
+ * 3. dokploy-network (fallback)
+ */
+const resolveTraefikNetworkWithDomains = async (
+	domains: Array<{ networkId: string | null }>,
+	customNetworkIds: string[] | null | undefined,
+): Promise<string> => {
+	// Priority 1: Check if any domain has a specific network selected
+	const domainNetworkIds = domains
+		.map((d) => d.networkId)
+		.filter((id): id is string => id !== null);
+
+	if (domainNetworkIds.length > 0) {
+		// Find the first valid, non-internal network from domain selections
+		const domainNetworks = await db.query.networks.findMany({
+			where: inArray(networks.networkId, domainNetworkIds),
+		});
+
+		const nonInternalDomainNetwork = domainNetworks.find((n) => !n.internal);
+		if (nonInternalDomainNetwork) {
+			console.log(
+				`Using domain-specific network: ${nonInternalDomainNetwork.networkName}`,
+			);
+			return nonInternalDomainNetwork.networkName;
+		}
+	}
+
+	// Priority 2: Fall back to first non-internal custom network
+	if (customNetworkIds && customNetworkIds.length > 0) {
+		const customNetworks = await db.query.networks.findMany({
+			where: inArray(networks.networkId, customNetworkIds),
+		});
+
+		const nonInternalCustomNetwork = customNetworks.find((n) => !n.internal);
+		if (nonInternalCustomNetwork) {
+			console.log(
+				`Using custom network: ${nonInternalCustomNetwork.networkName}`,
+			);
+			return nonInternalCustomNetwork.networkName;
+		}
+	}
+
+	// Priority 3: Final fallback to dokploy-network
+	console.log("Using default network: dokploy-network");
+	return "dokploy-network";
+};
+
+const buildRouterRule = (host: string, domainPath?: string | null): string => {
+	const pathRule =
+		domainPath && domainPath !== "/" ? ` && PathPrefix(\`${domainPath}\`)` : "";
+	return `Host(\`${host}\`)${pathRule}`;
+};
+
+const collectMiddlewares = (
+	appName: string,
+	uniqueConfigKey: string,
+	domainPath: string | null | undefined,
+	stripPath: boolean | null,
+	internalPath: string | null | undefined,
+	includeHttpsRedirect: boolean,
+): string[] => {
+	const middlewares: string[] = [];
+
+	if (includeHttpsRedirect) {
+		middlewares.push("redirect-to-https@file");
+	}
+
+	if (stripPath && domainPath && domainPath !== "/") {
+		const middlewareName = `stripprefix-${appName}-${uniqueConfigKey}`;
+		middlewares.push(middlewareName);
+	}
+
+	if (internalPath && internalPath !== "/" && internalPath.startsWith("/")) {
+		const middlewareName = `addprefix-${appName}-${uniqueConfigKey}`;
+		middlewares.push(middlewareName);
+	}
+
+	return middlewares;
+};
+
+const generateDomainLabels = async (
+	applicationId: string,
+	appName: string,
+	customNetworkIds: string[] | null | undefined,
+): Promise<Record<string, string>> => {
+	const application = await db.query.applications.findFirst({
+		where: (applications, { eq }) =>
+			eq(applications.applicationId, applicationId),
+		with: {
+			domains: true,
+		},
+	});
+
+	if (!application?.domains || application.domains.length === 0) {
+		return {};
+	}
+
+	const labels: Record<string, string> = {
+		"traefik.enable": "true",
+		"traefik.docker.network": await resolveTraefikNetworkWithDomains(
+			application.domains,
+			customNetworkIds,
+		),
+	};
+
+	for (const domain of application.domains) {
+		const {
+			host,
+			port,
+			https,
+			uniqueConfigKey,
+			certificateType,
+			path: domainPath,
+			customCertResolver,
+			stripPath,
+			internalPath,
+		} = domain;
+
+		if (!port) {
+			continue;
+		}
+
+		const routerName = `${appName}-${uniqueConfigKey}`;
+		const serviceName = `${appName}-service-${uniqueConfigKey}`;
+		const webRouterName = `${routerName}-web`;
+		const routerRule = buildRouterRule(host, domainPath);
+
+		labels[`traefik.http.routers.${webRouterName}.rule`] = routerRule;
+		labels[`traefik.http.routers.${webRouterName}.entrypoints`] = "web";
+		labels[`traefik.http.routers.${webRouterName}.service`] = serviceName;
+		labels[`traefik.http.services.${serviceName}.loadbalancer.server.port`] =
+			port.toString();
+
+		const webMiddlewares = collectMiddlewares(
+			appName,
+			uniqueConfigKey.toString(),
+			domainPath,
+			stripPath,
+			internalPath,
+			https ?? false,
+		);
+
+		if (webMiddlewares.length > 0) {
+			labels[`traefik.http.routers.${webRouterName}.middlewares`] =
+				webMiddlewares.join(",");
+		}
+
+		if (stripPath && domainPath && domainPath !== "/") {
+			const middlewareName = `stripprefix-${appName}-${uniqueConfigKey}`;
+			labels[
+				`traefik.http.middlewares.${middlewareName}.stripprefix.prefixes`
+			] = domainPath;
+		}
+
+		if (internalPath && internalPath !== "/" && internalPath.startsWith("/")) {
+			const middlewareName = `addprefix-${appName}-${uniqueConfigKey}`;
+			labels[`traefik.http.middlewares.${middlewareName}.addprefix.prefix`] =
+				internalPath;
+		}
+
+		if (https) {
+			const websecureRouterName = `${routerName}-websecure`;
+
+			labels[`traefik.http.routers.${websecureRouterName}.rule`] = routerRule;
+			labels[`traefik.http.routers.${websecureRouterName}.entrypoints`] =
+				"websecure";
+			labels[`traefik.http.routers.${websecureRouterName}.service`] =
+				serviceName;
+
+			const websecureMiddlewares = collectMiddlewares(
+				appName,
+				uniqueConfigKey.toString(),
+				domainPath,
+				stripPath,
+				internalPath,
+				false,
+			);
+
+			if (websecureMiddlewares.length > 0) {
+				labels[`traefik.http.routers.${websecureRouterName}.middlewares`] =
+					websecureMiddlewares.join(",");
+			}
+
+			if (certificateType === "letsencrypt") {
+				labels[`traefik.http.routers.${websecureRouterName}.tls.certresolver`] =
+					"letsencrypt";
+			} else if (certificateType === "custom" && customCertResolver) {
+				labels[`traefik.http.routers.${websecureRouterName}.tls.certresolver`] =
+					customCertResolver;
+			}
+		}
+	}
+
+	return labels;
+};
+
+export const generateConfigContainer = async (
 	application: Partial<ApplicationNested>,
 ) => {
 	const {
@@ -506,7 +722,10 @@ export const generateConfigContainer = (
 		replicas,
 		mounts,
 		networkSwarm,
+		customNetworkIds,
 		stopGracePeriodSwarm,
+		applicationId,
+		appName,
 		endpointSpecSwarm,
 		ulimitsSwarm,
 	} = application;
@@ -518,6 +737,29 @@ export const generateConfigContainer = (
 
 	const haveMounts = mounts && mounts.length > 0;
 
+	let networksToUse: Array<{ Target?: string }>;
+
+	if (networkSwarm) {
+		networksToUse = networkSwarm;
+	} else if (customNetworkIds && customNetworkIds.length > 0) {
+		const customNetworks = await db.query.networks.findMany({
+			where: inArray(networks.networkId, customNetworkIds),
+		});
+		networksToUse = customNetworks.map((net) => ({ Target: net.networkName }));
+	} else {
+		networksToUse = [{ Target: "dokploy-network" }];
+	}
+
+	const generatedLabels =
+		applicationId && appName
+			? await generateDomainLabels(applicationId, appName, customNetworkIds)
+			: {};
+
+	const finalLabels = {
+		...labelsSwarm,
+		...generatedLabels,
+	};
+
 	return {
 		...(healthCheckSwarm && {
 			HealthCheck: healthCheckSwarm,
@@ -530,20 +772,18 @@ export const generateConfigContainer = (
 					Placement: placementSwarm,
 				}
 			: {
-					// if app have mounts keep manager as constraint
 					Placement: {
 						Constraints: haveMounts ? ["node.role==manager"] : [],
 					},
 				}),
-		...(labelsSwarm && {
-			Labels: labelsSwarm,
+		...(Object.keys(finalLabels).length > 0 && {
+			Labels: finalLabels,
 		}),
 		...(modeSwarm
 			? {
 					Mode: modeSwarm,
 				}
 			: {
-					// use replicas value if no modeSwarm provided
 					Mode: {
 						Replicated: {
 							Replicas: replicas,
@@ -556,7 +796,6 @@ export const generateConfigContainer = (
 		...(updateConfigSwarm
 			? { UpdateConfig: updateConfigSwarm }
 			: {
-					// default config if no updateConfigSwarm provided
 					UpdateConfig: {
 						Parallelism: 1,
 						Order: "start-first",
@@ -566,13 +805,7 @@ export const generateConfigContainer = (
 			sanitizedStopGracePeriodSwarm !== undefined && {
 				StopGracePeriod: sanitizedStopGracePeriodSwarm,
 			}),
-		...(networkSwarm
-			? {
-					Networks: networkSwarm,
-				}
-			: {
-					Networks: [{ Target: "dokploy-network" }],
-				}),
+		Networks: networksToUse,
 		...(endpointSpecSwarm && {
 			EndpointSpec: {
 				...(endpointSpecSwarm.Mode && { Mode: endpointSpecSwarm.Mode }),
@@ -709,14 +942,11 @@ export const getComposeContainer = async (
 ) => {
 	try {
 		const { appName, composeType, serverId } = compose;
-		// 1. Determine the correct labels based on composeType
 		const labels: string[] = [];
 		if (composeType === "stack") {
-			// Labels for Docker Swarm stack services
 			labels.push(`com.docker.stack.namespace=${appName}`);
 			labels.push(`com.docker.swarm.service.name=${appName}_${serviceName}`);
 		} else {
-			// Labels for Docker Compose projects (default)
 			labels.push(`com.docker.compose.project=${appName}`);
 			labels.push(`com.docker.compose.service=${serviceName}`);
 		}