diff --git a/frontend/.claude/context/testing-against-pr-backend.md b/frontend/.claude/context/testing-against-pr-backend.md
new file mode 100644
index 000000000000..36b08ece2d71
--- /dev/null
+++ b/frontend/.claude/context/testing-against-pr-backend.md
@@ -0,0 +1,72 @@
+# Testing the Frontend Against an Unmerged Backend PR
+
+When a backend PR adds or changes API behaviour, you can run that exact backend
+locally — without checking out or building the API — and point your local
+frontend dev server at it. CI publishes a Docker image for every PR.
+
+## Where the images live
+
+Every PR's CI builds and **pushes** multi-arch (amd64 + arm64) images to GHCR,
+tagged `pr-<number>`. They are **public** — no `docker login` needed.
+
+| Image | Tag | Contents |
+| --- | --- | --- |
+| `ghcr.io/flagsmith/flagsmith` | `pr-<number>` | Unified image — API + bundled frontend, serves on `:8000` |
+| `ghcr.io/flagsmith/flagsmith-api` | `pr-<number>` | API only |
+
+Use the **unified** image with the repo's root `docker-compose.yml`, which is
+already wired for it (Postgres, migrations, API, task processor).
+
+Confirm an image exists before relying on it:
+
+```bash
+docker manifest inspect ghcr.io/flagsmith/flagsmith:pr-<number> >/dev/null && echo pullable
+```
+
+## Run a PR backend + local frontend
+
+From the repo root, create a one-off compose override that swaps the three
+`flagsmith` services onto the PR image (the root compose hardcodes the image, so
+an override file is the clean way to repoint it):
+
+```bash
+cat > docker-compose.pr.yml <<'EOF'
+services:
+  migrate-db:
+    image: ghcr.io/flagsmith/flagsmith:pr-<number>
+  flagsmith:
+    image: ghcr.io/flagsmith/flagsmith:pr-<number>
+  flagsmith-task-processor:
+    image: ghcr.io/flagsmith/flagsmith:pr-<number>
+EOF
+
+docker compose -f docker-compose.yml -f docker-compose.pr.yml pull
+docker compose -f docker-compose.yml -f docker-compose.pr.yml up
+```
+
+The API comes up on `localhost:8000`. Then run the frontend against it:
+
+```bash
+cd frontend
+ENV=local npm run dev   # dev server on :3000, talks to the API on :8000
+```
+
+`docker-compose.pr.yml` is throwaway — delete it (or keep it git-ignored) when
+done. To switch PRs, change the tag and re-run `pull` + `up`.
+
+## Notes / gotchas
+
+- **Flagsmith-on-Flagsmith gates.** Backend features are often gated by an
+  OpenFeature flag (e.g. `feature_lifecycle`). The flag's default for a
+  self-hosted/local run comes from the baked-in
+  `api/integrations/flagsmith/data/environment.json`. Check it's enabled there;
+  if not, the gated endpoints/fields won't appear.
+- **Data, not just code.** Endpoints may need seeded data to return anything
+  meaningful (e.g. code references, stale tags, usage). The image gives you the
+  behaviour; you still have to create the data through the UI/API.
+- **Inspect what the PR actually built.** Job logs show the pushed tag:
+  `gh run view --job <id> --log | grep -i 'tags:'`. The `pr-<number>` convention
+  is stable, but the logs are the source of truth.
+- **Contract-checking without running.** To verify the frontend matches a
+  backend PR's contract, read its diff directly instead of (or before) running:
+  `gh api repos/Flagsmith/flagsmith/contents/<path>?ref=<pr-head-branch> --jq .content | base64 -d`.
diff --git a/frontend/CLAUDE.md b/frontend/CLAUDE.md
index 49d43e6ea0d7..b87a96b225b3 100644
--- a/frontend/CLAUDE.md
+++ b/frontend/CLAUDE.md
@@ -32,6 +32,7 @@ For detailed guidance on specific topics:
 - **Quick Start**: `.claude/context/quick-reference.md` - Common tasks, commands, patterns
 - **API Integration**: `.claude/context/api-integration.md` - Adding endpoints, RTK Query (required reading for API work)
 - **Backend**: `.claude/context/backend-integration.md` - Finding endpoints, backend structure
+- **Testing vs PR backend**: `.claude/context/testing-against-pr-backend.md` - Run an unmerged backend PR's Docker image locally and point the dev server at it
 - **UI Patterns**: `.claude/context/ui-patterns.md` - Tables, tabs, modals, confirmations (required reading for UI work)
 - **Feature Flags**: `.claude/context/feature-flags/` - Using Flagsmith flags (optional, only when requested)
 - **Code Patterns**: `.claude/context/patterns/` - Complete examples, best practices
diff --git a/frontend/common/lifecycleEnvironmentSlice.ts b/frontend/common/lifecycleEnvironmentSlice.ts
new file mode 100644
index 000000000000..0df194402092
--- /dev/null
+++ b/frontend/common/lifecycleEnvironmentSlice.ts
@@ -0,0 +1,26 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit'
+
+type LifecycleEnvironmentState = {
+  // Maps a project id to the environment id selected for lifecycle analysis.
+  byProject: Record<number, number>
+}
+
+const initialState: LifecycleEnvironmentState = {
+  byProject: {},
+}
+
+const lifecycleEnvironmentSlice = createSlice({
+  initialState,
+  name: 'lifecycleEnvironment',
+  reducers: {
+    setLifecycleEnvironment(
+      state,
+      action: PayloadAction<{ projectId: number; environmentId: number }>,
+    ) {
+      state.byProject[action.payload.projectId] = action.payload.environmentId
+    },
+  },
+})
+
+export const { setLifecycleEnvironment } = lifecycleEnvironmentSlice.actions
+export default lifecycleEnvironmentSlice.reducer
diff --git a/frontend/common/services/useProjectFlag.ts b/frontend/common/services/useProjectFlag.ts
index 40e93ad4c780..d6a252a34d9d 100644
--- a/frontend/common/services/useProjectFlag.ts
+++ b/frontend/common/services/useProjectFlag.ts
@@ -132,6 +132,18 @@ export const projectFlagService = service
         }),
       }),
 
+      getLifecycleStatusCounts: builder.query<
+        Res['lifecycleStatusCounts'],
+        Req['getLifecycleStatusCounts']
+      >({
+        providesTags: (_res, _meta, req) => [
+          { id: req?.environment, type: 'ProjectFlag' },
+        ],
+        query: ({ environment }) => ({
+          url: `environments/${environment}/feature-lifecycle-counts/`,
+        }),
+      }),
+
       getProjectFlag: builder.query<Res['projectFlag'], Req['getProjectFlag']>({
         providesTags: (res) => [{ id: res?.id, type: 'ProjectFlag' }],
         query: (query: Req['getProjectFlag']) => ({
@@ -284,6 +296,7 @@ export const {
   useAddFlagOwnersMutation,
   useCreateProjectFlagMutation,
   useGetFeatureListQuery,
+  useGetLifecycleStatusCountsQuery,
   useGetProjectFlagQuery,
   useGetProjectFlagsQuery,
   useRemoveFlagGroupOwnersMutation,
diff --git a/frontend/common/store.ts b/frontend/common/store.ts
index 80045546fb5a..025632a08eb4 100644
--- a/frontend/common/store.ts
+++ b/frontend/common/store.ts
@@ -14,10 +14,12 @@ import storage from 'redux-persist/lib/storage'
 import { Persistor } from 'redux-persist/es/types'
 import { service } from './service'
 import selectedOrganisationReducer from './selectedOrganisationSlice'
+import lifecycleEnvironmentReducer from './lifecycleEnvironmentSlice'
 // END OF IMPORTS
 const createStore = () => {
   const reducer = combineReducers({
     [service.reducerPath]: service.reducer,
+    lifecycleEnvironment: lifecycleEnvironmentReducer,
     selectedOrganisation: selectedOrganisationReducer,
     // END OF REDUCERS
   })
diff --git a/frontend/common/types/requests.ts b/frontend/common/types/requests.ts
index 8617803fbcfb..23ba64cf82b3 100644
--- a/frontend/common/types/requests.ts
+++ b/frontend/common/types/requests.ts
@@ -32,6 +32,7 @@ import {
   FlagsmithValue,
   TagStrategy,
   FeatureType,
+  LifecycleStage,
 } from './responses'
 import { UtmsType } from './utms'
 
@@ -395,6 +396,10 @@ export type Req = {
     group_owners?: number[]
     sort_field?: string
     sort_direction?: SortOrder
+    lifecycle_stage?: LifecycleStage
+  }
+  getLifecycleStatusCounts: {
+    environment: number
   }
   getProjectFlag: { project: number; id: number }
   getRolesPermissionUsers: { organisation_id: number; role_id: number }
diff --git a/frontend/common/types/responses.ts b/frontend/common/types/responses.ts
index cd2815e0a1f8..d7149d5a3eee 100644
--- a/frontend/common/types/responses.ts
+++ b/frontend/common/types/responses.ts
@@ -741,8 +741,19 @@ export type ProjectFlag = {
     last_successful_repository_scanned_at: string
     last_feature_found_at: string
   }[]
+  lifecycle_stage?: LifecycleStage | null
 }
 
+export type LifecycleStage =
+  | 'new'
+  | 'live'
+  | 'permanent'
+  | 'stale'
+  | 'needs_monitoring'
+  | 'to_remove'
+
+export type LifecycleStatusCounts = Record<LifecycleStage, number>
+
 export type FeatureListProviderData = {
   projectFlags: ProjectFlag[] | null
   environmentFlags: Record<number, FeatureState> | undefined
@@ -1269,6 +1280,7 @@ export type Res = {
   rolePermission: PagedResponse<RolePermission>
   projectFlags: PagedResponse<ProjectFlag>
   projectFlag: ProjectFlag
+  lifecycleStatusCounts: LifecycleStatusCounts
   identityFeatureStatesAll: IdentityFeatureState[]
   createRolesPermissionUsers: RolePermissionUser
   rolesPermissionUsers: PagedResponse<RolePermissionUser>
diff --git a/frontend/web/components/pages/feature-lifecycle/FeatureLifecyclePage.tsx b/frontend/web/components/pages/feature-lifecycle/FeatureLifecyclePage.tsx
index 816dfd168b31..bba95a7f8be5 100644
--- a/frontend/web/components/pages/feature-lifecycle/FeatureLifecyclePage.tsx
+++ b/frontend/web/components/pages/feature-lifecycle/FeatureLifecyclePage.tsx
@@ -1,30 +1,29 @@
-import React, { FC, useCallback, useEffect, useMemo, useState } from 'react'
+import React, { FC, useCallback, useMemo, useState } from 'react'
 import { useParams } from 'react-router-dom'
 import { useRouteContext } from 'components/providers/RouteContext'
 import { usePageTracking } from 'common/hooks/usePageTracking'
-import { useProjectEnvironments } from 'common/hooks/useProjectEnvironments'
 import { hasActiveFilters } from 'common/utils/featureFilterParams'
 import PageTitle from 'components/PageTitle'
 import Icon from 'components/icons/Icon'
 import Button from 'components/base/forms/Button'
-import EnvironmentSelect from 'components/EnvironmentTagSelect'
 import CreateFlagModal from 'components/modals/create-feature'
 import LifecycleSidebar from './components/LifecycleSidebar'
-import EvaluationChecker from './components/EvaluationChecker'
 import NewSection from './components/NewSection'
 import LiveSection from './components/LiveSection'
 import PermanentSection from './components/PermanentSection'
 import StaleSection from './components/StaleSection'
 import MonitorSection from './components/MonitorSection'
 import RemoveSection from './components/RemoveSection'
-import { useLifecycleData } from './hooks/useLifecycleData'
-import { useEvaluationCounts } from './hooks/useEvaluationCounts'
+import { useLifecycleEnvironment } from './hooks/useLifecycleEnvironment'
+import {
+  useLifecycleCounts,
+  useLifecycleSectionFlags,
+} from './hooks/useLifecycleData'
 import {
   DEFAULT_FILTER_STATE,
   MONITOR_TOOLTIP,
   SECTIONS,
   STALE_TOOLTIP,
-  buildPeriodOptions,
 } from './constants'
 import type { Section } from './types'
 import type { FilterState } from 'common/types/featureFilters'
@@ -46,21 +45,11 @@ function useSectionParam(): Section {
 
 const FeatureLifecyclePage: FC = () => {
   const routeContext = useRouteContext()
-  const projectId = routeContext.projectId as string
-  const { environments } = useProjectEnvironments(projectId)
-  const defaultEnvironmentApiKey = environments[0]?.api_key
-
-  const allEnvironmentIds = useMemo(
-    () => environments.map((e) => `${e.id}`),
-    [environments],
-  )
-  const [selectedEnvironments, setSelectedEnvironments] = useState<string[]>([])
+  const projectId = String(routeContext.projectId)
+  const projectIdNum = Number(projectId)
 
-  useEffect(() => {
-    if (allEnvironmentIds.length > 0 && selectedEnvironments.length === 0) {
-      setSelectedEnvironments(allEnvironmentIds)
-    }
-  }, [allEnvironmentIds, selectedEnvironments.length])
+  const { environmentId, setEnvironmentId } =
+    useLifecycleEnvironment(projectIdNum)
 
   const [filters, setFilters] = useState<FilterState>(DEFAULT_FILTER_STATE)
   const handleFilterChange = useCallback(
@@ -76,59 +65,31 @@ const FeatureLifecyclePage: FC = () => {
     (s) => s.key === section,
   ) as (typeof SECTIONS)[number]
 
-  const [monitorPeriod, setMonitorPeriod] = useState(1)
-  const [removePeriod, setRemovePeriod] = useState(7)
+  const { counts, isLoading: isLoadingCounts } = useLifecycleCounts({
+    environmentId,
+  })
 
-  // Central data hook — 2 API calls, all filtering done here
   const {
-    counts,
     error,
-    isLoading,
-    liveFlags,
-    newFlags,
-    permanentFlags,
-    staleFlags,
-    staleNoCodeFlags,
-  } = useLifecycleData({
-    environmentApiKey: defaultEnvironmentApiKey,
+    flags,
+    isLoading: isLoadingFlags,
+  } = useLifecycleSectionFlags({
+    environmentId,
     filters,
-    projectId,
-  })
-
-  // Monitor evaluation counts (short period — "has evaluation within")
-  const {
-    handleEvaluationResult: handleMonitorResult,
-    isCheckingEvaluations: isCheckingMonitor,
-    monitorCount,
-    monitorFlags,
-  } = useEvaluationCounts({
-    period: monitorPeriod,
-    selectedEnvironments,
-    staleNoCodeFlags,
-  })
-
-  // Remove evaluation counts (longer period — "no evaluations in")
-  const {
-    handleEvaluationResult: handleRemoveResult,
-    isCheckingEvaluations: isCheckingRemove,
-    removeCount,
-    removeFlags,
-  } = useEvaluationCounts({
-    period: removePeriod,
-    selectedEnvironments,
-    staleNoCodeFlags,
+    projectId: projectIdNum,
+    section,
   })
 
   usePageTracking({
     context: {
       organisationId: routeContext.organisationId,
-      projectId,
+      projectId: projectIdNum,
     },
     pageName: 'CLEANUP',
     saveToStorage: false,
   })
 
-  if (!defaultEnvironmentApiKey) {
+  if (!environmentId) {
     return (
       <div className='text-center'>
         <Loader />
@@ -137,125 +98,45 @@ const FeatureLifecyclePage: FC = () => {
   }
 
   const filterProps = {
+    error,
     filters,
+    flags,
     hasFilters,
+    isLoading: isLoadingFlags,
     onClearFilters: clearFilters,
     onFilterChange: handleFilterChange,
-    projectId,
+    projectId: projectIdNum,
   }
 
   const renderSection = () => {
     switch (section) {
       case 'new':
-        return (
-          <NewSection
-            flags={newFlags}
-            isLoading={isLoading}
-            error={error}
-            {...filterProps}
-          />
-        )
+        return <NewSection {...filterProps} />
       case 'live':
-        return (
-          <LiveSection
-            flags={liveFlags}
-            isLoading={isLoading}
-            error={error}
-            {...filterProps}
-          />
-        )
+        return <LiveSection {...filterProps} />
       case 'permanent':
-        return (
-          <PermanentSection
-            flags={permanentFlags}
-            isLoading={isLoading}
-            error={error}
-            {...filterProps}
-          />
-        )
+        return <PermanentSection {...filterProps} />
       case 'stale':
-        return (
-          <StaleSection
-            flags={staleFlags}
-            isLoading={isLoading}
-            error={error}
-            {...filterProps}
-          />
-        )
+        return <StaleSection {...filterProps} />
       case 'monitor':
-        return (
-          <MonitorSection
-            flags={monitorFlags}
-            isLoading={isLoading}
-            isCheckingEvaluations={isCheckingMonitor}
-            error={error}
-            {...filterProps}
-          />
-        )
+        return <MonitorSection {...filterProps} />
       case 'remove':
-        return (
-          <RemoveSection
-            flags={removeFlags}
-            isLoading={isLoading}
-            isCheckingEvaluations={isCheckingRemove}
-            error={error}
-            {...filterProps}
-          />
-        )
+        return <RemoveSection {...filterProps} />
       default:
         return null
     }
   }
 
-  const activePeriod = section === 'monitor' ? monitorPeriod : removePeriod
-  const setActivePeriod =
-    section === 'monitor' ? setMonitorPeriod : setRemovePeriod
-  const periodPrefix =
-    section === 'monitor' ? 'Evaluated within' : 'No evaluations in'
-  const periodOptions = buildPeriodOptions(periodPrefix)
-
   return (
     <div data-test='cleanup-page' id='cleanup-page'>
-      {/* Hidden evaluators — monitor period */}
-      {staleNoCodeFlags.map((flag) =>
-        selectedEnvironments.map((envId) => (
-          <EvaluationChecker
-            key={`monitor-${
-              flag.id
-            }-${envId}-${monitorPeriod}-${selectedEnvironments.join()}`}
-            featureId={flag.id}
-            projectId={projectId}
-            environmentId={envId}
-            period={monitorPeriod}
-            onResult={handleMonitorResult}
-          />
-        )),
-      )}
-      {/* Hidden evaluators — remove period */}
-      {staleNoCodeFlags.map((flag) =>
-        selectedEnvironments.map((envId) => (
-          <EvaluationChecker
-            key={`remove-${
-              flag.id
-            }-${envId}-${removePeriod}-${selectedEnvironments.join()}`}
-            featureId={flag.id}
-            projectId={projectId}
-            environmentId={envId}
-            period={removePeriod}
-            onResult={handleRemoveResult}
-          />
-        )),
-      )}
       <div className='d-md-flex'>
         <LifecycleSidebar
-          projectId={projectId}
+          projectId={projectIdNum}
           activeSection={section}
           counts={counts}
-          monitorCount={monitorCount}
-          removeCount={removeCount}
-          isLoading={isLoading}
-          isCheckingMonitor={isCheckingMonitor}
-          isCheckingRemove={isCheckingRemove}
+          isLoading={isLoadingCounts}
+          environmentId={environmentId}
+          onEnvironmentChange={setEnvironmentId}
         />
         <div className='aside-container'>
           <div className='app-container container'>
@@ -269,7 +150,7 @@ const FeatureLifecyclePage: FC = () => {
                         openModal(
                           'New Feature',
                           <CreateFlagModal
-                            environmentId={defaultEnvironmentApiKey}
+                            environmentId={`${environmentId}`}
                             projectId={projectId}
                           />,
                           'side-modal create-feature-modal',
@@ -311,35 +192,6 @@ const FeatureLifecyclePage: FC = () => {
                 )}
               </PageTitle>
             </div>
-            {(section === 'monitor' || section === 'remove') && (
-              <>
-                <div className='mb-3' style={{ maxWidth: 300 }}>
-                  <Select
-                    value={periodOptions.find((o) => o.value === activePeriod)}
-                    onChange={(v: { value: number }) =>
-                      setActivePeriod(v.value)
-                    }
-                    options={periodOptions}
-                    className='react-select'
-                  />
-                </div>
-                <div className='mb-3'>
-                  <label className='fw-semibold mb-1 d-block'>
-                    Environments
-                  </label>
-                  <EnvironmentSelect
-                    projectId={projectId}
-                    value={selectedEnvironments}
-                    onChange={(v) =>
-                      setSelectedEnvironments((v as string[]) || [])
-                    }
-                    idField='id'
-                    multiple
-                    allowEmpty
-                  />
-                </div>
-              </>
-            )}
             {renderSection()}
           </div>
         </div>
diff --git a/frontend/web/components/pages/feature-lifecycle/components/EvaluationChecker.tsx b/frontend/web/components/pages/feature-lifecycle/components/EvaluationChecker.tsx
deleted file mode 100644
index a6e688cdc3cb..000000000000
--- a/frontend/web/components/pages/feature-lifecycle/components/EvaluationChecker.tsx
+++ /dev/null
@@ -1,36 +0,0 @@
-import { FC, useEffect } from 'react'
-import { useGetEnvironmentAnalyticsQuery } from 'common/services/useFeatureAnalytics'
-
-type EvaluationCheckerProps = {
-  featureId: number
-  projectId: number
-  environmentId: string
-  period: number
-  onResult: (featureId: number, envId: string, hasEvaluations: boolean) => void
-}
-
-const EvaluationChecker: FC<EvaluationCheckerProps> = ({
-  environmentId,
-  featureId,
-  onResult,
-  period,
-  projectId,
-}) => {
-  const { data, isSuccess } = useGetEnvironmentAnalyticsQuery({
-    environment_id: environmentId,
-    feature_id: featureId,
-    period,
-    project_id: projectId,
-  })
-
-  useEffect(() => {
-    if (isSuccess && data) {
-      const total = data.reduce((sum, entry) => sum + entry.count, 0)
-      onResult(featureId, environmentId, total > 0)
-    }
-  }, [data, isSuccess, featureId, environmentId, onResult])
-
-  return null
-}
-
-export default EvaluationChecker
diff --git a/frontend/web/components/pages/feature-lifecycle/components/LifecycleSidebar.tsx b/frontend/web/components/pages/feature-lifecycle/components/LifecycleSidebar.tsx
index 44e029a11f5c..5d6ac351116c 100644
--- a/frontend/web/components/pages/feature-lifecycle/components/LifecycleSidebar.tsx
+++ b/frontend/web/components/pages/feature-lifecycle/components/LifecycleSidebar.tsx
@@ -1,84 +1,64 @@
 import React, { FC } from 'react'
 import classNames from 'classnames'
 import SidebarLink from 'components/navigation/SidebarLink'
+import EnvironmentSelect from 'components/EnvironmentTagSelect'
 import { SECTIONS } from 'components/pages/feature-lifecycle/constants'
 import type {
   Section,
   LifecycleCounts,
 } from 'components/pages/feature-lifecycle/types'
-import Button from 'components/base/forms/Button'
-import Icon from 'components/icons/Icon'
 
 type LifecycleSidebarProps = {
   projectId: number
   activeSection: Section
   counts: LifecycleCounts
-  monitorCount: number | undefined
-  removeCount: number | undefined
   isLoading: boolean
-  isCheckingMonitor: boolean
-  isCheckingRemove: boolean
+  environmentId: number
+  onEnvironmentChange: (environmentId: number) => void
 }
 
 const LifecycleSidebar: FC<LifecycleSidebarProps> = ({
   activeSection,
   counts,
-  isCheckingMonitor,
-  isCheckingRemove,
+  environmentId,
   isLoading,
-  monitorCount,
+  onEnvironmentChange,
   projectId,
-  removeCount,
 }) => {
   return (
     <div className='border-md-right home-aside d-flex flex-column pe-0 me-0'>
       <div className='flex-1 flex-column ms-0 me-2'>
-        <div className='d-flex px-2 pb-1 pt-2 justify-content-between align-items-center'>
-          <div className='text-muted fs-captionXSmall'>LIFECYCLE STAGES</div>
-          <Button size='xSmall' className='ps-2 pe-1'>
-            <div className='d-flex align-items-center gap-1'>
-              Add
-              <Icon width={16} name='plus' />
-            </div>
-          </Button>
+        <div className='px-2 pt-2'>
+          <div className='text-muted fs-captionXSmall mb-1'>ENVIRONMENT</div>
+          <EnvironmentSelect
+            projectId={projectId}
+            value={`${environmentId}`}
+            onChange={(v) => onEnvironmentChange(Number(v))}
+            idField='id'
+          />
         </div>
         <hr className='mt-1 mb-2' />
         <div className='d-flex flex-column mx-0 py-1 py-md-0 gap-1'>
-          {SECTIONS.map((s) => {
-            let count: number | undefined
-            let loading = false
-            if (s.key === 'monitor') {
-              count = monitorCount
-              loading = isLoading || isCheckingMonitor
-            } else if (s.key === 'remove') {
-              count = removeCount
-              loading = isLoading || isCheckingRemove
-            } else {
-              count = counts[s.key]
-              loading = isLoading
-            }
-
-            return (
-              <SidebarLink
-                key={s.key}
-                icon={s.icon}
-                className='lh-1'
-                to={`/project/${projectId}/lifecycle/${s.key}`}
-                isActive={() => activeSection === s.key}
-              >
-                <div className='d-flex align-items-center'>
-                  {s.label}
-                  <span
-                    className={classNames('ms-1 px-2 unread rounded d-inline', {
-                      'bg-light300 text-muted': activeSection !== s.key,
-                    })}
-                  >
-                    {loading ? '...' : count ?? 0}
-                  </span>
-                </div>
-              </SidebarLink>
-            )
-          })}
+          {SECTIONS.map((s) => (
+            <SidebarLink
+              key={s.key}
+              icon={s.icon}
+              className='lh-1'
+              to={`/project/${projectId}/lifecycle/${s.key}`}
+              isActive={() => activeSection === s.key}
+            >
+              <div className='d-flex align-items-center'>
+                {s.label}
+                <span
+                  className={classNames('ms-1 px-2 unread rounded d-inline', {
+                    'bg-light300 text-muted': activeSection !== s.key,
+                  })}
+                >
+                  {isLoading ? '...' : counts[s.key] ?? 0}
+                </span>
+              </div>
+            </SidebarLink>
+          ))}
         </div>
       </div>
     </div>
diff --git a/frontend/web/components/pages/feature-lifecycle/components/MonitorSection.tsx b/frontend/web/components/pages/feature-lifecycle/components/MonitorSection.tsx
index c07c7d355a93..f84458560031 100644
--- a/frontend/web/components/pages/feature-lifecycle/components/MonitorSection.tsx
+++ b/frontend/web/components/pages/feature-lifecycle/components/MonitorSection.tsx
@@ -7,7 +7,6 @@ import type { FilterState } from 'common/types/featureFilters'
 type MonitorSectionProps = {
   flags: ProjectFlag[]
   isLoading: boolean
-  isCheckingEvaluations: boolean
   error: unknown
   projectId: number
   filters: FilterState
@@ -21,7 +20,6 @@ const MonitorSection: FC<MonitorSectionProps> = ({
   filters,
   flags,
   hasFilters,
-  isCheckingEvaluations,
   isLoading,
   onClearFilters,
   onFilterChange,
@@ -30,17 +28,6 @@ const MonitorSection: FC<MonitorSectionProps> = ({
   const { goToPage, nextPage, pageItems, paging, prevPage } =
     useClientPagination({ items: flags })
 
-  if (isCheckingEvaluations && !isLoading) {
-    return (
-      <div className='text-center py-4'>
-        <Loader />
-        <p className='text-muted mt-2'>
-          Checking evaluation data for features...
-        </p>
-      </div>
-    )
-  }
-
   return (
     <SectionShell
       id='monitor-list'
@@ -53,7 +40,7 @@ const MonitorSection: FC<MonitorSectionProps> = ({
       hasFilters={hasFilters}
       onFilterChange={onFilterChange}
       onClearFilters={onClearFilters}
-      emptyLabel='No stale features with zero code references are being evaluated in the selected environments.'
+      emptyLabel='No stale features with zero code references are being evaluated in this environment.'
       nextPage={nextPage}
       prevPage={prevPage}
       goToPage={goToPage}
diff --git a/frontend/web/components/pages/feature-lifecycle/components/RemoveSection.tsx b/frontend/web/components/pages/feature-lifecycle/components/RemoveSection.tsx
index 6858fd126673..c2d11f4a25b2 100644
--- a/frontend/web/components/pages/feature-lifecycle/components/RemoveSection.tsx
+++ b/frontend/web/components/pages/feature-lifecycle/components/RemoveSection.tsx
@@ -8,7 +8,6 @@ import type { FilterState } from 'common/types/featureFilters'
 type RemoveSectionProps = {
   flags: ProjectFlag[]
   isLoading: boolean
-  isCheckingEvaluations: boolean
   error: unknown
   projectId: number
   filters: FilterState
@@ -22,7 +21,6 @@ const RemoveSection: FC<RemoveSectionProps> = ({
   filters,
   flags,
   hasFilters,
-  isCheckingEvaluations,
   isLoading,
   onClearFilters,
   onFilterChange,
@@ -50,17 +48,6 @@ const RemoveSection: FC<RemoveSectionProps> = ({
     [selectedIds],
   )
 
-  if (isCheckingEvaluations && !isLoading) {
-    return (
-      <div className='text-center py-4'>
-        <Loader />
-        <p className='text-muted mt-2'>
-          Checking evaluation data for features...
-        </p>
-      </div>
-    )
-  }
-
   return (
     <SectionShell
       id='remove-list'
@@ -73,7 +60,7 @@ const RemoveSection: FC<RemoveSectionProps> = ({
       hasFilters={hasFilters}
       onFilterChange={onFilterChange}
       onClearFilters={onClearFilters}
-      emptyLabel='No stale features found with zero code references and zero evaluations in the selected environments and period.'
+      emptyLabel='No stale features found with zero code references and zero evaluations in this environment and period.'
       nextPage={nextPage}
       prevPage={prevPage}
       goToPage={goToPage}
diff --git a/frontend/web/components/pages/feature-lifecycle/constants.tsx b/frontend/web/components/pages/feature-lifecycle/constants.tsx
index 713ff99f590a..efc9fcda599c 100644
--- a/frontend/web/components/pages/feature-lifecycle/constants.tsx
+++ b/frontend/web/components/pages/feature-lifecycle/constants.tsx
@@ -3,7 +3,16 @@ import type { IconName } from 'components/icons/Icon'
 import type { FilterState } from 'common/types/featureFilters'
 import type { Section } from './types'
 import { SortOrder } from 'common/types/requests'
-import { TagStrategy } from 'common/types/responses'
+import { LifecycleStage, TagStrategy } from 'common/types/responses'
+
+export const SECTION_TO_STAGE: Record<Section, LifecycleStage> = {
+  live: 'live',
+  monitor: 'needs_monitoring',
+  new: 'new',
+  permanent: 'permanent',
+  remove: 'to_remove',
+  stale: 'stale',
+}
 
 export const DEFAULT_FILTER_STATE: FilterState = {
   group_owners: [],
@@ -17,19 +26,6 @@ export const DEFAULT_FILTER_STATE: FilterState = {
   value_search: '',
 }
 
-export const PERIOD_VALUES = [1, 7, 14, 30, 90]
-
-function dayLabel(days: number): string {
-  return days === 1 ? '1 day' : `${days} days`
-}
-
-export function buildPeriodOptions(prefix: string) {
-  return PERIOD_VALUES.map((v) => ({
-    label: `${prefix} ${dayLabel(v)}`,
-    value: v,
-  }))
-}
-
 export const STALE_TOOLTIP =
   'If no changes have been made to a feature in any environment within the configured threshold, the feature will be tagged as stale. You will need to enable feature versioning in your environments for stale features to be detected.'
 
diff --git a/frontend/web/components/pages/feature-lifecycle/hooks/predictProdEnvironment.ts b/frontend/web/components/pages/feature-lifecycle/hooks/predictProdEnvironment.ts
new file mode 100644
index 000000000000..23dce3f7ca69
--- /dev/null
+++ b/frontend/web/components/pages/feature-lifecycle/hooks/predictProdEnvironment.ts
@@ -0,0 +1,12 @@
+import type { Environment } from 'common/types/responses'
+
+// Picks the environment most likely to represent production: the first whose
+// name looks like production, falling back to the first environment. Used as
+// the default for lifecycle classification when the user has no stored choice.
+export function predictProdEnvironment(
+  environments: Environment[],
+): number | undefined {
+  if (!environments.length) return undefined
+  const prod = environments.find((e) => e.name.toLowerCase().includes('prod'))
+  return prod?.id ?? environments[0].id
+}
diff --git a/frontend/web/components/pages/feature-lifecycle/hooks/useEvaluationCounts.ts b/frontend/web/components/pages/feature-lifecycle/hooks/useEvaluationCounts.ts
deleted file mode 100644
index 490b95958a38..000000000000
--- a/frontend/web/components/pages/feature-lifecycle/hooks/useEvaluationCounts.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import type { ProjectFlag } from 'common/types/responses'
-
-type UseEvaluationCountsOptions = {
-  staleNoCodeFlags: ProjectFlag[]
-  selectedEnvironments: string[]
-  period: number
-}
-
-export function useEvaluationCounts({
-  period,
-  selectedEnvironments,
-  staleNoCodeFlags,
-}: UseEvaluationCountsOptions) {
-  const [checkedPairs, setCheckedPairs] = useState<Set<string>>(new Set())
-  const [activeFlagIds, setActiveFlagIds] = useState<Set<number>>(new Set())
-
-  // Reset when inputs change
-  useEffect(() => {
-    setCheckedPairs(new Set())
-    setActiveFlagIds(new Set())
-  }, [staleNoCodeFlags, selectedEnvironments, period])
-
-  const handleEvaluationResult = useCallback(
-    (featureId: number, envId: string, hasEvaluations: boolean) => {
-      const key = `${featureId}:${envId}`
-      setCheckedPairs((prev) => {
-        if (prev.has(key)) return prev
-        const next = new Set(prev)
-        next.add(key)
-        return next
-      })
-      if (hasEvaluations) {
-        setActiveFlagIds((prev) => {
-          if (prev.has(featureId)) return prev
-          const next = new Set(prev)
-          next.add(featureId)
-          return next
-        })
-      }
-    },
-    [],
-  )
-
-  const isCheckingEvaluations = useMemo(() => {
-    if (staleNoCodeFlags.length === 0) return false
-    return !staleNoCodeFlags.every((f) =>
-      selectedEnvironments.every((envId) =>
-        checkedPairs.has(`${f.id}:${envId}`),
-      ),
-    )
-  }, [staleNoCodeFlags, selectedEnvironments, checkedPairs])
-
-  const monitorFlags = useMemo(
-    () => staleNoCodeFlags.filter((f) => activeFlagIds.has(f.id)),
-    [staleNoCodeFlags, activeFlagIds],
-  )
-
-  const removeFlags = useMemo(
-    () => staleNoCodeFlags.filter((f) => !activeFlagIds.has(f.id)),
-    [staleNoCodeFlags, activeFlagIds],
-  )
-
-  return {
-    handleEvaluationResult,
-    isCheckingEvaluations,
-    monitorCount: isCheckingEvaluations ? undefined : monitorFlags.length,
-    monitorFlags,
-    removeCount: isCheckingEvaluations ? undefined : removeFlags.length,
-    removeFlags,
-  }
-}
diff --git a/frontend/web/components/pages/feature-lifecycle/hooks/useLifecycleData.ts b/frontend/web/components/pages/feature-lifecycle/hooks/useLifecycleData.ts
index 693c6ce60a95..0c5820d836f2 100644
--- a/frontend/web/components/pages/feature-lifecycle/hooks/useLifecycleData.ts
+++ b/frontend/web/components/pages/feature-lifecycle/hooks/useLifecycleData.ts
@@ -1,195 +1,128 @@
 import { useEffect, useMemo } from 'react'
 import { skipToken } from '@reduxjs/toolkit/query'
-import { useGetProjectFlagsQuery } from 'common/services/useProjectFlag'
-import { useGetTagsQuery } from 'common/services/useTag'
-import { useProjectEnvironments } from 'common/hooks/useProjectEnvironments'
+import {
+  useGetLifecycleStatusCountsQuery,
+  useGetProjectFlagsQuery,
+} from 'common/services/useProjectFlag'
 import FeatureListStore from 'common/stores/feature-list-store'
-import type { ProjectFlag } from 'common/types/responses'
 import type { Req } from 'common/types/requests'
 import type { FilterState } from 'common/types/featureFilters'
-import type { LifecycleCounts } from 'components/pages/feature-lifecycle/types'
+import { SECTION_TO_STAGE } from 'components/pages/feature-lifecycle/constants'
+import type {
+  LifecycleCounts,
+  Section,
+} from 'components/pages/feature-lifecycle/types'
 
-type UseLifecycleDataOptions = {
+type BaseOptions = {
   projectId: number
-  environmentApiKey: string | undefined
+  environmentId: number | undefined
   filters: FilterState
 }
 
-function totalCodeRefs(f: ProjectFlag): number {
-  return (f.code_references_counts ?? []).reduce((sum, r) => sum + r.count, 0)
-}
-
-export function useLifecycleData({
-  environmentApiKey,
-  filters,
-  projectId,
-}: UseLifecycleDataOptions) {
-  const { data: tags } = useGetTagsQuery({ projectId: `${projectId}` })
-
-  const staleTagId = useMemo(
-    () => tags?.find((t) => t.type === 'STALE')?.id,
-    [tags],
-  )
-  const permanentTagIds = useMemo(
-    () => new Set(tags?.filter((t) => t.is_permanent).map((t) => t.id)),
-    [tags],
-  )
-
-  const { getEnvironmentIdFromKey } = useProjectEnvironments(projectId)
-  const environmentId = environmentApiKey
-    ? getEnvironmentIdFromKey(environmentApiKey)
-    : undefined
-
-  // Build base query params shared by both calls.
-  // Uses getProjectFlags which recursively fetches all pages, so no
-  // page/page_size needed. Lifecycle classification still happens
-  // client-side based on code_references_counts (new vs live, stale vs
-  // monitor/remove) since the backend doesn't support filtering by
-  // code-reference presence.
-  const baseParams = useMemo((): Req['getProjectFlags'] | null => {
-    if (!environmentId) return null
-
-    const params: Req['getProjectFlags'] = {
-      environment: environmentId,
+// Filter params for the per-section list. The backend owns lifecycle
+// classification, so no client-side tag/code-reference logic remains here.
+function useFilterParams(filters: FilterState) {
+  return useMemo(() => {
+    const params: {
+      search?: string | null
+      tag_strategy: FilterState['tag_strategy']
+      tags?: string
+      is_archived: boolean
+      value_search?: string | null
+      is_enabled?: boolean | null
+      owners?: number[]
+      group_owners?: number[]
+    } = {
       is_archived: false,
-      project: String(projectId),
-      sort_direction: filters.sort.sortOrder,
-      sort_field: filters.sort.sortBy,
       tag_strategy: filters.tag_strategy,
     }
-
     if (filters.search) params.search = filters.search
     if (filters.owners?.length) params.owners = filters.owners
     if (filters.group_owners?.length) params.group_owners = filters.group_owners
     if (filters.is_enabled !== null) params.is_enabled = filters.is_enabled
     if (filters.value_search) params.value_search = filters.value_search
-
-    // Include user-selected tags (but not stale tag) for the "all" query
-    const userTags = filters.tags ?? []
-    if (userTags.length) params.tags = userTags.join(',')
-
+    if (filters.tags?.length) params.tags = filters.tags.join(',')
     return params
-  }, [environmentId, projectId, filters])
-
-  // Query 1: All features (no stale tag filter) — for new, live, permanent
-  const allQuery = useGetProjectFlagsQuery(baseParams ?? skipToken, {
-    refetchOnMountOrArgChange: true,
-  })
-
-  // Query 2: Stale-tagged features — for stale, monitor, remove
-  const staleParams = useMemo(() => {
-    if (!baseParams || !staleTagId) return null
-    const userTags = filters.tags ?? []
-    const mergedTags = userTags.includes(staleTagId)
-      ? userTags
-      : [...userTags, staleTagId]
-    return { ...baseParams, tags: mergedTags.join(',') }
-  }, [baseParams, staleTagId, filters.tags])
-
-  const staleQuery = useGetProjectFlagsQuery(staleParams ?? skipToken, {
-    refetchOnMountOrArgChange: true,
-  })
+  }, [filters])
+}
 
-  // Extract refetch fns so eslint sees stable references
-  const { refetch: refetchAll } = allQuery
-  const { refetch: refetchStale } = staleQuery
+// Sidebar counts for every lifecycle stage in a single API call. The counts
+// endpoint is environment-scoped and unfiltered — it reports the whole
+// environment regardless of the active list filters.
+export function useLifecycleCounts({
+  environmentId,
+}: {
+  environmentId: number | undefined
+}) {
+  const query = useGetLifecycleStatusCountsQuery(
+    environmentId ? { environment: environmentId } : skipToken,
+    { refetchOnMountOrArgChange: true },
+  )
 
-  // Refetch on feature save/remove
+  const { refetch } = query
   useEffect(() => {
-    const onFeatureListChange = () => {
-      refetchAll()
-      refetchStale()
-    }
-    FeatureListStore.on('saved', onFeatureListChange)
-    FeatureListStore.on('removed', onFeatureListChange)
+    FeatureListStore.on('saved', refetch)
+    FeatureListStore.on('removed', refetch)
     return () => {
-      FeatureListStore.off('saved', onFeatureListChange)
-      FeatureListStore.off('removed', onFeatureListChange)
+      FeatureListStore.off('saved', refetch)
+      FeatureListStore.off('removed', refetch)
     }
-  }, [refetchAll, refetchStale])
-
-  const isPermanent = useMemo(
-    () => (f: ProjectFlag) => f.tags.some((t) => permanentTagIds.has(t)),
-    [permanentTagIds],
-  )
-
-  // Pre-filter arrays from query 1
-  const newFlags = useMemo(() => {
-    if (!allQuery.data?.results || !staleTagId) return []
-    return allQuery.data.results.filter(
-      (f) =>
-        !f.tags.includes(staleTagId) &&
-        !isPermanent(f) &&
-        totalCodeRefs(f) === 0,
-    )
-  }, [allQuery.data?.results, staleTagId, isPermanent])
-
-  const liveFlags = useMemo(() => {
-    if (!allQuery.data?.results || !staleTagId) return []
-    return allQuery.data.results.filter(
-      (f) =>
-        !f.tags.includes(staleTagId) && !isPermanent(f) && totalCodeRefs(f) > 0,
-    )
-  }, [allQuery.data?.results, staleTagId, isPermanent])
-
-  const permanentFlags = useMemo(() => {
-    if (!allQuery.data?.results) return []
-    return allQuery.data.results.filter(isPermanent)
-  }, [allQuery.data?.results, isPermanent])
+  }, [refetch])
+
+  const counts: LifecycleCounts = useMemo(() => {
+    const data = query.data
+    if (!data) return {}
+    return {
+      live: data.live,
+      monitor: data.needs_monitoring,
+      new: data.new,
+      permanent: data.permanent,
+      remove: data.to_remove,
+      stale: data.stale,
+    }
+  }, [query.data])
 
-  // Pre-filter arrays from query 2
-  const staleFlags = useMemo(() => {
-    if (!staleQuery.data?.results) return []
-    return staleQuery.data.results.filter(
-      (f) => !isPermanent(f) && totalCodeRefs(f) > 0,
-    )
-  }, [staleQuery.data?.results, isPermanent])
+  return { counts, error: query.error, isLoading: query.isLoading }
+}
 
-  const staleNoCodeFlags = useMemo(() => {
-    if (!staleQuery.data?.results) return []
-    return staleQuery.data.results.filter(
-      (f) => !isPermanent(f) && totalCodeRefs(f) === 0,
-    )
-  }, [staleQuery.data?.results, isPermanent])
+// Flags for the currently active section, classified by the backend.
+export function useLifecycleSectionFlags({
+  environmentId,
+  filters,
+  projectId,
+  section,
+}: BaseOptions & { section: Section }) {
+  const filterParams = useFilterParams(filters)
 
-  // Counts (monitor/remove will be overridden by useEvaluationCounts)
-  const counts: LifecycleCounts = useMemo(
-    () => ({
-      live: liveFlags.length,
-      new: newFlags.length,
-      permanent: permanentFlags.length,
-      stale: staleFlags.length,
-    }),
-    [
-      newFlags.length,
-      liveFlags.length,
-      permanentFlags.length,
-      staleFlags.length,
-    ],
-  )
+  const params = useMemo((): Req['getProjectFlags'] | null => {
+    if (!environmentId) return null
+    return {
+      environment: environmentId,
+      lifecycle_stage: SECTION_TO_STAGE[section],
+      project: String(projectId),
+      sort_direction: filters.sort.sortOrder,
+      sort_field: filters.sort.sortBy,
+      ...filterParams,
+    }
+  }, [environmentId, section, projectId, filters.sort, filterParams])
 
-  const isLoading = allQuery.isLoading || staleQuery.isLoading || !staleTagId
-  const error = allQuery.error || staleQuery.error
+  const query = useGetProjectFlagsQuery(params ?? skipToken, {
+    refetchOnMountOrArgChange: true,
+  })
 
-  const refetch = useMemo(
-    () => () => {
-      refetchAll()
-      refetchStale()
-    },
-    [refetchAll, refetchStale],
-  )
+  const { refetch } = query
+  useEffect(() => {
+    FeatureListStore.on('saved', refetch)
+    FeatureListStore.on('removed', refetch)
+    return () => {
+      FeatureListStore.off('saved', refetch)
+      FeatureListStore.off('removed', refetch)
+    }
+  }, [refetch])
 
   return {
-    counts,
-    error,
-    isLoading,
-    liveFlags,
-    newFlags,
-    permanentFlags,
-    permanentTagIds,
-    refetch,
-    staleFlags,
-    staleNoCodeFlags,
-    staleTagId,
+    error: query.error,
+    flags: query.data?.results ?? [],
+    isLoading: query.isLoading,
   }
 }
diff --git a/frontend/web/components/pages/feature-lifecycle/hooks/useLifecycleEnvironment.ts b/frontend/web/components/pages/feature-lifecycle/hooks/useLifecycleEnvironment.ts
new file mode 100644
index 000000000000..e7d06716293b
--- /dev/null
+++ b/frontend/web/components/pages/feature-lifecycle/hooks/useLifecycleEnvironment.ts
@@ -0,0 +1,35 @@
+import { useCallback, useMemo } from 'react'
+import { useDispatch, useSelector } from 'react-redux'
+import { setLifecycleEnvironment } from 'common/lifecycleEnvironmentSlice'
+import { useProjectEnvironments } from 'common/hooks/useProjectEnvironments'
+import { StoreStateType } from 'common/store'
+import { predictProdEnvironment } from './predictProdEnvironment'
+
+// Resolves the environment used for lifecycle classification for a project.
+// Preference order: the user's stored choice → an environment whose name
+// looks like production → the first environment. The choice is cached per
+// project in the Redux store so it survives navigation.
+export function useLifecycleEnvironment(projectId: number) {
+  const dispatch = useDispatch()
+  const { environments } = useProjectEnvironments(projectId)
+
+  const storedEnvironmentId = useSelector(
+    (state: StoreStateType) => state.lifecycleEnvironment.byProject[projectId],
+  )
+
+  const defaultEnvironmentId = useMemo(
+    () => predictProdEnvironment(environments),
+    [environments],
+  )
+
+  const environmentId = storedEnvironmentId ?? defaultEnvironmentId
+
+  const setEnvironmentId = useCallback(
+    (id: number) => {
+      dispatch(setLifecycleEnvironment({ environmentId: id, projectId }))
+    },
+    [dispatch, projectId],
+  )
+
+  return { environmentId, environments, setEnvironmentId }
+}
diff --git a/frontend/web/components/pages/feature-lifecycle/types.ts b/frontend/web/components/pages/feature-lifecycle/types.ts
index 45a3e6932ee0..a1adafb88ff0 100644
--- a/frontend/web/components/pages/feature-lifecycle/types.ts
+++ b/frontend/web/components/pages/feature-lifecycle/types.ts
@@ -1,5 +1,3 @@
-import type { ProjectFlag } from 'common/types/responses'
-
 export type Section =
   | 'new'
   | 'live'
@@ -17,21 +15,3 @@ export type Pagination = {
 }
 
 export type LifecycleCounts = Partial<Record<Section, number>>
-
-type EvaluationResult = {
-  featureId: number
-  environmentId: string
-  hasEvaluations: boolean
-}
-
-type LifecycleData = {
-  newFlags: ProjectFlag[]
-  liveFlags: ProjectFlag[]
-  permanentFlags: ProjectFlag[]
-  staleFlags: ProjectFlag[]
-  staleNoCodeFlags: ProjectFlag[]
-  counts: LifecycleCounts
-  isLoading: boolean
-  error: unknown
-  refetch: () => void
-}