diff --git a/.changeset/saved-search-time-range.md b/.changeset/saved-search-time-range.md
new file mode 100644
index 0000000000..7034cb8e6f
--- /dev/null
+++ b/.changeset/saved-search-time-range.md
@@ -0,0 +1,7 @@
+---
+'@hyperdx/api': minor
+'@hyperdx/app': minor
+'@hyperdx/common-utils': minor
+---
+
+feat: saved searches can store a default time range (e.g. past 1 day) to open with instead of live tail, chosen in the save modal under "When opened"
diff --git a/packages/api/src/models/savedSearch.ts b/packages/api/src/models/savedSearch.ts
index 54e49ea657..cd64f1ae25 100644
--- a/packages/api/src/models/savedSearch.ts
+++ b/packages/api/src/models/savedSearch.ts
@@ -61,6 +61,7 @@ const savedSearchSchema = new Schema<
     },
     tags: [String],
     filters: [{ type: mongoose.Schema.Types.Mixed }],
+    defaultTimeRange: { type: mongoose.Schema.Types.Mixed, required: false },
     // Immutable: ownership attribution is set once at creation.
     createdBy: {
       type: mongoose.Schema.Types.ObjectId,
diff --git a/packages/api/src/routers/api/__tests__/savedSearch.int.test.ts b/packages/api/src/routers/api/__tests__/savedSearch.int.test.ts
index 6a51905ee5..7bc6744f93 100644
--- a/packages/api/src/routers/api/__tests__/savedSearch.int.test.ts
+++ b/packages/api/src/routers/api/__tests__/savedSearch.int.test.ts
@@ -101,6 +101,82 @@ describe('savedSearch router', () => {
     expect(updatedSavedSearch.body.select).toBe('SELECT 1');
   });
 
+  describe('defaultTimeRange', () => {
+    const ONE_DAY = { type: 'relative', value: 86400 };
+
+    it('persists a default time range on create and returns it from GET', async () => {
+      await agent
+        .post('/saved-search')
+        .send({ ...MOCK_SAVED_SEARCH, defaultTimeRange: ONE_DAY })
+        .expect(200);
+      const savedSearches = await agent.get('/saved-search').expect(200);
+      expect(savedSearches.body[0].defaultTimeRange).toEqual(ONE_DAY);
+    });
+
+    it('keeps the stored range when an update omits it', async () => {
+      const created = await agent
+        .post('/saved-search')
+        .send({ ...MOCK_SAVED_SEARCH, defaultTimeRange: ONE_DAY })
+        .expect(200);
+      const updated = await agent
+        .patch(`/saved-search/${created.body._id}`)
+        .send({ name: 'renamed' })
+        .expect(200);
+      expect(updated.body.defaultTimeRange).toEqual(ONE_DAY);
+    });
+
+    it('clears the stored range when an update sends null', async () => {
+      const created = await agent
+        .post('/saved-search')
+        .send({ ...MOCK_SAVED_SEARCH, defaultTimeRange: ONE_DAY })
+        .expect(200);
+      await agent
+        .patch(`/saved-search/${created.body._id}`)
+        .send({ defaultTimeRange: null })
+        .expect(200);
+      const dbRecord = await SavedSearch.findById(created.body._id);
+      expect(dbRecord?.defaultTimeRange ?? null).toBeNull();
+    });
+
+    it('rejects a malformed range', async () => {
+      await agent
+        .post('/saved-search')
+        .send({ ...MOCK_SAVED_SEARCH, defaultTimeRange: '1d' })
+        .expect(400);
+      await agent
+        .post('/saved-search')
+        .send({
+          ...MOCK_SAVED_SEARCH,
+          defaultTimeRange: { type: 'relative', value: 0 },
+        })
+        .expect(400);
+    });
+
+    it('rejects a fixed window', async () => {
+      await agent
+        .post('/saved-search')
+        .send({
+          ...MOCK_SAVED_SEARCH,
+          defaultTimeRange: {
+            type: 'historical',
+            value: [1700000000000, 1700003600000],
+          },
+        })
+        .expect(400);
+    });
+
+    it('still rejects null for fields that are not nullable', async () => {
+      const created = await agent
+        .post('/saved-search')
+        .send(MOCK_SAVED_SEARCH)
+        .expect(200);
+      await agent
+        .patch(`/saved-search/${created.body._id}`)
+        .send({ orderBy: null })
+        .expect(400);
+    });
+  });
+
   it('can get saved searches', async () => {
     await agent.post('/saved-search').send(MOCK_SAVED_SEARCH).expect(200);
     const savedSearches = await agent.get('/saved-search').expect(200);
diff --git a/packages/api/src/routers/api/savedSearch.ts b/packages/api/src/routers/api/savedSearch.ts
index 867a0bf8be..4362212773 100644
--- a/packages/api/src/routers/api/savedSearch.ts
+++ b/packages/api/src/routers/api/savedSearch.ts
@@ -86,9 +86,11 @@ router.patch(
       // Re-parse: validateRequest validates without replacing req.body, so
       // server-owned keys like `team`/`createdBy` would otherwise reach the
       // update. Parsing drops every key the schema doesn't declare.
+      // Only undefined is dropped: an explicit null clears a nullable field
+      // (defaultTimeRange), and the schema rejects null for every other field.
       const updates = _.omitBy(
         updateSavedSearchBodySchema.parse(req.body),
-        _.isNil,
+        _.isUndefined,
       );
 
       const updatedSavedSearch = await updateSavedSearch(
diff --git a/packages/app/src/DBSearchPage.tsx b/packages/app/src/DBSearchPage.tsx
index 4466eadd8c..f51d509fab 100644
--- a/packages/app/src/DBSearchPage.tsx
+++ b/packages/app/src/DBSearchPage.tsx
@@ -153,6 +153,11 @@ import {
 import ChartSQLPreview, { SQLPreview } from './components/ChartSQLPreview';
 import DBSqlRowTableWithSideBar from './components/DBSqlRowTableWithSidebar';
 import PatternTable from './components/PatternTable';
+import { getSavedSearchLanding } from './components/SavedSearches/savedSearchTimeRange';
+import {
+  SaveTimeRangeField,
+  useSaveTimeRangeField,
+} from './components/SavedSearches/SaveTimeRangeField';
 import { DBSearchHeatmapChart } from './components/Search/DBSearchHeatmapChart';
 import DirectTraceSidePanel from './components/Search/DirectTraceSidePanel';
 import SourceSchemaPreview, {
@@ -465,6 +470,10 @@ function SaveSearchModalComponent({
   onCreate,
   isUpdate,
   savedSearchId,
+  isLive,
+  liveIntervalMs,
+  searchedTimeRange,
+  openedAtMs,
 }: {
   searchedConfig: SearchConfig;
   opened: boolean;
@@ -472,6 +481,10 @@ function SaveSearchModalComponent({
   onCreate: (savedSearchId: string) => Promise<void>;
   isUpdate: boolean;
   savedSearchId: string | undefined | null;
+  isLive: boolean;
+  liveIntervalMs: number;
+  searchedTimeRange: [Date, Date];
+  openedAtMs: number | null;
 }) {
   const { data: savedSearch } = useSavedSearch(
     { id: savedSearchId ?? '' },
@@ -480,6 +493,14 @@ function SaveSearchModalComponent({
     },
   );
 
+  const timeRangeField = useSaveTimeRangeField({
+    openedAtMs,
+    isLive,
+    liveIntervalMs,
+    searchedTimeRange,
+    stored: savedSearch?.defaultTimeRange,
+  });
+
   const {
     control,
     handleSubmit,
@@ -528,6 +549,9 @@ function SaveSearchModalComponent({
     e.preventDefault();
 
     handleSubmit(async ({ name }) => {
+      const timeRange = timeRangeField.resolve(isUpdate);
+      const defaultTimeRangeUpdate =
+        timeRange === undefined ? {} : { defaultTimeRange: timeRange };
       if (isUpdate) {
         if (savedSearchId == null) {
           throw new Error('savedSearchId is required for update');
@@ -545,6 +569,7 @@ function SaveSearchModalComponent({
             orderBy: searchedConfig.orderBy ?? '',
             filters: searchedConfig.filters ?? [],
             tags: tags,
+            ...defaultTimeRangeUpdate,
           },
           {
             onSuccess: () => {
@@ -573,6 +598,7 @@ function SaveSearchModalComponent({
             orderBy: searchedConfig.orderBy ?? '',
             filters: searchedConfig.filters ?? [],
             tags: tags,
+            ...defaultTimeRangeUpdate,
           });
 
           await onCreate(savedSearch.id);
@@ -701,6 +727,7 @@ function SaveSearchModalComponent({
               </Tags>
             </Group>
           </Box>
+          <SaveTimeRangeField field={timeRangeField} />
           <Button
             data-testid="save-search-submit-button"
             variant="primary"
@@ -1131,6 +1158,10 @@ function DBSearchPageContent() {
     'isLive',
     parseAsBoolean.withDefault(true),
   );
+  const [interval, setInterval] = useQueryState(
+    'liveInterval',
+    parseAsInteger.withDefault(LIVE_TAIL_DURATION_MS),
+  );
 
   useEffect(() => {
     if (analysisMode === 'delta' || analysisMode === 'pattern') {
@@ -1291,6 +1322,28 @@ function DBSearchPageContent() {
       savedSearch.id === savedSearchId && // Make sure we've loaded the correct saved search
       isSearchConfigEmpty // Only populate if URL doesn't have explicit config
     ) {
+      const nowMs = performance.timeOrigin + performance.now();
+      const landing = getSavedSearchLanding(
+        savedSearch.defaultTimeRange,
+        window.location.search,
+        nowMs,
+      );
+      // Replace, not push: a pushed entry would leave the bare URL behind,
+      // and Back would land on it and re-apply the range forever.
+      if (landing?.kind === 'live') {
+        // Same writes as picking a live tail range in the time picker.
+        const [start, end] = parseRelativeTimeQuery(landing.intervalMs, nowMs);
+        setIsLive(true, { history: 'replace' });
+        setInterval(landing.intervalMs, { history: 'replace' });
+        onTimeRangeSelect(start, end, null, { history: 'replace' });
+        const label = getRelativeTimeOptionLabel(landing.intervalMs);
+        if (label) setDisplayedTimeInputValue(label);
+      } else if (landing?.kind === 'window') {
+        setIsLive(false, { history: 'replace' });
+        onTimeRangeSelect(landing.range[0], landing.range[1], undefined, {
+          history: 'replace',
+        });
+      }
       setSearchedConfig({
         source: savedSearch.source,
         where: savedSearch.where,
@@ -1327,6 +1380,9 @@ function DBSearchPageContent() {
     defaultSourceId,
     directTraceId,
     sources,
+    setIsLive,
+    setInterval,
+    onTimeRangeSelect,
   ]);
 
   const [_queryErrors, setQueryErrors] = useState<{
@@ -1593,9 +1649,19 @@ function DBSearchPageContent() {
   }, [setIsLive]);
 
   const [modelFormExpanded, setModelFormExpanded] = useState(false); // Used in local mode
+  // openedAtMs is read in the click handler: the modal compares it with the
+  // searched window to decide whether that window reads as "the past N".
   const [saveSearchModalState, setSaveSearchModalState] = useState<
-    'create' | 'update' | undefined
+    { mode: 'create' | 'update'; openedAtMs: number } | undefined
   >(undefined);
+  const openSaveSearchModal = useCallback(
+    (mode: 'create' | 'update') =>
+      setSaveSearchModalState({
+        mode,
+        openedAtMs: performance.timeOrigin + performance.now(),
+      }),
+    [],
+  );
   const chartSearchConfig = useMemo(
     () => ({
       select: searchedConfig.select ?? '',
@@ -1644,7 +1710,7 @@ function DBSearchPageContent() {
   const deleteSavedSearch = useDeleteSavedSearch();
   const onSaveSearch = useCallback(() => {
     if (savedSearch == null) {
-      setSaveSearchModalState('create');
+      openSaveSearchModal('create');
     } else {
       handleSubmit(s => {
         updateSavedSearch.mutate(
@@ -1661,7 +1727,13 @@ function DBSearchPageContent() {
         );
       })();
     }
-  }, [savedSearch, updateSavedSearch, onSubmit, handleSubmit]);
+  }, [
+    savedSearch,
+    updateSavedSearch,
+    onSubmit,
+    handleSubmit,
+    openSaveSearchModal,
+  ]);
 
   const handleUpdateTags = useCallback(
     (newTags: string[]) => {
@@ -1721,11 +1793,6 @@ function DBSearchPageContent() {
   // State for collapsing all expanded rows when resuming live tail
   const [collapseAllRows, setCollapseAllRows] = useState(false);
 
-  const [interval, setInterval] = useQueryState(
-    'liveInterval',
-    parseAsInteger.withDefault(LIVE_TAIL_DURATION_MS),
-  );
-
   const [refreshFrequency, setRefreshFrequency] = useQueryState(
     'refreshFrequency',
     parseAsInteger.withDefault(DEFAULT_REFRESH_FREQUENCY),
@@ -2482,7 +2549,7 @@ function DBSearchPageContent() {
                   });
                 }}
                 onClickSaveAsNew={() => {
-                  setSaveSearchModalState('create');
+                  openSaveSearchModal('create');
                 }}
               />
             </Group>
@@ -2543,7 +2610,7 @@ function DBSearchPageContent() {
                 variant="secondary"
                 size="xs"
                 onClick={() => {
-                  setSaveSearchModalState('update');
+                  openSaveSearchModal('update');
                 }}
                 style={{ flexShrink: 0 }}
               >
@@ -2668,8 +2735,12 @@ function DBSearchPageContent() {
           onClose={clearSaveSearchModalState}
           onCreate={onSavedSearchCreated}
           searchedConfig={searchedConfig}
-          isUpdate={saveSearchModalState === 'update'}
+          isUpdate={saveSearchModalState?.mode === 'update'}
           savedSearchId={savedSearchId}
+          isLive={isLive}
+          liveIntervalMs={interval}
+          searchedTimeRange={searchedTimeRange}
+          openedAtMs={saveSearchModalState?.openedAtMs ?? null}
         />
       )}
       <DirectTraceSidePanel
diff --git a/packages/app/src/components/SavedSearches/SaveTimeRangeField.tsx b/packages/app/src/components/SavedSearches/SaveTimeRangeField.tsx
new file mode 100644
index 0000000000..467cef0bd5
--- /dev/null
+++ b/packages/app/src/components/SavedSearches/SaveTimeRangeField.tsx
@@ -0,0 +1,135 @@
+import { useMemo, useState } from 'react';
+import { RelativeDateRange } from '@hyperdx/common-utils/dist/types';
+import { Radio, Stack, Text } from '@mantine/core';
+
+import { LIVE_TAIL_DURATION_MS } from '@/components/TimePicker/utils';
+
+import {
+  CurrentTimeRange,
+  formatRelativeDuration,
+  getTimeRangeChoices,
+  isLiveTailDuration,
+  resolveDefaultTimeRange,
+  TimeRangeChoice,
+} from './savedSearchTimeRange';
+
+function isTimeRangeChoice(value: string): value is TimeRangeChoice {
+  return value === 'live' || value === 'keep' || value === 'current';
+}
+
+/** What opening the search will show, e.g. "live tail, past 1 hour". */
+function describeRange(range: RelativeDateRange): string {
+  const duration = `past ${formatRelativeDuration(range.value)}`;
+  return isLiveTailDuration(range.value * 1000)
+    ? `live tail, ${duration}`
+    : duration;
+}
+
+export function useSaveTimeRangeField({
+  openedAtMs,
+  isLive,
+  liveIntervalMs,
+  searchedTimeRange,
+  stored,
+}: {
+  /** When the modal was opened, or null while it is closed. */
+  openedAtMs: number | null;
+  isLive: boolean;
+  liveIntervalMs: number;
+  searchedTimeRange: [Date, Date];
+  stored: RelativeDateRange | null | undefined;
+}) {
+  // Live updates pause while the save modal is open, so the window is stable.
+  const options = useMemo(() => {
+    const current: CurrentTimeRange = isLive
+      ? { kind: 'live', intervalMs: liveIntervalMs }
+      : { kind: 'window', range: searchedTimeRange };
+    return getTimeRangeChoices({
+      current,
+      stored,
+      nowMs: openedAtMs ?? 0,
+    });
+  }, [openedAtMs, isLive, liveIntervalMs, searchedTimeRange, stored]);
+
+  // A pick only counts for the opening it was made in. Until then the default
+  // applies, which can change once the stored saved search loads.
+  const [picked, setPicked] = useState<{
+    openedAtMs: number | null;
+    choice: TimeRangeChoice;
+  } | null>(null);
+  const pickedChoice =
+    picked != null && picked.openedAtMs === openedAtMs ? picked.choice : null;
+
+  const choice =
+    pickedChoice != null && options.choices.includes(pickedChoice)
+      ? pickedChoice
+      : options.defaultChoice;
+
+  return {
+    ...options,
+    isLive,
+    stored,
+    choice,
+    setChoice: (next: TimeRangeChoice) =>
+      setPicked({ openedAtMs, choice: next }),
+    resolve: (isUpdate: boolean) =>
+      resolveDefaultTimeRange({
+        isUpdate,
+        choice,
+        stored,
+        currentRange: options.currentRange,
+      }),
+  };
+}
+
+export function SaveTimeRangeField({
+  field,
+}: {
+  field: ReturnType<typeof useSaveTimeRangeField>;
+}) {
+  const { choices, choice, setChoice, stored, currentRange, isLive } = field;
+
+  return (
+    <Stack gap="xs">
+      <Radio.Group
+        data-testid="save-search-time-range"
+        label="When opened"
+        size="xs"
+        value={choice}
+        onChange={value => {
+          if (isTimeRangeChoice(value)) setChoice(value);
+        }}
+      >
+        <Stack gap="xs" mt="xs">
+          <Radio
+            value="live"
+            label={`Show live tail (past ${formatRelativeDuration(LIVE_TAIL_DURATION_MS / 1000)})`}
+          />
+          {choices.includes('keep') && stored != null && (
+            <Radio
+              value="keep"
+              label={`Show the saved time range (${describeRange(stored)})`}
+            />
+          )}
+          {choices.includes('current') && currentRange != null && (
+            <Radio
+              value="current"
+              label={
+                isLiveTailDuration(currentRange.value * 1000)
+                  ? `Show live tail for the past ${formatRelativeDuration(currentRange.value)}`
+                  : `Show the past ${formatRelativeDuration(currentRange.value)}`
+              }
+            />
+          )}
+        </Stack>
+      </Radio.Group>
+      {choices.length === 1 && (
+        <Text size="xs" c="dimmed">
+          {isLive
+            ? 'Live tail is the default. To save a time range, pick one first.'
+            : 'To save a time range, pick one that ends now.'}
+        </Text>
+      )}
+    </Stack>
+  );
+}
diff --git a/packages/app/src/components/SavedSearches/__tests__/savedSearchTimeRange.test.ts b/packages/app/src/components/SavedSearches/__tests__/savedSearchTimeRange.test.ts
new file mode 100644
index 0000000000..9703d65cb5
--- /dev/null
+++ b/packages/app/src/components/SavedSearches/__tests__/savedSearchTimeRange.test.ts
@@ -0,0 +1,219 @@
+import {
+  formatRelativeDuration,
+  getSavedSearchLanding,
+  getTimeRangeChoices,
+  hasExplicitTimeParams,
+  isLiveTailDuration,
+  isRangeEndingNow,
+  resolveDefaultTimeRange,
+  toDefaultTimeRange,
+} from '@/components/SavedSearches/savedSearchTimeRange';
+
+const NOW = Date.UTC(2026, 10, 6, 12, 0, 0, 500);
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const ONE_DAY = { type: 'relative' as const, value: 86400 };
+const ONE_HOUR = { type: 'relative' as const, value: 3600 };
+
+const windowEndingAt = (end: number, durationMs: number): [Date, Date] => [
+  new Date(end - durationMs),
+  new Date(end),
+];
+
+describe('hasExplicitTimeParams', () => {
+  it.each([
+    ['', false],
+    ['?source=abc&where=x', false],
+    ['?from=1&to=2', false],
+    ['?from=1&to=2&isLive=false', true],
+    ['?isLive=true', true],
+    ['?liveInterval=300000', true],
+  ])('%s -> %s', (search, expected) => {
+    expect(hasExplicitTimeParams(search)).toBe(expected);
+  });
+});
+
+describe('isLiveTailDuration', () => {
+  it.each([
+    [MINUTE, true],
+    [HOUR, true],
+    [6 * HOUR, true],
+    [12 * HOUR, false],
+    [DAY, false],
+    [90 * MINUTE, false],
+  ])('%i ms -> %s', (durationMs, expected) => {
+    expect(isLiveTailDuration(durationMs)).toBe(expected);
+  });
+});
+
+describe('getSavedSearchLanding', () => {
+  it('opens a range live tail supports as live tail with that interval', () => {
+    expect(getSavedSearchLanding(ONE_HOUR, '', NOW)).toEqual({
+      kind: 'live',
+      intervalMs: HOUR,
+    });
+  });
+
+  it('opens a longer range as a window ending at the current second', () => {
+    const end = NOW - 500;
+    expect(getSavedSearchLanding(ONE_DAY, '', NOW)).toEqual({
+      kind: 'window',
+      range: [new Date(end - DAY), new Date(end)],
+    });
+  });
+
+  it('yields to a time already in the URL', () => {
+    expect(
+      getSavedSearchLanding(ONE_DAY, '?from=1&to=2&isLive=false', NOW),
+    ).toBeNull();
+  });
+
+  it.each([
+    ['missing', undefined],
+    ['null', null],
+  ])('ignores a %s range', (_name, stored) => {
+    expect(getSavedSearchLanding(stored, '', NOW)).toBeNull();
+  });
+});
+
+describe('toDefaultTimeRange', () => {
+  it('snaps to a preset within one second', () => {
+    expect(toDefaultTimeRange(DAY + 800)).toEqual(ONE_DAY);
+  });
+
+  it('rounds other durations to whole seconds', () => {
+    expect(toDefaultTimeRange(90 * MINUTE + 400)).toEqual({
+      type: 'relative',
+      value: 5400,
+    });
+  });
+});
+
+describe('isRangeEndingNow', () => {
+  it('allows at least a minute of slack', () => {
+    expect(
+      isRangeEndingNow(windowEndingAt(NOW - 59 * SECOND, MINUTE), NOW),
+    ).toBe(true);
+    expect(
+      isRangeEndingNow(windowEndingAt(NOW - 61 * SECOND, MINUTE), NOW),
+    ).toBe(false);
+  });
+
+  it('allows 10% of the duration for long windows', () => {
+    const twoHoursAgo = NOW - 2 * 60 * MINUTE;
+    expect(isRangeEndingNow(windowEndingAt(twoHoursAgo, DAY), NOW)).toBe(true);
+  });
+
+  it('rejects a window that ended in the past', () => {
+    const oct2 = Date.UTC(2026, 9, 2);
+    expect(isRangeEndingNow(windowEndingAt(oct2, DAY), NOW)).toBe(false);
+  });
+});
+
+describe('formatRelativeDuration', () => {
+  it.each([
+    [86400, '1 day'],
+    [5400, '1 hour 30 minutes'],
+    [30 * 86400, '30 days'],
+  ])('%i -> %s', (seconds, expected) => {
+    expect(formatRelativeDuration(seconds)).toBe(expected);
+  });
+});
+
+describe('getTimeRangeChoices', () => {
+  const lastDay = { kind: 'window' as const, range: windowEndingAt(NOW, DAY) };
+
+  it('offers only live tail during default live tail with nothing stored', () => {
+    expect(
+      getTimeRangeChoices({
+        current: { kind: 'live', intervalMs: 15 * MINUTE },
+        stored: null,
+        nowMs: NOW,
+      }),
+    ).toEqual({ choices: ['live'], defaultChoice: 'live', currentRange: null });
+  });
+
+  it('offers a live tail interval picked in the time picker', () => {
+    expect(
+      getTimeRangeChoices({
+        current: { kind: 'live', intervalMs: HOUR },
+        stored: null,
+        nowMs: NOW,
+      }),
+    ).toEqual({
+      choices: ['live', 'current'],
+      defaultChoice: 'live',
+      currentRange: ONE_HOUR,
+    });
+  });
+
+  it('offers the current window when it ends now, defaulting to live tail', () => {
+    expect(
+      getTimeRangeChoices({ current: lastDay, stored: null, nowMs: NOW }),
+    ).toEqual({
+      choices: ['live', 'current'],
+      defaultChoice: 'live',
+      currentRange: ONE_DAY,
+    });
+  });
+
+  it('defaults to keeping a stored range', () => {
+    const tenMinutes = {
+      kind: 'window' as const,
+      range: windowEndingAt(NOW, 10 * MINUTE),
+    };
+    expect(
+      getTimeRangeChoices({ current: tenMinutes, stored: ONE_DAY, nowMs: NOW }),
+    ).toMatchObject({
+      choices: ['live', 'keep', 'current'],
+      defaultChoice: 'keep',
+    });
+  });
+
+  it('does not offer the current window when it equals the stored range', () => {
+    expect(
+      getTimeRangeChoices({ current: lastDay, stored: ONE_DAY, nowMs: NOW })
+        .choices,
+    ).toEqual(['live', 'keep']);
+  });
+
+  it('does not offer a window brushed into the past', () => {
+    const brushed = {
+      kind: 'window' as const,
+      range: windowEndingAt(NOW - 3 * 60 * MINUTE, 10 * MINUTE),
+    };
+    expect(
+      getTimeRangeChoices({ current: brushed, stored: ONE_DAY, nowMs: NOW })
+        .choices,
+    ).toEqual(['live', 'keep']);
+  });
+});
+
+describe('resolveDefaultTimeRange', () => {
+  const TEN_MINUTES = { type: 'relative' as const, value: 600 };
+
+  it.each([
+    [true, 'keep', ONE_DAY, undefined],
+    [true, 'current', ONE_DAY, TEN_MINUTES],
+    [true, 'current', null, TEN_MINUTES],
+    [true, 'live', ONE_DAY, null],
+    [true, 'live', null, undefined],
+    [false, 'keep', ONE_DAY, ONE_DAY],
+    [false, 'current', null, TEN_MINUTES],
+    [false, 'live', ONE_DAY, undefined],
+  ] as const)(
+    'update=%s choice=%s stored=%j -> %j',
+    (isUpdate, choice, stored, expected) => {
+      expect(
+        resolveDefaultTimeRange({
+          isUpdate,
+          choice,
+          stored,
+          currentRange: TEN_MINUTES,
+        }),
+      ).toEqual(expected);
+    },
+  );
+});
diff --git a/packages/app/src/components/SavedSearches/savedSearchTimeRange.ts b/packages/app/src/components/SavedSearches/savedSearchTimeRange.ts
new file mode 100644
index 0000000000..c9446b4d89
--- /dev/null
+++ b/packages/app/src/components/SavedSearches/savedSearchTimeRange.ts
@@ -0,0 +1,161 @@
+import { formatDuration, intervalToDuration } from 'date-fns';
+import { RelativeDateRange } from '@hyperdx/common-utils/dist/types';
+
+import {
+  LIVE_TAIL_DURATION_MS,
+  RELATIVE_TIME_OPTIONS,
+} from '@/components/TimePicker/utils';
+import { parseRelativeTimeQuery } from '@/timeQuery';
+
+/**
+ * URL params that mean the link already chose a time, so a saved search's
+ * default time range must not override it. Not `from`/`to`: live tail writes
+ * those on every tick and they mean live tail unless `isLive=false` is also
+ * set, which every link to a specific window (alerts, save redirects) carries.
+ */
+const EXPLICIT_TIME_PARAMS = ['isLive', 'liveInterval'] as const;
+
+export function hasExplicitTimeParams(search: string): boolean {
+  const params = new URLSearchParams(search);
+  return EXPLICIT_TIME_PARAMS.some(key => params.has(key));
+}
+
+const SNAP_TOLERANCE_MS = 1000;
+const ENDS_NOW_MIN_TOLERANCE_MS = 60 * 1000;
+
+/** Durations live tail can stream (the presets with relative support). */
+export function isLiveTailDuration(durationMs: number): boolean {
+  return RELATIVE_TIME_OPTIONS.some(
+    option =>
+      option !== 'divider' && option[2] === true && option[1] === durationMs,
+  );
+}
+
+export type SavedSearchLanding =
+  | { kind: 'live'; intervalMs: number }
+  | { kind: 'window'; range: [Date, Date] };
+
+/**
+ * How to open a saved search, or null to keep today's default. Ranges live
+ * tail supports open as live tail; longer ones open as a window ending now.
+ */
+export function getSavedSearchLanding(
+  stored: RelativeDateRange | null | undefined,
+  search: string,
+  nowMs: number,
+): SavedSearchLanding | null {
+  if (stored == null || hasExplicitTimeParams(search)) return null;
+  const durationMs = stored.value * 1000;
+  if (isLiveTailDuration(durationMs)) {
+    return { kind: 'live', intervalMs: durationMs };
+  }
+  // Whole seconds, so re-parsing the displayed text on the first submit lands
+  // on the same from/to.
+  return { kind: 'window', range: parseRelativeTimeQuery(durationMs, nowMs) };
+}
+
+/** Duration of a window as a relative range, snapped to the nearest preset. */
+export function toDefaultTimeRange(durationMs: number): RelativeDateRange {
+  for (const option of RELATIVE_TIME_OPTIONS) {
+    if (option === 'divider') continue;
+    if (Math.abs(option[1] - durationMs) <= SNAP_TOLERANCE_MS) {
+      return { type: 'relative', value: option[1] / 1000 };
+    }
+  }
+  return { type: 'relative', value: Math.round(durationMs / 1000) };
+}
+
+/**
+ * A window only reads as "the past N" if it ends about now. The floor absorbs
+ * re-parse drift and time spent editing before saving.
+ */
+export function isRangeEndingNow(
+  [start, end]: [Date, Date],
+  nowMs: number,
+): boolean {
+  const tolerance = Math.max(
+    ENDS_NOW_MIN_TOLERANCE_MS,
+    (end.getTime() - start.getTime()) * 0.1,
+  );
+  return Math.abs(end.getTime() - nowMs) <= tolerance;
+}
+
+/** "1 day", "1 hour 30 minutes". Anchored at epoch 0 so DST never shifts it. */
+export function formatRelativeDuration(seconds: number): string {
+  return formatDuration(intervalToDuration({ start: 0, end: seconds * 1000 }));
+}
+
+export type CurrentTimeRange =
+  | { kind: 'live'; intervalMs: number }
+  | { kind: 'window'; range: [Date, Date] };
+
+export type TimeRangeChoice = 'live' | 'keep' | 'current';
+
+function getCurrentCandidate(
+  current: CurrentTimeRange,
+  nowMs: number,
+): RelativeDateRange | null {
+  if (current.kind === 'live') {
+    // Plain live tail is already what a search opens with by default.
+    return current.intervalMs === LIVE_TAIL_DURATION_MS
+      ? null
+      : toDefaultTimeRange(current.intervalMs);
+  }
+  if (!isRangeEndingNow(current.range, nowMs)) return null;
+  const [start, end] = current.range;
+  return toDefaultTimeRange(end.getTime() - start.getTime());
+}
+
+export function getTimeRangeChoices({
+  current,
+  stored,
+  nowMs,
+}: {
+  current: CurrentTimeRange;
+  stored: RelativeDateRange | null | undefined;
+  nowMs: number;
+}): {
+  choices: TimeRangeChoice[];
+  defaultChoice: TimeRangeChoice;
+  currentRange: RelativeDateRange | null;
+} {
+  const choices: TimeRangeChoice[] = ['live'];
+  if (stored != null) choices.push('keep');
+
+  const candidate = getCurrentCandidate(current, nowMs);
+  const currentRange =
+    candidate != null && stored?.value !== candidate.value ? candidate : null;
+  if (currentRange != null) choices.push('current');
+
+  return {
+    choices,
+    defaultChoice: stored != null ? 'keep' : 'live',
+    currentRange,
+  };
+}
+
+/**
+ * The `defaultTimeRange` to send: a value to store, null to clear, or
+ * undefined to omit the key (the server keeps what is stored on update).
+ */
+export function resolveDefaultTimeRange({
+  isUpdate,
+  choice,
+  stored,
+  currentRange,
+}: {
+  isUpdate: boolean;
+  choice: TimeRangeChoice;
+  stored: RelativeDateRange | null | undefined;
+  currentRange: RelativeDateRange | null;
+}): RelativeDateRange | null | undefined {
+  switch (choice) {
+    case 'keep':
+      // "Save as new" copies the range of the search it came from.
+      return isUpdate ? undefined : (stored ?? undefined);
+    case 'current':
+      return currentRange ?? undefined;
+    case 'live':
+      return isUpdate && stored != null ? null : undefined;
+  }
+}
diff --git a/packages/app/src/timeQuery.ts b/packages/app/src/timeQuery.ts
index 96a7fa9336..194e367a73 100644
--- a/packages/app/src/timeQuery.ts
+++ b/packages/app/src/timeQuery.ts
@@ -43,9 +43,12 @@ function isInputTimeQueryLive(inputTimeQuery: string) {
   return inputTimeQuery === '' || inputTimeQuery.includes(LIVE_TAIL_TIME_QUERY);
 }
 
-export function parseRelativeTimeQuery(interval: number): [Date, Date] {
+export function parseRelativeTimeQuery(
+  interval: number,
+  nowMs?: number,
+): [Date, Date] {
   // eslint-disable-next-line no-restricted-syntax
-  const end = startOfSecond(new Date());
+  const end = startOfSecond(nowMs != null ? new Date(nowMs) : new Date());
   return [subMilliseconds(end, interval), end];
 }
 
@@ -390,6 +393,14 @@ export type UseTimeQueryInputType = {
   updateInput?: boolean;
 };
 
+type TimeRangeSelectOptions = {
+  /**
+   * Defaults to 'push'. Use 'replace' for programmatic writes that should not
+   * add a Back entry, such as applying a saved search's stored range on load.
+   */
+  history?: 'push' | 'replace';
+};
+
 export type UseTimeQueryReturnType = {
   isReady: boolean;
   displayedTimeInputValue: string;
@@ -400,6 +411,7 @@ export type UseTimeQueryReturnType = {
     start: Date,
     end: Date,
     displayedTimeInputValue?: string | null,
+    options?: TimeRangeSelectOptions,
   ) => void;
   from: number | null;
   to: number | null;
@@ -510,8 +522,16 @@ export function useNewTimeQuery({
     searchedTimeRange,
     onSearch,
     onTimeRangeSelect: useCallback(
-      (start: Date, end: Date, displayedTimeInputValue?: string | null) => {
-        setTimeRangeQuery({ from: start.getTime(), to: end.getTime() });
+      (
+        start: Date,
+        end: Date,
+        displayedTimeInputValue?: string | null,
+        options?: TimeRangeSelectOptions,
+      ) => {
+        setTimeRangeQuery(
+          { from: start.getTime(), to: end.getTime() },
+          options?.history ? { history: options.history } : undefined,
+        );
         setSearchedTimeRange([start, end]);
         const dateRangeStr = dateRangeToString([start, end], timeZone);
         if (displayedTimeInputValue !== null) {
diff --git a/packages/app/tests/e2e/components/SavedSearchModalComponent.ts b/packages/app/tests/e2e/components/SavedSearchModalComponent.ts
index e562ca5f31..4337c2ea6d 100644
--- a/packages/app/tests/e2e/components/SavedSearchModalComponent.ts
+++ b/packages/app/tests/e2e/components/SavedSearchModalComponent.ts
@@ -38,6 +38,17 @@ export class SavedSearchModalComponent {
     await this.nameInput.fill(name);
   }
 
+  /**
+   * Pick what the saved search shows when opened, by option label
+   * (e.g. "Show live tail", "Show the past 1 day")
+   */
+  async chooseTimeRange(label: string) {
+    await this.modal
+      .getByTestId('save-search-time-range')
+      .getByRole('radio', { name: label })
+      .check();
+  }
+
   /**
    * Submit the save search form
    */
diff --git a/packages/app/tests/e2e/features/search/saved-search.spec.ts b/packages/app/tests/e2e/features/search/saved-search.spec.ts
index 32a3c6731e..2474933167 100644
--- a/packages/app/tests/e2e/features/search/saved-search.spec.ts
+++ b/packages/app/tests/e2e/features/search/saved-search.spec.ts
@@ -832,6 +832,84 @@ test.describe('Saved Search Functionality', () => {
       });
     },
   );
+
+  test(
+    'should open a saved search with its saved time range',
+    { tag: ['@search'] },
+    async ({ page }) => {
+      const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+      let savedSearchUrl = '';
+
+      await test.step('Save a search that opens on the past 1 day', async () => {
+        await searchPage.timePicker.selectRelativeTime('Last 1 days');
+        await searchPage.openSaveSearchModal();
+        await searchPage.savedSearchModal.chooseTimeRange(
+          'Show the past 1 day',
+        );
+        await searchPage.savedSearchModal.saveSearchAndWaitForNavigation(
+          `Saved Time Range ${Date.now()}`,
+        );
+        const id = page.url().match(/\/search\/([a-f0-9]+)/)?.[1];
+        expect(id).toBeDefined();
+        savedSearchUrl = `/search/${id}`;
+      });
+
+      await test.step('Open the saved search with no time in the URL', async () => {
+        await page.goto('/search/list');
+        await page.goto(savedSearchUrl);
+        await page.waitForURL(
+          url => url.searchParams.get('isLive') === 'false',
+        );
+        const url = new URL(page.url());
+        const span =
+          Number(url.searchParams.get('to')) -
+          Number(url.searchParams.get('from'));
+        expect(Math.abs(span - ONE_DAY_MS)).toBeLessThanOrEqual(2000);
+      });
+
+      await test.step('Back returns to the previous page', async () => {
+        await page.goBack();
+        await expect(page).toHaveURL(/\/search\/list/);
+      });
+    },
+  );
+
+  test(
+    'should open a saved search in live tail with its saved interval',
+    { tag: ['@search'] },
+    async ({ page }) => {
+      const ONE_HOUR_MS = 60 * 60 * 1000;
+      let savedSearchUrl = '';
+
+      await test.step('Save a search that opens in a 1 hour live tail', async () => {
+        await searchPage.timePicker.open();
+        await searchPage.timePicker.enableRelativeTime();
+        await searchPage.timePicker.selectTimeInterval('Last 1 hour');
+        await searchPage.openSaveSearchModal();
+        await searchPage.savedSearchModal.chooseTimeRange(
+          'Show live tail for the past 1 hour',
+        );
+        await searchPage.savedSearchModal.saveSearchAndWaitForNavigation(
+          `Saved Live Interval ${Date.now()}`,
+        );
+        const id = page.url().match(/\/search\/([a-f0-9]+)/)?.[1];
+        expect(id).toBeDefined();
+        savedSearchUrl = `/search/${id}`;
+      });
+
+      await test.step('Open the saved search with no time in the URL', async () => {
+        await page.goto('/search/list');
+        await page.goto(savedSearchUrl);
+        await page.waitForURL(
+          url => url.searchParams.get('liveInterval') === String(ONE_HOUR_MS),
+        );
+        expect(new URL(page.url()).searchParams.get('isLive')).not.toBe(
+          'false',
+        );
+        await expect(searchPage.timePicker.input).toHaveValue('Last 1 hour');
+      });
+    },
+  );
 });
 
 test.describe('Saved Searches Listing Page', { tag: ['@search'] }, () => {
diff --git a/packages/common-utils/src/__tests__/types.test.ts b/packages/common-utils/src/__tests__/types.test.ts
index 3c0786dda5..514a41c927 100644
--- a/packages/common-utils/src/__tests__/types.test.ts
+++ b/packages/common-utils/src/__tests__/types.test.ts
@@ -16,6 +16,7 @@ import {
   PresetDashboardFilterSchema,
   PromqlSourceSchema,
   SavedChartConfigSchema,
+  SavedSearchSchema,
 } from '@/types';
 
 describe('ColorConditionSchema', () => {
@@ -853,6 +854,35 @@ describe('DashboardSchema.savedDateRange', () => {
   });
 });
 
+describe('SavedSearchSchema.defaultTimeRange', () => {
+  const base = {
+    id: 's1',
+    name: 'Errors',
+    select: '',
+    where: '',
+    source: 'source-1',
+    tags: [],
+  };
+  const parse = (defaultTimeRange: unknown) =>
+    SavedSearchSchema.safeParse({ ...base, defaultTimeRange }).success;
+
+  it('accepts relative, null, or absent', () => {
+    expect(parse({ type: 'relative', value: 86400 })).toBe(true);
+    expect(parse(null)).toBe(true);
+    expect(parse(undefined)).toBe(true);
+  });
+
+  it('rejects fixed windows and malformed values', () => {
+    expect(
+      parse({ type: 'historical', value: [1700000000000, 1700003600000] }),
+    ).toBe(false);
+    expect(parse({ type: 'relative', value: '1d' })).toBe(false);
+    expect(parse({ type: 'relative', value: 0 })).toBe(false);
+    expect(parse({ type: 'relative', value: -60 })).toBe(false);
+    expect(parse('1d')).toBe(false);
+  });
+});
+
 describe('MetricSourceSchema.minAutoGranularity', () => {
   const base = {
     id: 'source-1',
diff --git a/packages/common-utils/src/types.ts b/packages/common-utils/src/types.ts
index 8991efe487..22c32d9d54 100644
--- a/packages/common-utils/src/types.ts
+++ b/packages/common-utils/src/types.ts
@@ -1381,6 +1381,30 @@ export const DashboardFilterValueSchema = z.union([
 
 export type DashboardFilterValue = z.infer<typeof DashboardFilterValueSchema>;
 
+/**
+ * A time range a view opens with when the URL carries none, as a duration in
+ * seconds ending at the moment the view opens. A view default only; alerts
+ * never read it.
+ */
+export const RelativeDateRangeSchema = z.object({
+  type: z.literal('relative'),
+  value: z.number(),
+});
+
+export type RelativeDateRange = z.infer<typeof RelativeDateRangeSchema>;
+
+/**
+ * A dashboard's saved time range: relative, or `historical` as `[start, end]`
+ * in epoch milliseconds.
+ */
+const SavedDateRangeSchema = z.discriminatedUnion('type', [
+  RelativeDateRangeSchema,
+  z.object({
+    type: z.literal('historical'),
+    value: z.array(z.number()).length(2),
+  }),
+]);
+
 // --------------------------
 // SAVED SEARCH
 // --------------------------
@@ -1395,6 +1419,9 @@ export const SavedSearchSchema = z.object({
   orderBy: z.string().optional(),
   filters: z.array(FilterSchema).optional(),
   alerts: z.array(AlertSchema).optional(),
+  defaultTimeRange: RelativeDateRangeSchema.extend({
+    value: z.number().positive(),
+  }).nullish(),
 });
 
 export type SavedSearch = z.infer<typeof SavedSearchSchema>;
@@ -2504,18 +2531,7 @@ export const DashboardSchema = z.object({
   savedQuery: z.string().nullable().optional(),
   savedQueryLanguage: SearchConditionLanguageSchema.nullable().optional(),
   savedFilterValues: z.array(DashboardFilterValueSchema).optional(),
-  savedDateRange: z
-    .discriminatedUnion('type', [
-      z.object({
-        type: z.literal('relative'),
-        value: z.number(),
-      }),
-      z.object({
-        type: z.literal('historical'),
-        value: z.array(z.number()).length(2),
-      }),
-    ])
-    .nullish(),
+  savedDateRange: SavedDateRangeSchema.nullish(),
   containers: z
     .array(DashboardContainerSchema)
     .max(DASHBOARD_MAX_CONTAINERS)