diff --git a/packages/api-v4/.changeset/pr-11048-changed-1728076842800.md b/packages/api-v4/.changeset/pr-11048-changed-1728076842800.md
new file mode 100644
index 00000000000..2d1166729f1
--- /dev/null
+++ b/packages/api-v4/.changeset/pr-11048-changed-1728076842800.md
@@ -0,0 +1,5 @@
+---
+"@linode/api-v4": Changed
+---
+
+Specify the fork restore payload and return types ([#11048](https://github.com/linode/manager/pull/11048))
diff --git a/packages/api-v4/src/databases/databases.ts b/packages/api-v4/src/databases/databases.ts
index 7396c890a6e..53e5cbea952 100644
--- a/packages/api-v4/src/databases/databases.ts
+++ b/packages/api-v4/src/databases/databases.ts
@@ -22,6 +22,7 @@ import {
   Engine,
   SSLFields,
   UpdateDatabasePayload,
+  DatabaseFork,
 } from './types';
 
 /**
@@ -248,14 +249,8 @@ export const legacyRestoreWithBackup = (
  *
  * Fully restore a backup to the cluster
  */
-export const restoreWithBackup = (
-  engine: Engine,
-  fork: {
-    source: number;
-    restore_time?: string;
-  }
-) =>
-  Request<{}>(
+export const restoreWithBackup = (engine: Engine, fork: DatabaseFork) =>
+  Request<Database>(
     setURL(`${API_ROOT}/databases/${encodeURIComponent(engine)}/instances`),
     setMethod('POST'),
     setData({ fork })
diff --git a/packages/api-v4/src/databases/types.ts b/packages/api-v4/src/databases/types.ts
index 71e0f2d9a64..feb7987fde2 100644
--- a/packages/api-v4/src/databases/types.ts
+++ b/packages/api-v4/src/databases/types.ts
@@ -47,6 +47,11 @@ export interface DatabaseBackup {
   created: string;
 }
 
+export interface DatabaseFork {
+  source: number;
+  restore_time?: string;
+}
+
 export interface DatabaseCredentials {
   username: string;
   password: string;
diff --git a/packages/manager/.changeset/pr-11048-upcoming-features-1728076876251.md b/packages/manager/.changeset/pr-11048-upcoming-features-1728076876251.md
new file mode 100644
index 00000000000..26a86cb07aa
--- /dev/null
+++ b/packages/manager/.changeset/pr-11048-upcoming-features-1728076876251.md
@@ -0,0 +1,5 @@
+---
+"@linode/manager": Upcoming Features
+---
+
+DBaaS GA enhancements to backups tab and beta fixes ([#11048](https://github.com/linode/manager/pull/11048))
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.style.ts b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.style.ts
index 547fe03bfbf..2b00ab590c0 100644
--- a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.style.ts
+++ b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.style.ts
@@ -1,21 +1,15 @@
 import { styled } from '@mui/material/styles';
-import { DateCalendar, TimePicker } from '@mui/x-date-pickers';
-
-import { Box } from 'src/components/Box';
+import { DateCalendar } from '@mui/x-date-pickers';
 import { Typography } from 'src/components/Typography';
+import { makeStyles } from 'tss-react/mui';
 
-export const StyledTimePicker = styled(TimePicker)(() => ({
-  '.MuiInputAdornment-root': { marginRight: '0' },
-  '.MuiInputBase-input': { padding: '8px 0 8px 12px' },
-  '.MuiInputBase-root': { borderRadius: '0', padding: '0px' },
-
-  'button.MuiButtonBase-root': {
-    marginRight: '0',
-    padding: '8px',
+export const useStyles = makeStyles()(() => ({
+  timeAutocomplete: {
+    width: '140px',
+    '.MuiBox-root': {
+      marginTop: '0',
+    },
   },
-  height: '34px',
-  marginTop: '8px',
-  width: '120px',
 }));
 
 export const StyledDateCalendar = styled(DateCalendar, {
@@ -56,25 +50,6 @@ export const StyledDateCalendar = styled(DateCalendar, {
   width: '260px',
 }));
 
-export const StyledBox = styled(Box)(({ theme }) => ({
-  '& h6': {
-    fontSize: '0.875rem',
-  },
-  '& span': {
-    marginBottom: '5px',
-    marginTop: '7px',
-  },
-  alignItems: 'flex-start',
-
-  border: '1px solid #F4F4F4',
-  color: theme.name === 'light' ? '#555555' : theme.color.headline,
-  display: 'flex',
-  flexDirection: 'column',
-  height: '100%',
-  padding: '8px 15px',
-  background: theme.name === 'light' ? '#FBFBFB' : theme.color.grey2,
-}));
-
 export const StyledTypography = styled(Typography)(() => ({
   lineHeight: '20px',
   marginTop: '4px',
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.test.tsx b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.test.tsx
index 081dbc98cf3..0abbd2a4cad 100644
--- a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.test.tsx
+++ b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.test.tsx
@@ -95,10 +95,9 @@ describe('Database Backups', () => {
     });
   });
 
-  it('should disable the restore button if no oldest_restore_time is returned', async () => {
+  it('should enable the restore button if disabled = false', async () => {
     const mockDatabase = databaseFactory.build({
-      oldest_restore_time: undefined,
-      platform: 'rdbms-default',
+      platform: 'rdbms-legacy',
     });
     const backups = databaseBackupFactory.buildList(7);
 
@@ -115,19 +114,20 @@ describe('Database Backups', () => {
     );
 
     const { findAllByText } = renderWithTheme(
-      <DatabaseBackups disabled={true} />
+      <DatabaseBackups disabled={false} />
     );
     const buttonSpans = await findAllByText('Restore');
-    expect(buttonSpans.length).toEqual(1);
+    expect(buttonSpans.length).toEqual(7);
     buttonSpans.forEach((span: HTMLSpanElement) => {
       const button = span.closest('button');
-      expect(button).toBeDisabled();
+      expect(button).toBeEnabled();
     });
   });
 
-  it('should enable the restore button if disabled = false', async () => {
+  it('should disable the restore button if no oldest_restore_time is returned', async () => {
     const mockDatabase = databaseFactory.build({
-      platform: 'rdbms-legacy',
+      oldest_restore_time: undefined,
+      platform: 'rdbms-default',
     });
     const backups = databaseBackupFactory.buildList(7);
 
@@ -144,17 +144,34 @@ describe('Database Backups', () => {
     );
 
     const { findAllByText } = renderWithTheme(
-      <DatabaseBackups disabled={false} />
+      <DatabaseBackups disabled={true} />
     );
     const buttonSpans = await findAllByText('Restore');
-    expect(buttonSpans.length).toEqual(7);
+    expect(buttonSpans.length).toEqual(1);
     buttonSpans.forEach((span: HTMLSpanElement) => {
       const button = span.closest('button');
-      expect(button).toBeEnabled();
+      expect(button).toBeDisabled();
     });
   });
 
-  it('should render a time picker when it is a new database', async () => {
+  it('should render a date picker when it is a default database', async () => {
+    const mockDatabase = databaseFactory.build({
+      platform: 'rdbms-default',
+    });
+
+    server.use(
+      http.get('*/databases/:engine/instances/:id', () => {
+        return HttpResponse.json(mockDatabase);
+      })
+    );
+
+    const rendered = renderWithTheme(<DatabaseBackups disabled={false} />);
+    expect(
+      rendered.container.getElementsByClassName('MuiDateCalendar-root')
+    ).toBeDefined();
+  });
+
+  it('should render a time picker when it is a default database', async () => {
     const mockDatabase = databaseFactory.build({
       platform: 'rdbms-default',
     });
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.tsx b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.tsx
index 35aafb99e5c..513d881ddf7 100644
--- a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.tsx
+++ b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.tsx
@@ -1,134 +1,102 @@
-import { FormControl } from '@mui/material';
+import type { Engine } from '@linode/api-v4/lib/databases';
+import {
+  FormControl,
+  FormControlLabel,
+  Radio,
+  RadioGroup,
+} from '@mui/material';
 import Grid from '@mui/material/Grid';
 import { LocalizationProvider } from '@mui/x-date-pickers';
 import { AdapterLuxon } from '@mui/x-date-pickers/AdapterLuxon';
 import { DateTime } from 'luxon';
 import * as React from 'react';
 import { useParams } from 'react-router-dom';
-
 import { Box } from 'src/components/Box';
 import { Button } from 'src/components/Button/Button';
 import { Divider } from 'src/components/Divider';
-import Select from 'src/components/EnhancedSelect/Select';
 import { Notice } from 'src/components/Notice/Notice';
 import { Paper } from 'src/components/Paper';
-import { Table } from 'src/components/Table';
-import { TableBody } from 'src/components/TableBody';
-import { TableCell } from 'src/components/TableCell';
-import { TableHead } from 'src/components/TableHead';
-import { TableRow } from 'src/components/TableRow';
-import { TableRowEmpty } from 'src/components/TableRowEmpty/TableRowEmpty';
-import { TableRowError } from 'src/components/TableRowError/TableRowError';
-import { TableRowLoading } from 'src/components/TableRowLoading/TableRowLoading';
-import { TableSortCell } from 'src/components/TableSortCell';
 import { Typography } from 'src/components/Typography';
 import {
   StyledDateCalendar,
   StyledTypography,
+  useStyles,
 } from 'src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups.style';
-import RestoreLegacyFromBackupDialog from 'src/features/Databases/DatabaseDetail/DatabaseBackups/RestoreLegacyFromBackupDialog';
-import RestoreNewFromBackupDialog from 'src/features/Databases/DatabaseDetail/DatabaseBackups/RestoreNewFromBackupDialog';
-import { isOutsideBackupTimeframe } from 'src/features/Databases/utilities';
-import { useOrder } from 'src/hooks/useOrder';
-import {
-  useDatabaseBackupsQuery,
-  useDatabaseQuery,
-} from 'src/queries/databases/databases';
-
-import { BackupTableRow } from './DatabaseBackupTableRow';
 
-import type { DatabaseBackup, Engine } from '@linode/api-v4/lib/databases';
+import { Autocomplete } from 'src/components/Autocomplete/Autocomplete';
+import {
+  isDateOutsideBackup,
+  isTimeOutsideBackup,
+  useIsDatabasesEnabled,
+} from 'src/features/Databases/utilities';
+import { useDatabaseQuery } from 'src/queries/databases/databases';
+import DatabaseBackupsDialog from './DatabaseBackupsDialog';
+import DatabaseBackupsLegacy from './legacy/DatabaseBackupsLegacy';
 
 interface Props {
   disabled?: boolean;
 }
 
+export interface TimeOption {
+  label: string;
+  value: number;
+}
+
+const TIME_OPTIONS: TimeOption[] = [
+  { label: '00:00', value: 0 },
+  { label: '01:00', value: 1 },
+  { label: '02:00', value: 2 },
+  { label: '03:00', value: 3 },
+  { label: '04:00', value: 4 },
+  { label: '05:00', value: 5 },
+  { label: '06:00', value: 6 },
+  { label: '07:00', value: 7 },
+  { label: '08:00', value: 8 },
+  { label: '09:00', value: 9 },
+  { label: '10:00', value: 10 },
+  { label: '11:00', value: 11 },
+  { label: '12:00', value: 12 },
+  { label: '13:00', value: 13 },
+  { label: '14:00', value: 14 },
+  { label: '15:00', value: 15 },
+  { label: '16:00', value: 16 },
+  { label: '17:00', value: 17 },
+  { label: '18:00', value: 18 },
+  { label: '19:00', value: 19 },
+  { label: '20:00', value: 20 },
+  { label: '21:00', value: 21 },
+  { label: '22:00', value: 22 },
+  { label: '23:00', value: 23 },
+];
+
+export type VersionOption = 'newest' | 'dateTime';
+
 export const DatabaseBackups = (props: Props) => {
+  const { classes } = useStyles();
   const { disabled } = props;
   const { databaseId, engine } = useParams<{
     databaseId: string;
     engine: Engine;
   }>();
+  const { isV2GAUser } = useIsDatabasesEnabled();
 
   const [isRestoreDialogOpen, setIsRestoreDialogOpen] = React.useState(false);
-  const [idOfBackupToRestore, setIdOfBackupToRestore] = React.useState<
-    number | undefined
-  >();
-
   const [selectedDate, setSelectedDate] = React.useState<DateTime | null>(null);
-  const [selectedTime, setSelectedTime] = React.useState<DateTime | null>(
-    DateTime.now().set({ hour: 1, minute: 0, second: 0 })
+  const [selectedTime, setSelectedTime] = React.useState<TimeOption | null>(
+    null
+  );
+  const [versionOption, setVersionOption] = React.useState<VersionOption>(
+    isV2GAUser ? 'newest' : 'dateTime'
   );
-  const [
-    selectedRestoreTime,
-    setSelectedRestoreTime,
-  ] = React.useState<string>();
-
-  const id = Number(databaseId);
 
   const {
     data: database,
     error: databaseError,
     isLoading: isDatabaseLoading,
-  } = useDatabaseQuery(engine, id);
+  } = useDatabaseQuery(engine, Number(databaseId));
 
   const isDefaultDatabase = database?.platform === 'rdbms-default';
 
-  const {
-    data: backups,
-    error: backupsError,
-    isLoading: isBackupsLoading,
-  } = useDatabaseBackupsQuery(engine, id, !isDefaultDatabase);
-
-  const { handleOrderChange, order, orderBy } = useOrder({
-    order: 'desc',
-    orderBy: 'created',
-  });
-
-  const onRestoreLegacyDatabase = (id: number) => {
-    setIdOfBackupToRestore(id);
-    setIsRestoreDialogOpen(true);
-  };
-
-  const backupToRestoreLegacy = backups?.data.find(
-    (backup) => backup.id === idOfBackupToRestore
-  );
-
-  const sorter = (a: DatabaseBackup, b: DatabaseBackup) => {
-    if (order === 'asc') {
-      return new Date(b.created).getTime() - new Date(a.created).getTime();
-    }
-    return new Date(a.created).getTime() - new Date(b.created).getTime();
-  };
-
-  const renderTableBody = () => {
-    if (databaseError) {
-      return <TableRowError colSpan={3} message={databaseError[0].reason} />;
-    }
-    if (backupsError) {
-      return <TableRowError colSpan={3} message={backupsError[0].reason} />;
-    }
-    if (isDatabaseLoading || isBackupsLoading) {
-      return <TableRowLoading columns={3} />;
-    }
-    if (backups?.results === 0) {
-      return <TableRowEmpty colSpan={3} message="No backups to display." />;
-    }
-    if (backups) {
-      return backups.data
-        .sort(sorter)
-        .map((backup) => (
-          <BackupTableRow
-            backup={backup}
-            disabled={disabled}
-            key={backup.id}
-            onRestore={onRestoreLegacyDatabase}
-          />
-        ));
-    }
-    return null;
-  };
-
   const oldestBackup = database?.oldest_restore_time
     ? DateTime.fromISO(database.oldest_restore_time)
     : null;
@@ -137,15 +105,30 @@ export const DatabaseBackups = (props: Props) => {
     ? 'You can restore a backup after the first backup is completed.'
     : '';
 
-  const onRestoreNewDatabase = (selectedDate: DateTime | null) => {
-    const day = selectedDate?.toISODate();
-    const time = selectedTime?.toISOTime({ includeOffset: false });
-    const selectedDateTime = `${day}T${time}Z`;
+  const onRestoreDatabase = () => {
+    setIsRestoreDialogOpen(true);
+  };
+
+  const handleDateChange = (newDate: DateTime) => {
+    const isSelectedTimeInvalid = isTimeOutsideBackup(
+      selectedTime?.value,
+      newDate,
+      oldestBackup!
+    );
+    // If the user has selcted a time then changes the date,
+    // that date + time might now be outside of the backup timeframe.
+    // Reset selectedTime to null so user can select a valid time.
+    if (isSelectedTimeInvalid) {
+      setSelectedTime(null);
+    }
 
-    const selectedTimestamp = new Date(selectedDateTime).toISOString();
+    setSelectedDate(newDate);
+  };
 
-    setSelectedRestoreTime(selectedTimestamp);
-    setIsRestoreDialogOpen(true);
+  const handleOnVersionOptionChange = (_: any, value: string) => {
+    setVersionOption(value as VersionOption);
+    setSelectedDate(null);
+    setSelectedTime(null);
   };
 
   return isDefaultDatabase ? (
@@ -157,49 +140,58 @@ export const DatabaseBackups = (props: Props) => {
         version-specific binary backups, which when combined with binary
         logs allow for consistent recovery to a specific point in time (PITR).
       </StyledTypography>
-      {/* TODO: Uncomment when the all data is available (Number of Full Backups, Newest Full Backup, Oldest Full Backup) */}
-      {/* <Hidden xlDown={true} xlUp={true}>
-        <Grid alignItems="stretch" container mt={2} spacing={1}>
-          <Grid item md={4} xs={12}>
-            <StyledBox>
-              <Typography variant="h2">Number of Full Backups</Typography>
-              <Typography component="span" variant="h1">
-                {backups?.data.length}
-              </Typography>
-            </StyledBox>
-          </Grid>
-          <Grid item md={4} xs={12}>
-            <StyledBox>
-              <Typography variant="h2">Newest Full Backup</Typography>
-              <Typography variant="subtitle2">{newestBackup} (UTC)</Typography>
-            </StyledBox>
-          </Grid>
-          <Grid item md={4} xs={12}>
-            <StyledBox>
-              <Typography variant="h2">Oldest Full Backup</Typography>
-              <Typography variant="subtitle2">{oldestBackup} (UTC)</Typography>
-            </StyledBox>
-          </Grid>
-        </Grid>
-      </Hidden> */}
       <Divider spacingBottom={25} spacingTop={25} />
       <Typography variant="h2">Restore a Backup</Typography>
       <StyledTypography>
-        Select a date and time within the last 10 days you want to create a fork
-        from.
+        {isV2GAUser ? (
+          <span>
+            The newest full backup plus incremental is selected by default. Or,
+            select any date and time within the last 10 days you want to create
+            a fork from.
+          </span>
+        ) : (
+          <span>
+            Select a date and time within the last 10 days you want to create a
+            forkfrom.
+          </span>
+        )}
       </StyledTypography>
       {unableToRestoreCopy && (
         <Notice spacingTop={16} text={unableToRestoreCopy} variant="info" />
       )}
+      {isV2GAUser && (
+        <RadioGroup
+          aria-label="type"
+          name="type"
+          onChange={handleOnVersionOptionChange}
+          value={versionOption}
+        >
+          <FormControlLabel
+            control={<Radio />}
+            data-qa-dbaas-radio="Newest"
+            disabled={disabled}
+            label="Newest full backup plus incremental"
+            value="newest"
+          />
+          <FormControlLabel
+            control={<Radio />}
+            data-qa-dbaas-radio="DateTime"
+            disabled={disabled}
+            label="Specific date & time"
+            value="dateTime"
+          />
+        </RadioGroup>
+      )}
       <Grid container justifyContent="flex-start" mt={2}>
         <Grid item lg={3} md={4} xs={12}>
           <Typography variant="h3">Date</Typography>
           <LocalizationProvider dateAdapter={AdapterLuxon}>
             <StyledDateCalendar
+              disabled={disabled || versionOption === 'newest'}
               shouldDisableDate={(date) =>
-                isOutsideBackupTimeframe(date, oldestBackup)
+                isDateOutsideBackup(date, oldestBackup?.startOf('day'))
               }
-              onChange={(newDate) => setSelectedDate(newDate)}
+              onChange={handleDateChange}
               value={selectedDate}
             />
           </LocalizationProvider>
@@ -208,29 +200,31 @@ export const DatabaseBackups = (props: Props) => {
           <Typography variant="h3">Time (UTC)</Typography>
           <FormControl style={{ marginTop: 0 }}>
             {/* TODO: Replace Time Select to the own custom date-time picker component when it's ready */}
-            <Select
-              defaultValue={hourSelectionMap.find(
-                (option) => option.value === selectedTime?.hour
-              )}
-              onChange={(time) =>
-                setSelectedTime(
-                  DateTime.now().set({ hour: time.value, minute: 0 })
-                )
+            <Autocomplete
+              autoComplete={false}
+              className={classes.timeAutocomplete}
+              disabled={disabled || !selectedDate || versionOption === 'newest'}
+              getOptionDisabled={(option) =>
+                isTimeOutsideBackup(option.value, selectedDate!, oldestBackup!)
+              }
+              label=""
+              isOptionEqualToValue={(option, value) =>
+                option.value === value.value
               }
+              onChange={(_, newTime) => setSelectedTime(newTime)}
+              options={TIME_OPTIONS}
+              placeholder="Choose a time"
+              renderOption={(props, option) => (
+                <li {...props} key={option.value}>
+                  {option.label}
+                </li>
+              )}
               textFieldProps={{
                 dataAttrs: {
                   'data-qa-time-select': true,
                 },
               }}
-              value={hourSelectionMap.find(
-                (thisOption) => thisOption.value === selectedTime?.hour
-              )}
-              disabled={!selectedDate}
-              isClearable={false}
-              name="Time"
-              noMarginTop
-              options={hourSelectionMap}
-              placeholder="Choose a time"
+              value={selectedTime}
             />
           </FormControl>
         </Grid>
@@ -240,86 +234,34 @@ export const DatabaseBackups = (props: Props) => {
           <Button
             buttonType="primary"
             data-qa-settings-button="restore"
-            disabled={!selectedDate}
-            onClick={() => onRestoreNewDatabase(selectedDate)}
+            disabled={
+              versionOption === 'dateTime' && (!selectedDate || !selectedTime)
+            }
+            onClick={onRestoreDatabase}
           >
             Restore
           </Button>
         </Box>
       </Grid>
-      {database && selectedRestoreTime ? (
-        <RestoreNewFromBackupDialog
+      {database ? (
+        <DatabaseBackupsDialog
           database={database}
           onClose={() => setIsRestoreDialogOpen(false)}
           open={isRestoreDialogOpen}
-          restoreTime={selectedRestoreTime}
+          selectedDate={selectedDate}
+          selectedTime={selectedTime?.value}
         />
       ) : null}
     </Paper>
   ) : (
-    <>
-      <Table>
-        <TableHead>
-          <TableRow>
-            <TableSortCell
-              active={orderBy === 'created'}
-              direction={order}
-              handleClick={handleOrderChange}
-              label="created"
-              style={{ width: 155 }}
-            >
-              Date Created
-            </TableSortCell>
-            <TableCell></TableCell>
-            <TableCell style={{ width: 100 }}></TableCell>
-          </TableRow>
-        </TableHead>
-        <TableBody>{renderTableBody()}</TableBody>
-      </Table>
-      <Paper style={{ marginTop: 16 }}>
-        <Typography variant="h3">Backup Schedule</Typography>
-        <Typography style={{ lineHeight: '20px', marginTop: 4 }}>
-          A backup of this database is created every 24 hours and each backup is
-          retained for 7 days.
-        </Typography>
-      </Paper>
-      {database && backupToRestoreLegacy ? (
-        <RestoreLegacyFromBackupDialog
-          backup={backupToRestoreLegacy}
-          database={database}
-          onClose={() => setIsRestoreDialogOpen(false)}
-          open={isRestoreDialogOpen}
-        />
-      ) : null}
-    </>
+    <DatabaseBackupsLegacy
+      disabled={disabled}
+      database={database}
+      databaseError={databaseError}
+      engine={engine}
+      isDatabaseLoading={isDatabaseLoading}
+    />
   );
 };
 
-const hourSelectionMap = [
-  { label: '00:00', value: 0 },
-  { label: '01:00', value: 1 },
-  { label: '02:00', value: 2 },
-  { label: '03:00', value: 3 },
-  { label: '04:00', value: 4 },
-  { label: '05:00', value: 5 },
-  { label: '06:00', value: 6 },
-  { label: '07:00', value: 7 },
-  { label: '08:00', value: 8 },
-  { label: '09:00', value: 9 },
-  { label: '10:00', value: 10 },
-  { label: '11:00', value: 11 },
-  { label: '12:00', value: 12 },
-  { label: '13:00', value: 13 },
-  { label: '14:00', value: 14 },
-  { label: '15:00', value: 15 },
-  { label: '16:00', value: 16 },
-  { label: '17:00', value: 17 },
-  { label: '18:00', value: 18 },
-  { label: '19:00', value: 19 },
-  { label: '20:00', value: 20 },
-  { label: '21:00', value: 21 },
-  { label: '22:00', value: 22 },
-  { label: '23:00', value: 23 },
-];
-
 export default DatabaseBackups;
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/RestoreNewFromBackupDialog.tsx b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackupsDialog.tsx
similarity index 66%
rename from packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/RestoreNewFromBackupDialog.tsx
rename to packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackupsDialog.tsx
index ada23f9fe6e..b8c3a97fc98 100644
--- a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/RestoreNewFromBackupDialog.tsx
+++ b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackupsDialog.tsx
@@ -10,35 +10,36 @@ import { useRestoreFromBackupMutation } from 'src/queries/databases/databases';
 import { getAPIErrorOrDefault } from 'src/utilities/errorUtils';
 
 import type { Database } from '@linode/api-v4/lib/databases';
+import { DateTime } from 'luxon';
+import { useState } from 'react';
 import type { DialogProps } from 'src/components/Dialog/Dialog';
+import { toDatabaseFork, toFormatedDate } from '../../utilities';
 
 interface Props extends Omit<DialogProps, 'title'> {
   database: Database;
   onClose: () => void;
   open: boolean;
-  restoreTime?: string;
+  selectedDate?: DateTime | null;
+  selectedTime?: number;
 }
 
-export const RestoreNewFromBackupDialog = (props: Props) => {
-  const { database, onClose, open, restoreTime } = props;
+export const DatabaseBackupDialog = (props: Props) => {
+  const { database, onClose, open, selectedDate, selectedTime } = props;
   const history = useHistory();
   const { enqueueSnackbar } = useSnackbar();
+  const [isRestoring, setIsRestoring] = useState(false);
 
-  const formatedDate =
-    restoreTime &&
-    `${restoreTime?.split('T')[0]} ${restoreTime?.split('T')[1].slice(0, 5)}`;
+  const formatedDate = toFormatedDate(selectedDate, selectedTime);
 
   const { error, mutateAsync: restore } = useRestoreFromBackupMutation(
     database.engine,
-    {
-      restore_time: restoreTime,
-      source: database.id,
-    }
+    toDatabaseFork(database.id, selectedDate, selectedTime)
   );
 
-  const handleNewRestoreDatabase = () => {
-    restore().then(() => {
-      history.push('summary');
+  const handleRestoreDatabase = () => {
+    setIsRestoring(true);
+    restore().then((database: Database) => {
+      history.push(`/databases/${database.engine}/${database.id}`);
       enqueueSnackbar('Your database is being restored.', {
         variant: 'success',
       });
@@ -55,15 +56,16 @@ export const RestoreNewFromBackupDialog = (props: Props) => {
     >
       <Typography sx={(theme) => ({ marginBottom: theme.spacing(4) })}>
         Restoring a backup creates a fork from this backup. If you proceed and
-        the fork is created successfully, you have 10 days to delete the
-        original database cluster. Failing to do so will lead to additional
-        billing caused by two running clusters instead of one.
+        the fork is created successfully, you should remove the original
+        database cluster. Failing to do so will lead to additional billing
+        caused by two running clusters instead of one.
       </Typography>
       <ActionsPanel
         primaryButtonProps={{
           'data-testid': 'submit',
           label: 'Restore',
-          onClick: handleNewRestoreDatabase,
+          loading: isRestoring,
+          onClick: handleRestoreDatabase,
         }}
         secondaryButtonProps={{
           'data-testid': 'cancel',
@@ -89,4 +91,4 @@ export const RestoreNewFromBackupDialog = (props: Props) => {
   );
 };
 
-export default RestoreNewFromBackupDialog;
+export default DatabaseBackupDialog;
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/index.ts b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/index.ts
deleted file mode 100644
index df05787de51..00000000000
--- a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import DatabaseBackups from './DatabaseBackups';
-export default DatabaseBackups;
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackupActionMenu.tsx b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupActionMenu.tsx
similarity index 100%
rename from packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackupActionMenu.tsx
rename to packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupActionMenu.tsx
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupTableBody.tsx b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupTableBody.tsx
new file mode 100644
index 00000000000..6f7ee8ebaad
--- /dev/null
+++ b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupTableBody.tsx
@@ -0,0 +1,70 @@
+import { APIError, DatabaseBackup, ResourcePage } from '@linode/api-v4';
+import React from 'react';
+import { TableRowEmpty } from 'src/components/TableRowEmpty/TableRowEmpty';
+import { TableRowError } from 'src/components/TableRowError/TableRowError';
+import { TableRowLoading } from 'src/components/TableRowLoading/TableRowLoading';
+import { BackupTableRow } from './DatabaseBackupTableRow';
+
+interface Props {
+  backups?: ResourcePage<DatabaseBackup>;
+  backupsError: APIError[] | null;
+  databaseError: APIError[] | null;
+  disabled?: boolean;
+  isBackupsLoading: boolean;
+  isDatabaseLoading: boolean;
+  onRestore: (id: number) => void;
+  order: 'asc' | 'desc';
+}
+
+const DatabaseBackupTableBody = (props: Props) => {
+  const {
+    backups,
+    backupsError,
+    databaseError,
+    disabled,
+    isBackupsLoading,
+    isDatabaseLoading,
+    onRestore,
+    order,
+  } = props;
+
+  const sorter = (a: DatabaseBackup, b: DatabaseBackup) => {
+    if (order === 'asc') {
+      return new Date(b.created).getTime() - new Date(a.created).getTime();
+    }
+    return new Date(a.created).getTime() - new Date(b.created).getTime();
+  };
+
+  if (databaseError) {
+    return <TableRowError colSpan={3} message={databaseError[0].reason} />;
+  }
+
+  if (backupsError) {
+    return <TableRowError colSpan={3} message={backupsError[0].reason} />;
+  }
+
+  if (isDatabaseLoading || isBackupsLoading) {
+    return <TableRowLoading columns={3} />;
+  }
+
+  if (backups?.results === 0) {
+    return <TableRowEmpty colSpan={3} message="No backups to display." />;
+  }
+
+  if (backups) {
+    return backups.data
+      .sort(sorter)
+      .map((backup: DatabaseBackup) => (
+        <BackupTableRow
+          backup={backup}
+          disabled={disabled}
+          key={backup.id}
+          onRestore={onRestore}
+        />
+      ));
+  }
+
+  return null;
+};
+
+export default DatabaseBackupTableBody;
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackupTableRow.tsx b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupTableRow.tsx
similarity index 100%
rename from packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackupTableRow.tsx
rename to packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupTableRow.tsx
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupsLegacy.tsx b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupsLegacy.tsx
new file mode 100644
index 00000000000..bb260ed996f
--- /dev/null
+++ b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/DatabaseBackupsLegacy.tsx
@@ -0,0 +1,115 @@
+import { APIError } from '@linode/api-v4';
+import type { Database, Engine } from '@linode/api-v4/lib/databases';
+import * as React from 'react';
+import { Paper } from 'src/components/Paper';
+import { Table } from 'src/components/Table';
+import { TableBody } from 'src/components/TableBody';
+import { TableCell } from 'src/components/TableCell';
+import { TableHead } from 'src/components/TableHead';
+import { TableRow } from 'src/components/TableRow';
+import { TableSortCell } from 'src/components/TableSortCell';
+import { Typography } from 'src/components/Typography';
+import RestoreLegacyFromBackupDialog from 'src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/RestoreLegacyFromBackupDialog';
+import { useOrder } from 'src/hooks/useOrder';
+import { useDatabaseBackupsQuery } from 'src/queries/databases/databases';
+import DatabaseBackupTableBody from './DatabaseBackupTableBody';
+
+interface Props {
+  database: Database | undefined;
+  databaseError: APIError[] | null;
+  disabled?: boolean;
+  engine: Engine;
+  isDatabaseLoading: boolean;
+}
+
+export const DatabaseBackupsLegacy = (props: Props) => {
+  const {
+    database,
+    databaseError,
+    isDatabaseLoading,
+    disabled,
+    engine,
+  } = props;
+
+  const [isRestoreDialogOpen, setIsRestoreDialogOpen] = React.useState(false);
+  const [idOfBackupToRestore, setIdOfBackupToRestore] = React.useState<
+    number | undefined
+  >();
+
+  const id = database ? Number(database.id) : 0;
+
+  const {
+    data: backups,
+    error: backupsError,
+    isLoading: isBackupsLoading,
+  } = useDatabaseBackupsQuery(engine, id, Boolean(database));
+
+  const { handleOrderChange, order, orderBy } = useOrder({
+    order: 'desc',
+    orderBy: 'created',
+  });
+
+  if (!database) {
+    return null;
+  }
+
+  const onRestoreLegacyDatabase = (id: number) => {
+    setIdOfBackupToRestore(id);
+    setIsRestoreDialogOpen(true);
+  };
+
+  const backupToRestoreLegacy = backups?.data.find(
+    (backup) => backup.id === idOfBackupToRestore
+  );
+
+  return (
+    <>
+      <Table>
+        <TableHead>
+          <TableRow>
+            <TableSortCell
+              active={orderBy === 'created'}
+              direction={order}
+              handleClick={handleOrderChange}
+              label="created"
+              style={{ width: 155 }}
+            >
+              Date Created
+            </TableSortCell>
+            <TableCell></TableCell>
+            <TableCell style={{ width: 100 }}></TableCell>
+          </TableRow>
+        </TableHead>
+        <TableBody>
+          <DatabaseBackupTableBody
+            backups={backups}
+            backupsError={backupsError}
+            databaseError={databaseError}
+            disabled={disabled}
+            isBackupsLoading={isBackupsLoading}
+            isDatabaseLoading={isDatabaseLoading}
+            onRestore={onRestoreLegacyDatabase}
+            order={order}
+          />
+        </TableBody>
+      </Table>
+      <Paper style={{ marginTop: 16 }}>
+        <Typography variant="h3">Backup Schedule</Typography>
+        <Typography style={{ lineHeight: '20px', marginTop: 4 }}>
+          A backup of this database is created every 24 hours and each backup is
+          retained for 7 days.
+        </Typography>
+      </Paper>
+      {database && backupToRestoreLegacy && (
+        <RestoreLegacyFromBackupDialog
+          backup={backupToRestoreLegacy}
+          database={database}
+          onClose={() => setIsRestoreDialogOpen(false)}
+          open={isRestoreDialogOpen}
+        />
+      )}
+    </>
+  );
+};
+
+export default DatabaseBackupsLegacy;
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/RestoreLegacyFromBackupDialog.tsx b/packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/RestoreLegacyFromBackupDialog.tsx
similarity index 100%
rename from packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/RestoreLegacyFromBackupDialog.tsx
rename to packages/manager/src/features/Databases/DatabaseDetail/DatabaseBackups/legacy/RestoreLegacyFromBackupDialog.tsx
diff --git a/packages/manager/src/features/Databases/DatabaseDetail/index.tsx b/packages/manager/src/features/Databases/DatabaseDetail/index.tsx
index 0f858f039cd..85a017c95d3 100644
--- a/packages/manager/src/features/Databases/DatabaseDetail/index.tsx
+++ b/packages/manager/src/features/Databases/DatabaseDetail/index.tsx
@@ -25,7 +25,9 @@ import type { Engine } from '@linode/api-v4/lib/databases/types';
 import type { APIError } from '@linode/api-v4/lib/types';
 
 const DatabaseSummary = React.lazy(() => import('./DatabaseSummary'));
-const DatabaseBackups = React.lazy(() => import('./DatabaseBackups'));
+const DatabaseBackups = React.lazy(
+  () => import('./DatabaseBackups/DatabaseBackups')
+);
 const DatabaseSettings = React.lazy(() => import('./DatabaseSettings'));
 const DatabaseResize = React.lazy(() =>
   import('./DatabaseResize/DatabaseResize').then(({ DatabaseResize }) => ({
diff --git a/packages/manager/src/features/Databases/utilities.test.ts b/packages/manager/src/features/Databases/utilities.test.ts
index 814e3a2fb07..af6f29ea26a 100644
--- a/packages/manager/src/features/Databases/utilities.test.ts
+++ b/packages/manager/src/features/Databases/utilities.test.ts
@@ -1,84 +1,137 @@
 import { renderHook, waitFor } from '@testing-library/react';
 import { DateTime } from 'luxon';
 
+import { AccountCapability } from '@linode/api-v4';
 import { accountFactory } from 'src/factories';
+import { TimeOption } from 'src/features/Databases/DatabaseDetail/DatabaseBackups/DatabaseBackups';
 import {
-  isOutsideBackupTimeframe,
+  isDateOutsideBackup,
+  isTimeOutsideBackup,
+  toISOString,
   useIsDatabasesEnabled,
 } from 'src/features/Databases/utilities';
 import { makeResourcePage } from 'src/mocks/serverHandlers';
 import { HttpResponse, http, server } from 'src/mocks/testServer';
 import { wrapWithTheme } from 'src/utilities/testHelpers';
 
+const setup = (capabilities: AccountCapability[], flags: any) => {
+  const account = accountFactory.build({ capabilities });
+
+  server.use(
+    http.get('*/v4/account', () => {
+      return HttpResponse.json(account);
+    })
+  );
+
+  return renderHook(() => useIsDatabasesEnabled(), {
+    wrapper: (ui) => wrapWithTheme(ui, { flags }),
+  });
+};
+
 describe('useIsDatabasesEnabled', () => {
-  it('should return true for an unrestricted user with the account capability V1', async () => {
-    const account = accountFactory.build({
-      capabilities: ['Managed Databases'],
-    });
+  it('should return false for an unrestricted user without the account capability', async () => {
+    const { result } = setup([], { dbaasV2: { beta: true, enabled: true } });
+    await waitFor(() => {
+      expect(result.current.isDatabasesEnabled).toBe(false);
+      expect(result.current.isDatabasesV1Enabled).toBe(false);
+      expect(result.current.isDatabasesV2Enabled).toBe(false);
 
-    server.use(
-      http.get('*/v4/account', () => {
-        return HttpResponse.json(account);
-      })
-    );
+      expect(result.current.isDatabasesV2Beta).toBe(false);
+      expect(result.current.isV2ExistingBetaUser).toBe(false);
+      expect(result.current.isV2NewBetaUser).toBe(false);
 
-    const { result } = renderHook(() => useIsDatabasesEnabled(), {
-      wrapper: (ui) =>
-        wrapWithTheme(ui, {
-          flags: { dbaasV2: { beta: false, enabled: false } },
-        }),
+      expect(result.current.isV2GAUser).toBe(false);
+    });
+  });
+
+  it('should return true for an unrestricted user with the account capability V1', async () => {
+    const { result } = setup(['Managed Databases'], {
+      dbaasV2: { beta: false, enabled: false },
     });
 
     await waitFor(() => {
       expect(result.current.isDatabasesEnabled).toBe(true);
       expect(result.current.isDatabasesV1Enabled).toBe(true);
-      expect(result.current.isDatabasesV2Beta).toBe(false);
       expect(result.current.isDatabasesV2Enabled).toBe(false);
+
+      expect(result.current.isDatabasesV2Beta).toBe(false);
+      expect(result.current.isV2ExistingBetaUser).toBe(false);
+      expect(result.current.isV2NewBetaUser).toBe(false);
+
+      expect(result.current.isV2GAUser).toBe(false);
     });
   });
 
-  it('should return true for an unrestricted user with the account capability Beta', async () => {
-    const account = accountFactory.build({
-      capabilities: ['Managed Databases Beta'],
+  it('should return true for a new unrestricted user with the account capability V2 and beta feature flag', async () => {
+    const { result } = setup(['Managed Databases Beta'], {
+      dbaasV2: { beta: true, enabled: true },
     });
 
-    server.use(
-      http.get('*/v4/account', () => {
-        return HttpResponse.json(account);
-      })
-    );
+    await waitFor(() => {
+      expect(result.current.isDatabasesEnabled).toBe(true);
+      expect(result.current.isDatabasesV1Enabled).toBe(false);
+      expect(result.current.isDatabasesV2Enabled).toBe(true);
 
-    const { result } = renderHook(() => useIsDatabasesEnabled(), {
-      wrapper: (ui) =>
-        wrapWithTheme(ui, {
-          flags: { dbaasV2: { beta: true, enabled: true } },
-        }),
+      expect(result.current.isDatabasesV2Beta).toBe(true);
+      expect(result.current.isV2ExistingBetaUser).toBe(false);
+      expect(result.current.isV2NewBetaUser).toBe(true);
+
+      expect(result.current.isV2GAUser).toBe(false);
+    });
+  });
+
+  it('should return false for a new unrestricted user with the account capability V2 and no beta feature flag', async () => {
+    const { result } = setup(['Managed Databases Beta'], {
+      dbaasV2: { beta: true, enabled: false },
     });
 
     await waitFor(() => {
-      expect(result.current.isDatabasesEnabled).toBe(true);
+      expect(result.current.isDatabasesEnabled).toBe(false);
       expect(result.current.isDatabasesV1Enabled).toBe(false);
-      expect(result.current.isDatabasesV2Beta).toBe(true);
-      expect(result.current.isDatabasesV2Enabled).toBe(true);
+      expect(result.current.isDatabasesV2Enabled).toBe(false);
+
+      expect(result.current.isDatabasesV2Beta).toBe(false);
+      expect(result.current.isV2ExistingBetaUser).toBe(false);
+      expect(result.current.isV2NewBetaUser).toBe(false);
+
+      expect(result.current.isV2GAUser).toBe(false);
     });
   });
 
-  it('should return false for an unrestricted user without the account capability', async () => {
-    const account = accountFactory.build({
-      capabilities: [],
+  it('should return true for an existing unrestricted user with the account capability V1 & V2 and beta feature flag', async () => {
+    const { result } = setup(['Managed Databases', 'Managed Databases Beta'], {
+      dbaasV2: { beta: true, enabled: true },
     });
 
-    server.use(
-      http.get('*/v4/account', () => {
-        return HttpResponse.json(account);
-      })
-    );
+    await waitFor(() => {
+      expect(result.current.isDatabasesEnabled).toBe(true);
+      expect(result.current.isDatabasesV1Enabled).toBe(true);
+      expect(result.current.isDatabasesV2Enabled).toBe(true);
 
-    const { result } = renderHook(() => useIsDatabasesEnabled(), {
-      wrapper: wrapWithTheme,
+      expect(result.current.isDatabasesV2Beta).toBe(true);
+      expect(result.current.isV2ExistingBetaUser).toBe(true);
+      expect(result.current.isV2NewBetaUser).toBe(false);
+
+      expect(result.current.isV2GAUser).toBe(false);
+    });
+  });
+
+  it('should return true for an existing unrestricted user with the account capability V1 and no beta feature flag', async () => {
+    const { result } = setup(['Managed Databases'], {
+      dbaasV2: { beta: false, enabled: true },
     });
 
-    await waitFor(() => expect(result.current.isDatabasesEnabled).toBe(false));
+    await waitFor(() => {
+      expect(result.current.isDatabasesEnabled).toBe(true);
+      expect(result.current.isDatabasesV1Enabled).toBe(true);
+      expect(result.current.isDatabasesV2Enabled).toBe(false);
+
+      expect(result.current.isDatabasesV2Beta).toBe(false);
+      expect(result.current.isV2ExistingBetaUser).toBe(false);
+      expect(result.current.isV2NewBetaUser).toBe(false);
+
+      expect(result.current.isV2GAUser).toBe(true);
+    });
   });
 
   it('should return true for a restricted user who can not load account but can load database engines', async () => {
@@ -116,27 +169,77 @@ describe('useIsDatabasesEnabled', () => {
   });
 });
 
-describe('isOutsideBackupTimeframe', () => {
+describe('isDateOutsideBackup', () => {
   it('should return true if date is before the oldest backup', () => {
     const date = DateTime.now().minus({ days: 10 });
     const oldestBackup = DateTime.now().minus({ days: 5 });
-    expect(isOutsideBackupTimeframe(date, oldestBackup)).toBe(true);
+    expect(isDateOutsideBackup(date, oldestBackup)).toBe(true);
   });
 
   it('should return true if date is after today', () => {
     const date = DateTime.now().plus({ days: 1 });
     const oldestBackup = DateTime.now().minus({ days: 5 });
-    expect(isOutsideBackupTimeframe(date, oldestBackup)).toBe(true);
+    expect(isDateOutsideBackup(date, oldestBackup)).toBe(true);
   });
 
   it('should return false if date is between the oldest backup and today', () => {
     const date = DateTime.now().minus({ days: 3 });
     const oldestBackup = DateTime.now().minus({ days: 5 });
-    expect(isOutsideBackupTimeframe(date, oldestBackup)).toBe(false);
+    expect(isDateOutsideBackup(date, oldestBackup)).toBe(false);
   });
 
   it('should return true if there is no oldest backup', () => {
     const date = DateTime.now().minus({ days: 3 });
-    expect(isOutsideBackupTimeframe(date, null)).toBe(true);
+    expect(isDateOutsideBackup(date, null)).toBe(true);
+  });
+});
+
+describe('isTimeOutsideBackup', () => {
+  it('should return true when hour + selected date is before oldest backup', () => {
+    const selectedDate = DateTime.fromISO('2024-10-02');
+    const oldestBackup = DateTime.fromISO('2024-10-02T09:00:00');
+    const result = isTimeOutsideBackup(8, selectedDate, oldestBackup);
+    expect(result).toEqual(true);
+  });
+
+  it('should return false when hour + selected date is equal to the oldest backup', () => {
+    const selectedDate = DateTime.fromISO('2024-10-02');
+    const oldestBackup = DateTime.fromISO('2024-10-02T09:00:00');
+    const result = isTimeOutsideBackup(9, selectedDate, oldestBackup);
+    expect(result).toEqual(false);
+  });
+
+  it('should return false when hour + selected date is after the oldest backup', () => {
+    const selectedDate = DateTime.fromISO('2024-10-03');
+    const oldestBackup = DateTime.fromISO('2024-10-02T09:00:00');
+    const result = isTimeOutsideBackup(1, selectedDate, oldestBackup);
+    expect(result).toEqual(false);
+  });
+});
+
+describe('toISOString', () => {
+  it('should convert a date and time to ISO string format', () => {
+    const selectedDate = DateTime.fromObject({ year: 2023, month: 5, day: 15 });
+    const selectedTime: TimeOption = { label: '02:00', value: 14 };
+    const result = toISOString(selectedDate, selectedTime.value);
+    expect(result).toContain('2023-05-15T14:00');
+  });
+
+  it('should handle midnight correctly', () => {
+    const selectedDate = DateTime.fromObject({
+      year: 2023,
+      month: 12,
+      day: 31,
+    });
+    const selectedTime: TimeOption = { label: '12:00 AM', value: 0 };
+    const result = toISOString(selectedDate, selectedTime.value);
+    expect(result).toContain('2023-12-31T00:00');
+  });
+
+  it('should handle noon correctly', () => {
+    const selectedDate = DateTime.fromObject({ year: 2024, month: 1, day: 1 });
+    const selectedTime: TimeOption = { label: '12:00 PM', value: 12 };
+    const result = toISOString(selectedDate, selectedTime.value);
+    expect(result).toContain('2024-01-01T12:00');
   });
 });
diff --git a/packages/manager/src/features/Databases/utilities.ts b/packages/manager/src/features/Databases/utilities.ts
index 85bd6623f50..d1b6cea6b49 100644
--- a/packages/manager/src/features/Databases/utilities.ts
+++ b/packages/manager/src/features/Databases/utilities.ts
@@ -1,15 +1,14 @@
+import { DatabaseFork } from '@linode/api-v4';
 import { DateTime } from 'luxon';
 
 import { useFlags } from 'src/hooks/useFlags';
 import { useAccount } from 'src/queries/account/account';
 import { useDatabaseEnginesQuery } from 'src/queries/databases/databases';
+import { isFeatureEnabledV2 } from 'src/utilities/accountCapabilities';
 
 /**
  * A hook to determine if Databases should be visible to the user.
  *
- * Because DBaaS is end of sale, we treat it differently than other products.
- * It should only be visible to customers with the account capability.
- *
  * For unrestricted users, databases will show when
  * The user has the `Managed Databases` account capability.
  *
@@ -28,32 +27,34 @@ export const useIsDatabasesEnabled = () => {
 
   const { data: engines } = useDatabaseEnginesQuery(checkRestrictedUser);
   const flags = useFlags();
+  const isBeta = !!flags.dbaasV2?.beta;
 
   if (account) {
-    const isDatabasesV1Enabled = account.capabilities.includes(
-      'Managed Databases'
+    const isDatabasesV1Enabled = isFeatureEnabledV2(
+      'Managed Databases',
+      true,
+      account?.capabilities ?? []
     );
 
-    const isDatabasesV2Enabled =
-      account.capabilities.includes('Managed Databases Beta') &&
-      flags.dbaasV2?.enabled;
+    const isDatabasesV2Enabled = isFeatureEnabledV2(
+      'Managed Databases Beta',
+      !!flags.dbaasV2?.enabled,
+      account?.capabilities ?? []
+    );
 
     const isV2ExistingBetaUser =
-      account.capabilities.includes('Managed Databases') &&
-      account.capabilities.includes('Managed Databases Beta') &&
-      flags.dbaasV2?.enabled &&
-      flags.dbaasV2?.beta;
+      isBeta && isDatabasesV1Enabled && isDatabasesV2Enabled;
 
     const isV2NewBetaUser =
-      account.capabilities.includes('Managed Databases Beta') &&
-      !account.capabilities.includes('Managed Databases') &&
-      flags.dbaasV2?.enabled &&
-      flags.dbaasV2?.beta;
+      isBeta && !isDatabasesV1Enabled && isDatabasesV2Enabled;
 
     const isV2GAUser =
-      account.capabilities.includes('Managed Databases') &&
-      flags.dbaasV2?.enabled &&
-      !flags.dbaasV2?.beta;
+      !isBeta &&
+      isFeatureEnabledV2(
+        'Managed Databases',
+        !!flags.dbaasV2?.enabled,
+        account?.capabilities ?? []
+      );
 
     return {
       isDatabasesEnabled: isDatabasesV1Enabled || isDatabasesV2Enabled,
@@ -82,17 +83,100 @@ export const useIsDatabasesEnabled = () => {
  *   - `true` if the date is before the oldest backup or after today.
  *   - `false` if the date is within the range between the oldest backup and today.
  */
-export const isOutsideBackupTimeframe = (
+export const isDateOutsideBackup = (
   date: DateTime,
-  oldestBackup: DateTime | null
+  oldestBackup: DateTime | null | undefined
 ) => {
   if (!oldestBackup) {
     return true;
   }
+  const today = DateTime.now();
+  return date < oldestBackup || date > today;
+};
+
+/**
+ * Check if the time added to the selectedDate is outside the backup window.
+ *
+ * @param hour
+ * @param selectedDate
+ * @param oldestBackup
+ * @returns true when the selectedDate + hour is before the oldest backup DateTime or later than DateTime.now()
+ */
+export const isTimeOutsideBackup = (
+  time: number | undefined,
+  selectedDate: DateTime,
+  oldestBackup: DateTime
+) => {
+  if (time == null) {
+    return false;
+  }
+  const selectedDateTime = toSelectedDateTime(selectedDate, time);
+  return isDateOutsideBackup(selectedDateTime, oldestBackup);
+};
+
+/**
+ * Convert the selectedDate and selectedTime into a date as a string value in ISO format.
+ *
+ * @param selectedDate
+ * @param selectedTime
+ * @returns date as a string value in ISO format.
+ */
+export const toISOString = (selectedDate: DateTime, selectedTime: number) => {
+  const selectedDateTime = toSelectedDateTime(selectedDate, selectedTime);
+  return selectedDateTime.toISO({ includeOffset: false });
+};
 
-  const today = DateTime.now().startOf('day');
-  const backupStart = oldestBackup.startOf('day');
-  const dateStart = date.startOf('day');
+export const toSelectedDateTime = (
+  selectedDate: DateTime,
+  time: number = 0
+) => {
+  const isoDate = selectedDate?.toISODate();
+  const isoTime = DateTime.now()
+    .set({ hour: time, minute: 0 })
+    ?.toISOTime({ includeOffset: false });
+  const selectedDateTime = DateTime.fromISO(`${isoDate}T${isoTime}`);
+  return selectedDateTime;
+};
+
+/**
+ * Format the selectedDate and time as a modified (i.e. shortened) ISO format
+ * If no date/time is provided it will default to DateTime.now()
+ *
+ * @param selectedDate
+ * @param selectedTime
+ * @returns date string in the format 'YYYY-MM-ddThh:mm:ss'
+ */
+export const toFormatedDate = (
+  selectedDate?: DateTime | null,
+  selectedTime?: number
+) => {
+  const today = DateTime.now();
+  const isoDate =
+    selectedDate && selectedTime
+      ? toISOString(selectedDate!, selectedTime)
+      : toISOString(today, today.hour);
 
-  return dateStart < backupStart || dateStart > today;
+  return `${isoDate?.split('T')[0]} ${isoDate?.split('T')[1].slice(0, 5)}`;
+};
+
+/**
+ * Convert the sourceId and optional selectedDate and selecteTime into the DatabaseFork payload.
+ *
+ * @param sourceId
+ * @param selectedDate
+ * @param selectedTime
+ * @returns Databasefork object with at least the sourceId
+ */
+export const toDatabaseFork = (
+  sourceId: number,
+  selectedDate?: DateTime | null,
+  selectedTime?: number
+) => {
+  const fork: DatabaseFork = {
+    source: sourceId,
+  };
+  if (selectedDate && selectedTime) {
+    fork.restore_time = toISOString(selectedDate!, selectedTime)!;
+  }
+  return fork;
 };
diff --git a/packages/manager/src/queries/databases/databases.ts b/packages/manager/src/queries/databases/databases.ts
index 64777bec5e5..4ca5d85c42a 100644
--- a/packages/manager/src/queries/databases/databases.ts
+++ b/packages/manager/src/queries/databases/databases.ts
@@ -33,6 +33,7 @@ import type {
   DatabaseBackup,
   DatabaseCredentials,
   DatabaseEngine,
+  DatabaseFork,
   DatabaseInstance,
   DatabaseType,
   Engine,
@@ -240,13 +241,10 @@ export const useLegacyRestoreFromBackupMutation = (
 
 export const useRestoreFromBackupMutation = (
   engine: Engine,
-  fork: {
-    restore_time?: string;
-    source: number;
-  }
+  fork: DatabaseFork
 ) => {
   const queryClient = useQueryClient();
-  return useMutation<{}, APIError[]>({
+  return useMutation<Database, APIError[]>({
     mutationFn: () => restoreWithBackup(engine, fork),
     onSuccess() {
       queryClient.invalidateQueries({