@oneuptime/common 12.0.12 → 12.0.13

package/Server/API/StatusPageAPI.ts

@@ -1,4 +1,5 @@
 import UserMiddleware from "../Middleware/UserAuthorization";
+import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
 import AcmeChallengeService from "../Services/AcmeChallengeService";
 import IncidentEpisodeService from "../Services/IncidentEpisodeService";
 import IncidentEpisodeMemberService from "../Services/IncidentEpisodeMemberService";
@@ -36,6 +37,10 @@ import {
   NextFunction,
 } from "../Utils/Express";
 import logger, { getLogAttributesFromRequest } from "../Utils/Logger";
+import {
+  SEARCH_ENGINE_INDEXING_FLAG_NAME,
+  isSearchEngineIndexingEnabled,
+} from "../../Types/StatusPage/SearchEngineIndexing";
 import Response from "../Utils/Response";
 import BaseAPI from "./BaseAPI";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
@@ -156,6 +161,29 @@ export default class StatusPageAPI extends BaseAPI<
   StatusPage,
   StatusPageServiceType
 > {
+  /*
+   * Post-auth overview responses keyed by resolved statusPageId. The payload
+   * is user-independent (authorization is a binary gate checked per-request,
+   * before any cache read), so one short-TTL snapshot per page per process
+   * serves every viewer. See buildOverviewResponse.
+   */
+  private static overviewResponseCache: InMemoryTTLCache<JSONObject> =
+    new InMemoryTTLCache<JSONObject>(500);
+
+  /*
+   * In-flight overview builds keyed by the same cache key, so concurrent
+   * cold-cache requests share one build instead of stampeding the database.
+   */
+  private static overviewResponseInFlight: Map<string, Promise<JSONObject>> =
+    new Map();
+
+  private static readonly OVERVIEW_CACHE_TTL_MS: number = 15_000;
+
+  public static clearOverviewResponseCache(): void {
+    this.overviewResponseCache.clear();
+    this.overviewResponseInFlight.clear();
+  }
+
   public constructor() {
     super(StatusPage, StatusPageService);
 
@@ -192,6 +220,7 @@ export default class StatusPageAPI extends BaseAPI<
               pageDescription: true,
               name: true,
               defaultLanguage: true,
+              enableSearchEngineIndexing: true,
             },
             props: {
               isRoot: true,
@@ -212,6 +241,14 @@ export default class StatusPageAPI extends BaseAPI<
           description: statusPage.pageDescription,
           _id: statusPage._id?.toString(),
           defaultLanguage: statusPage.defaultLanguage || null,
+          /*
+           * Drives <meta name="robots"> and X-Robots-Tag on the rendered page.
+           * Normalised here rather than shipping the raw column, so the two
+           * frontend servers never have to decide what a missing value means.
+           */
+          [SEARCH_ENGINE_INDEXING_FLAG_NAME]: isSearchEngineIndexingEnabled(
+            statusPage.enableSearchEngineIndexing,
+          ),
         });
       },
     );
@@ -1553,918 +1590,353 @@ export default class StatusPageAPI extends BaseAPI<
           req.params["statusPageIdOrDomain"] as string,
         );
 
+        /*
+         * checkHasReadAccess MUST stay before any cache read: it is what keeps
+         * private pages, IP whitelists, and master passwords enforced on every
+         * request even when the payload below is served from cache.
+         */
         await this.checkHasReadAccess({
           statusPageId: statusPageId,
           req: req,
         });
 
+        // Resolved id, so domain-served and id-served views share one entry.
+        const cacheKey: string = statusPageId.toString();
+
         /*
-         * The timeline window comes from the status page's configured
-         * showUptimeHistoryInDays. getStatusPageResourcesAndTimelines
-         * fetches the status page row anyway, so let it compute the window
-         * (clamped to 1..90 days, ending now) instead of issuing a separate
-         * StatusPage query here just to read that one column.
+         * The cached JSONObject is shared across requests and must never be
+         * mutated after build.
          */
-        const {
-          monitorStatuses,
-          monitorGroupCurrentStatuses,
-          statusPageResources,
-          statusPage,
-          monitorsOnStatusPage,
-          monitorStatusTimelines,
-          statusPageGroups,
-          monitorsInGroup,
-          startDateForMonitorTimeline: startDate,
-          endDateForMonitorTimeline: endDate,
-        } = await this.getStatusPageResourcesAndTimelines({
-          statusPageId: statusPageId,
-        });
-
-        // check if status page has active incident.
-        let activeIncidents: Array<Incident> = [];
-        if (monitorsOnStatusPage.length > 0) {
-          let select: Select<Incident> = {
-            createdAt: true,
-            declaredAt: true,
-            updatedAt: true,
-            title: true,
-            description: true,
-            _id: true,
-            postmortemNote: true,
-            postmortemPostedAt: true,
-            showPostmortemOnStatusPage: true,
-            postmortemAttachments: {
-              _id: true,
-              name: true,
-            },
-            incidentSeverity: {
-              name: true,
-              color: true,
-            },
-            currentIncidentState: {
-              _id: true,
-              name: true,
-              color: true,
-              order: true,
-            },
-            monitors: {
-              _id: true,
-            },
-          };
-
-          if (statusPage.showIncidentLabelsOnStatusPage) {
-            select = {
-              ...select,
-              labels: {
-                name: true,
-                color: true,
-              },
-            };
+        let response: JSONObject | undefined =
+          StatusPageAPI.overviewResponseCache.get(cacheKey);
+
+        if (!response) {
+          let inFlight: Promise<JSONObject> | undefined =
+            StatusPageAPI.overviewResponseInFlight.get(cacheKey);
+
+          if (!inFlight) {
+            inFlight = this.buildOverviewResponse(statusPageId);
+            StatusPageAPI.overviewResponseInFlight.set(cacheKey, inFlight);
+
+            inFlight
+              .then((builtResponse: JSONObject) => {
+                StatusPageAPI.overviewResponseCache.set(
+                  cacheKey,
+                  builtResponse,
+                  StatusPageAPI.OVERVIEW_CACHE_TTL_MS,
+                );
+              })
+              .catch(() => {
+                // Failed builds are never cached; the next request rebuilds.
+              })
+              .finally(() => {
+                StatusPageAPI.overviewResponseInFlight.delete(cacheKey);
+              });
           }
 
-          const unresolvedIncidentStates: Array<IncidentState> =
-            await IncidentStateService.getUnresolvedIncidentStates(
-              statusPage.projectId!,
-              {
-                isRoot: true,
-              },
-            );
-
-          const unresolvedIncidentStateIds: Array<ObjectID> =
-            unresolvedIncidentStates.map((state: IncidentState) => {
-              return state.id!;
-            });
-
-          if (statusPage.showIncidentsOnStatusPage) {
-            activeIncidents = await IncidentService.findBy({
-              query: {
-                monitors: monitorsOnStatusPage as any,
-                currentIncidentStateId: QueryHelper.any(
-                  unresolvedIncidentStateIds,
-                ),
-                isVisibleOnStatusPage: true,
-                projectId: statusPage.projectId!,
-              },
-              select: select,
-              sort: {
-                declaredAt: SortOrder.Descending,
-                createdAt: SortOrder.Descending,
-              },
-
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            });
-          }
+          response = await inFlight;
         }
 
-        const incidentsOnStatusPage: Array<ObjectID> = activeIncidents.map(
-          (incident: Incident) => {
-            return incident.id!;
-          },
-        );
+        // These can serve private-page data on a GET; never let shared caches store them.
+        Response.setNoCacheHeaders(res);
 
-        let incidentPublicNotes: Array<IncidentPublicNote> = [];
+        return Response.sendJsonObjectResponse(req, res, response);
+      } catch (err) {
+        next(err);
+      }
+    };
 
-        if (incidentsOnStatusPage.length > 0) {
-          incidentPublicNotes = await IncidentPublicNoteService.findBy({
-            query: {
-              incidentId: QueryHelper.any(incidentsOnStatusPage),
-              projectId: statusPage.projectId!,
-            },
-            select: {
-              note: true,
-              incidentId: true,
-              postedAt: true,
-              attachments: {
-                _id: true,
-                name: true,
-              },
-            },
-            sort: {
-              postedAt: SortOrder.Descending, // new note first
-            },
-            skip: 0,
-            limit: LIMIT_PER_PROJECT,
-            props: {
-              isRoot: true,
-            },
-          });
-        }
+    const overviewApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/overview/:statusPageIdOrDomain`;
 
-        let incidentStateTimelines: Array<IncidentStateTimeline> = [];
+    this.router.post(
+      overviewApiPath,
+      UserMiddleware.getUserMiddleware,
+      overviewHandler,
+    );
 
-        if (incidentsOnStatusPage.length > 0) {
-          incidentStateTimelines = await IncidentStateTimelineService.findBy({
-            query: {
-              incidentId: QueryHelper.any(incidentsOnStatusPage),
-              projectId: statusPage.projectId!,
-            },
-            select: {
-              _id: true,
-              createdAt: true,
-              startsAt: true,
-              incidentId: true,
-              incidentState: {
-                _id: true,
-                name: true,
-                color: true,
-                isCreatedState: true,
-                isResolvedState: true,
-                isAcknowledgedState: true,
-              },
-            },
+    /*
+     * GET variant of the overview endpoint. Same middleware and same handler
+     * as the POST route above — private status pages are rejected for
+     * unauthenticated callers exactly as they are on POST.
+     */
+    this.router.get(
+      overviewApiPath,
+      UserMiddleware.getUserMiddleware,
+      overviewHandler,
+    );
 
-            sort: {
-              startsAt: SortOrder.Descending, // newer state changes first
-            },
-            skip: 0,
-            limit: LIMIT_PER_PROJECT,
-            props: {
-              isRoot: true,
-            },
-          });
+    this.router.put(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/update-subscription/:statusPageId/:subscriberId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.subscribeToStatusPage(req);
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (err) {
+          next(err);
         }
+      },
+    );
 
-        // Fetch active episodes (similar to incidents)
-        let activeEpisodes: Array<IncidentEpisode> = [];
-        let activeEpisodesJson: JSONArray = [];
-        let episodePublicNotes: Array<IncidentEpisodePublicNote> = [];
-        let episodeStateTimelines: Array<IncidentEpisodeStateTimeline> = [];
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/get-subscription/:statusPageId/:subscriberId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const subscriber: StatusPageSubscriber =
+            await this.getSubscriber(req);
 
-        /*
-         * Cheap guard before the expensive part: the block below scans every
-         * incident ever attached to this page's monitors (a many-to-many
-         * join, up to LIMIT_PER_PROJECT rows) just to discover episode
-         * membership — on every overview view, even though most pages have
-         * zero active episodes most of the time. One indexed COUNT of the
-         * project's unresolved, visible episodes lets us skip all of it in
-         * the common case. Behavior-preserving: the final activeEpisodes
-         * query applies exactly these three constraints, so count == 0
-         * implies the block's outputs stay empty.
-         */
-        let unresolvedIncidentStateIds: Array<ObjectID> = [];
-        let hasActiveEpisodes: boolean = false;
+          return Response.sendEntityResponse(
+            req,
+            res,
+            subscriber,
+            StatusPageSubscriber,
+          );
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
 
-        if (
-          statusPage.showEpisodesOnStatusPage &&
-          monitorsOnStatusPage.length > 0
-        ) {
-          const unresolvedIncidentStates: Array<IncidentState> =
-            await IncidentStateService.getUnresolvedIncidentStates(
-              statusPage.projectId!,
-              { isRoot: true },
-            );
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/subscribe/:statusPageId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.subscribeToStatusPage(req);
 
-          unresolvedIncidentStateIds = unresolvedIncidentStates.map(
-            (state: IncidentState) => {
-              return state.id!;
-            },
-          );
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
 
-          const activeEpisodeCount: PositiveNumber =
-            await IncidentEpisodeService.countBy({
-              query: {
-                projectId: statusPage.projectId!,
-                isVisibleOnStatusPage: true,
-                currentIncidentStateId: QueryHelper.any(
-                  unresolvedIncidentStateIds,
-                ),
-              },
-              props: {
-                isRoot: true,
-              },
-            });
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/manage-subscription/:statusPageId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.manageExistingSubscription(req);
 
-          hasActiveEpisodes = activeEpisodeCount.toNumber() > 0;
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (err) {
+          next(err);
         }
+      },
+    );
 
-        if (hasActiveEpisodes) {
-          // First, get incidents that have monitors on status page
-          const incidentsForEpisodes: Array<Incident> =
-            await IncidentService.findBy({
-              query: {
-                monitors: monitorsOnStatusPage as any,
-                isVisibleOnStatusPage: true,
-                projectId: statusPage.projectId!,
-              },
-              select: {
-                _id: true,
-              },
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            });
+    /*
+     * Shared handler for the incidents list endpoint. Registered for both
+     * POST and GET (same auth path). It does not read req.body.
+     */
+    const incidentsListHandler: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      try {
+        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+          req.params["statusPageIdOrDomain"] as string,
+        );
 
-          const incidentIdsForEpisodes: Array<ObjectID> =
-            incidentsForEpisodes.map((incident: Incident) => {
-              return incident.id!;
-            });
+        const response: JSONObject = await this.getIncidents(
+          objectId,
+          null,
+          req,
+        );
 
-          // Get episode members for these incidents
-          let episodeMembers: Array<IncidentEpisodeMember> = [];
-          if (incidentIdsForEpisodes.length > 0) {
-            episodeMembers = await IncidentEpisodeMemberService.findBy({
-              query: {
-                incidentId: QueryHelper.any(incidentIdsForEpisodes),
-                projectId: statusPage.projectId!,
-              },
-              select: {
-                incidentEpisodeId: true,
-                incidentId: true,
-              },
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            });
-          }
+        // These can serve private-page data on a GET; never let shared caches store them.
+        Response.setNoCacheHeaders(res);
 
-          // Get unique episode IDs
-          const episodeIdsFromMembers: Set<string> = new Set();
-          for (const member of episodeMembers) {
-            if (member.incidentEpisodeId) {
-              episodeIdsFromMembers.add(member.incidentEpisodeId.toString());
-            }
-          }
+        return Response.sendJsonObjectResponse(req, res, response);
+      } catch (err) {
+        next(err);
+      }
+    };
 
-          // Fetch active (unresolved) episodes
-          if (episodeIdsFromMembers.size > 0) {
-            // unresolvedIncidentStateIds was fetched by the guard above.
-            let selectEpisodes: Select<IncidentEpisode> = {
-              createdAt: true,
-              declaredAt: true,
-              updatedAt: true,
-              title: true,
-              description: true,
-              _id: true,
-              episodeNumber: true,
-              incidentSeverity: {
-                name: true,
-                color: true,
-              },
-              currentIncidentState: {
-                name: true,
-                color: true,
-                _id: true,
-                order: true,
-                isCreatedState: true,
-                isAcknowledgedState: true,
-                isResolvedState: true,
-              },
-              incidentCount: true,
-            };
+    const incidentsListApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/incidents/:statusPageIdOrDomain`;
 
-            if (statusPage.showEpisodeLabelsOnStatusPage) {
-              selectEpisodes = {
-                ...selectEpisodes,
-                labels: {
-                  name: true,
-                  color: true,
-                },
-              };
-            }
+    this.router.post(
+      incidentsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      incidentsListHandler,
+    );
 
-            activeEpisodes = await IncidentEpisodeService.findBy({
-              query: {
-                _id: QueryHelper.any(
-                  Array.from(episodeIdsFromMembers).map((id: string) => {
-                    return new ObjectID(id);
-                  }),
-                ),
-                currentIncidentStateId: QueryHelper.any(
-                  unresolvedIncidentStateIds,
-                ),
-                isVisibleOnStatusPage: true,
-                projectId: statusPage.projectId!,
-              },
-              select: selectEpisodes,
-              sort: {
-                declaredAt: SortOrder.Descending,
-                createdAt: SortOrder.Descending,
-              },
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            });
+    this.router.get(
+      incidentsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      incidentsListHandler,
+    );
 
-            // Build episode monitors map
-            if (activeEpisodes.length > 0) {
-              // Collect all incident IDs from episode members for active episodes
-              const activeEpisodeIds: Set<string> = new Set(
-                activeEpisodes.map((e: IncidentEpisode) => {
-                  return e.id!.toString();
-                }),
-              );
-
-              const memberIncidentIds: Array<ObjectID> = [];
-              for (const member of episodeMembers) {
-                if (
-                  member.incidentEpisodeId &&
-                  activeEpisodeIds.has(member.incidentEpisodeId.toString()) &&
-                  member.incidentId &&
-                  !memberIncidentIds.some((id: ObjectID) => {
-                    return id.toString() === member.incidentId!.toString();
-                  })
-                ) {
-                  memberIncidentIds.push(member.incidentId);
-                }
-              }
+    /*
+     * Shared handler for the scheduled maintenance events list endpoint.
+     * Registered for both POST and GET (same auth path). It does not read
+     * req.body.
+     */
+    const scheduledMaintenanceEventsListHandler: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      try {
+        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+          req.params["statusPageIdOrDomain"] as string,
+        );
 
-              // Fetch incidents with monitors
-              let memberIncidents: Array<Incident> = [];
-              if (memberIncidentIds.length > 0) {
-                memberIncidents = await IncidentService.findBy({
-                  query: {
-                    _id: QueryHelper.any(memberIncidentIds),
-                    isVisibleOnStatusPage: true,
-                    projectId: statusPage.projectId!,
-                  },
-                  select: {
-                    _id: true,
-                    monitors: {
-                      _id: true,
-                    },
-                  },
-                  skip: 0,
-                  limit: LIMIT_PER_PROJECT,
-                  props: {
-                    isRoot: true,
-                  },
-                });
-              }
+        const response: JSONObject = await this.getScheduledMaintenanceEvents(
+          objectId,
+          null,
 
-              // Build incident -> monitors map
-              const incidentMonitorsMap: Map<
-                string,
-                Array<ObjectID>
-              > = new Map();
-              for (const incident of memberIncidents) {
-                const incidentIdStr: string = incident.id!.toString();
-                const monitorIds: Array<ObjectID> = (incident.monitors || [])
-                  .map((m: Monitor) => {
-                    return new ObjectID(
-                      m._id?.toString() || m.id?.toString() || "",
-                    );
-                  })
-                  .filter((id: ObjectID) => {
-                    return id.toString() !== "";
-                  });
-                incidentMonitorsMap.set(incidentIdStr, monitorIds);
-              }
+          req,
+        );
 
-              // Build episode -> monitors map
-              const episodeMonitorsMap: Map<
-                string,
-                Array<ObjectID>
-              > = new Map();
-              for (const member of episodeMembers) {
-                if (
-                  member.incidentEpisodeId &&
-                  member.incidentId &&
-                  activeEpisodeIds.has(member.incidentEpisodeId.toString())
-                ) {
-                  const episodeIdStr: string =
-                    member.incidentEpisodeId.toString();
-                  const incidentIdStr: string = member.incidentId.toString();
+        // These can serve private-page data on a GET; never let shared caches store them.
+        Response.setNoCacheHeaders(res);
 
-                  if (!episodeMonitorsMap.has(episodeIdStr)) {
-                    episodeMonitorsMap.set(episodeIdStr, []);
-                  }
+        return Response.sendJsonObjectResponse(req, res, response);
+      } catch (err) {
+        next(err);
+      }
+    };
 
-                  const episodeMonitors: Array<ObjectID> =
-                    episodeMonitorsMap.get(episodeIdStr)!;
-                  const incidentMonitors: Array<ObjectID> =
-                    incidentMonitorsMap.get(incidentIdStr) || [];
-
-                  for (const monitorId of incidentMonitors) {
-                    if (
-                      !episodeMonitors.some((m: ObjectID) => {
-                        return m.toString() === monitorId.toString();
-                      })
-                    ) {
-                      episodeMonitors.push(monitorId);
-                    }
-                  }
-                }
-              }
+    const scheduledMaintenanceEventsListApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/scheduled-maintenance-events/:statusPageIdOrDomain`;
 
-              // Serialize episodes and add monitors
-              activeEpisodesJson = BaseModel.toJSONArray(
-                activeEpisodes,
-                IncidentEpisode,
-              );
-              for (const episodeJson of activeEpisodesJson) {
-                const episodeObj: JSONObject = episodeJson as JSONObject;
-                const episodeId: string | undefined =
-                  episodeObj["_id"]?.toString();
-                if (episodeId) {
-                  const monitorIds: Array<ObjectID> =
-                    episodeMonitorsMap.get(episodeId) || [];
-                  episodeObj["monitors"] = monitorIds.map((id: ObjectID) => {
-                    return { _id: id.toString() };
-                  });
-                }
-              }
+    this.router.post(
+      scheduledMaintenanceEventsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      scheduledMaintenanceEventsListHandler,
+    );
 
-              // Get episode public notes
-              const episodesOnStatusPage: Array<ObjectID> = activeEpisodes.map(
-                (episode: IncidentEpisode) => {
-                  return episode.id!;
-                },
-              );
-
-              if (episodesOnStatusPage.length > 0) {
-                episodePublicNotes =
-                  await IncidentEpisodePublicNoteService.findBy({
-                    query: {
-                      incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
-                      projectId: statusPage.projectId!,
-                    },
-                    select: {
-                      postedAt: true,
-                      note: true,
-                      incidentEpisodeId: true,
-                      attachments: {
-                        _id: true,
-                        name: true,
-                      },
-                    },
-                    sort: {
-                      postedAt: SortOrder.Descending,
-                    },
-                    skip: 0,
-                    limit: LIMIT_PER_PROJECT,
-                    props: {
-                      isRoot: true,
-                    },
-                  });
-
-                // Get episode state timelines
-                episodeStateTimelines =
-                  await IncidentEpisodeStateTimelineService.findBy({
-                    query: {
-                      incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
-                      projectId: statusPage.projectId!,
-                    },
-                    select: {
-                      _id: true,
-                      createdAt: true,
-                      startsAt: true,
-                      incidentEpisodeId: true,
-                      incidentState: {
-                        name: true,
-                        color: true,
-                        isCreatedState: true,
-                        isAcknowledgedState: true,
-                        isResolvedState: true,
-                      },
-                    },
-                    sort: {
-                      startsAt: SortOrder.Descending,
-                    },
-                    skip: 0,
-                    limit: LIMIT_PER_PROJECT,
-                    props: {
-                      isRoot: true,
-                    },
-                  });
-              }
-            }
-          }
-        }
+    this.router.get(
+      scheduledMaintenanceEventsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      scheduledMaintenanceEventsListHandler,
+    );
+
+    /*
+     * Shared handler for the announcements list endpoint. Registered for
+     * both POST and GET (same auth path). It does not read req.body.
+     */
+    const announcementsListHandler: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      try {
+        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+          req.params["statusPageIdOrDomain"] as string,
+        );
 
-        // check if status page has active announcement.
+        const response: JSONObject = await this.getAnnouncements(
+          objectId,
+          null,
 
-        const today: Date = OneUptimeDate.getCurrentDate();
+          req,
+        );
 
-        let activeAnnouncements: Array<StatusPageAnnouncement> = [];
+        // These can serve private-page data on a GET; never let shared caches store them.
+        Response.setNoCacheHeaders(res);
 
-        if (statusPage.showAnnouncementsOnStatusPage) {
-          activeAnnouncements = await StatusPageAnnouncementService.findBy({
-            query: {
-              statusPages: statusPageId as any,
-              showAnnouncementAt: QueryHelper.lessThan(today),
-              endAnnouncementAt: QueryHelper.greaterThanOrNull(today),
-              projectId: statusPage.projectId!,
-            },
-            select: {
-              createdAt: true,
-              title: true,
-              description: true,
-              _id: true,
-              showAnnouncementAt: true,
-              endAnnouncementAt: true,
-            },
-            skip: 0,
-            limit: LIMIT_PER_PROJECT,
-            props: {
-              isRoot: true,
-            },
-          });
-        }
+        return Response.sendJsonObjectResponse(req, res, response);
+      } catch (err) {
+        next(err);
+      }
+    };
 
-        // check if status page has active scheduled events.
+    const announcementsListApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/announcements/:statusPageIdOrDomain`;
 
-        let scheduledEventsSelect: Select<ScheduledMaintenance> = {
-          createdAt: true,
-          title: true,
-          description: true,
-          _id: true,
-          endsAt: true,
-          startsAt: true,
-          currentScheduledMaintenanceState: {
-            name: true,
-            color: true,
-            isScheduledState: true,
-            isResolvedState: true,
-            isOngoingState: true,
-          },
-          monitors: {
-            _id: true,
-          },
-        };
+    this.router.post(
+      announcementsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      announcementsListHandler,
+    );
 
-        if (statusPage.showScheduledEventLabelsOnStatusPage) {
-          scheduledEventsSelect = {
-            ...scheduledEventsSelect,
-            labels: {
-              name: true,
-              color: true,
-            },
-          };
-        }
+    this.router.get(
+      announcementsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      announcementsListHandler,
+    );
 
-        let scheduledMaintenanceEvents: Array<ScheduledMaintenance> = [];
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/incidents/:statusPageIdOrDomain/:incidentId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+            req.params["statusPageIdOrDomain"] as string,
+          );
 
-        if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
-          scheduledMaintenanceEvents = await ScheduledMaintenanceService.findBy(
-            {
-              query: {
-                currentScheduledMaintenanceState: {
-                  isOngoingState: true,
-                } as any,
-                statusPages: statusPageId as any,
-                projectId: statusPage.projectId!,
-                isVisibleOnStatusPage: true,
-              },
-              select: scheduledEventsSelect,
-              sort: {
-                startsAt: SortOrder.Ascending,
-              },
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            },
+          const incidentId: ObjectID = new ObjectID(
+            req.params["incidentId"] as string,
           );
-        }
 
-        let futureScheduledMaintenanceEvents: Array<ScheduledMaintenance> = [];
+          const response: JSONObject = await this.getIncidents(
+            objectId,
+            incidentId,
+            req,
+          );
 
-        if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
-          futureScheduledMaintenanceEvents =
-            await ScheduledMaintenanceService.findBy({
-              query: {
-                currentScheduledMaintenanceState: {
-                  isScheduledState: true,
-                } as any,
-                statusPages: statusPageId as any,
-                projectId: statusPage.projectId!,
-                isVisibleOnStatusPage: true,
-              },
-              select: scheduledEventsSelect,
-              sort: {
-                startsAt: SortOrder.Ascending,
-              },
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            });
+          return Response.sendJsonObjectResponse(req, res, response);
+        } catch (err) {
+          next(err);
         }
+      },
+    );
 
-        futureScheduledMaintenanceEvents.forEach(
-          (event: ScheduledMaintenance) => {
-            scheduledMaintenanceEvents.push(event);
-          },
-        );
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/scheduled-maintenance-events/:statusPageIdOrDomain/:scheduledMaintenanceId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+            req.params["statusPageIdOrDomain"] as string,
+          );
 
-        const scheduledMaintenanceEventsOnStatusPage: Array<ObjectID> =
-          scheduledMaintenanceEvents.map((event: ScheduledMaintenance) => {
-            return event.id!;
-          });
+          const scheduledMaintenanceId: ObjectID = new ObjectID(
+            req.params["scheduledMaintenanceId"] as string,
+          );
 
-        let scheduledMaintenanceEventsPublicNotes: Array<ScheduledMaintenancePublicNote> =
-          [];
+          const response: JSONObject = await this.getScheduledMaintenanceEvents(
+            objectId,
+            scheduledMaintenanceId,
 
-        if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
-          scheduledMaintenanceEventsPublicNotes =
-            await ScheduledMaintenancePublicNoteService.findBy({
-              query: {
-                scheduledMaintenanceId: QueryHelper.any(
-                  scheduledMaintenanceEventsOnStatusPage,
-                ),
-                projectId: statusPage.projectId!,
-              },
-              select: {
-                postedAt: true,
-                note: true,
-                scheduledMaintenanceId: true,
-                attachments: {
-                  _id: true,
-                  name: true,
-                },
-              },
-              sort: {
-                postedAt: SortOrder.Ascending,
-              },
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            });
-        }
-
-        let scheduledMaintenanceStateTimelines: Array<ScheduledMaintenanceStateTimeline> =
-          [];
-
-        if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
-          scheduledMaintenanceStateTimelines =
-            await ScheduledMaintenanceStateTimelineService.findBy({
-              query: {
-                scheduledMaintenanceId: QueryHelper.any(
-                  scheduledMaintenanceEventsOnStatusPage,
-                ),
-                projectId: statusPage.projectId!,
-              },
-              select: {
-                _id: true,
-                createdAt: true,
-                startsAt: true,
-                scheduledMaintenanceId: true,
-                scheduledMaintenanceState: {
-                  _id: true,
-                  color: true,
-                  name: true,
-                  isScheduledState: true,
-                  isResolvedState: true,
-                  isOngoingState: true,
-                },
-              },
-
-              sort: {
-                startsAt: SortOrder.Descending, // newer state changes first
-              },
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            });
-        }
-
-        // get all status page bar chart rules
-        const statusPageHistoryChartBarColorRules: Array<StatusPageHistoryChartBarColorRule> =
-          await StatusPageHistoryChartBarColorRuleService.findBy({
-            query: {
-              statusPageId: statusPageId,
-            },
-            select: {
-              _id: true,
-              barColor: true,
-              order: true,
-              statusPageId: true,
-              uptimePercentGreaterThanOrEqualTo: true,
-            },
-            sort: {
-              order: SortOrder.Ascending,
-            },
-            skip: 0,
-            limit: LIMIT_PER_PROJECT,
-            props: {
-              isRoot: true,
-            },
-          });
-
-        /*
-         * Fetch all incidents (active + resolved) in the timeline date range
-         * for the uptime bar tooltip and click-through
-         */
-        let timelineIncidents: Array<Incident> = [];
-        if (
-          monitorsOnStatusPage.length > 0 &&
-          statusPage.showIncidentsOnStatusPage
-        ) {
-          timelineIncidents = await IncidentService.findBy({
-            query: {
-              monitors: monitorsOnStatusPage as any,
-              declaredAt: QueryHelper.inBetween(startDate, endDate),
-              isVisibleOnStatusPage: true,
-              projectId: statusPage.projectId!,
-            },
-            select: {
-              _id: true,
-              title: true,
-              declaredAt: true,
-              incidentSeverity: {
-                name: true,
-                color: true,
-              },
-              currentIncidentState: {
-                _id: true,
-                name: true,
-                color: true,
-              },
-              monitors: {
-                _id: true,
-              },
-            },
-            sort: {
-              declaredAt: SortOrder.Descending,
-            },
-            skip: 0,
-            limit: LIMIT_PER_PROJECT,
-            props: {
-              isRoot: true,
-            },
-          });
-        }
-
-        const overallStatus: MonitorStatus | null =
-          StatusPageService.getOverallMonitorStatus({
-            statusPageResources,
-            monitorStatuses,
-            monitorGroupCurrentStatuses,
-          });
-
-        const response: JSONObject = {
-          overallStatus: overallStatus
-            ? BaseModel.toJSON(overallStatus, MonitorStatus)
-            : null,
-
-          scheduledMaintenanceEventsPublicNotes: BaseModel.toJSONArray(
-            scheduledMaintenanceEventsPublicNotes,
-            ScheduledMaintenancePublicNote,
-          ),
-          statusPageHistoryChartBarColorRules: BaseModel.toJSONArray(
-            statusPageHistoryChartBarColorRules,
-            StatusPageHistoryChartBarColorRule,
-          ),
-          scheduledMaintenanceEvents: BaseModel.toJSONArray(
-            scheduledMaintenanceEvents,
-            ScheduledMaintenance,
-          ),
-          activeAnnouncements: BaseModel.toJSONArray(
-            activeAnnouncements,
-            StatusPageAnnouncement,
-          ),
-          incidentPublicNotes: BaseModel.toJSONArray(
-            incidentPublicNotes,
-            IncidentPublicNote,
-          ),
-
-          activeIncidents: BaseModel.toJSONArray(activeIncidents, Incident),
-
-          activeEpisodes: activeEpisodesJson,
-          episodePublicNotes: BaseModel.toJSONArray(
-            episodePublicNotes,
-            IncidentEpisodePublicNote,
-          ),
-          episodeStateTimelines: BaseModel.toJSONArray(
-            episodeStateTimelines,
-            IncidentEpisodeStateTimeline,
-          ),
-
-          monitorStatusTimelines: BaseModel.toJSONArray(
-            monitorStatusTimelines,
-            MonitorStatusTimeline,
-          ),
-          resourceGroups: BaseModel.toJSONArray(
-            statusPageGroups,
-            StatusPageGroup,
-          ),
-          monitorStatuses: BaseModel.toJSONArray(
-            monitorStatuses,
-            MonitorStatus,
-          ),
-          statusPageResources: BaseModel.toJSONArray(
-            statusPageResources,
-            StatusPageResource,
-          ),
-          incidentStateTimelines: BaseModel.toJSONArray(
-            incidentStateTimelines,
-            IncidentStateTimeline,
-          ),
-          statusPage: (() => {
-            const statusPageJson: JSONObject = BaseModel.toJSONObject(
-              statusPage,
-              StatusPage,
-            );
-            delete statusPageJson["projectId"];
-            return statusPageJson;
-          })(),
-          scheduledMaintenanceStateTimelines: BaseModel.toJSONArray(
-            scheduledMaintenanceStateTimelines,
-            ScheduledMaintenanceStateTimeline,
-          ),
-
-          monitorGroupCurrentStatuses: JSONFunctions.serialize(
-            monitorGroupCurrentStatuses,
-          ),
-          monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
-          timelineIncidents: BaseModel.toJSONArray(timelineIncidents, Incident),
-        };
-
-        // These can serve private-page data on a GET; never let shared caches store them.
-        Response.setNoCacheHeaders(res);
-
-        return Response.sendJsonObjectResponse(req, res, response);
-      } catch (err) {
-        next(err);
-      }
-    };
-
-    const overviewApiPath: string = `${new this.entityType()
-      .getCrudApiPath()
-      ?.toString()}/overview/:statusPageIdOrDomain`;
-
-    this.router.post(
-      overviewApiPath,
-      UserMiddleware.getUserMiddleware,
-      overviewHandler,
-    );
-
-    /*
-     * GET variant of the overview endpoint. Same middleware and same handler
-     * as the POST route above — private status pages are rejected for
-     * unauthenticated callers exactly as they are on POST.
-     */
-    this.router.get(
-      overviewApiPath,
-      UserMiddleware.getUserMiddleware,
-      overviewHandler,
-    );
+            req,
+          );
 
-    this.router.put(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/update-subscription/:statusPageId/:subscriberId`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          await this.subscribeToStatusPage(req);
-          return Response.sendEmptySuccessResponse(req, res);
+          return Response.sendJsonObjectResponse(req, res, response);
         } catch (err) {
           next(err);
         }
@@ -2474,35 +1946,51 @@ export default class StatusPageAPI extends BaseAPI<
     this.router.post(
       `${new this.entityType()
         .getCrudApiPath()
-        ?.toString()}/get-subscription/:statusPageId/:subscriberId`,
+        ?.toString()}/announcements/:statusPageIdOrDomain/:announcementId`,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
-          const subscriber: StatusPageSubscriber =
-            await this.getSubscriber(req);
+          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+            req.params["statusPageIdOrDomain"] as string,
+          );
+
+          const announcementId: ObjectID = new ObjectID(
+            req.params["announcementId"] as string,
+          );
+
+          const response: JSONObject = await this.getAnnouncements(
+            objectId,
+            announcementId,
 
-          return Response.sendEntityResponse(
             req,
-            res,
-            subscriber,
-            StatusPageSubscriber,
           );
+
+          return Response.sendJsonObjectResponse(req, res, response);
         } catch (err) {
           next(err);
         }
       },
     );
 
+    // Episodes endpoints
     this.router.post(
       `${new this.entityType()
         .getCrudApiPath()
-        ?.toString()}/subscribe/:statusPageId`,
+        ?.toString()}/episodes/:statusPageIdOrDomain`,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
-          await this.subscribeToStatusPage(req);
+          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+            req.params["statusPageIdOrDomain"] as string,
+          );
 
-          return Response.sendEmptySuccessResponse(req, res);
+          const response: JSONObject = await this.getEpisodes(
+            objectId,
+            null,
+            req,
+          );
+
+          return Response.sendJsonObjectResponse(req, res, response);
         } catch (err) {
           next(err);
         }
@@ -2512,319 +2000,42 @@ export default class StatusPageAPI extends BaseAPI<
     this.router.post(
       `${new this.entityType()
         .getCrudApiPath()
-        ?.toString()}/manage-subscription/:statusPageId`,
+        ?.toString()}/episodes/:statusPageIdOrDomain/:episodeId`,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
-          await this.manageExistingSubscription(req);
+          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+            req.params["statusPageIdOrDomain"] as string,
+          );
 
-          return Response.sendEmptySuccessResponse(req, res);
+          const episodeId: ObjectID = new ObjectID(
+            req.params["episodeId"] as string,
+          );
+
+          const response: JSONObject = await this.getEpisodes(
+            objectId,
+            episodeId,
+            req,
+          );
+
+          return Response.sendJsonObjectResponse(req, res, response);
         } catch (err) {
           next(err);
         }
       },
     );
+  }
 
-    /*
-     * Shared handler for the incidents list endpoint. Registered for both
-     * POST and GET (same auth path). It does not read req.body.
-     */
-    const incidentsListHandler: (
-      req: ExpressRequest,
-      res: ExpressResponse,
-      next: NextFunction,
-    ) => Promise<void> = async (
-      req: ExpressRequest,
-      res: ExpressResponse,
-      next: NextFunction,
-    ): Promise<void> => {
-      try {
-        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-          req.params["statusPageIdOrDomain"] as string,
-        );
-
-        const response: JSONObject = await this.getIncidents(
-          objectId,
-          null,
-          req,
-        );
-
-        // These can serve private-page data on a GET; never let shared caches store them.
-        Response.setNoCacheHeaders(res);
-
-        return Response.sendJsonObjectResponse(req, res, response);
-      } catch (err) {
-        next(err);
-      }
-    };
-
-    const incidentsListApiPath: string = `${new this.entityType()
-      .getCrudApiPath()
-      ?.toString()}/incidents/:statusPageIdOrDomain`;
-
-    this.router.post(
-      incidentsListApiPath,
-      UserMiddleware.getUserMiddleware,
-      incidentsListHandler,
-    );
-
-    this.router.get(
-      incidentsListApiPath,
-      UserMiddleware.getUserMiddleware,
-      incidentsListHandler,
-    );
-
-    /*
-     * Shared handler for the scheduled maintenance events list endpoint.
-     * Registered for both POST and GET (same auth path). It does not read
-     * req.body.
-     */
-    const scheduledMaintenanceEventsListHandler: (
-      req: ExpressRequest,
-      res: ExpressResponse,
-      next: NextFunction,
-    ) => Promise<void> = async (
-      req: ExpressRequest,
-      res: ExpressResponse,
-      next: NextFunction,
-    ): Promise<void> => {
-      try {
-        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-          req.params["statusPageIdOrDomain"] as string,
-        );
-
-        const response: JSONObject = await this.getScheduledMaintenanceEvents(
-          objectId,
-          null,
-
-          req,
-        );
-
-        // These can serve private-page data on a GET; never let shared caches store them.
-        Response.setNoCacheHeaders(res);
-
-        return Response.sendJsonObjectResponse(req, res, response);
-      } catch (err) {
-        next(err);
-      }
-    };
-
-    const scheduledMaintenanceEventsListApiPath: string = `${new this.entityType()
-      .getCrudApiPath()
-      ?.toString()}/scheduled-maintenance-events/:statusPageIdOrDomain`;
-
-    this.router.post(
-      scheduledMaintenanceEventsListApiPath,
-      UserMiddleware.getUserMiddleware,
-      scheduledMaintenanceEventsListHandler,
-    );
-
-    this.router.get(
-      scheduledMaintenanceEventsListApiPath,
-      UserMiddleware.getUserMiddleware,
-      scheduledMaintenanceEventsListHandler,
-    );
-
-    /*
-     * Shared handler for the announcements list endpoint. Registered for
-     * both POST and GET (same auth path). It does not read req.body.
-     */
-    const announcementsListHandler: (
-      req: ExpressRequest,
-      res: ExpressResponse,
-      next: NextFunction,
-    ) => Promise<void> = async (
-      req: ExpressRequest,
-      res: ExpressResponse,
-      next: NextFunction,
-    ): Promise<void> => {
-      try {
-        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-          req.params["statusPageIdOrDomain"] as string,
-        );
-
-        const response: JSONObject = await this.getAnnouncements(
-          objectId,
-          null,
-
-          req,
-        );
-
-        // These can serve private-page data on a GET; never let shared caches store them.
-        Response.setNoCacheHeaders(res);
-
-        return Response.sendJsonObjectResponse(req, res, response);
-      } catch (err) {
-        next(err);
-      }
-    };
-
-    const announcementsListApiPath: string = `${new this.entityType()
-      .getCrudApiPath()
-      ?.toString()}/announcements/:statusPageIdOrDomain`;
-
-    this.router.post(
-      announcementsListApiPath,
-      UserMiddleware.getUserMiddleware,
-      announcementsListHandler,
-    );
-
-    this.router.get(
-      announcementsListApiPath,
-      UserMiddleware.getUserMiddleware,
-      announcementsListHandler,
-    );
-
-    this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/incidents/:statusPageIdOrDomain/:incidentId`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
-
-          const incidentId: ObjectID = new ObjectID(
-            req.params["incidentId"] as string,
-          );
-
-          const response: JSONObject = await this.getIncidents(
-            objectId,
-            incidentId,
-            req,
-          );
-
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
-
-    this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/scheduled-maintenance-events/:statusPageIdOrDomain/:scheduledMaintenanceId`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
-
-          const scheduledMaintenanceId: ObjectID = new ObjectID(
-            req.params["scheduledMaintenanceId"] as string,
-          );
-
-          const response: JSONObject = await this.getScheduledMaintenanceEvents(
-            objectId,
-            scheduledMaintenanceId,
-
-            req,
-          );
-
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
-
-    this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/announcements/:statusPageIdOrDomain/:announcementId`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
-
-          const announcementId: ObjectID = new ObjectID(
-            req.params["announcementId"] as string,
-          );
-
-          const response: JSONObject = await this.getAnnouncements(
-            objectId,
-            announcementId,
-
-            req,
-          );
-
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
-
-    // Episodes endpoints
-    this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/episodes/:statusPageIdOrDomain`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
-
-          const response: JSONObject = await this.getEpisodes(
-            objectId,
-            null,
-            req,
-          );
-
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
-
-    this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/episodes/:statusPageIdOrDomain/:episodeId`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
-
-          const episodeId: ObjectID = new ObjectID(
-            req.params["episodeId"] as string,
-          );
-
-          const response: JSONObject = await this.getEpisodes(
-            objectId,
-            episodeId,
-            req,
-          );
-
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
-  }
-
-  @CaptureSpan()
-  public async getScheduledMaintenanceEvents(
-    statusPageId: ObjectID,
-    scheduledMaintenanceId: ObjectID | null,
-    req: ExpressRequest,
-  ): Promise<JSONObject> {
-    await this.checkHasReadAccess({
-      statusPageId: statusPageId,
-      req: req,
-    });
+  @CaptureSpan()
+  public async getScheduledMaintenanceEvents(
+    statusPageId: ObjectID,
+    scheduledMaintenanceId: ObjectID | null,
+    req: ExpressRequest,
+  ): Promise<JSONObject> {
+    await this.checkHasReadAccess({
+      statusPageId: statusPageId,
+      req: req,
+    });
 
     const statusPage: StatusPage | null = await StatusPageService.findOneBy({
       query: {
@@ -3757,403 +2968,681 @@ export default class StatusPageAPI extends BaseAPI<
         getLogAttributesFromRequest(req as any),
       );
       throw new BadDataException(
-        "Email subscribers not enabled for this status page.",
+        "Email subscribers not enabled for this status page.",
+      );
+    }
+
+    if (req.body.data["subscriberPhone"] && !statusPage.enableSmsSubscribers) {
+      logger.debug(
+        `SMS subscribers not enabled for status page with ID: ${objectId}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      throw new BadDataException(
+        "SMS subscribers not enabled for this status page.",
+      );
+    }
+
+    // if no email or phone, throw error.
+
+    if (
+      req.body.data["slackWorkspaceName"] &&
+      !statusPage.enableSlackSubscribers
+    ) {
+      logger.debug(
+        `Slack subscribers not enabled for status page with ID: ${objectId}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      throw new BadDataException(
+        "Slack subscribers not enabled for this status page.",
+      );
+    }
+
+    if (
+      req.body.data["microsoftTeamsWorkspaceName"] &&
+      !statusPage.enableMicrosoftTeamsSubscribers
+    ) {
+      logger.debug(
+        `Microsoft Teams subscribers not enabled for status page with ID: ${objectId}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      throw new BadDataException(
+        "Microsoft Teams subscribers not enabled for this status page.",
+      );
+    }
+
+    if (
+      req.body.data["subscriberWebhook"] &&
+      !statusPage.enableWebhookSubscribers
+    ) {
+      logger.debug(
+        `Webhook subscribers not enabled for status page with ID: ${objectId}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      throw new BadDataException(
+        "Webhook subscribers not enabled for this status page.",
+      );
+    }
+
+    if (
+      !req.params["subscriberId"] &&
+      !req.body.data["subscriberEmail"] &&
+      !req.body.data["subscriberPhone"] &&
+      !req.body.data["slackWorkspaceName"] &&
+      !req.body.data["microsoftTeamsWorkspaceName"] &&
+      !req.body.data["subscriberWebhook"]
+    ) {
+      logger.debug(
+        `No email, phone, slack workspace name, Microsoft Teams workspace name, or webhook URL provided for subscription to status page with ID: ${objectId}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      throw new BadDataException(
+        "Email, phone, slack workspace name, Microsoft Teams workspace name, or webhook URL is required to subscribe to this status page.",
+      );
+    }
+
+    const email: Email | undefined = req.body.data["subscriberEmail"]
+      ? new Email(req.body.data["subscriberEmail"] as string)
+      : undefined;
+
+    const phone: Phone | undefined = req.body.data["subscriberPhone"]
+      ? new Phone(req.body.data["subscriberPhone"] as string)
+      : undefined;
+
+    const slackIncomingWebhookUrl: string | undefined = req.body.data[
+      "slackIncomingWebhookUrl"
+    ]
+      ? (req.body.data["slackIncomingWebhookUrl"] as string)
+      : undefined;
+
+    const slackWorkspaceName: string | undefined = req.body.data[
+      "slackWorkspaceName"
+    ]
+      ? (req.body.data["slackWorkspaceName"] as string)
+      : undefined;
+
+    const microsoftTeamsIncomingWebhookUrl: string | undefined = req.body.data[
+      "microsoftTeamsIncomingWebhookUrl"
+    ]
+      ? (req.body.data["microsoftTeamsIncomingWebhookUrl"] as string)
+      : undefined;
+
+    const microsoftTeamsWorkspaceName: string | undefined = req.body.data[
+      "microsoftTeamsWorkspaceName"
+    ]
+      ? (req.body.data["microsoftTeamsWorkspaceName"] as string)
+      : undefined;
+
+    const subscriberWebhookUrl: string | undefined = req.body.data[
+      "subscriberWebhook"
+    ]
+      ? (req.body.data["subscriberWebhook"] as string)
+      : undefined;
+
+    let statusPageSubscriber: StatusPageSubscriber | null = null;
+
+    let isUpdate: boolean = false;
+
+    if (!req.params["subscriberId"]) {
+      logger.debug(
+        `Creating new subscriber for status page with ID: ${objectId}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      statusPageSubscriber = new StatusPageSubscriber();
+    } else {
+      const subscriberId: ObjectID = new ObjectID(
+        req.params["subscriberId"] as string,
+      );
+
+      logger.debug(
+        `Updating existing subscriber with ID: ${subscriberId} for status page with ID: ${objectId}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      /*
+       * Scope the lookup to the status page in the route. This endpoint only
+       * checks read access on that status page, so without the statusPageId
+       * clause anyone holding a subscriber UUID could pass any status page they
+       * can read and edit a subscriber belonging to a different — possibly
+       * private — status page. A subscriber on another page must be
+       * indistinguishable from one that does not exist, so that the shared
+       * "Subscriber not found" below cannot be used to probe for valid UUIDs.
+       */
+      statusPageSubscriber = await StatusPageSubscriberService.findOneBy({
+        query: {
+          _id: subscriberId.toString(),
+          statusPageId: objectId,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!statusPageSubscriber) {
+        logger.debug(
+          `Subscriber not found with ID: ${subscriberId} on status page with ID: ${objectId}`,
+          getLogAttributesFromRequest(req as any),
+        );
+        throw new BadDataException("Subscriber not found");
+      }
+
+      isUpdate = true;
+    }
+
+    if (email) {
+      logger.debug(
+        `Setting subscriber email: ${email}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      statusPageSubscriber.subscriberEmail = email;
+    }
+
+    if (phone) {
+      logger.debug(
+        `Setting subscriber phone: ${phone}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      statusPageSubscriber.subscriberPhone = phone;
+    }
+
+    if (slackIncomingWebhookUrl) {
+      logger.debug(
+        `Setting subscriber slack: ${slackIncomingWebhookUrl}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      statusPageSubscriber.slackIncomingWebhookUrl = URL.fromString(
+        slackIncomingWebhookUrl,
+      );
+    }
+
+    if (slackWorkspaceName) {
+      logger.debug(
+        `Setting subscriber slack workspace name: ${slackWorkspaceName}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      statusPageSubscriber.slackWorkspaceName = slackWorkspaceName;
+    }
+
+    if (microsoftTeamsIncomingWebhookUrl) {
+      logger.debug(
+        `Setting subscriber Microsoft Teams webhook: ${microsoftTeamsIncomingWebhookUrl}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      statusPageSubscriber.microsoftTeamsIncomingWebhookUrl = URL.fromString(
+        microsoftTeamsIncomingWebhookUrl,
+      );
+    }
+
+    if (microsoftTeamsWorkspaceName) {
+      logger.debug(
+        `Setting subscriber Microsoft Teams workspace name: ${microsoftTeamsWorkspaceName}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      statusPageSubscriber.microsoftTeamsWorkspaceName =
+        microsoftTeamsWorkspaceName;
+    }
+
+    if (subscriberWebhookUrl) {
+      logger.debug(
+        `Setting subscriber webhook URL: ${subscriberWebhookUrl}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      statusPageSubscriber.subscriberWebhook =
+        URL.fromString(subscriberWebhookUrl);
+    }
+
+    if (
+      !isUpdate &&
+      req.body.data["statusPageResources"] &&
+      !statusPage.allowSubscribersToChooseResources
+    ) {
+      logger.debug(
+        `Subscribers not allowed to choose resources for status page with ID: ${objectId}`,
+        getLogAttributesFromRequest(req as any),
+      );
+      throw new BadDataException(
+        "Subscribers are not allowed to choose resources for this status page.",
       );
     }
 
-    if (req.body.data["subscriberPhone"] && !statusPage.enableSmsSubscribers) {
+    if (
+      !isUpdate &&
+      req.body.data["statusPageEventTypes"] &&
+      !statusPage.allowSubscribersToChooseEventTypes
+    ) {
       logger.debug(
-        `SMS subscribers not enabled for status page with ID: ${objectId}`,
+        `Subscribers not allowed to choose event types for status page with ID: ${objectId}`,
         getLogAttributesFromRequest(req as any),
       );
       throw new BadDataException(
-        "SMS subscribers not enabled for this status page.",
+        "Subscribers are not allowed to choose event types for this status page.",
       );
     }
 
-    // if no email or phone, throw error.
+    statusPageSubscriber.statusPageId = objectId;
+    statusPageSubscriber.sendYouHaveSubscribedMessage = true;
+    statusPageSubscriber.projectId = statusPage.projectId!;
+    statusPageSubscriber.isSubscribedToAllResources = Boolean(
+      req.body.data["isSubscribedToAllResources"],
+    );
+
+    statusPageSubscriber.isSubscribedToAllEventTypes = Boolean(
+      req.body.data["isSubscribedToAllEventTypes"],
+    );
 
     if (
-      req.body.data["slackWorkspaceName"] &&
-      !statusPage.enableSlackSubscribers
+      req.body.data["statusPageResources"] &&
+      req.body.data["statusPageResources"].length > 0
     ) {
       logger.debug(
-        `Slack subscribers not enabled for status page with ID: ${objectId}`,
+        `Setting subscriber resources: ${JSON.stringify(req.body.data["statusPageResources"])}`,
         getLogAttributesFromRequest(req as any),
       );
-      throw new BadDataException(
-        "Slack subscribers not enabled for this status page.",
-      );
+      statusPageSubscriber.statusPageResources = req.body.data[
+        "statusPageResources"
+      ] as Array<StatusPageResource>;
     }
 
     if (
-      req.body.data["microsoftTeamsWorkspaceName"] &&
-      !statusPage.enableMicrosoftTeamsSubscribers
+      req.body.data["statusPageEventTypes"] &&
+      req.body.data["statusPageEventTypes"].length > 0
     ) {
       logger.debug(
-        `Microsoft Teams subscribers not enabled for status page with ID: ${objectId}`,
+        `Setting subscriber event types: ${JSON.stringify(req.body.data["statusPageEventTypes"])}`,
         getLogAttributesFromRequest(req as any),
       );
-      throw new BadDataException(
-        "Microsoft Teams subscribers not enabled for this status page.",
-      );
+      statusPageSubscriber.statusPageEventTypes = req.body.data[
+        "statusPageEventTypes"
+      ] as Array<StatusPageEventType>;
     }
 
-    if (
-      req.body.data["subscriberWebhook"] &&
-      !statusPage.enableWebhookSubscribers
-    ) {
+    if (isUpdate) {
+      // check isUnsubscribed is set to false.
       logger.debug(
-        `Webhook subscribers not enabled for status page with ID: ${objectId}`,
+        `Updating subscriber with ID: ${statusPageSubscriber.id}`,
         getLogAttributesFromRequest(req as any),
       );
-      throw new BadDataException(
-        "Webhook subscribers not enabled for this status page.",
+      statusPageSubscriber.isUnsubscribed = Boolean(
+        req.body.data["isUnsubscribed"],
       );
-    }
 
-    if (
-      !req.params["subscriberId"] &&
-      !req.body.data["subscriberEmail"] &&
-      !req.body.data["subscriberPhone"] &&
-      !req.body.data["slackWorkspaceName"] &&
-      !req.body.data["microsoftTeamsWorkspaceName"] &&
-      !req.body.data["subscriberWebhook"]
-    ) {
+      await StatusPageSubscriberService.updateOneById({
+        id: statusPageSubscriber.id!,
+        data: {
+          statusPageResources: statusPageSubscriber.statusPageResources!,
+          isSubscribedToAllResources:
+            statusPageSubscriber.isSubscribedToAllResources!,
+          statusPageEventTypes: statusPageSubscriber.statusPageEventTypes!,
+          isSubscribedToAllEventTypes:
+            statusPageSubscriber.isSubscribedToAllEventTypes!,
+          isUnsubscribed: statusPageSubscriber.isUnsubscribed,
+        } as any,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
       logger.debug(
-        `No email, phone, slack workspace name, Microsoft Teams workspace name, or webhook URL provided for subscription to status page with ID: ${objectId}`,
+        `Creating new subscriber: ${JSON.stringify(statusPageSubscriber)}`,
         getLogAttributesFromRequest(req as any),
       );
-      throw new BadDataException(
-        "Email, phone, slack workspace name, Microsoft Teams workspace name, or webhook URL is required to subscribe to this status page.",
-      );
+      await StatusPageSubscriberService.create({
+        data: statusPageSubscriber,
+        props: {
+          isRoot: true,
+        },
+      });
     }
 
-    const email: Email | undefined = req.body.data["subscriberEmail"]
-      ? new Email(req.body.data["subscriberEmail"] as string)
-      : undefined;
-
-    const phone: Phone | undefined = req.body.data["subscriberPhone"]
-      ? new Phone(req.body.data["subscriberPhone"] as string)
-      : undefined;
-
-    const slackIncomingWebhookUrl: string | undefined = req.body.data[
-      "slackIncomingWebhookUrl"
-    ]
-      ? (req.body.data["slackIncomingWebhookUrl"] as string)
-      : undefined;
-
-    const slackWorkspaceName: string | undefined = req.body.data[
-      "slackWorkspaceName"
-    ]
-      ? (req.body.data["slackWorkspaceName"] as string)
-      : undefined;
-
-    const microsoftTeamsIncomingWebhookUrl: string | undefined = req.body.data[
-      "microsoftTeamsIncomingWebhookUrl"
-    ]
-      ? (req.body.data["microsoftTeamsIncomingWebhookUrl"] as string)
-      : undefined;
+    logger.debug(
+      `Subscription process completed for status page with ID: ${objectId}`,
+      getLogAttributesFromRequest(req as any),
+    );
+  }
 
-    const microsoftTeamsWorkspaceName: string | undefined = req.body.data[
-      "microsoftTeamsWorkspaceName"
-    ]
-      ? (req.body.data["microsoftTeamsWorkspaceName"] as string)
-      : undefined;
+  @CaptureSpan()
+  public async getSubscriber(
+    req: ExpressRequest,
+  ): Promise<StatusPageSubscriber> {
+    const objectId: ObjectID = new ObjectID(
+      req.params["statusPageId"] as string,
+    );
 
-    const subscriberWebhookUrl: string | undefined = req.body.data[
-      "subscriberWebhook"
-    ]
-      ? (req.body.data["subscriberWebhook"] as string)
-      : undefined;
+    await this.checkHasReadAccess({
+      statusPageId: objectId,
+      req: req,
+    });
 
-    let statusPageSubscriber: StatusPageSubscriber | null = null;
+    const statusPage: StatusPage | null = await StatusPageService.findOneBy({
+      query: {
+        _id: objectId.toString(),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
 
-    let isUpdate: boolean = false;
+    if (!statusPage) {
+      throw new BadDataException("Status Page not found");
+    }
 
-    if (!req.params["subscriberId"]) {
-      logger.debug(
-        `Creating new subscriber for status page with ID: ${objectId}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber = new StatusPageSubscriber();
-    } else {
-      const subscriberId: ObjectID = new ObjectID(
-        req.params["subscriberId"] as string,
-      );
+    const subscriberId: ObjectID = new ObjectID(
+      req.params["subscriberId"] as string,
+    );
 
-      logger.debug(
-        `Updating existing subscriber with ID: ${subscriberId} for status page with ID: ${objectId}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      /*
-       * Scope the lookup to the status page in the route. This endpoint only
-       * checks read access on that status page, so without the statusPageId
-       * clause anyone holding a subscriber UUID could pass any status page they
-       * can read and edit a subscriber belonging to a different — possibly
-       * private — status page. A subscriber on another page must be
-       * indistinguishable from one that does not exist, so that the shared
-       * "Subscriber not found" below cannot be used to probe for valid UUIDs.
-       */
-      statusPageSubscriber = await StatusPageSubscriberService.findOneBy({
+    const statusPageSubscriber: StatusPageSubscriber | null =
+      await StatusPageSubscriberService.findOneBy({
         query: {
           _id: subscriberId.toString(),
-          statusPageId: objectId,
+          statusPageId: statusPage.id!,
+        },
+        select: {
+          isUnsubscribed: true,
+          subscriberEmail: true,
+          subscriberPhone: true,
+          slackWorkspaceName: true,
+          statusPageId: true,
+          statusPageResources: true,
+          isSubscribedToAllResources: true,
+          statusPageEventTypes: true,
+          isSubscribedToAllEventTypes: true,
         },
         props: {
           isRoot: true,
         },
       });
 
-      if (!statusPageSubscriber) {
-        logger.debug(
-          `Subscriber not found with ID: ${subscriberId} on status page with ID: ${objectId}`,
-          getLogAttributesFromRequest(req as any),
-        );
-        throw new BadDataException("Subscriber not found");
-      }
+    if (!statusPageSubscriber) {
+      throw new BadDataException("Subscriber not found");
+    }
+
+    return statusPageSubscriber;
+  }
+
+  @CaptureSpan()
+  public async getIncidents(
+    statusPageId: ObjectID,
+    incidentId: ObjectID | null,
+    req: ExpressRequest,
+  ): Promise<JSONObject> {
+    await this.checkHasReadAccess({
+      statusPageId: statusPageId,
+      req: req,
+    });
+
+    const statusPage: StatusPage | null = await StatusPageService.findOneBy({
+      query: {
+        _id: statusPageId.toString(),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+        showIncidentHistoryInDays: true,
+        showIncidentLabelsOnStatusPage: true,
+        showIncidentsOnStatusPage: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!statusPage) {
+      throw new BadDataException("Status Page not found");
+    }
+
+    if (!statusPage.showIncidentsOnStatusPage) {
+      throw new BadDataException(
+        "Incidents are not enabled on this status page.",
+      );
+    }
+
+    // get monitors on status page.
+    const statusPageResources: Array<StatusPageResource> =
+      await StatusPageService.getStatusPageResources({
+        statusPageId: statusPageId,
+      });
+
+    const { monitorsOnStatusPage, monitorsInGroup } =
+      await StatusPageService.getMonitorIdsOnStatusPage({
+        statusPageId: statusPageId,
+        // reuse the resources fetched above instead of re-querying them
+        statusPageResources: statusPageResources,
+      });
 
-      isUpdate = true;
-    }
+    const today: Date = OneUptimeDate.getCurrentDate();
 
-    if (email) {
-      logger.debug(
-        `Setting subscriber email: ${email}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.subscriberEmail = email;
-    }
+    const historyDays: Date = OneUptimeDate.getSomeDaysAgo(
+      statusPage.showIncidentHistoryInDays || 14,
+    );
 
-    if (phone) {
-      logger.debug(
-        `Setting subscriber phone: ${phone}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.subscriberPhone = phone;
-    }
+    let incidentQuery: Query<Incident> = {
+      monitors: monitorsOnStatusPage as any,
+      projectId: statusPage.projectId!,
+      createdAt: QueryHelper.inBetween(historyDays, today),
+      isVisibleOnStatusPage: true,
+    };
 
-    if (slackIncomingWebhookUrl) {
-      logger.debug(
-        `Setting subscriber slack: ${slackIncomingWebhookUrl}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.slackIncomingWebhookUrl = URL.fromString(
-        slackIncomingWebhookUrl,
-      );
+    if (incidentId) {
+      incidentQuery = {
+        monitors: monitorsOnStatusPage as any,
+        projectId: statusPage.projectId!,
+        _id: incidentId.toString(),
+        isVisibleOnStatusPage: true,
+      };
     }
 
-    if (slackWorkspaceName) {
-      logger.debug(
-        `Setting subscriber slack workspace name: ${slackWorkspaceName}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.slackWorkspaceName = slackWorkspaceName;
-    }
+    // check if status page has active incident.
+    let incidents: Array<Incident> = [];
 
-    if (microsoftTeamsIncomingWebhookUrl) {
-      logger.debug(
-        `Setting subscriber Microsoft Teams webhook: ${microsoftTeamsIncomingWebhookUrl}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.microsoftTeamsIncomingWebhookUrl = URL.fromString(
-        microsoftTeamsIncomingWebhookUrl,
-      );
-    }
+    let selectIncidents: Select<Incident> = {
+      createdAt: true,
+      declaredAt: true,
+      updatedAt: true,
+      title: true,
+      description: true,
+      _id: true,
+      postmortemNote: true,
+      postmortemPostedAt: true,
+      showPostmortemOnStatusPage: true,
+      postmortemAttachments: {
+        _id: true,
+        name: true,
+      },
+      incidentSeverity: {
+        name: true,
+        color: true,
+      },
+      currentIncidentState: {
+        name: true,
+        color: true,
+        _id: true,
+        order: true,
+      },
+      monitors: {
+        _id: true,
+      },
+    };
 
-    if (microsoftTeamsWorkspaceName) {
-      logger.debug(
-        `Setting subscriber Microsoft Teams workspace name: ${microsoftTeamsWorkspaceName}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.microsoftTeamsWorkspaceName =
-        microsoftTeamsWorkspaceName;
+    if (statusPage.showIncidentLabelsOnStatusPage) {
+      selectIncidents = {
+        ...selectIncidents,
+        labels: {
+          name: true,
+          color: true,
+        },
+      };
     }
 
-    if (subscriberWebhookUrl) {
-      logger.debug(
-        `Setting subscriber webhook URL: ${subscriberWebhookUrl}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.subscriberWebhook =
-        URL.fromString(subscriberWebhookUrl);
-    }
+    if (monitorsOnStatusPage.length > 0) {
+      incidents = await IncidentService.findBy({
+        query: incidentQuery,
+        select: selectIncidents,
+        sort: {
+          declaredAt: SortOrder.Descending,
+          createdAt: SortOrder.Descending,
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: {
+          isRoot: true,
+        },
+      });
 
-    if (
-      !isUpdate &&
-      req.body.data["statusPageResources"] &&
-      !statusPage.allowSubscribersToChooseResources
-    ) {
-      logger.debug(
-        `Subscribers not allowed to choose resources for status page with ID: ${objectId}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      throw new BadDataException(
-        "Subscribers are not allowed to choose resources for this status page.",
-      );
-    }
+      let activeIncidents: Array<Incident> = [];
 
-    if (
-      !isUpdate &&
-      req.body.data["statusPageEventTypes"] &&
-      !statusPage.allowSubscribersToChooseEventTypes
-    ) {
-      logger.debug(
-        `Subscribers not allowed to choose event types for status page with ID: ${objectId}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      throw new BadDataException(
-        "Subscribers are not allowed to choose event types for this status page.",
-      );
-    }
+      const unresolvedIncidentStates: Array<IncidentState> =
+        await IncidentStateService.getUnresolvedIncidentStates(
+          statusPage.projectId!,
+          {
+            isRoot: true,
+          },
+        );
 
-    statusPageSubscriber.statusPageId = objectId;
-    statusPageSubscriber.sendYouHaveSubscribedMessage = true;
-    statusPageSubscriber.projectId = statusPage.projectId!;
-    statusPageSubscriber.isSubscribedToAllResources = Boolean(
-      req.body.data["isSubscribedToAllResources"],
-    );
+      const unresolvbedIncidentStateIds: Array<ObjectID> =
+        unresolvedIncidentStates.map((state: IncidentState) => {
+          return state.id!;
+        });
 
-    statusPageSubscriber.isSubscribedToAllEventTypes = Boolean(
-      req.body.data["isSubscribedToAllEventTypes"],
-    );
+      // If there is no particular incident id to fetch then fetch active incidents.
+      if (!incidentId) {
+        activeIncidents = await IncidentService.findBy({
+          query: {
+            monitors: monitorsOnStatusPage as any,
+            isVisibleOnStatusPage: true,
+            currentIncidentStateId: QueryHelper.any(
+              unresolvbedIncidentStateIds,
+            ),
+            projectId: statusPage.projectId!,
+          },
+          select: selectIncidents,
+          sort: {
+            declaredAt: SortOrder.Descending,
+            createdAt: SortOrder.Descending,
+          },
 
-    if (
-      req.body.data["statusPageResources"] &&
-      req.body.data["statusPageResources"].length > 0
-    ) {
-      logger.debug(
-        `Setting subscriber resources: ${JSON.stringify(req.body.data["statusPageResources"])}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.statusPageResources = req.body.data[
-        "statusPageResources"
-      ] as Array<StatusPageResource>;
-    }
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+      }
 
-    if (
-      req.body.data["statusPageEventTypes"] &&
-      req.body.data["statusPageEventTypes"].length > 0
-    ) {
-      logger.debug(
-        `Setting subscriber event types: ${JSON.stringify(req.body.data["statusPageEventTypes"])}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.statusPageEventTypes = req.body.data[
-        "statusPageEventTypes"
-      ] as Array<StatusPageEventType>;
-    }
+      incidents = [...activeIncidents, ...incidents];
 
-    if (isUpdate) {
-      // check isUnsubscribed is set to false.
-      logger.debug(
-        `Updating subscriber with ID: ${statusPageSubscriber.id}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      statusPageSubscriber.isUnsubscribed = Boolean(
-        req.body.data["isUnsubscribed"],
-      );
+      // get distinct by id.
 
-      await StatusPageSubscriberService.updateOneById({
-        id: statusPageSubscriber.id!,
-        data: {
-          statusPageResources: statusPageSubscriber.statusPageResources!,
-          isSubscribedToAllResources:
-            statusPageSubscriber.isSubscribedToAllResources!,
-          statusPageEventTypes: statusPageSubscriber.statusPageEventTypes!,
-          isSubscribedToAllEventTypes:
-            statusPageSubscriber.isSubscribedToAllEventTypes!,
-          isUnsubscribed: statusPageSubscriber.isUnsubscribed,
-        } as any,
-        props: {
-          isRoot: true,
+      incidents = ArrayUtil.distinctByFieldName(incidents, "_id");
+    }
+
+    const incidentsOnStatusPage: Array<ObjectID> = incidents.map(
+      (incident: Incident) => {
+        return incident.id!;
+      },
+    );
+
+    let incidentPublicNotes: Array<IncidentPublicNote> = [];
+
+    if (incidentsOnStatusPage.length > 0) {
+      incidentPublicNotes = await IncidentPublicNoteService.findBy({
+        query: {
+          incidentId: QueryHelper.any(incidentsOnStatusPage),
+          projectId: statusPage.projectId!,
         },
-      });
-    } else {
-      logger.debug(
-        `Creating new subscriber: ${JSON.stringify(statusPageSubscriber)}`,
-        getLogAttributesFromRequest(req as any),
-      );
-      await StatusPageSubscriberService.create({
-        data: statusPageSubscriber,
+        select: {
+          postedAt: true,
+          note: true,
+          incidentId: true,
+          attachments: {
+            _id: true,
+            name: true,
+          },
+        },
+        sort: {
+          postedAt: SortOrder.Descending, // new note first
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
         props: {
           isRoot: true,
         },
       });
     }
 
-    logger.debug(
-      `Subscription process completed for status page with ID: ${objectId}`,
-      getLogAttributesFromRequest(req as any),
-    );
-  }
-
-  @CaptureSpan()
-  public async getSubscriber(
-    req: ExpressRequest,
-  ): Promise<StatusPageSubscriber> {
-    const objectId: ObjectID = new ObjectID(
-      req.params["statusPageId"] as string,
-    );
-
-    await this.checkHasReadAccess({
-      statusPageId: objectId,
-      req: req,
-    });
+    let incidentStateTimelines: Array<IncidentStateTimeline> = [];
 
-    const statusPage: StatusPage | null = await StatusPageService.findOneBy({
-      query: {
-        _id: objectId.toString(),
-      },
-      select: {
-        _id: true,
-        projectId: true,
-      },
-      props: {
-        isRoot: true,
-      },
-    });
+    if (incidentsOnStatusPage.length > 0) {
+      incidentStateTimelines = await IncidentStateTimelineService.findBy({
+        query: {
+          incidentId: QueryHelper.any(incidentsOnStatusPage),
+          projectId: statusPage.projectId!,
+        },
+        select: {
+          _id: true,
+          createdAt: true,
+          startsAt: true,
+          incidentId: true,
+          incidentState: {
+            name: true,
+            color: true,
+          },
+        },
+        sort: {
+          startsAt: SortOrder.Descending, // newer state changes first
+        },
 
-    if (!statusPage) {
-      throw new BadDataException("Status Page not found");
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: {
+          isRoot: true,
+        },
+      });
     }
 
-    const subscriberId: ObjectID = new ObjectID(
-      req.params["subscriberId"] as string,
-    );
-
-    const statusPageSubscriber: StatusPageSubscriber | null =
-      await StatusPageSubscriberService.findOneBy({
+    // get all the incident states for this project.
+    const incidentStates: Array<IncidentState> =
+      await IncidentStateService.findBy({
         query: {
-          _id: subscriberId.toString(),
-          statusPageId: statusPage.id!,
+          projectId: statusPage.projectId!,
         },
         select: {
-          isUnsubscribed: true,
-          subscriberEmail: true,
-          subscriberPhone: true,
-          slackWorkspaceName: true,
-          statusPageId: true,
-          statusPageResources: true,
-          isSubscribedToAllResources: true,
-          statusPageEventTypes: true,
-          isSubscribedToAllEventTypes: true,
+          isResolvedState: true,
+          order: true,
         },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
         props: {
           isRoot: true,
         },
       });
 
-    if (!statusPageSubscriber) {
-      throw new BadDataException("Subscriber not found");
-    }
+    const response: JSONObject = {
+      incidentPublicNotes: BaseModel.toJSONArray(
+        incidentPublicNotes,
+        IncidentPublicNote,
+      ),
+      incidentStates: BaseModel.toJSONArray(incidentStates, IncidentState),
+      incidents: BaseModel.toJSONArray(incidents, Incident),
+      statusPageResources: BaseModel.toJSONArray(
+        statusPageResources,
+        StatusPageResource,
+      ),
+      incidentStateTimelines: BaseModel.toJSONArray(
+        incidentStateTimelines,
+        IncidentStateTimeline,
+      ),
+      monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
+    };
 
-    return statusPageSubscriber;
+    return response;
   }
 
   @CaptureSpan()
-  public async getIncidents(
+  public async getEpisodes(
     statusPageId: ObjectID,
-    incidentId: ObjectID | null,
+    episodeId: ObjectID | null,
     req: ExpressRequest,
   ): Promise<JSONObject> {
     await this.checkHasReadAccess({
@@ -4168,9 +3657,9 @@ export default class StatusPageAPI extends BaseAPI<
       select: {
         _id: true,
         projectId: true,
-        showIncidentHistoryInDays: true,
-        showIncidentLabelsOnStatusPage: true,
-        showIncidentsOnStatusPage: true,
+        showEpisodeHistoryInDays: true,
+        showEpisodesOnStatusPage: true,
+        showEpisodeLabelsOnStatusPage: true,
       },
       props: {
         isRoot: true,
@@ -4181,9 +3670,9 @@ export default class StatusPageAPI extends BaseAPI<
       throw new BadDataException("Status Page not found");
     }
 
-    if (!statusPage.showIncidentsOnStatusPage) {
+    if (!statusPage.showEpisodesOnStatusPage) {
       throw new BadDataException(
-        "Incidents are not enabled on this status page.",
+        "Episodes are not enabled on this status page.",
       );
     }
 
@@ -4203,42 +3692,133 @@ export default class StatusPageAPI extends BaseAPI<
     const today: Date = OneUptimeDate.getCurrentDate();
 
     const historyDays: Date = OneUptimeDate.getSomeDaysAgo(
-      statusPage.showIncidentHistoryInDays || 14,
+      statusPage.showEpisodeHistoryInDays || 14,
     );
 
-    let incidentQuery: Query<Incident> = {
+    /*
+     * Get incidents that have monitors on this status page
+     * Note: We don't filter by incident.isVisibleOnStatusPage here because
+     * episode visibility is independent of incident visibility.
+     * An episode should show if episode.isVisibleOnStatusPage is true,
+     * regardless of whether its member incidents are visible.
+     */
+    const incidentQuery: Query<Incident> = {
       monitors: monitorsOnStatusPage as any,
       projectId: statusPage.projectId!,
       createdAt: QueryHelper.inBetween(historyDays, today),
+    };
+
+    let incidents: Array<Incident> = [];
+
+    if (monitorsOnStatusPage.length > 0) {
+      incidents = await IncidentService.findBy({
+        query: incidentQuery,
+        select: {
+          _id: true,
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    const incidentIds: Array<ObjectID> = incidents.map((incident: Incident) => {
+      return incident.id!;
+    });
+
+    // Get episode members that link to these incidents
+    let episodeMembers: Array<IncidentEpisodeMember> = [];
+
+    if (incidentIds.length > 0) {
+      episodeMembers = await IncidentEpisodeMemberService.findBy({
+        query: {
+          incidentId: QueryHelper.any(incidentIds),
+          projectId: statusPage.projectId!,
+        },
+        select: {
+          incidentEpisodeId: true,
+          incidentId: true,
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    // Get unique episode IDs
+    const episodeIdsFromMembers: Set<string> = new Set();
+    for (const member of episodeMembers) {
+      if (member.incidentEpisodeId) {
+        episodeIdsFromMembers.add(member.incidentEpisodeId.toString());
+      }
+    }
+
+    let episodeQuery: Query<IncidentEpisode> = {
+      _id: QueryHelper.any(
+        Array.from(episodeIdsFromMembers).map((id: string) => {
+          return new ObjectID(id);
+        }),
+      ),
+      projectId: statusPage.projectId!,
       isVisibleOnStatusPage: true,
     };
 
-    if (incidentId) {
-      incidentQuery = {
-        monitors: monitorsOnStatusPage as any,
+    if (episodeId) {
+      episodeQuery = {
+        _id: episodeId.toString(),
         projectId: statusPage.projectId!,
-        _id: incidentId.toString(),
         isVisibleOnStatusPage: true,
       };
+
+      // When viewing a specific episode, also fetch its members directly
+      const episodeMembersForSpecificEpisode: Array<IncidentEpisodeMember> =
+        await IncidentEpisodeMemberService.findBy({
+          query: {
+            incidentEpisodeId: episodeId,
+            projectId: statusPage.projectId!,
+          },
+          select: {
+            incidentEpisodeId: true,
+            incidentId: true,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+
+      // Merge with existing episode members
+      for (const member of episodeMembersForSpecificEpisode) {
+        if (
+          !episodeMembers.some((m: IncidentEpisodeMember) => {
+            return (
+              m.incidentEpisodeId?.toString() ===
+                member.incidentEpisodeId?.toString() &&
+              m.incidentId?.toString() === member.incidentId?.toString()
+            );
+          })
+        ) {
+          episodeMembers.push(member);
+        }
+      }
     }
 
-    // check if status page has active incident.
-    let incidents: Array<Incident> = [];
+    // Get episodes
+    let episodes: Array<IncidentEpisode> = [];
 
-    let selectIncidents: Select<Incident> = {
+    let selectEpisodes: Select<IncidentEpisode> = {
       createdAt: true,
       declaredAt: true,
       updatedAt: true,
       title: true,
       description: true,
       _id: true,
-      postmortemNote: true,
-      postmortemPostedAt: true,
-      showPostmortemOnStatusPage: true,
-      postmortemAttachments: {
-        _id: true,
-        name: true,
-      },
+      episodeNumber: true,
       incidentSeverity: {
         name: true,
         color: true,
@@ -4248,15 +3828,16 @@ export default class StatusPageAPI extends BaseAPI<
         color: true,
         _id: true,
         order: true,
+        isCreatedState: true,
+        isAcknowledgedState: true,
+        isResolvedState: true,
       },
-      monitors: {
-        _id: true,
-      },
+      incidentCount: true,
     };
 
-    if (statusPage.showIncidentLabelsOnStatusPage) {
-      selectIncidents = {
-        ...selectIncidents,
+    if (statusPage.showEpisodeLabelsOnStatusPage) {
+      selectEpisodes = {
+        ...selectEpisodes,
         labels: {
           name: true,
           color: true,
@@ -4264,10 +3845,10 @@ export default class StatusPageAPI extends BaseAPI<
       };
     }
 
-    if (monitorsOnStatusPage.length > 0) {
-      incidents = await IncidentService.findBy({
-        query: incidentQuery,
-        select: selectIncidents,
+    if (episodeIdsFromMembers.size > 0 || episodeId) {
+      episodes = await IncidentEpisodeService.findBy({
+        query: episodeQuery,
+        select: selectEpisodes,
         sort: {
           declaredAt: SortOrder.Descending,
           createdAt: SortOrder.Descending,
@@ -4278,9 +3859,10 @@ export default class StatusPageAPI extends BaseAPI<
           isRoot: true,
         },
       });
+    }
 
-      let activeIncidents: Array<Incident> = [];
-
+    // If no specific episode, also fetch active (unresolved) episodes
+    if (!episodeId && episodeIdsFromMembers.size > 0) {
       const unresolvedIncidentStates: Array<IncidentState> =
         await IncidentStateService.getUnresolvedIncidentStates(
           statusPage.projectId!,
@@ -4289,68 +3871,145 @@ export default class StatusPageAPI extends BaseAPI<
           },
         );
 
-      const unresolvbedIncidentStateIds: Array<ObjectID> =
+      const unresolvedIncidentStateIds: Array<ObjectID> =
         unresolvedIncidentStates.map((state: IncidentState) => {
           return state.id!;
         });
 
-      // If there is no particular incident id to fetch then fetch active incidents.
-      if (!incidentId) {
-        activeIncidents = await IncidentService.findBy({
+      const activeEpisodes: Array<IncidentEpisode> =
+        await IncidentEpisodeService.findBy({
           query: {
-            monitors: monitorsOnStatusPage as any,
-            isVisibleOnStatusPage: true,
-            currentIncidentStateId: QueryHelper.any(
-              unresolvbedIncidentStateIds,
+            _id: QueryHelper.any(
+              Array.from(episodeIdsFromMembers).map((id: string) => {
+                return new ObjectID(id);
+              }),
             ),
+            isVisibleOnStatusPage: true,
+            currentIncidentStateId: QueryHelper.any(unresolvedIncidentStateIds),
             projectId: statusPage.projectId!,
           },
-          select: selectIncidents,
+          select: selectEpisodes,
           sort: {
             declaredAt: SortOrder.Descending,
             createdAt: SortOrder.Descending,
           },
-
           skip: 0,
           limit: LIMIT_PER_PROJECT,
           props: {
             isRoot: true,
           },
         });
-      }
-
-      incidents = [...activeIncidents, ...incidents];
 
-      // get distinct by id.
-
-      incidents = ArrayUtil.distinctByFieldName(incidents, "_id");
+      episodes = [...activeEpisodes, ...episodes];
+      episodes = ArrayUtil.distinctByFieldName(episodes, "_id");
     }
 
-    const incidentsOnStatusPage: Array<ObjectID> = incidents.map(
-      (incident: Incident) => {
-        return incident.id!;
+    const episodesOnStatusPage: Array<ObjectID> = episodes.map(
+      (episode: IncidentEpisode) => {
+        return episode.id!;
       },
     );
 
-    let incidentPublicNotes: Array<IncidentPublicNote> = [];
+    /*
+     * Build a map of episode ID -> monitor IDs from episode members
+     * Collect all unique incident IDs from episode members
+     */
+    const memberIncidentIds: Array<ObjectID> = [];
+    for (const member of episodeMembers) {
+      if (
+        member.incidentId &&
+        !memberIncidentIds.some((id: ObjectID) => {
+          return id.toString() === member.incidentId!.toString();
+        })
+      ) {
+        memberIncidentIds.push(member.incidentId);
+      }
+    }
 
-    if (incidentsOnStatusPage.length > 0) {
-      incidentPublicNotes = await IncidentPublicNoteService.findBy({
+    // Fetch incidents with their monitors
+    let memberIncidents: Array<Incident> = [];
+    if (memberIncidentIds.length > 0) {
+      memberIncidents = await IncidentService.findBy({
         query: {
-          incidentId: QueryHelper.any(incidentsOnStatusPage),
+          _id: QueryHelper.any(memberIncidentIds),
+          projectId: statusPage.projectId!,
+        },
+        select: {
+          _id: true,
+          monitors: {
+            _id: true,
+          },
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    // Build a map of incident ID -> monitors
+    const incidentMonitorsMap: Map<string, Array<ObjectID>> = new Map();
+    for (const incident of memberIncidents) {
+      const incidentIdStr: string = incident.id!.toString();
+      const monitorIds: Array<ObjectID> = (incident.monitors || [])
+        .map((m: Monitor) => {
+          return new ObjectID(m._id?.toString() || m.id?.toString() || "");
+        })
+        .filter((id: ObjectID) => {
+          return id.toString() !== "";
+        });
+      incidentMonitorsMap.set(incidentIdStr, monitorIds);
+    }
+
+    // Build episode monitors map from members and incident monitors
+    const episodeMonitorsMap: Map<string, Array<ObjectID>> = new Map();
+    for (const member of episodeMembers) {
+      if (member.incidentEpisodeId && member.incidentId) {
+        const episodeIdStr: string = member.incidentEpisodeId.toString();
+        const incidentIdStr: string = member.incidentId.toString();
+
+        if (!episodeMonitorsMap.has(episodeIdStr)) {
+          episodeMonitorsMap.set(episodeIdStr, []);
+        }
+
+        const episodeMonitors: Array<ObjectID> =
+          episodeMonitorsMap.get(episodeIdStr)!;
+        const incidentMonitors: Array<ObjectID> =
+          incidentMonitorsMap.get(incidentIdStr) || [];
+
+        for (const monitorId of incidentMonitors) {
+          if (
+            !episodeMonitors.some((m: ObjectID) => {
+              return m.toString() === monitorId.toString();
+            })
+          ) {
+            episodeMonitors.push(monitorId);
+          }
+        }
+      }
+    }
+
+    // Get public notes for episodes
+    let episodePublicNotes: Array<IncidentEpisodePublicNote> = [];
+
+    if (episodesOnStatusPage.length > 0) {
+      episodePublicNotes = await IncidentEpisodePublicNoteService.findBy({
+        query: {
+          incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
           projectId: statusPage.projectId!,
         },
         select: {
           postedAt: true,
           note: true,
-          incidentId: true,
+          incidentEpisodeId: true,
           attachments: {
             _id: true,
             name: true,
           },
         },
         sort: {
-          postedAt: SortOrder.Descending, // new note first
+          postedAt: SortOrder.Descending,
         },
         skip: 0,
         limit: LIMIT_PER_PROJECT,
@@ -4360,28 +4019,31 @@ export default class StatusPageAPI extends BaseAPI<
       });
     }
 
-    let incidentStateTimelines: Array<IncidentStateTimeline> = [];
+    // Get state timelines for episodes
+    let episodeStateTimelines: Array<IncidentEpisodeStateTimeline> = [];
 
-    if (incidentsOnStatusPage.length > 0) {
-      incidentStateTimelines = await IncidentStateTimelineService.findBy({
+    if (episodesOnStatusPage.length > 0) {
+      episodeStateTimelines = await IncidentEpisodeStateTimelineService.findBy({
         query: {
-          incidentId: QueryHelper.any(incidentsOnStatusPage),
+          incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
           projectId: statusPage.projectId!,
         },
         select: {
           _id: true,
           createdAt: true,
           startsAt: true,
-          incidentId: true,
+          incidentEpisodeId: true,
           incidentState: {
             name: true,
             color: true,
+            isCreatedState: true,
+            isAcknowledgedState: true,
+            isResolvedState: true,
           },
         },
         sort: {
-          startsAt: SortOrder.Descending, // newer state changes first
+          startsAt: SortOrder.Descending,
         },
-
         skip: 0,
         limit: LIMIT_PER_PROJECT,
         props: {
@@ -4390,7 +4052,7 @@ export default class StatusPageAPI extends BaseAPI<
       });
     }
 
-    // get all the incident states for this project.
+    // Get all incident states for this project
     const incidentStates: Array<IncidentState> =
       await IncidentStateService.findBy({
         query: {
@@ -4407,20 +4069,37 @@ export default class StatusPageAPI extends BaseAPI<
         },
       });
 
+    // Serialize episodes and add monitors to each
+    const episodesJson: JSONArray = BaseModel.toJSONArray(
+      episodes,
+      IncidentEpisode,
+    );
+    for (const episodeJson of episodesJson) {
+      const episodeObj: JSONObject = episodeJson as JSONObject;
+      const episodeId: string | undefined = episodeObj["_id"]?.toString();
+      if (episodeId) {
+        const monitorIds: Array<ObjectID> =
+          episodeMonitorsMap.get(episodeId) || [];
+        episodeObj["monitors"] = monitorIds.map((id: ObjectID) => {
+          return { _id: id.toString() };
+        });
+      }
+    }
+
     const response: JSONObject = {
-      incidentPublicNotes: BaseModel.toJSONArray(
-        incidentPublicNotes,
-        IncidentPublicNote,
+      episodePublicNotes: BaseModel.toJSONArray(
+        episodePublicNotes,
+        IncidentEpisodePublicNote,
       ),
       incidentStates: BaseModel.toJSONArray(incidentStates, IncidentState),
-      incidents: BaseModel.toJSONArray(incidents, Incident),
+      episodes: episodesJson,
       statusPageResources: BaseModel.toJSONArray(
         statusPageResources,
         StatusPageResource,
       ),
-      incidentStateTimelines: BaseModel.toJSONArray(
-        incidentStateTimelines,
-        IncidentStateTimeline,
+      episodeStateTimelines: BaseModel.toJSONArray(
+        episodeStateTimelines,
+        IncidentEpisodeStateTimeline,
       ),
       monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
     };
@@ -4429,26 +4108,54 @@ export default class StatusPageAPI extends BaseAPI<
   }
 
   @CaptureSpan()
-  public async getEpisodes(
-    statusPageId: ObjectID,
-    episodeId: ObjectID | null,
-    req: ExpressRequest,
-  ): Promise<JSONObject> {
-    await this.checkHasReadAccess({
-      statusPageId: statusPageId,
-      req: req,
-    });
+  public async getStatusPageResourcesAndTimelines(data: {
+    statusPageId: ObjectID;
+    /*
+     * When omitted, the timeline window is computed from the status page's
+     * own showUptimeHistoryInDays (clamped to 1..90 days, ending now) —
+     * the status page row is fetched below anyway, so callers that want the
+     * page-configured window (the overview endpoint) don't need their own
+     * StatusPage query just to read that column.
+     */
+    startDateForMonitorTimeline?: Date | undefined;
+    endDateForMonitorTimeline?: Date | undefined;
+  }): Promise<{
+    statusPageResources: StatusPageResource[];
+    monitorStatuses: MonitorStatus[];
+    monitorStatusTimelines: MonitorStatusTimeline[];
+    monitorGroupCurrentStatuses: Dictionary<ObjectID>;
+    statusPageGroups: StatusPageGroup[];
+    statusPage: StatusPage;
+    monitorsOnStatusPage: ObjectID[];
+    monitorsInGroup: Dictionary<ObjectID[]>;
+    startDateForMonitorTimeline: Date;
+    endDateForMonitorTimeline: Date;
+  }> {
+    const objectId: ObjectID = data.statusPageId;
 
     const statusPage: StatusPage | null = await StatusPageService.findOneBy({
       query: {
-        _id: statusPageId.toString(),
+        _id: objectId.toString(),
       },
       select: {
         _id: true,
         projectId: true,
-        showEpisodeHistoryInDays: true,
-        showEpisodesOnStatusPage: true,
+        isPublicStatusPage: true,
+        overviewPageDescription: true,
+        showIncidentLabelsOnStatusPage: true,
+        showScheduledEventLabelsOnStatusPage: true,
         showEpisodeLabelsOnStatusPage: true,
+        downtimeMonitorStatuses: {
+          _id: true,
+        },
+        defaultBarColor: true,
+        showOverallUptimePercentOnStatusPage: true,
+        overallUptimePercentPrecision: true,
+        showAnnouncementsOnStatusPage: true,
+        showIncidentsOnStatusPage: true,
+        showEpisodesOnStatusPage: true,
+        showScheduledMaintenanceEventsOnStatusPage: true,
+        showUptimeHistoryInDays: true,
       },
       props: {
         isRoot: true,
@@ -4459,51 +4166,42 @@ export default class StatusPageAPI extends BaseAPI<
       throw new BadDataException("Status Page not found");
     }
 
-    if (!statusPage.showEpisodesOnStatusPage) {
-      throw new BadDataException(
-        "Episodes are not enabled on this status page.",
-      );
-    }
-
-    // get monitors on status page.
-    const statusPageResources: Array<StatusPageResource> =
-      await StatusPageService.getStatusPageResources({
-        statusPageId: statusPageId,
-      });
+    let startDateForMonitorTimeline: Date | undefined =
+      data.startDateForMonitorTimeline;
+    let endDateForMonitorTimeline: Date | undefined =
+      data.endDateForMonitorTimeline;
 
-    const { monitorsOnStatusPage, monitorsInGroup } =
-      await StatusPageService.getMonitorIdsOnStatusPage({
-        statusPageId: statusPageId,
-        // reuse the resources fetched above instead of re-querying them
-        statusPageResources: statusPageResources,
-      });
+    if (!startDateForMonitorTimeline || !endDateForMonitorTimeline) {
+      let uptimeHistoryDays: number = statusPage.showUptimeHistoryInDays || 90;
 
-    const today: Date = OneUptimeDate.getCurrentDate();
+      if (uptimeHistoryDays > 90) {
+        uptimeHistoryDays = 90;
+      }
 
-    const historyDays: Date = OneUptimeDate.getSomeDaysAgo(
-      statusPage.showEpisodeHistoryInDays || 14,
-    );
+      if (uptimeHistoryDays < 1) {
+        uptimeHistoryDays = 1;
+      }
 
-    /*
-     * Get incidents that have monitors on this status page
-     * Note: We don't filter by incident.isVisibleOnStatusPage here because
-     * episode visibility is independent of incident visibility.
-     * An episode should show if episode.isVisibleOnStatusPage is true,
-     * regardless of whether its member incidents are visible.
-     */
-    const incidentQuery: Query<Incident> = {
-      monitors: monitorsOnStatusPage as any,
-      projectId: statusPage.projectId!,
-      createdAt: QueryHelper.inBetween(historyDays, today),
-    };
+      startDateForMonitorTimeline =
+        OneUptimeDate.getSomeDaysAgo(uptimeHistoryDays);
+      endDateForMonitorTimeline = OneUptimeDate.getCurrentDate();
+    }
 
-    let incidents: Array<Incident> = [];
+    //get monitor statuses
 
-    if (monitorsOnStatusPage.length > 0) {
-      incidents = await IncidentService.findBy({
-        query: incidentQuery,
+    const monitorStatuses: Array<MonitorStatus> =
+      await MonitorStatusService.findBy({
+        query: {
+          projectId: statusPage.projectId!,
+        },
         select: {
-          _id: true,
+          name: true,
+          color: true,
+          priority: true,
+          isOperationalState: true,
+        },
+        sort: {
+          priority: SortOrder.Ascending,
         },
         skip: 0,
         limit: LIMIT_PER_PROJECT,
@@ -4511,24 +4209,71 @@ export default class StatusPageAPI extends BaseAPI<
           isRoot: true,
         },
       });
-    }
 
-    const incidentIds: Array<ObjectID> = incidents.map((incident: Incident) => {
-      return incident.id!;
-    });
+    // get resource groups.
 
-    // Get episode members that link to these incidents
-    let episodeMembers: Array<IncidentEpisodeMember> = [];
+    const groups: Array<StatusPageGroup> = await StatusPageGroupService.findBy({
+      query: {
+        statusPageId: objectId,
+      },
+      select: {
+        name: true,
+        order: true,
+        description: true,
+        isExpandedByDefault: true,
+        showCurrentStatus: true,
+        showUptimePercent: true,
+        uptimePercentPrecision: true,
+        viewMode: true,
+        rowAxisLabel: true,
+        columnAxisLabel: true,
+        rowAxisValues: true,
+        columnAxisValues: true,
+        parentStatusPageGroupId: true,
+      },
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      skip: 0,
+      limit: LIMIT_PER_PROJECT,
+      props: {
+        isRoot: true,
+      },
+    });
 
-    if (incidentIds.length > 0) {
-      episodeMembers = await IncidentEpisodeMemberService.findBy({
+    // get monitors on status page.
+    const statusPageResources: Array<StatusPageResource> =
+      await StatusPageResourceService.findBy({
         query: {
-          incidentId: QueryHelper.any(incidentIds),
-          projectId: statusPage.projectId!,
+          statusPageId: objectId,
         },
         select: {
-          incidentEpisodeId: true,
-          incidentId: true,
+          statusPageGroupId: true,
+          statusPageGroup: {
+            name: true,
+            viewMode: true,
+            rowAxisLabel: true,
+            columnAxisLabel: true,
+          },
+          monitorId: true,
+          displayTooltip: true,
+          displayDescription: true,
+          displayName: true,
+          showStatusHistoryChart: true,
+          showCurrentStatus: true,
+          order: true,
+          monitor: {
+            _id: true,
+            currentMonitorStatusId: true,
+          },
+          monitorGroupId: true,
+          showUptimePercent: true,
+          uptimePercentPrecision: true,
+          rowAxisValue: true,
+          columnAxisValue: true,
+        },
+        sort: {
+          order: SortOrder.Ascending,
         },
         skip: 0,
         limit: LIMIT_PER_PROJECT,
@@ -4536,122 +4281,218 @@ export default class StatusPageAPI extends BaseAPI<
           isRoot: true,
         },
       });
-    }
 
-    // Get unique episode IDs
-    const episodeIdsFromMembers: Set<string> = new Set();
-    for (const member of episodeMembers) {
-      if (member.incidentEpisodeId) {
-        episodeIdsFromMembers.add(member.incidentEpisodeId.toString());
+    const monitorGroupIds: Array<ObjectID> = statusPageResources
+      .map((resource: StatusPageResource) => {
+        return resource.monitorGroupId!;
+      })
+      .filter((id: ObjectID) => {
+        return Boolean(id); // remove nulls
+      });
+
+    // get monitors in the group.
+    const monitorGroupCurrentStatuses: Dictionary<ObjectID> = {};
+    const monitorsInGroup: Dictionary<Array<ObjectID>> = {};
+
+    // get monitor status charts.
+    const monitorsOnStatusPage: Array<ObjectID> = statusPageResources
+      .map((monitor: StatusPageResource) => {
+        return monitor.monitorId!;
+      })
+      .filter((id: ObjectID) => {
+        return Boolean(id); // remove nulls
+      });
+
+    const monitorsOnStatusPageForTimeline: Array<ObjectID> = statusPageResources
+      .filter((monitor: StatusPageResource) => {
+        return monitor.showStatusHistoryChart || monitor.showUptimePercent;
+      })
+      .map((monitor: StatusPageResource) => {
+        return monitor.monitorId!;
+      })
+      .filter((id: ObjectID) => {
+        return Boolean(id); // remove nulls
+      });
+
+    /*
+     * Batched: this loop used to issue 4 queries per monitor group per page
+     * view (3 inside MonitorGroupService.getCurrentStatus + one duplicate
+     * group-resource fetch), on the hottest public endpoint in the product.
+     * One shared fetch + the already-loaded `monitorStatuses` now serve every
+     * group.
+     */
+    const monitorGroupResourcesByGroupId: Dictionary<
+      Array<MonitorGroupResource>
+    > =
+      await MonitorGroupService.getMonitorGroupResourcesByGroupIds(
+        monitorGroupIds,
+      );
+
+    const monitorGroupStatuses: Dictionary<MonitorStatus> =
+      await MonitorGroupService.getCurrentStatusesForMonitorGroups({
+        monitorGroupIds: monitorGroupIds,
+        monitorStatuses: monitorStatuses,
+        monitorGroupResources: monitorGroupResourcesByGroupId,
+      });
+
+    for (const monitorGroupId of monitorGroupIds) {
+      // get current status of monitors in the group.
+
+      const currentStatus: MonitorStatus | undefined =
+        monitorGroupStatuses[monitorGroupId.toString()];
+
+      if (currentStatus) {
+        monitorGroupCurrentStatuses[monitorGroupId.toString()] =
+          currentStatus.id!;
       }
-    }
 
-    let episodeQuery: Query<IncidentEpisode> = {
-      _id: QueryHelper.any(
-        Array.from(episodeIdsFromMembers).map((id: string) => {
-          return new ObjectID(id);
+      // get monitors in the group.
+
+      const monitorsInGroupIds: Array<ObjectID> = (
+        monitorGroupResourcesByGroupId[monitorGroupId.toString()] || []
+      )
+        .map((resource: MonitorGroupResource) => {
+          return resource.monitorId!;
+        })
+        .filter((id: ObjectID) => {
+          return Boolean(id); // remove nulls
+        });
+
+      const shouldShowTimelineForThisGroup: boolean = Boolean(
+        statusPageResources.find((resource: StatusPageResource) => {
+          return (
+            resource.monitorGroupId?.toString() === monitorGroupId.toString() &&
+            (resource.showStatusHistoryChart || resource.showUptimePercent)
+          );
         }),
-      ),
-      projectId: statusPage.projectId!,
-      isVisibleOnStatusPage: true,
-    };
+      );
 
-    if (episodeId) {
-      episodeQuery = {
-        _id: episodeId.toString(),
-        projectId: statusPage.projectId!,
-        isVisibleOnStatusPage: true,
-      };
+      for (const monitorId of monitorsInGroupIds) {
+        if (!monitorId) {
+          continue;
+        }
 
-      // When viewing a specific episode, also fetch its members directly
-      const episodeMembersForSpecificEpisode: Array<IncidentEpisodeMember> =
-        await IncidentEpisodeMemberService.findBy({
-          query: {
-            incidentEpisodeId: episodeId,
-            projectId: statusPage.projectId!,
-          },
-          select: {
-            incidentEpisodeId: true,
-            incidentId: true,
-          },
-          skip: 0,
-          limit: LIMIT_PER_PROJECT,
-          props: {
-            isRoot: true,
-          },
-        });
+        if (
+          !monitorsOnStatusPage.find((item: ObjectID) => {
+            return item.toString() === monitorId.toString();
+          })
+        ) {
+          monitorsOnStatusPage.push(monitorId);
+        }
+
+        // add this to the timeline event for this group.
 
-      // Merge with existing episode members
-      for (const member of episodeMembersForSpecificEpisode) {
         if (
-          !episodeMembers.some((m: IncidentEpisodeMember) => {
-            return (
-              m.incidentEpisodeId?.toString() ===
-                member.incidentEpisodeId?.toString() &&
-              m.incidentId?.toString() === member.incidentId?.toString()
-            );
+          shouldShowTimelineForThisGroup &&
+          !monitorsOnStatusPageForTimeline.find((item: ObjectID) => {
+            return item.toString() === monitorId.toString();
           })
         ) {
-          episodeMembers.push(member);
+          monitorsOnStatusPageForTimeline.push(monitorId);
         }
       }
+
+      monitorsInGroup[monitorGroupId.toString()] = monitorsInGroupIds;
     }
 
-    // Get episodes
-    let episodes: Array<IncidentEpisode> = [];
+    const monitorStatusTimelines: Array<MonitorStatusTimeline> =
+      await StatusPageService.getMonitorStatusTimelineForStatusPage({
+        monitorIds: monitorsOnStatusPageForTimeline,
+        startDate: startDateForMonitorTimeline,
+        endDate: endDateForMonitorTimeline,
+      });
 
-    let selectEpisodes: Select<IncidentEpisode> = {
-      createdAt: true,
-      declaredAt: true,
-      updatedAt: true,
-      title: true,
-      description: true,
-      _id: true,
-      episodeNumber: true,
-      incidentSeverity: {
-        name: true,
-        color: true,
-      },
-      currentIncidentState: {
-        name: true,
-        color: true,
-        _id: true,
-        order: true,
-        isCreatedState: true,
-        isAcknowledgedState: true,
-        isResolvedState: true,
-      },
-      incidentCount: true,
+    // return everything.
+
+    return {
+      statusPageResources,
+      monitorStatuses,
+      monitorGroupCurrentStatuses,
+      statusPageGroups: groups,
+      monitorStatusTimelines,
+      statusPage,
+      monitorsOnStatusPage,
+      monitorsInGroup,
+      startDateForMonitorTimeline,
+      endDateForMonitorTimeline,
     };
+  }
 
-    if (statusPage.showEpisodeLabelsOnStatusPage) {
-      selectEpisodes = {
-        ...selectEpisodes,
-        labels: {
+  /*
+   * Builds the full overview payload for one status page. Everything below
+   * is a pure function of the statusPageId — every query runs with isRoot
+   * props and nothing is read from the request — which is what makes the
+   * result safe to cache and share across requests. The returned JSONObject
+   * must never be mutated after build.
+   */
+  @CaptureSpan()
+  public async buildOverviewResponse(
+    statusPageId: ObjectID,
+  ): Promise<JSONObject> {
+    /*
+     * The timeline window comes from the status page's configured
+     * showUptimeHistoryInDays. getStatusPageResourcesAndTimelines
+     * fetches the status page row anyway, so let it compute the window
+     * (clamped to 1..90 days, ending now) instead of issuing a separate
+     * StatusPage query here just to read that one column.
+     */
+    const {
+      monitorStatuses,
+      monitorGroupCurrentStatuses,
+      statusPageResources,
+      statusPage,
+      monitorsOnStatusPage,
+      monitorStatusTimelines,
+      statusPageGroups,
+      monitorsInGroup,
+      startDateForMonitorTimeline: startDate,
+      endDateForMonitorTimeline: endDate,
+    } = await this.getStatusPageResourcesAndTimelines({
+      statusPageId: statusPageId,
+    });
+
+    // check if status page has active incident.
+    let activeIncidents: Array<Incident> = [];
+    if (monitorsOnStatusPage.length > 0) {
+      let select: Select<Incident> = {
+        createdAt: true,
+        declaredAt: true,
+        updatedAt: true,
+        title: true,
+        description: true,
+        _id: true,
+        postmortemNote: true,
+        postmortemPostedAt: true,
+        showPostmortemOnStatusPage: true,
+        postmortemAttachments: {
+          _id: true,
+          name: true,
+        },
+        incidentSeverity: {
           name: true,
           color: true,
         },
-      };
-    }
-
-    if (episodeIdsFromMembers.size > 0 || episodeId) {
-      episodes = await IncidentEpisodeService.findBy({
-        query: episodeQuery,
-        select: selectEpisodes,
-        sort: {
-          declaredAt: SortOrder.Descending,
-          createdAt: SortOrder.Descending,
+        currentIncidentState: {
+          _id: true,
+          name: true,
+          color: true,
+          order: true,
         },
-        skip: 0,
-        limit: LIMIT_PER_PROJECT,
-        props: {
-          isRoot: true,
+        monitors: {
+          _id: true,
         },
-      });
-    }
+      };
+
+      if (statusPage.showIncidentLabelsOnStatusPage) {
+        select = {
+          ...select,
+          labels: {
+            name: true,
+            color: true,
+          },
+        };
+      }
 
-    // If no specific episode, also fetch active (unresolved) episodes
-    if (!episodeId && episodeIdsFromMembers.size > 0) {
       const unresolvedIncidentStates: Array<IncidentState> =
         await IncidentStateService.getUnresolvedIncidentStates(
           statusPage.projectId!,
@@ -4665,140 +4506,54 @@ export default class StatusPageAPI extends BaseAPI<
           return state.id!;
         });
 
-      const activeEpisodes: Array<IncidentEpisode> =
-        await IncidentEpisodeService.findBy({
+      if (statusPage.showIncidentsOnStatusPage) {
+        activeIncidents = await IncidentService.findBy({
           query: {
-            _id: QueryHelper.any(
-              Array.from(episodeIdsFromMembers).map((id: string) => {
-                return new ObjectID(id);
-              }),
-            ),
-            isVisibleOnStatusPage: true,
+            monitors: monitorsOnStatusPage as any,
             currentIncidentStateId: QueryHelper.any(unresolvedIncidentStateIds),
+            isVisibleOnStatusPage: true,
             projectId: statusPage.projectId!,
-          },
-          select: selectEpisodes,
-          sort: {
-            declaredAt: SortOrder.Descending,
-            createdAt: SortOrder.Descending,
-          },
-          skip: 0,
-          limit: LIMIT_PER_PROJECT,
-          props: {
-            isRoot: true,
-          },
-        });
-
-      episodes = [...activeEpisodes, ...episodes];
-      episodes = ArrayUtil.distinctByFieldName(episodes, "_id");
-    }
-
-    const episodesOnStatusPage: Array<ObjectID> = episodes.map(
-      (episode: IncidentEpisode) => {
-        return episode.id!;
-      },
-    );
-
-    /*
-     * Build a map of episode ID -> monitor IDs from episode members
-     * Collect all unique incident IDs from episode members
-     */
-    const memberIncidentIds: Array<ObjectID> = [];
-    for (const member of episodeMembers) {
-      if (
-        member.incidentId &&
-        !memberIncidentIds.some((id: ObjectID) => {
-          return id.toString() === member.incidentId!.toString();
-        })
-      ) {
-        memberIncidentIds.push(member.incidentId);
-      }
-    }
-
-    // Fetch incidents with their monitors
-    let memberIncidents: Array<Incident> = [];
-    if (memberIncidentIds.length > 0) {
-      memberIncidents = await IncidentService.findBy({
-        query: {
-          _id: QueryHelper.any(memberIncidentIds),
-          projectId: statusPage.projectId!,
-        },
-        select: {
-          _id: true,
-          monitors: {
-            _id: true,
-          },
-        },
-        skip: 0,
-        limit: LIMIT_PER_PROJECT,
-        props: {
-          isRoot: true,
-        },
-      });
-    }
-
-    // Build a map of incident ID -> monitors
-    const incidentMonitorsMap: Map<string, Array<ObjectID>> = new Map();
-    for (const incident of memberIncidents) {
-      const incidentIdStr: string = incident.id!.toString();
-      const monitorIds: Array<ObjectID> = (incident.monitors || [])
-        .map((m: Monitor) => {
-          return new ObjectID(m._id?.toString() || m.id?.toString() || "");
-        })
-        .filter((id: ObjectID) => {
-          return id.toString() !== "";
-        });
-      incidentMonitorsMap.set(incidentIdStr, monitorIds);
-    }
-
-    // Build episode monitors map from members and incident monitors
-    const episodeMonitorsMap: Map<string, Array<ObjectID>> = new Map();
-    for (const member of episodeMembers) {
-      if (member.incidentEpisodeId && member.incidentId) {
-        const episodeIdStr: string = member.incidentEpisodeId.toString();
-        const incidentIdStr: string = member.incidentId.toString();
-
-        if (!episodeMonitorsMap.has(episodeIdStr)) {
-          episodeMonitorsMap.set(episodeIdStr, []);
-        }
-
-        const episodeMonitors: Array<ObjectID> =
-          episodeMonitorsMap.get(episodeIdStr)!;
-        const incidentMonitors: Array<ObjectID> =
-          incidentMonitorsMap.get(incidentIdStr) || [];
+          },
+          select: select,
+          sort: {
+            declaredAt: SortOrder.Descending,
+            createdAt: SortOrder.Descending,
+          },
 
-        for (const monitorId of incidentMonitors) {
-          if (
-            !episodeMonitors.some((m: ObjectID) => {
-              return m.toString() === monitorId.toString();
-            })
-          ) {
-            episodeMonitors.push(monitorId);
-          }
-        }
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
       }
     }
 
-    // Get public notes for episodes
-    let episodePublicNotes: Array<IncidentEpisodePublicNote> = [];
+    const incidentsOnStatusPage: Array<ObjectID> = activeIncidents.map(
+      (incident: Incident) => {
+        return incident.id!;
+      },
+    );
 
-    if (episodesOnStatusPage.length > 0) {
-      episodePublicNotes = await IncidentEpisodePublicNoteService.findBy({
+    let incidentPublicNotes: Array<IncidentPublicNote> = [];
+
+    if (incidentsOnStatusPage.length > 0) {
+      incidentPublicNotes = await IncidentPublicNoteService.findBy({
         query: {
-          incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
+          incidentId: QueryHelper.any(incidentsOnStatusPage),
           projectId: statusPage.projectId!,
         },
         select: {
-          postedAt: true,
           note: true,
-          incidentEpisodeId: true,
+          incidentId: true,
+          postedAt: true,
           attachments: {
             _id: true,
             name: true,
           },
         },
         sort: {
-          postedAt: SortOrder.Descending,
+          postedAt: SortOrder.Descending, // new note first
         },
         skip: 0,
         limit: LIMIT_PER_PROJECT,
@@ -4808,30 +4563,402 @@ export default class StatusPageAPI extends BaseAPI<
       });
     }
 
-    // Get state timelines for episodes
-    let episodeStateTimelines: Array<IncidentEpisodeStateTimeline> = [];
+    let incidentStateTimelines: Array<IncidentStateTimeline> = [];
 
-    if (episodesOnStatusPage.length > 0) {
-      episodeStateTimelines = await IncidentEpisodeStateTimelineService.findBy({
+    if (incidentsOnStatusPage.length > 0) {
+      incidentStateTimelines = await IncidentStateTimelineService.findBy({
         query: {
-          incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
+          incidentId: QueryHelper.any(incidentsOnStatusPage),
           projectId: statusPage.projectId!,
         },
         select: {
           _id: true,
           createdAt: true,
           startsAt: true,
-          incidentEpisodeId: true,
+          incidentId: true,
           incidentState: {
+            _id: true,
+            name: true,
+            color: true,
+            isCreatedState: true,
+            isResolvedState: true,
+            isAcknowledgedState: true,
+          },
+        },
+
+        sort: {
+          startsAt: SortOrder.Descending, // newer state changes first
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    // Fetch active episodes (similar to incidents)
+    let activeEpisodes: Array<IncidentEpisode> = [];
+    let activeEpisodesJson: JSONArray = [];
+    let episodePublicNotes: Array<IncidentEpisodePublicNote> = [];
+    let episodeStateTimelines: Array<IncidentEpisodeStateTimeline> = [];
+
+    /*
+     * Cheap guard before the expensive part: the block below scans every
+     * incident ever attached to this page's monitors (a many-to-many
+     * join, up to LIMIT_PER_PROJECT rows) just to discover episode
+     * membership — on every overview view, even though most pages have
+     * zero active episodes most of the time. One indexed COUNT of the
+     * project's unresolved, visible episodes lets us skip all of it in
+     * the common case. Behavior-preserving: the final activeEpisodes
+     * query applies exactly these three constraints, so count == 0
+     * implies the block's outputs stay empty.
+     */
+    let unresolvedIncidentStateIds: Array<ObjectID> = [];
+    let hasActiveEpisodes: boolean = false;
+
+    if (
+      statusPage.showEpisodesOnStatusPage &&
+      monitorsOnStatusPage.length > 0
+    ) {
+      const unresolvedIncidentStates: Array<IncidentState> =
+        await IncidentStateService.getUnresolvedIncidentStates(
+          statusPage.projectId!,
+          { isRoot: true },
+        );
+
+      unresolvedIncidentStateIds = unresolvedIncidentStates.map(
+        (state: IncidentState) => {
+          return state.id!;
+        },
+      );
+
+      const activeEpisodeCount: PositiveNumber =
+        await IncidentEpisodeService.countBy({
+          query: {
+            projectId: statusPage.projectId!,
+            isVisibleOnStatusPage: true,
+            currentIncidentStateId: QueryHelper.any(unresolvedIncidentStateIds),
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      hasActiveEpisodes = activeEpisodeCount.toNumber() > 0;
+    }
+
+    if (hasActiveEpisodes) {
+      // First, get incidents that have monitors on status page
+      const incidentsForEpisodes: Array<Incident> =
+        await IncidentService.findBy({
+          query: {
+            monitors: monitorsOnStatusPage as any,
+            isVisibleOnStatusPage: true,
+            projectId: statusPage.projectId!,
+          },
+          select: {
+            _id: true,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+
+      const incidentIdsForEpisodes: Array<ObjectID> = incidentsForEpisodes.map(
+        (incident: Incident) => {
+          return incident.id!;
+        },
+      );
+
+      // Get episode members for these incidents
+      let episodeMembers: Array<IncidentEpisodeMember> = [];
+      if (incidentIdsForEpisodes.length > 0) {
+        episodeMembers = await IncidentEpisodeMemberService.findBy({
+          query: {
+            incidentId: QueryHelper.any(incidentIdsForEpisodes),
+            projectId: statusPage.projectId!,
+          },
+          select: {
+            incidentEpisodeId: true,
+            incidentId: true,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+
+      // Get unique episode IDs
+      const episodeIdsFromMembers: Set<string> = new Set();
+      for (const member of episodeMembers) {
+        if (member.incidentEpisodeId) {
+          episodeIdsFromMembers.add(member.incidentEpisodeId.toString());
+        }
+      }
+
+      // Fetch active (unresolved) episodes
+      if (episodeIdsFromMembers.size > 0) {
+        // unresolvedIncidentStateIds was fetched by the guard above.
+        let selectEpisodes: Select<IncidentEpisode> = {
+          createdAt: true,
+          declaredAt: true,
+          updatedAt: true,
+          title: true,
+          description: true,
+          _id: true,
+          episodeNumber: true,
+          incidentSeverity: {
             name: true,
             color: true,
+          },
+          currentIncidentState: {
+            name: true,
+            color: true,
+            _id: true,
+            order: true,
             isCreatedState: true,
             isAcknowledgedState: true,
             isResolvedState: true,
           },
+          incidentCount: true,
+        };
+
+        if (statusPage.showEpisodeLabelsOnStatusPage) {
+          selectEpisodes = {
+            ...selectEpisodes,
+            labels: {
+              name: true,
+              color: true,
+            },
+          };
+        }
+
+        activeEpisodes = await IncidentEpisodeService.findBy({
+          query: {
+            _id: QueryHelper.any(
+              Array.from(episodeIdsFromMembers).map((id: string) => {
+                return new ObjectID(id);
+              }),
+            ),
+            currentIncidentStateId: QueryHelper.any(unresolvedIncidentStateIds),
+            isVisibleOnStatusPage: true,
+            projectId: statusPage.projectId!,
+          },
+          select: selectEpisodes,
+          sort: {
+            declaredAt: SortOrder.Descending,
+            createdAt: SortOrder.Descending,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+
+        // Build episode monitors map
+        if (activeEpisodes.length > 0) {
+          // Collect all incident IDs from episode members for active episodes
+          const activeEpisodeIds: Set<string> = new Set(
+            activeEpisodes.map((e: IncidentEpisode) => {
+              return e.id!.toString();
+            }),
+          );
+
+          const memberIncidentIds: Array<ObjectID> = [];
+          for (const member of episodeMembers) {
+            if (
+              member.incidentEpisodeId &&
+              activeEpisodeIds.has(member.incidentEpisodeId.toString()) &&
+              member.incidentId &&
+              !memberIncidentIds.some((id: ObjectID) => {
+                return id.toString() === member.incidentId!.toString();
+              })
+            ) {
+              memberIncidentIds.push(member.incidentId);
+            }
+          }
+
+          // Fetch incidents with monitors
+          let memberIncidents: Array<Incident> = [];
+          if (memberIncidentIds.length > 0) {
+            memberIncidents = await IncidentService.findBy({
+              query: {
+                _id: QueryHelper.any(memberIncidentIds),
+                isVisibleOnStatusPage: true,
+                projectId: statusPage.projectId!,
+              },
+              select: {
+                _id: true,
+                monitors: {
+                  _id: true,
+                },
+              },
+              skip: 0,
+              limit: LIMIT_PER_PROJECT,
+              props: {
+                isRoot: true,
+              },
+            });
+          }
+
+          // Build incident -> monitors map
+          const incidentMonitorsMap: Map<string, Array<ObjectID>> = new Map();
+          for (const incident of memberIncidents) {
+            const incidentIdStr: string = incident.id!.toString();
+            const monitorIds: Array<ObjectID> = (incident.monitors || [])
+              .map((m: Monitor) => {
+                return new ObjectID(
+                  m._id?.toString() || m.id?.toString() || "",
+                );
+              })
+              .filter((id: ObjectID) => {
+                return id.toString() !== "";
+              });
+            incidentMonitorsMap.set(incidentIdStr, monitorIds);
+          }
+
+          // Build episode -> monitors map
+          const episodeMonitorsMap: Map<string, Array<ObjectID>> = new Map();
+          for (const member of episodeMembers) {
+            if (
+              member.incidentEpisodeId &&
+              member.incidentId &&
+              activeEpisodeIds.has(member.incidentEpisodeId.toString())
+            ) {
+              const episodeIdStr: string = member.incidentEpisodeId.toString();
+              const incidentIdStr: string = member.incidentId.toString();
+
+              if (!episodeMonitorsMap.has(episodeIdStr)) {
+                episodeMonitorsMap.set(episodeIdStr, []);
+              }
+
+              const episodeMonitors: Array<ObjectID> =
+                episodeMonitorsMap.get(episodeIdStr)!;
+              const incidentMonitors: Array<ObjectID> =
+                incidentMonitorsMap.get(incidentIdStr) || [];
+
+              for (const monitorId of incidentMonitors) {
+                if (
+                  !episodeMonitors.some((m: ObjectID) => {
+                    return m.toString() === monitorId.toString();
+                  })
+                ) {
+                  episodeMonitors.push(monitorId);
+                }
+              }
+            }
+          }
+
+          // Serialize episodes and add monitors
+          activeEpisodesJson = BaseModel.toJSONArray(
+            activeEpisodes,
+            IncidentEpisode,
+          );
+          for (const episodeJson of activeEpisodesJson) {
+            const episodeObj: JSONObject = episodeJson as JSONObject;
+            const episodeId: string | undefined = episodeObj["_id"]?.toString();
+            if (episodeId) {
+              const monitorIds: Array<ObjectID> =
+                episodeMonitorsMap.get(episodeId) || [];
+              episodeObj["monitors"] = monitorIds.map((id: ObjectID) => {
+                return { _id: id.toString() };
+              });
+            }
+          }
+
+          // Get episode public notes
+          const episodesOnStatusPage: Array<ObjectID> = activeEpisodes.map(
+            (episode: IncidentEpisode) => {
+              return episode.id!;
+            },
+          );
+
+          if (episodesOnStatusPage.length > 0) {
+            episodePublicNotes = await IncidentEpisodePublicNoteService.findBy({
+              query: {
+                incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
+                projectId: statusPage.projectId!,
+              },
+              select: {
+                postedAt: true,
+                note: true,
+                incidentEpisodeId: true,
+                attachments: {
+                  _id: true,
+                  name: true,
+                },
+              },
+              sort: {
+                postedAt: SortOrder.Descending,
+              },
+              skip: 0,
+              limit: LIMIT_PER_PROJECT,
+              props: {
+                isRoot: true,
+              },
+            });
+
+            // Get episode state timelines
+            episodeStateTimelines =
+              await IncidentEpisodeStateTimelineService.findBy({
+                query: {
+                  incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
+                  projectId: statusPage.projectId!,
+                },
+                select: {
+                  _id: true,
+                  createdAt: true,
+                  startsAt: true,
+                  incidentEpisodeId: true,
+                  incidentState: {
+                    name: true,
+                    color: true,
+                    isCreatedState: true,
+                    isAcknowledgedState: true,
+                    isResolvedState: true,
+                  },
+                },
+                sort: {
+                  startsAt: SortOrder.Descending,
+                },
+                skip: 0,
+                limit: LIMIT_PER_PROJECT,
+                props: {
+                  isRoot: true,
+                },
+              });
+          }
+        }
+      }
+    }
+
+    // check if status page has active announcement.
+
+    const today: Date = OneUptimeDate.getCurrentDate();
+
+    let activeAnnouncements: Array<StatusPageAnnouncement> = [];
+
+    if (statusPage.showAnnouncementsOnStatusPage) {
+      activeAnnouncements = await StatusPageAnnouncementService.findBy({
+        query: {
+          statusPages: statusPageId as any,
+          showAnnouncementAt: QueryHelper.lessThan(today),
+          endAnnouncementAt: QueryHelper.greaterThanOrNull(today),
+          projectId: statusPage.projectId!,
         },
-        sort: {
-          startsAt: SortOrder.Descending,
+        select: {
+          createdAt: true,
+          title: true,
+          description: true,
+          _id: true,
+          showAnnouncementAt: true,
+          endAnnouncementAt: true,
         },
         skip: 0,
         limit: LIMIT_PER_PROJECT,
@@ -4841,156 +4968,180 @@ export default class StatusPageAPI extends BaseAPI<
       });
     }
 
-    // Get all incident states for this project
-    const incidentStates: Array<IncidentState> =
-      await IncidentStateService.findBy({
+    // check if status page has active scheduled events.
+
+    let scheduledEventsSelect: Select<ScheduledMaintenance> = {
+      createdAt: true,
+      title: true,
+      description: true,
+      _id: true,
+      endsAt: true,
+      startsAt: true,
+      currentScheduledMaintenanceState: {
+        name: true,
+        color: true,
+        isScheduledState: true,
+        isResolvedState: true,
+        isOngoingState: true,
+      },
+      monitors: {
+        _id: true,
+      },
+    };
+
+    if (statusPage.showScheduledEventLabelsOnStatusPage) {
+      scheduledEventsSelect = {
+        ...scheduledEventsSelect,
+        labels: {
+          name: true,
+          color: true,
+        },
+      };
+    }
+
+    let scheduledMaintenanceEvents: Array<ScheduledMaintenance> = [];
+
+    if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
+      scheduledMaintenanceEvents = await ScheduledMaintenanceService.findBy({
         query: {
+          currentScheduledMaintenanceState: {
+            isOngoingState: true,
+          } as any,
+          statusPages: statusPageId as any,
           projectId: statusPage.projectId!,
+          isVisibleOnStatusPage: true,
         },
-        select: {
-          isResolvedState: true,
-          order: true,
+        select: scheduledEventsSelect,
+        sort: {
+          startsAt: SortOrder.Ascending,
         },
-        limit: LIMIT_PER_PROJECT,
         skip: 0,
+        limit: LIMIT_PER_PROJECT,
         props: {
           isRoot: true,
         },
       });
-
-    // Serialize episodes and add monitors to each
-    const episodesJson: JSONArray = BaseModel.toJSONArray(
-      episodes,
-      IncidentEpisode,
-    );
-    for (const episodeJson of episodesJson) {
-      const episodeObj: JSONObject = episodeJson as JSONObject;
-      const episodeId: string | undefined = episodeObj["_id"]?.toString();
-      if (episodeId) {
-        const monitorIds: Array<ObjectID> =
-          episodeMonitorsMap.get(episodeId) || [];
-        episodeObj["monitors"] = monitorIds.map((id: ObjectID) => {
-          return { _id: id.toString() };
-        });
-      }
     }
 
-    const response: JSONObject = {
-      episodePublicNotes: BaseModel.toJSONArray(
-        episodePublicNotes,
-        IncidentEpisodePublicNote,
-      ),
-      incidentStates: BaseModel.toJSONArray(incidentStates, IncidentState),
-      episodes: episodesJson,
-      statusPageResources: BaseModel.toJSONArray(
-        statusPageResources,
-        StatusPageResource,
-      ),
-      episodeStateTimelines: BaseModel.toJSONArray(
-        episodeStateTimelines,
-        IncidentEpisodeStateTimeline,
-      ),
-      monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
-    };
-
-    return response;
-  }
+    let futureScheduledMaintenanceEvents: Array<ScheduledMaintenance> = [];
 
-  @CaptureSpan()
-  public async getStatusPageResourcesAndTimelines(data: {
-    statusPageId: ObjectID;
-    /*
-     * When omitted, the timeline window is computed from the status page's
-     * own showUptimeHistoryInDays (clamped to 1..90 days, ending now) —
-     * the status page row is fetched below anyway, so callers that want the
-     * page-configured window (the overview endpoint) don't need their own
-     * StatusPage query just to read that column.
-     */
-    startDateForMonitorTimeline?: Date | undefined;
-    endDateForMonitorTimeline?: Date | undefined;
-  }): Promise<{
-    statusPageResources: StatusPageResource[];
-    monitorStatuses: MonitorStatus[];
-    monitorStatusTimelines: MonitorStatusTimeline[];
-    monitorGroupCurrentStatuses: Dictionary<ObjectID>;
-    statusPageGroups: StatusPageGroup[];
-    statusPage: StatusPage;
-    monitorsOnStatusPage: ObjectID[];
-    monitorsInGroup: Dictionary<ObjectID[]>;
-    startDateForMonitorTimeline: Date;
-    endDateForMonitorTimeline: Date;
-  }> {
-    const objectId: ObjectID = data.statusPageId;
+    if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
+      futureScheduledMaintenanceEvents =
+        await ScheduledMaintenanceService.findBy({
+          query: {
+            currentScheduledMaintenanceState: {
+              isScheduledState: true,
+            } as any,
+            statusPages: statusPageId as any,
+            projectId: statusPage.projectId!,
+            isVisibleOnStatusPage: true,
+          },
+          select: scheduledEventsSelect,
+          sort: {
+            startsAt: SortOrder.Ascending,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+    }
 
-    const statusPage: StatusPage | null = await StatusPageService.findOneBy({
-      query: {
-        _id: objectId.toString(),
-      },
-      select: {
-        _id: true,
-        projectId: true,
-        isPublicStatusPage: true,
-        overviewPageDescription: true,
-        showIncidentLabelsOnStatusPage: true,
-        showScheduledEventLabelsOnStatusPage: true,
-        showEpisodeLabelsOnStatusPage: true,
-        downtimeMonitorStatuses: {
-          _id: true,
-        },
-        defaultBarColor: true,
-        showOverallUptimePercentOnStatusPage: true,
-        overallUptimePercentPrecision: true,
-        showAnnouncementsOnStatusPage: true,
-        showIncidentsOnStatusPage: true,
-        showEpisodesOnStatusPage: true,
-        showScheduledMaintenanceEventsOnStatusPage: true,
-        showUptimeHistoryInDays: true,
-      },
-      props: {
-        isRoot: true,
-      },
+    futureScheduledMaintenanceEvents.forEach((event: ScheduledMaintenance) => {
+      scheduledMaintenanceEvents.push(event);
     });
 
-    if (!statusPage) {
-      throw new BadDataException("Status Page not found");
-    }
+    const scheduledMaintenanceEventsOnStatusPage: Array<ObjectID> =
+      scheduledMaintenanceEvents.map((event: ScheduledMaintenance) => {
+        return event.id!;
+      });
 
-    let startDateForMonitorTimeline: Date | undefined =
-      data.startDateForMonitorTimeline;
-    let endDateForMonitorTimeline: Date | undefined =
-      data.endDateForMonitorTimeline;
+    let scheduledMaintenanceEventsPublicNotes: Array<ScheduledMaintenancePublicNote> =
+      [];
 
-    if (!startDateForMonitorTimeline || !endDateForMonitorTimeline) {
-      let uptimeHistoryDays: number = statusPage.showUptimeHistoryInDays || 90;
+    if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
+      scheduledMaintenanceEventsPublicNotes =
+        await ScheduledMaintenancePublicNoteService.findBy({
+          query: {
+            scheduledMaintenanceId: QueryHelper.any(
+              scheduledMaintenanceEventsOnStatusPage,
+            ),
+            projectId: statusPage.projectId!,
+          },
+          select: {
+            postedAt: true,
+            note: true,
+            scheduledMaintenanceId: true,
+            attachments: {
+              _id: true,
+              name: true,
+            },
+          },
+          sort: {
+            postedAt: SortOrder.Ascending,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+    }
 
-      if (uptimeHistoryDays > 90) {
-        uptimeHistoryDays = 90;
-      }
+    let scheduledMaintenanceStateTimelines: Array<ScheduledMaintenanceStateTimeline> =
+      [];
 
-      if (uptimeHistoryDays < 1) {
-        uptimeHistoryDays = 1;
-      }
+    if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
+      scheduledMaintenanceStateTimelines =
+        await ScheduledMaintenanceStateTimelineService.findBy({
+          query: {
+            scheduledMaintenanceId: QueryHelper.any(
+              scheduledMaintenanceEventsOnStatusPage,
+            ),
+            projectId: statusPage.projectId!,
+          },
+          select: {
+            _id: true,
+            createdAt: true,
+            startsAt: true,
+            scheduledMaintenanceId: true,
+            scheduledMaintenanceState: {
+              _id: true,
+              color: true,
+              name: true,
+              isScheduledState: true,
+              isResolvedState: true,
+              isOngoingState: true,
+            },
+          },
 
-      startDateForMonitorTimeline =
-        OneUptimeDate.getSomeDaysAgo(uptimeHistoryDays);
-      endDateForMonitorTimeline = OneUptimeDate.getCurrentDate();
+          sort: {
+            startsAt: SortOrder.Descending, // newer state changes first
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
     }
 
-    //get monitor statuses
-
-    const monitorStatuses: Array<MonitorStatus> =
-      await MonitorStatusService.findBy({
+    // get all status page bar chart rules
+    const statusPageHistoryChartBarColorRules: Array<StatusPageHistoryChartBarColorRule> =
+      await StatusPageHistoryChartBarColorRuleService.findBy({
         query: {
-          projectId: statusPage.projectId!,
+          statusPageId: statusPageId,
         },
         select: {
-          name: true,
-          color: true,
-          priority: true,
-          isOperationalState: true,
+          _id: true,
+          barColor: true,
+          order: true,
+          statusPageId: true,
+          uptimePercentGreaterThanOrEqualTo: true,
         },
         sort: {
-          priority: SortOrder.Ascending,
+          order: SortOrder.Ascending,
         },
         skip: 0,
         limit: LIMIT_PER_PROJECT,
@@ -4999,70 +5150,41 @@ export default class StatusPageAPI extends BaseAPI<
         },
       });
 
-    // get resource groups.
-
-    const groups: Array<StatusPageGroup> = await StatusPageGroupService.findBy({
-      query: {
-        statusPageId: objectId,
-      },
-      select: {
-        name: true,
-        order: true,
-        description: true,
-        isExpandedByDefault: true,
-        showCurrentStatus: true,
-        showUptimePercent: true,
-        uptimePercentPrecision: true,
-        viewMode: true,
-        rowAxisLabel: true,
-        columnAxisLabel: true,
-        rowAxisValues: true,
-        columnAxisValues: true,
-        parentStatusPageGroupId: true,
-      },
-      sort: {
-        order: SortOrder.Ascending,
-      },
-      skip: 0,
-      limit: LIMIT_PER_PROJECT,
-      props: {
-        isRoot: true,
-      },
-    });
-
-    // get monitors on status page.
-    const statusPageResources: Array<StatusPageResource> =
-      await StatusPageResourceService.findBy({
+    /*
+     * Fetch all incidents (active + resolved) in the timeline date range
+     * for the uptime bar tooltip and click-through
+     */
+    let timelineIncidents: Array<Incident> = [];
+    if (
+      monitorsOnStatusPage.length > 0 &&
+      statusPage.showIncidentsOnStatusPage
+    ) {
+      timelineIncidents = await IncidentService.findBy({
         query: {
-          statusPageId: objectId,
+          monitors: monitorsOnStatusPage as any,
+          declaredAt: QueryHelper.inBetween(startDate, endDate),
+          isVisibleOnStatusPage: true,
+          projectId: statusPage.projectId!,
         },
         select: {
-          statusPageGroupId: true,
-          statusPageGroup: {
+          _id: true,
+          title: true,
+          declaredAt: true,
+          incidentSeverity: {
             name: true,
-            viewMode: true,
-            rowAxisLabel: true,
-            columnAxisLabel: true,
+            color: true,
           },
-          monitorId: true,
-          displayTooltip: true,
-          displayDescription: true,
-          displayName: true,
-          showStatusHistoryChart: true,
-          showCurrentStatus: true,
-          order: true,
-          monitor: {
+          currentIncidentState: {
+            _id: true,
+            name: true,
+            color: true,
+          },
+          monitors: {
             _id: true,
-            currentMonitorStatusId: true,
           },
-          monitorGroupId: true,
-          showUptimePercent: true,
-          uptimePercentPrecision: true,
-          rowAxisValue: true,
-          columnAxisValue: true,
         },
         sort: {
-          order: SortOrder.Ascending,
+          declaredAt: SortOrder.Descending,
         },
         skip: 0,
         limit: LIMIT_PER_PROJECT,
@@ -5070,141 +5192,88 @@ export default class StatusPageAPI extends BaseAPI<
           isRoot: true,
         },
       });
+    }
 
-    const monitorGroupIds: Array<ObjectID> = statusPageResources
-      .map((resource: StatusPageResource) => {
-        return resource.monitorGroupId!;
-      })
-      .filter((id: ObjectID) => {
-        return Boolean(id); // remove nulls
-      });
-
-    // get monitors in the group.
-    const monitorGroupCurrentStatuses: Dictionary<ObjectID> = {};
-    const monitorsInGroup: Dictionary<Array<ObjectID>> = {};
-
-    // get monitor status charts.
-    const monitorsOnStatusPage: Array<ObjectID> = statusPageResources
-      .map((monitor: StatusPageResource) => {
-        return monitor.monitorId!;
-      })
-      .filter((id: ObjectID) => {
-        return Boolean(id); // remove nulls
-      });
-
-    const monitorsOnStatusPageForTimeline: Array<ObjectID> = statusPageResources
-      .filter((monitor: StatusPageResource) => {
-        return monitor.showStatusHistoryChart || monitor.showUptimePercent;
-      })
-      .map((monitor: StatusPageResource) => {
-        return monitor.monitorId!;
-      })
-      .filter((id: ObjectID) => {
-        return Boolean(id); // remove nulls
-      });
-
-    /*
-     * Batched: this loop used to issue 4 queries per monitor group per page
-     * view (3 inside MonitorGroupService.getCurrentStatus + one duplicate
-     * group-resource fetch), on the hottest public endpoint in the product.
-     * One shared fetch + the already-loaded `monitorStatuses` now serve every
-     * group.
-     */
-    const monitorGroupResourcesByGroupId: Dictionary<
-      Array<MonitorGroupResource>
-    > =
-      await MonitorGroupService.getMonitorGroupResourcesByGroupIds(
-        monitorGroupIds,
-      );
-
-    const monitorGroupStatuses: Dictionary<MonitorStatus> =
-      await MonitorGroupService.getCurrentStatusesForMonitorGroups({
-        monitorGroupIds: monitorGroupIds,
-        monitorStatuses: monitorStatuses,
-        monitorGroupResources: monitorGroupResourcesByGroupId,
+    const overallStatus: MonitorStatus | null =
+      StatusPageService.getOverallMonitorStatus({
+        statusPageResources,
+        monitorStatuses,
+        monitorGroupCurrentStatuses,
       });
 
-    for (const monitorGroupId of monitorGroupIds) {
-      // get current status of monitors in the group.
-
-      const currentStatus: MonitorStatus | undefined =
-        monitorGroupStatuses[monitorGroupId.toString()];
-
-      if (currentStatus) {
-        monitorGroupCurrentStatuses[monitorGroupId.toString()] =
-          currentStatus.id!;
-      }
-
-      // get monitors in the group.
-
-      const monitorsInGroupIds: Array<ObjectID> = (
-        monitorGroupResourcesByGroupId[monitorGroupId.toString()] || []
-      )
-        .map((resource: MonitorGroupResource) => {
-          return resource.monitorId!;
-        })
-        .filter((id: ObjectID) => {
-          return Boolean(id); // remove nulls
-        });
-
-      const shouldShowTimelineForThisGroup: boolean = Boolean(
-        statusPageResources.find((resource: StatusPageResource) => {
-          return (
-            resource.monitorGroupId?.toString() === monitorGroupId.toString() &&
-            (resource.showStatusHistoryChart || resource.showUptimePercent)
-          );
-        }),
-      );
-
-      for (const monitorId of monitorsInGroupIds) {
-        if (!monitorId) {
-          continue;
-        }
-
-        if (
-          !monitorsOnStatusPage.find((item: ObjectID) => {
-            return item.toString() === monitorId.toString();
-          })
-        ) {
-          monitorsOnStatusPage.push(monitorId);
-        }
-
-        // add this to the timeline event for this group.
+    const response: JSONObject = {
+      overallStatus: overallStatus
+        ? BaseModel.toJSON(overallStatus, MonitorStatus)
+        : null,
 
-        if (
-          shouldShowTimelineForThisGroup &&
-          !monitorsOnStatusPageForTimeline.find((item: ObjectID) => {
-            return item.toString() === monitorId.toString();
-          })
-        ) {
-          monitorsOnStatusPageForTimeline.push(monitorId);
-        }
-      }
+      scheduledMaintenanceEventsPublicNotes: BaseModel.toJSONArray(
+        scheduledMaintenanceEventsPublicNotes,
+        ScheduledMaintenancePublicNote,
+      ),
+      statusPageHistoryChartBarColorRules: BaseModel.toJSONArray(
+        statusPageHistoryChartBarColorRules,
+        StatusPageHistoryChartBarColorRule,
+      ),
+      scheduledMaintenanceEvents: BaseModel.toJSONArray(
+        scheduledMaintenanceEvents,
+        ScheduledMaintenance,
+      ),
+      activeAnnouncements: BaseModel.toJSONArray(
+        activeAnnouncements,
+        StatusPageAnnouncement,
+      ),
+      incidentPublicNotes: BaseModel.toJSONArray(
+        incidentPublicNotes,
+        IncidentPublicNote,
+      ),
 
-      monitorsInGroup[monitorGroupId.toString()] = monitorsInGroupIds;
-    }
+      activeIncidents: BaseModel.toJSONArray(activeIncidents, Incident),
 
-    const monitorStatusTimelines: Array<MonitorStatusTimeline> =
-      await StatusPageService.getMonitorStatusTimelineForStatusPage({
-        monitorIds: monitorsOnStatusPageForTimeline,
-        startDate: startDateForMonitorTimeline,
-        endDate: endDateForMonitorTimeline,
-      });
+      activeEpisodes: activeEpisodesJson,
+      episodePublicNotes: BaseModel.toJSONArray(
+        episodePublicNotes,
+        IncidentEpisodePublicNote,
+      ),
+      episodeStateTimelines: BaseModel.toJSONArray(
+        episodeStateTimelines,
+        IncidentEpisodeStateTimeline,
+      ),
 
-    // return everything.
+      monitorStatusTimelines: BaseModel.toJSONArray(
+        monitorStatusTimelines,
+        MonitorStatusTimeline,
+      ),
+      resourceGroups: BaseModel.toJSONArray(statusPageGroups, StatusPageGroup),
+      monitorStatuses: BaseModel.toJSONArray(monitorStatuses, MonitorStatus),
+      statusPageResources: BaseModel.toJSONArray(
+        statusPageResources,
+        StatusPageResource,
+      ),
+      incidentStateTimelines: BaseModel.toJSONArray(
+        incidentStateTimelines,
+        IncidentStateTimeline,
+      ),
+      statusPage: (() => {
+        const statusPageJson: JSONObject = BaseModel.toJSONObject(
+          statusPage,
+          StatusPage,
+        );
+        delete statusPageJson["projectId"];
+        return statusPageJson;
+      })(),
+      scheduledMaintenanceStateTimelines: BaseModel.toJSONArray(
+        scheduledMaintenanceStateTimelines,
+        ScheduledMaintenanceStateTimeline,
+      ),
 
-    return {
-      statusPageResources,
-      monitorStatuses,
-      monitorGroupCurrentStatuses,
-      statusPageGroups: groups,
-      monitorStatusTimelines,
-      statusPage,
-      monitorsOnStatusPage,
-      monitorsInGroup,
-      startDateForMonitorTimeline,
-      endDateForMonitorTimeline,
+      monitorGroupCurrentStatuses: JSONFunctions.serialize(
+        monitorGroupCurrentStatuses,
+      ),
+      monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
+      timelineIncidents: BaseModel.toJSONArray(timelineIncidents, Incident),
     };
+
+    return response;
   }
 
   private async getStatusPageAnnouncementAttachment(