diff --git a/site/src/api/queries/workspaceBuilds.ts b/site/src/api/queries/workspaceBuilds.ts
index 98049a89e7ffe..d0d8557683792 100644
--- a/site/src/api/queries/workspaceBuilds.ts
+++ b/site/src/api/queries/workspaceBuilds.ts
@@ -1,7 +1,18 @@
-import { UseInfiniteQueryOptions } from "react-query";
+import { QueryOptions, UseInfiniteQueryOptions } from "react-query";
 import * as API from "api/api";
 import { WorkspaceBuild, WorkspaceBuildsRequest } from "api/typesGenerated";
 
+export function workspaceBuildParametersKey(workspaceId: string) {
+  return ["workspaceBuilds", workspaceId, "parameters"] as const;
+}
+
+export function workspaceBuildParameters(workspaceBuildId: string) {
+  return {
+    queryKey: workspaceBuildParametersKey(workspaceBuildId),
+    queryFn: () => API.getWorkspaceBuildParameters(workspaceBuildId),
+  } as const satisfies QueryOptions;
+}
+
 export const workspaceBuildByNumber = (
   username: string,
   workspaceName: string,
diff --git a/site/src/api/queries/workspaces.ts b/site/src/api/queries/workspaces.ts
index bd5b76f951838..4607464621e2d 100644
--- a/site/src/api/queries/workspaces.ts
+++ b/site/src/api/queries/workspaces.ts
@@ -26,7 +26,7 @@ export const workspaceByOwnerAndName = (
   };
 };
 
-type AutoCreateWorkspaceOptions = {
+export type AutoCreateWorkspaceOptions = {
   templateName: string;
   versionId?: string;
   organizationId: string;
@@ -84,6 +84,27 @@ export const autoCreateWorkspace = (queryClient: QueryClient) => {
   };
 };
 
+export function workspaceParametersKey(workspaceId: string) {
+  return ["workspaces", workspaceId, "parameters"] as const;
+}
+
+export function workspaceParameters(workspace: Workspace) {
+  return {
+    queryKey: workspaceParametersKey(workspace.id),
+    queryFn: () => API.getWorkspaceParameters(workspace),
+  } as const;
+}
+
+export function updateWorkspaceParameters(workspaceId: string) {
+  return {
+    mutationFn: (buildParameters: WorkspaceBuildParameter[]) =>
+      API.postWorkspaceBuild(workspaceId, {
+        transition: "start",
+        rich_parameter_values: buildParameters,
+      }),
+  } as const;
+}
+
 export function workspacesKey(config: WorkspacesRequest = {}) {
   const { q, limit } = config;
   return ["workspaces", { q, limit }] as const;
diff --git a/site/src/components/TemplateParameters/TemplateParameters.tsx b/site/src/components/TemplateParameters/TemplateParameters.tsx
index 9befc7c74051f..2213166b3ae71 100644
--- a/site/src/components/TemplateParameters/TemplateParameters.tsx
+++ b/site/src/components/TemplateParameters/TemplateParameters.tsx
@@ -17,68 +17,60 @@ export type TemplateParametersSectionProps = {
 export const MutableTemplateParametersSection: FC<
   TemplateParametersSectionProps
 > = ({ templateParameters, getInputProps, ...formSectionProps }) => {
-  const hasMutableParameters =
-    templateParameters.filter((p) => p.mutable).length > 0;
+  const mutableParameters = templateParameters.filter((p) => p.mutable);
+
+  if (mutableParameters.length === 0) {
+    return null;
+  }
 
   return (
-    <>
-      {hasMutableParameters && (
-        <FormSection
-          {...formSectionProps}
-          title="Parameters"
-          description="Settings used by your template"
-        >
-          <FormFields>
-            {templateParameters.map(
-              (parameter, index) =>
-                parameter.mutable && (
-                  <RichParameterInput
-                    {...getInputProps(parameter, index)}
-                    key={parameter.name}
-                    parameter={parameter}
-                  />
-                ),
-            )}
-          </FormFields>
-        </FormSection>
-      )}
-    </>
+    <FormSection
+      {...formSectionProps}
+      title="Parameters"
+      description="Settings used by your template"
+    >
+      <FormFields>
+        {mutableParameters.map((parameter, index) => (
+          <RichParameterInput
+            {...getInputProps(parameter, index)}
+            key={parameter.name}
+            parameter={parameter}
+          />
+        ))}
+      </FormFields>
+    </FormSection>
   );
 };
 
 export const ImmutableTemplateParametersSection: FC<
   TemplateParametersSectionProps
 > = ({ templateParameters, getInputProps, ...formSectionProps }) => {
-  const hasImmutableParameters =
-    templateParameters.filter((p) => !p.mutable).length > 0;
+  const immutableParams = templateParameters.filter((p) => !p.mutable);
+
+  if (immutableParams.length === 0) {
+    return null;
+  }
 
   return (
-    <>
-      {hasImmutableParameters && (
-        <FormSection
-          {...formSectionProps}
-          title="Immutable parameters"
-          description={
-            <>
-              These settings <strong>cannot be changed</strong> after creating
-              the workspace.
-            </>
-          }
-        >
-          <FormFields>
-            {templateParameters.map(
-              (parameter, index) =>
-                !parameter.mutable && (
-                  <RichParameterInput
-                    {...getInputProps(parameter, index)}
-                    key={parameter.name}
-                    parameter={parameter}
-                  />
-                ),
-            )}
-          </FormFields>
-        </FormSection>
-      )}
-    </>
+    <FormSection
+      {...formSectionProps}
+      title="Immutable parameters"
+      description={
+        <>
+          These settings <strong>cannot be changed</strong> after creating the
+          workspace.
+        </>
+      }
+    >
+      <FormFields>
+        {immutableParams.map((parameter, index) => (
+          <RichParameterInput
+            {...getInputProps(parameter, index)}
+            key={parameter.name}
+            parameter={parameter}
+          />
+        ))}
+      </FormFields>
+    </FormSection>
   );
 };
diff --git a/site/src/pages/CreateWorkspacePage/CreateWorkspacePage.tsx b/site/src/pages/CreateWorkspacePage/CreateWorkspacePage.tsx
index 2c6cff4807e81..045efa021fc39 100644
--- a/site/src/pages/CreateWorkspacePage/CreateWorkspacePage.tsx
+++ b/site/src/pages/CreateWorkspacePage/CreateWorkspacePage.tsx
@@ -24,125 +24,111 @@ import {
   templateVersionExternalAuth,
   richParameters,
 } from "api/queries/templates";
-import { autoCreateWorkspace, createWorkspace } from "api/queries/workspaces";
+import {
+  AutoCreateWorkspaceOptions,
+  autoCreateWorkspace,
+  createWorkspace,
+} from "api/queries/workspaces";
 import { checkAuthorization } from "api/queries/authCheck";
 import { CreateWSPermissions, createWorkspaceChecks } from "./permissions";
-import { paramsUsedToCreateWorkspace } from "utils/workspace";
 import { useEffectEvent } from "hooks/hookPolyfills";
+import { workspaceBuildParameters } from "api/queries/workspaceBuilds";
 
-type CreateWorkspaceMode = "form" | "auto";
+export const createWorkspaceModes = ["form", "auto", "duplicate"] as const;
+export type CreateWorkspaceMode = (typeof createWorkspaceModes)[number];
 
-export type ExternalAuthPollingState = "idle" | "polling" | "abandoned";
+export type ExternalAuthPollingStatus = "idle" | "polling" | "abandoned";
 
 const CreateWorkspacePage: FC = () => {
   const organizationId = useOrganizationId();
+  const [searchParams] = useSearchParams();
   const { template: templateName } = useParams() as { template: string };
-  const me = useMe();
   const navigate = useNavigate();
-  const [searchParams, setSearchParams] = useSearchParams();
-  const defaultBuildParameters = getDefaultBuildParameters(searchParams);
-  const mode = (searchParams.get("mode") ?? "form") as CreateWorkspaceMode;
-  const customVersionId = searchParams.get("version") ?? undefined;
-  const defaultName =
-    mode === "auto" ? generateUniqueName() : searchParams.get("name") ?? "";
+  const me = useMe();
 
   const queryClient = useQueryClient();
-  const autoCreateWorkspaceMutation = useMutation(
-    autoCreateWorkspace(queryClient),
-  );
   const createWorkspaceMutation = useMutation(createWorkspace(queryClient));
 
   const templateQuery = useQuery(templateByName(organizationId, templateName));
   const permissionsQuery = useQuery(
-    checkAuthorization({
-      checks: createWorkspaceChecks(organizationId),
-    }),
+    checkAuthorization({ checks: createWorkspaceChecks(organizationId) }),
   );
-  const realizedVersionId =
-    customVersionId ?? templateQuery.data?.active_version_id;
+
+  const versionId =
+    searchParams.get("version") ?? templateQuery.data?.active_version_id;
+
+  const { authList, pollingStatus, startPolling } = useExternalAuth(versionId);
   const richParametersQuery = useQuery({
-    ...richParameters(realizedVersionId ?? ""),
-    enabled: realizedVersionId !== undefined,
+    ...richParameters(versionId ?? ""),
+    enabled: versionId !== undefined,
   });
-  const realizedParameters = richParametersQuery.data
-    ? richParametersQuery.data.filter(paramsUsedToCreateWorkspace)
-    : undefined;
 
-  const { externalAuth, externalAuthPollingState, startPollingExternalAuth } =
-    useExternalAuth(realizedVersionId);
+  const defaultBuildParameters = getDefaultBuildParameters(searchParams);
+  const mode = getWorkspaceMode(searchParams);
+  const defaultName = getDefaultName(mode, searchParams);
+
+  const onCreateWorkspace = (workspace: Workspace) => {
+    navigate(`/@${workspace.owner_name}/${workspace.name}`);
+  };
+
+  const isAutoCreating = useAutomatedWorkspaceCreation({
+    auto: mode === "auto",
+    onSuccess: onCreateWorkspace,
+    payload: {
+      templateName,
+      organizationId,
+      defaultBuildParameters,
+      defaultName,
+      versionId,
+    },
+  });
 
   const isLoadingFormData =
     templateQuery.isLoading ||
     permissionsQuery.isLoading ||
     richParametersQuery.isLoading;
+
   const loadFormDataError =
     templateQuery.error ?? permissionsQuery.error ?? richParametersQuery.error;
 
-  const title = autoCreateWorkspaceMutation.isLoading
-    ? "Creating workspace..."
-    : "Create workspace";
-
-  const onCreateWorkspace = useCallback(
-    (workspace: Workspace) => {
-      navigate(`/@${workspace.owner_name}/${workspace.name}`);
-    },
-    [navigate],
-  );
-
-  const automateWorkspaceCreation = useEffectEvent(async () => {
-    try {
-      const newWorkspace = await autoCreateWorkspaceMutation.mutateAsync({
-        templateName,
-        organizationId,
-        defaultBuildParameters,
-        defaultName,
-        versionId: realizedVersionId,
-      });
-
-      onCreateWorkspace(newWorkspace);
-    } catch (err) {
-      searchParams.delete("mode");
-      setSearchParams(searchParams);
-    }
-  });
-
-  useEffect(() => {
-    if (mode === "auto") {
-      void automateWorkspaceCreation();
-    }
-  }, [automateWorkspaceCreation, mode]);
-
   return (
     <>
       <Helmet>
-        <title>{pageTitle(title)}</title>
+        <title>
+          {pageTitle(
+            isAutoCreating ? "Creating workspace..." : "Create workspace",
+          )}
+        </title>
       </Helmet>
+
       {loadFormDataError && <ErrorAlert error={loadFormDataError} />}
-      {isLoadingFormData || autoCreateWorkspaceMutation.isLoading ? (
+
+      {isLoadingFormData || isAutoCreating ? (
         <Loader />
       ) : (
         <CreateWorkspacePageView
+          mode={mode}
           defaultName={defaultName}
           defaultOwner={me}
           defaultBuildParameters={defaultBuildParameters}
           error={createWorkspaceMutation.error}
           template={templateQuery.data!}
-          versionId={realizedVersionId}
-          externalAuth={externalAuth ?? []}
-          externalAuthPollingState={externalAuthPollingState}
-          startPollingExternalAuth={startPollingExternalAuth}
+          versionId={versionId}
+          externalAuth={authList ?? []}
+          externalAuthPollingStatus={pollingStatus}
+          startPollingExternalAuth={startPolling}
           permissions={permissionsQuery.data as CreateWSPermissions}
-          parameters={realizedParameters as TemplateVersionParameter[]}
           creatingWorkspace={createWorkspaceMutation.isLoading}
-          onCancel={() => {
-            navigate(-1);
-          }}
+          onCancel={() => navigate(-1)}
+          parameters={richParametersQuery.data!.filter(
+            (param) => !param.ephemeral,
+          )}
           onSubmit={async (request, owner) => {
-            if (realizedVersionId) {
+            if (versionId) {
               request = {
                 ...request,
                 template_id: undefined,
-                template_version_id: realizedVersionId,
+                template_version_id: versionId,
               };
             }
 
@@ -160,78 +146,184 @@ const CreateWorkspacePage: FC = () => {
 };
 
 const useExternalAuth = (versionId: string | undefined) => {
-  const [externalAuthPollingState, setExternalAuthPollingState] =
-    useState<ExternalAuthPollingState>("idle");
+  const [pollingStatus, setPollingStatus] =
+    useState<ExternalAuthPollingStatus>("idle");
 
-  const startPollingExternalAuth = useCallback(() => {
-    setExternalAuthPollingState("polling");
+  const startPolling = useCallback(() => {
+    setPollingStatus("polling");
   }, []);
 
-  const { data: externalAuth } = useQuery(
+  const { data: authList } = useQuery(
     versionId
       ? {
           ...templateVersionExternalAuth(versionId),
-          refetchInterval:
-            externalAuthPollingState === "polling" ? 1000 : false,
+          refetchInterval: pollingStatus === "polling" ? 1000 : false,
         }
       : { enabled: false },
   );
 
-  const allSignedIn = externalAuth?.every((it) => it.authenticated);
-
   useEffect(() => {
-    if (allSignedIn) {
-      setExternalAuthPollingState("idle");
-      return;
-    }
-
-    if (externalAuthPollingState !== "polling") {
+    if (pollingStatus !== "polling") {
       return;
     }
 
-    // Poll for a maximum of one minute
-    const quitPolling = setTimeout(
-      () => setExternalAuthPollingState("abandoned"),
+    const timeoutId = window.setTimeout(
+      () => setPollingStatus("abandoned"),
       60_000,
     );
-    return () => {
-      clearTimeout(quitPolling);
-    };
-  }, [externalAuthPollingState, allSignedIn]);
 
-  return {
-    startPollingExternalAuth,
-    externalAuth,
-    externalAuthPollingState,
-  };
+    return () => clearTimeout(timeoutId);
+  }, [pollingStatus]);
+
+  const isAllSignedIn = authList?.every((it) => it.authenticated) ?? false;
+
+  // Doing state sync inline, because doing it inside a useEffect call would add
+  // unnecessary renders and re-painting.
+  if (isAllSignedIn && pollingStatus === "polling") {
+    setPollingStatus("idle");
+  }
+
+  return { authList, isAllSignedIn, pollingStatus, startPolling } as const;
+};
+
+function getWorkspaceMode(params: URLSearchParams): CreateWorkspaceMode {
+  const paramMode = params.get("mode");
+  if (createWorkspaceModes.includes(paramMode as CreateWorkspaceMode)) {
+    return paramMode as CreateWorkspaceMode;
+  }
+
+  return "form";
+}
+
+function getDefaultName(mode: CreateWorkspaceMode, params: URLSearchParams) {
+  if (mode === "auto") {
+    return generateUniqueName();
+  }
+
+  const paramsName = params.get("name");
+  if (mode === "duplicate" && paramsName) {
+    return `${paramsName}-copy`;
+  }
+
+  return paramsName ?? "";
+}
+
+type AutomatedWorkspaceConfig = {
+  auto: boolean;
+  payload: AutoCreateWorkspaceOptions;
+  onSuccess: (newWorkspace: Workspace) => void;
 };
 
+function useAutomatedWorkspaceCreation(config: AutomatedWorkspaceConfig) {
+  // Duplicates some of the hook calls from the parent, but that was preferable
+  // to having the function arguments balloon in complexity
+  const [searchParams, setSearchParams] = useSearchParams();
+  const queryClient = useQueryClient();
+  const autoCreateWorkspaceMutation = useMutation(
+    autoCreateWorkspace(queryClient),
+  );
+
+  const automateWorkspaceCreation = useEffectEvent(async () => {
+    try {
+      const newWorkspace = await autoCreateWorkspaceMutation.mutateAsync(
+        config.payload,
+      );
+
+      config.onSuccess(newWorkspace);
+    } catch (err) {
+      searchParams.delete("mode");
+      setSearchParams(searchParams);
+    }
+  });
+
+  useEffect(() => {
+    if (config.auto) {
+      void automateWorkspaceCreation();
+    }
+  }, [automateWorkspaceCreation, config.auto]);
+
+  return autoCreateWorkspaceMutation.isLoading;
+}
+
 const getDefaultBuildParameters = (
   urlSearchParams: URLSearchParams,
 ): WorkspaceBuildParameter[] => {
-  const buildValues: WorkspaceBuildParameter[] = [];
-  Array.from(urlSearchParams.keys())
+  return [...urlSearchParams.keys()]
     .filter((key) => key.startsWith("param."))
-    .forEach((key) => {
-      const name = key.replace("param.", "");
-      const value = urlSearchParams.get(key) ?? "";
-      buildValues.push({ name, value });
+    .map((key) => {
+      return {
+        name: key.replace("param.", ""),
+        value: urlSearchParams.get(key) ?? "",
+      };
     });
-  return buildValues;
 };
 
-export const orderedTemplateParameters = (
-  templateParameters?: TemplateVersionParameter[],
-): TemplateVersionParameter[] => {
-  if (!templateParameters) {
-    return [];
+function getDuplicationUrlParams(
+  workspaceParams: readonly WorkspaceBuildParameter[],
+  workspace: Workspace,
+): URLSearchParams {
+  // Record type makes sure that every property key added starts with "param.";
+  // page is also set up to parse params with this prefix for auto mode
+  const consolidatedParams: Record<`param.${string}`, string> = {};
+
+  for (const p of workspaceParams) {
+    consolidatedParams[`param.${p.name}`] = p.value;
   }
 
-  const immutables = templateParameters.filter(
-    (parameter) => !parameter.mutable,
+  return new URLSearchParams({
+    ...consolidatedParams,
+    mode: "duplicate" satisfies CreateWorkspaceMode,
+    name: workspace.name,
+    version: workspace.template_active_version_id,
+  });
+}
+
+/**
+ * Takes a workspace, and returns out a function that will navigate the user to
+ * the 'Create Workspace' page, pre-filling the form with as much information
+ * about the workspace as possible.
+ */
+// Meant to be consumed by components outside of this file
+export function useWorkspaceDuplication(workspace: Workspace) {
+  const navigate = useNavigate();
+  const buildParametersQuery = useQuery(
+    workspaceBuildParameters(workspace.latest_build.id),
   );
-  const mutables = templateParameters.filter((parameter) => parameter.mutable);
-  return [...immutables, ...mutables];
+
+  // Not using useEffectEvent for this, even with the slightly more complicated
+  // dependency array, because useEffect isn't really an intended use case
+  const duplicateWorkspace = useCallback(() => {
+    const buildParams = buildParametersQuery.data;
+    if (buildParams === undefined) {
+      return;
+    }
+
+    const newUrlParams = getDuplicationUrlParams(buildParams, workspace);
+
+    // Necessary for giving modals/popups time to flush their state changes and
+    // close the popup before actually navigating. Otherwise, you risk the modal
+    // awkwardly hanging there during the page transition
+    void Promise.resolve().then(() => {
+      navigate({
+        pathname: `/templates/${workspace.template_name}/workspace`,
+        search: newUrlParams.toString(),
+      });
+    });
+  }, [navigate, workspace, buildParametersQuery.data]);
+
+  return {
+    duplicateWorkspace,
+    duplicationReady: !buildParametersQuery.isLoading,
+  } as const;
+}
+
+export const orderTemplateParameters = (
+  templateParameters?: readonly TemplateVersionParameter[],
+) => {
+  return {
+    mutable: templateParameters?.filter((p) => p.mutable) ?? [],
+    immutable: templateParameters?.filter((p) => !p.mutable) ?? [],
+  } as const;
 };
 
 const generateUniqueName = () => {
diff --git a/site/src/pages/CreateWorkspacePage/CreateWorkspacePageView.tsx b/site/src/pages/CreateWorkspacePage/CreateWorkspacePageView.tsx
index a4afc25bfc4c2..627f4a14d0b44 100644
--- a/site/src/pages/CreateWorkspacePage/CreateWorkspacePageView.tsx
+++ b/site/src/pages/CreateWorkspacePage/CreateWorkspacePageView.tsx
@@ -2,7 +2,7 @@ import TextField from "@mui/material/TextField";
 import * as TypesGen from "api/typesGenerated";
 import { UserAutocomplete } from "components/UserAutocomplete/UserAutocomplete";
 import { FormikContextType, useFormik } from "formik";
-import { FC, useEffect, useState } from "react";
+import { type FC, useEffect, useState, useReducer } from "react";
 import {
   getFormHelpers,
   nameValidator,
@@ -20,7 +20,7 @@ import {
 import { makeStyles } from "@mui/styles";
 import {
   getInitialRichParameterValues,
-  useValidationSchemaForRichParameters,
+  validateRichParameters,
 } from "utils/richParameters";
 import {
   ImmutableTemplateParametersSection,
@@ -29,9 +29,15 @@ import {
 import { ExternalAuth } from "./ExternalAuth";
 import { ErrorAlert } from "components/Alert/ErrorAlert";
 import { Stack } from "components/Stack/Stack";
-import { type ExternalAuthPollingState } from "./CreateWorkspacePage";
 import { useSearchParams } from "react-router-dom";
 import { CreateWSPermissions } from "./permissions";
+import { useTheme } from "@emotion/react";
+import { Alert } from "components/Alert/Alert";
+import { Margins } from "components/Margins/Margins";
+import {
+  type ExternalAuthPollingStatus,
+  type CreateWorkspaceMode,
+} from "./CreateWorkspacePage";
 
 export interface CreateWorkspacePageViewProps {
   error: unknown;
@@ -40,13 +46,14 @@ export interface CreateWorkspacePageViewProps {
   template: TypesGen.Template;
   versionId?: string;
   externalAuth: TypesGen.TemplateVersionExternalAuth[];
-  externalAuthPollingState: ExternalAuthPollingState;
+  externalAuthPollingStatus: ExternalAuthPollingStatus;
   startPollingExternalAuth: () => void;
   parameters: TypesGen.TemplateVersionParameter[];
   defaultBuildParameters: TypesGen.WorkspaceBuildParameter[];
   permissions: CreateWSPermissions;
   creatingWorkspace: boolean;
   onCancel: () => void;
+  mode: CreateWorkspaceMode;
   onSubmit: (
     req: TypesGen.CreateWorkspaceRequest,
     owner: TypesGen.User,
@@ -60,7 +67,7 @@ export const CreateWorkspacePageView: FC<CreateWorkspacePageViewProps> = ({
   template,
   versionId,
   externalAuth,
-  externalAuthPollingState,
+  externalAuthPollingStatus,
   startPollingExternalAuth,
   parameters,
   defaultBuildParameters,
@@ -68,14 +75,14 @@ export const CreateWorkspacePageView: FC<CreateWorkspacePageViewProps> = ({
   creatingWorkspace,
   onSubmit,
   onCancel,
+  mode,
 }) => {
   const styles = useStyles();
   const [owner, setOwner] = useState(defaultOwner);
-  const { verifyExternalAuth, externalAuthErrors } =
-    useExternalAuthVerification(externalAuth);
   const [searchParams] = useSearchParams();
   const disabledParamsList = searchParams?.get("disable_params")?.split(",");
 
+  const authErrors = getAuthErrors(externalAuth);
   const form: FormikContextType<TypesGen.CreateWorkspaceRequest> =
     useFormik<TypesGen.CreateWorkspaceRequest>({
       initialValues: {
@@ -88,11 +95,13 @@ export const CreateWorkspacePageView: FC<CreateWorkspacePageViewProps> = ({
       },
       validationSchema: Yup.object({
         name: nameValidator("Workspace Name"),
-        rich_parameter_values: useValidationSchemaForRichParameters(parameters),
+        rich_parameter_values: validateRichParameters(parameters),
       }),
       enableReinitialize: true,
       onSubmit: (request) => {
-        if (!verifyExternalAuth()) {
+        const errorCount = Object.keys(authErrors).length;
+        if (errorCount > 0) {
+          form.setSubmitting(false);
           return;
         }
 
@@ -112,172 +121,186 @@ export const CreateWorkspacePageView: FC<CreateWorkspacePageViewProps> = ({
   );
 
   return (
-    <FullPageHorizontalForm title="New workspace" onCancel={onCancel}>
-      <HorizontalForm onSubmit={form.handleSubmit}>
-        {Boolean(error) && <ErrorAlert error={error} />}
-        {/* General info */}
-        <FormSection
-          title="General"
-          description="The template and name of your new workspace."
-        >
-          <FormFields>
-            <SelectedTemplate template={template} />
-            {versionId && versionId !== template.active_version_id && (
-              <Stack spacing={1} className={styles.hasDescription}>
-                <TextField
-                  disabled
-                  fullWidth
-                  value={versionId}
-                  label="Version ID"
-                />
-                <span className={styles.description}>
-                  This parameter has been preset, and cannot be modified.
-                </span>
-              </Stack>
-            )}
-            <TextField
-              {...getFieldHelpers("name")}
-              disabled={creatingWorkspace}
-              onChange={onChangeTrimmed(form)}
-              autoFocus
-              fullWidth
-              label="Workspace Name"
-            />
-          </FormFields>
-        </FormSection>
+    <>
+      {mode === "duplicate" && <DuplicateWarningMessage />}
+
+      <FullPageHorizontalForm title="New workspace" onCancel={onCancel}>
+        <HorizontalForm onSubmit={form.handleSubmit}>
+          {Boolean(error) && <ErrorAlert error={error} />}
 
-        {permissions.createWorkspaceForUser && (
+          {/* General info */}
           <FormSection
-            title="Workspace Owner"
-            description="Only admins can create workspace for other users."
+            title="General"
+            description="The template and name of your new workspace."
           >
             <FormFields>
-              <UserAutocomplete
-                value={owner}
-                onChange={(user) => {
-                  setOwner(user ?? defaultOwner);
-                }}
-                label="Owner"
-                size="medium"
+              <SelectedTemplate template={template} />
+              {versionId && versionId !== template.active_version_id && (
+                <Stack spacing={1} className={styles.hasDescription}>
+                  <TextField
+                    disabled
+                    fullWidth
+                    value={versionId}
+                    label="Version ID"
+                  />
+                  <span className={styles.description}>
+                    This parameter has been preset, and cannot be modified.
+                  </span>
+                </Stack>
+              )}
+              <TextField
+                {...getFieldHelpers("name")}
+                disabled={creatingWorkspace}
+                onChange={onChangeTrimmed(form)}
+                autoFocus
+                fullWidth
+                label="Workspace Name"
               />
             </FormFields>
           </FormSection>
-        )}
 
-        {externalAuth && externalAuth.length > 0 && (
-          <FormSection
-            title="External Authentication"
-            description="This template requires authentication to external services."
-          >
-            <FormFields>
-              {externalAuth.map((auth) => (
-                <ExternalAuth
-                  key={auth.id}
-                  authenticateURL={auth.authenticate_url}
-                  authenticated={auth.authenticated}
-                  externalAuthPollingState={externalAuthPollingState}
-                  startPollingExternalAuth={startPollingExternalAuth}
-                  displayName={auth.display_name}
-                  displayIcon={auth.display_icon}
-                  error={externalAuthErrors[auth.id]}
+          {permissions.createWorkspaceForUser && (
+            <FormSection
+              title="Workspace Owner"
+              description="Only admins can create workspace for other users."
+            >
+              <FormFields>
+                <UserAutocomplete
+                  value={owner}
+                  onChange={(user) => {
+                    setOwner(user ?? defaultOwner);
+                  }}
+                  label="Owner"
+                  size="medium"
                 />
-              ))}
-            </FormFields>
-          </FormSection>
-        )}
+              </FormFields>
+            </FormSection>
+          )}
+
+          {externalAuth && externalAuth.length > 0 && (
+            <FormSection
+              title="External Authentication"
+              description="This template requires authentication to external services."
+            >
+              <FormFields>
+                {externalAuth.map((auth) => (
+                  <ExternalAuth
+                    key={auth.id}
+                    authenticateURL={auth.authenticate_url}
+                    authenticated={auth.authenticated}
+                    externalAuthPollingState={externalAuthPollingStatus}
+                    startPollingExternalAuth={startPollingExternalAuth}
+                    displayName={auth.display_name}
+                    displayIcon={auth.display_icon}
+                    error={authErrors[auth.id]}
+                  />
+                ))}
+              </FormFields>
+            </FormSection>
+          )}
+
+          {parameters && (
+            <>
+              <MutableTemplateParametersSection
+                templateParameters={parameters}
+                getInputProps={(parameter, index) => {
+                  return {
+                    ...getFieldHelpers(
+                      "rich_parameter_values[" + index + "].value",
+                    ),
+                    onChange: async (value) => {
+                      await form.setFieldValue(
+                        "rich_parameter_values." + index,
+                        {
+                          name: parameter.name,
+                          value: value,
+                        },
+                      );
+                    },
+                    disabled:
+                      disabledParamsList?.includes(
+                        parameter.name.toLowerCase().replace(/ /g, "_"),
+                      ) || form.isSubmitting,
+                  };
+                }}
+              />
 
-        {parameters && (
-          <>
-            <MutableTemplateParametersSection
-              templateParameters={parameters}
-              getInputProps={(parameter, index) => {
-                return {
-                  ...getFieldHelpers(
-                    "rich_parameter_values[" + index + "].value",
-                  ),
-                  onChange: async (value) => {
-                    await form.setFieldValue("rich_parameter_values." + index, {
-                      name: parameter.name,
-                      value: value,
-                    });
-                  },
-                  disabled:
-                    disabledParamsList?.includes(
-                      parameter.name.toLowerCase().replace(/ /g, "_"),
-                    ) || creatingWorkspace,
-                };
-              }}
-            />
-            <ImmutableTemplateParametersSection
-              templateParameters={parameters}
-              classes={{ root: styles.warningSection }}
-              getInputProps={(parameter, index) => {
-                return {
-                  ...getFieldHelpers(
-                    "rich_parameter_values[" + index + "].value",
-                  ),
-                  onChange: async (value) => {
-                    await form.setFieldValue("rich_parameter_values." + index, {
-                      name: parameter.name,
-                      value: value,
-                    });
-                  },
-                  disabled:
-                    disabledParamsList?.includes(
-                      parameter.name.toLowerCase().replace(/ /g, "_"),
-                    ) || creatingWorkspace,
-                };
-              }}
-            />
-          </>
-        )}
+              <ImmutableTemplateParametersSection
+                templateParameters={parameters}
+                classes={{ root: styles.warningSection }}
+                getInputProps={(parameter, index) => {
+                  return {
+                    ...getFieldHelpers(
+                      "rich_parameter_values[" + index + "].value",
+                    ),
+                    onChange: async (value) => {
+                      await form.setFieldValue(
+                        "rich_parameter_values." + index,
+                        {
+                          name: parameter.name,
+                          value: value,
+                        },
+                      );
+                    },
+                    disabled:
+                      disabledParamsList?.includes(
+                        parameter.name.toLowerCase().replace(/ /g, "_"),
+                      ) || form.isSubmitting,
+                  };
+                }}
+              />
+            </>
+          )}
 
-        <FormFooter
-          onCancel={onCancel}
-          isLoading={creatingWorkspace}
-          submitLabel="Create Workspace"
-        />
-      </HorizontalForm>
-    </FullPageHorizontalForm>
+          <FormFooter
+            onCancel={onCancel}
+            isLoading={creatingWorkspace}
+            submitLabel="Create Workspace"
+          />
+        </HorizontalForm>
+      </FullPageHorizontalForm>
+    </>
   );
 };
 
-type ExternalAuthErrors = Record<string, string>;
+function getAuthErrors(
+  authList: readonly TypesGen.TemplateVersionExternalAuth[],
+): Readonly<Record<string, string>> {
+  const authErrors: Record<string, string> = {};
 
-const useExternalAuthVerification = (
-  externalAuth: TypesGen.TemplateVersionExternalAuth[],
-) => {
-  const [externalAuthErrors, setExternalAuthErrors] =
-    useState<ExternalAuthErrors>({});
-
-  // Clear errors when externalAuth is refreshed
-  useEffect(() => {
-    setExternalAuthErrors({});
-  }, [externalAuth]);
+  for (const auth of authList) {
+    if (!auth.authenticated) {
+      authErrors[auth.id] = "You must authenticate to create a workspace!";
+    }
+  }
 
-  const verifyExternalAuth = () => {
-    const errors: ExternalAuthErrors = {};
+  return authErrors;
+}
 
-    for (let i = 0; i < externalAuth.length; i++) {
-      const auth = externalAuth.at(i);
-      if (!auth) {
-        continue;
-      }
-      if (!auth.authenticated) {
-        errors[auth.id] = "You must authenticate to create a workspace!";
-      }
-    }
+function DuplicateWarningMessage() {
+  const [isDismissed, dismiss] = useReducer(() => true, false);
+  const theme = useTheme();
 
-    setExternalAuthErrors(errors);
-    const isValid = Object.keys(errors).length === 0;
-    return isValid;
-  };
+  if (isDismissed) {
+    return null;
+  }
 
-  return {
-    externalAuthErrors,
-    verifyExternalAuth,
-  };
-};
+  // Setup looks a little hokey (having an Alert already fully configured to
+  // listen to dismissals, on top of more dismissal state), but relying solely
+  // on the Alert API wouldn't get rid of the div and horizontal margin helper
+  // after the dismiss happens. Not using CSS margins because those can be a
+  // style maintenance nightmare over time
+  return (
+    <div css={{ paddingTop: theme.spacing(6) }}>
+      <Margins size="medium">
+        <Alert severity="warning" dismissible onDismiss={dismiss}>
+          Duplicating a workspace only copies its parameters. No state from the
+          old workspace is copied over.
+        </Alert>
+      </Margins>
+    </div>
+  );
+}
 
 const useStyles = makeStyles((theme) => ({
   hasDescription: {
diff --git a/site/src/pages/CreateWorkspacePage/ExternalAuth.tsx b/site/src/pages/CreateWorkspacePage/ExternalAuth.tsx
index 41dde1b8420ab..e9d85d17311cb 100644
--- a/site/src/pages/CreateWorkspacePage/ExternalAuth.tsx
+++ b/site/src/pages/CreateWorkspacePage/ExternalAuth.tsx
@@ -5,14 +5,14 @@ import Tooltip from "@mui/material/Tooltip";
 import { type FC } from "react";
 import { LoadingButton } from "components/LoadingButton/LoadingButton";
 import { Stack } from "components/Stack/Stack";
-import { type ExternalAuthPollingState } from "./CreateWorkspacePage";
+import { type ExternalAuthPollingStatus } from "./CreateWorkspacePage";
 
 export interface ExternalAuthProps {
   displayName: string;
   displayIcon: string;
   authenticated: boolean;
   authenticateURL: string;
-  externalAuthPollingState: ExternalAuthPollingState;
+  externalAuthPollingState: ExternalAuthPollingStatus;
   startPollingExternalAuth: () => void;
   error?: string;
 }
diff --git a/site/src/pages/TemplatesPage/TemplatesPageView.tsx b/site/src/pages/TemplatesPage/TemplatesPageView.tsx
index 14834849a1bd3..9ebecbc27018b 100644
--- a/site/src/pages/TemplatesPage/TemplatesPageView.tsx
+++ b/site/src/pages/TemplatesPage/TemplatesPageView.tsx
@@ -120,6 +120,7 @@ const TemplateRow: FC<{ template: Template }> = ({ template }) => {
 
       <TableCell className={styles.actionCell}>
         <Button
+          type="button"
           size="small"
           className={styles.actionButton}
           startIcon={<ArrowForwardOutlined />}
diff --git a/site/src/pages/WorkspacePage/UpdateBuildParametersDialog.tsx b/site/src/pages/WorkspacePage/UpdateBuildParametersDialog.tsx
index f91f807ac8a17..63cf5ef498649 100644
--- a/site/src/pages/WorkspacePage/UpdateBuildParametersDialog.tsx
+++ b/site/src/pages/WorkspacePage/UpdateBuildParametersDialog.tsx
@@ -19,7 +19,7 @@ import type {
 import { RichParameterInput } from "components/RichParameterInput/RichParameterInput";
 import {
   getInitialRichParameterValues,
-  useValidationSchemaForRichParameters,
+  validateRichParameters,
 } from "utils/richParameters";
 
 export type UpdateBuildParametersDialogProps = DialogProps & {
@@ -37,8 +37,7 @@ export const UpdateBuildParametersDialog: FC<
       rich_parameter_values: getInitialRichParameterValues(missedParameters),
     },
     validationSchema: Yup.object({
-      rich_parameter_values:
-        useValidationSchemaForRichParameters(missedParameters),
+      rich_parameter_values: validateRichParameters(missedParameters),
     }),
     onSubmit: (values) => {
       onUpdate(values.rich_parameter_values);
diff --git a/site/src/pages/WorkspacePage/Workspace.stories.tsx b/site/src/pages/WorkspacePage/Workspace.stories.tsx
index d77bff78c5875..7ef67ac0911eb 100644
--- a/site/src/pages/WorkspacePage/Workspace.stories.tsx
+++ b/site/src/pages/WorkspacePage/Workspace.stories.tsx
@@ -3,7 +3,7 @@ import { Meta, StoryObj } from "@storybook/react";
 import { WatchAgentMetadataContext } from "components/Resources/AgentMetadata";
 import { ProvisionerJobLog } from "api/typesGenerated";
 import * as Mocks from "testHelpers/entities";
-import { Workspace, WorkspaceErrors } from "./Workspace";
+import { Workspace } from "./Workspace";
 import { withReactContext } from "storybook-react-context";
 import EventSource from "eventsourcemock";
 import { ProxyContext, getPreferredProxy } from "contexts/ProxyContext";
@@ -133,7 +133,7 @@ export const Failed: Story = {
     ...Running.args,
     workspace: Mocks.MockFailedWorkspace,
     workspaceErrors: {
-      [WorkspaceErrors.BUILD_ERROR]: Mocks.mockApiError({
+      buildError: Mocks.mockApiError({
         message: "A workspace build is already active.",
       }),
     },
@@ -216,7 +216,7 @@ export const GetBuildsError: Story = {
   args: {
     ...Running.args,
     workspaceErrors: {
-      [WorkspaceErrors.GET_BUILDS_ERROR]: Mocks.mockApiError({
+      getBuildsError: Mocks.mockApiError({
         message: "There is a problem fetching builds.",
       }),
     },
@@ -227,7 +227,7 @@ export const CancellationError: Story = {
   args: {
     ...Failed.args,
     workspaceErrors: {
-      [WorkspaceErrors.CANCELLATION_ERROR]: Mocks.mockApiError({
+      cancellationError: Mocks.mockApiError({
         message: "Job could not be canceled.",
       }),
     },
diff --git a/site/src/pages/WorkspacePage/Workspace.tsx b/site/src/pages/WorkspacePage/Workspace.tsx
index 7dbcd6cc0527a..569384cb3f54d 100644
--- a/site/src/pages/WorkspacePage/Workspace.tsx
+++ b/site/src/pages/WorkspacePage/Workspace.tsx
@@ -30,11 +30,11 @@ import { BuildsTable } from "./BuildsTable";
 import { WorkspaceDeletedBanner } from "./WorkspaceDeletedBanner";
 import { WorkspaceStats } from "./WorkspaceStats";
 
-export enum WorkspaceErrors {
-  GET_BUILDS_ERROR = "getBuildsError",
-  BUILD_ERROR = "buildError",
-  CANCELLATION_ERROR = "cancellationError",
-}
+export type WorkspaceError =
+  | "getBuildsError"
+  | "buildError"
+  | "cancellationError";
+
 export interface WorkspaceProps {
   scheduleProps: {
     onDeadlinePlus: (hours: number) => void;
@@ -62,7 +62,7 @@ export interface WorkspaceProps {
   canChangeVersions: boolean;
   hideSSHButton?: boolean;
   hideVSCodeDesktopButton?: boolean;
-  workspaceErrors: Partial<Record<WorkspaceErrors, unknown>>;
+  workspaceErrors: Partial<Record<WorkspaceError, unknown>>;
   buildInfo?: TypesGen.BuildInfoResponse;
   sshPrefix?: string;
   template?: TypesGen.Template;
@@ -116,20 +116,12 @@ export const Workspace: FC<React.PropsWithChildren<WorkspaceProps>> = ({
   const serverVersion = buildInfo?.version || "";
   const { saveLocal, getLocal } = useLocalStorage();
 
-  const buildError = Boolean(workspaceErrors[WorkspaceErrors.BUILD_ERROR]) && (
-    <ErrorAlert
-      error={workspaceErrors[WorkspaceErrors.BUILD_ERROR]}
-      dismissible
-    />
+  const buildError = Boolean(workspaceErrors.buildError) && (
+    <ErrorAlert error={workspaceErrors.buildError} dismissible />
   );
 
-  const cancellationError = Boolean(
-    workspaceErrors[WorkspaceErrors.CANCELLATION_ERROR],
-  ) && (
-    <ErrorAlert
-      error={workspaceErrors[WorkspaceErrors.CANCELLATION_ERROR]}
-      dismissible
-    />
+  const cancellationError = Boolean(workspaceErrors.cancellationError) && (
+    <ErrorAlert error={workspaceErrors.cancellationError} dismissible />
   );
 
   let transitionStats: TypesGen.TransitionStats | undefined = undefined;
@@ -341,10 +333,8 @@ export const Workspace: FC<React.PropsWithChildren<WorkspaceProps>> = ({
             />
           )}
 
-          {workspaceErrors[WorkspaceErrors.GET_BUILDS_ERROR] ? (
-            <ErrorAlert
-              error={workspaceErrors[WorkspaceErrors.GET_BUILDS_ERROR]}
-            />
+          {workspaceErrors.getBuildsError ? (
+            <ErrorAlert error={workspaceErrors.getBuildsError} />
           ) : (
             <BuildsTable
               builds={builds}
diff --git a/site/src/pages/WorkspacePage/WorkspaceActions/WorkspaceActions.tsx b/site/src/pages/WorkspacePage/WorkspaceActions/WorkspaceActions.tsx
index 04d2744530b90..ead67790309d3 100644
--- a/site/src/pages/WorkspacePage/WorkspaceActions/WorkspaceActions.tsx
+++ b/site/src/pages/WorkspacePage/WorkspaceActions/WorkspaceActions.tsx
@@ -1,9 +1,10 @@
-import MenuItem from "@mui/material/MenuItem";
-import Menu from "@mui/material/Menu";
-import { makeStyles } from "@mui/styles";
-import MoreVertOutlined from "@mui/icons-material/MoreVertOutlined";
-import { FC, Fragment, ReactNode, useRef, useState } from "react";
-import { Workspace, WorkspaceBuildParameter } from "api/typesGenerated";
+import { type FC, Fragment, type ReactNode, useRef, useState } from "react";
+import { ButtonMapping, actionsByWorkspaceStatus } from "./constants";
+import {
+  type Workspace,
+  type WorkspaceBuildParameter,
+} from "api/typesGenerated";
+
 import {
   ActionLoadingButton,
   CancelButton,
@@ -14,16 +15,19 @@ import {
   UpdateButton,
   ActivateButton,
 } from "./Buttons";
-import {
-  ButtonMapping,
-  ButtonTypesEnum,
-  actionsByWorkspaceStatus,
-} from "./constants";
-import SettingsOutlined from "@mui/icons-material/SettingsOutlined";
-import HistoryOutlined from "@mui/icons-material/HistoryOutlined";
-import DeleteOutlined from "@mui/icons-material/DeleteOutlined";
+
+import { makeStyles } from "@mui/styles";
+import Menu from "@mui/material/Menu";
+import MenuItem from "@mui/material/MenuItem";
 import IconButton from "@mui/material/IconButton";
 
+import SettingsIcon from "@mui/icons-material/SettingsOutlined";
+import HistoryIcon from "@mui/icons-material/HistoryOutlined";
+import DeleteIcon from "@mui/icons-material/DeleteOutlined";
+import MoreOptionsIcon from "@mui/icons-material/MoreVertOutlined";
+import DuplicateIcon from "@mui/icons-material/FileCopyOutlined";
+import { useWorkspaceDuplication } from "pages/CreateWorkspacePage/CreateWorkspacePage";
+
 export interface WorkspaceActionsProps {
   workspace: Workspace;
   handleStart: (buildParameters?: WorkspaceBuildParameter[]) => void;
@@ -56,71 +60,66 @@ export const WorkspaceActions: FC<WorkspaceActionsProps> = ({
   isRestarting,
   canChangeVersions,
 }) => {
-  const styles = useStyles();
-  const {
-    canCancel,
-    canAcceptJobs,
-    actions: actionsByStatus,
-  } = actionsByWorkspaceStatus(workspace, workspace.latest_build.status);
-  const canBeUpdated = workspace.outdated && canAcceptJobs;
-  const menuTriggerRef = useRef<HTMLButtonElement>(null);
-  const [isMenuOpen, setIsMenuOpen] = useState(false);
-
   // A mapping of button type to the corresponding React component
   const buttonMapping: ButtonMapping = {
-    [ButtonTypesEnum.update]: <UpdateButton handleAction={handleUpdate} />,
-    [ButtonTypesEnum.updating]: (
-      <UpdateButton loading handleAction={handleUpdate} />
-    ),
-    [ButtonTypesEnum.start]: (
-      <StartButton workspace={workspace} handleAction={handleStart} />
-    ),
-    [ButtonTypesEnum.starting]: (
+    update: <UpdateButton handleAction={handleUpdate} />,
+    updating: <UpdateButton loading handleAction={handleUpdate} />,
+    start: <StartButton workspace={workspace} handleAction={handleStart} />,
+    starting: (
       <StartButton loading workspace={workspace} handleAction={handleStart} />
     ),
-    [ButtonTypesEnum.stop]: <StopButton handleAction={handleStop} />,
-    [ButtonTypesEnum.stopping]: (
-      <StopButton loading handleAction={handleStop} />
-    ),
-    [ButtonTypesEnum.restart]: (
+    stop: <StopButton handleAction={handleStop} />,
+    stopping: <StopButton loading handleAction={handleStop} />,
+    restart: (
       <RestartButton workspace={workspace} handleAction={handleRestart} />
     ),
-    [ButtonTypesEnum.restarting]: (
+    restarting: (
       <RestartButton
         loading
         workspace={workspace}
         handleAction={handleRestart}
       />
     ),
-    [ButtonTypesEnum.deleting]: <ActionLoadingButton label="Deleting" />,
-    [ButtonTypesEnum.canceling]: <DisabledButton label="Canceling..." />,
-    [ButtonTypesEnum.deleted]: <DisabledButton label="Deleted" />,
-    [ButtonTypesEnum.pending]: <ActionLoadingButton label="Pending..." />,
-    [ButtonTypesEnum.activate]: (
-      <ActivateButton handleAction={handleDormantActivate} />
-    ),
-    [ButtonTypesEnum.activating]: (
-      <ActivateButton loading handleAction={handleDormantActivate} />
-    ),
+    deleting: <ActionLoadingButton label="Deleting" />,
+    canceling: <DisabledButton label="Canceling..." />,
+    deleted: <DisabledButton label="Deleted" />,
+    pending: <ActionLoadingButton label="Pending..." />,
+    activate: <ActivateButton handleAction={handleDormantActivate} />,
+    activating: <ActivateButton loading handleAction={handleDormantActivate} />,
   };
 
+  const styles = useStyles();
+  const menuTriggerRef = useRef<HTMLButtonElement>(null);
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
+
+  const { duplicateWorkspace, duplicationReady } =
+    useWorkspaceDuplication(workspace);
+
   // Returns a function that will execute the action and close the menu
   const onMenuItemClick = (actionFn: () => void) => () => {
     setIsMenuOpen(false);
     actionFn();
   };
 
+  const {
+    canCancel,
+    canAcceptJobs,
+    actions: actionsByStatus,
+  } = actionsByWorkspaceStatus(workspace, workspace.latest_build.status);
+  const canBeUpdated = workspace.outdated && canAcceptJobs;
+
   return (
     <div className={styles.actions} data-testid="workspace-actions">
       {canBeUpdated &&
-        (isUpdating
-          ? buttonMapping[ButtonTypesEnum.updating]
-          : buttonMapping[ButtonTypesEnum.update])}
-      {isRestarting && buttonMapping[ButtonTypesEnum.restarting]}
+        (isUpdating ? buttonMapping.updating : buttonMapping.update)}
+
+      {isRestarting && buttonMapping.restarting}
+
       {!isRestarting &&
         actionsByStatus.map((action) => (
           <Fragment key={action}>{buttonMapping[action]}</Fragment>
         ))}
+
       {canCancel && <CancelButton handleAction={handleCancel} />}
       <div>
         <IconButton
@@ -133,8 +132,9 @@ export const WorkspaceActions: FC<WorkspaceActionsProps> = ({
           ref={menuTriggerRef}
           onClick={() => setIsMenuOpen(true)}
         >
-          <MoreVertOutlined />
+          <MoreOptionsIcon />
         </IconButton>
+
         <Menu
           id="workspace-options"
           anchorEl={menuTriggerRef.current}
@@ -142,20 +142,30 @@ export const WorkspaceActions: FC<WorkspaceActionsProps> = ({
           onClose={() => setIsMenuOpen(false)}
         >
           <MenuItem onClick={onMenuItemClick(handleSettings)}>
-            <SettingsOutlined />
+            <SettingsIcon />
             Settings
           </MenuItem>
+
           {canChangeVersions && (
             <MenuItem onClick={onMenuItemClick(handleChangeVersion)}>
-              <HistoryOutlined />
+              <HistoryIcon />
               Change version&hellip;
             </MenuItem>
           )}
+
+          <MenuItem
+            onClick={onMenuItemClick(duplicateWorkspace)}
+            disabled={!duplicationReady}
+          >
+            <DuplicateIcon />
+            Duplicate&hellip;
+          </MenuItem>
+
           <MenuItem
             onClick={onMenuItemClick(handleDelete)}
             data-testid="delete-button"
           >
-            <DeleteOutlined />
+            <DeleteIcon />
             Delete&hellip;
           </MenuItem>
         </Menu>
diff --git a/site/src/pages/WorkspacePage/WorkspaceActions/constants.ts b/site/src/pages/WorkspacePage/WorkspaceActions/constants.ts
index d6f2704a18f80..19274346d539a 100644
--- a/site/src/pages/WorkspacePage/WorkspaceActions/constants.ts
+++ b/site/src/pages/WorkspacePage/WorkspaceActions/constants.ts
@@ -1,31 +1,27 @@
-import { Workspace, WorkspaceStatus } from "api/typesGenerated";
-import { ReactNode } from "react";
+import { type Workspace, type WorkspaceStatus } from "api/typesGenerated";
+import { type ReactElement } from "react";
 
-// the button types we have
-export enum ButtonTypesEnum {
-  start = "start",
-  starting = "starting",
-  stop = "stop",
-  stopping = "stopping",
-  restart = "restart",
-  restarting = "restarting",
-  deleting = "deleting",
-  update = "update",
-  updating = "updating",
-  activate = "activate",
-  activating = "activating",
-  // disabled buttons
-  canceling = "canceling",
-  deleted = "deleted",
-  pending = "pending",
-}
+/**
+ * Buttons supported by workspace actions. Canceling, Deleted, and Pending
+ * should all be associated with disabled states
+ */
+export type ButtonType =
+  | Exclude<WorkspaceStatus, "failed" | "canceled" | "running" | "stopped">
+  | "start"
+  | "stop"
+  | "restart"
+  | "restarting"
+  | "update"
+  | "updating"
+  | "activate"
+  | "activating";
 
 export type ButtonMapping = {
-  [key in ButtonTypesEnum]: ReactNode;
+  [key in ButtonType]: ReactElement;
 };
 
 interface WorkspaceAbilities {
-  actions: ButtonTypesEnum[];
+  actions: readonly ButtonType[];
   canCancel: boolean;
   canAcceptJobs: boolean;
 }
@@ -36,7 +32,7 @@ export const actionsByWorkspaceStatus = (
 ): WorkspaceAbilities => {
   if (workspace.dormant_at) {
     return {
-      actions: [ButtonTypesEnum.activate],
+      actions: ["activate"],
       canCancel: false,
       canAcceptJobs: false,
     };
@@ -44,35 +40,35 @@ export const actionsByWorkspaceStatus = (
   return statusToActions[status];
 };
 
-const statusToActions: Record<WorkspaceStatus, WorkspaceAbilities> = {
+const statusToActions = {
   starting: {
-    actions: [ButtonTypesEnum.starting],
+    actions: ["starting"],
     canCancel: true,
     canAcceptJobs: false,
   },
   running: {
-    actions: [ButtonTypesEnum.stop, ButtonTypesEnum.restart],
+    actions: ["stop", "restart"],
     canCancel: false,
     canAcceptJobs: true,
   },
   stopping: {
-    actions: [ButtonTypesEnum.stopping],
+    actions: ["stopping"],
     canCancel: true,
     canAcceptJobs: false,
   },
   stopped: {
-    actions: [ButtonTypesEnum.start],
+    actions: ["start"],
     canCancel: false,
     canAcceptJobs: true,
   },
   canceled: {
-    actions: [ButtonTypesEnum.start, ButtonTypesEnum.stop],
+    actions: ["start", "stop"],
     canCancel: false,
     canAcceptJobs: true,
   },
   // in the case of an error
   failed: {
-    actions: [ButtonTypesEnum.start, ButtonTypesEnum.stop],
+    actions: ["start", "stop"],
     canCancel: false,
     canAcceptJobs: true,
   },
@@ -80,23 +76,23 @@ const statusToActions: Record<WorkspaceStatus, WorkspaceAbilities> = {
    * disabled states
    */
   canceling: {
-    actions: [ButtonTypesEnum.canceling],
+    actions: ["canceling"],
     canCancel: false,
     canAcceptJobs: false,
   },
   deleting: {
-    actions: [ButtonTypesEnum.deleting],
+    actions: ["deleting"],
     canCancel: true,
     canAcceptJobs: false,
   },
   deleted: {
-    actions: [ButtonTypesEnum.deleted],
+    actions: ["deleted"],
     canCancel: false,
     canAcceptJobs: false,
   },
   pending: {
-    actions: [ButtonTypesEnum.pending],
+    actions: ["pending"],
     canCancel: false,
     canAcceptJobs: false,
   },
-};
+} as const satisfies Record<WorkspaceStatus, WorkspaceAbilities>;
diff --git a/site/src/pages/WorkspacePage/WorkspaceReadyPage.tsx b/site/src/pages/WorkspacePage/WorkspaceReadyPage.tsx
index f332ea78500f2..e7fb62eb47591 100644
--- a/site/src/pages/WorkspacePage/WorkspaceReadyPage.tsx
+++ b/site/src/pages/WorkspacePage/WorkspaceReadyPage.tsx
@@ -2,7 +2,7 @@ import { useActor } from "@xstate/react";
 import { useDashboard } from "components/Dashboard/DashboardProvider";
 import dayjs from "dayjs";
 import { useFeatureVisibility } from "hooks/useFeatureVisibility";
-import { FC, useEffect, useState } from "react";
+import { type FC, useEffect, useState } from "react";
 import { Helmet } from "react-helmet-async";
 import { useNavigate } from "react-router-dom";
 import {
@@ -13,7 +13,7 @@ import {
 } from "utils/schedule";
 import { StateFrom } from "xstate";
 import { DeleteDialog } from "components/Dialogs/DeleteDialog/DeleteDialog";
-import { Workspace, WorkspaceErrors } from "./Workspace";
+import { Workspace } from "./Workspace";
 import { pageTitle } from "utils/page";
 import { getFaviconByStatus, hasJobError } from "utils/workspace";
 import {
@@ -56,11 +56,6 @@ export const WorkspaceReadyPage = ({
   isLoadingMoreBuilds,
   hasMoreBuilds,
 }: WorkspaceReadyPageProps): JSX.Element => {
-  const [_, bannerSend] = useActor(
-    workspaceState.children["scheduleBannerMachine"],
-  );
-  const { buildInfo } = useDashboard();
-  const featureVisibility = useFeatureVisibility();
   const {
     workspace,
     template,
@@ -72,17 +67,22 @@ export const WorkspaceReadyPage = ({
     permissions,
     missedParameters,
   } = workspaceState.context;
+
+  // Breaks the rules of hooks, but if we're throwing an error, the rules won't
+  // even have a chance to matter. Best to get the check out of the way early
+  // for better type narrowing
   if (workspace === undefined) {
     throw Error("Workspace is undefined");
   }
-  const deadline = getDeadline(workspace);
-  const canUpdateWorkspace = Boolean(permissions?.updateWorkspace);
-  const canUpdateTemplate = Boolean(permissions?.updateTemplate);
-  const canRetryDebugMode =
-    Boolean(permissions?.viewDeploymentValues) &&
-    Boolean(deploymentValues?.enable_terraform_debug_mode);
-  const favicon = getFaviconByStatus(workspace.latest_build);
+
+  const { buildInfo } = useDashboard();
+  const featureVisibility = useFeatureVisibility();
   const navigate = useNavigate();
+
+  const [_, bannerSend] = useActor(
+    workspaceState.children["scheduleBannerMachine"],
+  );
+
   const [changeVersionDialogOpen, setChangeVersionDialogOpen] = useState(false);
   const [isConfirmingUpdate, setIsConfirmingUpdate] = useState(false);
   const [confirmingRestart, setConfirmingRestart] = useState<{
@@ -90,29 +90,19 @@ export const WorkspaceReadyPage = ({
     buildParameters?: TypesGen.WorkspaceBuildParameter[];
   }>({ open: false });
 
-  const { data: allVersions } = useQuery({
+  const { data: allTemplateVersions } = useQuery({
     ...templateVersions(workspace.template_id),
     enabled: changeVersionDialogOpen,
   });
-  const { data: latestVersion } = useQuery({
+
+  const { data: latestTemplateVersion } = useQuery({
     ...templateVersion(workspace.template_active_version_id),
     enabled: workspace.outdated,
   });
-  const [faviconTheme, setFaviconTheme] = useState<"light" | "dark">("dark");
-  useEffect(() => {
-    if (typeof window === "undefined" || !window.matchMedia) {
-      return;
-    }
-    const isDark = window.matchMedia("(prefers-color-scheme: dark)");
-    // We want the favicon the opposite of the theme.
-    setFaviconTheme(isDark ? "light" : "dark");
-  }, []);
+
   const buildLogs = useWorkspaceBuildLogs(workspace.latest_build.id);
-  const shouldDisplayBuildLogs =
-    hasJobError(workspace) ||
-    ["canceling", "deleting", "pending", "starting", "stopping"].includes(
-      workspace.latest_build.status,
-    );
+  const faviconTheme = useFaviconTheme();
+
   const {
     mutate: mutateRestartWorkspace,
     error: restartBuildError,
@@ -120,11 +110,26 @@ export const WorkspaceReadyPage = ({
   } = useMutation({
     mutationFn: restartWorkspace,
   });
+
   // keep banner machine in sync with workspace
   useEffect(() => {
     bannerSend({ type: "REFRESH_WORKSPACE", workspace });
   }, [bannerSend, workspace]);
 
+  const favicon = getFaviconByStatus(workspace.latest_build);
+  const deadline = getDeadline(workspace);
+  const canUpdateWorkspace = Boolean(permissions?.updateWorkspace);
+  const canUpdateTemplate = Boolean(permissions?.updateTemplate);
+  const canRetryDebugMode =
+    Boolean(permissions?.viewDeploymentValues) &&
+    Boolean(deploymentValues?.enable_terraform_debug_mode);
+
+  const shouldDisplayBuildLogs =
+    hasJobError(workspace) ||
+    ["canceling", "deleting", "pending", "starting", "stopping"].includes(
+      workspace.latest_build.status,
+    );
+
   return (
     <>
       <Helmet>
@@ -188,15 +193,15 @@ export const WorkspaceReadyPage = ({
         isLoadingMoreBuilds={isLoadingMoreBuilds}
         hasMoreBuilds={hasMoreBuilds}
         canUpdateWorkspace={canUpdateWorkspace}
-        updateMessage={latestVersion?.message}
+        updateMessage={latestTemplateVersion?.message}
         canRetryDebugMode={canRetryDebugMode}
         canChangeVersions={canUpdateTemplate}
         hideSSHButton={featureVisibility["browser_only"]}
         hideVSCodeDesktopButton={featureVisibility["browser_only"]}
         workspaceErrors={{
-          [WorkspaceErrors.GET_BUILDS_ERROR]: buildsError,
-          [WorkspaceErrors.BUILD_ERROR]: buildError || restartBuildError,
-          [WorkspaceErrors.CANCELLATION_ERROR]: cancellationError,
+          getBuildsError: buildsError,
+          buildError: buildError || restartBuildError,
+          cancellationError: cancellationError,
         }}
         buildInfo={buildInfo}
         sshPrefix={sshPrefix}
@@ -234,9 +239,9 @@ export const WorkspaceReadyPage = ({
         }}
       />
       <ChangeVersionDialog
-        templateVersions={allVersions?.reverse()}
+        templateVersions={allTemplateVersions?.reverse()}
         template={template}
-        defaultTemplateVersion={allVersions?.find(
+        defaultTemplateVersion={allTemplateVersions?.find(
           (v) => workspace.latest_build.template_version_id === v.id,
         )}
         open={changeVersionDialogOpen}
@@ -266,8 +271,8 @@ export const WorkspaceReadyPage = ({
               Restarting your workspace will stop all running processes and{" "}
               <strong>delete non-persistent data</strong>.
             </p>
-            {latestVersion?.message && (
-              <Alert severity="info">{latestVersion.message}</Alert>
+            {latestTemplateVersion?.message && (
+              <Alert severity="info">{latestTemplateVersion.message}</Alert>
             )}
           </Stack>
         }
@@ -296,6 +301,21 @@ export const WorkspaceReadyPage = ({
   );
 };
 
+function useFaviconTheme() {
+  const [faviconTheme, setFaviconTheme] = useState<"light" | "dark">("dark");
+
+  useEffect(() => {
+    if (typeof window === "undefined" || !window.matchMedia) {
+      return;
+    }
+    const isDark = window.matchMedia("(prefers-color-scheme: dark)");
+    // We want the favicon the opposite of the theme.
+    setFaviconTheme(isDark ? "light" : "dark");
+  }, []);
+
+  return faviconTheme;
+}
+
 const WarningDialog: FC<
   Pick<
     ConfirmDialogProps,
diff --git a/site/src/pages/WorkspaceSettingsPage/WorkspaceParametersPage/WorkspaceParametersForm.tsx b/site/src/pages/WorkspaceSettingsPage/WorkspaceParametersPage/WorkspaceParametersForm.tsx
index e281a740ed9ce..ebb284e29608f 100644
--- a/site/src/pages/WorkspaceSettingsPage/WorkspaceParametersPage/WorkspaceParametersForm.tsx
+++ b/site/src/pages/WorkspaceSettingsPage/WorkspaceParametersPage/WorkspaceParametersForm.tsx
@@ -9,7 +9,7 @@ import { useFormik } from "formik";
 import { FC } from "react";
 import {
   getInitialRichParameterValues,
-  useValidationSchemaForRichParameters,
+  validateRichParameters,
 } from "utils/richParameters";
 import * as Yup from "yup";
 import { getFormHelpers } from "utils/formUtils";
@@ -46,7 +46,7 @@ export const WorkspaceParametersForm: FC<{
       ),
     },
     validationSchema: Yup.object({
-      rich_parameter_values: useValidationSchemaForRichParameters(
+      rich_parameter_values: validateRichParameters(
         templateVersionRichParameters,
       ),
     }),
diff --git a/site/src/pages/WorkspaceSettingsPage/WorkspaceParametersPage/WorkspaceParametersPage.tsx b/site/src/pages/WorkspaceSettingsPage/WorkspaceParametersPage/WorkspaceParametersPage.tsx
index c7656c8ea04d2..b8edaac6e7df2 100644
--- a/site/src/pages/WorkspaceSettingsPage/WorkspaceParametersPage/WorkspaceParametersPage.tsx
+++ b/site/src/pages/WorkspaceSettingsPage/WorkspaceParametersPage/WorkspaceParametersPage.tsx
@@ -1,4 +1,4 @@
-import { getWorkspaceParameters, postWorkspaceBuild } from "api/api";
+import { getWorkspaceParameters } from "api/api";
 import { Helmet } from "react-helmet-async";
 import { pageTitle } from "utils/page";
 import { useWorkspaceSettings } from "../WorkspaceSettingsLayout";
@@ -13,7 +13,10 @@ import { PageHeader, PageHeaderTitle } from "components/PageHeader/PageHeader";
 import { FC } from "react";
 import { isApiValidationError } from "api/errors";
 import { ErrorAlert } from "components/Alert/ErrorAlert";
-import { WorkspaceBuildParameter } from "api/typesGenerated";
+import {
+  updateWorkspaceParameters,
+  workspaceParameters,
+} from "api/queries/workspaces";
 import { EmptyState } from "components/EmptyState/EmptyState";
 import Button from "@mui/material/Button";
 import OpenInNewOutlined from "@mui/icons-material/OpenInNewOutlined";
@@ -21,17 +24,11 @@ import { docs } from "utils/docs";
 
 const WorkspaceParametersPage = () => {
   const workspace = useWorkspaceSettings();
-  const parameters = useQuery({
-    queryKey: ["workspace", workspace.id, "parameters"],
-    queryFn: () => getWorkspaceParameters(workspace),
-  });
+  const parameters = useQuery(workspaceParameters(workspace));
   const navigate = useNavigate();
+
   const updateParameters = useMutation({
-    mutationFn: (buildParameters: WorkspaceBuildParameter[]) =>
-      postWorkspaceBuild(workspace.id, {
-        transition: "start",
-        rich_parameter_values: buildParameters,
-      }),
+    ...updateWorkspaceParameters(workspace.id),
     onSuccess: () => {
       navigate(`/${workspace.owner_name}/${workspace.name}`);
     },
diff --git a/site/src/testHelpers/handlers.ts b/site/src/testHelpers/handlers.ts
index 8bc5dabba16c4..cc16cfeab9c2d 100644
--- a/site/src/testHelpers/handlers.ts
+++ b/site/src/testHelpers/handlers.ts
@@ -71,6 +71,12 @@ export const handlers = [
       return res(ctx.status(200), ctx.json([M.MockTemplate]));
     },
   ),
+  rest.post(
+    "/api/v2/organizations/:organizationId/members/:userId/workspaces",
+    async (req, res, ctx) => {
+      return res(ctx.status(200), ctx.json(M.MockWorkspace));
+    },
+  ),
 
   // templates
   rest.get("/api/v2/templates/:templateId", async (req, res, ctx) => {
diff --git a/site/src/utils/richParameters.ts b/site/src/utils/richParameters.ts
index d63da7c4ee530..64a9e0d5638bd 100644
--- a/site/src/utils/richParameters.ts
+++ b/site/src/utils/richParameters.ts
@@ -5,24 +5,27 @@ import {
 import * as Yup from "yup";
 
 export const getInitialRichParameterValues = (
-  templateParameters: TemplateVersionParameter[],
-  buildParameters?: WorkspaceBuildParameter[],
+  templateParameters: readonly TemplateVersionParameter[],
+  buildParameters?: readonly WorkspaceBuildParameter[],
 ): WorkspaceBuildParameter[] => {
-  return templateParameters.map((parameter) => {
-    const existentBuildParameter = buildParameters?.find(
-      (p) => p.name === parameter.name,
+  return templateParameters.map((templateParam) => {
+    const matchedBuildParam = buildParameters?.find(
+      (buildParam) => buildParam.name === templateParam.name,
     );
-    const shouldReturnTheDefaultValue =
-      !existentBuildParameter ||
-      !isValidValue(parameter, existentBuildParameter) ||
-      parameter.ephemeral;
-    if (shouldReturnTheDefaultValue) {
-      return {
-        name: parameter.name,
-        value: parameter.default_value,
-      };
+
+    const shouldOverrideTemplate =
+      matchedBuildParam !== undefined &&
+      isValidValue(templateParam, matchedBuildParam) &&
+      !templateParam.ephemeral;
+
+    if (shouldOverrideTemplate) {
+      return matchedBuildParam;
     }
-    return existentBuildParameter;
+
+    return {
+      name: templateParam.name,
+      value: templateParam.default_value,
+    };
   });
 };
 
@@ -38,7 +41,7 @@ const isValidValue = (
   return true;
 };
 
-export const useValidationSchemaForRichParameters = (
+export const validateRichParameters = (
   templateParameters?: TemplateVersionParameter[],
   lastBuildParameters?: WorkspaceBuildParameter[],
 ): Yup.AnySchema => {