diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/EnvironmentDrawer.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/EnvironmentDrawer.tsx
new file mode 100644
index 000000000..835bb394c
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/EnvironmentDrawer.tsx
@@ -0,0 +1,403 @@
+"use client";
+
+import type * as schema from "@ctrlplane/db/schema";
+import React, { useState } from "react";
+import Link from "next/link";
+import { useParams, useRouter, useSearchParams } from "next/navigation";
+import { SiKubernetes, SiTerraform } from "@icons-pack/react-simple-icons";
+import {
+  IconExternalLink,
+  IconFilter,
+  IconInfoCircle,
+  IconPlant,
+  IconServer,
+  IconTarget,
+} from "@tabler/icons-react";
+import * as LZString from "lz-string";
+import { z } from "zod";
+
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+} from "@ctrlplane/ui/alert-dialog";
+import { Button, buttonVariants } from "@ctrlplane/ui/button";
+import { Drawer, DrawerContent, DrawerTitle } from "@ctrlplane/ui/drawer";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+  useForm,
+} from "@ctrlplane/ui/form";
+import { Input } from "@ctrlplane/ui/input";
+import { Label } from "@ctrlplane/ui/label";
+import { Textarea } from "@ctrlplane/ui/textarea";
+import {
+  defaultCondition,
+  targetCondition,
+} from "@ctrlplane/validators/targets";
+
+import { api } from "~/trpc/react";
+import { TabButton } from "./TabButton";
+import { TargetConditionRender } from "./target-condition/TargetConditionRender";
+
+const DeleteEnvironmentDialog: React.FC<{
+  environment: schema.Environment;
+  children: React.ReactNode;
+}> = ({ environment, children }) => {
+  const deleteEnvironment = api.environment.delete.useMutation();
+  const utils = api.useUtils();
+  const { removeEnvironmentId } = useEnvironmentDrawer();
+
+  const onDelete = () =>
+    deleteEnvironment
+      .mutateAsync(environment.id)
+      .then(() => utils.environment.bySystemId.invalidate(environment.systemId))
+      .then(removeEnvironmentId);
+
+  return (
+    <AlertDialog>
+      <AlertDialogTrigger asChild>{children}</AlertDialogTrigger>
+      <AlertDialogContent>
+        <AlertDialogHeader>
+          <AlertDialogTitle>Delete Environment</AlertDialogTitle>
+        </AlertDialogHeader>
+        <AlertDialogDescription>
+          Are you sure you want to delete this environment? You will have to
+          recreate it from scratch.
+        </AlertDialogDescription>
+        <AlertDialogFooter>
+          <AlertDialogCancel>Cancel</AlertDialogCancel>
+          <AlertDialogAction
+            onClick={onDelete}
+            className={buttonVariants({ variant: "destructive" })}
+          >
+            Delete
+          </AlertDialogAction>
+        </AlertDialogFooter>
+      </AlertDialogContent>
+    </AlertDialog>
+  );
+};
+const environmentForm = z.object({
+  name: z.string(),
+  description: z.string().default(""),
+});
+
+const EnvironmentForm: React.FC<{
+  environment: schema.Environment;
+}> = ({ environment }) => {
+  const form = useForm({
+    schema: environmentForm,
+    defaultValues: {
+      name: environment.name,
+      description: environment.description ?? "",
+    },
+  });
+  const update = api.environment.update.useMutation();
+  const envOverride = api.job.trigger.create.byEnvId.useMutation();
+
+  const utils = api.useUtils();
+
+  const { id, systemId } = environment;
+  const onSubmit = form.handleSubmit((data) =>
+    update
+      .mutateAsync({ id, data })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.bySystemId.invalidate(systemId))
+      .then(() => utils.environment.byId.invalidate(id)),
+  );
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="m-6 space-y-8">
+        <FormField
+          control={form.control}
+          name="name"
+          render={({ field }) => (
+            <FormItem>
+              <FormLabel>Name</FormLabel>
+              <FormControl>
+                <Input placeholder="Staging, Production, QA..." {...field} />
+              </FormControl>
+            </FormItem>
+          )}
+        />
+        <FormField
+          control={form.control}
+          name="description"
+          render={({ field }) => (
+            <FormItem>
+              <FormLabel>Description</FormLabel>
+              <FormControl>
+                <Textarea placeholder="Add a description..." {...field} />
+              </FormControl>
+            </FormItem>
+          )}
+        />
+
+        <div className="flex gap-2">
+          <Button
+            type="submit"
+            disabled={update.isPending || !form.formState.isDirty}
+          >
+            Save
+          </Button>
+          <Button
+            variant="outline"
+            onClick={() =>
+              envOverride
+                .mutateAsync(id)
+                .then(() => utils.environment.bySystemId.invalidate(systemId))
+                .then(() => utils.environment.byId.invalidate(id))
+            }
+          >
+            Override
+          </Button>
+          <div className="flex-grow" />
+          <DeleteEnvironmentDialog environment={environment}>
+            <Button variant="destructive">Delete</Button>
+          </DeleteEnvironmentDialog>
+        </div>
+      </form>
+    </Form>
+  );
+};
+
+const TargetIcon: React.FC<{ version: string }> = ({ version }) => {
+  if (version.includes("kubernetes"))
+    return <SiKubernetes className="h-6 w-6 shrink-0 text-blue-300" />;
+  if (version.includes("vm") || version.includes("compute"))
+    return <IconServer className="h-6 w-6 shrink-0 text-cyan-300" />;
+  if (version.includes("terraform"))
+    return <SiTerraform className="h-6 w-6 shrink-0 text-purple-300" />;
+  return <IconTarget className="h-6 w-6 shrink-0 text-neutral-300" />;
+};
+
+const filterForm = z.object({
+  targetFilter: targetCondition.optional(),
+});
+
+const EditFilterForm: React.FC<{
+  environment: schema.Environment;
+}> = ({ environment }) => {
+  const { workspaceSlug } = useParams<{ workspaceSlug: string }>();
+  const workspaceQ = api.workspace.bySlug.useQuery(workspaceSlug);
+  const workspace = workspaceQ.data;
+
+  const update = api.environment.update.useMutation();
+  const form = useForm({
+    schema: filterForm,
+    defaultValues: { targetFilter: environment.targetFilter ?? undefined },
+  });
+
+  const { targetFilter } = form.watch();
+
+  const targets = api.target.byWorkspaceId.list.useQuery(
+    {
+      workspaceId: workspace?.id ?? "",
+      filter: targetFilter ?? undefined,
+      limit: 10,
+    },
+    { enabled: workspace != null },
+  );
+
+  const utils = api.useUtils();
+
+  const onSubmit = form.handleSubmit((data) =>
+    update
+      .mutateAsync({
+        id: environment.id,
+        data: {
+          ...data,
+          targetFilter: targetFilter ?? null,
+        },
+      })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.bySystemId.invalidate(environment.systemId))
+      .then(() => utils.environment.byId.invalidate(environment.id)),
+  );
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="m-6 space-y-8">
+        <div className="space-y-2">
+          <FormField
+            control={form.control}
+            name="targetFilter"
+            render={({ field: { onChange } }) => (
+              <FormItem>
+                <FormLabel>Target Filter</FormLabel>
+                <FormControl>
+                  <TargetConditionRender
+                    condition={targetFilter ?? defaultCondition}
+                    onChange={onChange}
+                  />
+                </FormControl>
+                <FormMessage />
+                {form.formState.isDirty && (
+                  <span className="text-xs text-muted-foreground">
+                    Save to apply
+                  </span>
+                )}
+              </FormItem>
+            )}
+          />
+
+          <div className="flex gap-2">
+            <Button
+              type="submit"
+              disabled={update.isPending || !form.formState.isDirty}
+            >
+              Save
+            </Button>
+            {targetFilter != null && (
+              <Button
+                variant="outline"
+                type="button"
+                onClick={() =>
+                  form.setValue("targetFilter", undefined, {
+                    shouldValidate: true,
+                    shouldDirty: true,
+                    shouldTouch: true,
+                  })
+                }
+              >
+                Clear
+              </Button>
+            )}
+          </div>
+        </div>
+
+        {targetFilter != null &&
+          targets.data != null &&
+          targets.data.total > 0 && (
+            <div className="space-y-4">
+              <Label>Targets ({targets.data.total})</Label>
+              <div className="space-y-2">
+                {targets.data.items.map((target) => (
+                  <div className="flex items-center gap-2" key={target.id}>
+                    <TargetIcon version={target.version} />
+                    <div className="flex flex-col">
+                      <span className="overflow-hidden text-nowrap text-sm">
+                        {target.name}
+                      </span>
+                      <span className="text-xs text-muted-foreground">
+                        {target.version}
+                      </span>
+                    </div>
+                  </div>
+                ))}
+              </div>
+
+              <Button variant="outline" size="sm">
+                <Link
+                  href={`/${workspaceSlug}/targets?${new URLSearchParams({
+                    filter: LZString.compressToEncodedURIComponent(
+                      JSON.stringify(form.getValues("targetFilter")),
+                    ),
+                  })}`}
+                  className="flex items-center gap-1"
+                  target="_blank"
+                  rel="noopener noreferrer"
+                >
+                  <IconExternalLink className="h-4 w-4" />
+                  View Targets
+                </Link>
+              </Button>
+            </div>
+          )}
+      </form>
+    </Form>
+  );
+};
+
+const param = "environment_id";
+export const useEnvironmentDrawer = () => {
+  const router = useRouter();
+  const params = useSearchParams();
+  const environmentId = params.get(param);
+
+  const setEnvironmentId = (id: string | null) => {
+    const url = new URL(window.location.href);
+    if (id === null) {
+      url.searchParams.delete(param);
+    } else {
+      url.searchParams.set(param, id);
+    }
+    router.replace(url.toString());
+  };
+
+  const removeEnvironmentId = () => setEnvironmentId(null);
+
+  return { environmentId, setEnvironmentId, removeEnvironmentId };
+};
+
+export const EnvironmentDrawer: React.FC = () => {
+  const { environmentId, removeEnvironmentId } = useEnvironmentDrawer();
+  const isOpen = environmentId != null && environmentId != "";
+  const setIsOpen = removeEnvironmentId;
+  const environmentQ = api.environment.byId.useQuery(environmentId ?? "", {
+    enabled: isOpen,
+  });
+  const environment = environmentQ.data;
+
+  const { workspaceSlug } = useParams<{ workspaceSlug: string }>();
+  const workspaceQ = api.workspace.bySlug.useQuery(workspaceSlug);
+  const workspace = workspaceQ.data;
+
+  const [activeTab, setActiveTab] = useState("overview");
+
+  return (
+    <Drawer open={isOpen} onOpenChange={setIsOpen}>
+      <DrawerContent
+        showBar={false}
+        className="left-auto right-0 top-0 mt-0 h-screen w-[1100px] overflow-auto rounded-none focus-visible:outline-none"
+      >
+        <DrawerTitle className="flex items-center gap-2 border-b p-6">
+          <div className="flex-shrink-0 rounded bg-green-500/20 p-1 text-green-400">
+            <IconPlant className="h-4 w-4" />
+          </div>
+          {environment?.name}
+        </DrawerTitle>
+
+        <div className="flex w-full gap-6 p-6">
+          <div className="space-y-1">
+            <TabButton
+              active={activeTab === "overview"}
+              onClick={() => setActiveTab("overview")}
+              icon={<IconInfoCircle className="h-4 w-4" />}
+              label="Overview"
+            />
+            <TabButton
+              active={activeTab === "filter"}
+              onClick={() => setActiveTab("filter")}
+              icon={<IconFilter className="h-4 w-4" />}
+              label="Filter"
+            />
+          </div>
+
+          {environment != null && workspace != null && (
+            <div className="w-full overflow-auto">
+              {activeTab === "overview" && (
+                <EnvironmentForm environment={environment} />
+              )}
+              {activeTab === "filter" && (
+                <EditFilterForm environment={environment} />
+              )}
+            </div>
+          )}
+        </div>
+      </DrawerContent>
+    </Drawer>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/TabButton.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/TabButton.tsx
new file mode 100644
index 000000000..965dbdc5c
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/TabButton.tsx
@@ -0,0 +1,23 @@
+import { cn } from "@ctrlplane/ui";
+import { Button } from "@ctrlplane/ui/button";
+
+export const TabButton: React.FC<{
+  active: boolean;
+  onClick: () => void;
+  icon: React.ReactNode;
+  label: string;
+}> = ({ active, onClick, icon, label }) => (
+  <Button
+    onClick={onClick}
+    variant="ghost"
+    className={cn(
+      "flex h-7 w-full items-center justify-normal gap-2 p-2 py-0 pr-3",
+      active
+        ? "bg-blue-500/10 text-blue-300 hover:bg-blue-500/10 hover:text-blue-300"
+        : "text-muted-foreground",
+    )}
+  >
+    {icon}
+    {label}
+  </Button>
+);
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Approval.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Approval.tsx
new file mode 100644
index 000000000..512f91676
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Approval.tsx
@@ -0,0 +1,80 @@
+import type * as SCHEMA from "@ctrlplane/db/schema";
+import React from "react";
+import { z } from "zod";
+
+import { Button } from "@ctrlplane/ui/button";
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  useForm,
+} from "@ctrlplane/ui/form";
+import { Switch } from "@ctrlplane/ui/switch";
+
+import { api } from "~/trpc/react";
+
+const schema = z.object({
+  approvalRequirement: z.enum(["automatic", "manual"]),
+});
+
+export const Approval: React.FC<{
+  environmentPolicy: SCHEMA.EnvironmentPolicy;
+}> = ({ environmentPolicy }) => {
+  const form = useForm({ schema, defaultValues: { ...environmentPolicy } });
+
+  const updatePolicy = api.environment.policy.update.useMutation();
+  const utils = api.useUtils();
+
+  const { id, systemId } = environmentPolicy;
+  const onSubmit = form.handleSubmit((data) =>
+    updatePolicy
+      .mutateAsync({ id, data })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.policy.byId.invalidate(id))
+      .then(() => utils.environment.policy.bySystemId.invalidate(systemId)),
+  );
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="space-y-6 p-2">
+        <FormField
+          control={form.control}
+          name="approvalRequirement"
+          render={({ field: { value, onChange } }) => (
+            <FormItem>
+              <div className="space-y-1">
+                <FormLabel>Approval gates</FormLabel>
+                <FormDescription>
+                  If enabled, a release will require approval from an authorized
+                  user before it can be deployed to any environment with this
+                  policy.
+                </FormDescription>
+              </div>
+              <FormControl>
+                <div className="flex items-center gap-2">
+                  <span className="text-xs text-neutral-400">Enabled:</span>{" "}
+                  <Switch
+                    checked={value === "manual"}
+                    onCheckedChange={(checked) =>
+                      onChange(checked ? "manual" : "automatic")
+                    }
+                  />
+                </div>
+              </FormControl>
+            </FormItem>
+          )}
+        />
+
+        <Button
+          type="submit"
+          disabled={form.formState.isSubmitting || !form.formState.isDirty}
+        >
+          Save
+        </Button>
+      </form>
+    </Form>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Concurrency.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Concurrency.tsx
new file mode 100644
index 000000000..15008c1d2
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Concurrency.tsx
@@ -0,0 +1,107 @@
+import type * as SCHEMA from "@ctrlplane/db/schema";
+import React from "react";
+import { z } from "zod";
+
+import { Button } from "@ctrlplane/ui/button";
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  useForm,
+} from "@ctrlplane/ui/form";
+import { Input } from "@ctrlplane/ui/input";
+import { RadioGroup, RadioGroupItem } from "@ctrlplane/ui/radio-group";
+
+import { api } from "~/trpc/react";
+
+const schema = z.object({
+  concurrencyType: z.enum(["all", "some"]),
+  concurrencyLimit: z.number().min(1, "Must be a positive number"),
+});
+
+export const Concurrency: React.FC<{
+  environmentPolicy: SCHEMA.EnvironmentPolicy;
+}> = ({ environmentPolicy }) => {
+  const form = useForm({ schema, defaultValues: { ...environmentPolicy } });
+
+  const updatePolicy = api.environment.policy.update.useMutation();
+  const utils = api.useUtils();
+
+  const { id, systemId } = environmentPolicy;
+  const onSubmit = form.handleSubmit((data) =>
+    updatePolicy
+      .mutateAsync({ id, data })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.policy.byId.invalidate(id))
+      .then(() => utils.environment.policy.bySystemId.invalidate(systemId)),
+  );
+
+  const { concurrencyLimit } = form.watch();
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="space-y-6 p-2">
+        <FormField
+          control={form.control}
+          name="concurrencyType"
+          render={({ field: { value, onChange } }) => (
+            <FormItem>
+              <div className="space-y-4">
+                <div className="flex flex-col gap-1">
+                  <FormLabel>Concurrency</FormLabel>
+                  <FormDescription>
+                    The number of jobs that can run concurrently in an
+                    environment.
+                  </FormDescription>
+                </div>
+                <FormControl>
+                  <RadioGroup value={value} onValueChange={onChange}>
+                    <FormItem className="flex items-center space-x-3 space-y-0">
+                      <FormControl>
+                        <RadioGroupItem value="all" />
+                      </FormControl>
+                      <FormLabel className="flex items-center gap-2 font-normal">
+                        All jobs can run concurrently
+                      </FormLabel>
+                    </FormItem>
+                    <FormItem className="flex items-center space-x-3 space-y-0">
+                      <FormControl>
+                        <RadioGroupItem value="some" className="min-w-4" />
+                      </FormControl>
+                      <FormLabel className="flex flex-wrap items-center gap-2 font-normal">
+                        A maximum of
+                        <Input
+                          disabled={value !== "some"}
+                          type="number"
+                          value={concurrencyLimit}
+                          onChange={(e) =>
+                            form.setValue(
+                              "concurrencyLimit",
+                              e.target.valueAsNumber,
+                            )
+                          }
+                          className="border-b-1 h-6 w-16 text-xs"
+                        />
+                        jobs can run concurrently
+                      </FormLabel>
+                    </FormItem>
+                  </RadioGroup>
+                </FormControl>
+              </div>
+            </FormItem>
+          )}
+        />
+
+        <Button
+          type="submit"
+          disabled={form.formState.isSubmitting || !form.formState.isDirty}
+        >
+          Save
+        </Button>
+      </form>
+    </Form>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/EnvironmentPolicyDrawer.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/EnvironmentPolicyDrawer.tsx
new file mode 100644
index 000000000..0c4512cc9
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/EnvironmentPolicyDrawer.tsx
@@ -0,0 +1,170 @@
+"use client";
+
+import type * as SCHEMA from "@ctrlplane/db/schema";
+import type React from "react";
+import { useState } from "react";
+import { useRouter, useSearchParams } from "next/navigation";
+import {
+  IconCalendar,
+  IconCheck,
+  IconChecklist,
+  IconCircuitDiode,
+  IconClock,
+  IconFilter,
+  IconInfoCircle,
+  IconPlayerPause,
+} from "@tabler/icons-react";
+
+import { Drawer, DrawerContent, DrawerTitle } from "@ctrlplane/ui/drawer";
+
+import { api } from "~/trpc/react";
+import { TabButton } from "../TabButton";
+import { Approval } from "./Approval";
+import { Concurrency } from "./Concurrency";
+import { GradualRollouts } from "./GradualRollouts";
+import { Overview } from "./Overview";
+import { ReleaseFilter } from "./ReleaseFilter";
+import { ReleaseSequencing } from "./ReleaseSequencing";
+import { ReleaseWindows } from "./ReleaseWindows";
+import { SuccessCriteria } from "./SuccessCriteria";
+
+const param = "environment_policy_id";
+export const useEnvironmentPolicyDrawer = () => {
+  const router = useRouter();
+  const params = useSearchParams();
+  const environmentPolicyId = params.get(param);
+
+  const setEnvironmentPolicyId = (id: string | null) => {
+    const url = new URL(window.location.href);
+    if (id === null) {
+      url.searchParams.delete(param);
+    } else {
+      url.searchParams.set(param, id);
+    }
+    router.replace(url.toString());
+  };
+
+  const removeEnvironmentPolicyId = () => setEnvironmentPolicyId(null);
+
+  return {
+    environmentPolicyId,
+    setEnvironmentPolicyId,
+    removeEnvironmentPolicyId,
+  };
+};
+
+const View: React.FC<{
+  activeTab: string;
+  environmentPolicy: SCHEMA.EnvironmentPolicy & {
+    releaseWindows: SCHEMA.EnvironmentPolicyReleaseWindow[];
+  };
+}> = ({ activeTab, environmentPolicy }) => {
+  return {
+    overview: <Overview environmentPolicy={environmentPolicy} />,
+    approval: <Approval environmentPolicy={environmentPolicy} />,
+    concurrency: <Concurrency environmentPolicy={environmentPolicy} />,
+    "gradual-rollout": (
+      <GradualRollouts environmentPolicy={environmentPolicy} />
+    ),
+    "success-criteria": (
+      <SuccessCriteria environmentPolicy={environmentPolicy} />
+    ),
+    "release-sequencing": (
+      <ReleaseSequencing environmentPolicy={environmentPolicy} />
+    ),
+    "release-windows": <ReleaseWindows environmentPolicy={environmentPolicy} />,
+    "release-filter": <ReleaseFilter environmentPolicy={environmentPolicy} />,
+  }[activeTab];
+};
+
+export const EnvironmentPolicyDrawer: React.FC = () => {
+  const { environmentPolicyId, removeEnvironmentPolicyId } =
+    useEnvironmentPolicyDrawer();
+  const isOpen = environmentPolicyId != null && environmentPolicyId != "";
+  const setIsOpen = removeEnvironmentPolicyId;
+  const environmentPolicyQ = api.environment.policy.byId.useQuery(
+    environmentPolicyId ?? "",
+    { enabled: isOpen },
+  );
+  const environmentPolicy = environmentPolicyQ.data;
+
+  const [activeTab, setActiveTab] = useState("overview");
+
+  return (
+    <Drawer open={isOpen} onOpenChange={setIsOpen}>
+      <DrawerContent
+        showBar={false}
+        className="left-auto right-0 top-0 mt-0 h-screen w-[1200px] overflow-auto rounded-none focus-visible:outline-none"
+      >
+        <DrawerTitle className="flex items-center gap-2 border-b p-6">
+          <div className="flex-shrink-0 rounded bg-purple-500/20 p-1 text-purple-400">
+            <IconFilter className="h-4 w-4" />
+          </div>
+          {environmentPolicy?.name ?? "Policy"}
+        </DrawerTitle>
+
+        <div className="flex w-full gap-6 p-6">
+          <div className="space-y-1">
+            <TabButton
+              active={activeTab === "overview"}
+              onClick={() => setActiveTab("overview")}
+              icon={<IconInfoCircle className="h-4 w-4" />}
+              label="Overview"
+            />
+            <TabButton
+              active={activeTab === "approval"}
+              onClick={() => setActiveTab("approval")}
+              icon={<IconCheck className="h-4 w-4" />}
+              label="Approval"
+            />
+            <TabButton
+              active={activeTab === "concurrency"}
+              onClick={() => setActiveTab("concurrency")}
+              icon={<IconCircuitDiode className="h-4 w-4" />}
+              label="Concurrency"
+            />
+            <TabButton
+              active={activeTab === "gradual-rollout"}
+              onClick={() => setActiveTab("gradual-rollout")}
+              icon={<IconClock className="h-4 w-4" />}
+              label="Gradual Rollout"
+            />
+            <TabButton
+              active={activeTab === "success-criteria"}
+              onClick={() => setActiveTab("success-criteria")}
+              icon={<IconChecklist className="h-4 w-4" />}
+              label="Success Criteria"
+            />
+            <TabButton
+              active={activeTab === "release-sequencing"}
+              onClick={() => setActiveTab("release-sequencing")}
+              icon={<IconPlayerPause className="h-4 w-4" />}
+              label="Release Sequencing"
+            />
+            <TabButton
+              active={activeTab === "release-windows"}
+              onClick={() => setActiveTab("release-windows")}
+              icon={<IconCalendar className="h-4 w-4" />}
+              label="Release Windows"
+            />
+            <TabButton
+              active={activeTab === "release-filter"}
+              onClick={() => setActiveTab("release-filter")}
+              icon={<IconFilter className="h-4 w-4" />}
+              label="Release Filter"
+            />
+          </div>
+
+          {environmentPolicy != null && (
+            <div className="w-full overflow-auto">
+              <View
+                activeTab={activeTab}
+                environmentPolicy={environmentPolicy}
+              />
+            </div>
+          )}
+        </div>
+      </DrawerContent>
+    </Drawer>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/GradualRollouts.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/GradualRollouts.tsx
new file mode 100644
index 000000000..df5a8cbdb
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/GradualRollouts.tsx
@@ -0,0 +1,94 @@
+import type * as SCHEMA from "@ctrlplane/db/schema";
+import ms from "ms";
+import prettyMilliseconds from "pretty-ms";
+import { z } from "zod";
+
+import { Button } from "@ctrlplane/ui/button";
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+  useForm,
+} from "@ctrlplane/ui/form";
+import { Input } from "@ctrlplane/ui/input";
+
+import { api } from "~/trpc/react";
+
+const isValidDuration = (str: string) => !isNaN(ms(str));
+
+const schema = z.object({
+  duration: z.string().refine(isValidDuration, {
+    message: "Invalid duration pattern",
+  }),
+});
+
+export const GradualRollouts: React.FC<{
+  environmentPolicy: SCHEMA.EnvironmentPolicy;
+}> = ({ environmentPolicy }) => {
+  const form = useForm({
+    schema,
+    defaultValues: { duration: prettyMilliseconds(environmentPolicy.duration) },
+  });
+
+  const updatePolicy = api.environment.policy.update.useMutation();
+  const utils = api.useUtils();
+
+  const { id, systemId } = environmentPolicy;
+  const onSubmit = form.handleSubmit((data) =>
+    updatePolicy
+      .mutateAsync({ id, data: { duration: ms(data.duration) } })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.policy.byId.invalidate(id))
+      .then(() => utils.environment.policy.bySystemId.invalidate(systemId)),
+  );
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="space-y-6 p-2">
+        <FormField
+          control={form.control}
+          name="duration"
+          render={({ field }) => (
+            <FormItem className="space-y-4">
+              <div className="flex flex-col gap-1">
+                <FormLabel>Gradual Rollout</FormLabel>
+                <FormDescription>
+                  Enabling gradual rollouts will spread deployments out over a
+                  given duration. A default duration of 0ms means that
+                  deployments will be rolled out immediately.
+                </FormDescription>
+              </div>
+              <FormControl>
+                <div className="flex flex-col gap-1">
+                  <div className="flex items-center gap-2">
+                    <span className="text-sm text-muted-foreground">
+                      Spread deployments out over
+                    </span>
+                    <Input
+                      type="string"
+                      {...field}
+                      placeholder="1d"
+                      className="border-b-1 h-6 w-16 text-xs"
+                    />
+                  </div>
+                  <FormMessage />
+                </div>
+              </FormControl>
+            </FormItem>
+          )}
+        />
+
+        <Button
+          type="submit"
+          disabled={form.formState.isSubmitting || !form.formState.isDirty}
+        >
+          Save
+        </Button>
+      </form>
+    </Form>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Overview.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Overview.tsx
new file mode 100644
index 000000000..d6c7ef09d
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/Overview.tsx
@@ -0,0 +1,143 @@
+import type * as SCHEMA from "@ctrlplane/db/schema";
+import React from "react";
+import { z } from "zod";
+
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+} from "@ctrlplane/ui/alert-dialog";
+import { Button, buttonVariants } from "@ctrlplane/ui/button";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  useForm,
+} from "@ctrlplane/ui/form";
+import { Input } from "@ctrlplane/ui/input";
+import { Textarea } from "@ctrlplane/ui/textarea";
+
+import { api } from "~/trpc/react";
+import { useEnvironmentPolicyDrawer } from "./EnvironmentPolicyDrawer";
+
+const DeleteEnvironmentPolicyDialog: React.FC<{
+  environmentPolicy: SCHEMA.EnvironmentPolicy;
+  children: React.ReactNode;
+}> = ({ environmentPolicy, children }) => {
+  const deleteEnvironmentPolicy = api.environment.policy.delete.useMutation();
+  const utils = api.useUtils();
+  const { removeEnvironmentPolicyId } = useEnvironmentPolicyDrawer();
+
+  const onDelete = () =>
+    deleteEnvironmentPolicy
+      .mutateAsync(environmentPolicy.id)
+      .then(removeEnvironmentPolicyId)
+      .then(() =>
+        utils.environment.policy.bySystemId.invalidate(
+          environmentPolicy.systemId,
+        ),
+      );
+
+  return (
+    <AlertDialog>
+      <AlertDialogTrigger asChild>{children}</AlertDialogTrigger>
+      <AlertDialogContent>
+        <AlertDialogHeader>
+          <AlertDialogTitle>Delete Environment Policy</AlertDialogTitle>
+        </AlertDialogHeader>
+        <AlertDialogDescription>
+          Are you sure you want to delete this environment policy? You will have
+          to recreate it from scratch.
+        </AlertDialogDescription>
+        <AlertDialogFooter>
+          <AlertDialogCancel>Cancel</AlertDialogCancel>
+          <AlertDialogAction
+            onClick={onDelete}
+            className={buttonVariants({ variant: "destructive" })}
+          >
+            Delete
+          </AlertDialogAction>
+        </AlertDialogFooter>
+      </AlertDialogContent>
+    </AlertDialog>
+  );
+};
+
+const schema = z.object({ name: z.string(), description: z.string() });
+
+export const Overview: React.FC<{
+  environmentPolicy: SCHEMA.EnvironmentPolicy;
+}> = ({ environmentPolicy }) => {
+  const form = useForm({
+    schema,
+    defaultValues: {
+      name: environmentPolicy.name,
+      description: environmentPolicy.description ?? "",
+    },
+  });
+
+  const updatePolicy = api.environment.policy.update.useMutation();
+  const utils = api.useUtils();
+
+  const { id, systemId } = environmentPolicy;
+  const onSubmit = form.handleSubmit((data) =>
+    updatePolicy
+      .mutateAsync({ id, data })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.policy.byId.invalidate(id))
+      .then(() => utils.environment.policy.bySystemId.invalidate(systemId)),
+  );
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="space-y-6 p-2">
+        <FormField
+          control={form.control}
+          name="name"
+          render={({ field }) => (
+            <FormItem>
+              <FormLabel>Name</FormLabel>
+              <FormControl>
+                <Input {...field} />
+              </FormControl>
+            </FormItem>
+          )}
+        />
+
+        <FormField
+          control={form.control}
+          name="description"
+          render={({ field }) => (
+            <FormItem>
+              <FormLabel>Description</FormLabel>
+              <FormControl>
+                <Textarea placeholder="Add a description..." {...field} />
+              </FormControl>
+            </FormItem>
+          )}
+        />
+
+        <div className="flex gap-2">
+          <Button
+            type="submit"
+            disabled={updatePolicy.isPending || !form.formState.isDirty}
+          >
+            Save
+          </Button>
+          <div className="flex-grow" />
+          <DeleteEnvironmentPolicyDialog environmentPolicy={environmentPolicy}>
+            <Button variant="destructive">Delete</Button>
+          </DeleteEnvironmentPolicyDialog>
+        </div>
+      </form>
+    </Form>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseFilter.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseFilter.tsx
new file mode 100644
index 000000000..780589c28
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseFilter.tsx
@@ -0,0 +1,220 @@
+import type * as SCHEMA from "@ctrlplane/db/schema";
+import type { VersionCheck } from "@ctrlplane/validators/environment-policies";
+import _ from "lodash";
+import { validRange } from "semver";
+import { z } from "zod";
+
+import { Button } from "@ctrlplane/ui/button";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+  useForm,
+} from "@ctrlplane/ui/form";
+import { Input } from "@ctrlplane/ui/input";
+import { RadioGroup, RadioGroupItem } from "@ctrlplane/ui/radio-group";
+import {
+  isFilterCheck,
+  isNoneCheck,
+  isRegexCheck,
+  isSemverCheck,
+} from "@ctrlplane/validators/environment-policies";
+import {
+  defaultCondition,
+  isValidReleaseCondition,
+  releaseCondition,
+} from "@ctrlplane/validators/releases";
+
+import { api } from "~/trpc/react";
+import { ReleaseConditionRender } from "../release-condition/ReleaseConditionRender";
+
+const isValidRegex = (str: string) => {
+  try {
+    new RegExp(str);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const schema = z
+  .object({
+    evaluateWith: z.literal("regex"),
+    evaluate: z.string().refine(isValidRegex, {
+      message: "Invalid regex pattern",
+    }),
+  })
+  .or(
+    z.object({
+      evaluateWith: z.literal("none"),
+      evaluate: z.null(),
+    }),
+  )
+  .or(
+    z.object({
+      evaluateWith: z.literal("semver"),
+      evaluate: z
+        .string()
+        .refine((s) => validRange(s) !== null, "Invalid semver range"),
+    }),
+  )
+  .or(
+    z.object({
+      evaluateWith: z.literal("filter"),
+      evaluate: releaseCondition.refine(isValidReleaseCondition, {
+        message: "Invalid release condition",
+      }),
+    }),
+  );
+
+export const ReleaseFilter: React.FC<{
+  environmentPolicy: SCHEMA.EnvironmentPolicy;
+}> = ({ environmentPolicy }) => {
+  const check: VersionCheck = { ...environmentPolicy };
+  // schema complains about type mismatching unless we add type guards
+  const defaultValues = _.merge(
+    {},
+    environmentPolicy,
+    isFilterCheck(check) && { evaluate: check.evaluate },
+    isNoneCheck(check) && { evaluate: check.evaluate },
+    isSemverCheck(check) && { evaluate: check.evaluate },
+    isRegexCheck(check) && { evaluate: check.evaluate },
+  );
+
+  const form = useForm({ schema, defaultValues });
+  const { evaluateWith, evaluate } = form.watch();
+
+  const policyUpdate = api.environment.policy.update.useMutation();
+  const utils = api.useUtils();
+
+  const { id, systemId } = environmentPolicy;
+  const onSubmit = form.handleSubmit((data) =>
+    policyUpdate
+      .mutateAsync({ id, data })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.policy.byId.invalidate(id))
+      .then(() => utils.environment.policy.bySystemId.invalidate(systemId)),
+  );
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="space-y-6 p-2">
+        <FormField
+          control={form.control}
+          name="evaluateWith"
+          render={({ field: { value, onChange } }) => (
+            <FormItem>
+              <FormLabel>Evaluate With</FormLabel>
+              <RadioGroup onValueChange={onChange} value={value}>
+                <FormItem className="flex items-center space-x-3 space-y-0">
+                  <FormControl>
+                    <RadioGroupItem value="none" />
+                  </FormControl>
+                  <FormLabel className="flex items-center gap-2 font-normal">
+                    None
+                  </FormLabel>
+                </FormItem>
+                <FormItem className="flex items-center space-x-3 space-y-0">
+                  <FormControl>
+                    <RadioGroupItem value="regex" />
+                  </FormControl>
+                  <FormLabel className="flex items-center gap-2 font-normal">
+                    Regex
+                  </FormLabel>
+                </FormItem>
+                <FormItem className="flex items-center space-x-3 space-y-0">
+                  <FormControl>
+                    <RadioGroupItem value="semver" />
+                  </FormControl>
+                  <FormLabel className="flex items-center gap-2 font-normal">
+                    Semver
+                  </FormLabel>
+                </FormItem>
+                <FormItem className="flex items-center space-x-3 space-y-0">
+                  <FormControl>
+                    <RadioGroupItem value="filter" />
+                  </FormControl>
+                  <FormLabel className="flex items-center gap-2 font-normal">
+                    Filter
+                  </FormLabel>
+                </FormItem>
+              </RadioGroup>
+            </FormItem>
+          )}
+        />
+
+        {evaluateWith === "regex" && (
+          <FormField
+            control={form.control}
+            name="evaluate"
+            render={({ field }) => (
+              <FormItem>
+                <FormLabel>Regex</FormLabel>
+                <Input {...field} placeholder="^v[0-9]+.[0-9]+.[0-9]+$" />
+              </FormItem>
+            )}
+          />
+        )}
+
+        {evaluateWith === "semver" && (
+          <FormField
+            control={form.control}
+            name="evaluate"
+            render={({ field }) => (
+              <FormItem>
+                <FormLabel>Semver</FormLabel>
+                <Input {...field} placeholder=">=v1.0.0" />
+              </FormItem>
+            )}
+          />
+        )}
+
+        {evaluateWith === "filter" && (
+          <FormField
+            control={form.control}
+            name="evaluate"
+            render={({ field: { onChange } }) => (
+              <FormItem>
+                <FormLabel>Filter</FormLabel>
+                <FormControl>
+                  <ReleaseConditionRender
+                    condition={evaluate ?? defaultCondition}
+                    onChange={onChange}
+                  />
+                </FormControl>
+                <FormMessage />
+                {form.formState.isDirty && (
+                  <span className="text-xs text-muted-foreground">
+                    Save to apply
+                  </span>
+                )}
+              </FormItem>
+            )}
+          />
+        )}
+
+        <div className="flex gap-2">
+          <Button
+            type="submit"
+            disabled={policyUpdate.isPending || !form.formState.isDirty}
+          >
+            Save
+          </Button>
+
+          {evaluateWith === "filter" && (
+            <Button
+              type="button"
+              variant="secondary"
+              onClick={() => form.setValue("evaluate", defaultCondition)}
+            >
+              Clear
+            </Button>
+          )}
+        </div>
+      </form>
+    </Form>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseSequencing.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseSequencing.tsx
new file mode 100644
index 000000000..b8b5c96a2
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseSequencing.tsx
@@ -0,0 +1,85 @@
+import type * as SCHEMA from "@ctrlplane/db/schema";
+import { z } from "zod";
+
+import { Button } from "@ctrlplane/ui/button";
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  useForm,
+} from "@ctrlplane/ui/form";
+import { RadioGroup, RadioGroupItem } from "@ctrlplane/ui/radio-group";
+
+import { api } from "~/trpc/react";
+
+const schema = z.object({ releaseSequencing: z.enum(["wait", "cancel"]) });
+
+export const ReleaseSequencing: React.FC<{
+  environmentPolicy: SCHEMA.EnvironmentPolicy;
+}> = ({ environmentPolicy }) => {
+  const form = useForm({ schema, defaultValues: { ...environmentPolicy } });
+
+  const updatePolicy = api.environment.policy.update.useMutation();
+  const utils = api.useUtils();
+
+  const { id, systemId } = environmentPolicy;
+  const onSubmit = form.handleSubmit((data) =>
+    updatePolicy
+      .mutateAsync({ id, data })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.policy.byId.invalidate(id))
+      .then(() => utils.environment.policy.bySystemId.invalidate(systemId)),
+  );
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="space-y-6 p-2">
+        <FormField
+          control={form.control}
+          name="releaseSequencing"
+          render={({ field: { value, onChange } }) => (
+            <FormItem className="space-y-4">
+              <div className="flex flex-col gap-1">
+                <FormLabel>Release Sequencing</FormLabel>
+                <FormDescription>
+                  Specify whether pending releases should be cancelled or
+                  awaited when a new release is triggered.
+                </FormDescription>
+              </div>
+              <FormControl>
+                <RadioGroup value={value} onValueChange={onChange}>
+                  <FormItem className="flex items-center space-x-3 space-y-0">
+                    <FormControl>
+                      <RadioGroupItem value="wait" />
+                    </FormControl>
+                    <FormLabel className="flex items-center gap-2 font-normal">
+                      Pause deployment until active releases are completed
+                    </FormLabel>
+                  </FormItem>
+                  <FormItem className="flex items-center space-x-3 space-y-0">
+                    <FormControl>
+                      <RadioGroupItem value="cancel" />
+                    </FormControl>
+                    <FormLabel className="flex items-center gap-2 font-normal">
+                      Cancel pending releases
+                    </FormLabel>
+                  </FormItem>
+                </RadioGroup>
+              </FormControl>
+            </FormItem>
+          )}
+        />
+
+        <Button
+          type="submit"
+          disabled={form.formState.isSubmitting || !form.formState.isDirty}
+        >
+          Save
+        </Button>
+      </form>
+    </Form>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseWindows.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseWindows.tsx
new file mode 100644
index 000000000..a4c71bb78
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/ReleaseWindows.tsx
@@ -0,0 +1,203 @@
+import type * as schema from "@ctrlplane/db/schema";
+import React from "react";
+import { ZonedDateTime } from "@internationalized/date";
+import { IconX } from "@tabler/icons-react";
+import _ from "lodash";
+import ms from "ms";
+import { z } from "zod";
+
+import { Button } from "@ctrlplane/ui/button";
+import { DateTimePicker } from "@ctrlplane/ui/date-time-picker/date-time-picker";
+import { Form, FormField, useFieldArray, useForm } from "@ctrlplane/ui/form";
+import { Label } from "@ctrlplane/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@ctrlplane/ui/select";
+
+import { api } from "~/trpc/react";
+
+const releaseWindowsForm = z.object({
+  releaseWindows: z.array(
+    z.object({
+      policyId: z.string().uuid(),
+      recurrence: z.enum(["hourly", "daily", "weekly", "monthly"]),
+      startTime: z.date(),
+      endTime: z.date(),
+    }),
+  ),
+});
+
+const toZonedDateTime = (date: Date): ZonedDateTime => {
+  const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const offset = -date.getTimezoneOffset() * ms("1m");
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+  const hour = date.getHours();
+  const minute = date.getMinutes();
+  const second = date.getSeconds();
+  const millisecond = date.getMilliseconds();
+
+  return new ZonedDateTime(
+    year,
+    month,
+    day,
+    timeZone,
+    offset,
+    hour,
+    minute,
+    second,
+    millisecond,
+  );
+};
+
+export const ReleaseWindows: React.FC<{
+  environmentPolicy: schema.EnvironmentPolicy & {
+    releaseWindows: schema.EnvironmentPolicyReleaseWindow[];
+  };
+}> = ({ environmentPolicy }) => {
+  const form = useForm({
+    schema: releaseWindowsForm,
+    defaultValues: {
+      releaseWindows: environmentPolicy.releaseWindows,
+    },
+  });
+
+  const { fields, append, remove } = useFieldArray({
+    control: form.control,
+    name: "releaseWindows",
+  });
+
+  const setPolicyWindows = api.environment.policy.setWindows.useMutation();
+  const utils = api.useUtils();
+
+  const { id: policyId, systemId } = environmentPolicy;
+  const onSubmit = form.handleSubmit((data) =>
+    setPolicyWindows
+      .mutateAsync({ policyId, releaseWindows: data.releaseWindows })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.policy.byId.invalidate(policyId))
+      .then(() => utils.environment.policy.bySystemId.invalidate(systemId)),
+  );
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="flex flex-col gap-4">
+        <div className="flex flex-col gap-1">
+          <Label>Release Windows</Label>
+          <span className="text-xs text-muted-foreground">
+            Release windows allow you to control when deployments can be
+            released into an environment.
+          </span>
+        </div>
+
+        {fields.map((field, index) => {
+          return (
+            <FormField
+              control={form.control}
+              key={field.id}
+              name={`releaseWindows.${index}`}
+              render={({ field: { value, onChange } }) => {
+                return (
+                  <div
+                    key={index}
+                    className="flex w-fit items-center gap-2 rounded-md border p-1 text-sm"
+                  >
+                    <DateTimePicker
+                      value={toZonedDateTime(value.startTime)}
+                      aria-label="Start Time"
+                      onChange={(t) => {
+                        onChange({
+                          ...value,
+                          startTime: t.toDate(
+                            Intl.DateTimeFormat().resolvedOptions().timeZone,
+                          ),
+                        });
+                      }}
+                    />{" "}
+                    <span className="text-muted-foreground">to</span>{" "}
+                    <DateTimePicker
+                      value={toZonedDateTime(value.endTime)}
+                      onChange={(t) => {
+                        onChange({
+                          ...value,
+                          endTime: t.toDate(
+                            Intl.DateTimeFormat().resolvedOptions().timeZone,
+                          ),
+                        });
+                      }}
+                      aria-label="End Time"
+                    />
+                    <span className="text-muted-foreground">recurring</span>
+                    <div className="w-32">
+                      <Select
+                        value={value.recurrence}
+                        onValueChange={(v) => {
+                          onChange({
+                            ...value,
+                            recurrence: v,
+                          });
+                        }}
+                      >
+                        <SelectTrigger className="h-8">
+                          <SelectValue>
+                            {_.capitalize(value.recurrence)}
+                          </SelectValue>
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectGroup>
+                            <SelectItem value="hourly">hourly</SelectItem>
+                            <SelectItem value="daily">daily</SelectItem>
+                            <SelectItem value="weekly">weekly</SelectItem>
+                            <SelectItem value="monthly">monthly</SelectItem>
+                          </SelectGroup>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                    <Button
+                      variant="ghost"
+                      size="icon"
+                      onClick={() => remove(index)}
+                      className="h-6 w-6"
+                    >
+                      <IconX className="h-4 w-4" />
+                    </Button>
+                  </div>
+                );
+              }}
+            />
+          );
+        })}
+
+        <div className="flex gap-2">
+          <Button
+            type="button"
+            variant="outline"
+            className="w-fit"
+            onClick={() =>
+              append({
+                policyId: environmentPolicy.id,
+                recurrence: "weekly",
+                startTime: new Date(),
+                endTime: new Date(),
+              })
+            }
+          >
+            Add Release Window
+          </Button>
+          <Button
+            type="submit"
+            disabled={setPolicyWindows.isPending || !form.formState.isDirty}
+          >
+            Save
+          </Button>
+        </div>
+      </form>
+    </Form>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/SuccessCriteria.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/SuccessCriteria.tsx
new file mode 100644
index 000000000..7207c8353
--- /dev/null
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/environment-policy-drawer/SuccessCriteria.tsx
@@ -0,0 +1,121 @@
+import type * as schema from "@ctrlplane/db/schema";
+import { z } from "zod";
+
+import { Button } from "@ctrlplane/ui/button";
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  useForm,
+} from "@ctrlplane/ui/form";
+import { Input } from "@ctrlplane/ui/input";
+import { RadioGroup, RadioGroupItem } from "@ctrlplane/ui/radio-group";
+
+import { api } from "~/trpc/react";
+
+const successCriteriaForm = z.object({
+  successType: z.enum(["all", "some", "optional"]),
+  successMinimum: z.number().min(0, "Must be a positive number"),
+});
+
+export const SuccessCriteria: React.FC<{
+  environmentPolicy: schema.EnvironmentPolicy;
+}> = ({ environmentPolicy }) => {
+  const form = useForm({
+    schema: successCriteriaForm,
+    defaultValues: {
+      successType: environmentPolicy.successType,
+      successMinimum: environmentPolicy.successMinimum,
+    },
+  });
+
+  const updatePolicy = api.environment.policy.update.useMutation();
+  const utils = api.useUtils();
+
+  const { id, systemId } = environmentPolicy;
+  const onSubmit = form.handleSubmit((data) =>
+    updatePolicy
+      .mutateAsync({ id, data })
+      .then(() => form.reset(data))
+      .then(() => utils.environment.policy.byId.invalidate(id))
+      .then(() => utils.environment.policy.bySystemId.invalidate(systemId)),
+  );
+
+  const { successMinimum } = form.watch();
+
+  return (
+    <Form {...form}>
+      <form onSubmit={onSubmit} className="space-y-6 p-2">
+        <FormField
+          control={form.control}
+          name="successType"
+          render={({ field: { value, onChange } }) => (
+            <FormItem className="space-y-6">
+              <div className="flex flex-col gap-1">
+                <FormLabel>Previous Deploy Status</FormLabel>
+                <FormDescription>
+                  Specify a minimum number of targets in dependent environments
+                  to successfully be deployed to before triggering a release.
+                  For example, specifying that all targets in QA must be
+                  deployed to before releasing to PROD.
+                </FormDescription>
+              </div>
+              <FormControl>
+                <RadioGroup value={value} onValueChange={onChange}>
+                  <FormItem className="flex items-center space-x-3 space-y-0">
+                    <FormControl>
+                      <RadioGroupItem value="all" />
+                    </FormControl>
+                    <FormLabel className="flex items-center gap-2 font-normal">
+                      All targets in dependent environments must complete
+                      successfully
+                    </FormLabel>
+                  </FormItem>
+                  <FormItem className="flex items-center space-x-3 space-y-0">
+                    <FormControl>
+                      <RadioGroupItem value="some" />
+                    </FormControl>
+                    <FormLabel className="flex items-center gap-2 font-normal">
+                      A minimum of{" "}
+                      <Input
+                        disabled={value !== "some"}
+                        type="number"
+                        value={successMinimum}
+                        onChange={(e) =>
+                          form.setValue(
+                            "successMinimum",
+                            e.target.valueAsNumber,
+                          )
+                        }
+                        className="border-b-1 h-6 w-16 text-xs"
+                      />
+                      targets must be successfully deployed to
+                    </FormLabel>
+                  </FormItem>
+                  <FormItem className="flex items-center space-x-3 space-y-0">
+                    <FormControl>
+                      <RadioGroupItem value="optional" />
+                    </FormControl>
+                    <FormLabel className="flex items-center gap-2 font-normal">
+                      No validation required
+                    </FormLabel>
+                  </FormItem>
+                </RadioGroup>
+              </FormControl>
+            </FormItem>
+          )}
+        />
+
+        <Button
+          type="submit"
+          disabled={form.formState.isSubmitting || !form.formState.isDirty}
+        >
+          Save
+        </Button>
+      </form>
+    </Form>
+  );
+};
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/release-condition/MetadataConditionRender.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/release-condition/MetadataConditionRender.tsx
index 747025edb..f1c2fd4bb 100644
--- a/apps/webservice/src/app/[workspaceSlug]/_components/release-condition/MetadataConditionRender.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/release-condition/MetadataConditionRender.tsx
@@ -22,8 +22,14 @@ import { useMatchSorter } from "~/utils/useMatchSorter";
 export const MetadataConditionRender: React.FC<
   ReleaseConditionRenderProps<MetadataCondition>
 > = ({ condition, onChange, className }) => {
-  const { workspaceSlug } = useParams<{ workspaceSlug: string }>();
-  const workspace = api.workspace.bySlug.useQuery(workspaceSlug);
+  const { workspaceSlug, systemSlug } = useParams();
+  const wSlug = workspaceSlug! as string;
+  const sSlug = systemSlug as string | undefined;
+
+  const metadataKeys = api.release.metadataKeys.useQuery({
+    workspaceSlug: wSlug,
+    systemSlug: sSlug,
+  });
 
   const setKey = (key: string) => onChange({ ...condition, key });
 
@@ -43,10 +49,6 @@ export const MetadataConditionRender: React.FC<
       : onChange({ ...condition, operator, value: condition.value ?? "" });
 
   const [open, setOpen] = useState(false);
-  const metadataKeys = api.target.metadataKeys.useQuery(
-    workspace.data?.id ?? "",
-    { enabled: workspace.isSuccess && workspace.data != null },
-  );
   const filteredMetadataKeys = useMatchSorter(
     metadataKeys.data ?? [],
     condition.key,
@@ -74,14 +76,14 @@ export const MetadataConditionRender: React.FC<
                 <Button
                   variant="ghost"
                   size="sm"
-                  key={k}
+                  key={k.key}
                   className="w-full rounded-none text-left"
                   onClick={() => {
-                    setKey(k);
+                    setKey(k.key);
                     setOpen(false);
                   }}
                 >
-                  <div className="w-full">{k}</div>
+                  <div className="w-full">{k.key}</div>
                 </Button>
               ))}
             </PopoverContent>
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/release-condition/ReleaseConditionBadge.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/release-condition/ReleaseConditionBadge.tsx
index 8f571d3b3..0e04ecda2 100644
--- a/apps/webservice/src/app/[workspaceSlug]/_components/release-condition/ReleaseConditionBadge.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/release-condition/ReleaseConditionBadge.tsx
@@ -216,7 +216,7 @@ export const ReleaseConditionBadge: React.FC<{
         <StringifiedReleaseCondition condition={condition} truncate />
       </div>
     </HoverCardTrigger>
-    <HoverCardContent align="start" className={cn("w-full")}>
+    <HoverCardContent align="start" className="w-full">
       <div className="cursor-pointer rounded-lg bg-neutral-950 text-xs text-muted-foreground">
         <StringifiedReleaseCondition condition={condition} tabbed={tabbed} />
       </div>
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/release-drawer/ReleaseDrawer.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/release-drawer/ReleaseDrawer.tsx
index e4b25e02f..b530bc054 100644
--- a/apps/webservice/src/app/[workspaceSlug]/_components/release-drawer/ReleaseDrawer.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/release-drawer/ReleaseDrawer.tsx
@@ -9,35 +9,14 @@ import {
   IconProgress,
 } from "@tabler/icons-react";
 
-import { cn } from "@ctrlplane/ui";
-import { Button, buttonVariants } from "@ctrlplane/ui/button";
+import { buttonVariants } from "@ctrlplane/ui/button";
 import { Drawer, DrawerContent, DrawerTitle } from "@ctrlplane/ui/drawer";
 import { ReservedMetadataKey } from "@ctrlplane/validators/releases";
 
 import { api } from "~/trpc/react";
+import { TabButton } from "../TabButton";
 import { OverviewContent } from "./OverviewContent";
 
-const TabButton: React.FC<{
-  active: boolean;
-  onClick: () => void;
-  icon: React.ReactNode;
-  label: string;
-}> = ({ active, onClick, icon, label }) => (
-  <Button
-    onClick={onClick}
-    variant="ghost"
-    className={cn(
-      "flex h-7 w-full items-center justify-normal gap-2 p-2 py-0 pr-3",
-      active
-        ? "bg-blue-500/10 text-blue-300 hover:bg-blue-500/10 hover:text-blue-300"
-        : "text-muted-foreground",
-    )}
-  >
-    {icon}
-    {label}
-  </Button>
-);
-
 const param = "release_id";
 export const useReleaseDrawer = () => {
   const router = useRouter();
diff --git a/apps/webservice/src/app/[workspaceSlug]/_components/target-drawer/TargetDrawer.tsx b/apps/webservice/src/app/[workspaceSlug]/_components/target-drawer/TargetDrawer.tsx
index f5bf570e4..5a023e6a3 100644
--- a/apps/webservice/src/app/[workspaceSlug]/_components/target-drawer/TargetDrawer.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/_components/target-drawer/TargetDrawer.tsx
@@ -14,40 +14,19 @@ import {
   IconVariable,
 } from "@tabler/icons-react";
 
-import { cn } from "@ctrlplane/ui";
 import { Button, buttonVariants } from "@ctrlplane/ui/button";
 import { Drawer, DrawerContent, DrawerTitle } from "@ctrlplane/ui/drawer";
 import { ReservedMetadataKey } from "@ctrlplane/validators/targets";
 
 import { api } from "~/trpc/react";
 import { EditTargetDialog } from "../EditTarget";
+import { TabButton } from "../TabButton";
 import { DeploymentsContent } from "./DeploymentContent";
 import { JobsContent } from "./JobsContent";
 import { OverviewContent } from "./OverviewContent";
 import { RelationshipsContent } from "./relationships/RelationshipContent";
 import { VariableContent } from "./VariablesContent";
 
-const TabButton: React.FC<{
-  active: boolean;
-  onClick: () => void;
-  icon: React.ReactNode;
-  label: string;
-}> = ({ active, onClick, icon, label }) => (
-  <Button
-    onClick={onClick}
-    variant="ghost"
-    className={cn(
-      "flex h-7 w-full items-center justify-normal gap-2 p-2 py-0 pr-3",
-      active
-        ? "bg-blue-500/10 text-blue-300 hover:bg-blue-500/10 hover:text-blue-300"
-        : "text-muted-foreground",
-    )}
-  >
-    {icon}
-    {label}
-  </Button>
-);
-
 const param = "target_id";
 export const useTargetDrawer = () => {
   const router = useRouter();
diff --git a/apps/webservice/src/app/[workspaceSlug]/layout.tsx b/apps/webservice/src/app/[workspaceSlug]/layout.tsx
index f6f216d55..8d7982711 100644
--- a/apps/webservice/src/app/[workspaceSlug]/layout.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/layout.tsx
@@ -3,6 +3,8 @@ import { notFound, redirect } from "next/navigation";
 import { auth } from "@ctrlplane/auth";
 
 import { api } from "~/trpc/server";
+import { EnvironmentPolicyDrawer } from "./_components/environment-policy-drawer/EnvironmentPolicyDrawer";
+import { EnvironmentDrawer } from "./_components/EnvironmentDrawer";
 import { ReleaseDrawer } from "./_components/release-drawer/ReleaseDrawer";
 import { TargetDrawer } from "./_components/target-drawer/TargetDrawer";
 import { SidebarPanels } from "./SidebarPanels";
@@ -33,6 +35,8 @@ export default async function WorkspaceLayout({
       </div>
       <TargetDrawer />
       <ReleaseDrawer />
+      <EnvironmentDrawer />
+      <EnvironmentPolicyDrawer />
     </>
   );
 }
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/JobAgentSection.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/JobAgentSection.tsx
index cd90ee2ab..b66c32ce7 100644
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/JobAgentSection.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/JobAgentSection.tsx
@@ -18,32 +18,25 @@ import { api } from "~/trpc/react";
 const JobAgentForm: React.FC<{
   jobAgent?: schema.JobAgent;
   jobAgents: schema.JobAgent[];
-  config: Record<string, any>;
-  deployment: schema.Deployment;
+  jobAgentConfig: Record<string, any>;
   workspace: { id: string; slug: string };
-}> = ({ deployment, jobAgents, workspace, jobAgent, config }) => {
+  deploymentId: string;
+}> = ({ jobAgents, workspace, jobAgent, jobAgentConfig, deploymentId }) => {
   const form = useForm({
     schema: z.object({
       jobAgentId: z.string().uuid(),
-      config: z.record(z.any()),
+      jobAgentConfig: z.record(z.any()),
     }),
-    defaultValues: { jobAgentId: jobAgent?.id ?? "", config },
+    defaultValues: { jobAgentId: jobAgent?.id ?? "", jobAgentConfig },
   });
 
   const update = api.deployment.update.useMutation();
   const router = useRouter();
-  const onFormSubmit = form.handleSubmit(async (data) => {
-    await update.mutateAsync({
-      id: deployment.id,
-      data: {
-        jobAgentId: data.jobAgentId,
-        jobAgentConfig: data.config,
-      },
-    });
-    router.refresh();
-  });
+  const onFormSubmit = form.handleSubmit((data) =>
+    update.mutateAsync({ id: deploymentId, data }).then(() => router.refresh()),
+  );
 
-  const { jobAgentId, config: formConfig } = form.watch();
+  const { jobAgentId, jobAgentConfig: formConfig } = form.watch();
   const selectedJobAgent = jobAgents.find((j) => j.id === jobAgentId);
 
   return (
@@ -65,7 +58,7 @@ const JobAgentForm: React.FC<{
         <Card className="rounded-md border-neutral-900 p-4">
           <FormField
             control={form.control}
-            name="config"
+            name="jobAgentConfig"
             render={({ field: { value, onChange } }) =>
               selectedJobAgent == null ? (
                 <span className="px-2 text-sm text-muted-foreground">
@@ -85,7 +78,7 @@ const JobAgentForm: React.FC<{
 
         <Button
           type="submit"
-          disabled={update.isPending || _.isEqual(formConfig, config)}
+          disabled={update.isPending || _.isEqual(formConfig, jobAgentConfig)}
         >
           Save
         </Button>
@@ -95,11 +88,11 @@ const JobAgentForm: React.FC<{
 };
 
 export const JobAgentSection: React.FC<{
-  deployment: schema.Deployment;
   jobAgent?: schema.JobAgent;
   jobAgents: schema.JobAgent[];
-  config: Record<string, any>;
+  jobAgentConfig: Record<string, any>;
   workspace: { id: string; slug: string };
+  deploymentId: string;
 }> = (props) => {
   return (
     <div className="container m-8 mx-auto max-w-3xl space-y-2">
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/page.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/page.tsx
index f8f261c30..b11b2961b 100644
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/page.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/page.tsx
@@ -165,11 +165,11 @@ export default async function DeploymentPage({
         <EditDeploymentSection deployment={deployment} />
 
         <JobAgentSection
-          deployment={deployment}
           jobAgents={jobAgents}
           workspace={workspace}
           jobAgent={jobAgent}
-          config={deployment.jobAgentConfig}
+          jobAgentConfig={deployment.jobAgentConfig}
+          deploymentId={deployment.id}
         />
 
         <Variables workspaceId={workspace.id} deployment={deployment} />
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/releases/[versionId]/FlowPolicyNode.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/releases/[versionId]/FlowPolicyNode.tsx
index fefdb05c1..25cb84fc9 100644
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/releases/[versionId]/FlowPolicyNode.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/deployments/[deploymentSlug]/releases/[versionId]/FlowPolicyNode.tsx
@@ -3,9 +3,15 @@ import type {
   EnvironmentPolicyDeployment,
   Release,
 } from "@ctrlplane/db/schema";
+import type {
+  RegexCheck,
+  SemverCheck,
+  VersionCheck,
+} from "@ctrlplane/validators/environment-policies";
+import type { ReleaseCondition } from "@ctrlplane/validators/releases";
 import type { NodeProps } from "reactflow";
 import { useState } from "react";
-import { useRouter } from "next/navigation";
+import { useParams, useRouter } from "next/navigation";
 import { IconCheck, IconLoader2, IconMinus, IconX } from "@tabler/icons-react";
 import { addMilliseconds, isBefore } from "date-fns";
 import prettyMilliseconds from "pretty-ms";
@@ -26,7 +32,16 @@ import {
   AlertDialogTitle,
   AlertDialogTrigger,
 } from "@ctrlplane/ui/alert-dialog";
+import {
+  isRegexCheck,
+  isFilterCheck as isReleaseFilterCheck,
+  isSemverCheck,
+} from "@ctrlplane/validators/environment-policies";
 import { JobStatus } from "@ctrlplane/validators/jobs";
+import {
+  ReleaseFilterType,
+  ReleaseOperator,
+} from "@ctrlplane/validators/releases";
 
 import { api } from "~/trpc/react";
 
@@ -80,7 +95,7 @@ const Cancelled: React.FC = () => (
 
 const Blocked: React.FC = () => (
   <div className="rounded-full bg-red-400 p-0.5 dark:text-black">
-    <IconX strokeWidth={3} className="h-4 w-4" />
+    <IconX strokeWidth={3} className="h-3 w-3" />
   </div>
 );
 
@@ -104,39 +119,83 @@ type PolicyNodeProps = NodeProps<
 >;
 
 const evaluateVersionCheck = (
-  evaluateWith: "regex" | "semver" | "none",
-  evaluate: string,
+  check: RegexCheck | SemverCheck,
   version: string,
 ) =>
-  evaluateWith === "none"
-    ? true
-    : evaluateWith === "regex"
-      ? new RegExp(evaluate).test(version)
-      : satisfies(version, evaluate);
+  check.evaluateWith === "regex"
+    ? new RegExp(check.evaluate).test(version)
+    : satisfies(version, check.evaluate);
 
 const EvaluateCheck: React.FC<{
   version: string;
-  evaluateWith: "regex" | "semver" | "none";
-  evaluate: string;
-}> = ({ version, evaluateWith, evaluate }) => {
-  if (evaluateWith === "none") return;
-
-  const passes = evaluateVersionCheck(evaluateWith, evaluate, version);
-  if (evaluateWith === "regex") {
+  check: RegexCheck | SemverCheck;
+}> = ({ version, check }) => {
+  const passes = evaluateVersionCheck(check, version);
+  if (check.evaluateWith === "semver")
     return (
       <div className="flex items-center gap-2">
-        {passes ? <Passing /> : <Blocked />} Satified <pre>{evaluate}</pre>
+        {passes ? <Passing /> : <Blocked />} Satisfied{" "}
+        <pre>{check.evaluate}</pre>
       </div>
     );
-  }
 
   return (
     <div className="flex items-center gap-2">
-      {passes ? <Passing /> : <Blocked />} Matchs regex
+      {passes ? <Passing /> : <Blocked />} Matches regex
     </div>
   );
 };
 
+const useEvaluateReleaseFilterCheck = (
+  check: VersionCheck,
+  release: Release,
+) => {
+  const { workspaceSlug, systemSlug, deploymentSlug } = useParams<{
+    workspaceSlug: string;
+    systemSlug: string;
+    deploymentSlug: string;
+  }>();
+  const deploymentQ = api.deployment.bySlug.useQuery({
+    workspaceSlug,
+    systemSlug,
+    deploymentSlug,
+  });
+  const deployment = deploymentQ.data;
+  const filter: ReleaseCondition = {
+    type: ReleaseFilterType.Comparison,
+    operator: ReleaseOperator.And,
+    conditions: isReleaseFilterCheck(check)
+      ? [
+          {
+            type: ReleaseFilterType.Version,
+            operator: ReleaseOperator.Equals,
+            value: release.version,
+          },
+          check.evaluate,
+        ]
+      : [],
+  };
+
+  const targetsQ = api.release.list.useQuery(
+    { deploymentId: deployment?.id ?? "", filter },
+    { enabled: deployment?.id != null && isReleaseFilterCheck(check) },
+  );
+
+  return {
+    loading: targetsQ.isLoading,
+    passing: (targetsQ.data?.total ?? 0) > 0,
+  };
+};
+
+const EvaluateFilterCheck: React.FC<{
+  passing: boolean;
+}> = ({ passing }) => (
+  <div className="flex items-center gap-2">
+    {passing ? <Passing /> : <Blocked />}
+    Release version satisfies filter
+  </div>
+);
+
 const MinSucessCheck: React.FC<PolicyNodeProps["data"]> = ({
   successMinimum,
   successType,
@@ -245,16 +304,30 @@ const ApprovalCheck: React.FC<PolicyNodeProps["data"]> = ({ id, release }) => {
 };
 
 export const PolicyNode: React.FC<PolicyNodeProps> = ({ data }) => {
-  const passesVersionStringCheck = evaluateVersionCheck(
-    data.evaluateWith,
-    data.evaluate,
-    data.release.version,
-  );
+  const check: VersionCheck = {
+    evaluateWith: data.evaluateWith,
+    evaluate: data.evaluate,
+  };
+
+  const isFilterCheck = isReleaseFilterCheck(check);
+  const { loading: isFilterCheckLoading, passing: isFilterCheckPassing } =
+    useEvaluateReleaseFilterCheck(check, data.release);
+
+  const isStringCheck = isRegexCheck(check) || isSemverCheck(check);
 
-  const noStringCheck = data.evaluateWith === "none";
   const noMinSuccess = data.successType === "optional";
   const noRollout = data.duration === 0;
   const noApproval = data.approvalRequirement === "automatic";
+
+  if (isFilterCheck && isFilterCheckLoading)
+    return (
+      <div
+        className={cn(
+          "relative w-[250px] space-y-1 rounded-md border px-2 py-1.5 text-sm",
+        )}
+      />
+    );
+
   return (
     <>
       <div
@@ -262,28 +335,23 @@ export const PolicyNode: React.FC<PolicyNodeProps> = ({ data }) => {
           "relative w-[250px] space-y-1 rounded-md border px-2 py-1.5 text-sm",
         )}
       >
-        {passesVersionStringCheck ? (
-          <>
-            {!noStringCheck && (
-              <EvaluateCheck
-                evaluateWith={data.evaluateWith}
-                evaluate={data.evaluate}
-                version={data.release.version}
-              />
-            )}
-            {!noMinSuccess && <MinSucessCheck {...data} />}
-            {!noRollout && <GradualRolloutCheck {...data} />}
-            {!noApproval && <ApprovalCheck {...data} />}
-
-            {noStringCheck && noMinSuccess && noRollout && noApproval && (
-              <div className="text-muted-foreground">No policy checks.</div>
-            )}
-          </>
-        ) : (
-          <div className="text-muted-foreground">
-            Release does not match pattern
-          </div>
+        {isStringCheck && (
+          <EvaluateCheck check={check} version={data.release.version} />
+        )}
+        {isFilterCheck && (
+          <EvaluateFilterCheck passing={isFilterCheckPassing} />
         )}
+        {!noMinSuccess && <MinSucessCheck {...data} />}
+        {!noRollout && <GradualRolloutCheck {...data} />}
+        {!noApproval && <ApprovalCheck {...data} />}
+
+        {!isStringCheck &&
+          !isFilterCheck &&
+          noMinSuccess &&
+          noRollout &&
+          noApproval && (
+            <div className="text-muted-foreground">No policy checks.</div>
+          )}
       </div>
 
       <Handle
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/EnvFlowBuilder.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/EnvFlowBuilder.tsx
index 6fcb5e37b..1628b898d 100644
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/EnvFlowBuilder.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/EnvFlowBuilder.tsx
@@ -22,6 +22,7 @@ import ReactFlow, {
 import colors from "tailwindcss/colors";
 import { isPresent } from "ts-is-present";
 
+import { useEnvironmentDrawer } from "~/app/[workspaceSlug]/_components/EnvironmentDrawer";
 import { ArrowEdge } from "~/app/[workspaceSlug]/_components/reactflow/ArrowEdge";
 import {
   createEdgesFromPolicyDeployment,
@@ -30,6 +31,7 @@ import {
 } from "~/app/[workspaceSlug]/_components/reactflow/edges";
 import { getLayoutedElementsDagre } from "~/app/[workspaceSlug]/_components/reactflow/layout";
 import { api } from "~/trpc/react";
+import { useEnvironmentPolicyDrawer } from "../../../_components/environment-policy-drawer/EnvironmentPolicyDrawer";
 import { useDeleteNodeDialog } from "./DeleteNodeDialog";
 import { useHandleEdgeDelete, useOnEdgeClick } from "./edges";
 import { EnvFlowPanel } from "./EnvFlowPanel";
@@ -261,6 +263,9 @@ export const EnvFlowBuilder: React.FC<{
     setOpen,
   ]);
 
+  const { setEnvironmentId } = useEnvironmentDrawer();
+  const { setEnvironmentPolicyId } = useEnvironmentPolicyDrawer();
+
   return (
     <ReactFlow
       nodes={nodes}
@@ -279,6 +284,11 @@ export const EnvFlowBuilder: React.FC<{
       fitView
       nodesDraggable
       proOptions={{ hideAttribution: true }}
+      onNodeClick={(_, node) => {
+        if (node.type === NodeType.Environment) setEnvironmentId(node.id);
+        if (node.type === NodeType.Policy) setEnvironmentPolicyId(node.id);
+        setSelectedNodeId(node.id);
+      }}
       onEdgeClick={(_, edge) => {
         onEdgeClick(edge);
       }}
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/EnvFlowPanel.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/EnvFlowPanel.tsx
index 567b9fe78..da84f5412 100644
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/EnvFlowPanel.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/EnvFlowPanel.tsx
@@ -35,6 +35,7 @@ import { Input } from "@ctrlplane/ui/input";
 import { Separator } from "@ctrlplane/ui/separator";
 import { Textarea } from "@ctrlplane/ui/textarea";
 
+import { useEnvironmentDrawer } from "~/app/[workspaceSlug]/_components/EnvironmentDrawer";
 import { api } from "~/trpc/react";
 import { DeleteNodeDialog, useDeleteNodeDialog } from "./DeleteNodeDialog";
 import { useHandleEdgeDelete } from "./edges";
@@ -65,6 +66,7 @@ const AddEnvironmentButton: React.FC<{
 
   const { addNodes, addEdges } = useReactFlow();
   const { x, y } = useViewport();
+  const { setEnvironmentId } = useEnvironmentDrawer();
   const onSubmit = form.handleSubmit(async (values) => {
     setOpen(false);
 
@@ -87,7 +89,7 @@ const AddEnvironmentButton: React.FC<{
         color: colors.neutral[700],
       },
     });
-
+    setEnvironmentId(env.id);
     window.requestAnimationFrame(() => setSelectedNodeId(env.id));
     form.reset();
   });
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/Sidebar.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/Sidebar.tsx
deleted file mode 100644
index b3f447c3e..000000000
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/Sidebar.tsx
+++ /dev/null
@@ -1,27 +0,0 @@
-"use client";
-
-import { useReactFlow } from "reactflow";
-
-import { ScrollArea } from "@ctrlplane/ui/scroll-area";
-
-import { NodeType } from "./FlowNodeTypes";
-import { SidebarEnvironmentPanel } from "./SidebarEnvironmentPanel";
-import { SidebarPhasePanel } from "./SidebarPolicyPanel";
-import { SidebarTriggerPanel } from "./SidebarTriggerPanel";
-import { usePanel } from "./SidepanelContext";
-
-export const Sidebar: React.FC<{ systemId: string }> = ({ systemId }) => {
-  const { getNode } = useReactFlow();
-  const { selectedNodeId } = usePanel();
-  const node = getNode(selectedNodeId ?? "") ?? null;
-  return (
-    <ScrollArea className="h-[calc(100vh-53px)]">
-      {node == null && <div className="m-6">Select a node</div>}
-      {node?.type === NodeType.Policy && (
-        <SidebarPhasePanel policy={node.data} systemId={systemId} />
-      )}
-      {node?.type === NodeType.Trigger && <SidebarTriggerPanel />}
-      {node?.type === NodeType.Environment && <SidebarEnvironmentPanel />}
-    </ScrollArea>
-  );
-};
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarEnvironmentPanel.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarEnvironmentPanel.tsx
deleted file mode 100644
index e1318beba..000000000
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarEnvironmentPanel.tsx
+++ /dev/null
@@ -1,256 +0,0 @@
-"use client";
-
-import type { TargetCondition } from "@ctrlplane/validators/targets";
-import { useEffect } from "react";
-import Link from "next/link";
-import { useParams } from "next/navigation";
-import {
-  IconExternalLink,
-  IconInfoCircle,
-  IconPlant,
-} from "@tabler/icons-react";
-import LZString from "lz-string";
-import { useReactFlow } from "reactflow";
-import { z } from "zod";
-
-import { Button, buttonVariants } from "@ctrlplane/ui/button";
-import {
-  Form,
-  FormControl,
-  FormField,
-  FormItem,
-  FormLabel,
-  useForm,
-} from "@ctrlplane/ui/form";
-import { Input } from "@ctrlplane/ui/input";
-import { Label } from "@ctrlplane/ui/label";
-import { Separator } from "@ctrlplane/ui/separator";
-import { Textarea } from "@ctrlplane/ui/textarea";
-import { toast } from "@ctrlplane/ui/toast";
-
-import { TargetConditionBadge } from "~/app/[workspaceSlug]/_components/target-condition/TargetConditionBadge";
-import { TargetConditionDialog } from "~/app/[workspaceSlug]/_components/target-condition/TargetConditionDialog";
-import { api } from "~/trpc/react";
-import { usePanel } from "./SidepanelContext";
-import { TargetFilterUniquenessIndicator } from "./TargetFilterUniquenessIndicator";
-
-const environmentForm = z.object({
-  name: z.string(),
-  description: z.string().default(""),
-  targetFilter: z.any().optional(),
-});
-
-export const SidebarEnvironmentPanel: React.FC = () => {
-  const { getNode, getNodes, setNodes } = useReactFlow();
-  const { selectedNodeId } = usePanel();
-  const node = getNode(selectedNodeId!)!;
-  const { workspaceSlug } = useParams<{ workspaceSlug: string }>();
-  const workspace = api.workspace.bySlug.useQuery(workspaceSlug);
-  const update = api.environment.update.useMutation();
-  const envOverride = api.job.trigger.create.byEnvId.useMutation();
-
-  const form = useForm({
-    schema: environmentForm,
-    defaultValues: {
-      name: node.data.label,
-      description: node.data.description,
-      targetFilter: node.data.targetFilter,
-    },
-  });
-
-  /*
-   * The form only sets default values on the initial mount, not on subsequent re-renders.
-   * Selecting a different environment in the panel doesn't unmount the form.
-   * Therefore, useEffect is used to reset the form with the new node data.
-   */
-  useEffect(() => {
-    form.reset({
-      name: node.data.label,
-      description: node.data.description,
-      targetFilter: node.data.targetFilter,
-    });
-    form.setValue("targetFilter", node.data.targetFilter);
-  }, [node, form]);
-
-  const targets = api.target.byWorkspaceId.list.useQuery(
-    {
-      workspaceId: workspace.data?.id ?? "",
-      filter: node.data.targetFilter,
-    },
-    { enabled: workspace.data != null && node.data.targetFilter != null },
-  );
-
-  const utils = api.useUtils();
-
-  const onSubmit = form.handleSubmit((values) => {
-    setNodes((nodes) => {
-      const node = nodes.find((n) => n.id === selectedNodeId);
-      if (!node) return nodes;
-
-      update
-        .mutateAsync({
-          id: node.id,
-          data: { ...values },
-        })
-        .then(() => {
-          utils.environment.bySystemId.invalidate(node.data.systemId);
-          toast.success(`Environment updated successfully`);
-        })
-        .catch(() => toast.error(`Failed to update environment`));
-      return nodes.map((n) =>
-        n.id === selectedNodeId
-          ? {
-              ...n,
-              data: {
-                ...n.data,
-                ...values,
-                label: values.name,
-              },
-            }
-          : n,
-      );
-    });
-  });
-
-  const onFilterDialogSubmit = (condition: TargetCondition | undefined) => {
-    setNodes((nodes) => {
-      const node = nodes.find((n) => n.id === selectedNodeId);
-      if (!node) return nodes;
-
-      const updatedNodes = nodes.map((n) =>
-        n.id === selectedNodeId
-          ? {
-              ...n,
-              data: {
-                ...n.data,
-                targetFilter: condition ?? null,
-              },
-            }
-          : n,
-      );
-      form.setValue("targetFilter", condition);
-      utils.environment.bySystemId.invalidate(node.data.systemId);
-      if (workspace.data)
-        utils.target.byWorkspaceId.list.invalidate({
-          workspaceId: workspace.data.id,
-          filter: condition,
-        });
-      return updatedNodes;
-    });
-    form.reset({
-      name: node.data.label,
-      description: node.data.description,
-      targetFilter: condition,
-    });
-  };
-
-  const nodes = getNodes();
-
-  return (
-    <Form {...form}>
-      <h2 className="flex items-center gap-4 p-6 text-2xl font-semibold">
-        <div className="flex-shrink-0 rounded bg-green-500/20 p-1 text-green-400">
-          <IconPlant className="h-4 w-4" />
-        </div>
-        <span className="flex-grow">Environment</span>
-        <Button
-          variant="ghost"
-          size="icon"
-          className="flex-shrink-0 text-neutral-500 hover:text-white"
-        >
-          <IconInfoCircle className="h-4 w-4" />
-        </Button>
-      </h2>
-      <Separator />
-      <form onSubmit={onSubmit} className="m-5 space-y-8">
-        <FormField
-          control={form.control}
-          name="name"
-          render={({ field }) => (
-            <FormItem>
-              <FormLabel>Name</FormLabel>
-              <FormControl>
-                <Input placeholder="Staging, Production, QA..." {...field} />
-              </FormControl>
-            </FormItem>
-          )}
-        />
-        <FormField
-          control={form.control}
-          name="description"
-          render={({ field }) => (
-            <FormItem>
-              <FormLabel>Description</FormLabel>
-              <FormControl>
-                <Textarea placeholder="Add a description..." {...field} />
-              </FormControl>
-            </FormItem>
-          )}
-        />
-
-        <div className="flex flex-col gap-2">
-          <Label
-            className="flex items-center gap-2"
-            onClick={(e) => e.preventDefault()}
-          >
-            <span>
-              Target Filter (
-              {node.data.targetFilter != null && targets.data != null
-                ? targets.data.total
-                : "-"}
-              )
-            </span>
-            {node.data.targetFilter != null && (
-              <Link
-                href={`/${workspaceSlug}/targets?${new URLSearchParams({
-                  filter: LZString.compressToEncodedURIComponent(
-                    JSON.stringify(node.data.targetFilter),
-                  ),
-                })}`}
-                className={buttonVariants({ variant: "ghost" })}
-              >
-                <span className="flex items-center">
-                  <IconExternalLink className="mr-1 h-4 w-4" />
-                  View Targets
-                </span>
-              </Link>
-            )}
-          </Label>
-          {workspace.data?.id && (
-            <TargetFilterUniquenessIndicator
-              nodes={nodes}
-              currentNode={node}
-              workspaceId={workspace.data.id}
-              workspaceSlug={workspaceSlug}
-            />
-          )}
-          {node.data.targetFilter != null && (
-            <TargetConditionBadge condition={node.data.targetFilter} tabbed />
-          )}
-          <TargetConditionDialog
-            condition={node.data.targetFilter}
-            onChange={onFilterDialogSubmit}
-          >
-            <Button variant="outline" className="w-fit">
-              Set targets
-            </Button>
-          </TargetConditionDialog>
-        </div>
-
-        <div className="flex gap-2">
-          <Button type="submit" disabled={update.isPending}>
-            Save
-          </Button>
-          <Button
-            variant="outline"
-            onClick={() =>
-              selectedNodeId != null && envOverride.mutate(selectedNodeId)
-            }
-          >
-            Override
-          </Button>
-        </div>
-      </form>
-    </Form>
-  );
-};
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarPolicyPanel.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarPolicyPanel.tsx
deleted file mode 100644
index 8f1909969..000000000
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarPolicyPanel.tsx
+++ /dev/null
@@ -1,591 +0,0 @@
-"use client";
-
-import type {
-  EnvironmentPolicy,
-  EnvironmentPolicyReleaseWindow,
-} from "@ctrlplane/db/schema";
-import { zodResolver } from "@hookform/resolvers/zod";
-import { ZonedDateTime } from "@internationalized/date";
-import {
-  IconBolt,
-  IconFilter,
-  IconInfoCircle,
-  IconRegex,
-  IconUser,
-  IconVersions,
-  IconX,
-} from "@tabler/icons-react";
-import _ from "lodash";
-import ms from "ms";
-import prettyMilliseconds from "pretty-ms";
-import { useFieldArray, useForm } from "react-hook-form";
-import { validRange } from "semver";
-import { z } from "zod";
-
-import { Button } from "@ctrlplane/ui/button";
-import { DateTimePicker } from "@ctrlplane/ui/date-time-picker/date-time-picker";
-import {
-  Form,
-  FormControl,
-  FormField,
-  FormItem,
-  FormLabel,
-} from "@ctrlplane/ui/form";
-import { Input } from "@ctrlplane/ui/input";
-import { Label } from "@ctrlplane/ui/label";
-import { RadioGroup, RadioGroupItem } from "@ctrlplane/ui/radio-group";
-import {
-  Select,
-  SelectContent,
-  SelectGroup,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from "@ctrlplane/ui/select";
-import { Separator } from "@ctrlplane/ui/separator";
-import { Textarea } from "@ctrlplane/ui/textarea";
-
-import { api } from "~/trpc/react";
-
-const isValidRegex = (str: string) => {
-  try {
-    new RegExp(str);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const isValidDuration = (str: string) => {
-  try {
-    ms(str);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const policyForm = z
-  .object({
-    name: z.string(),
-    description: z.string(),
-    approvalRequirement: z.enum(["automatic", "manual"]),
-    successType: z.enum(["all", "some", "optional"]),
-    successMinimum: z.number().min(0, "Must be a positive number"),
-    duration: z.string().refine(isValidDuration, {
-      message: "Invalid duration pattern",
-    }),
-    releaseSequencing: z.enum(["wait", "cancel"]),
-    releaseWindows: z
-      .array(
-        z.object({
-          policyId: z.string().uuid(),
-          recurrence: z.enum(["hourly", "daily", "weekly", "monthly"]),
-          startTime: z.date(),
-          endTime: z.date(),
-        }),
-      )
-      .nullable()
-      .default(null),
-    concurrencyType: z.enum(["all", "some"]),
-    concurrencyLimit: z.number().min(1, "Must be a positive number"),
-  })
-  .and(
-    z
-      .object({
-        evaluateWith: z.literal("regex"),
-        evaluate: z.string().refine(isValidRegex, {
-          message: "Invalid regex pattern",
-        }),
-      })
-      .or(
-        z.object({
-          evaluateWith: z.literal("none"),
-          evaluate: z
-            .string()
-            .max(0, `'none' cannot have a string to be evaluated.`),
-        }),
-      )
-      .or(
-        z.object({
-          evaluateWith: z.literal("semver"),
-          evaluate: z
-            .string()
-            .refine((s) => validRange(s) !== null, "Invalid semver range"),
-        }),
-      ),
-  );
-
-type PhaseFormValues = z.infer<typeof policyForm>;
-
-const toZonedDateTime = (date: Date): ZonedDateTime => {
-  const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  const offset = -date.getTimezoneOffset() * ms("1m");
-  const year = date.getFullYear();
-  const month = date.getMonth() + 1;
-  const day = date.getDate();
-  const hour = date.getHours();
-  const minute = date.getMinutes();
-  const second = date.getSeconds();
-  const millisecond = date.getMilliseconds();
-
-  return new ZonedDateTime(
-    year,
-    month,
-    day,
-    timeZone,
-    offset,
-    hour,
-    minute,
-    second,
-    millisecond,
-  );
-};
-
-export const SidebarPhasePanel: React.FC<{
-  policy: EnvironmentPolicy & {
-    releaseWindows: Array<EnvironmentPolicyReleaseWindow> | null;
-  };
-  systemId: string;
-}> = ({ policy, systemId }) => {
-  const form = useForm<PhaseFormValues>({
-    resolver: zodResolver(policyForm),
-    defaultValues: {
-      ...policy,
-      description: policy.description ?? "",
-      duration: prettyMilliseconds(policy.duration),
-    },
-    mode: "onChange",
-  });
-
-  const { mutateAsync, error, isError } =
-    api.environment.policy.update.useMutation();
-  const setPolicyWindows = api.environment.policy.setWindows.useMutation();
-  const utils = api.useUtils();
-
-  const { fields, append, remove } = useFieldArray({
-    control: form.control,
-    name: "releaseWindows",
-  });
-
-  const { evaluateWith, successMinimum, concurrencyLimit } = form.watch();
-
-  const onSubmit = form.handleSubmit(async (values) => {
-    const isReleaseWindowsChanged = !_.isEqual(
-      values.releaseWindows,
-      policy.releaseWindows,
-    );
-    const isSettingNullToEmptyArray =
-      values.releaseWindows?.length === 0 && policy.releaseWindows == null;
-    if (
-      isReleaseWindowsChanged &&
-      values.releaseWindows != null &&
-      !isSettingNullToEmptyArray
-    )
-      await setPolicyWindows.mutateAsync({
-        policyId: policy.id,
-        releaseWindows: values.releaseWindows,
-      });
-
-    await mutateAsync({
-      id: policy.id,
-      data: {
-        ...values,
-        duration: ms(values.duration),
-      },
-    });
-
-    utils.environment.policy.bySystemId.invalidate(systemId);
-    form.reset(values);
-  });
-
-  return (
-    <Form {...form}>
-      <h2 className="flex items-center gap-4 p-6 text-2xl font-semibold">
-        <div className="flex-shrink-0 rounded bg-neutral-800 p-1 text-neutral-400">
-          <IconFilter className="h-4 w-4" />
-        </div>
-        <span className="flex-grow">Policy</span>
-        <Button
-          variant="ghost"
-          size="icon"
-          className="flex-shrink-0 text-neutral-500 hover:text-white"
-        >
-          <IconInfoCircle className="h-4 w-4" />
-        </Button>
-      </h2>
-      <Separator />
-      <form onSubmit={onSubmit} className="m-6 space-y-8">
-        <FormField
-          control={form.control}
-          name="name"
-          render={({ field }) => (
-            <FormItem>
-              <FormLabel>Name</FormLabel>
-              <FormControl>
-                <Input placeholder="Add a name..." {...field} />
-              </FormControl>
-            </FormItem>
-          )}
-        />
-        <FormField
-          control={form.control}
-          name="description"
-          render={({ field }) => (
-            <FormItem>
-              <FormLabel>Description</FormLabel>
-              <FormControl>
-                <Textarea placeholder="Add a description..." {...field} />
-              </FormControl>
-            </FormItem>
-          )}
-        />
-        <FormField
-          control={form.control}
-          name="approvalRequirement"
-          render={({ field: { value, onChange } }) => (
-            <FormItem>
-              <FormLabel>Approval</FormLabel>
-              <FormControl>
-                <RadioGroup value={value} onValueChange={onChange}>
-                  <FormItem className="flex items-center space-x-3 space-y-0">
-                    <FormControl>
-                      <RadioGroupItem value="automatic" />
-                    </FormControl>
-                    <FormLabel className="flex items-center gap-2 font-normal">
-                      <IconBolt className="h-4 w-4 text-neutral-400" />
-                      Automatic approval
-                    </FormLabel>
-                  </FormItem>
-
-                  <FormItem className="flex items-center space-x-3 space-y-0">
-                    <FormControl>
-                      <RadioGroupItem value="manual" />
-                    </FormControl>
-                    <FormLabel className="flex items-center gap-2 font-normal">
-                      <IconUser className="text-neutral-400" /> Manual approval
-                    </FormLabel>
-                  </FormItem>
-                </RadioGroup>
-              </FormControl>
-            </FormItem>
-          )}
-        />
-        <FormField
-          control={form.control}
-          name="successType"
-          render={({ field: { value, onChange } }) => (
-            <FormItem>
-              <FormLabel>Previous Deploy Status</FormLabel>
-              <FormControl>
-                <RadioGroup value={value} onValueChange={onChange}>
-                  <FormItem className="flex items-center space-x-3 space-y-0">
-                    <FormControl>
-                      <RadioGroupItem value="all" />
-                    </FormControl>
-                    <FormLabel className="flex items-center gap-2 font-normal">
-                      All environments must complete sucessfully
-                    </FormLabel>
-                  </FormItem>
-                  <FormItem className="flex items-center space-x-3 space-y-0">
-                    <FormControl>
-                      <RadioGroupItem value="some" />
-                    </FormControl>
-                    <FormLabel className="flex items-center gap-2 font-normal">
-                      A minimum of{" "}
-                      <Input
-                        disabled={value !== "some"}
-                        type="number"
-                        value={successMinimum}
-                        onChange={(e) =>
-                          form.setValue(
-                            "successMinimum",
-                            e.target.valueAsNumber,
-                          )
-                        }
-                        className="border-b-1 h-6 w-16 text-xs"
-                      />
-                      must complete
-                    </FormLabel>
-                  </FormItem>
-                  <FormItem className="flex items-center space-x-3 space-y-0">
-                    <FormControl>
-                      <RadioGroupItem value="optional" />
-                    </FormControl>
-                    <FormLabel className="flex items-center gap-2 font-normal">
-                      No validation required
-                    </FormLabel>
-                  </FormItem>
-                </RadioGroup>
-              </FormControl>
-            </FormItem>
-          )}
-        />
-        <FormField
-          control={form.control}
-          name="releaseSequencing"
-          render={({ field: { value, onChange } }) => (
-            <FormItem>
-              <FormLabel>Release Sequencing</FormLabel>
-              <FormControl>
-                <RadioGroup value={value} onValueChange={onChange}>
-                  <FormItem className="flex items-center space-x-3 space-y-0">
-                    <FormControl>
-                      <RadioGroupItem value="wait" />
-                    </FormControl>
-                    <FormLabel className="flex items-center gap-2 font-normal">
-                      Pause deployment until active releases are completed
-                    </FormLabel>
-                  </FormItem>
-                  <FormItem className="flex items-center space-x-3 space-y-0">
-                    <FormControl>
-                      <RadioGroupItem value="cancel" />
-                    </FormControl>
-                    <FormLabel className="flex items-center gap-2 font-normal">
-                      Cancel pending releases
-                    </FormLabel>
-                  </FormItem>
-                </RadioGroup>
-              </FormControl>
-            </FormItem>
-          )}
-        />
-        <FormField
-          control={form.control}
-          name="concurrencyType"
-          render={({ field: { value, onChange } }) => (
-            <FormItem>
-              <FormLabel>Concurrency</FormLabel>
-              <FormControl>
-                <RadioGroup value={value} onValueChange={onChange}>
-                  <FormItem className="flex items-center space-x-3">
-                    <FormControl>
-                      <RadioGroupItem value="all" />
-                    </FormControl>
-                    <FormLabel className="flex items-center gap-2 font-normal">
-                      All jobs can run concurrently
-                    </FormLabel>
-                  </FormItem>
-                  <FormItem className="flex items-center space-x-3 space-y-0">
-                    <FormControl>
-                      <RadioGroupItem value="some" className="min-w-4" />
-                    </FormControl>
-                    <FormLabel className="flex flex-wrap items-center gap-2 font-normal">
-                      A maximum of
-                      <Input
-                        disabled={value !== "some"}
-                        type="number"
-                        value={concurrencyLimit}
-                        onChange={(e) =>
-                          form.setValue(
-                            "concurrencyLimit",
-                            e.target.valueAsNumber,
-                          )
-                        }
-                        className="border-b-1 h-6 w-16 text-xs"
-                      />
-                      jobs can run concurrently
-                    </FormLabel>
-                  </FormItem>
-                </RadioGroup>
-              </FormControl>
-            </FormItem>
-          )}
-        />
-        <FormField
-          control={form.control}
-          name="duration"
-          render={({ field: { value, onChange } }) => (
-            <FormItem>
-              <FormLabel className="flex items-center">
-                Gradual Rollout
-              </FormLabel>
-              <FormLabel className="flex items-center gap-2 font-normal">
-                Spread deployments out over{" "}
-                <FormControl>
-                  <Input
-                    type="string"
-                    value={value}
-                    placeholder="1d"
-                    onChange={onChange}
-                    className="border-b-1 h-6 w-16 text-xs"
-                  />
-                </FormControl>
-              </FormLabel>
-            </FormItem>
-          )}
-        />
-        <div className="flex">
-          <FormField
-            control={form.control}
-            name="evaluateWith"
-            render={({ field: { value, onChange } }) => (
-              <FormItem>
-                <FormLabel>Release Validation</FormLabel>
-                <FormControl>
-                  <Select value={value} onValueChange={onChange}>
-                    <SelectTrigger className="w-[180px] rounded-r-none">
-                      <SelectValue />
-                    </SelectTrigger>
-                    <SelectContent>
-                      <SelectGroup>
-                        <SelectItem value="none">None</SelectItem>
-                        <SelectItem value="regex">
-                          <IconRegex className="mb-1 mr-2 inline text-neutral-500" />
-                          Regex
-                        </SelectItem>
-                        <SelectItem value="semver">
-                          <IconVersions className="mb-1 mr-2 inline text-neutral-500" />
-                          Semver
-                        </SelectItem>
-                      </SelectGroup>
-                    </SelectContent>
-                  </Select>
-                </FormControl>
-              </FormItem>
-            )}
-          />
-          <FormField
-            control={form.control}
-            name="evaluate"
-            render={({ field }) => (
-              <FormItem className="flex-grow">
-                <FormLabel className="text-transparent">
-                  Validation String
-                </FormLabel>
-                <FormControl>
-                  <Input
-                    className="rounded-l-none"
-                    {...field}
-                    value={evaluateWith === "none" ? "" : field.value}
-                    disabled={evaluateWith === "none"}
-                    placeholder={
-                      evaluateWith === "none"
-                        ? "No string required."
-                        : evaluateWith === "semver"
-                          ? "1.0.0"
-                          : "^[a-zA-Z0-9]+"
-                    }
-                  />
-                </FormControl>
-              </FormItem>
-            )}
-          />
-        </div>
-
-        <div className="flex flex-col gap-4">
-          <Label>Release Windows</Label>
-
-          {fields.map((field, index) => {
-            return (
-              <FormField
-                control={form.control}
-                key={field.id}
-                name={`releaseWindows.${index}`}
-                render={({ field: { value, onChange } }) => {
-                  return (
-                    <div
-                      key={index}
-                      className="flex items-center justify-between rounded-md border px-4 py-3 text-sm"
-                    >
-                      <div className="flex flex-grow flex-col gap-3">
-                        <div className="flex items-center gap-1">
-                          <DateTimePicker
-                            value={toZonedDateTime(value.startTime)}
-                            aria-label="Start Time"
-                            onChange={(t) => {
-                              onChange({
-                                ...value,
-                                startTime: t.toDate(
-                                  Intl.DateTimeFormat().resolvedOptions()
-                                    .timeZone,
-                                ),
-                              });
-                            }}
-                          />{" "}
-                          <span>to</span>{" "}
-                          <DateTimePicker
-                            value={toZonedDateTime(value.endTime)}
-                            onChange={(t) => {
-                              onChange({
-                                ...value,
-                                endTime: t.toDate(
-                                  Intl.DateTimeFormat().resolvedOptions()
-                                    .timeZone,
-                                ),
-                              });
-                            }}
-                            aria-label="End Time"
-                          />
-                        </div>
-
-                        <div className="w-32">
-                          <Select
-                            value={value.recurrence}
-                            onValueChange={(v) => {
-                              onChange({
-                                ...value,
-                                recurrence: v,
-                              });
-                            }}
-                          >
-                            <SelectTrigger>
-                              <SelectValue>
-                                {_.capitalize(value.recurrence)}
-                              </SelectValue>
-                            </SelectTrigger>
-                            <SelectContent>
-                              <SelectGroup>
-                                <SelectItem value="hourly">hourly</SelectItem>
-                                <SelectItem value="daily">daily</SelectItem>
-                                <SelectItem value="weekly">weekly</SelectItem>
-                                <SelectItem value="monthly">monthly</SelectItem>
-                              </SelectGroup>
-                            </SelectContent>
-                          </Select>
-                        </div>
-                      </div>
-                      <Button
-                        variant="ghost"
-                        size="sm"
-                        onClick={() => remove(index)}
-                        className="h-8 w-8 p-0 text-neutral-500 hover:text-white"
-                      >
-                        <IconX />
-                      </Button>
-                    </div>
-                  );
-                }}
-              />
-            );
-          })}
-
-          <Button
-            type="button"
-            variant="outline"
-            size="sm"
-            className="w-36"
-            onClick={() =>
-              append({
-                policyId: policy.id,
-                recurrence: "weekly",
-                startTime: new Date(),
-                endTime: new Date(),
-              })
-            }
-          >
-            Add Release Window
-          </Button>
-        </div>
-
-        <Button
-          type="submit"
-          disabled={Object.keys(form.formState.dirtyFields).length === 0}
-        >
-          Save
-        </Button>
-        {isError && <div className="text-red-500">{error.message}</div>}
-      </form>
-    </Form>
-  );
-};
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarTriggerPanel.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarTriggerPanel.tsx
deleted file mode 100644
index 46e3c7e10..000000000
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/SidebarTriggerPanel.tsx
+++ /dev/null
@@ -1,24 +0,0 @@
-import { IconBolt } from "@tabler/icons-react";
-
-import { Separator } from "@ctrlplane/ui/separator";
-
-export const SidebarTriggerPanel: React.FC = () => {
-  return (
-    <div>
-      <h2 className="flex items-center gap-4 p-6 text-2xl font-semibold">
-        <div className="flex-shrink-0 rounded bg-blue-500/20 p-1 text-blue-400">
-          <IconBolt className="h-4 w-4" />
-        </div>
-        <span className="flex-grow">Trigger</span>
-      </h2>
-      <Separator />
-      <div className="m-6 space-y-3">
-        <p>
-          This block repersents the starting point of the environment release
-          flow. When a new release is created it starts here.
-        </p>
-        <p>Create policies to add restrictions.</p>
-      </div>
-    </div>
-  );
-};
diff --git a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/page.tsx b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/page.tsx
index 9eee4fefe..9c0de298d 100644
--- a/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/page.tsx
+++ b/apps/webservice/src/app/[workspaceSlug]/systems/[systemSlug]/environments/page.tsx
@@ -1,16 +1,9 @@
 import type { Metadata } from "next";
 
-import {
-  ResizableHandle,
-  ResizablePanel,
-  ResizablePanelGroup,
-} from "@ctrlplane/ui/resizable";
-
 import { ReactFlowProvider } from "~/app/[workspaceSlug]/_components/reactflow/ReactFlowProvider";
 import { api } from "~/trpc/server";
 import { DeleteNodeDialogProvider } from "./DeleteNodeDialog";
 import { EnvFlowBuilder } from "./EnvFlowBuilder";
-import { Sidebar } from "./Sidebar";
 import { PanelProvider } from "./SidepanelContext";
 
 export const metadata: Metadata = { title: "Environments - Systems" };
@@ -30,25 +23,14 @@ export default async function SystemEnvironmentPage({
     <PanelProvider>
       <DeleteNodeDialogProvider>
         <ReactFlowProvider>
-          <ResizablePanelGroup direction="horizontal">
-            <ResizablePanel defaultSize={60}>
-              <div className="h-[calc(100vh-53px)]">
-                <EnvFlowBuilder
-                  systemId={sys.id}
-                  envs={envs}
-                  policies={policies}
-                  policyDeployments={policyDeployments}
-                />
-              </div>
-            </ResizablePanel>
-            <ResizableHandle />
-            <ResizablePanel
-              className="min-w-[350px] max-w-[600px]"
-              defaultSize={30}
-            >
-              <Sidebar systemId={sys.id} />
-            </ResizablePanel>
-          </ResizablePanelGroup>
+          <div className="h-[calc(100vh-53px)]">
+            <EnvFlowBuilder
+              systemId={sys.id}
+              envs={envs}
+              policies={policies}
+              policyDeployments={policyDeployments}
+            />
+          </div>
         </ReactFlowProvider>
       </DeleteNodeDialogProvider>
     </PanelProvider>
diff --git a/packages/api/src/router/environment.ts b/packages/api/src/router/environment.ts
index 4ce5c7bda..e15f15865 100644
--- a/packages/api/src/router/environment.ts
+++ b/packages/api/src/router/environment.ts
@@ -1,4 +1,5 @@
 import type { Tx } from "@ctrlplane/db";
+import type { EnvironmentPolicyReleaseWindow } from "@ctrlplane/db/schema";
 import _ from "lodash";
 import { isPresent } from "ts-is-present";
 import { z } from "zod";
@@ -296,10 +297,42 @@ const policyRouter = createTRPCRouter({
     })
     .input(z.string())
     .query(({ ctx, input }) =>
-      ctx.db.query.environmentPolicy.findMany({
-        where: eq(system.id, input),
-        with: {},
-      }),
+      ctx.db
+        .select({
+          environmentPolicy: environmentPolicy,
+          releaseWindows: sql<EnvironmentPolicyReleaseWindow[]>`
+          COALESCE(
+            array_agg(
+              CASE WHEN ${environmentPolicyReleaseWindow.id} IS NOT NULL
+              THEN json_build_object(
+                'id', ${environmentPolicyReleaseWindow.id},
+                'policyId', ${environmentPolicyReleaseWindow.policyId},
+                'recurrence', ${environmentPolicyReleaseWindow.recurrence},
+                'startTime', ${environmentPolicyReleaseWindow.startTime},
+                'endTime', ${environmentPolicyReleaseWindow.endTime}
+              )
+              ELSE NULL END
+            ) FILTER (WHERE ${environmentPolicyReleaseWindow.id} IS NOT NULL),
+            ARRAY[]::json[]
+          )
+        `.as("releaseWindows"),
+        })
+        .from(environmentPolicy)
+        .leftJoin(
+          environmentPolicyReleaseWindow,
+          eq(environmentPolicyReleaseWindow.policyId, environmentPolicy.id),
+        )
+        .where(eq(environmentPolicy.id, input))
+        .groupBy(environmentPolicy.id)
+        .then(takeFirst)
+        .then((p) => ({
+          ...p.environmentPolicy,
+          releaseWindows: p.releaseWindows.map((r) => ({
+            ...r,
+            startTime: new Date(r.startTime),
+            endTime: new Date(r.endTime),
+          })),
+        })),
     ),
 
   create: protectedProcedure
@@ -473,13 +506,6 @@ export const environmentRouter = createTRPCRouter({
         .where(eq(environment.id, input.id))
         .then(takeFirst);
 
-      await ctx.db
-        .update(environment)
-        .set(input.data)
-        .where(eq(environment.id, input.id))
-        .returning()
-        .then(takeFirst);
-
       const { targetFilter } = input.data;
       const isUpdatingTargetFilter = targetFilter != null;
       if (isUpdatingTargetFilter) {
@@ -529,14 +555,10 @@ export const environmentRouter = createTRPCRouter({
     .mutation(({ ctx, input }) =>
       ctx.db.transaction((db) =>
         db
-          .update(environment)
-          .set({ deletedAt: new Date() })
+          .delete(environment)
           .where(eq(environment.id, input))
-          .then(() =>
-            db
-              .delete(environmentPolicyDeployment)
-              .where(eq(environmentPolicyDeployment.environmentId, input)),
-          ),
+          .returning()
+          .then(takeFirst),
       ),
     ),
 });
diff --git a/packages/api/src/router/release.ts b/packages/api/src/router/release.ts
index ccfd4d9da..7df03aae6 100644
--- a/packages/api/src/router/release.ts
+++ b/packages/api/src/router/release.ts
@@ -1,5 +1,6 @@
 import type { Tx } from "@ctrlplane/db";
 import type { ReleaseJobTrigger } from "@ctrlplane/db/schema";
+import type { VersionCheck } from "@ctrlplane/validators/environment-policies";
 import _ from "lodash";
 import { satisfies } from "semver";
 import { isPresent } from "ts-is-present";
@@ -28,7 +29,9 @@ import {
   releaseJobTrigger,
   releaseMatchesCondition,
   releaseMetadata,
+  system,
   target,
+  workspace,
 } from "@ctrlplane/db/schema";
 import {
   cancelOldReleaseJobTriggersOnJobDispatch,
@@ -41,6 +44,11 @@ import {
   isPassingReleaseStringCheckPolicy,
 } from "@ctrlplane/job-dispatch";
 import { Permission } from "@ctrlplane/validators/auth";
+import {
+  isFilterCheck,
+  isRegexCheck,
+  isSemverCheck,
+} from "@ctrlplane/validators/environment-policies";
 import { releaseCondition } from "@ctrlplane/validators/releases";
 
 import { createTRPCRouter, protectedProcedure } from "../trpc";
@@ -222,6 +230,11 @@ export const releaseRouter = createTRPCRouter({
               ? (_, releaseJobTriggers) => releaseJobTriggers
               : isPassingReleaseSequencingCancelPolicy,
           )
+          .filter(
+            input.isForcedRelease
+              ? (_, releaseJobTriggers) => releaseJobTriggers
+              : isPassingReleaseStringCheckPolicy,
+          )
           .then(input.isForcedRelease ? cancelPreviousJobs : createJobApprovals)
           .insert();
 
@@ -305,6 +318,11 @@ export const releaseRouter = createTRPCRouter({
                     ? (_tx, releaseJobTriggers) => releaseJobTriggers
                     : isPassingReleaseSequencingCancelPolicy,
                 )
+                .filter(
+                  input.isForcedRelease
+                    ? (_, releaseJobTriggers) => releaseJobTriggers
+                    : isPassingReleaseStringCheckPolicy,
+                )
                 .then(input.isForcedRelease ? () => {} : createJobApprovals)
                 .insert();
 
@@ -393,20 +411,52 @@ export const releaseRouter = createTRPCRouter({
           ),
         );
 
-      return policies.reduce(
-        (acc, { release, environment, environment_policy }) => {
-          if (!acc[release.id]) acc[release.id] = [];
+      const blockedEnvironments = await Promise.all(
+        policies.map(
+          async ({ release: rel, environment, environment_policy }) => {
+            const check: VersionCheck = { ...environment_policy };
 
-          const isInvalidSemver =
-            environment_policy.evaluateWith === "semver" &&
-            !satisfies(release.version, environment_policy.evaluate);
-          const isInvalidRegex =
-            environment_policy.evaluateWith === "regex" &&
-            !new RegExp(environment_policy.evaluate).test(release.version);
+            if (isSemverCheck(check) && satisfies(rel.version, check.evaluate))
+              return null;
+            if (
+              isRegexCheck(check) &&
+              new RegExp(check.evaluate).test(rel.version)
+            )
+              return null;
+            if (isFilterCheck(check)) {
+              const { evaluate } = check;
+
+              const r = await db
+                .select()
+                .from(release)
+                .where(
+                  and(
+                    eq(release.id, rel.id),
+                    releaseMatchesCondition(db, evaluate),
+                  ),
+                )
+                .then(takeFirstOrNull);
 
-          if (isInvalidSemver || isInvalidRegex)
-            acc[release.id]!.push(environment.id);
+              return r != null
+                ? null
+                : {
+                    releaseId: rel.id,
+                    environmentId: environment.id,
+                  };
+            }
+
+            return {
+              releaseId: rel.id,
+              environmentId: environment.id,
+            };
+          },
+        ),
+      ).then((r) => r.filter(isPresent));
 
+      return blockedEnvironments.reduce(
+        (acc, { releaseId, environmentId }) => {
+          if (!acc[releaseId]) acc[releaseId] = [];
+          acc[releaseId].push(environmentId);
           return acc;
         },
         {} as Record<string, string[]>,
@@ -415,21 +465,51 @@ export const releaseRouter = createTRPCRouter({
 
   metadataKeys: protectedProcedure
     .meta({
-      authorizationCheck: ({ canUser, input }) =>
-        canUser
+      authorizationCheck: async ({ canUser, input }) => {
+        if (input.systemSlug != null) {
+          const sys = await db
+            .select()
+            .from(system)
+            .where(eq(system.slug, input.systemSlug))
+            .then(takeFirstOrNull);
+          if (sys == null) return false;
+
+          return canUser
+            .perform(Permission.ReleaseGet)
+            .on({ type: "system", id: sys.id });
+        }
+
+        const ws = await db
+          .select()
+          .from(workspace)
+          .where(eq(workspace.slug, input.workspaceSlug))
+          .then(takeFirstOrNull);
+        if (ws == null) return false;
+
+        return canUser
           .perform(Permission.ReleaseGet)
-          .on({ type: "deployment", id: input }),
+          .on({ type: "workspace", id: ws.id });
+      },
     })
-    .input(z.string().uuid())
-    .query(async ({ input }) => {
-      const keys = await db
+    .input(
+      z.object({
+        workspaceSlug: z.string(),
+        systemSlug: z.string().optional(),
+      }),
+    )
+    .query(({ input }) => {
+      const baseQuery = db
         .selectDistinct({ key: releaseMetadata.key })
         .from(release)
         .innerJoin(releaseMetadata, eq(releaseMetadata.releaseId, release.id))
         .innerJoin(deployment, eq(release.deploymentId, deployment.id))
-        .where(eq(deployment.id, input))
-        .then((r) => r.map((row) => row.key));
+        .innerJoin(system, eq(deployment.systemId, system.id));
+
+      if (input.systemSlug != null)
+        return baseQuery.where(eq(system.slug, input.systemSlug));
 
-      return keys;
+      return baseQuery
+        .innerJoin(workspace, eq(system.workspaceId, workspace.id))
+        .where(eq(workspace.slug, input.workspaceSlug));
     }),
 });
diff --git a/packages/db/drizzle/0010_sharp_shriek.sql b/packages/db/drizzle/0010_sharp_shriek.sql
new file mode 100644
index 000000000..b6386832a
--- /dev/null
+++ b/packages/db/drizzle/0010_sharp_shriek.sql
@@ -0,0 +1,8 @@
+DO $$ BEGIN
+ CREATE TYPE "public"."target_relationship_type" AS ENUM('depends_on', 'created_by');
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+ALTER TYPE "evaluation_type" ADD VALUE 'filter';--> statement-breakpoint
+ALTER TABLE "environment_policy" DROP COLUMN IF EXISTS "evaluate";
\ No newline at end of file
diff --git a/packages/db/drizzle/0011_flippant_amazoness.sql b/packages/db/drizzle/0011_flippant_amazoness.sql
new file mode 100644
index 000000000..eb28971e4
--- /dev/null
+++ b/packages/db/drizzle/0011_flippant_amazoness.sql
@@ -0,0 +1 @@
+ALTER TABLE "environment_policy" ADD COLUMN "evaluate" jsonb DEFAULT NULL;
\ No newline at end of file
diff --git a/packages/db/drizzle/meta/0010_snapshot.json b/packages/db/drizzle/meta/0010_snapshot.json
new file mode 100644
index 000000000..acfabef7d
--- /dev/null
+++ b/packages/db/drizzle/meta/0010_snapshot.json
@@ -0,0 +1,3702 @@
+{
+  "id": "b6e7d815-72fa-49af-8572-c80143fd5a84",
+  "prevId": "54a4a3da-abf6-45e0-964f-061e38adfbba",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.account": {
+      "name": "account",
+      "schema": "",
+      "columns": {
+        "userId": {
+          "name": "userId",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "providerAccountId": {
+          "name": "providerAccountId",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "token_type": {
+          "name": "token_type",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "session_state": {
+          "name": "session_state",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "account_userId_user_id_fk": {
+          "name": "account_userId_user_id_fk",
+          "tableFrom": "account",
+          "tableTo": "user",
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "account_provider_providerAccountId_pk": {
+          "name": "account_provider_providerAccountId_pk",
+          "columns": ["provider", "providerAccountId"]
+        }
+      },
+      "uniqueConstraints": {}
+    },
+    "public.session": {
+      "name": "session",
+      "schema": "",
+      "columns": {
+        "sessionToken": {
+          "name": "sessionToken",
+          "type": "varchar(255)",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "userId": {
+          "name": "userId",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires": {
+          "name": "expires",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "session_userId_user_id_fk": {
+          "name": "session_userId_user_id_fk",
+          "tableFrom": "session",
+          "tableTo": "user",
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.user": {
+      "name": "user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "emailVerified": {
+          "name": "emailVerified",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "image": {
+          "name": "image",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_workspace_id": {
+          "name": "active_workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "null"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "user_active_workspace_id_workspace_id_fk": {
+          "name": "user_active_workspace_id_workspace_id_fk",
+          "tableFrom": "user",
+          "tableTo": "workspace",
+          "columnsFrom": ["active_workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.user_api_key": {
+      "name": "user_api_key",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key_preview": {
+          "name": "key_preview",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key_hash": {
+          "name": "key_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key_prefix": {
+          "name": "key_prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "user_api_key_key_prefix_key_hash_index": {
+          "name": "user_api_key_key_prefix_key_hash_index",
+          "columns": [
+            {
+              "expression": "key_prefix",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_api_key_user_id_user_id_fk": {
+          "name": "user_api_key_user_id_user_id_fk",
+          "tableFrom": "user_api_key",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.dashboard": {
+      "name": "dashboard",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "dashboard_workspace_id_workspace_id_fk": {
+          "name": "dashboard_workspace_id_workspace_id_fk",
+          "tableFrom": "dashboard",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.dashboard_widget": {
+      "name": "dashboard_widget",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "dashboard_id": {
+          "name": "dashboard_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "widget": {
+          "name": "widget",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "x": {
+          "name": "x",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "y": {
+          "name": "y",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "w": {
+          "name": "w",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "h": {
+          "name": "h",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "dashboard_widget_dashboard_id_dashboard_id_fk": {
+          "name": "dashboard_widget_dashboard_id_dashboard_id_fk",
+          "tableFrom": "dashboard_widget",
+          "tableTo": "dashboard",
+          "columnsFrom": ["dashboard_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment_variable": {
+      "name": "deployment_variable",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "default_value_id": {
+          "name": "default_value_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "NULL"
+        },
+        "schema": {
+          "name": "schema",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "deployment_variable_deployment_id_key_index": {
+          "name": "deployment_variable_deployment_id_key_index",
+          "columns": [
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_variable_deployment_id_deployment_id_fk": {
+          "name": "deployment_variable_deployment_id_deployment_id_fk",
+          "tableFrom": "deployment_variable",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "deployment_variable_default_value_id_deployment_variable_value_id_fk": {
+          "name": "deployment_variable_default_value_id_deployment_variable_value_id_fk",
+          "tableFrom": "deployment_variable",
+          "tableTo": "deployment_variable_value",
+          "columnsFrom": ["default_value_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment_variable_set": {
+      "name": "deployment_variable_set",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "variable_set_id": {
+          "name": "variable_set_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "deployment_variable_set_deployment_id_variable_set_id_index": {
+          "name": "deployment_variable_set_deployment_id_variable_set_id_index",
+          "columns": [
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "variable_set_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_variable_set_deployment_id_deployment_id_fk": {
+          "name": "deployment_variable_set_deployment_id_deployment_id_fk",
+          "tableFrom": "deployment_variable_set",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "deployment_variable_set_variable_set_id_variable_set_id_fk": {
+          "name": "deployment_variable_set_variable_set_id_variable_set_id_fk",
+          "tableFrom": "deployment_variable_set",
+          "tableTo": "variable_set",
+          "columnsFrom": ["variable_set_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment_variable_value": {
+      "name": "deployment_variable_value",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "variable_id": {
+          "name": "variable_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_filter": {
+          "name": "target_filter",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "NULL"
+        }
+      },
+      "indexes": {
+        "deployment_variable_value_variable_id_value_index": {
+          "name": "deployment_variable_value_variable_id_value_index",
+          "columns": [
+            {
+              "expression": "variable_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_variable_value_variable_id_deployment_variable_id_fk": {
+          "name": "deployment_variable_value_variable_id_deployment_variable_id_fk",
+          "tableFrom": "deployment_variable_value",
+          "tableTo": "deployment_variable",
+          "columnsFrom": ["variable_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "restrict"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment": {
+      "name": "deployment",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_agent_id": {
+          "name": "job_agent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_agent_config": {
+          "name": "job_agent_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        },
+        "github_config_file_id": {
+          "name": "github_config_file_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "deployment_system_id_slug_index": {
+          "name": "deployment_system_id_slug_index",
+          "columns": [
+            {
+              "expression": "system_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_system_id_system_id_fk": {
+          "name": "deployment_system_id_system_id_fk",
+          "tableFrom": "deployment",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "deployment_job_agent_id_job_agent_id_fk": {
+          "name": "deployment_job_agent_id_job_agent_id_fk",
+          "tableFrom": "deployment",
+          "tableTo": "job_agent",
+          "columnsFrom": ["job_agent_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "deployment_github_config_file_id_github_config_file_id_fk": {
+          "name": "deployment_github_config_file_id_github_config_file_id_fk",
+          "tableFrom": "deployment",
+          "tableTo": "github_config_file",
+          "columnsFrom": ["github_config_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment_meta_dependency": {
+      "name": "deployment_meta_dependency",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "depends_on_id": {
+          "name": "depends_on_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "deployment_meta_dependency_depends_on_id_deployment_id_index": {
+          "name": "deployment_meta_dependency_depends_on_id_deployment_id_index",
+          "columns": [
+            {
+              "expression": "depends_on_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_meta_dependency_deployment_id_deployment_id_fk": {
+          "name": "deployment_meta_dependency_deployment_id_deployment_id_fk",
+          "tableFrom": "deployment_meta_dependency",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "deployment_meta_dependency_depends_on_id_deployment_id_fk": {
+          "name": "deployment_meta_dependency_depends_on_id_deployment_id_fk",
+          "tableFrom": "deployment_meta_dependency",
+          "tableTo": "deployment",
+          "columnsFrom": ["depends_on_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment": {
+      "name": "environment",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "''"
+        },
+        "policy_id": {
+          "name": "policy_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_filter": {
+          "name": "target_filter",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "NULL"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "environment_system_id_system_id_fk": {
+          "name": "environment_system_id_system_id_fk",
+          "tableFrom": "environment",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "environment_policy_id_environment_policy_id_fk": {
+          "name": "environment_policy_id_environment_policy_id_fk",
+          "tableFrom": "environment",
+          "tableTo": "environment_policy",
+          "columnsFrom": ["policy_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment_policy": {
+      "name": "environment_policy",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "approval_required": {
+          "name": "approval_required",
+          "type": "environment_policy_approval_requirement",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual'"
+        },
+        "success_status": {
+          "name": "success_status",
+          "type": "environment_policy_deployment_success_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'all'"
+        },
+        "minimum_success": {
+          "name": "minimum_success",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "concurrency_type": {
+          "name": "concurrency_type",
+          "type": "concurrency_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'all'"
+        },
+        "concurrency_limit": {
+          "name": "concurrency_limit",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "duration": {
+          "name": "duration",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "evaluate_with": {
+          "name": "evaluate_with",
+          "type": "evaluation_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'none'"
+        },
+        "release_sequencing": {
+          "name": "release_sequencing",
+          "type": "release_sequencing_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'cancel'"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "environment_policy_system_id_system_id_fk": {
+          "name": "environment_policy_system_id_system_id_fk",
+          "tableFrom": "environment_policy",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment_policy_approval": {
+      "name": "environment_policy_approval",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "policy_id": {
+          "name": "policy_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "release_id": {
+          "name": "release_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "approval_status_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        }
+      },
+      "indexes": {
+        "environment_policy_approval_policy_id_release_id_index": {
+          "name": "environment_policy_approval_policy_id_release_id_index",
+          "columns": [
+            {
+              "expression": "policy_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "release_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "environment_policy_approval_policy_id_environment_policy_id_fk": {
+          "name": "environment_policy_approval_policy_id_environment_policy_id_fk",
+          "tableFrom": "environment_policy_approval",
+          "tableTo": "environment_policy",
+          "columnsFrom": ["policy_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "environment_policy_approval_release_id_release_id_fk": {
+          "name": "environment_policy_approval_release_id_release_id_fk",
+          "tableFrom": "environment_policy_approval",
+          "tableTo": "release",
+          "columnsFrom": ["release_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment_policy_deployment": {
+      "name": "environment_policy_deployment",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "policy_id": {
+          "name": "policy_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "environment_id": {
+          "name": "environment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "environment_policy_deployment_policy_id_environment_id_index": {
+          "name": "environment_policy_deployment_policy_id_environment_id_index",
+          "columns": [
+            {
+              "expression": "policy_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "environment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "environment_policy_deployment_policy_id_environment_policy_id_fk": {
+          "name": "environment_policy_deployment_policy_id_environment_policy_id_fk",
+          "tableFrom": "environment_policy_deployment",
+          "tableTo": "environment_policy",
+          "columnsFrom": ["policy_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "environment_policy_deployment_environment_id_environment_id_fk": {
+          "name": "environment_policy_deployment_environment_id_environment_id_fk",
+          "tableFrom": "environment_policy_deployment",
+          "tableTo": "environment",
+          "columnsFrom": ["environment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment_policy_release_window": {
+      "name": "environment_policy_release_window",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "policy_id": {
+          "name": "policy_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "start_time": {
+          "name": "start_time",
+          "type": "timestamp (0) with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "end_time": {
+          "name": "end_time",
+          "type": "timestamp (0) with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "recurrence": {
+          "name": "recurrence",
+          "type": "recurrence_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "environment_policy_release_window_policy_id_environment_policy_id_fk": {
+          "name": "environment_policy_release_window_policy_id_environment_policy_id_fk",
+          "tableFrom": "environment_policy_release_window",
+          "tableTo": "environment_policy",
+          "columnsFrom": ["policy_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.github_config_file": {
+      "name": "github_config_file",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "repository_name": {
+          "name": "repository_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "unique_organization_repository_path": {
+          "name": "unique_organization_repository_path",
+          "columns": [
+            {
+              "expression": "organization_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "repository_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "path",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "github_config_file_organization_id_github_organization_id_fk": {
+          "name": "github_config_file_organization_id_github_organization_id_fk",
+          "tableFrom": "github_config_file",
+          "tableTo": "github_organization",
+          "columnsFrom": ["organization_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "github_config_file_workspace_id_workspace_id_fk": {
+          "name": "github_config_file_workspace_id_workspace_id_fk",
+          "tableFrom": "github_config_file",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.github_organization": {
+      "name": "github_organization",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "installation_id": {
+          "name": "installation_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "organization_name": {
+          "name": "organization_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_by_user_id": {
+          "name": "added_by_user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'main'"
+        }
+      },
+      "indexes": {
+        "unique_installation_workspace": {
+          "name": "unique_installation_workspace",
+          "columns": [
+            {
+              "expression": "installation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "github_organization_added_by_user_id_user_id_fk": {
+          "name": "github_organization_added_by_user_id_user_id_fk",
+          "tableFrom": "github_organization",
+          "tableTo": "user",
+          "columnsFrom": ["added_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "github_organization_workspace_id_workspace_id_fk": {
+          "name": "github_organization_workspace_id_workspace_id_fk",
+          "tableFrom": "github_organization",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.github_user": {
+      "name": "github_user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "github_user_id": {
+          "name": "github_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "github_username": {
+          "name": "github_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "github_user_user_id_user_id_fk": {
+          "name": "github_user_user_id_user_id_fk",
+          "tableFrom": "github_user",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target": {
+      "name": "target",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "version": {
+          "name": "version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        },
+        "locked_at": {
+          "name": "locked_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "target_identifier_workspace_id_index": {
+          "name": "target_identifier_workspace_id_index",
+          "columns": [
+            {
+              "expression": "identifier",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_provider_id_target_provider_id_fk": {
+          "name": "target_provider_id_target_provider_id_fk",
+          "tableFrom": "target",
+          "tableTo": "target_provider",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "target_workspace_id_workspace_id_fk": {
+          "name": "target_workspace_id_workspace_id_fk",
+          "tableFrom": "target",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_metadata": {
+      "name": "target_metadata",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "target_metadata_key_target_id_index": {
+          "name": "target_metadata_key_target_id_index",
+          "columns": [
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_metadata_target_id_target_id_fk": {
+          "name": "target_metadata_target_id_target_id_fk",
+          "tableFrom": "target_metadata",
+          "tableTo": "target",
+          "columnsFrom": ["target_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_relationship": {
+      "name": "target_relationship",
+      "schema": "",
+      "columns": {
+        "uuid": {
+          "name": "uuid",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "relationship_type": {
+          "name": "relationship_type",
+          "type": "target_relationship_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "target_relationship_target_id_source_id_index": {
+          "name": "target_relationship_target_id_source_id_index",
+          "columns": [
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "source_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_relationship_source_id_target_id_fk": {
+          "name": "target_relationship_source_id_target_id_fk",
+          "tableFrom": "target_relationship",
+          "tableTo": "target",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "target_relationship_target_id_target_id_fk": {
+          "name": "target_relationship_target_id_target_id_fk",
+          "tableFrom": "target_relationship",
+          "tableTo": "target",
+          "columnsFrom": ["target_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_schema": {
+      "name": "target_schema",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "version": {
+          "name": "version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "json_schema": {
+          "name": "json_schema",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "target_schema_version_kind_workspace_id_index": {
+          "name": "target_schema_version_kind_workspace_id_index",
+          "columns": [
+            {
+              "expression": "version",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_schema_workspace_id_workspace_id_fk": {
+          "name": "target_schema_workspace_id_workspace_id_fk",
+          "tableFrom": "target_schema",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_view": {
+      "name": "target_view",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "''"
+        },
+        "filter": {
+          "name": "filter",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "target_view_workspace_id_workspace_id_fk": {
+          "name": "target_view_workspace_id_workspace_id_fk",
+          "tableFrom": "target_view",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_provider": {
+      "name": "target_provider",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "target_provider_workspace_id_name_index": {
+          "name": "target_provider_workspace_id_name_index",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_provider_workspace_id_workspace_id_fk": {
+          "name": "target_provider_workspace_id_workspace_id_fk",
+          "tableFrom": "target_provider",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_provider_google": {
+      "name": "target_provider_google",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "target_provider_id": {
+          "name": "target_provider_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "project_ids": {
+          "name": "project_ids",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "target_provider_google_target_provider_id_target_provider_id_fk": {
+          "name": "target_provider_google_target_provider_id_target_provider_id_fk",
+          "tableFrom": "target_provider_google",
+          "tableTo": "target_provider",
+          "columnsFrom": ["target_provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.release": {
+      "name": "release",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "version": {
+          "name": "version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "release_deployment_id_version_index": {
+          "name": "release_deployment_id_version_index",
+          "columns": [
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "version",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "release_deployment_id_deployment_id_fk": {
+          "name": "release_deployment_id_deployment_id_fk",
+          "tableFrom": "release",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.release_dependency": {
+      "name": "release_dependency",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "release_id": {
+          "name": "release_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_metadata_group_id": {
+          "name": "target_metadata_group_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rule_type": {
+          "name": "rule_type",
+          "type": "release_dependency_rule_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rule": {
+          "name": "rule",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "release_dependency_release_id_deployment_id_target_metadata_group_id_index": {
+          "name": "release_dependency_release_id_deployment_id_target_metadata_group_id_index",
+          "columns": [
+            {
+              "expression": "release_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_metadata_group_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "release_dependency_release_id_release_id_fk": {
+          "name": "release_dependency_release_id_release_id_fk",
+          "tableFrom": "release_dependency",
+          "tableTo": "release",
+          "columnsFrom": ["release_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "release_dependency_deployment_id_deployment_id_fk": {
+          "name": "release_dependency_deployment_id_deployment_id_fk",
+          "tableFrom": "release_dependency",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "release_dependency_target_metadata_group_id_target_metadata_group_id_fk": {
+          "name": "release_dependency_target_metadata_group_id_target_metadata_group_id_fk",
+          "tableFrom": "release_dependency",
+          "tableTo": "target_metadata_group",
+          "columnsFrom": ["target_metadata_group_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.release_job_trigger": {
+      "name": "release_job_trigger",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "release_job_trigger_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "caused_by_id": {
+          "name": "caused_by_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "release_id": {
+          "name": "release_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "environment_id": {
+          "name": "environment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "release_job_trigger_job_id_job_id_fk": {
+          "name": "release_job_trigger_job_id_job_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "job",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "release_job_trigger_caused_by_id_user_id_fk": {
+          "name": "release_job_trigger_caused_by_id_user_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "user",
+          "columnsFrom": ["caused_by_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "release_job_trigger_release_id_release_id_fk": {
+          "name": "release_job_trigger_release_id_release_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "release",
+          "columnsFrom": ["release_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "release_job_trigger_target_id_target_id_fk": {
+          "name": "release_job_trigger_target_id_target_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "target",
+          "columnsFrom": ["target_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "release_job_trigger_environment_id_environment_id_fk": {
+          "name": "release_job_trigger_environment_id_environment_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "environment",
+          "columnsFrom": ["environment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "release_job_trigger_job_id_unique": {
+          "name": "release_job_trigger_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["job_id"]
+        }
+      }
+    },
+    "public.release_metadata": {
+      "name": "release_metadata",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "release_id": {
+          "name": "release_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "release_metadata_key_release_id_index": {
+          "name": "release_metadata_key_release_id_index",
+          "columns": [
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "release_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "release_metadata_release_id_release_id_fk": {
+          "name": "release_metadata_release_id_release_id_fk",
+          "tableFrom": "release_metadata",
+          "tableTo": "release",
+          "columnsFrom": ["release_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.system": {
+      "name": "system",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "system_workspace_id_slug_index": {
+          "name": "system_workspace_id_slug_index",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "system_workspace_id_workspace_id_fk": {
+          "name": "system_workspace_id_workspace_id_fk",
+          "tableFrom": "system",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.runbook": {
+      "name": "runbook",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_agent_id": {
+          "name": "job_agent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_agent_config": {
+          "name": "job_agent_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "runbook_system_id_system_id_fk": {
+          "name": "runbook_system_id_system_id_fk",
+          "tableFrom": "runbook",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "runbook_job_agent_id_job_agent_id_fk": {
+          "name": "runbook_job_agent_id_job_agent_id_fk",
+          "tableFrom": "runbook",
+          "tableTo": "job_agent",
+          "columnsFrom": ["job_agent_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.runbook_job_trigger": {
+      "name": "runbook_job_trigger",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "runbook_id": {
+          "name": "runbook_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "runbook_job_trigger_job_id_job_id_fk": {
+          "name": "runbook_job_trigger_job_id_job_id_fk",
+          "tableFrom": "runbook_job_trigger",
+          "tableTo": "job",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "runbook_job_trigger_runbook_id_runbook_id_fk": {
+          "name": "runbook_job_trigger_runbook_id_runbook_id_fk",
+          "tableFrom": "runbook_job_trigger",
+          "tableTo": "runbook",
+          "columnsFrom": ["runbook_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "runbook_job_trigger_job_id_unique": {
+          "name": "runbook_job_trigger_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["job_id"]
+        }
+      }
+    },
+    "public.team": {
+      "name": "team",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "team_workspace_id_workspace_id_fk": {
+          "name": "team_workspace_id_workspace_id_fk",
+          "tableFrom": "team",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.team_member": {
+      "name": "team_member",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "team_member_team_id_user_id_index": {
+          "name": "team_member_team_id_user_id_index",
+          "columns": [
+            {
+              "expression": "team_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "team_member_team_id_team_id_fk": {
+          "name": "team_member_team_id_team_id_fk",
+          "tableFrom": "team_member",
+          "tableTo": "team",
+          "columnsFrom": ["team_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "team_member_user_id_user_id_fk": {
+          "name": "team_member_user_id_user_id_fk",
+          "tableFrom": "team_member",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.job": {
+      "name": "job",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_agent_id": {
+          "name": "job_agent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_agent_config": {
+          "name": "job_agent_config",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        },
+        "external_id": {
+          "name": "external_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "job_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "message": {
+          "name": "message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reason": {
+          "name": "reason",
+          "type": "job_reason",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'policy_passing'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "job_job_agent_id_job_agent_id_fk": {
+          "name": "job_job_agent_id_job_agent_id_fk",
+          "tableFrom": "job",
+          "tableTo": "job_agent",
+          "columnsFrom": ["job_agent_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.job_metadata": {
+      "name": "job_metadata",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "job_metadata_key_job_id_index": {
+          "name": "job_metadata_key_job_id_index",
+          "columns": [
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "job_metadata_job_id_job_id_fk": {
+          "name": "job_metadata_job_id_job_id_fk",
+          "tableFrom": "job_metadata",
+          "tableTo": "job",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.job_variable": {
+      "name": "job_variable",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "job_variable_job_id_key_index": {
+          "name": "job_variable_job_id_key_index",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "job_variable_job_id_job_id_fk": {
+          "name": "job_variable_job_id_job_id_fk",
+          "tableFrom": "job_variable",
+          "tableTo": "job",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.workspace": {
+      "name": "workspace",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "google_service_account_email": {
+          "name": "google_service_account_email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "workspace_slug_unique": {
+          "name": "workspace_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": ["slug"]
+        }
+      }
+    },
+    "public.workspace_email_domain_matching": {
+      "name": "workspace_email_domain_matching",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "domain": {
+          "name": "domain",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "verified": {
+          "name": "verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "verification_code": {
+          "name": "verification_code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "verification_email": {
+          "name": "verification_email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "workspace_email_domain_matching_workspace_id_domain_index": {
+          "name": "workspace_email_domain_matching_workspace_id_domain_index",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "domain",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "workspace_email_domain_matching_workspace_id_workspace_id_fk": {
+          "name": "workspace_email_domain_matching_workspace_id_workspace_id_fk",
+          "tableFrom": "workspace_email_domain_matching",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "workspace_email_domain_matching_role_id_role_id_fk": {
+          "name": "workspace_email_domain_matching_role_id_role_id_fk",
+          "tableFrom": "workspace_email_domain_matching",
+          "tableTo": "role",
+          "columnsFrom": ["role_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.variable_set": {
+      "name": "variable_set",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "variable_set_system_id_system_id_fk": {
+          "name": "variable_set_system_id_system_id_fk",
+          "tableFrom": "variable_set",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.variable_set_value": {
+      "name": "variable_set_value",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "variable_set_id": {
+          "name": "variable_set_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "variable_set_value_variable_set_id_key_index": {
+          "name": "variable_set_value_variable_set_id_key_index",
+          "columns": [
+            {
+              "expression": "variable_set_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "variable_set_value_variable_set_id_variable_set_id_fk": {
+          "name": "variable_set_value_variable_set_id_variable_set_id_fk",
+          "tableFrom": "variable_set_value",
+          "tableTo": "variable_set",
+          "columnsFrom": ["variable_set_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.workspace_invite_token": {
+      "name": "workspace_invite_token",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "workspace_invite_token_role_id_role_id_fk": {
+          "name": "workspace_invite_token_role_id_role_id_fk",
+          "tableFrom": "workspace_invite_token",
+          "tableTo": "role",
+          "columnsFrom": ["role_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "workspace_invite_token_workspace_id_workspace_id_fk": {
+          "name": "workspace_invite_token_workspace_id_workspace_id_fk",
+          "tableFrom": "workspace_invite_token",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "workspace_invite_token_created_by_user_id_fk": {
+          "name": "workspace_invite_token_created_by_user_id_fk",
+          "tableFrom": "workspace_invite_token",
+          "tableTo": "user",
+          "columnsFrom": ["created_by"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "workspace_invite_token_token_unique": {
+          "name": "workspace_invite_token_token_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token"]
+        }
+      }
+    },
+    "public.target_metadata_group": {
+      "name": "target_metadata_group",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "keys": {
+          "name": "keys",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "include_null_combinations": {
+          "name": "include_null_combinations",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "target_metadata_group_workspace_id_workspace_id_fk": {
+          "name": "target_metadata_group_workspace_id_workspace_id_fk",
+          "tableFrom": "target_metadata_group",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.runbook_variable": {
+      "name": "runbook_variable",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "runbook_id": {
+          "name": "runbook_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "schema": {
+          "name": "schema",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "required": {
+          "name": "required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {
+        "runbook_variable_runbook_id_key_index": {
+          "name": "runbook_variable_runbook_id_key_index",
+          "columns": [
+            {
+              "expression": "runbook_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "runbook_variable_runbook_id_runbook_id_fk": {
+          "name": "runbook_variable_runbook_id_runbook_id_fk",
+          "tableFrom": "runbook_variable",
+          "tableTo": "runbook",
+          "columnsFrom": ["runbook_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.entity_role": {
+      "name": "entity_role",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "entity_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope_id": {
+          "name": "scope_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope_type": {
+          "name": "scope_type",
+          "type": "scope_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "entity_role_role_id_entity_type_entity_id_scope_id_scope_type_index": {
+          "name": "entity_role_role_id_entity_type_entity_id_scope_id_scope_type_index",
+          "columns": [
+            {
+              "expression": "role_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scope_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scope_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "entity_role_role_id_role_id_fk": {
+          "name": "entity_role_role_id_role_id_fk",
+          "tableFrom": "entity_role",
+          "tableTo": "role",
+          "columnsFrom": ["role_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.role": {
+      "name": "role",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "role_workspace_id_workspace_id_fk": {
+          "name": "role_workspace_id_workspace_id_fk",
+          "tableFrom": "role",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.role_permission": {
+      "name": "role_permission",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permission": {
+          "name": "permission",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "role_permission_role_id_permission_index": {
+          "name": "role_permission_role_id_permission_index",
+          "columns": [
+            {
+              "expression": "role_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "permission",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "role_permission_role_id_role_id_fk": {
+          "name": "role_permission_role_id_role_id_fk",
+          "tableFrom": "role_permission",
+          "tableTo": "role",
+          "columnsFrom": ["role_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.job_agent": {
+      "name": "job_agent",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        }
+      },
+      "indexes": {
+        "job_agent_workspace_id_name_index": {
+          "name": "job_agent_workspace_id_name_index",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "job_agent_workspace_id_workspace_id_fk": {
+          "name": "job_agent_workspace_id_workspace_id_fk",
+          "tableFrom": "job_agent",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    }
+  },
+  "enums": {
+    "public.environment_policy_approval_requirement": {
+      "name": "environment_policy_approval_requirement",
+      "schema": "public",
+      "values": ["manual", "automatic"]
+    },
+    "public.approval_status_type": {
+      "name": "approval_status_type",
+      "schema": "public",
+      "values": ["pending", "approved", "rejected"]
+    },
+    "public.concurrency_type": {
+      "name": "concurrency_type",
+      "schema": "public",
+      "values": ["all", "some"]
+    },
+    "public.environment_policy_deployment_success_type": {
+      "name": "environment_policy_deployment_success_type",
+      "schema": "public",
+      "values": ["all", "some", "optional"]
+    },
+    "public.evaluation_type": {
+      "name": "evaluation_type",
+      "schema": "public",
+      "values": ["semver", "regex", "filter", "none"]
+    },
+    "public.recurrence_type": {
+      "name": "recurrence_type",
+      "schema": "public",
+      "values": ["hourly", "daily", "weekly", "monthly"]
+    },
+    "public.release_sequencing_type": {
+      "name": "release_sequencing_type",
+      "schema": "public",
+      "values": ["wait", "cancel"]
+    },
+    "public.target_relationship_type": {
+      "name": "target_relationship_type",
+      "schema": "public",
+      "values": ["depends_on", "created_by"]
+    },
+    "public.release_dependency_rule_type": {
+      "name": "release_dependency_rule_type",
+      "schema": "public",
+      "values": ["regex", "semver"]
+    },
+    "public.release_job_trigger_type": {
+      "name": "release_job_trigger_type",
+      "schema": "public",
+      "values": [
+        "new_release",
+        "new_target",
+        "target_changed",
+        "api",
+        "redeploy",
+        "force_deploy"
+      ]
+    },
+    "public.job_reason": {
+      "name": "job_reason",
+      "schema": "public",
+      "values": [
+        "policy_passing",
+        "policy_override",
+        "env_policy_override",
+        "config_policy_override"
+      ]
+    },
+    "public.job_status": {
+      "name": "job_status",
+      "schema": "public",
+      "values": [
+        "completed",
+        "cancelled",
+        "skipped",
+        "in_progress",
+        "action_required",
+        "pending",
+        "failure",
+        "invalid_job_agent",
+        "invalid_integration",
+        "external_run_not_found"
+      ]
+    },
+    "public.entity_type": {
+      "name": "entity_type",
+      "schema": "public",
+      "values": ["user", "team"]
+    },
+    "public.scope_type": {
+      "name": "scope_type",
+      "schema": "public",
+      "values": [
+        "release",
+        "target",
+        "targetProvider",
+        "targetMetadataGroup",
+        "workspace",
+        "environment",
+        "environmentPolicy",
+        "deploymentVariable",
+        "variableSet",
+        "system",
+        "deployment",
+        "job",
+        "jobAgent",
+        "runbook",
+        "targetView"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/packages/db/drizzle/meta/0011_snapshot.json b/packages/db/drizzle/meta/0011_snapshot.json
new file mode 100644
index 000000000..26721fa7e
--- /dev/null
+++ b/packages/db/drizzle/meta/0011_snapshot.json
@@ -0,0 +1,3709 @@
+{
+  "id": "052bad36-d876-45ca-8d38-9a78a1f686be",
+  "prevId": "b6e7d815-72fa-49af-8572-c80143fd5a84",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.account": {
+      "name": "account",
+      "schema": "",
+      "columns": {
+        "userId": {
+          "name": "userId",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "providerAccountId": {
+          "name": "providerAccountId",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "token_type": {
+          "name": "token_type",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "session_state": {
+          "name": "session_state",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "account_userId_user_id_fk": {
+          "name": "account_userId_user_id_fk",
+          "tableFrom": "account",
+          "tableTo": "user",
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "account_provider_providerAccountId_pk": {
+          "name": "account_provider_providerAccountId_pk",
+          "columns": ["provider", "providerAccountId"]
+        }
+      },
+      "uniqueConstraints": {}
+    },
+    "public.session": {
+      "name": "session",
+      "schema": "",
+      "columns": {
+        "sessionToken": {
+          "name": "sessionToken",
+          "type": "varchar(255)",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "userId": {
+          "name": "userId",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires": {
+          "name": "expires",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "session_userId_user_id_fk": {
+          "name": "session_userId_user_id_fk",
+          "tableFrom": "session",
+          "tableTo": "user",
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.user": {
+      "name": "user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "emailVerified": {
+          "name": "emailVerified",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "image": {
+          "name": "image",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_workspace_id": {
+          "name": "active_workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "null"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "user_active_workspace_id_workspace_id_fk": {
+          "name": "user_active_workspace_id_workspace_id_fk",
+          "tableFrom": "user",
+          "tableTo": "workspace",
+          "columnsFrom": ["active_workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.user_api_key": {
+      "name": "user_api_key",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key_preview": {
+          "name": "key_preview",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key_hash": {
+          "name": "key_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key_prefix": {
+          "name": "key_prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "user_api_key_key_prefix_key_hash_index": {
+          "name": "user_api_key_key_prefix_key_hash_index",
+          "columns": [
+            {
+              "expression": "key_prefix",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_api_key_user_id_user_id_fk": {
+          "name": "user_api_key_user_id_user_id_fk",
+          "tableFrom": "user_api_key",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.dashboard": {
+      "name": "dashboard",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "dashboard_workspace_id_workspace_id_fk": {
+          "name": "dashboard_workspace_id_workspace_id_fk",
+          "tableFrom": "dashboard",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.dashboard_widget": {
+      "name": "dashboard_widget",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "dashboard_id": {
+          "name": "dashboard_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "widget": {
+          "name": "widget",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "x": {
+          "name": "x",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "y": {
+          "name": "y",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "w": {
+          "name": "w",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "h": {
+          "name": "h",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "dashboard_widget_dashboard_id_dashboard_id_fk": {
+          "name": "dashboard_widget_dashboard_id_dashboard_id_fk",
+          "tableFrom": "dashboard_widget",
+          "tableTo": "dashboard",
+          "columnsFrom": ["dashboard_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment_variable": {
+      "name": "deployment_variable",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "default_value_id": {
+          "name": "default_value_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "NULL"
+        },
+        "schema": {
+          "name": "schema",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "deployment_variable_deployment_id_key_index": {
+          "name": "deployment_variable_deployment_id_key_index",
+          "columns": [
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_variable_deployment_id_deployment_id_fk": {
+          "name": "deployment_variable_deployment_id_deployment_id_fk",
+          "tableFrom": "deployment_variable",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "deployment_variable_default_value_id_deployment_variable_value_id_fk": {
+          "name": "deployment_variable_default_value_id_deployment_variable_value_id_fk",
+          "tableFrom": "deployment_variable",
+          "tableTo": "deployment_variable_value",
+          "columnsFrom": ["default_value_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment_variable_set": {
+      "name": "deployment_variable_set",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "variable_set_id": {
+          "name": "variable_set_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "deployment_variable_set_deployment_id_variable_set_id_index": {
+          "name": "deployment_variable_set_deployment_id_variable_set_id_index",
+          "columns": [
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "variable_set_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_variable_set_deployment_id_deployment_id_fk": {
+          "name": "deployment_variable_set_deployment_id_deployment_id_fk",
+          "tableFrom": "deployment_variable_set",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "deployment_variable_set_variable_set_id_variable_set_id_fk": {
+          "name": "deployment_variable_set_variable_set_id_variable_set_id_fk",
+          "tableFrom": "deployment_variable_set",
+          "tableTo": "variable_set",
+          "columnsFrom": ["variable_set_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment_variable_value": {
+      "name": "deployment_variable_value",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "variable_id": {
+          "name": "variable_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_filter": {
+          "name": "target_filter",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "NULL"
+        }
+      },
+      "indexes": {
+        "deployment_variable_value_variable_id_value_index": {
+          "name": "deployment_variable_value_variable_id_value_index",
+          "columns": [
+            {
+              "expression": "variable_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_variable_value_variable_id_deployment_variable_id_fk": {
+          "name": "deployment_variable_value_variable_id_deployment_variable_id_fk",
+          "tableFrom": "deployment_variable_value",
+          "tableTo": "deployment_variable",
+          "columnsFrom": ["variable_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "restrict"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment": {
+      "name": "deployment",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_agent_id": {
+          "name": "job_agent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_agent_config": {
+          "name": "job_agent_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        },
+        "github_config_file_id": {
+          "name": "github_config_file_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "deployment_system_id_slug_index": {
+          "name": "deployment_system_id_slug_index",
+          "columns": [
+            {
+              "expression": "system_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_system_id_system_id_fk": {
+          "name": "deployment_system_id_system_id_fk",
+          "tableFrom": "deployment",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "deployment_job_agent_id_job_agent_id_fk": {
+          "name": "deployment_job_agent_id_job_agent_id_fk",
+          "tableFrom": "deployment",
+          "tableTo": "job_agent",
+          "columnsFrom": ["job_agent_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "deployment_github_config_file_id_github_config_file_id_fk": {
+          "name": "deployment_github_config_file_id_github_config_file_id_fk",
+          "tableFrom": "deployment",
+          "tableTo": "github_config_file",
+          "columnsFrom": ["github_config_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.deployment_meta_dependency": {
+      "name": "deployment_meta_dependency",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "depends_on_id": {
+          "name": "depends_on_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "deployment_meta_dependency_depends_on_id_deployment_id_index": {
+          "name": "deployment_meta_dependency_depends_on_id_deployment_id_index",
+          "columns": [
+            {
+              "expression": "depends_on_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "deployment_meta_dependency_deployment_id_deployment_id_fk": {
+          "name": "deployment_meta_dependency_deployment_id_deployment_id_fk",
+          "tableFrom": "deployment_meta_dependency",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "deployment_meta_dependency_depends_on_id_deployment_id_fk": {
+          "name": "deployment_meta_dependency_depends_on_id_deployment_id_fk",
+          "tableFrom": "deployment_meta_dependency",
+          "tableTo": "deployment",
+          "columnsFrom": ["depends_on_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment": {
+      "name": "environment",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "''"
+        },
+        "policy_id": {
+          "name": "policy_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_filter": {
+          "name": "target_filter",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "NULL"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "environment_system_id_system_id_fk": {
+          "name": "environment_system_id_system_id_fk",
+          "tableFrom": "environment",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "environment_policy_id_environment_policy_id_fk": {
+          "name": "environment_policy_id_environment_policy_id_fk",
+          "tableFrom": "environment",
+          "tableTo": "environment_policy",
+          "columnsFrom": ["policy_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment_policy": {
+      "name": "environment_policy",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "approval_required": {
+          "name": "approval_required",
+          "type": "environment_policy_approval_requirement",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual'"
+        },
+        "success_status": {
+          "name": "success_status",
+          "type": "environment_policy_deployment_success_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'all'"
+        },
+        "minimum_success": {
+          "name": "minimum_success",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "concurrency_type": {
+          "name": "concurrency_type",
+          "type": "concurrency_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'all'"
+        },
+        "concurrency_limit": {
+          "name": "concurrency_limit",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "duration": {
+          "name": "duration",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "evaluate_with": {
+          "name": "evaluate_with",
+          "type": "evaluation_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'none'"
+        },
+        "evaluate": {
+          "name": "evaluate",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "NULL"
+        },
+        "release_sequencing": {
+          "name": "release_sequencing",
+          "type": "release_sequencing_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'cancel'"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "environment_policy_system_id_system_id_fk": {
+          "name": "environment_policy_system_id_system_id_fk",
+          "tableFrom": "environment_policy",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment_policy_approval": {
+      "name": "environment_policy_approval",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "policy_id": {
+          "name": "policy_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "release_id": {
+          "name": "release_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "approval_status_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        }
+      },
+      "indexes": {
+        "environment_policy_approval_policy_id_release_id_index": {
+          "name": "environment_policy_approval_policy_id_release_id_index",
+          "columns": [
+            {
+              "expression": "policy_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "release_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "environment_policy_approval_policy_id_environment_policy_id_fk": {
+          "name": "environment_policy_approval_policy_id_environment_policy_id_fk",
+          "tableFrom": "environment_policy_approval",
+          "tableTo": "environment_policy",
+          "columnsFrom": ["policy_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "environment_policy_approval_release_id_release_id_fk": {
+          "name": "environment_policy_approval_release_id_release_id_fk",
+          "tableFrom": "environment_policy_approval",
+          "tableTo": "release",
+          "columnsFrom": ["release_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment_policy_deployment": {
+      "name": "environment_policy_deployment",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "policy_id": {
+          "name": "policy_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "environment_id": {
+          "name": "environment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "environment_policy_deployment_policy_id_environment_id_index": {
+          "name": "environment_policy_deployment_policy_id_environment_id_index",
+          "columns": [
+            {
+              "expression": "policy_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "environment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "environment_policy_deployment_policy_id_environment_policy_id_fk": {
+          "name": "environment_policy_deployment_policy_id_environment_policy_id_fk",
+          "tableFrom": "environment_policy_deployment",
+          "tableTo": "environment_policy",
+          "columnsFrom": ["policy_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "environment_policy_deployment_environment_id_environment_id_fk": {
+          "name": "environment_policy_deployment_environment_id_environment_id_fk",
+          "tableFrom": "environment_policy_deployment",
+          "tableTo": "environment",
+          "columnsFrom": ["environment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.environment_policy_release_window": {
+      "name": "environment_policy_release_window",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "policy_id": {
+          "name": "policy_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "start_time": {
+          "name": "start_time",
+          "type": "timestamp (0) with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "end_time": {
+          "name": "end_time",
+          "type": "timestamp (0) with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "recurrence": {
+          "name": "recurrence",
+          "type": "recurrence_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "environment_policy_release_window_policy_id_environment_policy_id_fk": {
+          "name": "environment_policy_release_window_policy_id_environment_policy_id_fk",
+          "tableFrom": "environment_policy_release_window",
+          "tableTo": "environment_policy",
+          "columnsFrom": ["policy_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.github_config_file": {
+      "name": "github_config_file",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "repository_name": {
+          "name": "repository_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "unique_organization_repository_path": {
+          "name": "unique_organization_repository_path",
+          "columns": [
+            {
+              "expression": "organization_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "repository_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "path",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "github_config_file_organization_id_github_organization_id_fk": {
+          "name": "github_config_file_organization_id_github_organization_id_fk",
+          "tableFrom": "github_config_file",
+          "tableTo": "github_organization",
+          "columnsFrom": ["organization_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "github_config_file_workspace_id_workspace_id_fk": {
+          "name": "github_config_file_workspace_id_workspace_id_fk",
+          "tableFrom": "github_config_file",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.github_organization": {
+      "name": "github_organization",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "installation_id": {
+          "name": "installation_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "organization_name": {
+          "name": "organization_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_by_user_id": {
+          "name": "added_by_user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'main'"
+        }
+      },
+      "indexes": {
+        "unique_installation_workspace": {
+          "name": "unique_installation_workspace",
+          "columns": [
+            {
+              "expression": "installation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "github_organization_added_by_user_id_user_id_fk": {
+          "name": "github_organization_added_by_user_id_user_id_fk",
+          "tableFrom": "github_organization",
+          "tableTo": "user",
+          "columnsFrom": ["added_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "github_organization_workspace_id_workspace_id_fk": {
+          "name": "github_organization_workspace_id_workspace_id_fk",
+          "tableFrom": "github_organization",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.github_user": {
+      "name": "github_user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "github_user_id": {
+          "name": "github_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "github_username": {
+          "name": "github_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "github_user_user_id_user_id_fk": {
+          "name": "github_user_user_id_user_id_fk",
+          "tableFrom": "github_user",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target": {
+      "name": "target",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "version": {
+          "name": "version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        },
+        "locked_at": {
+          "name": "locked_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "target_identifier_workspace_id_index": {
+          "name": "target_identifier_workspace_id_index",
+          "columns": [
+            {
+              "expression": "identifier",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_provider_id_target_provider_id_fk": {
+          "name": "target_provider_id_target_provider_id_fk",
+          "tableFrom": "target",
+          "tableTo": "target_provider",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "target_workspace_id_workspace_id_fk": {
+          "name": "target_workspace_id_workspace_id_fk",
+          "tableFrom": "target",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_metadata": {
+      "name": "target_metadata",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "target_metadata_key_target_id_index": {
+          "name": "target_metadata_key_target_id_index",
+          "columns": [
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_metadata_target_id_target_id_fk": {
+          "name": "target_metadata_target_id_target_id_fk",
+          "tableFrom": "target_metadata",
+          "tableTo": "target",
+          "columnsFrom": ["target_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_relationship": {
+      "name": "target_relationship",
+      "schema": "",
+      "columns": {
+        "uuid": {
+          "name": "uuid",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "relationship_type": {
+          "name": "relationship_type",
+          "type": "target_relationship_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "target_relationship_target_id_source_id_index": {
+          "name": "target_relationship_target_id_source_id_index",
+          "columns": [
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "source_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_relationship_source_id_target_id_fk": {
+          "name": "target_relationship_source_id_target_id_fk",
+          "tableFrom": "target_relationship",
+          "tableTo": "target",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "target_relationship_target_id_target_id_fk": {
+          "name": "target_relationship_target_id_target_id_fk",
+          "tableFrom": "target_relationship",
+          "tableTo": "target",
+          "columnsFrom": ["target_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_schema": {
+      "name": "target_schema",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "version": {
+          "name": "version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "json_schema": {
+          "name": "json_schema",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "target_schema_version_kind_workspace_id_index": {
+          "name": "target_schema_version_kind_workspace_id_index",
+          "columns": [
+            {
+              "expression": "version",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_schema_workspace_id_workspace_id_fk": {
+          "name": "target_schema_workspace_id_workspace_id_fk",
+          "tableFrom": "target_schema",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_view": {
+      "name": "target_view",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "''"
+        },
+        "filter": {
+          "name": "filter",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "target_view_workspace_id_workspace_id_fk": {
+          "name": "target_view_workspace_id_workspace_id_fk",
+          "tableFrom": "target_view",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_provider": {
+      "name": "target_provider",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "target_provider_workspace_id_name_index": {
+          "name": "target_provider_workspace_id_name_index",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "target_provider_workspace_id_workspace_id_fk": {
+          "name": "target_provider_workspace_id_workspace_id_fk",
+          "tableFrom": "target_provider",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.target_provider_google": {
+      "name": "target_provider_google",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "target_provider_id": {
+          "name": "target_provider_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "project_ids": {
+          "name": "project_ids",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "target_provider_google_target_provider_id_target_provider_id_fk": {
+          "name": "target_provider_google_target_provider_id_target_provider_id_fk",
+          "tableFrom": "target_provider_google",
+          "tableTo": "target_provider",
+          "columnsFrom": ["target_provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.release": {
+      "name": "release",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "version": {
+          "name": "version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "release_deployment_id_version_index": {
+          "name": "release_deployment_id_version_index",
+          "columns": [
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "version",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "release_deployment_id_deployment_id_fk": {
+          "name": "release_deployment_id_deployment_id_fk",
+          "tableFrom": "release",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.release_dependency": {
+      "name": "release_dependency",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "release_id": {
+          "name": "release_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "deployment_id": {
+          "name": "deployment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_metadata_group_id": {
+          "name": "target_metadata_group_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rule_type": {
+          "name": "rule_type",
+          "type": "release_dependency_rule_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rule": {
+          "name": "rule",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "release_dependency_release_id_deployment_id_target_metadata_group_id_index": {
+          "name": "release_dependency_release_id_deployment_id_target_metadata_group_id_index",
+          "columns": [
+            {
+              "expression": "release_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "deployment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_metadata_group_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "release_dependency_release_id_release_id_fk": {
+          "name": "release_dependency_release_id_release_id_fk",
+          "tableFrom": "release_dependency",
+          "tableTo": "release",
+          "columnsFrom": ["release_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "release_dependency_deployment_id_deployment_id_fk": {
+          "name": "release_dependency_deployment_id_deployment_id_fk",
+          "tableFrom": "release_dependency",
+          "tableTo": "deployment",
+          "columnsFrom": ["deployment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "release_dependency_target_metadata_group_id_target_metadata_group_id_fk": {
+          "name": "release_dependency_target_metadata_group_id_target_metadata_group_id_fk",
+          "tableFrom": "release_dependency",
+          "tableTo": "target_metadata_group",
+          "columnsFrom": ["target_metadata_group_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.release_job_trigger": {
+      "name": "release_job_trigger",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "release_job_trigger_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "caused_by_id": {
+          "name": "caused_by_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "release_id": {
+          "name": "release_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "environment_id": {
+          "name": "environment_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "release_job_trigger_job_id_job_id_fk": {
+          "name": "release_job_trigger_job_id_job_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "job",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "release_job_trigger_caused_by_id_user_id_fk": {
+          "name": "release_job_trigger_caused_by_id_user_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "user",
+          "columnsFrom": ["caused_by_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "release_job_trigger_release_id_release_id_fk": {
+          "name": "release_job_trigger_release_id_release_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "release",
+          "columnsFrom": ["release_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "release_job_trigger_target_id_target_id_fk": {
+          "name": "release_job_trigger_target_id_target_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "target",
+          "columnsFrom": ["target_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "release_job_trigger_environment_id_environment_id_fk": {
+          "name": "release_job_trigger_environment_id_environment_id_fk",
+          "tableFrom": "release_job_trigger",
+          "tableTo": "environment",
+          "columnsFrom": ["environment_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "release_job_trigger_job_id_unique": {
+          "name": "release_job_trigger_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["job_id"]
+        }
+      }
+    },
+    "public.release_metadata": {
+      "name": "release_metadata",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "release_id": {
+          "name": "release_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "release_metadata_key_release_id_index": {
+          "name": "release_metadata_key_release_id_index",
+          "columns": [
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "release_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "release_metadata_release_id_release_id_fk": {
+          "name": "release_metadata_release_id_release_id_fk",
+          "tableFrom": "release_metadata",
+          "tableTo": "release",
+          "columnsFrom": ["release_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.system": {
+      "name": "system",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "system_workspace_id_slug_index": {
+          "name": "system_workspace_id_slug_index",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "system_workspace_id_workspace_id_fk": {
+          "name": "system_workspace_id_workspace_id_fk",
+          "tableFrom": "system",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.runbook": {
+      "name": "runbook",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_agent_id": {
+          "name": "job_agent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_agent_config": {
+          "name": "job_agent_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "runbook_system_id_system_id_fk": {
+          "name": "runbook_system_id_system_id_fk",
+          "tableFrom": "runbook",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "runbook_job_agent_id_job_agent_id_fk": {
+          "name": "runbook_job_agent_id_job_agent_id_fk",
+          "tableFrom": "runbook",
+          "tableTo": "job_agent",
+          "columnsFrom": ["job_agent_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.runbook_job_trigger": {
+      "name": "runbook_job_trigger",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "runbook_id": {
+          "name": "runbook_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "runbook_job_trigger_job_id_job_id_fk": {
+          "name": "runbook_job_trigger_job_id_job_id_fk",
+          "tableFrom": "runbook_job_trigger",
+          "tableTo": "job",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "runbook_job_trigger_runbook_id_runbook_id_fk": {
+          "name": "runbook_job_trigger_runbook_id_runbook_id_fk",
+          "tableFrom": "runbook_job_trigger",
+          "tableTo": "runbook",
+          "columnsFrom": ["runbook_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "runbook_job_trigger_job_id_unique": {
+          "name": "runbook_job_trigger_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["job_id"]
+        }
+      }
+    },
+    "public.team": {
+      "name": "team",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "team_workspace_id_workspace_id_fk": {
+          "name": "team_workspace_id_workspace_id_fk",
+          "tableFrom": "team",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.team_member": {
+      "name": "team_member",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "team_id": {
+          "name": "team_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "team_member_team_id_user_id_index": {
+          "name": "team_member_team_id_user_id_index",
+          "columns": [
+            {
+              "expression": "team_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "team_member_team_id_team_id_fk": {
+          "name": "team_member_team_id_team_id_fk",
+          "tableFrom": "team_member",
+          "tableTo": "team",
+          "columnsFrom": ["team_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "team_member_user_id_user_id_fk": {
+          "name": "team_member_user_id_user_id_fk",
+          "tableFrom": "team_member",
+          "tableTo": "user",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.job": {
+      "name": "job",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_agent_id": {
+          "name": "job_agent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_agent_config": {
+          "name": "job_agent_config",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        },
+        "external_id": {
+          "name": "external_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "job_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "message": {
+          "name": "message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reason": {
+          "name": "reason",
+          "type": "job_reason",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'policy_passing'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "job_job_agent_id_job_agent_id_fk": {
+          "name": "job_job_agent_id_job_agent_id_fk",
+          "tableFrom": "job",
+          "tableTo": "job_agent",
+          "columnsFrom": ["job_agent_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.job_metadata": {
+      "name": "job_metadata",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "job_metadata_key_job_id_index": {
+          "name": "job_metadata_key_job_id_index",
+          "columns": [
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "job_metadata_job_id_job_id_fk": {
+          "name": "job_metadata_job_id_job_id_fk",
+          "tableFrom": "job_metadata",
+          "tableTo": "job",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.job_variable": {
+      "name": "job_variable",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "job_variable_job_id_key_index": {
+          "name": "job_variable_job_id_key_index",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "job_variable_job_id_job_id_fk": {
+          "name": "job_variable_job_id_job_id_fk",
+          "tableFrom": "job_variable",
+          "tableTo": "job",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.workspace": {
+      "name": "workspace",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "google_service_account_email": {
+          "name": "google_service_account_email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "workspace_slug_unique": {
+          "name": "workspace_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": ["slug"]
+        }
+      }
+    },
+    "public.workspace_email_domain_matching": {
+      "name": "workspace_email_domain_matching",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "domain": {
+          "name": "domain",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "verified": {
+          "name": "verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "verification_code": {
+          "name": "verification_code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "verification_email": {
+          "name": "verification_email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "workspace_email_domain_matching_workspace_id_domain_index": {
+          "name": "workspace_email_domain_matching_workspace_id_domain_index",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "domain",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "workspace_email_domain_matching_workspace_id_workspace_id_fk": {
+          "name": "workspace_email_domain_matching_workspace_id_workspace_id_fk",
+          "tableFrom": "workspace_email_domain_matching",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "workspace_email_domain_matching_role_id_role_id_fk": {
+          "name": "workspace_email_domain_matching_role_id_role_id_fk",
+          "tableFrom": "workspace_email_domain_matching",
+          "tableTo": "role",
+          "columnsFrom": ["role_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.variable_set": {
+      "name": "variable_set",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "variable_set_system_id_system_id_fk": {
+          "name": "variable_set_system_id_system_id_fk",
+          "tableFrom": "variable_set",
+          "tableTo": "system",
+          "columnsFrom": ["system_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.variable_set_value": {
+      "name": "variable_set_value",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "variable_set_id": {
+          "name": "variable_set_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "variable_set_value_variable_set_id_key_index": {
+          "name": "variable_set_value_variable_set_id_key_index",
+          "columns": [
+            {
+              "expression": "variable_set_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "variable_set_value_variable_set_id_variable_set_id_fk": {
+          "name": "variable_set_value_variable_set_id_variable_set_id_fk",
+          "tableFrom": "variable_set_value",
+          "tableTo": "variable_set",
+          "columnsFrom": ["variable_set_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.workspace_invite_token": {
+      "name": "workspace_invite_token",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "workspace_invite_token_role_id_role_id_fk": {
+          "name": "workspace_invite_token_role_id_role_id_fk",
+          "tableFrom": "workspace_invite_token",
+          "tableTo": "role",
+          "columnsFrom": ["role_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "workspace_invite_token_workspace_id_workspace_id_fk": {
+          "name": "workspace_invite_token_workspace_id_workspace_id_fk",
+          "tableFrom": "workspace_invite_token",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "workspace_invite_token_created_by_user_id_fk": {
+          "name": "workspace_invite_token_created_by_user_id_fk",
+          "tableFrom": "workspace_invite_token",
+          "tableTo": "user",
+          "columnsFrom": ["created_by"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "workspace_invite_token_token_unique": {
+          "name": "workspace_invite_token_token_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token"]
+        }
+      }
+    },
+    "public.target_metadata_group": {
+      "name": "target_metadata_group",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "keys": {
+          "name": "keys",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "include_null_combinations": {
+          "name": "include_null_combinations",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "target_metadata_group_workspace_id_workspace_id_fk": {
+          "name": "target_metadata_group_workspace_id_workspace_id_fk",
+          "tableFrom": "target_metadata_group",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.runbook_variable": {
+      "name": "runbook_variable",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "runbook_id": {
+          "name": "runbook_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "schema": {
+          "name": "schema",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "required": {
+          "name": "required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {
+        "runbook_variable_runbook_id_key_index": {
+          "name": "runbook_variable_runbook_id_key_index",
+          "columns": [
+            {
+              "expression": "runbook_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "runbook_variable_runbook_id_runbook_id_fk": {
+          "name": "runbook_variable_runbook_id_runbook_id_fk",
+          "tableFrom": "runbook_variable",
+          "tableTo": "runbook",
+          "columnsFrom": ["runbook_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.entity_role": {
+      "name": "entity_role",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "entity_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope_id": {
+          "name": "scope_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope_type": {
+          "name": "scope_type",
+          "type": "scope_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "entity_role_role_id_entity_type_entity_id_scope_id_scope_type_index": {
+          "name": "entity_role_role_id_entity_type_entity_id_scope_id_scope_type_index",
+          "columns": [
+            {
+              "expression": "role_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scope_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scope_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "entity_role_role_id_role_id_fk": {
+          "name": "entity_role_role_id_role_id_fk",
+          "tableFrom": "entity_role",
+          "tableTo": "role",
+          "columnsFrom": ["role_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.role": {
+      "name": "role",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "role_workspace_id_workspace_id_fk": {
+          "name": "role_workspace_id_workspace_id_fk",
+          "tableFrom": "role",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.role_permission": {
+      "name": "role_permission",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permission": {
+          "name": "permission",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "role_permission_role_id_permission_index": {
+          "name": "role_permission_role_id_permission_index",
+          "columns": [
+            {
+              "expression": "role_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "permission",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "role_permission_role_id_role_id_fk": {
+          "name": "role_permission_role_id_role_id_fk",
+          "tableFrom": "role_permission",
+          "tableTo": "role",
+          "columnsFrom": ["role_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "public.job_agent": {
+      "name": "job_agent",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'"
+        }
+      },
+      "indexes": {
+        "job_agent_workspace_id_name_index": {
+          "name": "job_agent_workspace_id_name_index",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "job_agent_workspace_id_workspace_id_fk": {
+          "name": "job_agent_workspace_id_workspace_id_fk",
+          "tableFrom": "job_agent",
+          "tableTo": "workspace",
+          "columnsFrom": ["workspace_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    }
+  },
+  "enums": {
+    "public.environment_policy_approval_requirement": {
+      "name": "environment_policy_approval_requirement",
+      "schema": "public",
+      "values": ["manual", "automatic"]
+    },
+    "public.approval_status_type": {
+      "name": "approval_status_type",
+      "schema": "public",
+      "values": ["pending", "approved", "rejected"]
+    },
+    "public.concurrency_type": {
+      "name": "concurrency_type",
+      "schema": "public",
+      "values": ["all", "some"]
+    },
+    "public.environment_policy_deployment_success_type": {
+      "name": "environment_policy_deployment_success_type",
+      "schema": "public",
+      "values": ["all", "some", "optional"]
+    },
+    "public.evaluation_type": {
+      "name": "evaluation_type",
+      "schema": "public",
+      "values": ["semver", "regex", "filter", "none"]
+    },
+    "public.recurrence_type": {
+      "name": "recurrence_type",
+      "schema": "public",
+      "values": ["hourly", "daily", "weekly", "monthly"]
+    },
+    "public.release_sequencing_type": {
+      "name": "release_sequencing_type",
+      "schema": "public",
+      "values": ["wait", "cancel"]
+    },
+    "public.target_relationship_type": {
+      "name": "target_relationship_type",
+      "schema": "public",
+      "values": ["depends_on", "created_by"]
+    },
+    "public.release_dependency_rule_type": {
+      "name": "release_dependency_rule_type",
+      "schema": "public",
+      "values": ["regex", "semver"]
+    },
+    "public.release_job_trigger_type": {
+      "name": "release_job_trigger_type",
+      "schema": "public",
+      "values": [
+        "new_release",
+        "new_target",
+        "target_changed",
+        "api",
+        "redeploy",
+        "force_deploy"
+      ]
+    },
+    "public.job_reason": {
+      "name": "job_reason",
+      "schema": "public",
+      "values": [
+        "policy_passing",
+        "policy_override",
+        "env_policy_override",
+        "config_policy_override"
+      ]
+    },
+    "public.job_status": {
+      "name": "job_status",
+      "schema": "public",
+      "values": [
+        "completed",
+        "cancelled",
+        "skipped",
+        "in_progress",
+        "action_required",
+        "pending",
+        "failure",
+        "invalid_job_agent",
+        "invalid_integration",
+        "external_run_not_found"
+      ]
+    },
+    "public.entity_type": {
+      "name": "entity_type",
+      "schema": "public",
+      "values": ["user", "team"]
+    },
+    "public.scope_type": {
+      "name": "scope_type",
+      "schema": "public",
+      "values": [
+        "release",
+        "target",
+        "targetProvider",
+        "targetMetadataGroup",
+        "workspace",
+        "environment",
+        "environmentPolicy",
+        "deploymentVariable",
+        "variableSet",
+        "system",
+        "deployment",
+        "job",
+        "jobAgent",
+        "runbook",
+        "targetView"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/packages/db/drizzle/meta/_journal.json b/packages/db/drizzle/meta/_journal.json
index 5532f6ebd..9d5794849 100644
--- a/packages/db/drizzle/meta/_journal.json
+++ b/packages/db/drizzle/meta/_journal.json
@@ -71,6 +71,20 @@
       "when": 1727989623771,
       "tag": "0009_flaky_hellfire_club",
       "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "7",
+      "when": 1728354690899,
+      "tag": "0010_sharp_shriek",
+      "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "7",
+      "when": 1728354754889,
+      "tag": "0011_flippant_amazoness",
+      "breakpoints": true
     }
   ]
 }
diff --git a/packages/db/src/schema/environment.ts b/packages/db/src/schema/environment.ts
index bf3576fbf..d1cacddbf 100644
--- a/packages/db/src/schema/environment.ts
+++ b/packages/db/src/schema/environment.ts
@@ -1,6 +1,6 @@
+import type { ReleaseCondition } from "@ctrlplane/validators/releases";
 import type { TargetCondition } from "@ctrlplane/validators/targets";
 import type { InferSelectModel } from "drizzle-orm";
-import type { z } from "zod";
 import { sql } from "drizzle-orm";
 import {
   bigint,
@@ -14,7 +14,9 @@ import {
   uuid,
 } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
+import { z } from "zod";
 
+import { releaseCondition } from "@ctrlplane/validators/releases";
 import { targetCondition } from "@ctrlplane/validators/targets";
 
 import { release } from "./release.js";
@@ -58,6 +60,7 @@ export const environmentPolicyDeploymentSuccessType = pgEnum(
 export const evaluationType = pgEnum("evaluation_type", [
   "semver",
   "regex",
+  "filter",
   "none",
 ]);
 
@@ -91,7 +94,9 @@ export const environmentPolicy = pgTable("environment_policy", {
   duration: bigint("duration", { mode: "number" }).notNull().default(0),
 
   evaluateWith: evaluationType("evaluate_with").notNull().default("none"),
-  evaluate: text("evaluate").notNull().default(""),
+  evaluate: jsonb("evaluate")
+    .$type<ReleaseCondition | string | null>()
+    .default(sql`NULL`),
 
   releaseSequencing: releaseSequencingType("release_sequencing")
     .notNull()
@@ -100,13 +105,11 @@ export const environmentPolicy = pgTable("environment_policy", {
 
 export type EnvironmentPolicy = InferSelectModel<typeof environmentPolicy>;
 
-export const createEnvironmentPolicy = createInsertSchema(
-  environmentPolicy,
-).omit({ id: true });
+export const createEnvironmentPolicy = createInsertSchema(environmentPolicy, {
+  evaluate: z.union([releaseCondition, z.string(), z.null()]),
+}).omit({ id: true });
 
-export const updateEnvironmentPolicy = createInsertSchema(
-  environmentPolicy,
-).omit({ id: true, systemId: true });
+export const updateEnvironmentPolicy = createEnvironmentPolicy.partial();
 
 export const recurrenceType = pgEnum("recurrence_type", [
   "hourly",
diff --git a/packages/job-dispatch/src/policies/release-string-check.ts b/packages/job-dispatch/src/policies/release-string-check.ts
index 3ad819d39..e63a88672 100644
--- a/packages/job-dispatch/src/policies/release-string-check.ts
+++ b/packages/job-dispatch/src/policies/release-string-check.ts
@@ -1,9 +1,15 @@
+import type { VersionCheck } from "@ctrlplane/validators/environment-policies";
 import _ from "lodash";
 import { satisfies } from "semver";
 import { isPresent } from "ts-is-present";
 
-import { and, eq, inArray, isNull } from "@ctrlplane/db";
-import { environment, environmentPolicy, release } from "@ctrlplane/db/schema";
+import { and, eq, inArray, isNull, takeFirstOrNull } from "@ctrlplane/db";
+import * as schema from "@ctrlplane/db/schema";
+import {
+  isFilterCheck,
+  isRegexCheck,
+  isSemverCheck,
+} from "@ctrlplane/validators/environment-policies";
 
 import type { ReleasePolicyChecker } from "./utils.js";
 
@@ -21,33 +27,56 @@ export const isPassingReleaseStringCheckPolicy: ReleasePolicyChecker = async (
   const envIds = wf.map((v) => v.environmentId).filter(isPresent);
   const policies = await db
     .select()
-    .from(environment)
+    .from(schema.environment)
     .innerJoin(
-      environmentPolicy,
-      eq(environment.policyId, environmentPolicy.id),
+      schema.environmentPolicy,
+      eq(schema.environment.policyId, schema.environmentPolicy.id),
     )
-    .where(and(inArray(environment.id, envIds), isNull(environment.deletedAt)));
+    .where(
+      and(
+        inArray(schema.environment.id, envIds),
+        isNull(schema.environment.deletedAt),
+      ),
+    );
 
   const releaseIds = wf.map((v) => v.releaseId).filter(isPresent);
   const rels = await db
     .select()
-    .from(release)
-    .where(inArray(release.id, releaseIds));
+    .from(schema.release)
+    .where(inArray(schema.release.id, releaseIds));
 
-  return wf.filter((v) => {
-    const policy = policies.find((p) => p.environment.id === v.environmentId);
-    if (policy == null) return true;
+  return Promise.all(
+    wf.map(async (v) => {
+      const policy = policies.find((p) => p.environment.id === v.environmentId);
+      if (policy == null) return v;
 
-    const rel = rels.find((r) => r.id === v.releaseId);
-    if (rel == null) return true;
+      const rel = rels.find((r) => r.id === v.releaseId);
+      if (rel == null) return v;
 
-    const { environment_policy: envPolicy } = policy;
-    if (envPolicy.evaluateWith === "semver")
-      return satisfies(rel.version, policy.environment_policy.evaluate);
+      const { environment_policy: envPolicy } = policy;
+      const check: VersionCheck = { ...envPolicy };
+      if (isSemverCheck(check) && satisfies(rel.version, check.evaluate))
+        return v;
 
-    if (envPolicy.evaluateWith === "regex")
-      return new RegExp(policy.environment_policy.evaluate).test(rel.version);
+      if (isRegexCheck(check) && new RegExp(check.evaluate).test(rel.version))
+        return v;
 
-    return true;
-  });
+      if (isFilterCheck(check)) {
+        const release = await db
+          .select()
+          .from(schema.release)
+          .where(
+            and(
+              eq(schema.release.id, rel.id),
+              schema.releaseMatchesCondition(db, check.evaluate),
+            ),
+          )
+          .then(takeFirstOrNull);
+
+        return isPresent(release) ? v : null;
+      }
+
+      return null;
+    }),
+  ).then((results) => results.filter(isPresent));
 };
diff --git a/packages/validators/package.json b/packages/validators/package.json
index a07927367..287f5da21 100644
--- a/packages/validators/package.json
+++ b/packages/validators/package.json
@@ -35,6 +35,10 @@
     "./auth": {
       "types": "./src/auth/index.ts",
       "default": "./dist/auth/index.js"
+    },
+    "./environment-policies": {
+      "types": "./src/environment-policies/index.ts",
+      "default": "./dist/environment-policies/index.js"
     }
   },
   "license": "MIT",
diff --git a/packages/validators/src/environment-policies/index.ts b/packages/validators/src/environment-policies/index.ts
new file mode 100644
index 000000000..5279e1d46
--- /dev/null
+++ b/packages/validators/src/environment-policies/index.ts
@@ -0,0 +1,38 @@
+import type { ReleaseCondition } from "../releases";
+
+export type RegexCheck = {
+  evaluateWith: "regex";
+  evaluate: string;
+};
+
+export type SemverCheck = {
+  evaluateWith: "semver";
+  evaluate: string;
+};
+
+export type FilterCheck = {
+  evaluateWith: "filter";
+  evaluate: ReleaseCondition;
+};
+
+export type NoneCheck = {
+  evaluateWith: "none";
+  evaluate: null;
+};
+
+export type VersionCheck = {
+  evaluateWith: "regex" | "semver" | "filter" | "none";
+  evaluate: string | ReleaseCondition | null;
+};
+
+export const isRegexCheck = (check: VersionCheck): check is RegexCheck =>
+  check.evaluateWith === "regex";
+
+export const isSemverCheck = (check: VersionCheck): check is SemverCheck =>
+  check.evaluateWith === "semver";
+
+export const isFilterCheck = (check: VersionCheck): check is FilterCheck =>
+  check.evaluateWith === "filter";
+
+export const isNoneCheck = (check: VersionCheck): check is NoneCheck =>
+  check.evaluateWith === "none";