diff --git a/packages/toolpad-app/pages/api/rpc.ts b/packages/toolpad-app/pages/api/rpc.ts
index 3a651d858f0..a6622a1e5e4 100644
--- a/packages/toolpad-app/pages/api/rpc.ts
+++ b/packages/toolpad-app/pages/api/rpc.ts
@@ -18,6 +18,8 @@ import {
   findActiveDeployment,
   findLastRelease,
   deleteApp,
+  deploy,
+  getDeployments,
 } from '../../src/server/data';
 import { hasOwnProperty } from '../../src/utils/collections';
 
@@ -117,6 +119,9 @@ const rpcServer = {
     getActiveDeployments: createMethod<typeof getActiveDeployments>((params) => {
       return getActiveDeployments(...params);
     }),
+    getDeployments: createMethod<typeof getDeployments>((params) => {
+      return getDeployments(...params);
+    }),
     getApp: createMethod<typeof getApp>((params) => {
       return getApp(...params);
     }),
@@ -155,6 +160,9 @@ const rpcServer = {
     createDeployment: createMethod<typeof createDeployment>((params) => {
       return createDeployment(...params);
     }),
+    deploy: createMethod<typeof deploy>((params) => {
+      return deploy(...params);
+    }),
     saveDom: createMethod<typeof saveDom>((params) => {
       return saveDom(...params);
     }),
diff --git a/packages/toolpad-app/src/server/data.ts b/packages/toolpad-app/src/server/data.ts
index c3b0f63eae5..2a144bd3334 100644
--- a/packages/toolpad-app/src/server/data.ts
+++ b/packages/toolpad-app/src/server/data.ts
@@ -1,12 +1,6 @@
 import { NodeId, BindableAttrValue } from '@mui/toolpad-core';
 import * as _ from 'lodash-es';
-import {
-  App,
-  DomNodeAttributeType,
-  PrismaClient,
-  Release,
-  Prisma,
-} from '../../prisma/generated/client';
+import * as prisma from '../../prisma/generated/client';
 import { ServerDataSource, ApiResult, VersionOrPreview } from '../types';
 import serverDataSources from '../toolpadDataSources/server';
 import * as appDom from '../appDom';
@@ -14,43 +8,30 @@ import { omit } from '../utils/immutability';
 import { asArray } from '../utils/collections';
 import { decryptSecret, encryptSecret } from './secrets';
 import applyTransform from './applyTransform';
+import { excludeFields } from '../utils/prisma';
 
-// See https://github.com/prisma/prisma/issues/5042#issuecomment-1104679760
-function excludeFields<T, K extends (keyof T)[]>(
-  fields: T,
-  excluded: K,
-): Record<Exclude<keyof T, K[number]>, boolean> {
-  const result = {} as Record<Exclude<keyof T, K[number]>, boolean>;
-  for (const key of Object.keys(fields)) {
-    if (!excluded.includes(key as any)) {
-      result[key as Exclude<keyof T, K[number]>] = true;
-    }
-  }
-  return result;
-}
+const SELECT_RELEASE_META = excludeFields(prisma.Prisma.ReleaseScalarFieldEnum, ['snapshot']);
+const SELECT_APP_META = excludeFields(prisma.Prisma.AppScalarFieldEnum, ['dom']);
 
-const SELECT_RELEASE_META = excludeFields(Prisma.ReleaseScalarFieldEnum, ['snapshot']);
-const SELECT_APP_META = excludeFields(Prisma.AppScalarFieldEnum, ['dom']);
+export type AppMeta = Omit<prisma.App, 'dom'>;
 
-export type AppMeta = Omit<App, 'dom'>;
-
-function getPrismaClient(): PrismaClient {
+function getPrismaClient(): prisma.PrismaClient {
   if (process.env.NODE_ENV === 'production') {
-    return new PrismaClient();
+    return new prisma.PrismaClient();
   }
 
   // avoid Next.js dev server from creating too many prisma clients
   // See https://github.com/prisma/prisma/issues/1983
   if (!(globalThis as any).prisma) {
-    (globalThis as any).prisma = new PrismaClient();
+    (globalThis as any).prisma = new prisma.PrismaClient();
   }
 
   return (globalThis as any).prisma;
 }
 
-const prisma = getPrismaClient();
+const prismaClient = getPrismaClient();
 
-function deserializeValue(dbValue: string, type: DomNodeAttributeType): unknown {
+function deserializeValue(dbValue: string, type: prisma.DomNodeAttributeType): unknown {
   const serialized = type === 'secret' ? decryptSecret(dbValue) : dbValue;
   return serialized.length <= 0 ? undefined : JSON.parse(serialized);
 }
@@ -90,7 +71,7 @@ function decryptSecrets(dom: appDom.AppDom): appDom.AppDom {
 }
 
 export async function saveDom(appId: string, app: appDom.AppDom): Promise<void> {
-  await prisma.app.update({
+  await prismaClient.app.update({
     where: {
       id: appId,
     },
@@ -100,7 +81,7 @@ export async function saveDom(appId: string, app: appDom.AppDom): Promise<void>
 }
 
 async function loadPreviewDomLegacy(appId: string): Promise<appDom.AppDom> {
-  const dbNodes = await prisma.domNode.findMany({
+  const dbNodes = await prismaClient.domNode.findMany({
     where: { appId },
     include: { attributes: true },
   });
@@ -146,7 +127,7 @@ async function loadPreviewDomLegacy(appId: string): Promise<appDom.AppDom> {
 }
 
 async function loadPreviewDom(appId: string): Promise<appDom.AppDom> {
-  const { dom } = await prisma.app.findUniqueOrThrow({
+  const { dom } = await prismaClient.app.findUniqueOrThrow({
     where: { id: appId },
   });
 
@@ -158,7 +139,7 @@ async function loadPreviewDom(appId: string): Promise<appDom.AppDom> {
 }
 
 export async function getApps(): Promise<AppMeta[]> {
-  return prisma.app.findMany({
+  return prismaClient.app.findMany({
     orderBy: {
       editedAt: 'desc',
     },
@@ -167,14 +148,14 @@ export async function getApps(): Promise<AppMeta[]> {
 }
 
 export async function getActiveDeployments() {
-  return prisma.deployment.findMany({
+  return prismaClient.deployment.findMany({
     distinct: ['appId'],
     orderBy: { createdAt: 'desc' },
   });
 }
 
 export async function getApp(id: string): Promise<AppMeta | null> {
-  return prisma.app.findUnique({ where: { id }, select: SELECT_APP_META });
+  return prismaClient.app.findUnique({ where: { id }, select: SELECT_APP_META });
 }
 
 function createDefaultDom(): appDom.AppDom {
@@ -198,9 +179,9 @@ export interface CreateAppOptions {
   dom?: appDom.AppDom | null;
 }
 
-export async function createApp(name: string, opts: CreateAppOptions = {}): Promise<App> {
-  return prisma.$transaction(async () => {
-    const app = await prisma.app.create({
+export async function createApp(name: string, opts: CreateAppOptions = {}): Promise<prisma.App> {
+  return prismaClient.$transaction(async () => {
+    const app = await prismaClient.app.create({
       data: { name },
     });
 
@@ -213,7 +194,7 @@ export async function createApp(name: string, opts: CreateAppOptions = {}): Prom
 }
 
 export async function updateApp(appId: string, name: string): Promise<void> {
-  await prisma.app.update({
+  await prismaClient.app.update({
     where: {
       id: appId,
     },
@@ -226,7 +207,7 @@ export async function updateApp(appId: string, name: string): Promise<void> {
 }
 
 export async function deleteApp(id: string): Promise<void> {
-  await prisma.app.delete({
+  await prismaClient.app.delete({
     where: { id },
     select: {
       // Only return the id to reduce amount of data returned from the db
@@ -235,19 +216,21 @@ export async function deleteApp(id: string): Promise<void> {
   });
 }
 
-interface CreateReleaseParams {
+export interface CreateReleaseParams {
   description: string;
 }
 
+export type ReleaseMeta = Pick<prisma.Release, keyof typeof SELECT_RELEASE_META>;
+
 async function findLastReleaseInternal(appId: string) {
-  return prisma.release.findFirst({
+  return prismaClient.release.findFirst({
     where: { appId },
     orderBy: { version: 'desc' },
   });
 }
 
-export async function findLastRelease(appId: string) {
-  return prisma.release.findFirst({
+export async function findLastRelease(appId: string): Promise<ReleaseMeta | null> {
+  return prismaClient.release.findFirst({
     where: { appId },
     orderBy: { version: 'desc' },
     select: SELECT_RELEASE_META,
@@ -257,14 +240,14 @@ export async function findLastRelease(appId: string) {
 export async function createRelease(
   appId: string,
   { description }: CreateReleaseParams,
-): Promise<Pick<Release, keyof typeof SELECT_RELEASE_META>> {
+): Promise<ReleaseMeta> {
   const currentDom = await loadPreviewDom(appId);
   const snapshot = Buffer.from(JSON.stringify(currentDom), 'utf-8');
 
   const lastRelease = await findLastReleaseInternal(appId);
   const versionNumber = lastRelease ? lastRelease.version + 1 : 1;
 
-  const release = await prisma.release.create({
+  const release = await prismaClient.release.create({
     select: SELECT_RELEASE_META,
     data: {
       appId,
@@ -277,8 +260,8 @@ export async function createRelease(
   return release;
 }
 
-export async function getReleases(appId: string) {
-  return prisma.release.findMany({
+export async function getReleases(appId: string): Promise<ReleaseMeta[]> {
+  return prismaClient.release.findMany({
     where: { appId },
     select: SELECT_RELEASE_META,
     orderBy: {
@@ -287,15 +270,31 @@ export async function getReleases(appId: string) {
   });
 }
 
-export async function getRelease(appId: string, version: number) {
-  return prisma.release.findUnique({
+export async function getRelease(appId: string, version: number): Promise<ReleaseMeta | null> {
+  return prismaClient.release.findUnique({
     where: { release_app_constraint: { appId, version } },
     select: SELECT_RELEASE_META,
   });
 }
 
-export async function createDeployment(appId: string, version: number) {
-  return prisma.deployment.create({
+export type Deployment = prisma.Deployment & {
+  release: ReleaseMeta;
+};
+
+export function getDeployments(appId: string): Promise<Deployment[]> {
+  return prismaClient.deployment.findMany({
+    where: { appId },
+    orderBy: { createdAt: 'desc' },
+    include: {
+      release: {
+        select: SELECT_RELEASE_META,
+      },
+    },
+  });
+}
+
+export async function createDeployment(appId: string, version: number): Promise<Deployment> {
+  return prismaClient.deployment.create({
     data: {
       app: {
         connect: { id: appId },
@@ -304,11 +303,25 @@ export async function createDeployment(appId: string, version: number) {
         connect: { release_app_constraint: { appId, version } },
       },
     },
+    include: {
+      release: {
+        select: SELECT_RELEASE_META,
+      },
+    },
   });
 }
 
-export async function findActiveDeployment(appId: string) {
-  return prisma.deployment.findFirst({
+export async function deploy(
+  appId: string,
+  releaseInput: CreateReleaseParams,
+): Promise<Deployment> {
+  const release = await createRelease(appId, releaseInput);
+  const deployment = await createDeployment(appId, release.version);
+  return deployment;
+}
+
+export async function findActiveDeployment(appId: string): Promise<Deployment | null> {
+  return prismaClient.deployment.findFirst({
     where: { appId },
     orderBy: { createdAt: 'desc' },
     include: {
@@ -320,7 +333,7 @@ export async function findActiveDeployment(appId: string) {
 }
 
 export async function loadReleaseDom(appId: string, version: number): Promise<appDom.AppDom> {
-  const release = await prisma.release.findUnique({
+  const release = await prismaClient.release.findUnique({
     where: { release_app_constraint: { appId, version } },
   });
   if (!release) {
diff --git a/packages/toolpad-app/src/toolpad/AppEditor/AppEditorShell.tsx b/packages/toolpad-app/src/toolpad/AppEditor/AppEditorShell.tsx
index 4e69033aa81..3a6b3dd28df 100644
--- a/packages/toolpad-app/src/toolpad/AppEditor/AppEditorShell.tsx
+++ b/packages/toolpad-app/src/toolpad/AppEditor/AppEditorShell.tsx
@@ -8,7 +8,6 @@ import {
   DialogActions,
   DialogContent,
   DialogTitle,
-  IconButton,
   Stack,
   TextField,
   Tooltip,
@@ -17,14 +16,16 @@ import {
 import CloudDoneIcon from '@mui/icons-material/CloudDone';
 import * as React from 'react';
 import { useForm } from 'react-hook-form';
-import { Outlet, useNavigate } from 'react-router-dom';
+import { Outlet } from 'react-router-dom';
 import OpenInNewIcon from '@mui/icons-material/OpenInNew';
 import RocketLaunchIcon from '@mui/icons-material/RocketLaunch';
+import invariant from 'invariant';
 import DialogForm from '../../components/DialogForm';
 import { useDomLoader } from '../DomLoader';
-import ToolpadAppShell from '../ToolpadAppShell';
+import ToolpadShell from '../ToolpadShell';
 import PagePanel from './PagePanel';
 import client from '../../api';
+import useBoolean from '../../utils/useBoolean';
 
 interface CreateReleaseDialogProps {
   appId: string;
@@ -33,8 +34,6 @@ interface CreateReleaseDialogProps {
 }
 
 function CreateReleaseDialog({ appId, open, onClose }: CreateReleaseDialogProps) {
-  const navigate = useNavigate();
-
   const lastRelease = client.useQuery('findLastRelease', [appId]);
 
   const { handleSubmit, register, formState, reset } = useForm({
@@ -43,32 +42,32 @@ function CreateReleaseDialog({ appId, open, onClose }: CreateReleaseDialogProps)
     },
   });
 
-  const createReleaseMutation = client.useMutation('createRelease');
+  React.useEffect(() => {
+    if (open) {
+      reset();
+    }
+  }, [reset, open]);
+
+  const deployMutation = client.useMutation('deploy');
   const doSubmit = handleSubmit(async (releaseParams) => {
-    const newRelease = await createReleaseMutation.mutateAsync([appId, releaseParams]);
-    reset();
-    navigate(`/app/${appId}/releases/${newRelease.version}`);
+    await deployMutation.mutateAsync([appId, releaseParams]);
+    const url = new URL(`/deploy/${appId}/pages`, window.location.href);
+    const deploymentWindow = window.open(url, '_blank');
+    invariant(deploymentWindow, 'window failed to open');
+    deploymentWindow.focus();
+    onClose();
   });
 
   return (
     <Dialog open={open} onClose={onClose}>
       <DialogForm autoComplete="off" onSubmit={doSubmit}>
-        <DialogTitle>Create new release</DialogTitle>
+        <DialogTitle>Deploy application</DialogTitle>
         <DialogContent>
           {lastRelease.isSuccess ? (
             <Stack spacing={1}>
               <Typography>
-                You are about to create a snapshot of your application under a unique url. You will
-                be able to verify whether everything is working correctly before deploying this
-                release to production.
-              </Typography>
-              <Typography>
-                The new version to be created is &quot;
-                {lastRelease.data ? lastRelease.data.version + 1 : 1}&quot;.
-              </Typography>
-              <Typography>
-                Please summarize the changes you have made to the application since the last
-                release:
+                You are about to deploy your application to production. Please summarize the changes
+                you have made to the application since the last release:
               </Typography>
               <TextField
                 label="description"
@@ -83,8 +82,8 @@ function CreateReleaseDialog({ appId, open, onClose }: CreateReleaseDialogProps)
             </Stack>
           ) : null}
 
-          {createReleaseMutation.isError ? (
-            <Alert severity="error">{(createReleaseMutation.error as Error).message}</Alert>
+          {deployMutation.isError ? (
+            <Alert severity="error">{(deployMutation.error as Error).message}</Alert>
           ) : null}
         </DialogContent>
         <DialogActions>
@@ -93,10 +92,10 @@ function CreateReleaseDialog({ appId, open, onClose }: CreateReleaseDialogProps)
           </Button>
           <LoadingButton
             disabled={!lastRelease.isSuccess}
-            loading={createReleaseMutation.isLoading}
+            loading={deployMutation.isLoading}
             type="submit"
           >
-            Create
+            Deploy
           </LoadingButton>
         </DialogActions>
       </DialogForm>
@@ -114,22 +113,25 @@ function getSaveStateMessage(isSaving: boolean, hasUnsavedChanges: boolean): str
   return 'All changes saved!';
 }
 
-export interface ToolpadAppShellProps {
+export interface ToolpadShellProps {
   appId: string;
   actions?: React.ReactNode;
 }
 
-export default function AppEditorShell({ appId, ...props }: ToolpadAppShellProps) {
+export default function AppEditorShell({ appId, ...props }: ToolpadShellProps) {
   const domLoader = useDomLoader();
 
-  const [createReleaseDialogOpen, setCreateReleaseDialogOpen] = React.useState(false);
+  const {
+    value: createReleaseDialogOpen,
+    setTrue: handleCreateReleasDialogOpen,
+    setFalse: handleCreateReleasDialogClose,
+  } = useBoolean(false);
 
   const hasUnsavedChanges = domLoader.unsavedChanges > 0;
   const isSaving = domLoader.saving;
 
   return (
-    <ToolpadAppShell
-      appId={appId}
+    <ToolpadShell
       actions={
         <Stack direction="row" gap={1} alignItems="center">
           <Tooltip title={getSaveStateMessage(isSaving, hasUnsavedChanges)}>
@@ -144,15 +146,9 @@ export default function AppEditorShell({ appId, ...props }: ToolpadAppShellProps
               )}
             </Box>
           </Tooltip>
-          <IconButton
-            aria-label="Create release"
-            color="inherit"
-            onClick={() => setCreateReleaseDialogOpen(true)}
-          >
-            <RocketLaunchIcon />
-          </IconButton>
           <Button
             variant="outlined"
+            color="inherit"
             component="a"
             href={`/app/${appId}/preview`}
             target="_blank"
@@ -160,6 +156,14 @@ export default function AppEditorShell({ appId, ...props }: ToolpadAppShellProps
           >
             Preview
           </Button>
+          <Button
+            variant="outlined"
+            color="inherit"
+            onClick={handleCreateReleasDialogOpen}
+            endIcon={<RocketLaunchIcon />}
+          >
+            Deploy
+          </Button>
         </Stack>
       }
       {...props}
@@ -193,9 +197,9 @@ export default function AppEditorShell({ appId, ...props }: ToolpadAppShellProps
         <CreateReleaseDialog
           appId={appId}
           open={createReleaseDialogOpen}
-          onClose={() => setCreateReleaseDialogOpen(false)}
+          onClose={handleCreateReleasDialogClose}
         />
       </Box>
-    </ToolpadAppShell>
+    </ToolpadShell>
   );
 }
diff --git a/packages/toolpad-app/src/toolpad/Release.tsx b/packages/toolpad-app/src/toolpad/Release.tsx
deleted file mode 100644
index 4ad7f8a65cf..00000000000
--- a/packages/toolpad-app/src/toolpad/Release.tsx
+++ /dev/null
@@ -1,164 +0,0 @@
-import {
-  Button,
-  Container,
-  Toolbar,
-  Typography,
-  Paper,
-  Breadcrumbs,
-  Link as MuiLink,
-  Stack,
-} from '@mui/material';
-import * as React from 'react';
-import OpenInNewIcon from '@mui/icons-material/OpenInNew';
-import RocketLaunchIcon from '@mui/icons-material/RocketLaunch';
-import { Link, useParams } from 'react-router-dom';
-import client from '../api';
-import ToolpadAppShell from './ToolpadAppShell';
-import DefinitionList from '../components/DefinitionList';
-import useLatest from '../utils/useLatest';
-import useDialog from '../utils/useDialog';
-import { ConfirmDialog } from '../components/SystemDialogs';
-
-function getDeploymentStatusMessage(version: number, activeVersion?: number): React.ReactNode {
-  if (typeof activeVersion === 'undefined') {
-    return <Typography>App is not deployed</Typography>;
-  }
-
-  return version === activeVersion ? (
-    <Typography>This is the deployed release</Typography>
-  ) : (
-    <Typography>
-      <MuiLink component={Link} to={`../releases/${activeVersion}`}>
-        Version &quot;{activeVersion}&quot;
-      </MuiLink>{' '}
-      is currently deployed
-    </Typography>
-  );
-}
-
-interface ConfirmDeployDialogProps {
-  data?: {
-    version: number;
-  };
-  open: boolean;
-  onClose: (confirm: boolean) => void;
-}
-
-function ConfirmDeployDialog({ open, onClose, data: dataProp }: ConfirmDeployDialogProps) {
-  const data = useLatest(dataProp);
-
-  return data ? (
-    <ConfirmDialog open={open} onClose={onClose} okButton="deploy">
-      Press &quot;Deploy&quot; to change the canonical URL of your application to
-      version&nbsp;&quot;{data.version}&quot;.
-    </ConfirmDialog>
-  ) : null;
-}
-
-interface ActiveReleaseMessageProps {
-  appId: string;
-  version: number;
-  activeVersion?: number;
-}
-
-function DeploymentStatus({ appId, activeVersion, version }: ActiveReleaseMessageProps) {
-  const msg: React.ReactNode = getDeploymentStatusMessage(version, activeVersion);
-  const isActiveDeployment = activeVersion === version;
-
-  const deployReleaseMutation = client.useMutation('createDeployment');
-
-  const { element, show: showConfirmDialog } = useDialog(ConfirmDeployDialog);
-
-  const handleDeployClick = React.useCallback(async () => {
-    const ok = await showConfirmDialog({ version });
-
-    if (!ok) {
-      return;
-    }
-
-    if (version) {
-      await deployReleaseMutation.mutateAsync([appId, version]);
-      client.invalidateQueries('findActiveDeployment', [appId]);
-    }
-  }, [appId, deployReleaseMutation, showConfirmDialog, version]);
-
-  const canDeploy = deployReleaseMutation.isIdle && !isActiveDeployment;
-  const isNewerVersion = version >= (activeVersion ?? -Infinity);
-
-  return (
-    <React.Fragment>
-      {msg}
-      <Toolbar disableGutters sx={{ gap: 1 }}>
-        <Button
-          variant={isActiveDeployment ? 'contained' : 'outlined'}
-          component="a"
-          href={`/deploy/${appId}`}
-          target="_blank"
-          endIcon={<OpenInNewIcon />}
-        >
-          Open
-        </Button>
-        <Button
-          variant={canDeploy ? 'contained' : 'outlined'}
-          color={isNewerVersion ? 'primary' : 'error'}
-          disabled={!canDeploy}
-          onClick={handleDeployClick}
-          startIcon={<RocketLaunchIcon />}
-        >
-          {isNewerVersion ? 'Deploy' : 'Rollback to'} version &quot;
-          {version}&quot;
-        </Button>
-      </Toolbar>
-      {element}
-    </React.Fragment>
-  );
-}
-
-export default function Release() {
-  const { version: rawVersion, appId } = useParams();
-  const version = Number(rawVersion);
-
-  if (!appId) {
-    throw new Error(`Missing queryParam "appId"`);
-  }
-
-  const releaseQuery = client.useQuery('getRelease', [appId, version]);
-
-  const activeDeploymentQuery = client.useQuery('findActiveDeployment', [appId]);
-
-  const permaLink = String(new URL(`/app/${appId}/${version}`, window.location.href));
-
-  return (
-    <ToolpadAppShell appId={appId}>
-      <Container sx={{ my: 3 }}>
-        <Stack gap={3}>
-          <Breadcrumbs aria-label="breadcrumb">
-            <MuiLink component={Link} underline="hover" color="inherit" to="../releases">
-              Releases
-            </MuiLink>
-            <Typography color="text.primary">Version &quot;{version}&quot;</Typography>
-          </Breadcrumbs>
-          <Paper sx={{ p: 2 }}>
-            <Typography variant="h5">Version &quot;{version}&quot;</Typography>
-
-            <DefinitionList>
-              <dt>Created:</dt>
-              <dd>{releaseQuery?.data?.createdAt.toLocaleString('short')}</dd>
-              <dt>Description:</dt>
-              <dd>{releaseQuery?.data?.description}</dd>
-              <dt>Permalink:</dt>
-              <dd>
-                <MuiLink href={permaLink}>{permaLink}</MuiLink>
-              </dd>
-            </DefinitionList>
-            <DeploymentStatus
-              appId={appId}
-              version={version}
-              activeVersion={activeDeploymentQuery.data?.release.version}
-            />
-          </Paper>
-        </Stack>
-      </Container>
-    </ToolpadAppShell>
-  );
-}
diff --git a/packages/toolpad-app/src/toolpad/Releases.tsx b/packages/toolpad-app/src/toolpad/Releases.tsx
deleted file mode 100644
index eccb8680f57..00000000000
--- a/packages/toolpad-app/src/toolpad/Releases.tsx
+++ /dev/null
@@ -1,174 +0,0 @@
-import {
-  Container,
-  Typography,
-  Box,
-  Paper,
-  Skeleton,
-  Button,
-  styled,
-  Breadcrumbs,
-  Stack,
-} from '@mui/material';
-import { DataGridPro, GridColumns } from '@mui/x-data-grid-pro';
-import * as React from 'react';
-import { useNavigate, useParams } from 'react-router-dom';
-import OpenInNewIcon from '@mui/icons-material/OpenInNew';
-import RocketLaunchIcon from '@mui/icons-material/RocketLaunch';
-import type { Deployment } from '../../prisma/generated/client';
-import client from '../api';
-import { Maybe } from '../utils/types';
-import ToolpadAppShell from './ToolpadAppShell';
-import DefinitionList from '../components/DefinitionList';
-
-interface ReleaseRow {
-  createdAt: Date;
-  version: number;
-  description: string;
-}
-
-const DeploymentActions = styled('div')(({ theme }) => ({
-  marginTop: theme.spacing(1),
-}));
-
-type ActiveDeploymentProps = {
-  value?: Maybe<Deployment>;
-};
-
-function ActiveDeployment({ value }: ActiveDeploymentProps) {
-  const url = value ? String(new URL(`/deploy/${value.appId}`, window.location.href)) : null;
-
-  return (
-    <React.Fragment>
-      <Typography variant="h5">
-        {value ? (
-          <React.Fragment>Version &quot;{value.version}&quot;</React.Fragment>
-        ) : (
-          <Skeleton />
-        )}
-      </Typography>
-      <Typography>Currently active deployment</Typography>
-      <DefinitionList>
-        <dt>Deployed:</dt>
-        <dd>{value ? value.createdAt.toLocaleString('short') : <Skeleton />}</dd>
-      </DefinitionList>
-
-      <DeploymentActions>
-        <Button
-          variant="contained"
-          component="a"
-          href={url || '#'}
-          target="_blank"
-          disabled={!url}
-          endIcon={<OpenInNewIcon />}
-        >
-          Open
-        </Button>
-      </DeploymentActions>
-    </React.Fragment>
-  );
-}
-
-interface NoActiveDeploymentProps {
-  appId: string;
-  releases?: ReleaseRow[];
-}
-
-function NoActiveDeployment({ appId, releases = [] }: NoActiveDeploymentProps) {
-  const latestRelease = releases.length > 0 ? releases[0] : null;
-
-  const deployReleaseMutation = client.useMutation('createDeployment');
-
-  const handleDeployClick = React.useCallback(async () => {
-    if (latestRelease) {
-      await deployReleaseMutation.mutateAsync([appId, latestRelease.version]);
-      client.invalidateQueries('findActiveDeployment', [appId]);
-    }
-  }, [appId, deployReleaseMutation, latestRelease]);
-
-  return (
-    <React.Fragment>
-      <Typography variant="h5">App not deployed yet</Typography>
-
-      <DeploymentActions>
-        {latestRelease ? (
-          <Button variant="contained" onClick={handleDeployClick} startIcon={<RocketLaunchIcon />}>
-            Deploy version &quot;{latestRelease.version}&quot;
-          </Button>
-        ) : (
-          <Typography>There are no releases to deploy</Typography>
-        )}
-      </DeploymentActions>
-    </React.Fragment>
-  );
-}
-
-export default function Releases() {
-  const { appId } = useParams();
-
-  if (!appId) {
-    throw new Error(`Missing queryParam "appId"`);
-  }
-
-  const navigate = useNavigate();
-  const { data: releases = [], isLoading, error } = client.useQuery('getReleases', [appId]);
-
-  const activeDeploymentQuery = client.useQuery('findActiveDeployment', [appId]);
-  const activeVersion = activeDeploymentQuery.data?.release.version;
-
-  const columns = React.useMemo<GridColumns<ReleaseRow>>(
-    () => [
-      {
-        field: 'version',
-        headerName: 'Version',
-      },
-      {
-        field: 'description',
-        headerName: 'Description',
-        flex: 1,
-      },
-      {
-        field: 'active',
-        headerName: 'Deployed',
-        type: 'boolean',
-        valueGetter: (params) => params.row.version === activeVersion,
-      },
-      {
-        field: 'createdAt',
-        headerName: 'Created',
-        type: 'date',
-      },
-    ],
-    [activeVersion],
-  );
-
-  return (
-    <ToolpadAppShell appId={appId}>
-      <Container sx={{ my: 3 }}>
-        <Stack gap={3}>
-          <Breadcrumbs aria-label="breadcrumb">
-            <Typography color="text.primary">Releases</Typography>
-          </Breadcrumbs>
-
-          <Paper sx={{ p: 2 }}>
-            {activeDeploymentQuery.isLoading || activeDeploymentQuery.data ? (
-              <ActiveDeployment value={activeDeploymentQuery.data} />
-            ) : (
-              <NoActiveDeployment appId={appId} releases={releases} />
-            )}
-          </Paper>
-
-          <Box sx={{ height: 350, width: '100%' }}>
-            <DataGridPro
-              rows={releases}
-              columns={columns}
-              getRowId={(row) => row.version}
-              loading={isLoading}
-              error={(error as any)?.message}
-              onRowClick={({ row }) => navigate(`/app/${appId}/releases/${row.version}`)}
-            />
-          </Box>
-        </Stack>
-      </Container>
-    </ToolpadAppShell>
-  );
-}
diff --git a/packages/toolpad-app/src/toolpad/Toolpad.tsx b/packages/toolpad-app/src/toolpad/Toolpad.tsx
index f0bf5bb9222..b463aaf0d76 100644
--- a/packages/toolpad-app/src/toolpad/Toolpad.tsx
+++ b/packages/toolpad-app/src/toolpad/Toolpad.tsx
@@ -2,8 +2,6 @@ import * as React from 'react';
 import { BrowserRouter, Routes, Route } from 'react-router-dom';
 import { Box, CircularProgress, NoSsr, styled } from '@mui/material';
 import { ErrorBoundary } from 'react-error-boundary';
-import Release from './Release';
-import Releases from './Releases';
 import AppEditor from './AppEditor';
 import Home from './Home';
 import ErrorAlert from './AppEditor/PageEditor/ErrorAlert';
@@ -40,8 +38,6 @@ function AppWorkspace() {
     <Routes>
       <Route>
         <Route path="editor/*" element={<AppEditor />} />
-        <Route path="releases" element={<Releases />} />
-        <Route path="releases/:version" element={<Release />} />
       </Route>
     </Routes>
   );
diff --git a/packages/toolpad-app/src/toolpad/ToolpadAppShell.tsx b/packages/toolpad-app/src/toolpad/ToolpadAppShell.tsx
deleted file mode 100644
index 70725cc45a1..00000000000
--- a/packages/toolpad-app/src/toolpad/ToolpadAppShell.tsx
+++ /dev/null
@@ -1,28 +0,0 @@
-import * as React from 'react';
-import { Button } from '@mui/material';
-import { Link } from 'react-router-dom';
-import ToolpadShell from './ToolpadShell';
-
-export interface ToolpadAppShellProps {
-  appId: string;
-  actions?: React.ReactNode;
-  children?: React.ReactNode;
-}
-
-export default function ToolpadAppShell({ appId, ...props }: ToolpadAppShellProps) {
-  return (
-    <ToolpadShell
-      navigation={
-        <React.Fragment>
-          <Button component={Link} to={`/app/${appId}/editor`} color="inherit">
-            Editor
-          </Button>
-          <Button component={Link} to={`/app/${appId}/releases`} color="inherit">
-            Releases
-          </Button>
-        </React.Fragment>
-      }
-      {...props}
-    />
-  );
-}
diff --git a/packages/toolpad-app/src/utils/prisma.ts b/packages/toolpad-app/src/utils/prisma.ts
new file mode 100644
index 00000000000..d967ca43605
--- /dev/null
+++ b/packages/toolpad-app/src/utils/prisma.ts
@@ -0,0 +1,13 @@
+// See https://github.com/prisma/prisma/issues/5042#issuecomment-1104679760
+export function excludeFields<T, K extends (keyof T)[]>(
+  fields: T,
+  excluded: K,
+): Record<Exclude<keyof T, K[number]>, boolean> {
+  const result = {} as Record<Exclude<keyof T, K[number]>, boolean>;
+  for (const key of Object.keys(fields)) {
+    if (!excluded.includes(key as any)) {
+      result[key as Exclude<keyof T, K[number]>] = true;
+    }
+  }
+  return result;
+}