diff --git a/README.md b/README.md
index 45ae4ebc8aae7..6776b643722fd 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,7 @@
 - Analyze data with ready-made visualizations, or do it yourself with SQL
 - Only capture properties on the people you want to track, save money when you don't
 - Gather insights by capturing session replays, console logs, and network monitoring
-- Improve your product with A/B testing that automatically analyzes performance
+- Improve your product with Experiments that automatically analyze performance
 - Safely roll out features to select users or cohorts with feature flags
 - Send out fully customizable surveys to specific cohorts of users
 - Connect to external services and manage data flows with PostHog CDP
@@ -81,7 +81,7 @@ PostHog brings all the tools and data you need to build better products.
 - **Session replays:** [Watch videos](https://posthog.com/docs/features/session-recording) of your users' behavior, with fine-grained filters and privacy controls, as well as network monitoring and captured console logs
 - **Heatmaps:** See where users click and get a visual representation of their behaviour with the [PostHog Toolbar](https://posthog.com/docs/features/toolbar)
 - **Feature flags:** Test and manage the rollout of [new features](https://posthog.com/docs/feature-flags/installation) to specific users and groups, or deploy flags as kill-switches
-- **A/B and multivariate experimentation:** run simple or complex changes as [experiments](https://posthog.com/manual/experimentation) and get automatic significance calculations
+- **Experiments:** run simple or complex changes as [experiments](https://posthog.com/manual/experimentation) and get automatic significance calculations
 - **Correlation analysis:** Discover what events and properties [correlate](https://posthog.com/manual/correlation) with success and failure
 - **Surveys:** Collect qualitative feedback from your users using fully customizable [surveys](https://posthog.com/docs/surveys/installation)
 
diff --git a/bin/upgrade-hobby b/bin/upgrade-hobby
index 0e75aeb6352b1..2c882978618e9 100644
--- a/bin/upgrade-hobby
+++ b/bin/upgrade-hobby
@@ -11,6 +11,13 @@ else
     exit
 fi
 
+if [ "$REGISTRY_URL" == "" ]
+then
+export REGISTRY_URL="posthog/posthog"
+fi
+
+export POSTHOG_APP_TAG="${POSTHOG_APP_TAG:-latest}"
+
 echo "Checking for named postgres and clickhouse volumes to avoid data loss when upgrading from < 1.39"
 if docker volume ls | grep -Pzoq 'clickhouse-data\n(.|\n)*postgres-data\n'
 then
diff --git a/cypress/e2e/experiments.cy.ts b/cypress/e2e/experiments.cy.ts
index af8da82929a2f..5f432e1e41dc1 100644
--- a/cypress/e2e/experiments.cy.ts
+++ b/cypress/e2e/experiments.cy.ts
@@ -17,7 +17,7 @@ describe('Experiments', () => {
 
     it('create experiment', () => {
         cy.visit('/experiments')
-        cy.get('[data-attr=top-bar-name]').should('contain', 'A/B testing')
+        cy.get('[data-attr=top-bar-name]').should('contain', 'Experiments')
 
         // Name, flag key, description
         cy.get('[data-attr=create-experiment]').first().click()
diff --git a/docker-compose.hobby.yml b/docker-compose.hobby.yml
index d268e570a3ca9..0b00d510ad754 100644
--- a/docker-compose.hobby.yml
+++ b/docker-compose.hobby.yml
@@ -24,6 +24,14 @@ services:
             service: redis
         volumes:
             - redis-data:/data
+
+    redis7:
+        extends:
+            file: docker-compose.base.yml
+            service: redis7
+        volumes:
+            - redis7-data:/data
+
     clickhouse:
         #
         # Note: please keep the default version in sync across
@@ -112,9 +120,11 @@ services:
             OBJECT_STORAGE_SECRET_ACCESS_KEY: 'object_storage_root_password'
             OBJECT_STORAGE_ENDPOINT: http://objectstorage:19000
             OBJECT_STORAGE_ENABLED: true
+            CDP_REDIS_HOST: redis7
         depends_on:
             - db
             - redis
+            - redis7
             - clickhouse
             - kafka
             - objectstorage
@@ -215,4 +225,5 @@ volumes:
     caddy-data:
     caddy-config:
     redis-data:
+    redis7-data:
     kafka-data:
diff --git a/ee/api/feature_flag_role_access.py b/ee/api/feature_flag_role_access.py
index f0bd176484ee4..6d03c7a4f361c 100644
--- a/ee/api/feature_flag_role_access.py
+++ b/ee/api/feature_flag_role_access.py
@@ -77,7 +77,7 @@ class FeatureFlagRoleAccessViewSet(
     permission_classes = [FeatureFlagRoleAccessPermissions]
     serializer_class = FeatureFlagRoleAccessSerializer
     queryset = FeatureFlagRoleAccess.objects.select_related("feature_flag")
-    filter_rewrite_rules = {"team_id": "feature_flag__team_id"}
+    filter_rewrite_rules = {"project_id": "feature_flag__team__project_id"}
 
     def safely_get_queryset(self, queryset):
         filters = self.request.GET.dict()
diff --git a/ee/billing/test/test_billing_manager.py b/ee/billing/test/test_billing_manager.py
index 1c5ed9d2ba859..4672baa98d83e 100644
--- a/ee/billing/test/test_billing_manager.py
+++ b/ee/billing/test/test_billing_manager.py
@@ -18,7 +18,7 @@ def create_default_products_response(**kwargs) -> dict[str, list[Product]]:
             Product(
                 name="Product analytics",
                 headline="Product analytics with autocapture",
-                description="A comprehensive product analytics platform built to natively work with session replay, feature flags, A/B testing, and surveys.",
+                description="A comprehensive product analytics platform built to natively work with session replay, feature flags, experiments, and surveys.",
                 usage_key="events",
                 image_url="https://posthog.com/images/products/product-analytics/product-analytics.png",
                 docs_url="https://posthog.com/docs/product-analytics",
diff --git a/ee/clickhouse/queries/experiments/funnel_experiment_result.py b/ee/clickhouse/queries/experiments/funnel_experiment_result.py
index ea95e177a5c80..4df48b0c97b0a 100644
--- a/ee/clickhouse/queries/experiments/funnel_experiment_result.py
+++ b/ee/clickhouse/queries/experiments/funnel_experiment_result.py
@@ -176,13 +176,13 @@ def calculate_results(
 
         if len(test_variants) >= 10:
             raise ValidationError(
-                "Can't calculate A/B test results for more than 10 variants",
+                "Can't calculate experiment results for more than 10 variants",
                 code="too_much_data",
             )
 
         if len(test_variants) < 1:
             raise ValidationError(
-                "Can't calculate A/B test results for less than 2 variants",
+                "Can't calculate experiment results for less than 2 variants",
                 code="no_data",
             )
 
@@ -311,7 +311,7 @@ def calculate_probability_of_winning_for_each(variants: list[Variant]) -> list[P
     """
     if len(variants) > 10:
         raise ValidationError(
-            "Can't calculate A/B test results for more than 10 variants",
+            "Can't calculate experiment results for more than 10 variants",
             code="too_much_data",
         )
 
diff --git a/ee/clickhouse/queries/experiments/trend_experiment_result.py b/ee/clickhouse/queries/experiments/trend_experiment_result.py
index 781d5690f006e..489520fd02596 100644
--- a/ee/clickhouse/queries/experiments/trend_experiment_result.py
+++ b/ee/clickhouse/queries/experiments/trend_experiment_result.py
@@ -338,13 +338,13 @@ def calculate_results(control_variant: Variant, test_variants: list[Variant]) ->
 
         if len(test_variants) >= 10:
             raise ValidationError(
-                "Can't calculate A/B test results for more than 10 variants",
+                "Can't calculate experiment results for more than 10 variants",
                 code="too_much_data",
             )
 
         if len(test_variants) < 1:
             raise ValidationError(
-                "Can't calculate A/B test results for less than 2 variants",
+                "Can't calculate experiment results for less than 2 variants",
                 code="no_data",
             )
 
@@ -413,7 +413,7 @@ def calculate_probability_of_winning_for_each(variants: list[Variant]) -> list[P
 
     if len(variants) > 10:
         raise ValidationError(
-            "Can't calculate A/B test results for more than 10 variants",
+            "Can't calculate experiment results for more than 10 variants",
             code="too_much_data",
         )
 
@@ -447,7 +447,7 @@ def intermediate_poisson_term(count: int, iterator: int, relative_exposure: floa
 
 def poisson_p_value(control_count, control_exposure, test_count, test_exposure):
     """
-    Calculates the p-value of the A/B test.
+    Calculates the p-value of the experiment.
     Calculations from: https://www.evanmiller.org/statistical-formulas-for-programmers.html#count_test
     """
     relative_exposure = test_exposure / (control_exposure + test_exposure)
diff --git a/frontend/__snapshots__/filters-property-filter-button--filter-types--dark.png b/frontend/__snapshots__/filters-property-filter-button--filter-types--dark.png
index a1b68be569fea..0672903871c50 100644
Binary files a/frontend/__snapshots__/filters-property-filter-button--filter-types--dark.png and b/frontend/__snapshots__/filters-property-filter-button--filter-types--dark.png differ
diff --git a/frontend/__snapshots__/filters-property-filter-button--filter-types--light.png b/frontend/__snapshots__/filters-property-filter-button--filter-types--light.png
index a74328c260a96..4873b57513359 100644
Binary files a/frontend/__snapshots__/filters-property-filter-button--filter-types--light.png and b/frontend/__snapshots__/filters-property-filter-button--filter-types--light.png differ
diff --git a/frontend/__snapshots__/replay-player-failure--recent-recordings-404--dark.png b/frontend/__snapshots__/replay-player-failure--recent-recordings-404--dark.png
index cc74b8c8cc166..4a7f487fb6b79 100644
Binary files a/frontend/__snapshots__/replay-player-failure--recent-recordings-404--dark.png and b/frontend/__snapshots__/replay-player-failure--recent-recordings-404--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-errortracking--group-page--dark.png b/frontend/__snapshots__/scenes-app-errortracking--group-page--dark.png
index 81e9d428f91a1..13c26071b3bcc 100644
Binary files a/frontend/__snapshots__/scenes-app-errortracking--group-page--dark.png and b/frontend/__snapshots__/scenes-app-errortracking--group-page--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-errortracking--group-page--light.png b/frontend/__snapshots__/scenes-app-errortracking--group-page--light.png
index f6d202d44c7b1..5a0cbd2405b75 100644
Binary files a/frontend/__snapshots__/scenes-app-errortracking--group-page--light.png and b/frontend/__snapshots__/scenes-app-errortracking--group-page--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-experiments--experiments-list--dark.png b/frontend/__snapshots__/scenes-app-experiments--experiments-list--dark.png
index 9944485ce6c2f..b447a10f2dec2 100644
Binary files a/frontend/__snapshots__/scenes-app-experiments--experiments-list--dark.png and b/frontend/__snapshots__/scenes-app-experiments--experiments-list--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-experiments--experiments-list--light.png b/frontend/__snapshots__/scenes-app-experiments--experiments-list--light.png
index def9e9eeb9007..e631f63618026 100644
Binary files a/frontend/__snapshots__/scenes-app-experiments--experiments-list--light.png and b/frontend/__snapshots__/scenes-app-experiments--experiments-list--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--user-paths-edit--dark.png b/frontend/__snapshots__/scenes-app-insights--user-paths-edit--dark.png
index b213cb8e6c970..1308913c32079 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--user-paths-edit--dark.png and b/frontend/__snapshots__/scenes-app-insights--user-paths-edit--dark.png differ
diff --git a/frontend/src/layout/navigation-3000/navigationLogic.tsx b/frontend/src/layout/navigation-3000/navigationLogic.tsx
index 9764bd6fb71a2..b1eddf98ad684 100644
--- a/frontend/src/layout/navigation-3000/navigationLogic.tsx
+++ b/frontend/src/layout/navigation-3000/navigationLogic.tsx
@@ -475,7 +475,7 @@ export const navigation3000Logic = kea<navigation3000LogicType>([
                         },
                         {
                             identifier: Scene.Experiments,
-                            label: 'A/B testing',
+                            label: 'Experiments',
                             icon: <IconTestTube />,
                             logic: isUsingSidebar ? experimentsSidebarLogic : undefined,
                             to: isUsingSidebar ? undefined : urls.experiments(),
diff --git a/frontend/src/layout/navigation-3000/sidebars/dataManagement.ts b/frontend/src/layout/navigation-3000/sidebars/dataManagement.ts
index 210204936359e..5eeaff0109f63 100644
--- a/frontend/src/layout/navigation-3000/sidebars/dataManagement.ts
+++ b/frontend/src/layout/navigation-3000/sidebars/dataManagement.ts
@@ -117,7 +117,7 @@ export const dataManagementSidebarLogic = kea<dataManagementSidebarLogicType>([
                                 menuItems: [
                                     {
                                         label: 'View recordings',
-                                        to: urls.replay(ReplayTabs.Recent, {
+                                        to: urls.replay(ReplayTabs.Home, {
                                             filter_group: {
                                                 type: FilterLogicalOperator.And,
                                                 values: [
diff --git a/frontend/src/layout/navigation-3000/sidepanel/panels/SidePanelSupport.tsx b/frontend/src/layout/navigation-3000/sidepanel/panels/SidePanelSupport.tsx
index 74e4653f2d776..f1f6a5a1e8a7b 100644
--- a/frontend/src/layout/navigation-3000/sidepanel/panels/SidePanelSupport.tsx
+++ b/frontend/src/layout/navigation-3000/sidepanel/panels/SidePanelSupport.tsx
@@ -60,7 +60,7 @@ const PRODUCTS = [
         icon: <IconToggle className="text-success h-5 w-5" />,
     },
     {
-        name: 'A/B testing',
+        name: 'Experiments',
         slug: 'experiments',
         icon: <IconFlask className="text-purple h-5 w-5" />,
     },
diff --git a/frontend/src/lib/components/Cards/InsightCard/InsightCard.scss b/frontend/src/lib/components/Cards/InsightCard/InsightCard.scss
index b21e228a3ef63..9a8afaa08b7af 100644
--- a/frontend/src/lib/components/Cards/InsightCard/InsightCard.scss
+++ b/frontend/src/lib/components/Cards/InsightCard/InsightCard.scss
@@ -16,14 +16,6 @@
         outline: 1px solid var(--primary-3000);
     }
 
-    &.react-draggable::after {
-        // During dashboard layout editing, we need an overlay to prevent accidental interaction with card content
-        position: absolute;
-        inset: 0;
-        z-index: var(--z-content-overlay);
-        content: '';
-    }
-
     .ErrorBoundary {
         width: 100%;
         height: 100%;
diff --git a/frontend/src/lib/components/Cards/handles.tsx b/frontend/src/lib/components/Cards/handles.tsx
index 5e25bd8f244a7..68d82e2b59853 100644
--- a/frontend/src/lib/components/Cards/handles.tsx
+++ b/frontend/src/lib/components/Cards/handles.tsx
@@ -5,8 +5,8 @@ export function ResizeHandle1D({ orientation }: { orientation: 'horizontal' | 'v
     return (
         <div className={clsx('handle', orientation)}>
             <svg fill="none" height="24" viewBox="0 0 16 24" width="16" xmlns="http://www.w3.org/2000/svg">
-                <rect fill="#fff" height="23" rx="3.5" width="15" x=".5" y=".5" />
-                <g fill="#5375ff">
+                <rect fill="var(--bg-light)" height="23" rx="3.5" width="15" x=".5" y=".5" />
+                <g fill="var(--primary)">
                     <rect height="2" rx=".25" width="2" x="5" y="5" />
                     <rect height="2" rx=".25" width="2" x="9" y="5" />
                     <rect height="2" rx=".25" width="2" x="5" y="9" />
@@ -16,7 +16,7 @@ export function ResizeHandle1D({ orientation }: { orientation: 'horizontal' | 'v
                     <rect height="2" rx=".25" width="2" x="5" y="13" />
                     <rect height="2" rx=".25" width="2" x="5" y="17" />
                 </g>
-                <rect height="23" rx="3.5" stroke="#d9d9d9" width="15" x=".5" y=".5" />
+                <rect height="23" rx="3.5" stroke="var(--border)" width="15" x=".5" y=".5" />
             </svg>
         </div>
     )
@@ -27,8 +27,8 @@ export function ResizeHandle2D(): JSX.Element {
     return (
         <div className="handle corner">
             <svg fill="none" height="18" viewBox="0 0 18 18" width="18" xmlns="http://www.w3.org/2000/svg">
-                <rect fill="#fff" height="17" rx="3.5" width="17" x=".5" y=".5" />
-                <g fill="#5375ff">
+                <rect fill="var(--bg-light)" height="17" rx="3.5" width="17" x=".5" y=".5" />
+                <g fill="var(--primary)">
                     <rect height="2" rx=".25" width="2" x="8" y="8" />
                     <rect height="2" rx=".25" width="2" x="8" y="12" />
                     <rect height="2" rx=".25" width="2" x="12" y="4" />
@@ -36,7 +36,7 @@ export function ResizeHandle2D(): JSX.Element {
                     <rect height="2" rx=".25" width="2" x="12" y="8" />
                     <rect height="2" rx=".25" width="2" x="12" y="12" />
                 </g>
-                <rect height="17" rx="3.5" stroke="#d9d9d9" width="17" x=".5" y=".5" />
+                <rect height="17" rx="3.5" stroke="var(--border)" width="17" x=".5" y=".5" />
             </svg>
         </div>
     )
diff --git a/frontend/src/lib/components/CommandPalette/commandPaletteLogic.tsx b/frontend/src/lib/components/CommandPalette/commandPaletteLogic.tsx
index 9f1f2d5cfda9d..e462fed6e1c8f 100644
--- a/frontend/src/lib/components/CommandPalette/commandPaletteLogic.tsx
+++ b/frontend/src/lib/components/CommandPalette/commandPaletteLogic.tsx
@@ -589,7 +589,7 @@ export const commandPaletteLogic = kea<commandPaletteLogicType>([
                     },
                     {
                         icon: IconTestTube,
-                        display: 'Go to A/B testing',
+                        display: 'Go to Experiments',
                         executor: () => {
                             push(urls.experiments())
                         },
diff --git a/frontend/src/lib/components/IframedToolbarBrowser/IframedToolbarBrowser.tsx b/frontend/src/lib/components/IframedToolbarBrowser/IframedToolbarBrowser.tsx
new file mode 100644
index 0000000000000..3e34575b31c96
--- /dev/null
+++ b/frontend/src/lib/components/IframedToolbarBrowser/IframedToolbarBrowser.tsx
@@ -0,0 +1,75 @@
+import { LemonBanner, Spinner } from '@posthog/lemon-ui'
+import { useActions, useValues } from 'kea'
+import { useEffect } from 'react'
+import useResizeObserver from 'use-resize-observer'
+
+import { ToolbarUserIntent } from '~/types'
+
+import { appEditorUrl } from '../AuthorizedUrlList/authorizedUrlListLogic'
+import { iframedToolbarBrowserLogic } from './iframedToolbarBrowserLogic'
+
+function IframeErrorOverlay(): JSX.Element | null {
+    const logic = iframedToolbarBrowserLogic()
+    const { iframeBanner } = useValues(logic)
+    return iframeBanner ? (
+        <div className="absolute flex flex-col w-full h-full bg-blend-overlay items-start py-4 px-8 pointer-events-none">
+            <LemonBanner className="w-full" type={iframeBanner.level}>
+                {iframeBanner.message}. Your site might not allow being embedded in an iframe. You can click "Open in
+                toolbar" above to visit your site and view the heatmap there.
+            </LemonBanner>
+        </div>
+    ) : null
+}
+
+function LoadingOverlay(): JSX.Element | null {
+    const logic = iframedToolbarBrowserLogic()
+    const { loading } = useValues(logic)
+    return loading ? (
+        <div className="absolute flex flex-col w-full h-full items-center justify-center pointer-events-none">
+            <Spinner className="text-5xl" textColored={true} />
+        </div>
+    ) : null
+}
+
+export function IframedToolbarBrowser({
+    iframeRef,
+    userIntent,
+}: {
+    iframeRef?: React.MutableRefObject<HTMLIFrameElement | null>
+    userIntent: ToolbarUserIntent
+}): JSX.Element | null {
+    const logic = iframedToolbarBrowserLogic()
+
+    const { browserUrl } = useValues(logic)
+    const { onIframeLoad, setIframeWidth } = useActions(logic)
+
+    const { width: iframeWidth } = useResizeObserver<HTMLIFrameElement>({ ref: iframeRef })
+    useEffect(() => {
+        setIframeWidth(iframeWidth ?? null)
+    }, [iframeWidth])
+
+    return browserUrl ? (
+        <div className="relative flex-1 w-full h-full">
+            <IframeErrorOverlay />
+            <LoadingOverlay />
+            <iframe
+                ref={iframeRef}
+                className="w-full h-full"
+                src={appEditorUrl(browserUrl, {
+                    userIntent: userIntent,
+                })}
+                // eslint-disable-next-line react/forbid-dom-props
+                style={{
+                    background: '#FFF',
+                }}
+                onLoad={onIframeLoad}
+                // these two sandbox values are necessary so that the site and toolbar can run
+                // this is a very loose sandbox,
+                // but we specify it so that at least other capabilities are denied
+                sandbox="allow-scripts allow-same-origin"
+                // we don't allow things such as camera access though
+                allow=""
+            />
+        </div>
+    ) : null
+}
diff --git a/frontend/src/lib/components/IframedToolbarBrowser/iframedToolbarBrowserLogic.ts b/frontend/src/lib/components/IframedToolbarBrowser/iframedToolbarBrowserLogic.ts
new file mode 100644
index 0000000000000..71a59fdde32a1
--- /dev/null
+++ b/frontend/src/lib/components/IframedToolbarBrowser/iframedToolbarBrowserLogic.ts
@@ -0,0 +1,272 @@
+import { actions, afterMount, beforeUnmount, connect, kea, listeners, path, props, reducers, selectors } from 'kea'
+import { authorizedUrlListLogic, AuthorizedUrlListType } from 'lib/components/AuthorizedUrlList/authorizedUrlListLogic'
+import { CommonFilters, HeatmapFilters, HeatmapFixedPositionMode } from 'lib/components/heatmaps/types'
+import {
+    calculateViewportRange,
+    DEFAULT_HEATMAP_FILTERS,
+    PostHogAppToolbarEvent,
+} from 'lib/components/IframedToolbarBrowser/utils'
+import { LemonBannerProps } from 'lib/lemon-ui/LemonBanner'
+import posthog from 'posthog-js'
+import { RefObject } from 'react'
+
+import type { iframedToolbarBrowserLogicType } from './iframedToolbarBrowserLogicType'
+
+export type IframedToolbarBrowserLogicProps = {
+    iframeRef: RefObject<HTMLIFrameElement | null>
+    clearBrowserUrlOnUnmount?: boolean
+}
+
+export interface IFrameBanner {
+    level: LemonBannerProps['type']
+    message: string | JSX.Element
+}
+
+export const iframedToolbarBrowserLogic = kea<iframedToolbarBrowserLogicType>([
+    path(['lib', 'components', 'iframedToolbarBrowser', 'iframedToolbarBrowserLogic']),
+    props({} as IframedToolbarBrowserLogicProps),
+
+    connect({
+        values: [
+            authorizedUrlListLogic({ actionId: null, type: AuthorizedUrlListType.TOOLBAR_URLS }),
+            ['urlsKeyed', 'checkUrlIsAuthorized'],
+        ],
+    }),
+
+    actions({
+        setBrowserUrl: (url: string | null) => ({ url }),
+        onIframeLoad: true,
+        sendToolbarMessage: (type: PostHogAppToolbarEvent, payload?: Record<string, any>) => ({
+            type,
+            payload,
+        }),
+        // TRICKY: duplicated with the heatmapLogic so that we can share the settings picker
+        patchHeatmapFilters: (filters: Partial<HeatmapFilters>) => ({ filters }),
+        setHeatmapColorPalette: (Palette: string | null) => ({ Palette }),
+        setHeatmapFixedPositionMode: (mode: HeatmapFixedPositionMode) => ({ mode }),
+        setCommonFilters: (filters: CommonFilters) => ({ filters }),
+        // TRICKY: duplication ends
+        setIframeWidth: (width: number | null) => ({ width }),
+        setIframeBanner: (banner: IFrameBanner | null) => ({ banner }),
+        startTrackingLoading: true,
+        stopTrackingLoading: true,
+    }),
+
+    reducers({
+        // they're called common filters in the toolbar because they're shared between heatmaps and clickmaps
+        // the name is continued here since they're passed down into the embedded iframe
+        commonFilters: [
+            { date_from: '-7d' } as CommonFilters,
+            {
+                setCommonFilters: (_, { filters }) => filters,
+            },
+        ],
+        heatmapColorPalette: [
+            'default' as string | null,
+            {
+                setHeatmapColorPalette: (_, { Palette }) => Palette,
+            },
+        ],
+        heatmapFilters: [
+            DEFAULT_HEATMAP_FILTERS,
+            {
+                patchHeatmapFilters: (state, { filters }) => ({ ...state, ...filters }),
+            },
+        ],
+        heatmapFixedPositionMode: [
+            'fixed' as HeatmapFixedPositionMode,
+            {
+                setHeatmapFixedPositionMode: (_, { mode }) => mode,
+            },
+        ],
+        iframeWidth: [
+            null as number | null,
+            {
+                setIframeWidth: (_, { width }) => width,
+            },
+        ],
+        browserUrl: [
+            null as string | null,
+            { persist: true },
+            {
+                setBrowserUrl: (_, { url }) => url,
+            },
+        ],
+        loading: [
+            false as boolean,
+            {
+                setBrowserUrl: (state, { url }) => (url?.trim().length ? true : state),
+                setIframeBanner: (state, { banner }) => (banner?.level == 'error' ? false : state),
+                startTrackingLoading: () => true,
+                stopTrackingLoading: () => false,
+            },
+        ],
+        iframeBanner: [
+            null as IFrameBanner | null,
+            {
+                setIframeBanner: (_, { banner }) => banner,
+            },
+        ],
+    }),
+
+    selectors({
+        isBrowserUrlAuthorized: [
+            (s) => [s.browserUrl, s.checkUrlIsAuthorized],
+            (browserUrl, checkUrlIsAuthorized) => {
+                if (!browserUrl) {
+                    return false
+                }
+                return checkUrlIsAuthorized(browserUrl)
+            },
+        ],
+
+        viewportRange: [
+            (s) => [s.heatmapFilters, s.iframeWidth],
+            (heatmapFilters, iframeWidth) => {
+                return iframeWidth ? calculateViewportRange(heatmapFilters, iframeWidth) : { min: 0, max: 1800 }
+            },
+        ],
+    }),
+
+    listeners(({ actions, cache, props, values }) => ({
+        sendToolbarMessage: ({ type, payload }) => {
+            props.iframeRef?.current?.contentWindow?.postMessage(
+                {
+                    type,
+                    payload,
+                },
+                '*'
+            )
+        },
+
+        patchHeatmapFilters: ({ filters }) => {
+            actions.sendToolbarMessage(PostHogAppToolbarEvent.PH_PATCH_HEATMAP_FILTERS, { filters })
+        },
+
+        setHeatmapFixedPositionMode: ({ mode }) => {
+            actions.sendToolbarMessage(PostHogAppToolbarEvent.PH_HEATMAPS_FIXED_POSITION_MODE, {
+                fixedPositionMode: mode,
+            })
+        },
+
+        setHeatmapColorPalette: ({ Palette }) => {
+            actions.sendToolbarMessage(PostHogAppToolbarEvent.PH_HEATMAPS_COLOR_PALETTE, {
+                colorPalette: Palette,
+            })
+        },
+
+        setCommonFilters: ({ filters }) => {
+            actions.sendToolbarMessage(PostHogAppToolbarEvent.PH_HEATMAPS_COMMON_FILTERS, { commonFilters: filters })
+        },
+
+        onIframeLoad: () => {
+            // we get this callback whether the iframe loaded successfully or not
+            // and don't get a signal if the load was successful, so we have to check
+            // but there's no slam dunk way to do that
+
+            const init = (): void => {
+                actions.sendToolbarMessage(PostHogAppToolbarEvent.PH_APP_INIT, {
+                    filters: values.heatmapFilters,
+                    colorPalette: values.heatmapColorPalette,
+                    fixedPositionMode: values.heatmapFixedPositionMode,
+                    commonFilters: values.commonFilters,
+                })
+                actions.sendToolbarMessage(PostHogAppToolbarEvent.PH_HEATMAPS_CONFIG, {
+                    enabled: true,
+                })
+            }
+
+            const onIframeMessage = (e: MessageEvent): void => {
+                const type: PostHogAppToolbarEvent = e?.data?.type
+
+                if (!type || !type.startsWith('ph-')) {
+                    return
+                }
+                if (!values.checkUrlIsAuthorized(e.origin)) {
+                    console.warn(
+                        'ignoring message from iframe with origin not in authorized toolbar urls',
+                        e.origin,
+                        e.data
+                    )
+                    return
+                }
+
+                switch (type) {
+                    case PostHogAppToolbarEvent.PH_TOOLBAR_INIT:
+                        return init()
+                    case PostHogAppToolbarEvent.PH_TOOLBAR_READY:
+                        posthog.capture('in-app heatmap frame loaded', {
+                            inapp_heatmap_page_url_visited: values.browserUrl,
+                            inapp_heatmap_filters: values.heatmapFilters,
+                            inapp_heatmap_color_palette: values.heatmapColorPalette,
+                            inapp_heatmap_fixed_position_mode: values.heatmapFixedPositionMode,
+                        })
+                        // reset loading tracking - if we're e.g. slow this will avoid a flash of warning message
+                        return actions.startTrackingLoading()
+                    case PostHogAppToolbarEvent.PH_TOOLBAR_HEATMAP_LOADING:
+                        return actions.startTrackingLoading()
+                    case PostHogAppToolbarEvent.PH_TOOLBAR_HEATMAP_LOADED:
+                        posthog.capture('in-app heatmap loaded', {
+                            inapp_heatmap_page_url_visited: values.browserUrl,
+                            inapp_heatmap_filters: values.heatmapFilters,
+                            inapp_heatmap_color_palette: values.heatmapColorPalette,
+                            inapp_heatmap_fixed_position_mode: values.heatmapFixedPositionMode,
+                        })
+                        return actions.stopTrackingLoading()
+                    case PostHogAppToolbarEvent.PH_TOOLBAR_HEATMAP_FAILED:
+                        posthog.capture('in-app heatmap failed', {
+                            inapp_heatmap_page_url_visited: values.browserUrl,
+                            inapp_heatmap_filters: values.heatmapFilters,
+                            inapp_heatmap_color_palette: values.heatmapColorPalette,
+                            inapp_heatmap_fixed_position_mode: values.heatmapFixedPositionMode,
+                        })
+                        actions.stopTrackingLoading()
+                        actions.setIframeBanner({ level: 'error', message: 'The heatmap failed to load.' })
+                        return
+                    default:
+                        console.warn(`[PostHog Heatmaps] Received unknown child window message: ${type}`)
+                }
+            }
+
+            window.addEventListener('message', onIframeMessage, false)
+            // We call init in case the toolbar got there first (unlikely)
+            init()
+        },
+
+        setBrowserUrl: ({ url }) => {
+            if (url?.trim().length) {
+                actions.startTrackingLoading()
+            }
+        },
+
+        startTrackingLoading: () => {
+            actions.setIframeBanner(null)
+
+            clearTimeout(cache.errorTimeout)
+            cache.errorTimeout = setTimeout(() => {
+                actions.setIframeBanner({ level: 'error', message: 'The heatmap failed to load (or is very slow).' })
+            }, 7500)
+
+            clearTimeout(cache.warnTimeout)
+            cache.warnTimeout = setTimeout(() => {
+                actions.setIframeBanner({ level: 'warning', message: 'Still waiting for the toolbar to load.' })
+            }, 3000)
+        },
+
+        stopTrackingLoading: () => {
+            actions.setIframeBanner(null)
+
+            clearTimeout(cache.errorTimeout)
+            clearTimeout(cache.warnTimeout)
+        },
+    })),
+
+    afterMount(({ actions, values }) => {
+        if (values.browserUrl?.trim().length) {
+            actions.startTrackingLoading()
+        }
+    }),
+    beforeUnmount(({ actions, props }) => {
+        props.clearBrowserUrlOnUnmount && actions.setBrowserUrl('')
+    }),
+])
diff --git a/frontend/src/lib/components/heatmaps/utils.ts b/frontend/src/lib/components/IframedToolbarBrowser/utils.ts
similarity index 100%
rename from frontend/src/lib/components/heatmaps/utils.ts
rename to frontend/src/lib/components/IframedToolbarBrowser/utils.ts
diff --git a/frontend/src/lib/components/PropertyFilters/components/PropertyFilterIcon.tsx b/frontend/src/lib/components/PropertyFilters/components/PropertyFilterIcon.tsx
index e5f21f758ca64..c07469732a56d 100644
--- a/frontend/src/lib/components/PropertyFilters/components/PropertyFilterIcon.tsx
+++ b/frontend/src/lib/components/PropertyFilters/components/PropertyFilterIcon.tsx
@@ -1,33 +1,36 @@
-import { IconPerson } from '@posthog/icons'
+import { IconBuilding, IconPerson } from '@posthog/icons'
 import { IconCohort, IconUnverifiedEvent } from 'lib/lemon-ui/icons'
 import { Tooltip } from 'lib/lemon-ui/Tooltip'
 
 import { PropertyFilterType } from '~/types'
 
-export function PropertyFilterIcon({ type }: { type?: PropertyFilterType }): JSX.Element {
-    let iconElement = <></>
+export function PropertyFilterIcon({ type }: { type?: PropertyFilterType }): JSX.Element | null {
     switch (type) {
         case 'event':
-            iconElement = (
+            return (
                 <Tooltip title="Event property">
                     <IconUnverifiedEvent />
                 </Tooltip>
             )
-            break
         case 'person':
-            iconElement = (
+            return (
                 <Tooltip title="Person property">
                     <IconPerson />
                 </Tooltip>
             )
-            break
         case 'cohort':
-            iconElement = (
+            return (
                 <Tooltip title="Cohort filter">
                     <IconCohort />
                 </Tooltip>
             )
-            break
+        case 'group':
+            return (
+                <Tooltip title="Group filter">
+                    <IconBuilding />
+                </Tooltip>
+            )
+        default:
+            return null
     }
-    return iconElement
 }
diff --git a/frontend/src/lib/components/Support/supportLogic.ts b/frontend/src/lib/components/Support/supportLogic.ts
index 5bb67f51f2ad8..d947dc10e6723 100644
--- a/frontend/src/lib/components/Support/supportLogic.ts
+++ b/frontend/src/lib/components/Support/supportLogic.ts
@@ -131,7 +131,7 @@ export const TARGET_AREA_TO_NAME = [
             {
                 value: 'experiments',
                 'data-attr': `support-form-target-area-experiments`,
-                label: 'A/B testing',
+                label: 'Experiments',
             },
             {
                 value: 'data_warehouse',
diff --git a/frontend/src/lib/internalMetrics.ts b/frontend/src/lib/internalMetrics.ts
index 353d6fc3b3afa..e95c05eae5e85 100644
--- a/frontend/src/lib/internalMetrics.ts
+++ b/frontend/src/lib/internalMetrics.ts
@@ -6,6 +6,7 @@ import { getResponseBytes } from 'scenes/insights/utils'
 import { getCurrentExporterData } from '~/exporter/exporterViewLogic'
 
 export interface TimeToSeeDataPayload {
+    team_id?: number | null
     type: 'dashboard_load' | 'insight_load' | 'properties_timeline_load' | 'property_values_load' | 'properties_load'
     context: 'dashboard' | 'insight' | 'actors_modal' | 'filters'
     time_to_see_data_ms: number
diff --git a/frontend/src/lib/utils/eventUsageLogic.ts b/frontend/src/lib/utils/eventUsageLogic.ts
index 2e6db6758873d..7a92178c28191 100644
--- a/frontend/src/lib/utils/eventUsageLogic.ts
+++ b/frontend/src/lib/utils/eventUsageLogic.ts
@@ -10,6 +10,7 @@ import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
 import { isActionFilter, isEventFilter } from 'lib/components/UniversalFilters/utils'
 import type { Dayjs } from 'lib/dayjs'
 import { now } from 'lib/dayjs'
+import { TimeToSeeDataPayload } from 'lib/internalMetrics'
 import { isCoreFilter, PROPERTY_KEYS } from 'lib/taxonomy'
 import { objectClean } from 'lib/utils'
 import posthog from 'posthog-js'
@@ -292,6 +293,8 @@ export const eventUsageLogic = kea<eventUsageLogicType>([
         reportPersonsModalViewed: (params: any) => ({
             params,
         }),
+        // timing
+        reportTimeToSeeData: (payload: TimeToSeeDataPayload) => ({ payload }),
         // insights
         reportInsightCreated: (query: Node | null) => ({ query }),
         reportInsightSaved: (query: Node | null, isNewInsight: boolean) => ({ query, isNewInsight }),
@@ -638,6 +641,9 @@ export const eventUsageLogic = kea<eventUsageLogicType>([
             }
             posthog.capture('person viewed', properties)
         },
+        reportTimeToSeeData: async ({ payload }) => {
+            posthog.capture('time to see data', payload)
+        },
         reportInsightCreated: async ({ query }, breakpoint) => {
             // "insight created" essentially means that the user clicked "New insight"
             await breakpoint(500) // Debounce to avoid multiple quick "New insight" clicks being reported
diff --git a/frontend/src/mocks/fixtures/_billing.tsx b/frontend/src/mocks/fixtures/_billing.tsx
index 870d313157a0a..276026beb55aa 100644
--- a/frontend/src/mocks/fixtures/_billing.tsx
+++ b/frontend/src/mocks/fixtures/_billing.tsx
@@ -18,7 +18,7 @@ export const billingJson: BillingType = {
             name: 'Product analytics',
             headline: 'Product analytics with autocapture',
             description:
-                'A comprehensive product analytics platform built to natively work with session replay, feature flags, A/B testing, and surveys.',
+                'A comprehensive product analytics platform built to natively work with session replay, feature flags, experiments, and surveys.',
             price_description: null,
             usage_key: 'events',
             image_url: 'https://posthog.com/images/products/product-analytics/product-analytics.png',
@@ -32,7 +32,7 @@ export const billingJson: BillingType = {
                     product_key: 'product_analytics',
                     name: 'Free',
                     description:
-                        'A comprehensive product analytics platform built to natively work with session replay, feature flags, A/B testing, and surveys.',
+                        'A comprehensive product analytics platform built to natively work with session replay, feature flags, experiments, and surveys.',
                     image_url: 'https://posthog.com/images/products/product-analytics/product-analytics.png',
                     docs_url: 'https://posthog.com/docs/product-analytics',
                     note: null,
@@ -95,7 +95,7 @@ export const billingJson: BillingType = {
                     product_key: 'product_analytics',
                     name: 'Paid',
                     description:
-                        'A comprehensive product analytics platform built to natively work with session replay, feature flags, A/B testing, and surveys.',
+                        'A comprehensive product analytics platform built to natively work with session replay, feature flags, experiments, and surveys.',
                     image_url: 'https://posthog.com/images/products/product-analytics/product-analytics.png',
                     docs_url: 'https://posthog.com/docs/product-analytics',
                     note: null,
@@ -1444,8 +1444,8 @@ export const billingJson: BillingType = {
             ],
         },
         {
-            name: 'Feature flags & A/B testing',
-            headline: 'Safely roll out features and A/B tests to specific users or groups',
+            name: 'Feature flags & experiments',
+            headline: 'Safely roll out features and experiments to specific users or groups',
             description:
                 'Test changes with small groups of users before rolling out wider. Analyze usage with product analytics and session replay.',
             price_description: null,
@@ -1551,7 +1551,7 @@ export const billingJson: BillingType = {
                         },
                         {
                             key: 'experimentation',
-                            name: 'A/B testing',
+                            name: 'Experiments',
                             description: 'Test changes to your product and evaluate the impacts those changes make.',
                             unit: null,
                             limit: null,
@@ -1694,7 +1694,7 @@ export const billingJson: BillingType = {
                         },
                         {
                             key: 'experimentation',
-                            name: 'A/B testing',
+                            name: 'Experiments',
                             description: 'Test changes to your product and evaluate the impacts those changes make.',
                             unit: null,
                             limit: null,
@@ -1966,7 +1966,7 @@ export const billingJson: BillingType = {
                 },
                 {
                     key: 'experimentation',
-                    name: 'A/B testing',
+                    name: 'Experiments',
                     description: 'Test changes to your product and evaluate the impacts those changes make.',
                     images: null,
                     icon_key: null,
diff --git a/frontend/src/queries/schema.json b/frontend/src/queries/schema.json
index 3a9ea2ab136b2..10e539b1d61ac 100644
--- a/frontend/src/queries/schema.json
+++ b/frontend/src/queries/schema.json
@@ -3669,12 +3669,6 @@
                 "description": {
                     "type": ["string", "null"]
                 },
-                "events": {
-                    "items": {
-                        "type": "object"
-                    },
-                    "type": "array"
-                },
                 "exception_type": {
                     "type": ["string", "null"]
                 },
@@ -3747,12 +3741,6 @@
                 "dateRange": {
                     "$ref": "#/definitions/DateRange"
                 },
-                "eventColumns": {
-                    "items": {
-                        "type": "string"
-                    },
-                    "type": "array"
-                },
                 "filterGroup": {
                     "$ref": "#/definitions/PropertyGroupFilter"
                 },
@@ -3776,9 +3764,6 @@
                     "$ref": "#/definitions/HogQLQueryModifiers",
                     "description": "Modifiers used when performing the query"
                 },
-                "offset": {
-                    "type": "integer"
-                },
                 "order": {
                     "enum": ["last_seen", "first_seen", "occurrences", "users", "sessions"],
                     "type": "string"
diff --git a/frontend/src/queries/schema.ts b/frontend/src/queries/schema.ts
index 176eb9d8579ab..8ddd7d79fad6d 100644
--- a/frontend/src/queries/schema.ts
+++ b/frontend/src/queries/schema.ts
@@ -1380,14 +1380,12 @@ export interface ErrorTrackingQuery extends DataNode<ErrorTrackingQueryResponse>
     kind: NodeKind.ErrorTrackingQuery
     fingerprint?: string[]
     select?: HogQLExpression[]
-    eventColumns?: string[]
     order?: 'last_seen' | 'first_seen' | 'occurrences' | 'users' | 'sessions'
     dateRange: DateRange
     assignee?: integer | null
     filterGroup?: PropertyGroupFilter
     filterTestAccounts?: boolean
     limit?: integer
-    offset?: integer
 }
 
 export interface ErrorTrackingGroup {
@@ -1406,7 +1404,6 @@ export interface ErrorTrackingGroup {
     volume?: any
     assignee: number | null
     status: 'archived' | 'active' | 'resolved' | 'pending_release'
-    events?: Record<string, any>[]
 }
 
 export interface ErrorTrackingQueryResponse extends AnalyticsQueryResponseBase<ErrorTrackingGroup[]> {
diff --git a/frontend/src/scenes/actions/ActionEdit.tsx b/frontend/src/scenes/actions/ActionEdit.tsx
index eb2516b69e0e8..83c0744eb3592 100644
--- a/frontend/src/scenes/actions/ActionEdit.tsx
+++ b/frontend/src/scenes/actions/ActionEdit.tsx
@@ -116,7 +116,7 @@ export function ActionEdit({ action: loadedAction, id }: ActionEditLogicProps):
                             {id ? (
                                 <LemonButton
                                     type="secondary"
-                                    to={urls.replay(ReplayTabs.Recent, {
+                                    to={urls.replay(ReplayTabs.Home, {
                                         filter_group: {
                                             type: FilterLogicalOperator.And,
                                             values: [
diff --git a/frontend/src/scenes/billing/BillingLimit.tsx b/frontend/src/scenes/billing/BillingLimit.tsx
index 84dfc6b2ff720..3fe760df96f11 100644
--- a/frontend/src/scenes/billing/BillingLimit.tsx
+++ b/frontend/src/scenes/billing/BillingLimit.tsx
@@ -1,6 +1,7 @@
 import { LemonButton, LemonInput } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
-import { Field, Form } from 'kea-forms'
+import { Form } from 'kea-forms'
+import { LemonField } from 'lib/lemon-ui/LemonField'
 import { Tooltip } from 'lib/lemon-ui/Tooltip'
 import { useRef } from 'react'
 
@@ -48,8 +49,8 @@ export const BillingLimit = ({ product }: { product: BillingProductV2Type }): JS
                                     ) : (
                                         <Tooltip title="Set a billing limit to control your recurring costs. Some features may stop working and data may be dropped if your usage exceeds your limit.">
                                             <span className="text-sm" data-attr={`billing-limit-set-${product.type}`}>
-                                                You have a <b>${customLimitUsd}</b> billing limit set for{' '}
-                                                {product?.name?.toLowerCase()}.
+                                                You have a <b>${customLimitUsd?.toLocaleString()}</b> billing limit set
+                                                for {product?.name?.toLowerCase()}.
                                             </span>
                                         </Tooltip>
                                     )}
@@ -78,30 +79,26 @@ export const BillingLimit = ({ product }: { product: BillingProductV2Type }): JS
                             )}{' '}
                         </div>
                     ) : (
-                        <div className="flex items-center justify-center gap-2.5">
-                            <Field name="input" noStyle>
+                        <div className="flex items-start justify-start gap-2.5">
+                            <LemonField name="input" className="max-w-52">
                                 {({ value, onChange, error }) => (
-                                    <Tooltip title={error}>
-                                        <div className="max-w-36">
-                                            <LemonInput
-                                                inputRef={limitInputRef}
-                                                type="number"
-                                                fullWidth={false}
-                                                status={error ? 'danger' : 'default'}
-                                                value={value}
-                                                data-attr={`billing-limit-input-${product.type}`}
-                                                onChange={onChange}
-                                                prefix={<b>$</b>}
-                                                disabled={billingLoading}
-                                                min={0}
-                                                step={10}
-                                                suffix={<>/ {billing?.billing_period?.interval}</>}
-                                                size="small"
-                                            />
-                                        </div>
-                                    </Tooltip>
+                                    <LemonInput
+                                        inputRef={limitInputRef}
+                                        type="number"
+                                        fullWidth={false}
+                                        status={error ? 'danger' : 'default'}
+                                        value={value}
+                                        data-attr={`billing-limit-input-${product.type}`}
+                                        onChange={onChange}
+                                        prefix={<b>$</b>}
+                                        disabled={billingLoading}
+                                        min={0}
+                                        step={10}
+                                        suffix={<>/ {billing?.billing_period?.interval}</>}
+                                        size="small"
+                                    />
                                 )}
-                            </Field>
+                            </LemonField>
 
                             <LemonButton
                                 loading={billingLoading}
diff --git a/frontend/src/scenes/billing/billingLogic.tsx b/frontend/src/scenes/billing/billingLogic.tsx
index b6ffa6a4aafff..3c3f5505eeb34 100644
--- a/frontend/src/scenes/billing/billingLogic.tsx
+++ b/frontend/src/scenes/billing/billingLogic.tsx
@@ -191,10 +191,16 @@ export const billingLogic = kea<billingLogicType>([
                 },
 
                 updateBillingLimits: async (limits: { [key: string]: number | null }) => {
-                    const response = await api.update('api/billing', { custom_limits_usd: limits })
-
-                    lemonToast.success('Billing limits updated')
-                    return parseBillingResponse(response)
+                    try {
+                        const response = await api.update('api/billing', { custom_limits_usd: limits })
+                        lemonToast.success('Billing limits updated')
+                        return parseBillingResponse(response)
+                    } catch (error: any) {
+                        lemonToast.error(
+                            'There was an error updating your billing limits. Please try again or contact support.'
+                        )
+                        throw error
+                    }
                 },
 
                 deactivateProduct: async (key: string) => {
diff --git a/frontend/src/scenes/billing/billingProductLogic.ts b/frontend/src/scenes/billing/billingProductLogic.ts
index 777925d1a812f..deaae97fbc689 100644
--- a/frontend/src/scenes/billing/billingProductLogic.ts
+++ b/frontend/src/scenes/billing/billingProductLogic.ts
@@ -272,7 +272,6 @@ export const billingProductLogic = kea<billingProductLogicType>([
                 const projectedAmount = parseInt(product.projected_amount_usd || '0')
                 return product.tiers && projectedAmount ? projectedAmount * 1.5 : DEFAULT_BILLING_LIMIT
             }
-
             actions.setIsEditingBillingLimit(false)
             actions.setBillingLimitInput(
                 values.hasCustomLimitSet ? values.customLimitUsd : calculateDefaultBillingLimit(props.product)
@@ -335,7 +334,12 @@ export const billingProductLogic = kea<billingProductLogicType>([
     forms(({ actions, props, values }) => ({
         billingLimitInput: {
             errors: ({ input }) => ({
-                input: input === null || Number.isInteger(input) ? undefined : 'Please enter a whole number',
+                input:
+                    input === null || Number.isInteger(input)
+                        ? input > 25000
+                            ? 'Please enter a number less than 25,000'
+                            : undefined
+                        : 'Please enter a whole number',
             }),
             submit: async ({ input }) => {
                 const addonTiers =
diff --git a/frontend/src/scenes/dashboard/DashboardItems.scss b/frontend/src/scenes/dashboard/DashboardItems.scss
index 53c81cd649851..7107657348f3e 100644
--- a/frontend/src/scenes/dashboard/DashboardItems.scss
+++ b/frontend/src/scenes/dashboard/DashboardItems.scss
@@ -23,8 +23,10 @@
     will-change: width, height;
 }
 
-.react-grid-item.react-draggable {
+.react-grid-item.react-draggable .CardMeta {
+    // .CardMeta is the draggable handle
     cursor: move;
+    user-select: none; // Prevent accidental text selection while dragging
 }
 
 .react-grid-item.react-draggable-dragging {
diff --git a/frontend/src/scenes/dashboard/DashboardItems.tsx b/frontend/src/scenes/dashboard/DashboardItems.tsx
index fccd51a9885f5..48196a79c1b8d 100644
--- a/frontend/src/scenes/dashboard/DashboardItems.tsx
+++ b/frontend/src/scenes/dashboard/DashboardItems.tsx
@@ -59,6 +59,7 @@ export function DashboardItems(): JSX.Element {
                 <ReactGridLayout
                     width={gridWrapperWidth}
                     className={className}
+                    draggableHandle=".CardMeta"
                     isDraggable={dashboardMode === DashboardMode.Edit}
                     isResizable={dashboardMode === DashboardMode.Edit}
                     layouts={layouts}
@@ -98,7 +99,7 @@ export function DashboardItems(): JSX.Element {
                             isDragging.current = false
                         }, 250)
                     }}
-                    draggableCancel=".anticon,table,button,.Popover"
+                    draggableCancel="a,table,button,.Popover"
                 >
                     {tiles?.map((tile) => {
                         const { insight, text } = tile
diff --git a/frontend/src/scenes/dashboard/dashboardLogic.tsx b/frontend/src/scenes/dashboard/dashboardLogic.tsx
index 908b778ebb311..2d9a642ba5e77 100644
--- a/frontend/src/scenes/dashboard/dashboardLogic.tsx
+++ b/frontend/src/scenes/dashboard/dashboardLogic.tsx
@@ -17,7 +17,7 @@ import { router, urlToAction } from 'kea-router'
 import api, { ApiMethodOptions, getJSONOrNull } from 'lib/api'
 import { DashboardPrivilegeLevel, OrganizationMembershipLevel } from 'lib/constants'
 import { Dayjs, dayjs, now } from 'lib/dayjs'
-import { captureTimeToSeeData, currentSessionId, TimeToSeeDataPayload } from 'lib/internalMetrics'
+import { currentSessionId, TimeToSeeDataPayload } from 'lib/internalMetrics'
 import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
 import { Link } from 'lib/lemon-ui/Link'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
@@ -65,6 +65,7 @@ export const DASHBOARD_MIN_REFRESH_INTERVAL_MINUTES = 5
 
 const IS_TEST_MODE = process.env.NODE_ENV === 'test'
 
+const REFRESH_DASHBOARD_ITEM_ACTION = 'refresh_dashboard_item'
 export interface DashboardLogicProps {
     id: number
     dashboard?: DashboardType<QueryBasedInsightModel>
@@ -190,7 +191,6 @@ export const dashboardLogic = kea<dashboardLogicType>([
         refreshAllDashboardItems: (payload: {
             tiles?: DashboardTile<QueryBasedInsightModel>[]
             action: string
-            initialLoad?: boolean
             dashboardQueryId?: string
         }) => payload,
         refreshAllDashboardItemsManual: true,
@@ -953,7 +953,19 @@ export const dashboardLogic = kea<dashboardLogicType>([
         setRefreshError: sharedListeners.reportRefreshTiming,
         setRefreshStatuses: sharedListeners.reportRefreshTiming,
         setRefreshStatus: sharedListeners.reportRefreshTiming,
-        loadDashboardFailure: sharedListeners.reportLoadTiming,
+        loadDashboardFailure: () => {
+            const { action, dashboardQueryId, startTime } = values.dashboardLoadTimerData
+
+            eventUsageLogic.actions.reportTimeToSeeData({
+                team_id: values.currentTeamId,
+                type: 'dashboard_load',
+                context: 'dashboard',
+                status: 'failure',
+                action,
+                primary_interaction_id: dashboardQueryId,
+                time_to_see_data_ms: Math.floor(performance.now() - startTime),
+            })
+        },
         [insightsModel.actionTypes.duplicateInsightSuccess]: () => {
             // TODO this is a bit hacky, but we need to reload the dashboard to get the new insight
             // TODO when duplicated from a dashboard we should carry the context so only one logic needs to reload
@@ -1039,12 +1051,12 @@ export const dashboardLogic = kea<dashboardLogicType>([
                 dashboardsModel.actions.updateDashboardInsight(refreshedInsight!)
                 // Start polling for results
                 tile.insight = refreshedInsight!
-                actions.refreshAllDashboardItems({ tiles: [tile], action: 'refresh' })
+                actions.refreshAllDashboardItems({ tiles: [tile], action: REFRESH_DASHBOARD_ITEM_ACTION })
             } catch (e: any) {
                 actions.setRefreshError(insight.short_id)
             }
         },
-        refreshAllDashboardItems: async ({ tiles, action, initialLoad, dashboardQueryId = uuid() }, breakpoint) => {
+        refreshAllDashboardItems: async ({ tiles, action, dashboardQueryId = uuid() }, breakpoint) => {
             const dashboardId: number = props.id
 
             const insightsToRefresh = (tiles || values.insightTiles || [])
@@ -1058,6 +1070,31 @@ export const dashboardLogic = kea<dashboardLogicType>([
 
             // Don't do anything if there's nothing to refresh
             if (insightsToRefresh.length === 0) {
+                // still report time to see updated data
+                // in case loadDashboard found all cached insights
+                const dashboard = values.dashboard
+                if (dashboard && action !== REFRESH_DASHBOARD_ITEM_ACTION) {
+                    const { action, dashboardQueryId, startTime, responseBytes } = values.dashboardLoadTimerData
+                    const lastRefresh = sortDates(dashboard.tiles.map((tile) => tile.insight?.last_refresh || null))
+
+                    eventUsageLogic.actions.reportTimeToSeeData({
+                        team_id: values.currentTeamId,
+                        type: 'dashboard_load',
+                        context: 'dashboard',
+                        action,
+                        primary_interaction_id: dashboardQueryId,
+                        time_to_see_data_ms: Math.floor(performance.now() - startTime),
+                        api_response_bytes: responseBytes,
+                        insights_fetched: dashboard.tiles.length,
+                        insights_fetched_cached: dashboard.tiles.reduce(
+                            (acc, curr) => acc + (curr.is_cached ? 1 : 0),
+                            0
+                        ),
+                        min_last_refresh: lastRefresh[0],
+                        max_last_refresh: lastRefresh[lastRefresh.length - 1],
+                    })
+                }
+
                 return
             }
 
@@ -1129,6 +1166,7 @@ export const dashboardLogic = kea<dashboardLogicType>([
                 refreshesFinished += 1
                 if (!cancelled && refreshesFinished === insightsToRefresh.length) {
                     const payload: TimeToSeeDataPayload = {
+                        team_id: values.currentTeamId,
                         type: 'dashboard_load',
                         context: 'dashboard',
                         action,
@@ -1138,20 +1176,8 @@ export const dashboardLogic = kea<dashboardLogicType>([
                         insights_fetched: insightsToRefresh.length,
                         insights_fetched_cached: 0,
                     }
-                    void captureTimeToSeeData(values.currentTeamId, {
-                        ...payload,
-                        is_primary_interaction: !initialLoad,
-                    })
-                    if (initialLoad) {
-                        const { startTime, responseBytes } = values.dashboardLoadTimerData
-                        void captureTimeToSeeData(values.currentTeamId, {
-                            ...payload,
-                            action: 'initial_load_full',
-                            time_to_see_data_ms: Math.floor(performance.now() - startTime),
-                            api_response_bytes: responseBytes + totalResponseBytes,
-                            is_primary_interaction: true,
-                        })
-                    }
+
+                    eventUsageLogic.actions.reportTimeToSeeData(payload)
                 }
             })
 
@@ -1218,37 +1244,8 @@ export const dashboardLogic = kea<dashboardLogicType>([
                 return // We hit a 404
             }
 
-            const dashboard = values.dashboard
-            const { action, dashboardQueryId, startTime, responseBytes } = values.dashboardLoadTimerData
-            const lastRefresh = sortDates(dashboard.tiles.map((tile) => tile.insight?.last_refresh || null))
-
-            const initialLoad = action === 'initial_load'
-            const allLoaded = false // TODO: Check this
-
-            actions.refreshAllDashboardItems({ action, initialLoad, dashboardQueryId })
-
-            const payload: TimeToSeeDataPayload = {
-                type: 'dashboard_load',
-                context: 'dashboard',
-                action,
-                primary_interaction_id: dashboardQueryId,
-                time_to_see_data_ms: Math.floor(performance.now() - startTime),
-                api_response_bytes: responseBytes,
-                insights_fetched: dashboard.tiles.length,
-                insights_fetched_cached: dashboard.tiles.reduce((acc, curr) => acc + (curr.is_cached ? 1 : 0), 0),
-                min_last_refresh: lastRefresh[0],
-                max_last_refresh: lastRefresh[lastRefresh.length - 1],
-                is_primary_interaction: !initialLoad,
-            }
-
-            void captureTimeToSeeData(values.currentTeamId, payload)
-            if (initialLoad && allLoaded) {
-                void captureTimeToSeeData(values.currentTeamId, {
-                    ...payload,
-                    action: 'initial_load_full',
-                    is_primary_interaction: true,
-                })
-            }
+            const { action, dashboardQueryId } = values.dashboardLoadTimerData
+            actions.refreshAllDashboardItems({ action, dashboardQueryId })
 
             if (values.shouldReportOnAPILoad) {
                 actions.setShouldReportOnAPILoad(false)
@@ -1288,7 +1285,8 @@ export const dashboardLogic = kea<dashboardLogicType>([
             // TRICKY: we cancel just once using the dashboard query id.
             // we can record the queryId that happened to capture the AbortError exception
             // and request the cancellation, but it is probably not particularly relevant
-            await captureTimeToSeeData(values.currentTeamId, {
+            eventUsageLogic.actions.reportTimeToSeeData({
+                team_id: values.currentTeamId,
                 type: 'insight_load',
                 context: 'dashboard',
                 primary_interaction_id: dashboardQueryId,
diff --git a/frontend/src/scenes/data-management/actions/ActionsTable.tsx b/frontend/src/scenes/data-management/actions/ActionsTable.tsx
index 17cb9f52f2643..ae3c059a6503c 100644
--- a/frontend/src/scenes/data-management/actions/ActionsTable.tsx
+++ b/frontend/src/scenes/data-management/actions/ActionsTable.tsx
@@ -188,7 +188,7 @@ export function ActionsTable(): JSX.Element {
                                     Duplicate
                                 </LemonButton>
                                 <LemonButton
-                                    to={urls.replay(ReplayTabs.Recent, {
+                                    to={urls.replay(ReplayTabs.Home, {
                                         filter_group: {
                                             type: FilterLogicalOperator.And,
                                             values: [
diff --git a/frontend/src/scenes/data-management/definition/DefinitionView.tsx b/frontend/src/scenes/data-management/definition/DefinitionView.tsx
index 57936949c2f22..d13d77b55543e 100644
--- a/frontend/src/scenes/data-management/definition/DefinitionView.tsx
+++ b/frontend/src/scenes/data-management/definition/DefinitionView.tsx
@@ -55,7 +55,7 @@ export function DefinitionView(props: DefinitionLogicProps = {}): JSX.Element {
                         {isEvent && (
                             <LemonButton
                                 type="secondary"
-                                to={urls.replay(ReplayTabs.Recent, {
+                                to={urls.replay(ReplayTabs.Home, {
                                     filter_group: {
                                         type: FilterLogicalOperator.And,
                                         values: [
diff --git a/frontend/src/scenes/data-management/events/EventDefinitionsTable.tsx b/frontend/src/scenes/data-management/events/EventDefinitionsTable.tsx
index b174429cc64b3..f8e69bc68c6e2 100644
--- a/frontend/src/scenes/data-management/events/EventDefinitionsTable.tsx
+++ b/frontend/src/scenes/data-management/events/EventDefinitionsTable.tsx
@@ -87,7 +87,7 @@ export function EventDefinitionsTable(): JSX.Element {
                         overlay={
                             <>
                                 <LemonButton
-                                    to={urls.replay(ReplayTabs.Recent, {
+                                    to={urls.replay(ReplayTabs.Home, {
                                         filter_group: {
                                             type: FilterLogicalOperator.And,
                                             values: [
diff --git a/frontend/src/scenes/early-access-features/EarlyAccessFeature.tsx b/frontend/src/scenes/early-access-features/EarlyAccessFeature.tsx
index cabd132c21809..4bfe2200d9b59 100644
--- a/frontend/src/scenes/early-access-features/EarlyAccessFeature.tsx
+++ b/frontend/src/scenes/early-access-features/EarlyAccessFeature.tsx
@@ -493,7 +493,7 @@ function PersonsTableByFilter({ recordingsFilters, properties }: PersonsTableByF
             <div className="absolute top-0 right-0 z-10">
                 <LemonButton
                     key="view-opt-in-session-recordings"
-                    to={urls.replay(ReplayTabs.Recent, recordingsFilters)}
+                    to={urls.replay(ReplayTabs.Home, recordingsFilters)}
                     type="secondary"
                 >
                     View recordings
diff --git a/frontend/src/scenes/error-tracking/ErrorTracking.stories.tsx b/frontend/src/scenes/error-tracking/ErrorTracking.stories.tsx
index de359b37aac9d..348dc537034fd 100644
--- a/frontend/src/scenes/error-tracking/ErrorTracking.stories.tsx
+++ b/frontend/src/scenes/error-tracking/ErrorTracking.stories.tsx
@@ -5,8 +5,9 @@ import { App } from 'scenes/App'
 import { urls } from 'scenes/urls'
 
 import { mswDecorator } from '~/mocks/browser'
+import { NodeKind } from '~/queries/schema'
 
-import { errorTrackingGroupQueryResponse, errorTrackingQueryResponse } from './__mocks__/error_tracking_query'
+import { errorTrackingEventsQueryResponse, errorTrackingQueryResponse } from './__mocks__/error_tracking_query'
 import { stringifiedFingerprint } from './utils'
 
 const meta: Meta = {
@@ -21,10 +22,10 @@ const meta: Meta = {
             post: {
                 '/api/projects/:team_id/query': async (req, res, ctx) => {
                     const query = (await req.clone().json()).query
-                    if (query.fingerprint) {
-                        return res(ctx.json(errorTrackingGroupQueryResponse))
+                    if (query.kind === NodeKind.ErrorTrackingQuery) {
+                        return res(ctx.json(errorTrackingQueryResponse))
                     }
-                    return res(ctx.json(errorTrackingQueryResponse))
+                    return res(ctx.json(errorTrackingEventsQueryResponse))
                 },
             },
         }),
diff --git a/frontend/src/scenes/error-tracking/__mocks__/error_tracking_query.ts b/frontend/src/scenes/error-tracking/__mocks__/error_tracking_query.ts
index b69d479cf1acb..50fd5d545853c 100644
--- a/frontend/src/scenes/error-tracking/__mocks__/error_tracking_query.ts
+++ b/frontend/src/scenes/error-tracking/__mocks__/error_tracking_query.ts
@@ -9,7 +9,7 @@ const eventProperties = JSON.stringify({
     distinct_id: 'person_id',
     $exception_message: "Cannot read properties of undefined (reading 'onLCP')",
     $exception_type: 'TypeError',
-    $exception_fingerprint: 'TypeError',
+    $exception_fingerprint: ['TypeError'],
     $exception_personURL: 'https://us.posthog.com/project/:id/person/:person_id',
     $exception_level: 'error',
     $sentry_event_id: '790b4d4b9ec6430fb88f18ba2dc7e7c4',
@@ -89,13 +89,13 @@ const errorTrackingQueryResponse = {
     columns: ['occurrences', 'sessions', 'users', 'last_seen', 'first_seen', 'description', 'fingerprint', 'volume'],
     hasMore: false,
     results: [
-        { type: 'TypeError', occurrences: 1000, sessions: 750, users: 500 },
-        { type: 'SyntaxError', occurrences: 800, sessions: 200, users: 50 },
-        { type: 'Error', occurrences: 6, sessions: 3, users: 1 },
-    ].map(({ type, occurrences, sessions, users }) => ({
+        { fingerprint: ['TypeError'], occurrences: 1000, sessions: 750, users: 500 },
+        { fingerprint: ['SyntaxError'], occurrences: 800, sessions: 200, users: 50 },
+        { fingerprint: ['Error'], occurrences: 6, sessions: 3, users: 1 },
+    ].map(({ fingerprint, occurrences, sessions, users }) => ({
         assignee: null,
-        description: `This is a ${type} error`,
-        fingerprint: type,
+        description: `This is a ${fingerprint} error`,
+        fingerprint: fingerprint,
         first_seen: '2023-07-07T00:00:00.000000-00:00',
         last_seen: '2024-07-07T00:00:00.000000-00:00',
         merged_fingerprints: [],
@@ -124,35 +124,20 @@ const errorTrackingQueryResponse = {
     })),
 }
 
-const errorTrackingGroupQueryResponse = {
+const errorTrackingEventsQueryResponse = {
     columns: ['uuid', 'properties', 'timestamp', 'person'],
     hasMore: false,
-    results: [
+    results: range(20).map((index) => [
+        `event_uuid_${index}`,
+        eventProperties,
+        '2024-07-07T00:00:00.000000-00:00',
         {
-            assignee: null,
-            description: `This is a SyntaxError error`,
-            fingerprint: 'SyntaxError',
-            first_seen: '2023-07-07T00:00:00.000000-00:00',
-            last_seen: '2024-07-07T00:00:00.000000-00:00',
-            merged_fingerprints: [],
-            occurrences: 1000,
-            sessions: 500,
-            users: 100,
-            status: 'active',
-            volume: null,
-            events: range(20).map((index) => ({
-                uuid: `event_uuid_${index}`,
-                properties: eventProperties,
-                timestamp: '2024-07-07T00:00:00.000000-00:00',
-                person: {
-                    created_at: '2024-04-05T21:14:16.048000Z',
-                    distinct_id: 'BTQiT390vxwlLeDSwZAZpXC7r7bkNc3TQuhobit0oj7',
-                    properties: { email: 'test@example.com' },
-                    uuid: 'person_uuid',
-                },
-            })),
+            created_at: '2024-04-05T21:14:16.048000Z',
+            distinct_id: 'BTQiT390vxwlLeDSwZAZpXC7r7bkNc3TQuhobit0oj7',
+            properties: { email: 'test@example.com' },
+            uuid: 'person_uuid',
         },
-    ],
+    ]),
 }
 
-export { errorTrackingGroupQueryResponse, errorTrackingQueryResponse }
+export { errorTrackingEventsQueryResponse, errorTrackingQueryResponse }
diff --git a/frontend/src/scenes/error-tracking/errorTrackingGroupSceneLogic.ts b/frontend/src/scenes/error-tracking/errorTrackingGroupSceneLogic.ts
index ef892de0d9bee..af9ba29f04255 100644
--- a/frontend/src/scenes/error-tracking/errorTrackingGroupSceneLogic.ts
+++ b/frontend/src/scenes/error-tracking/errorTrackingGroupSceneLogic.ts
@@ -1,7 +1,8 @@
-import { actions, afterMount, connect, kea, path, props, reducers, selectors } from 'kea'
+import { actions, afterMount, connect, kea, listeners, path, props, reducers, selectors } from 'kea'
 import { loaders } from 'kea-loaders'
 import { actionToUrl, router, urlToAction } from 'kea-router'
 import api from 'lib/api'
+import { Dayjs, dayjs } from 'lib/dayjs'
 import { Scene } from 'scenes/sceneTypes'
 import { urls } from 'scenes/urls'
 
@@ -10,21 +11,12 @@ import { Breadcrumb } from '~/types'
 
 import type { errorTrackingGroupSceneLogicType } from './errorTrackingGroupSceneLogicType'
 import { errorTrackingLogic } from './errorTrackingLogic'
-import { errorTrackingGroupQuery } from './queries'
+import { errorTrackingGroupEventsQuery, errorTrackingGroupQuery } from './queries'
 
-export interface ErrorTrackingGroupSceneLogicProps {
-    fingerprint: string[]
-}
-
-export enum ErrorGroupTab {
-    Overview = 'overview',
-    Breakdowns = 'breakdowns',
-}
-
-export type ErrorTrackingGroupEvent = {
+export interface ErrorTrackingEvent {
     uuid: string
-    properties: string
-    timestamp: string
+    timestamp: Dayjs
+    properties: Record<string, any>
     person: {
         distinct_id: string
         uuid?: string
@@ -33,6 +25,15 @@ export type ErrorTrackingGroupEvent = {
     }
 }
 
+export interface ErrorTrackingGroupSceneLogicProps {
+    fingerprint: ErrorTrackingGroup['fingerprint']
+}
+
+export enum ErrorGroupTab {
+    Overview = 'overview',
+    Breakdowns = 'breakdowns',
+}
+
 export const errorTrackingGroupSceneLogic = kea<errorTrackingGroupSceneLogicType>([
     path((key) => ['scenes', 'error-tracking', 'errorTrackingGroupSceneLogic', key]),
     props({} as ErrorTrackingGroupSceneLogicProps),
@@ -43,6 +44,7 @@ export const errorTrackingGroupSceneLogic = kea<errorTrackingGroupSceneLogicType
 
     actions({
         setErrorGroupTab: (tab: ErrorGroupTab) => ({ tab }),
+        setActiveEventUUID: (uuid: ErrorTrackingEvent['uuid']) => ({ uuid }),
     }),
 
     reducers(() => ({
@@ -52,6 +54,12 @@ export const errorTrackingGroupSceneLogic = kea<errorTrackingGroupSceneLogicType
                 setErrorGroupTab: (_, { tab }) => tab,
             },
         ],
+        activeEventUUID: [
+            undefined as ErrorTrackingEvent['uuid'] | undefined,
+            {
+                setActiveEventUUID: (_, { uuid }) => uuid,
+            },
+        ],
     })),
 
     loaders(({ props, values }) => ({
@@ -74,6 +82,43 @@ export const errorTrackingGroupSceneLogic = kea<errorTrackingGroupSceneLogicType
                 },
             },
         ],
+        events: [
+            [] as ErrorTrackingEvent[],
+            {
+                loadEvents: async () => {
+                    const response = await api.query(
+                        errorTrackingGroupEventsQuery({
+                            select: ['uuid', 'properties', 'timestamp', 'person'],
+                            fingerprints: values.combinedFingerprints,
+                            dateRange: values.dateRange,
+                            filterTestAccounts: values.filterTestAccounts,
+                            filterGroup: values.filterGroup,
+                            offset: values.events.length,
+                        })
+                    )
+
+                    const newResults = response.results.map((r) => ({
+                        uuid: r[0],
+                        properties: JSON.parse(r[1]),
+                        timestamp: dayjs(r[2]),
+                        person: r[3],
+                    }))
+
+                    return [...values.events, ...newResults]
+                },
+            },
+        ],
+    })),
+
+    listeners(({ values, actions }) => ({
+        loadGroupSuccess: () => {
+            actions.loadEvents()
+        },
+        loadEventsSuccess: () => {
+            if (!values.activeEventUUID) {
+                actions.setActiveEventUUID(values.events[0]?.uuid)
+            }
+        },
     })),
 
     selectors({
@@ -95,7 +140,11 @@ export const errorTrackingGroupSceneLogic = kea<errorTrackingGroupSceneLogicType
             },
         ],
 
-        events: [(s) => [s.group], (group) => (group?.events || []) as ErrorTrackingGroupEvent[]],
+        combinedFingerprints: [
+            (s) => [s.group],
+            (group): ErrorTrackingGroup['fingerprint'][] =>
+                group ? [group.fingerprint, ...group.merged_fingerprints] : [],
+        ],
     }),
 
     actionToUrl(({ values }) => ({
diff --git a/frontend/src/scenes/error-tracking/groups/OverviewTab.tsx b/frontend/src/scenes/error-tracking/groups/OverviewTab.tsx
index 7f74758bc4d3f..323bbdf3da110 100644
--- a/frontend/src/scenes/error-tracking/groups/OverviewTab.tsx
+++ b/frontend/src/scenes/error-tracking/groups/OverviewTab.tsx
@@ -1,26 +1,25 @@
 import { PersonDisplay, TZLabel } from '@posthog/apps-common'
-import { LemonButton, Spinner } from '@posthog/lemon-ui'
+import { LemonButton } from '@posthog/lemon-ui'
 import clsx from 'clsx'
 import { useActions, useValues } from 'kea'
 import { EmptyMessage } from 'lib/components/EmptyMessage/EmptyMessage'
 import { ErrorDisplay } from 'lib/components/Errors/ErrorDisplay'
-import { NotFound } from 'lib/components/NotFound'
 import { Playlist } from 'lib/components/Playlist/Playlist'
 import { dayjs } from 'lib/dayjs'
 import { sessionPlayerModalLogic } from 'scenes/session-recordings/player/modal/sessionPlayerModalLogic'
 import { PropertyIcons } from 'scenes/session-recordings/playlist/SessionRecordingPreview'
 
-import { ErrorTrackingGroupEvent, errorTrackingGroupSceneLogic } from '../errorTrackingGroupSceneLogic'
+import { ErrorTrackingEvent, errorTrackingGroupSceneLogic } from '../errorTrackingGroupSceneLogic'
 
 export const OverviewTab = (): JSX.Element => {
-    const { group, events, groupLoading } = useValues(errorTrackingGroupSceneLogic)
+    const { events, groupLoading, eventsLoading, activeEventUUID } = useValues(errorTrackingGroupSceneLogic)
+    const { loadEvents, setActiveEventUUID } = useActions(errorTrackingGroupSceneLogic)
 
-    return groupLoading ? (
-        <Spinner className="self-align-center justify-self-center" />
-    ) : group ? (
+    return (
         <div className="ErrorTracking__group">
             <div className="h-full space-y-2">
                 <Playlist
+                    loading={groupLoading || eventsLoading}
                     title="Exceptions"
                     sections={[
                         {
@@ -30,6 +29,10 @@ export const OverviewTab = (): JSX.Element => {
                             render: ListItemException,
                         },
                     ]}
+                    onSelect={({ uuid }) => {
+                        setActiveEventUUID(uuid)
+                    }}
+                    activeItemId={activeEventUUID}
                     listEmptyState={<div className="flex justify-center p-4">No exceptions found</div>}
                     content={({ activeItem: event }) =>
                         event ? (
@@ -38,7 +41,7 @@ export const OverviewTab = (): JSX.Element => {
                                     <ViewSessionButton event={event} />
                                 </div>
                                 <div className="pl-2">
-                                    <ErrorDisplay eventProperties={JSON.parse(event.properties)} />
+                                    <ErrorDisplay eventProperties={event.properties} />
                                 </div>
                             </div>
                         ) : (
@@ -48,30 +51,30 @@ export const OverviewTab = (): JSX.Element => {
                             />
                         )
                     }
-                    selectInitialItem
+                    onScrollListEdge={(edge) => {
+                        if (edge === 'bottom' && !eventsLoading) {
+                            loadEvents()
+                        }
+                    }}
                 />
             </div>
         </div>
-    ) : (
-        <NotFound object="exception" />
     )
 }
 
-const ViewSessionButton = ({ event }: { event: ErrorTrackingGroupEvent }): JSX.Element | null => {
+const ViewSessionButton = ({ event }: { event: ErrorTrackingEvent }): JSX.Element | null => {
     const { openSessionPlayer } = useActions(sessionPlayerModalLogic)
 
-    const properties = JSON.parse(event.properties)
+    const sessionId = event.properties.$session_id
 
     return (
         <LemonButton
             size="small"
             onClick={() => {
                 const fiveSecondsBeforeEvent = dayjs(event.timestamp).valueOf() - 5000
-                openSessionPlayer({ id: properties.$session_id }, Math.max(fiveSecondsBeforeEvent, 0))
+                openSessionPlayer({ id: sessionId }, Math.max(fiveSecondsBeforeEvent, 0))
             }}
-            disabledReason={
-                !properties.$session_id ? 'There was no $session_id associated with this exception' : undefined
-            }
+            disabledReason={!sessionId ? 'There was no Session ID associated with this exception' : undefined}
         >
             View recording
         </LemonButton>
@@ -79,14 +82,12 @@ const ViewSessionButton = ({ event }: { event: ErrorTrackingGroupEvent }): JSX.E
 }
 
 const ListItemException = ({
-    item: event,
+    item: { timestamp, properties, person },
     isActive,
 }: {
-    item: ErrorTrackingGroupEvent
+    item: ErrorTrackingEvent
     isActive: boolean
 }): JSX.Element => {
-    const properties = JSON.parse(event.properties)
-
     const recordingProperties = ['$browser', '$device_type', '$os']
         .flatMap((property) => {
             let value = properties[property]
@@ -100,17 +101,22 @@ const ListItemException = ({
         .filter((property) => !!property.value)
 
     return (
-        <div className={clsx('cursor-pointer p-2 space-y-1', isActive && 'border-l-4 border-primary-3000')}>
+        <div
+            className={clsx(
+                'cursor-pointer p-2 space-y-1 border-l-4',
+                isActive ? 'border-primary-3000' : 'border-transparent'
+            )}
+        >
             <div className="flex justify-between items-center space-x-3">
                 <div className="line-clamp-1">
-                    <PersonDisplay person={event.person} withIcon noPopover noLink />
+                    <PersonDisplay person={person} withIcon noPopover noLink />
                 </div>
                 <PropertyIcons recordingProperties={recordingProperties} iconClassNames="text-muted" />
             </div>
             {properties.$current_url && <div className="text-xs text-muted truncate">{properties.$current_url}</div>}
             <TZLabel
                 className="overflow-hidden text-ellipsis text-xs text-muted shrink-0"
-                time={event.timestamp}
+                time={timestamp}
                 placement="right"
                 showPopover={false}
             />
diff --git a/frontend/src/scenes/error-tracking/queries.ts b/frontend/src/scenes/error-tracking/queries.ts
index eaba43b079f74..41d843041ce2f 100644
--- a/frontend/src/scenes/error-tracking/queries.ts
+++ b/frontend/src/scenes/error-tracking/queries.ts
@@ -2,7 +2,15 @@ import { UniversalFiltersGroup } from 'lib/components/UniversalFilters/Universal
 import { dayjs } from 'lib/dayjs'
 import { range } from 'lib/utils'
 
-import { DataTableNode, DateRange, ErrorTrackingQuery, InsightVizNode, NodeKind } from '~/queries/schema'
+import {
+    DataTableNode,
+    DateRange,
+    ErrorTrackingGroup,
+    ErrorTrackingQuery,
+    EventsQuery,
+    InsightVizNode,
+    NodeKind,
+} from '~/queries/schema'
 import { AnyPropertyFilter, BaseMathType, ChartDisplayType, PropertyGroupFilter } from '~/types'
 
 export type SparklineConfig = {
@@ -124,7 +132,6 @@ export const errorTrackingGroupQuery = ({
 }): ErrorTrackingQuery => {
     return {
         kind: NodeKind.ErrorTrackingQuery,
-        eventColumns: ['uuid', 'properties', 'timestamp', 'person'],
         fingerprint: fingerprint,
         dateRange: dateRange,
         filterGroup: filterGroup as PropertyGroupFilter,
@@ -132,6 +139,60 @@ export const errorTrackingGroupQuery = ({
     }
 }
 
+export const errorTrackingGroupEventsQuery = ({
+    select,
+    fingerprints,
+    dateRange,
+    filterTestAccounts,
+    filterGroup,
+    offset,
+}: {
+    select: string[]
+    fingerprints: ErrorTrackingGroup['fingerprint'][]
+    dateRange: DateRange
+    filterTestAccounts: boolean
+    filterGroup: UniversalFiltersGroup
+    offset: number
+}): EventsQuery => {
+    const group = filterGroup.values[0] as UniversalFiltersGroup
+    const properties = group.values as AnyPropertyFilter[]
+
+    const where = [
+        `has(${stringifyFingerprints(
+            fingerprints
+        )}, JSONExtract(ifNull(properties.$exception_fingerprint,'[]'),'Array(String)'))`,
+    ]
+
+    const query: EventsQuery = {
+        kind: NodeKind.EventsQuery,
+        event: '$exception',
+        select,
+        where,
+        properties,
+        filterTestAccounts: filterTestAccounts,
+        offset: offset,
+        limit: 50,
+    }
+
+    if (dateRange.date_from) {
+        query.after = dateRange.date_from
+    }
+    if (dateRange.date_to) {
+        query.before = dateRange.date_to
+    }
+
+    return query
+}
+
+// JSON.stringify wraps strings in double quotes and HogQL only supports single quote strings
+const stringifyFingerprints = (fingerprints: ErrorTrackingGroup['fingerprint'][]): string => {
+    const stringifiedFingerprints = fingerprints.map((fp) => {
+        const stringifiedParts = fp.map((s) => `'${s}'`)
+        return `[${stringifiedParts.join(',')}]`
+    })
+    return `[${stringifiedFingerprints.join(',')}]`
+}
+
 export const errorTrackingGroupBreakdownQuery = ({
     breakdownProperty,
     dateRange,
diff --git a/frontend/src/scenes/experiments/ExperimentView/components.tsx b/frontend/src/scenes/experiments/ExperimentView/components.tsx
index 1db1f9b9d93ad..476ea2fa613fe 100644
--- a/frontend/src/scenes/experiments/ExperimentView/components.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/components.tsx
@@ -274,13 +274,33 @@ export function NoResultsEmptyState(): JSX.Element {
         )
     }
 
-    // Non-400 errors are rendered as plain text
+    if (experimentResultCalculationError?.statusCode === 504) {
+        return (
+            <div>
+                <div className="border rounded bg-bg-light py-10">
+                    <div className="flex flex-col items-center mx-auto text-muted space-y-2">
+                        <IconArchive className="text-4xl text-secondary-3000" />
+                        <h2 className="text-xl font-semibold leading-tight">Experiment results timed out</h2>
+                        {!!experimentResultCalculationError && (
+                            <div className="text-sm text-center text-balance">
+                                This may occur when the experiment has a large amount of data or is particularly
+                                complex. We are actively working on fixing this. In the meantime, please try refreshing
+                                the experiment to retrieve the results.
+                            </div>
+                        )}
+                    </div>
+                </div>
+            </div>
+        )
+    }
+
+    // Other unexpected errors
     return (
         <div>
             <div className="border rounded bg-bg-light py-10">
                 <div className="flex flex-col items-center mx-auto text-muted space-y-2">
                     <IconArchive className="text-4xl text-secondary-3000" />
-                    <h2 className="text-xl font-semibold leading-tight">There are no experiment results yet</h2>
+                    <h2 className="text-xl font-semibold leading-tight">Experiment results could not be calculated</h2>
                     {!!experimentResultCalculationError && (
                         <div className="text-sm text-center text-balance">
                             {experimentResultCalculationError.detail}
diff --git a/frontend/src/scenes/experiments/Experiments.tsx b/frontend/src/scenes/experiments/Experiments.tsx
index 484e3bdf7cfd3..a8ded04da8f00 100644
--- a/frontend/src/scenes/experiments/Experiments.tsx
+++ b/frontend/src/scenes/experiments/Experiments.tsx
@@ -35,7 +35,7 @@ export function Experiments(): JSX.Element {
         useActions(experimentsLogic)
 
     const EXPERIMENTS_PRODUCT_DESCRIPTION =
-        'A/B testing help you test changes to your product to see which changes will lead to optimal results. Automatic statistical calculations let you see if the results are valid or if they are likely just a chance occurrence.'
+        'Experiments help you test changes to your product to see which changes will lead to optimal results. Automatic statistical calculations let you see if the results are valid or if they are likely just a chance occurrence.'
 
     const getExperimentDuration = (experiment: Experiment): number | undefined => {
         return experiment.end_date
@@ -213,7 +213,7 @@ export function Experiments(): JSX.Element {
             />
             {tab === ExperimentsTabs.Archived ? (
                 <ProductIntroduction
-                    productName="A/B testing"
+                    productName="Experiments"
                     productKey={ProductKey.EXPERIMENTS}
                     thingName="archived experiment"
                     description={EXPERIMENTS_PRODUCT_DESCRIPTION}
@@ -222,7 +222,7 @@ export function Experiments(): JSX.Element {
                 />
             ) : (
                 <ProductIntroduction
-                    productName="A/B testing"
+                    productName="Experiments"
                     productKey={ProductKey.EXPERIMENTS}
                     thingName="experiment"
                     description={EXPERIMENTS_PRODUCT_DESCRIPTION}
diff --git a/frontend/src/scenes/feature-flags/FeatureFlag.tsx b/frontend/src/scenes/feature-flags/FeatureFlag.tsx
index 3467ddeba97e6..26c00e46ad9e9 100644
--- a/frontend/src/scenes/feature-flags/FeatureFlag.tsx
+++ b/frontend/src/scenes/feature-flags/FeatureFlag.tsx
@@ -533,7 +533,7 @@ export function FeatureFlag({ id }: { id?: string } = {}): JSX.Element {
                                             overlay={
                                                 <>
                                                     <LemonButton
-                                                        to={urls.replay(ReplayTabs.Recent, recordingFilterForFlag)}
+                                                        to={urls.replay(ReplayTabs.Home, recordingFilterForFlag)}
                                                         fullWidth
                                                     >
                                                         View Recordings
@@ -787,7 +787,7 @@ function FeatureFlagRollout({ readOnly }: { readOnly?: boolean }): JSX.Element {
                         <span className="card-secondary mt-4">Type</span>
                         <span>
                             {featureFlag.filters.multivariate
-                                ? 'Multiple variants with rollout percentages (A/B/C test)'
+                                ? 'Multiple variants with rollout percentages (A/B/n test)'
                                 : 'Release toggle (boolean)'}
                         </span>
 
@@ -868,7 +868,7 @@ function FeatureFlagRollout({ readOnly }: { readOnly?: boolean }): JSX.Element {
                                             : undefined,
                                 },
                                 {
-                                    label: <span>Multiple variants with rollout percentages (A/B test)</span>,
+                                    label: <span>Multiple variants with rollout percentages (A/B/n test)</span>,
                                     value: 'multivariate',
                                 },
                             ]}
diff --git a/frontend/src/scenes/heatmaps/HeatmapsBrowser.tsx b/frontend/src/scenes/heatmaps/HeatmapsBrowser.tsx
index b36d822503feb..3b83a4ef79f20 100644
--- a/frontend/src/scenes/heatmaps/HeatmapsBrowser.tsx
+++ b/frontend/src/scenes/heatmaps/HeatmapsBrowser.tsx
@@ -5,8 +5,8 @@ import { AuthorizedUrlList } from 'lib/components/AuthorizedUrlList/AuthorizedUr
 import { appEditorUrl, AuthorizedUrlListType } from 'lib/components/AuthorizedUrlList/authorizedUrlListLogic'
 import { DateFilter } from 'lib/components/DateFilter/DateFilter'
 import { HeatmapsSettings } from 'lib/components/heatmaps/HeatMapsSettings'
-import { heatmapDateOptions } from 'lib/components/heatmaps/utils'
 import { DetectiveHog } from 'lib/components/hedgehogs'
+import { heatmapDateOptions } from 'lib/components/IframedToolbarBrowser/utils'
 import { useResizeObserver } from 'lib/hooks/useResizeObserver'
 import { IconChevronRight, IconOpenInNew } from 'lib/lemon-ui/icons'
 import React, { useEffect, useRef } from 'react'
diff --git a/frontend/src/scenes/heatmaps/heatmapsBrowserLogic.ts b/frontend/src/scenes/heatmaps/heatmapsBrowserLogic.ts
index acc981688c5bf..902d9a639b72a 100644
--- a/frontend/src/scenes/heatmaps/heatmapsBrowserLogic.ts
+++ b/frontend/src/scenes/heatmaps/heatmapsBrowserLogic.ts
@@ -4,7 +4,11 @@ import { actionToUrl, router, urlToAction } from 'kea-router'
 import api from 'lib/api'
 import { authorizedUrlListLogic, AuthorizedUrlListType } from 'lib/components/AuthorizedUrlList/authorizedUrlListLogic'
 import { CommonFilters, HeatmapFilters, HeatmapFixedPositionMode } from 'lib/components/heatmaps/types'
-import { calculateViewportRange, DEFAULT_HEATMAP_FILTERS, PostHogAppToolbarEvent } from 'lib/components/heatmaps/utils'
+import {
+    calculateViewportRange,
+    DEFAULT_HEATMAP_FILTERS,
+    PostHogAppToolbarEvent,
+} from 'lib/components/IframedToolbarBrowser/utils'
 import { LemonBannerProps } from 'lib/lemon-ui/LemonBanner'
 import { objectsEqual } from 'lib/utils'
 import posthog from 'posthog-js'
diff --git a/frontend/src/scenes/insights/insightDataTimingLogic.ts b/frontend/src/scenes/insights/insightDataTimingLogic.ts
index 22d6558d43b42..8b4eaa61410c0 100644
--- a/frontend/src/scenes/insights/insightDataTimingLogic.ts
+++ b/frontend/src/scenes/insights/insightDataTimingLogic.ts
@@ -1,5 +1,5 @@
 import { actions, connect, kea, key, listeners, path, props, reducers } from 'kea'
-import { captureTimeToSeeData } from 'lib/internalMetrics'
+import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
 import { teamLogic } from 'scenes/teamLogic'
 
 import { dataNodeLogic, DataNodeLogicProps } from '~/queries/nodes/DataNode/dataNodeLogic'
@@ -24,6 +24,7 @@ export const insightDataTimingLogic = kea<insightDataTimingLogicType>([
             dataNodeLogic({ key: insightVizDataNodeKey(props) } as DataNodeLogicProps),
             ['loadData', 'loadDataSuccess', 'loadDataFailure', 'abortQuery as loadDataCancellation'],
         ],
+        logic: [eventUsageLogic],
     })),
     actions({
         startQuery: (queryId: string) => ({ queryId }),
@@ -52,7 +53,9 @@ export const insightDataTimingLogic = kea<insightDataTimingLogicType>([
             }
 
             const duration = performance.now() - values.queryStartTimes[payload.queryId]
-            void captureTimeToSeeData(values.currentTeamId, {
+
+            eventUsageLogic.actions.reportTimeToSeeData({
+                team_id: values.currentTeamId,
                 type: 'insight_load',
                 context: 'insight',
                 primary_interaction_id: payload.queryId,
@@ -76,7 +79,8 @@ export const insightDataTimingLogic = kea<insightDataTimingLogicType>([
             }
 
             const duration = performance.now() - values.queryStartTimes[errorObject.queryId]
-            void captureTimeToSeeData(values.currentTeamId, {
+            eventUsageLogic.actions.reportTimeToSeeData({
+                team_id: values.currentTeamId,
                 type: 'insight_load',
                 context: 'insight',
                 primary_interaction_id: errorObject.queryId,
@@ -95,7 +99,8 @@ export const insightDataTimingLogic = kea<insightDataTimingLogicType>([
         },
         loadDataCancellation: (payload) => {
             const duration = performance.now() - values.queryStartTimes[payload.queryId]
-            void captureTimeToSeeData(values.currentTeamId, {
+            eventUsageLogic.actions.reportTimeToSeeData({
+                team_id: values.currentTeamId,
                 type: 'insight_load',
                 context: 'insight',
                 primary_interaction_id: payload.queryId,
diff --git a/frontend/src/scenes/insights/views/LineGraph/LineGraph.tsx b/frontend/src/scenes/insights/views/LineGraph/LineGraph.tsx
index 3334e3958017c..c7451e76c2c0f 100644
--- a/frontend/src/scenes/insights/views/LineGraph/LineGraph.tsx
+++ b/frontend/src/scenes/insights/views/LineGraph/LineGraph.tsx
@@ -749,7 +749,7 @@ export function LineGraph_({
                                     d.compareLabels?.[i],
                                 ]
                             } else if (d.breakdownLabels?.[i]) {
-                                labelDescriptors = [d.breakdownLabels[i], d.compareLabels?.[i]]
+                                labelDescriptors = [d.actions?.[i]?.name, d.breakdownLabels[i], d.compareLabels?.[i]]
                             } else if (d.labels?.[i]) {
                                 labelDescriptors = [d.labels[i], d.compareLabels?.[i]]
                             } else {
diff --git a/frontend/src/scenes/moveToPostHogCloud/MoveToPostHogCloud.tsx b/frontend/src/scenes/moveToPostHogCloud/MoveToPostHogCloud.tsx
index 8d0ff1dabfdb6..7b2557d6986cd 100644
--- a/frontend/src/scenes/moveToPostHogCloud/MoveToPostHogCloud.tsx
+++ b/frontend/src/scenes/moveToPostHogCloud/MoveToPostHogCloud.tsx
@@ -68,7 +68,7 @@ const CLOUD_FEATURES: CloudFeature[] = [
     {
         name: 'Access to all features',
         description:
-            'Group analytics, data pipelines, A/B testing, and other premium features are only available on PostHog Cloud.',
+            'Group analytics, data pipelines, experiments, and other premium features are only available on PostHog Cloud.',
         icon: <IconFeatures />,
         link: 'https://posthog.com/pricing',
     },
diff --git a/frontend/src/scenes/notebooks/Nodes/NotebookNodePlaylist.tsx b/frontend/src/scenes/notebooks/Nodes/NotebookNodePlaylist.tsx
index b97ddaca04e92..c9604e6f80623 100644
--- a/frontend/src/scenes/notebooks/Nodes/NotebookNodePlaylist.tsx
+++ b/frontend/src/scenes/notebooks/Nodes/NotebookNodePlaylist.tsx
@@ -150,7 +150,7 @@ export const NotebookNodePlaylist = createPostHogWidgetNode<NotebookNodePlaylist
         },
     },
     pasteOptions: {
-        find: urls.replay(ReplayTabs.Recent) + '(.*)',
+        find: urls.replay(ReplayTabs.Home) + '(.*)',
         getAttributes: async (match) => {
             const url = new URL(match[0])
             const stringifiedFilters = url.searchParams.get('filters')
diff --git a/frontend/src/scenes/onboarding/OnboardingStep.tsx b/frontend/src/scenes/onboarding/OnboardingStep.tsx
index 9472c266d0f3a..963b5834b0390 100644
--- a/frontend/src/scenes/onboarding/OnboardingStep.tsx
+++ b/frontend/src/scenes/onboarding/OnboardingStep.tsx
@@ -22,6 +22,7 @@ export const OnboardingStep = ({
     continueOverride,
     hideHeader,
     breadcrumbHighlightName,
+    fullWidth = false,
 }: {
     stepKey: OnboardingStepKey
     title: string
@@ -35,6 +36,7 @@ export const OnboardingStep = ({
     continueOverride?: JSX.Element
     hideHeader?: boolean
     breadcrumbHighlightName?: OnboardingStepKey
+    fullWidth?: boolean
 }): JSX.Element => {
     const { hasNextStep, onboardingStepKeys, currentOnboardingStep } = useValues(onboardingLogic)
     const { completeOnboarding, goToNextStep, setStepKey } = useActions(onboardingLogic)
@@ -78,13 +80,21 @@ export const OnboardingStep = ({
                             )
                         })}
                     </div>
-                    <h1 className="font-bold m-0 mt-3 px-2">
+                    <h1 className={`font-bold m-0 mt-3 px-2 ${fullWidth && 'text-center'}`}>
                         {title || stepKeyToTitle(currentOnboardingStep?.props.stepKey)}
                     </h1>
                 </div>
             </div>
-            <div className={`${stepKey !== 'product_intro' && 'p-2 max-w-screen-md mx-auto'}`}>
-                {subtitle && <p>{subtitle}</p>}
+            <div
+                className={`${stepKey !== 'product_intro' && 'p-2'} ${
+                    stepKey !== 'product_intro' && !fullWidth && 'max-w-screen-md mx-auto'
+                }`}
+            >
+                {subtitle && (
+                    <div className="max-w-screen-md mx-auto">
+                        <p>{subtitle}</p>
+                    </div>
+                )}
                 {children}
                 <div className="mt-8 flex justify-end gap-x-2">
                     {showHelpButton && (
diff --git a/frontend/src/scenes/onboarding/onboardingLogic.tsx b/frontend/src/scenes/onboarding/onboardingLogic.tsx
index 6a637b81ee33e..3446001b5f37f 100644
--- a/frontend/src/scenes/onboarding/onboardingLogic.tsx
+++ b/frontend/src/scenes/onboarding/onboardingLogic.tsx
@@ -62,7 +62,7 @@ export const availableOnboardingProducts: AvailableOnboardingProducts = {
         scene: Scene.Replay,
     },
     [ProductKey.FEATURE_FLAGS]: {
-        name: 'Feature Flags & A/B Testing',
+        name: 'Feature Flags & Experiments',
         breadcrumbsName: 'Feature Flags',
         icon: 'IconToggle',
         iconColor: 'seagreen',
diff --git a/frontend/src/scenes/onboarding/productAnalyticsSteps/DashboardTemplateConfigureStep.tsx b/frontend/src/scenes/onboarding/productAnalyticsSteps/DashboardTemplateConfigureStep.tsx
index cc3878fed6474..1f67ee2abd399 100644
--- a/frontend/src/scenes/onboarding/productAnalyticsSteps/DashboardTemplateConfigureStep.tsx
+++ b/frontend/src/scenes/onboarding/productAnalyticsSteps/DashboardTemplateConfigureStep.tsx
@@ -1,12 +1,17 @@
-import { LemonButton } from '@posthog/lemon-ui'
+import { IconArrowRight } from '@posthog/icons'
+import { LemonButton, LemonCard, LemonSkeleton } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
-import { useState } from 'react'
+import { authorizedUrlListLogic, AuthorizedUrlListType } from 'lib/components/AuthorizedUrlList/authorizedUrlListLogic'
+import { IframedToolbarBrowser } from 'lib/components/IframedToolbarBrowser/IframedToolbarBrowser'
+import { iframedToolbarBrowserLogic } from 'lib/components/IframedToolbarBrowser/iframedToolbarBrowserLogic'
+import { useRef, useState } from 'react'
 import { DashboardTemplateVariables } from 'scenes/dashboard/DashboardTemplateVariables'
 import { dashboardTemplateVariablesLogic } from 'scenes/dashboard/dashboardTemplateVariablesLogic'
 import { newDashboardLogic } from 'scenes/dashboard/newDashboardLogic'
 
 import { OnboardingStepKey } from '../onboardingLogic'
 import { OnboardingStep } from '../OnboardingStep'
+import { sdksLogic } from '../sdks/sdksLogic'
 import { onboardingTemplateConfigLogic } from './onboardingTemplateConfigLogic'
 
 export const OnboardingDashboardTemplateConfigureStep = ({
@@ -14,10 +19,15 @@ export const OnboardingDashboardTemplateConfigureStep = ({
 }: {
     stepKey?: OnboardingStepKey
 }): JSX.Element => {
+    const iframeRef = useRef<HTMLIFrameElement>(null)
     const { activeDashboardTemplate } = useValues(onboardingTemplateConfigLogic)
     const { createDashboardFromTemplate } = useActions(newDashboardLogic)
     const { isLoading } = useValues(newDashboardLogic)
     const { variables } = useValues(dashboardTemplateVariablesLogic)
+    const { snippetHosts } = useValues(sdksLogic)
+    const { addUrl } = useActions(authorizedUrlListLogic({ actionId: null, type: AuthorizedUrlListType.TOOLBAR_URLS }))
+    const { setBrowserUrl } = useActions(iframedToolbarBrowserLogic({ iframeRef, clearBrowserUrlOnUnmount: true }))
+    const { browserUrl } = useValues(iframedToolbarBrowserLogic({ iframeRef, clearBrowserUrlOnUnmount: true }))
 
     const [isSubmitting, setIsSubmitting] = useState(false)
 
@@ -26,27 +36,94 @@ export const OnboardingDashboardTemplateConfigureStep = ({
             title={activeDashboardTemplate?.template_name || 'Configure dashboard'}
             stepKey={stepKey}
             breadcrumbHighlightName={OnboardingStepKey.DASHBOARD_TEMPLATE}
-            continueOverride={
-                <LemonButton
-                    type="primary"
-                    onClick={() => {
-                        if (activeDashboardTemplate) {
-                            setIsSubmitting(true)
-                            createDashboardFromTemplate(activeDashboardTemplate, variables, false)
-                        }
-                    }}
-                    loading={isLoading}
-                >
-                    Create dashboard
-                </LemonButton>
-            }
+            fullWidth
+            continueOverride={<></>}
         >
             {isSubmitting || isLoading ? (
                 <p>Creating dashboard...</p>
             ) : (
                 <>
-                    <p>Select the events or website elements that represent important parts of your funnel.</p>
-                    <DashboardTemplateVariables />
+                    <div className="grid grid-cols-6 space-x-6 min-h-[80vh]">
+                        <div className="col-span-4 relative">
+                            {browserUrl ? (
+                                <div className="border border-1 border-border-bold p-2 rounded h-full w-full">
+                                    <IframedToolbarBrowser iframeRef={iframeRef} userIntent="add-action" />
+                                </div>
+                            ) : (
+                                <>
+                                    <div className="absolute inset-0 bg-primary-alt-highlight z-10 rounded opacity-80 backdrop-filter backdrop-blur-md flex items-center justify-center" />
+                                    <div className="absolute inset-0 z-20 rounded flex items-center justify-center">
+                                        <LemonCard className="max-w-lg" hoverEffect={false}>
+                                            <h2>Select where you want to track events from.</h2>
+                                            <p>
+                                                Not seeing the site you want? Install posthog-js or the HTML snippet
+                                                wherever you want to track events, then come back here.
+                                            </p>
+                                            {snippetHosts.length > 0 ? (
+                                                <div className="space-y-2">
+                                                    {snippetHosts.map((host) => (
+                                                        <LemonButton
+                                                            key={`snippet-host-button-${host}`}
+                                                            type="tertiary"
+                                                            status="default"
+                                                            onClick={() => {
+                                                                addUrl(host)
+                                                                setBrowserUrl(host)
+                                                            }}
+                                                            sideIcon={<IconArrowRight />}
+                                                        >
+                                                            {host}
+                                                        </LemonButton>
+                                                    ))}
+                                                </div>
+                                            ) : (
+                                                <p>
+                                                    Hm, we're not finding any available hosts. Head back to the install
+                                                    step to install posthog-js in your frontend.
+                                                </p>
+                                            )}
+                                        </LemonCard>
+                                    </div>
+                                    <div className="space-y-6 relative m-6">
+                                        <LemonSkeleton className="h-10 rounded-lg w-1/3" />
+                                        <div className="space-y-2">
+                                            <LemonSkeleton repeat={5} />
+                                        </div>
+                                        <div className="space-y-2">
+                                            <LemonSkeleton repeat={3} />
+                                        </div>
+                                        <LemonSkeleton className="h-6 rounded-lg w-2/3" />
+                                        <div className="space-y-2">
+                                            <LemonSkeleton repeat={3} />
+                                        </div>
+                                        <LemonSkeleton className="h-10 rounded-lg w-2/3" />
+                                        <div className="space-y-2">
+                                            <LemonSkeleton repeat={5} />
+                                        </div>
+                                    </div>
+                                </>
+                            )}
+                        </div>
+                        <div className="col-span-2">
+                            <DashboardTemplateVariables />
+                            <LemonButton
+                                type="primary"
+                                status="alt"
+                                onClick={() => {
+                                    if (activeDashboardTemplate) {
+                                        setIsSubmitting(true)
+                                        createDashboardFromTemplate(activeDashboardTemplate, variables, false)
+                                    }
+                                }}
+                                loading={isLoading}
+                                fullWidth
+                                center
+                                className="mt-6"
+                            >
+                                Create dashboard
+                            </LemonButton>
+                        </div>
+                    </div>
                 </>
             )}
         </OnboardingStep>
diff --git a/frontend/src/scenes/onboarding/sdks/feature-flags/flagImplementationSnippet.tsx b/frontend/src/scenes/onboarding/sdks/feature-flags/flagImplementationSnippet.tsx
index a4c3abd3db803..59a8802b3ffdc 100644
--- a/frontend/src/scenes/onboarding/sdks/feature-flags/flagImplementationSnippet.tsx
+++ b/frontend/src/scenes/onboarding/sdks/feature-flags/flagImplementationSnippet.tsx
@@ -16,7 +16,7 @@ export const FlagImplementationSnippet = ({ sdkKey }: { sdkKey: SDKKey }): JSX.E
             <h3>Running experiments</h3>
             <p>
                 Experiments run on top of our feature flags. Once you've implemented the flag in your code, you run an
-                A/B test by creating a new experiment in the PostHog dashboard.
+                experiment by creating a new experiment in the PostHog dashboard.
             </p>
         </>
     )
diff --git a/frontend/src/scenes/onboarding/sdks/sdksLogic.tsx b/frontend/src/scenes/onboarding/sdks/sdksLogic.tsx
index a46984ee8f897..0ab48594d2825 100644
--- a/frontend/src/scenes/onboarding/sdks/sdksLogic.tsx
+++ b/frontend/src/scenes/onboarding/sdks/sdksLogic.tsx
@@ -54,6 +54,7 @@ export const sdksLogic = kea<sdksLogicType>([
         setShowSideBySide: (showSideBySide: boolean) => ({ showSideBySide }),
         setPanel: (panel: 'instructions' | 'options') => ({ panel }),
         setHasSnippetEvents: (hasSnippetEvents: boolean) => ({ hasSnippetEvents }),
+        setSnippetHosts: (snippetHosts: string[]) => ({ snippetHosts }),
     }),
     reducers({
         sourceFilter: [
@@ -101,6 +102,12 @@ export const sdksLogic = kea<sdksLogicType>([
         hasSnippetEvents: {
             setHasSnippetEvents: (_, { hasSnippetEvents }) => hasSnippetEvents,
         },
+        snippetHosts: [
+            [] as string[],
+            {
+                setSnippetHosts: (_, { snippetHosts }) => snippetHosts,
+            },
+        ],
     }),
     selectors({
         showSourceOptionsSelect: [
@@ -112,7 +119,7 @@ export const sdksLogic = kea<sdksLogicType>([
             },
         ],
     }),
-    loaders({
+    loaders(({ actions }) => ({
         hasSnippetEvents: [
             null as boolean | null,
             {
@@ -120,23 +127,33 @@ export const sdksLogic = kea<sdksLogicType>([
                     const query: HogQLQuery = {
                         kind: NodeKind.HogQLQuery,
                         query: hogql`SELECT properties.$lib_version AS lib_version,
-                                            max(timestamp)          AS latest_timestamp,
-                                            count(lib_version) as count
-                                     FROM events
-                                     WHERE timestamp >= now() - INTERVAL 3 DAY
-                                       AND timestamp <= now()
-                                       AND properties.$lib = 'web'
-                                     GROUP BY lib_version
-                                     ORDER BY latest_timestamp DESC
-                                         limit 10`,
+                                        max(timestamp) AS latest_timestamp,
+                                        count(lib_version) AS count,
+                                        concat(
+                                            if(startsWith(properties.current_url, 'https://'), 'https://', 'http://'),
+                                            properties.$host
+                                        ) AS full_host
+                                    FROM events
+                                    WHERE timestamp >= now() - INTERVAL 3 DAY
+                                    AND timestamp <= now()
+                                    AND properties.$lib = 'web'
+                                    AND properties.$host is not null
+                                    GROUP BY lib_version, full_host
+                                    ORDER BY latest_timestamp DESC
+                                    LIMIT 10`,
                     }
 
                     const res = await api.query(query)
-                    return !!(res.results?.length ?? 0 > 0)
+                    const hasEvents = !!(res.results?.length ?? 0 > 0)
+                    const snippetHosts = res.results?.map((result) => result[3]).filter((val) => !!val) ?? []
+                    if (hasEvents) {
+                        actions.setSnippetHosts(snippetHosts)
+                    }
+                    return hasEvents
                 },
             },
         ],
-    }),
+    })),
     listeners(({ actions, values }) => ({
         filterSDKs: () => {
             const filteredSDks: SDK[] = allSDKs
diff --git a/frontend/src/scenes/scenes.ts b/frontend/src/scenes/scenes.ts
index 8066fbcd93571..9b4019886e9b2 100644
--- a/frontend/src/scenes/scenes.ts
+++ b/frontend/src/scenes/scenes.ts
@@ -177,7 +177,7 @@ export const sceneConfigurations: Record<Scene, SceneConfig> = {
     },
     [Scene.Experiments]: {
         projectBased: true,
-        name: 'A/B testing',
+        name: 'Experiments',
         defaultDocsPath: '/docs/experiments',
         activityScope: ActivityScope.EXPERIMENT,
     },
@@ -379,7 +379,7 @@ export const sceneConfigurations: Record<Scene, SceneConfig> = {
     },
 }
 
-// NOTE: These redirects will fully replace the URL. If you want to keep support for query and hash params then you should use the above `preserveParams` function.
+// NOTE: These redirects will fully replace the URL. If you want to keep support for query and hash params then you should use a function (not string) redirect
 export const redirects: Record<
     string,
     string | ((params: Params, searchParams: Params, hashParams: Params) => string)
@@ -428,6 +428,9 @@ export const redirects: Record<
         return urls.replay()
     },
     '/replay': urls.replay(),
+    '/replay/recent': (_params, searchParams) => {
+        return urls.replay(undefined, searchParams.filters, searchParams.sessionRecordingId)
+    },
     '/settings': urls.settings(),
     '/project/settings': urls.settings('project'),
     '/organization/settings': urls.settings('organization'),
diff --git a/frontend/src/scenes/session-recordings/SessionRecordings.tsx b/frontend/src/scenes/session-recordings/SessionRecordings.tsx
index b82171522363b..bccee886cceba 100644
--- a/frontend/src/scenes/session-recordings/SessionRecordings.tsx
+++ b/frontend/src/scenes/session-recordings/SessionRecordings.tsx
@@ -29,7 +29,7 @@ import { humanFriendlyTabName, sessionReplaySceneLogic } from './sessionReplaySc
 
 function Header(): JSX.Element {
     const { guardAvailableFeature } = useValues(upgradeModalLogic)
-    const playlistsLogic = savedSessionRecordingPlaylistsLogic({ tab: ReplayTabs.Recent })
+    const playlistsLogic = savedSessionRecordingPlaylistsLogic({ tab: ReplayTabs.Home })
     const { playlists } = useValues(playlistsLogic)
     const { tab } = useValues(sessionReplaySceneLogic)
     const { currentTeam } = useValues(teamLogic)
@@ -54,7 +54,7 @@ function Header(): JSX.Element {
         <PageHeader
             buttons={
                 <>
-                    {tab === ReplayTabs.Recent && !recordingsDisabled && (
+                    {tab === ReplayTabs.Home && !recordingsDisabled && (
                         <>
                             <LemonMenu
                                 items={[
@@ -184,7 +184,7 @@ function MainPanel(): JSX.Element {
 
             {!tab ? (
                 <Spinner />
-            ) : tab === ReplayTabs.Recent ? (
+            ) : tab === ReplayTabs.Home ? (
                 <div className="SessionRecordingPlaylistHeightWrapper">
                     <SessionRecordingsPlaylist updateSearchParams />
                 </div>
diff --git a/frontend/src/scenes/session-recordings/apm/performanceEventDataLogic.ts b/frontend/src/scenes/session-recordings/apm/performanceEventDataLogic.ts
index e6a27e9ed22a6..248279af1eb6a 100644
--- a/frontend/src/scenes/session-recordings/apm/performanceEventDataLogic.ts
+++ b/frontend/src/scenes/session-recordings/apm/performanceEventDataLogic.ts
@@ -165,7 +165,9 @@ function filterUnwanted(events: PerformanceEvent[]): PerformanceEvent[] {
     // the browser can provide network events that we're not interested in,
     // like a navigation to "about:blank"
     return events.filter((event) => {
-        return !(event.entry_type === 'navigation' && event.name && event.name.startsWith('about:'))
+        const hasNoName = !event.name?.trim().length
+        const isNavigationToAbout = event.entry_type === 'navigation' && !!event.name && event.name.startsWith('about:')
+        return !(hasNoName || isNavigationToAbout)
     })
 }
 
diff --git a/frontend/src/scenes/session-recordings/player/sessionRecordingDataLogic.ts b/frontend/src/scenes/session-recordings/player/sessionRecordingDataLogic.ts
index 1db07b7544720..953a180473e94 100644
--- a/frontend/src/scenes/session-recordings/player/sessionRecordingDataLogic.ts
+++ b/frontend/src/scenes/session-recordings/player/sessionRecordingDataLogic.ts
@@ -881,12 +881,10 @@ export const sessionRecordingDataLogic = kea<sessionRecordingDataLogicType>([
                 if (everyWindowMissingFullSnapshot) {
                     // video is definitely unplayable
                     posthog.capture('recording_has_no_full_snapshot', {
-                        ...windowsHaveFullSnapshot,
                         sessionId: sessionRecordingId,
                     })
                 } else if (anyWindowMissingFullSnapshot) {
                     posthog.capture('recording_window_missing_full_snapshot', {
-                        ...windowsHaveFullSnapshot,
                         sessionId: sessionRecordingId,
                     })
                 }
diff --git a/frontend/src/scenes/session-recordings/playlist/SessionRecordingsPlaylist.tsx b/frontend/src/scenes/session-recordings/playlist/SessionRecordingsPlaylist.tsx
index b0b9d18313f3b..4c2e0c2ee8e65 100644
--- a/frontend/src/scenes/session-recordings/playlist/SessionRecordingsPlaylist.tsx
+++ b/frontend/src/scenes/session-recordings/playlist/SessionRecordingsPlaylist.tsx
@@ -112,7 +112,7 @@ export function SessionRecordingsPlaylist(props: SessionRecordingPlaylistLogicPr
                 )}
                 <Playlist
                     data-attr="session-recordings-playlist"
-                    notebooksHref={urls.replay(ReplayTabs.Recent, filters)}
+                    notebooksHref={urls.replay(ReplayTabs.Home, filters)}
                     title="Recordings"
                     embedded={!!notebookNode}
                     sections={sections}
diff --git a/frontend/src/scenes/session-recordings/saved-playlists/SavedSessionRecordingPlaylistsEmptyState.tsx b/frontend/src/scenes/session-recordings/saved-playlists/SavedSessionRecordingPlaylistsEmptyState.tsx
index 062b6c5ecf214..e2933ff1ddda3 100644
--- a/frontend/src/scenes/session-recordings/saved-playlists/SavedSessionRecordingPlaylistsEmptyState.tsx
+++ b/frontend/src/scenes/session-recordings/saved-playlists/SavedSessionRecordingPlaylistsEmptyState.tsx
@@ -11,7 +11,7 @@ import { savedSessionRecordingPlaylistsLogic } from './savedSessionRecordingPlay
 
 export function SavedSessionRecordingPlaylistsEmptyState(): JSX.Element {
     const { guardAvailableFeature } = useValues(upgradeModalLogic)
-    const playlistsLogic = savedSessionRecordingPlaylistsLogic({ tab: ReplayTabs.Recent })
+    const playlistsLogic = savedSessionRecordingPlaylistsLogic({ tab: ReplayTabs.Home })
     const { playlists, loadPlaylistsFailed } = useValues(playlistsLogic)
     return loadPlaylistsFailed ? (
         <LemonBanner type="error">Error while trying to load playlist.</LemonBanner>
diff --git a/frontend/src/scenes/session-recordings/sessionReplaySceneLogic.ts b/frontend/src/scenes/session-recordings/sessionReplaySceneLogic.ts
index 3feef913ce04b..492f65fea4038 100644
--- a/frontend/src/scenes/session-recordings/sessionReplaySceneLogic.ts
+++ b/frontend/src/scenes/session-recordings/sessionReplaySceneLogic.ts
@@ -13,8 +13,8 @@ import type { sessionReplaySceneLogicType } from './sessionReplaySceneLogicType'
 
 export const humanFriendlyTabName = (tab: ReplayTabs): string => {
     switch (tab) {
-        case ReplayTabs.Recent:
-            return 'Recent recordings'
+        case ReplayTabs.Home:
+            return 'Recordings'
         case ReplayTabs.Playlists:
             return 'Playlists'
         default:
@@ -30,11 +30,11 @@ export const sessionReplaySceneLogic = kea<sessionReplaySceneLogicType>([
         values: [featureFlagLogic, ['featureFlags']],
     }),
     actions({
-        setTab: (tab: ReplayTabs = ReplayTabs.Recent) => ({ tab }),
+        setTab: (tab: ReplayTabs = ReplayTabs.Home) => ({ tab }),
     }),
     reducers(() => ({
         tab: [
-            ReplayTabs.Recent as ReplayTabs,
+            ReplayTabs.Home as ReplayTabs,
             {
                 setTab: (_, { tab }) => tab,
             },
@@ -59,7 +59,7 @@ export const sessionReplaySceneLogic = kea<sessionReplaySceneLogicType>([
             (s) => [s.tab],
             (tab): Breadcrumb[] => {
                 const breadcrumbs: Breadcrumb[] = []
-                if (tab !== ReplayTabs.Recent) {
+                if (tab !== ReplayTabs.Home) {
                     breadcrumbs.push({
                         key: Scene.Replay,
                         name: 'Replay',
diff --git a/frontend/src/scenes/trends/viz/ActionsHorizontalBar.tsx b/frontend/src/scenes/trends/viz/ActionsHorizontalBar.tsx
index 2b26b5f36d8ed..0fbdecb949d35 100644
--- a/frontend/src/scenes/trends/viz/ActionsHorizontalBar.tsx
+++ b/frontend/src/scenes/trends/viz/ActionsHorizontalBar.tsx
@@ -48,22 +48,12 @@ export function ActionsHorizontalBar({ showPersonsModal = true }: ChartParams):
                 personsValues: _data.map((item) => item.persons),
                 breakdownValues: _data.map((item) => item.breakdown_value),
                 breakdownLabels: _data.map((item) => {
-                    const itemLabel = item.action
-                        ? item.action.custom_name ?? item.action.name ?? item.action.id
-                        : item.label
-
-                    if (!item.breakdown_value) {
-                        return itemLabel
-                    }
-
-                    const breakdownLabel = formatBreakdownLabel(
+                    return formatBreakdownLabel(
                         item.breakdown_value,
                         breakdownFilter,
                         cohorts,
                         formatPropertyValueForDisplay
                     )
-
-                    return `${itemLabel} - ${breakdownLabel}`
                 }),
                 compareLabels: _data.map((item) => item.compare_label),
                 backgroundColor: colorList,
diff --git a/frontend/src/scenes/urls.ts b/frontend/src/scenes/urls.ts
index f12b5017a9014..ca6c98088952a 100644
--- a/frontend/src/scenes/urls.ts
+++ b/frontend/src/scenes/urls.ts
@@ -98,8 +98,11 @@ export const urls = {
     savedInsights: (tab?: string): string => `/insights${tab ? `?tab=${tab}` : ''}`,
     webAnalytics: (): string => `/web`,
 
-    replay: (tab?: ReplayTabs, filters?: Partial<RecordingUniversalFilters>): string =>
-        combineUrl(tab ? `/replay/${tab}` : '/replay/recent', filters ? { filters } : {}).url,
+    replay: (tab?: ReplayTabs, filters?: Partial<RecordingUniversalFilters>, sessionRecordingId?: string): string =>
+        combineUrl(tab ? `/replay/${tab}` : '/replay/home', {
+            ...(filters ? { filters } : {}),
+            ...(sessionRecordingId ? { sessionRecordingId } : {}),
+        }).url,
     replayPlaylist: (id: string): string => `/replay/playlists/${id}`,
     replaySingle: (id: string): string => `/replay/${id}`,
     replayFilePlayback: (): string => '/replay/file-playback',
diff --git a/frontend/src/scenes/web-analytics/tiles/WebAnalyticsRecordings.tsx b/frontend/src/scenes/web-analytics/tiles/WebAnalyticsRecordings.tsx
index eeaa74591be5f..25a7500913e99 100644
--- a/frontend/src/scenes/web-analytics/tiles/WebAnalyticsRecordings.tsx
+++ b/frontend/src/scenes/web-analytics/tiles/WebAnalyticsRecordings.tsx
@@ -45,7 +45,7 @@ export function WebAnalyticsRecordingsTile({ tile }: { tile: ReplayTile }): JSX.
               buttonText: 'Learn more',
               buttonTo: 'https://posthog.com/docs/user-guides/recordings',
           }
-    const to = items.length > 0 ? urls.replay(ReplayTabs.Recent, replayFilters) : urls.replay()
+    const to = items.length > 0 ? urls.replay(ReplayTabs.Home, replayFilters) : urls.replay()
     return (
         <>
             <SessionPlayerModal />
diff --git a/frontend/src/toolbar/bar/toolbarLogic.ts b/frontend/src/toolbar/bar/toolbarLogic.ts
index 9512cfcfb5777..20148d0ca3b40 100644
--- a/frontend/src/toolbar/bar/toolbarLogic.ts
+++ b/frontend/src/toolbar/bar/toolbarLogic.ts
@@ -1,8 +1,8 @@
 import { actions, afterMount, beforeUnmount, connect, kea, listeners, path, reducers, selectors } from 'kea'
 import { windowValues } from 'kea-window-values'
-import { PostHogAppToolbarEvent } from 'lib/components/heatmaps/utils'
 import { HedgehogActor } from 'lib/components/HedgehogBuddy/HedgehogBuddy'
 import { SPRITE_SIZE } from 'lib/components/HedgehogBuddy/sprites/sprites'
+import { PostHogAppToolbarEvent } from 'lib/components/IframedToolbarBrowser/utils'
 
 import { actionsTabLogic } from '~/toolbar/actions/actionsTabLogic'
 import { elementsLogic } from '~/toolbar/elements/elementsLogic'
diff --git a/frontend/src/toolbar/elements/heatmapLogic.ts b/frontend/src/toolbar/elements/heatmapLogic.ts
index f297110587e1a..00ec34523bb62 100644
--- a/frontend/src/toolbar/elements/heatmapLogic.ts
+++ b/frontend/src/toolbar/elements/heatmapLogic.ts
@@ -14,7 +14,7 @@ import {
     HeatmapJsDataPoint,
     HeatmapRequestType,
 } from 'lib/components/heatmaps/types'
-import { calculateViewportRange, DEFAULT_HEATMAP_FILTERS } from 'lib/components/heatmaps/utils'
+import { calculateViewportRange, DEFAULT_HEATMAP_FILTERS } from 'lib/components/IframedToolbarBrowser/utils'
 import { dateFilterToText } from 'lib/utils'
 import { createVersionChecker } from 'lib/utils/semver'
 import { PostHog } from 'posthog-js'
diff --git a/frontend/src/toolbar/stats/HeatmapToolbarMenu.tsx b/frontend/src/toolbar/stats/HeatmapToolbarMenu.tsx
index dc7b06fd99540..49576459788c2 100644
--- a/frontend/src/toolbar/stats/HeatmapToolbarMenu.tsx
+++ b/frontend/src/toolbar/stats/HeatmapToolbarMenu.tsx
@@ -3,7 +3,7 @@ import { LemonTag, Link } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { DateFilter } from 'lib/components/DateFilter/DateFilter'
 import { HeatmapsSettings } from 'lib/components/heatmaps/HeatMapsSettings'
-import { heatmapDateOptions } from 'lib/components/heatmaps/utils'
+import { heatmapDateOptions } from 'lib/components/IframedToolbarBrowser/utils'
 import { IconSync } from 'lib/lemon-ui/icons'
 import { LemonButton } from 'lib/lemon-ui/LemonButton'
 import { LemonInput } from 'lib/lemon-ui/LemonInput'
diff --git a/frontend/src/types.ts b/frontend/src/types.ts
index 0e32117d3688e..cbc91482a2bae 100644
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -639,7 +639,7 @@ export enum SavedInsightsTabs {
 }
 
 export enum ReplayTabs {
-    Recent = 'recent',
+    Home = 'home',
     Playlists = 'playlists',
     Errors = 'errors',
 }
diff --git a/hogvm/__tests__/__snapshots__/operations.hoge b/hogvm/__tests__/__snapshots__/operations.hoge
index f11d3fa9ea5b5..3a08b489025d2 100644
--- a/hogvm/__tests__/__snapshots__/operations.hoge
+++ b/hogvm/__tests__/__snapshots__/operations.hoge
@@ -20,4 +20,10 @@
 35, 29, 2, "toString", 1, 36, 0, 54, 1, 35, 31, 2, "toString", 1, 36, 0, 54, 1, 35, 32, "string", 2, "toString", 1, 36,
 0, 54, 1, 35, 32, "1", 2, "toInt", 1, 36, 0, 54, 1, 35, 32, "bla", 2, "toInt", 1, 36, 0, 54, 1, 35, 32, "1.2", 2,
 "toFloat", 1, 36, 0, 54, 1, 35, 32, "bla", 2, "toFloat", 1, 36, 0, 54, 1, 35, 32, "asd", 2, "toUUID", 1, 36, 0, 54, 1,
-35, 31, 33, 1, 11, 36, 0, 54, 1, 35, 31, 33, 1, 12, 36, 0, 54, 1, 35, 35]
+35, 31, 33, 1, 11, 36, 0, 54, 1, 35, 31, 33, 1, 12, 36, 0, 54, 1, 35, 33, 1, 32, "1", 11, 36, 0, 54, 1, 35, 32, "1", 33,
+1, 11, 36, 0, 54, 1, 35, 29, 33, 1, 11, 36, 0, 54, 1, 35, 29, 33, 0, 11, 36, 0, 54, 1, 35, 29, 33, 2, 11, 36, 0, 54, 1,
+35, 30, 33, 1, 12, 36, 0, 54, 1, 35, 32, "2", 33, 1, 11, 36, 0, 54, 1, 35, 32, "2", 33, 1, 11, 36, 0, 54, 1, 35, 32,
+"2", 33, 1, 12, 36, 0, 54, 1, 35, 32, "2", 33, 1, 15, 36, 0, 54, 1, 35, 32, "2", 33, 1, 16, 36, 0, 54, 1, 35, 32, "2",
+33, 1, 13, 36, 0, 54, 1, 35, 32, "2", 33, 1, 14, 36, 0, 54, 1, 35, 33, 2, 32, "1", 11, 36, 0, 54, 1, 35, 33, 2, 32, "1",
+11, 36, 0, 54, 1, 35, 33, 2, 32, "1", 12, 36, 0, 54, 1, 35, 33, 2, 32, "1", 15, 36, 0, 54, 1, 35, 33, 2, 32, "1", 16,
+36, 0, 54, 1, 35, 33, 2, 32, "1", 13, 36, 0, 54, 1, 35, 33, 2, 32, "1", 14, 36, 0, 54, 1, 35, 35]
diff --git a/hogvm/__tests__/__snapshots__/operations.stdout b/hogvm/__tests__/__snapshots__/operations.stdout
index 5017b0e3005c7..849bb2699265f 100644
--- a/hogvm/__tests__/__snapshots__/operations.stdout
+++ b/hogvm/__tests__/__snapshots__/operations.stdout
@@ -60,3 +60,23 @@ null
 "asd"
 false
 true
+true
+true
+true
+false
+false
+true
+false
+false
+true
+true
+true
+false
+false
+false
+false
+true
+true
+true
+false
+false
diff --git a/hogvm/__tests__/__snapshots__/typeof.hoge b/hogvm/__tests__/__snapshots__/typeof.hoge
new file mode 100644
index 0000000000000..873e6d46efb63
--- /dev/null
+++ b/hogvm/__tests__/__snapshots__/typeof.hoge
@@ -0,0 +1,5 @@
+["_H", 1, 52, "test", 1, 0, 11, 36, 0, 2, "typeof", 1, 2, "print", 1, 35, 31, 38, 53, 0, 32, "hello world", 36, 0, 54,
+1, 35, 33, 123, 36, 0, 54, 1, 35, 34, 1.23, 36, 0, 54, 1, 35, 29, 36, 0, 54, 1, 35, 30, 36, 0, 54, 1, 35, 31, 36, 0, 54,
+1, 35, 42, 0, 36, 0, 54, 1, 35, 43, 0, 36, 0, 54, 1, 35, 33, 1, 33, 2, 33, 3, 44, 3, 36, 0, 54, 1, 35, 52, "lambda", 0,
+0, 6, 33, 2, 33, 1, 6, 38, 53, 0, 36, 0, 54, 1, 35, 32, "2021-01-01T00:00:00Z", 2, "toDateTime", 1, 36, 0, 54, 1, 35,
+32, "2021-01-01", 2, "toDate", 1, 36, 0, 54, 1, 35, 32, "BigError", 32, "message", 2, "Error", 2, 36, 0, 54, 1, 35, 35]
diff --git a/hogvm/__tests__/__snapshots__/typeof.stdout b/hogvm/__tests__/__snapshots__/typeof.stdout
new file mode 100644
index 0000000000000..ea10db2000516
--- /dev/null
+++ b/hogvm/__tests__/__snapshots__/typeof.stdout
@@ -0,0 +1,13 @@
+string
+integer
+float
+boolean
+boolean
+null
+object
+array
+tuple
+function
+datetime
+date
+error
diff --git a/hogvm/__tests__/operations.hog b/hogvm/__tests__/operations.hog
index 9f65924bed192..259353afcf798 100644
--- a/hogvm/__tests__/operations.hog
+++ b/hogvm/__tests__/operations.hog
@@ -64,3 +64,23 @@ test(toFloat('bla'))                      // null
 test(toUUID('asd'))                       // 'asd'
 test(1 == null)                           // false
 test(1 != null)                           // true
+test('1' = 1)                             // true
+test(1 = '1')                             // true
+test(1 == true)                           // true
+test(0 == true)                           // false
+test(2 == true)                           // false
+test(1 != false)                          // true
+test(1 = '2')                             // false
+test(1 == '2')                            // false
+test(1 != '2')                            // true
+test(1 < '2')                             // true
+test(1 <= '2')                            // true
+test(1 > '2')                             // false
+test(1 >= '2')                            // false
+test('1' = 2)                             // false
+test('1' == 2)                            // false
+test('1' != 2)                            // true
+test('1' < 2)                             // true
+test('1' <= 2)                            // true
+test('1' > 2)                             // false
+test('1' >= 2)                            // false
diff --git a/hogvm/__tests__/typeof.hog b/hogvm/__tests__/typeof.hog
new file mode 100644
index 0000000000000..2ad529cbaaad7
--- /dev/null
+++ b/hogvm/__tests__/typeof.hog
@@ -0,0 +1,17 @@
+fun test(obj) {
+  print(typeof(obj))
+}
+
+test('hello world')
+test(123)
+test(1.23)
+test(true)
+test(false)
+test(null)
+test({})
+test([])
+test((1,2,3))
+test(() -> 1 + 2)
+test(toDateTime('2021-01-01T00:00:00Z'))
+test(toDate('2021-01-01'))
+test(Error('BigError', 'message'))
diff --git a/hogvm/python/execute.py b/hogvm/python/execute.py
index a8553628c73b2..2d11cae58d611 100644
--- a/hogvm/python/execute.py
+++ b/hogvm/python/execute.py
@@ -19,6 +19,7 @@
     like,
     set_nested_value,
     calculate_cost,
+    unify_comparison_types,
 )
 
 if TYPE_CHECKING:
@@ -201,17 +202,23 @@ def capture_upvalue(index) -> dict:
             case Operation.MOD:
                 push_stack(pop_stack() % pop_stack())
             case Operation.EQ:
-                push_stack(pop_stack() == pop_stack())
+                var1, var2 = unify_comparison_types(pop_stack(), pop_stack())
+                push_stack(var1 == var2)
             case Operation.NOT_EQ:
-                push_stack(pop_stack() != pop_stack())
+                var1, var2 = unify_comparison_types(pop_stack(), pop_stack())
+                push_stack(var1 != var2)
             case Operation.GT:
-                push_stack(pop_stack() > pop_stack())
+                var1, var2 = unify_comparison_types(pop_stack(), pop_stack())
+                push_stack(var1 > var2)
             case Operation.GT_EQ:
-                push_stack(pop_stack() >= pop_stack())
+                var1, var2 = unify_comparison_types(pop_stack(), pop_stack())
+                push_stack(var1 >= var2)
             case Operation.LT:
-                push_stack(pop_stack() < pop_stack())
+                var1, var2 = unify_comparison_types(pop_stack(), pop_stack())
+                push_stack(var1 < var2)
             case Operation.LT_EQ:
-                push_stack(pop_stack() <= pop_stack())
+                var1, var2 = unify_comparison_types(pop_stack(), pop_stack())
+                push_stack(var1 <= var2)
             case Operation.LIKE:
                 push_stack(like(pop_stack(), pop_stack()))
             case Operation.ILIKE:
diff --git a/hogvm/python/stl/__init__.py b/hogvm/python/stl/__init__.py
index fb69d9f477dd6..feaae8a899aeb 100644
--- a/hogvm/python/stl/__init__.py
+++ b/hogvm/python/stl/__init__.py
@@ -314,6 +314,34 @@ def _formatDateTime(args: list[Any], team: Optional["Team"], stdout: Optional[li
     return formatDateTime(args[0], args[1], args[2] if len(args) > 2 else None)
 
 
+def _typeof(args: list[Any], team: Optional["Team"], stdout: Optional[list[str]], timeout: float) -> str:
+    if args[0] is None:
+        return "null"
+    elif is_hog_datetime(args[0]):
+        return "datetime"
+    elif is_hog_date(args[0]):
+        return "date"
+    elif is_hog_error(args[0]):
+        return "error"
+    elif is_hog_callable(args[0]) or is_hog_closure(args[0]):
+        return "function"
+    elif isinstance(args[0], list):
+        return "array"
+    elif isinstance(args[0], tuple):
+        return "tuple"
+    elif isinstance(args[0], dict):
+        return "object"
+    elif args[0] is True or args[0] is False:
+        return "boolean"
+    elif isinstance(args[0], int):
+        return "integer"
+    elif isinstance(args[0], float):
+        return "float"
+    elif isinstance(args[0], str):
+        return "string"
+    return "unknown"
+
+
 STL: dict[str, STLFunction] = {
     "concat": STLFunction(
         fn=lambda args, team, stdout, timeout: "".join(
@@ -424,6 +452,7 @@ def _formatDateTime(args: list[Any], team: Optional["Team"], stdout: Optional[li
         minArgs=0,
         maxArgs=2,
     ),
+    "typeof": STLFunction(fn=_typeof, minArgs=1, maxArgs=1),
     # only in python, async function in nodejs
     "sleep": STLFunction(fn=sleep, minArgs=1, maxArgs=1),
     "run": STLFunction(fn=run, minArgs=1, maxArgs=1),
diff --git a/hogvm/python/utils.py b/hogvm/python/utils.py
index ebb18ca751ec2..4a8e899266233 100644
--- a/hogvm/python/utils.py
+++ b/hogvm/python/utils.py
@@ -90,3 +90,19 @@ def calculate_cost(object, marked: set | None = None) -> int:
     elif isinstance(object, str):
         return COST_PER_UNIT + len(object)
     return COST_PER_UNIT
+
+
+def unify_comparison_types(left, right):
+    if isinstance(left, int | float) and isinstance(right, str):
+        return left, float(right)
+    if isinstance(left, str) and isinstance(right, int | float):
+        return float(left), right
+    if isinstance(left, bool) and isinstance(right, str):
+        return left, bool(right)
+    if isinstance(left, str) and isinstance(right, bool):
+        return bool(left), right
+    if isinstance(left, int | float) and isinstance(right, bool):
+        return left, int(right)
+    if isinstance(left, bool) and isinstance(right, int | float):
+        return int(left), right
+    return left, right
diff --git a/hogvm/typescript/package.json b/hogvm/typescript/package.json
index d1bebac9b8ef2..8a52d73906343 100644
--- a/hogvm/typescript/package.json
+++ b/hogvm/typescript/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@posthog/hogvm",
-    "version": "1.0.42",
+    "version": "1.0.44",
     "description": "PostHog Hog Virtual Machine",
     "types": "dist/index.d.ts",
     "source": "src/index.ts",
diff --git a/hogvm/typescript/src/execute.ts b/hogvm/typescript/src/execute.ts
index 5ef6edd259bf3..090de4076a54a 100644
--- a/hogvm/typescript/src/execute.ts
+++ b/hogvm/typescript/src/execute.ts
@@ -13,6 +13,7 @@ import {
     like,
     setNestedValue,
     UncaughtHogVMException,
+    unifyComparisonTypes,
 } from './utils'
 
 export function execSync(bytecode: any[], options?: ExecOptions): any {
@@ -280,22 +281,28 @@ export function exec(code: any[] | VMState, options?: ExecOptions): ExecResult {
                 pushStack(Number(popStack()) % Number(popStack()))
                 break
             case Operation.EQ:
-                pushStack(popStack() === popStack())
+                ;[temp, temp2] = unifyComparisonTypes(popStack(), popStack())
+                pushStack(temp === temp2)
                 break
             case Operation.NOT_EQ:
-                pushStack(popStack() !== popStack())
+                ;[temp, temp2] = unifyComparisonTypes(popStack(), popStack())
+                pushStack(temp !== temp2)
                 break
             case Operation.GT:
-                pushStack(popStack() > popStack())
+                ;[temp, temp2] = unifyComparisonTypes(popStack(), popStack())
+                pushStack(temp > temp2)
                 break
             case Operation.GT_EQ:
-                pushStack(popStack() >= popStack())
+                ;[temp, temp2] = unifyComparisonTypes(popStack(), popStack())
+                pushStack(temp >= temp2)
                 break
             case Operation.LT:
-                pushStack(popStack() < popStack())
+                ;[temp, temp2] = unifyComparisonTypes(popStack(), popStack())
+                pushStack(temp < temp2)
                 break
             case Operation.LT_EQ:
-                pushStack(popStack() <= popStack())
+                ;[temp, temp2] = unifyComparisonTypes(popStack(), popStack())
+                pushStack(temp <= temp2)
                 break
             case Operation.LIKE:
                 pushStack(like(popStack(), popStack()))
diff --git a/hogvm/typescript/src/stl/stl.ts b/hogvm/typescript/src/stl/stl.ts
index 332e79da60e65..1e8282730900b 100644
--- a/hogvm/typescript/src/stl/stl.ts
+++ b/hogvm/typescript/src/stl/stl.ts
@@ -591,6 +591,37 @@ export const STL: Record<string, STLFunction> = {
         minArgs: 0,
         maxArgs: 2,
     },
+    typeof: {
+        fn: (args) => {
+            if (args[0] === null || args[0] === undefined) {
+                return 'null'
+            } else if (isHogDateTime(args[0])) {
+                return 'datetime'
+            } else if (isHogDate(args[0])) {
+                return 'date'
+            } else if (isHogError(args[0])) {
+                return 'error'
+            } else if (isHogCallable(args[0]) || isHogClosure(args[0])) {
+                return 'function'
+            } else if (Array.isArray(args[0])) {
+                if ((args[0] as any).__isHogTuple) {
+                    return 'tuple'
+                }
+                return 'array'
+            } else if (typeof args[0] === 'object') {
+                return 'object'
+            } else if (typeof args[0] === 'number') {
+                return Number.isInteger(args[0]) ? 'integer' : 'float'
+            } else if (typeof args[0] === 'string') {
+                return 'string'
+            } else if (typeof args[0] === 'boolean') {
+                return 'boolean'
+            }
+            return 'unknown'
+        },
+        minArgs: 1,
+        maxArgs: 1,
+    },
 }
 
 export const ASYNC_STL: Record<string, AsyncSTLFunction> = {
diff --git a/hogvm/typescript/src/utils.ts b/hogvm/typescript/src/utils.ts
index 45ea53bfedb83..077b7ea451c89 100644
--- a/hogvm/typescript/src/utils.ts
+++ b/hogvm/typescript/src/utils.ts
@@ -164,3 +164,25 @@ export function calculateCost(object: any, marked: Set<any> | undefined = undefi
     }
     return COST_PER_UNIT
 }
+
+export function unifyComparisonTypes(left: any, right: any): [any, any] {
+    if (typeof left === 'number' && typeof right === 'string') {
+        return [left, Number(right)]
+    }
+    if (typeof left === 'string' && typeof right === 'number') {
+        return [Number(left), right]
+    }
+    if (typeof left === 'boolean' && typeof right === 'string') {
+        return [left, right === 'true']
+    }
+    if (typeof left === 'string' && typeof right === 'boolean') {
+        return [left === 'true', right]
+    }
+    if (typeof left === 'boolean' && typeof right === 'number') {
+        return [left ? 1 : 0, right]
+    }
+    if (typeof left === 'number' && typeof right === 'boolean') {
+        return [left, right ? 1 : 0]
+    }
+    return [left, right]
+}
diff --git a/latest_migrations.manifest b/latest_migrations.manifest
index cec1c5bb59401..85b48ed0ed16f 100644
--- a/latest_migrations.manifest
+++ b/latest_migrations.manifest
@@ -5,7 +5,7 @@ contenttypes: 0002_remove_content_type_name
 ee: 0016_rolemembership_organization_member
 otp_static: 0002_throttling
 otp_totp: 0002_auto_20190420_0723
-posthog: 0464_action_pinned_at
+posthog: 0465_datawarehouse_stripe_account
 sessions: 0001_initial
 social_django: 0010_uid_db_index
 two_factor: 0007_auto_20201201_1019
diff --git a/mypy-baseline.txt b/mypy-baseline.txt
index 1fd47dbec5261..2a1b0092f3f1b 100644
--- a/mypy-baseline.txt
+++ b/mypy-baseline.txt
@@ -780,6 +780,7 @@ posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "typ
 posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/tasks/test/test_email.py:0: error: Argument 1 to "send_batch_export_run_failure" has incompatible type "UUID"; expected "str"  [arg-type]
 posthog/tasks/test/test_email.py:0: error: Argument 1 to "send_batch_export_run_failure" has incompatible type "UUID"; expected "str"  [arg-type]
 posthog/tasks/test/test_email.py:0: error: Argument 1 to "send_batch_export_run_failure" has incompatible type "UUID"; expected "str"  [arg-type]
diff --git a/package.json b/package.json
index ff0c2031dff8d..8a67dc54ba8c3 100644
--- a/package.json
+++ b/package.json
@@ -77,7 +77,7 @@
         "@medv/finder": "^3.1.0",
         "@microlink/react-json-view": "^1.21.3",
         "@monaco-editor/react": "4.6.0",
-        "@posthog/hogvm": "^1.0.42",
+        "@posthog/hogvm": "^1.0.44",
         "@posthog/icons": "0.7.3",
         "@posthog/plugin-scaffold": "^1.4.4",
         "@react-hook/size": "^2.1.2",
@@ -150,7 +150,7 @@
         "pmtiles": "^2.11.0",
         "postcss": "^8.4.31",
         "postcss-preset-env": "^9.3.0",
-        "posthog-js": "1.159.0",
+        "posthog-js": "1.160.3",
         "posthog-js-lite": "3.0.0",
         "prettier": "^2.8.8",
         "prop-types": "^15.7.2",
diff --git a/plugin-server/bin/ci_functional_tests.sh b/plugin-server/bin/ci_functional_tests.sh
index 2d89a623624bd..4ec68bf229c91 100755
--- a/plugin-server/bin/ci_functional_tests.sh
+++ b/plugin-server/bin/ci_functional_tests.sh
@@ -12,8 +12,6 @@
 set -e -o pipefail
 
 export WORKER_CONCURRENCY=1
-export CONVERSION_BUFFER_ENABLED=true
-export BUFFER_CONVERSION_SECONDS=2 # Make sure we don't have to wait for the default 60 seconds
 export KAFKA_MAX_MESSAGE_BATCH_SIZE=0
 export APP_METRICS_FLUSH_FREQUENCY_MS=0 # Reduce the potential for spurious errors in tests that wait for metrics
 export APP_METRICS_GATHERED_FOR_ALL=true
diff --git a/plugin-server/package.json b/plugin-server/package.json
index 654e9886b655d..75a137b2e1924 100644
--- a/plugin-server/package.json
+++ b/plugin-server/package.json
@@ -53,7 +53,7 @@
         "@maxmind/geoip2-node": "^3.4.0",
         "@posthog/clickhouse": "^1.7.0",
         "@posthog/cyclotron": "file:../rust/cyclotron-node",
-        "@posthog/hogvm": "^1.0.42",
+        "@posthog/hogvm": "^1.0.44",
         "@posthog/plugin-scaffold": "1.4.4",
         "@sentry/node": "^7.49.0",
         "@sentry/profiling-node": "^0.3.0",
diff --git a/plugin-server/pnpm-lock.yaml b/plugin-server/pnpm-lock.yaml
index 1149bb0508873..08f08046ad14c 100644
--- a/plugin-server/pnpm-lock.yaml
+++ b/plugin-server/pnpm-lock.yaml
@@ -47,8 +47,8 @@ dependencies:
     specifier: file:../rust/cyclotron-node
     version: file:../rust/cyclotron-node
   '@posthog/hogvm':
-    specifier: ^1.0.42
-    version: 1.0.42(luxon@3.4.4)
+    specifier: ^1.0.44
+    version: 1.0.44(luxon@3.4.4)
   '@posthog/plugin-scaffold':
     specifier: 1.4.4
     version: 1.4.4
@@ -3116,8 +3116,8 @@ packages:
     engines: {node: '>=12'}
     dev: false
 
-  /@posthog/hogvm@1.0.42(luxon@3.4.4):
-    resolution: {integrity: sha512-vrIl2XVtlBqkPOmF65pd8WYFFnv+Mtc2kgmJga9CDo8obsn/aMcYf4UrKNcXsK9XAz4vxw7ItwcgrD/Hb6WjuQ==}
+  /@posthog/hogvm@1.0.44(luxon@3.4.4):
+    resolution: {integrity: sha512-Ss7gTPyvPyviNipVQOqnsCa66IMmMf+DEg7iX/vQMcWDuFwvHNbdze1iwFVoXCjLci+h8SW2rOMPB0S5A2jJXg==}
     peerDependencies:
       luxon: ^3.4.4
     dependencies:
diff --git a/plugin-server/src/capabilities.ts b/plugin-server/src/capabilities.ts
index 7b8c8461b78ad..6a9d30af15ff4 100644
--- a/plugin-server/src/capabilities.ts
+++ b/plugin-server/src/capabilities.ts
@@ -25,7 +25,6 @@ export function getPluginServerCapabilities(config: PluginsServerConfig): Plugin
                 preflightSchedules: true,
                 cdpProcessedEvents: true,
                 cdpFunctionCallbacks: true,
-                cdpFunctionOverflow: true,
                 cdpCyclotronWorker: true,
                 syncInlinePlugins: true,
                 ...sharedCapabilities,
@@ -104,11 +103,6 @@ export function getPluginServerCapabilities(config: PluginsServerConfig): Plugin
                 cdpFunctionCallbacks: true,
                 ...sharedCapabilities,
             }
-        case PluginServerMode.cdp_function_overflow:
-            return {
-                cdpFunctionOverflow: true,
-                ...sharedCapabilities,
-            }
         case PluginServerMode.cdp_cyclotron_worker:
             return {
                 cdpCyclotronWorker: true,
diff --git a/plugin-server/src/cdp/async-function-executor.ts b/plugin-server/src/cdp/async-function-executor.ts
deleted file mode 100644
index fe6df753dc723..0000000000000
--- a/plugin-server/src/cdp/async-function-executor.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-import cyclotron from '@posthog/cyclotron'
-import { Histogram } from 'prom-client'
-
-import { buildIntegerMatcher } from '../config/config'
-import { PluginsServerConfig, ValueMatcher } from '../types'
-import { trackedFetch } from '../utils/fetch'
-import { status } from '../utils/status'
-import { RustyHook } from '../worker/rusty-hook'
-import { HogFunctionInvocationAsyncRequest, HogFunctionInvocationAsyncResponse } from './types'
-
-export const BUCKETS_KB_WRITTEN = [0, 128, 512, 1024, 2024, 4096, 10240, Infinity]
-
-const histogramFetchPayloadSize = new Histogram({
-    name: 'cdp_async_function_fetch_payload_size_kb',
-    help: 'The size in kb of the batches we are receiving from Kafka',
-    buckets: BUCKETS_KB_WRITTEN,
-})
-
-const histogramHogHooksPayloadSize = new Histogram({
-    name: 'cdp_async_function_hoghooks_payload_size_kb',
-    help: 'The size in kb of the batches we are receiving from Kafka',
-    buckets: BUCKETS_KB_WRITTEN,
-})
-
-export type AsyncFunctionExecutorOptions = {
-    sync?: boolean
-}
-
-export class AsyncFunctionExecutor {
-    hogHookEnabledForTeams: ValueMatcher<number>
-    cyclotronEnabledForTeams: ValueMatcher<number>
-
-    constructor(private serverConfig: PluginsServerConfig, private rustyHook: RustyHook) {
-        this.hogHookEnabledForTeams = buildIntegerMatcher(serverConfig.CDP_ASYNC_FUNCTIONS_RUSTY_HOOK_TEAMS, true)
-        this.cyclotronEnabledForTeams = buildIntegerMatcher(serverConfig.CDP_ASYNC_FUNCTIONS_CYCLOTRON_TEAMS, true)
-    }
-
-    async execute(
-        request: HogFunctionInvocationAsyncRequest,
-        options: AsyncFunctionExecutorOptions = { sync: false }
-    ): Promise<HogFunctionInvocationAsyncResponse | undefined> {
-        if (!request.asyncFunctionRequest) {
-            throw new Error('No async function request provided')
-        }
-
-        const loggingContext = {
-            hogFunctionId: request.hogFunctionId,
-            asyncFunctionName: request.asyncFunctionRequest.name,
-        }
-        status.info('🦔', `[AsyncFunctionExecutor] Executing async function`, loggingContext)
-
-        switch (request.asyncFunctionRequest.name) {
-            // TODO: Add error case here - if we don't get a valid queued message then we should log something against the function
-            case 'fetch':
-                return await this.asyncFunctionFetch(request, options)
-            default:
-                status.error(
-                    '🦔',
-                    `[HogExecutor] Unknown async function: ${request.asyncFunctionRequest.name}`,
-                    loggingContext
-                )
-        }
-    }
-
-    private async asyncFunctionFetch(
-        request: HogFunctionInvocationAsyncRequest,
-        options?: AsyncFunctionExecutorOptions
-    ): Promise<HogFunctionInvocationAsyncResponse | undefined> {
-        if (!request.asyncFunctionRequest) {
-            return
-        }
-
-        const asyncFunctionResponse: HogFunctionInvocationAsyncResponse['asyncFunctionResponse'] = {
-            response: null,
-            timings: [],
-        }
-
-        try {
-            // Sanitize the args
-            const [url, fetchOptions] = request.asyncFunctionRequest.args as [
-                string | undefined,
-                Record<string, any> | undefined
-            ]
-
-            if (typeof url !== 'string') {
-                status.error('🦔', `[HogExecutor] Invalid URL`, { ...request, url })
-                return
-            }
-
-            const method = fetchOptions?.method || 'POST'
-            const headers = fetchOptions?.headers || {
-                'Content-Type': 'application/json',
-            }
-            let body = fetchOptions?.body
-            // Modify the body to ensure it is a string (we allow Hog to send an object to keep things simple)
-            body = body ? (typeof body === 'string' ? body : JSON.stringify(body)) : body
-
-            // Finally overwrite the args with the sanitized ones
-            request.asyncFunctionRequest.args = [url, { method, headers, body }]
-
-            if (body) {
-                histogramFetchPayloadSize.observe(body.length / 1024)
-            }
-
-            // If the caller hasn't forced it to be synchronous and the team has the cyclotron or
-            // rustyhook enabled, enqueue it in one of those services.
-            if (!options?.sync && this.cyclotronEnabledForTeams(request.teamId)) {
-                try {
-                    await cyclotron.createJob({
-                        teamId: request.teamId,
-                        functionId: request.hogFunctionId,
-                        queueName: 'fetch',
-                        // TODO: The async function compression changes happen upstream of this
-                        // function. I guess we'll want to unwind that change because we actually
-                        // want the `vmState` (and the rest of state) so we can put it into PG here.
-                        vmState: '',
-                        parameters: JSON.stringify({
-                            return_queue: 'hog',
-                            url,
-                            method,
-                            headers,
-                            // The body is passed in the `blob` field below.
-                        }),
-                        metadata: JSON.stringify({}),
-                        // Fetch bodies are passed in the binary blob column/field.
-                        blob: toUint8Array(body),
-                    })
-                } catch (e) {
-                    status.error(
-                        '🦔',
-                        `[HogExecutor] Cyclotron failed to enqueue async fetch function, sending directly instead`,
-                        {
-                            error: e,
-                        }
-                    )
-                }
-            } else if (!options?.sync && this.hogHookEnabledForTeams(request.teamId)) {
-                const hoghooksPayload = JSON.stringify(request)
-
-                histogramHogHooksPayloadSize.observe(hoghooksPayload.length / 1024)
-
-                const enqueued = await this.rustyHook.enqueueForHog(JSON.stringify(request))
-                if (enqueued) {
-                    return
-                }
-            }
-
-            status.info('🦔', `[HogExecutor] Webhook not sent via rustyhook, sending directly instead`)
-
-            const start = performance.now()
-            const fetchResponse = await trackedFetch(url, {
-                method,
-                body,
-                headers,
-                timeout: this.serverConfig.EXTERNAL_REQUEST_TIMEOUT_MS,
-            })
-
-            let responseBody = await fetchResponse.text()
-            try {
-                responseBody = JSON.parse(responseBody)
-            } catch (err) {
-                // Ignore
-            }
-
-            const duration = performance.now() - start
-
-            asyncFunctionResponse.timings!.push({
-                kind: 'async_function',
-                duration_ms: duration,
-            })
-
-            asyncFunctionResponse.response = {
-                status: fetchResponse.status,
-                body: responseBody,
-            }
-        } catch (err) {
-            status.error('🦔', `[HogExecutor] Error during fetch`, { error: String(err) })
-            asyncFunctionResponse.error = 'Something went wrong with the fetch request.'
-        }
-
-        const response: HogFunctionInvocationAsyncResponse = {
-            state: request.state,
-            teamId: request.teamId,
-            hogFunctionId: request.hogFunctionId,
-            asyncFunctionResponse,
-        }
-
-        return response
-    }
-}
-
-function toUint8Array(data: any): Uint8Array | undefined {
-    if (data === null || data === undefined) {
-        return undefined
-    }
-
-    if (data instanceof Uint8Array) {
-        return data
-    }
-
-    if (data instanceof ArrayBuffer) {
-        return new Uint8Array(data)
-    }
-
-    if (typeof data === 'string') {
-        return new TextEncoder().encode(data)
-    }
-
-    return new TextEncoder().encode(JSON.stringify(data))
-}
diff --git a/plugin-server/src/cdp/cdp-api.ts b/plugin-server/src/cdp/cdp-api.ts
index 943091af13814..34de05942471e 100644
--- a/plugin-server/src/cdp/cdp-api.ts
+++ b/plugin-server/src/cdp/cdp-api.ts
@@ -4,16 +4,17 @@ import { DateTime } from 'luxon'
 import { Hub } from '../types'
 import { status } from '../utils/status'
 import { delay } from '../utils/utils'
-import { AsyncFunctionExecutor } from './async-function-executor'
+import { FetchExecutor } from './fetch-executor'
 import { HogExecutor } from './hog-executor'
 import { HogFunctionManager } from './hog-function-manager'
 import { HogWatcher, HogWatcherState } from './hog-watcher'
-import { HogFunctionInvocation, HogFunctionInvocationAsyncRequest, HogFunctionType, LogEntry } from './types'
+import { HogFunctionInvocationResult, HogFunctionType, LogEntry } from './types'
+import { createInvocation } from './utils'
 
 export class CdpApi {
     private hogExecutor: HogExecutor
     private hogFunctionManager: HogFunctionManager
-    private asyncFunctionExecutor: AsyncFunctionExecutor
+    private fetchExecutor: FetchExecutor
     private hogWatcher: HogWatcher
 
     constructor(
@@ -21,13 +22,13 @@ export class CdpApi {
         dependencies: {
             hogExecutor: HogExecutor
             hogFunctionManager: HogFunctionManager
-            asyncFunctionExecutor: AsyncFunctionExecutor
+            fetchExecutor: FetchExecutor
             hogWatcher: HogWatcher
         }
     ) {
         this.hogExecutor = dependencies.hogExecutor
         this.hogFunctionManager = dependencies.hogFunctionManager
-        this.asyncFunctionExecutor = dependencies.asyncFunctionExecutor
+        this.fetchExecutor = dependencies.fetchExecutor
         this.hogWatcher = dependencies.hogWatcher
     }
 
@@ -104,14 +105,6 @@ export class CdpApi {
                 return
             }
 
-            const invocation: HogFunctionInvocation = {
-                id,
-                globals: globals,
-                teamId: team.id,
-                hogFunctionId: id,
-                timings: [],
-            }
-
             // We use the provided config if given, otherwise the function's config
             // We use the provided config if given, otherwise the function's config
             const compoundConfiguration: HogFunctionType = {
@@ -119,64 +112,72 @@ export class CdpApi {
                 ...(configuration ?? {}),
             }
 
-            // TODO: Type the configuration better so we don't make mistakes here
             await this.hogFunctionManager.enrichWithIntegrations([compoundConfiguration])
 
-            let response = this.hogExecutor.execute(compoundConfiguration, invocation)
+            let lastResponse: HogFunctionInvocationResult | null = null
             const logs: LogEntry[] = []
 
-            while (response.asyncFunctionRequest) {
-                invocation.vmState = response.invocation.vmState
-
-                const asyncFunctionRequest = response.asyncFunctionRequest
-
-                if (mock_async_functions || asyncFunctionRequest.name !== 'fetch') {
-                    response.logs.push({
-                        level: 'info',
-                        timestamp: DateTime.now(),
-                        message: `Async function '${asyncFunctionRequest.name}' was mocked with arguments:`,
-                    })
-
-                    response.logs.push({
-                        level: 'info',
-                        timestamp: DateTime.now(),
-                        message: `${asyncFunctionRequest.name}(${asyncFunctionRequest.args
-                            .map((x) => JSON.stringify(x, null, 2))
-                            .join(', ')})`,
-                    })
+            let count = 0
 
-                    // Add the state, simulating what executeAsyncResponse would do
-                    invocation.vmState!.stack.push({ status: 200, body: {} })
-                } else {
-                    const asyncInvocationRequest: HogFunctionInvocationAsyncRequest = {
-                        state: '', // WE don't care about the state for this level of testing
-                        teamId: team.id,
-                        hogFunctionId: hogFunction.id,
-                        asyncFunctionRequest,
-                    }
-                    const asyncRes = await this.asyncFunctionExecutor!.execute(asyncInvocationRequest, {
-                        sync: true,
-                    })
-
-                    if (!asyncRes || asyncRes.asyncFunctionResponse.error) {
-                        response.logs.push({
-                            level: 'error',
-                            timestamp: DateTime.now(),
-                            message: 'Failed to execute async function',
-                        })
+            while (!lastResponse || !lastResponse.finished) {
+                if (count > 5) {
+                    throw new Error('Too many iterations')
+                }
+                count += 1
+
+                let response: HogFunctionInvocationResult
+
+                const invocation =
+                    lastResponse?.invocation ||
+                    createInvocation(
+                        {
+                            ...globals,
+                            project: {
+                                id: team.id,
+                                name: team.name,
+                                url: `${this.hub.SITE_URL ?? 'http://localhost:8000'}/project/${team.id}`,
+                            },
+                        },
+                        compoundConfiguration
+                    )
+
+                if (invocation.queue === 'fetch') {
+                    if (mock_async_functions) {
+                        // Add the state, simulating what executeAsyncResponse would do
+                        response = {
+                            invocation: {
+                                ...invocation,
+                                queue: 'hog',
+                                queueParameters: { response: { status: 200, body: {} } },
+                            },
+                            finished: false,
+                            logs: [
+                                {
+                                    level: 'info',
+                                    timestamp: DateTime.now(),
+                                    message: `Async function 'fetch' was mocked with arguments:`,
+                                },
+                                {
+                                    level: 'info',
+                                    timestamp: DateTime.now(),
+                                    message: `fetch(${JSON.stringify(invocation.queueParameters, null, 2)})`,
+                                },
+                            ],
+                        }
+                    } else {
+                        response = await this.fetchExecutor!.executeLocally(invocation)
                     }
-                    invocation.vmState!.stack.push(asyncRes?.asyncFunctionResponse.response ?? null)
+                } else {
+                    response = this.hogExecutor.execute(invocation)
                 }
 
                 logs.push(...response.logs)
-                response = this.hogExecutor.execute(compoundConfiguration, invocation)
+                lastResponse = response
             }
 
-            logs.push(...response.logs)
-
             res.json({
-                status: response.finished ? 'success' : 'error',
-                error: String(response.error),
+                status: lastResponse.finished ? 'success' : 'error',
+                error: String(lastResponse.error),
                 logs: logs,
             })
         } catch (e) {
diff --git a/plugin-server/src/cdp/cdp-consumers.ts b/plugin-server/src/cdp/cdp-consumers.ts
index fef401d472927..984cd03a23cfd 100644
--- a/plugin-server/src/cdp/cdp-consumers.ts
+++ b/plugin-server/src/cdp/cdp-consumers.ts
@@ -1,28 +1,27 @@
 import cyclotron from '@posthog/cyclotron'
 import { captureException } from '@sentry/node'
-import { features, librdkafkaVersion, Message } from 'node-rdkafka'
+import { Message } from 'node-rdkafka'
 import { Counter, Histogram } from 'prom-client'
 
 import {
     KAFKA_APP_METRICS_2,
     KAFKA_CDP_FUNCTION_CALLBACKS,
-    KAFKA_CDP_FUNCTION_OVERFLOW,
     KAFKA_EVENTS_JSON,
     KAFKA_EVENTS_PLUGIN_INGESTION,
     KAFKA_LOG_ENTRIES,
 } from '../config/kafka-topics'
 import { BatchConsumer, startBatchConsumer } from '../kafka/batch-consumer'
-import { createRdConnectionConfigFromEnvVars, createRdProducerConfigFromEnvVars } from '../kafka/config'
-import { createKafkaProducer } from '../kafka/producer'
+import { createRdConnectionConfigFromEnvVars } from '../kafka/config'
 import { addSentryBreadcrumbsEventListeners } from '../main/ingestion-queues/kafka-metrics'
 import { runInstrumentedFunction } from '../main/utils'
-import { AppMetric2Type, Hub, RawClickHouseEvent, TeamId, TimestampFormat } from '../types'
+import { AppMetric2Type, Hub, PluginServerService, RawClickHouseEvent, TeamId, TimestampFormat } from '../types'
+import { createKafkaProducerWrapper } from '../utils/db/hub'
 import { KafkaProducerWrapper } from '../utils/db/kafka-producer-wrapper'
 import { captureTeamEvent } from '../utils/posthog'
 import { status } from '../utils/status'
 import { castTimestampOrNow } from '../utils/utils'
 import { RustyHook } from '../worker/rusty-hook'
-import { AsyncFunctionExecutor } from './async-function-executor'
+import { FetchExecutor } from './fetch-executor'
 import { GroupsManager } from './groups-manager'
 import { HogExecutor } from './hog-executor'
 import { HogFunctionManager } from './hog-function-manager'
@@ -30,20 +29,19 @@ import { HogMasker } from './hog-masker'
 import { HogWatcher, HogWatcherState } from './hog-watcher'
 import { CdpRedis, createCdpRedisPool } from './redis'
 import {
-    CdpOverflowMessage,
-    HogFunctionAsyncFunctionResponse,
     HogFunctionInvocation,
-    HogFunctionInvocationAsyncRequest,
-    HogFunctionInvocationAsyncResponse,
     HogFunctionInvocationGlobals,
     HogFunctionInvocationResult,
+    HogFunctionInvocationSerialized,
+    HogFunctionInvocationSerializedCompressed,
     HogFunctionMessageToProduce,
-    HogFunctionOverflowedGlobals,
     HogFunctionType,
+    HogHooksFetchResponse,
 } from './types'
 import {
     convertToCaptureEvent,
     convertToHogFunctionInvocationGlobals,
+    createInvocation,
     gzipObject,
     prepareLogEntriesForClickhouse,
     unGzipObject,
@@ -70,12 +68,6 @@ const counterFunctionInvocation = new Counter({
     labelNames: ['outcome'], // One of 'failed', 'succeeded', 'overflowed', 'disabled', 'filtered'
 })
 
-const counterAsyncFunctionResponse = new Counter({
-    name: 'cdp_async_function_response',
-    help: 'An async function response was received with an outcome',
-    labelNames: ['outcome'], // One of 'failed', 'succeeded', 'overflowed', 'disabled', 'filtered'
-})
-
 export interface TeamIDWithConfig {
     teamId: TeamId | null
     consoleLogIngestionEnabled: boolean
@@ -84,7 +76,7 @@ export interface TeamIDWithConfig {
 abstract class CdpConsumerBase {
     batchConsumer?: BatchConsumer
     hogFunctionManager: HogFunctionManager
-    asyncFunctionExecutor: AsyncFunctionExecutor
+    fetchExecutor: FetchExecutor
     hogExecutor: HogExecutor
     hogWatcher: HogWatcher
     hogMasker: HogMasker
@@ -109,10 +101,19 @@ abstract class CdpConsumerBase {
         this.hogMasker = new HogMasker(this.redis)
         this.hogExecutor = new HogExecutor(this.hogFunctionManager)
         const rustyHook = this.hub?.rustyHook ?? new RustyHook(this.hub)
-        this.asyncFunctionExecutor = new AsyncFunctionExecutor(this.hub, rustyHook)
+        this.fetchExecutor = new FetchExecutor(this.hub, rustyHook)
         this.groupsManager = new GroupsManager(this.hub)
     }
 
+    public get service(): PluginServerService {
+        return {
+            id: this.consumerGroupId,
+            onShutdown: async () => await this.stop(),
+            healthcheck: () => this.isHealthy() ?? false,
+            batchConsumer: this.batchConsumer,
+        }
+    }
+
     private async captureInternalPostHogEvent(
         hogFunctionId: HogFunctionType['id'],
         event: string,
@@ -154,29 +155,9 @@ abstract class CdpConsumerBase {
         return results
     }
 
-    public async handleEachBatch(messages: Message[], heartbeat: () => void): Promise<void> {
-        status.info('🔁', `${this.name} - handling batch`, {
-            size: messages.length,
-        })
-
-        this.heartbeat = heartbeat
-
-        histogramKafkaBatchSize.observe(messages.length)
-        histogramKafkaBatchSizeKb.observe(messages.reduce((acc, m) => (m.value?.length ?? 0) + acc, 0) / 1024)
-
-        return await runInstrumentedFunction({
-            statsKey: `cdpConsumer.handleEachBatch`,
-            sendTimeoutGuardToSentry: false,
-            func: async () => {
-                await this._handleEachBatch(messages)
-                await this.produceQueuedMessages()
-            },
-        })
-    }
-
-    protected abstract _handleEachBatch(messages: Message[]): Promise<void>
+    protected abstract _handleKafkaBatch(messages: Message[]): Promise<void>
 
-    private async produceQueuedMessages() {
+    protected async produceQueuedMessages() {
         const messages = [...this.messagesToProduce]
         this.messagesToProduce = []
         await Promise.all(
@@ -223,21 +204,57 @@ abstract class CdpConsumerBase {
         })
     }
 
+    protected async queueInvocations(invocation: HogFunctionInvocation[]) {
+        await Promise.all(
+            invocation.map(async (item) => {
+                await this.queueInvocation(item)
+            })
+        )
+    }
+
+    protected async queueInvocation(invocation: HogFunctionInvocation) {
+        // TODO: Add cylcotron check here and enqueue that way
+        // For now we just enqueue to kafka
+        // For kafka style this is overkill to enqueue this way but it simplifies migrating to the new system
+
+        const serializedInvocation: HogFunctionInvocationSerialized = {
+            ...invocation,
+            hogFunctionId: invocation.hogFunction.id,
+        }
+
+        delete (serializedInvocation as any).hogFunction
+
+        const request: HogFunctionInvocationSerializedCompressed = {
+            state: await gzipObject(serializedInvocation),
+        }
+
+        // NOTE: This is very temporary as it is producing the response. the response will actually be produced by the 3rd party service
+        // Later this will actually be the _request_ which we will push to the async function topic if we make one
+        this.messagesToProduce.push({
+            topic: KAFKA_CDP_FUNCTION_CALLBACKS,
+            value: request,
+            key: invocation.hogFunction.id,
+        })
+    }
+
     protected async processInvocationResults(results: HogFunctionInvocationResult[]): Promise<void> {
         await runInstrumentedFunction({
             statsKey: `cdpConsumer.handleEachBatch.produceResults`,
             func: async () => {
+                console.log('Processing invocations results', results.length)
+
                 await Promise.all(
                     results.map(async (result) => {
                         // Tricky: We want to pull all the logs out as we don't want them to be passed around to any subsequent functions
-
-                        this.produceAppMetric({
-                            team_id: result.invocation.teamId,
-                            app_source_id: result.invocation.hogFunctionId,
-                            metric_kind: result.error ? 'failure' : 'success',
-                            metric_name: result.error ? 'failed' : 'succeeded',
-                            count: 1,
-                        })
+                        if (result.finished || result.error) {
+                            this.produceAppMetric({
+                                team_id: result.invocation.teamId,
+                                app_source_id: result.invocation.hogFunction.id,
+                                metric_kind: result.error ? 'failure' : 'success',
+                                metric_name: result.error ? 'failed' : 'succeeded',
+                                count: 1,
+                            })
+                        }
 
                         this.produceLogs(result)
 
@@ -257,24 +274,9 @@ abstract class CdpConsumerBase {
                             })
                         }
 
-                        if (result.asyncFunctionRequest) {
-                            const request: HogFunctionInvocationAsyncRequest = {
-                                state: await gzipObject(result.invocation),
-                                teamId: result.invocation.teamId,
-                                hogFunctionId: result.invocation.hogFunctionId,
-                                asyncFunctionRequest: result.asyncFunctionRequest,
-                            }
-                            const res = await this.runWithHeartbeat(() => this.asyncFunctionExecutor.execute(request))
-
-                            // NOTE: This is very temporary as it is producing the response. the response will actually be produced by the 3rd party service
-                            // Later this will actually be the _request_ which we will push to the async function topic if we make one
-                            if (res) {
-                                this.messagesToProduce.push({
-                                    topic: KAFKA_CDP_FUNCTION_CALLBACKS,
-                                    value: res,
-                                    key: res.hogFunctionId,
-                                })
-                            }
+                        if (!result.finished) {
+                            // If it isn't finished then we need to put it back on the queue
+                            await this.queueInvocation(result.invocation)
                         }
                     })
                 )
@@ -282,53 +284,149 @@ abstract class CdpConsumerBase {
         })
     }
 
-    protected async executeAsyncResponses(
-        asyncResponses: HogFunctionInvocationAsyncResponse[]
-    ): Promise<HogFunctionInvocationResult[]> {
-        return await runInstrumentedFunction({
-            statsKey: `cdpConsumer.handleEachBatch.executeAsyncResponses`,
-            func: async () => {
-                asyncResponses.forEach((x) => {
-                    counterAsyncFunctionResponse.inc({
-                        outcome: x.asyncFunctionResponse.error ? 'failed' : 'succeeded',
-                    })
+    protected async startKafkaConsumer() {
+        this.batchConsumer = await startBatchConsumer({
+            connectionConfig: createRdConnectionConfigFromEnvVars(this.hub),
+            groupId: this.consumerGroupId,
+            topic: this.topic,
+            autoCommit: true,
+            sessionTimeout: this.hub.KAFKA_CONSUMPTION_SESSION_TIMEOUT_MS,
+            maxPollIntervalMs: this.hub.KAFKA_CONSUMPTION_MAX_POLL_INTERVAL_MS,
+            // the largest size of a message that can be fetched by the consumer.
+            // the largest size our MSK cluster allows is 20MB
+            // we only use 9 or 10MB but there's no reason to limit this 🤷️
+            consumerMaxBytes: this.hub.KAFKA_CONSUMPTION_MAX_BYTES,
+            consumerMaxBytesPerPartition: this.hub.KAFKA_CONSUMPTION_MAX_BYTES_PER_PARTITION,
+            // our messages are very big, so we don't want to buffer too many
+            // queuedMinMessages: this.hub.KAFKA_QUEUE_SIZE,
+            consumerMaxWaitMs: this.hub.KAFKA_CONSUMPTION_MAX_WAIT_MS,
+            consumerErrorBackoffMs: this.hub.KAFKA_CONSUMPTION_ERROR_BACKOFF_MS,
+            fetchBatchSize: this.hub.INGESTION_BATCH_SIZE,
+            batchingTimeoutMs: this.hub.KAFKA_CONSUMPTION_BATCHING_TIMEOUT_MS,
+            topicCreationTimeoutMs: this.hub.KAFKA_TOPIC_CREATION_TIMEOUT_MS,
+            topicMetadataRefreshInterval: this.hub.KAFKA_TOPIC_METADATA_REFRESH_INTERVAL_MS,
+            eachBatch: async (messages, { heartbeat }) => {
+                status.info('🔁', `${this.name} - handling batch`, {
+                    size: messages.length,
                 })
 
-                const invocationsWithResponses: [HogFunctionInvocation, HogFunctionAsyncFunctionResponse][] = []
+                this.heartbeat = heartbeat
 
-                // Deserialize the compressed data
-                await Promise.all(
-                    asyncResponses.map(async (item) => {
-                        try {
-                            const invocation = await unGzipObject<HogFunctionInvocation>(item.state)
-                            invocationsWithResponses.push([invocation, item.asyncFunctionResponse])
-                        } catch (e) {
-                            status.error('Error unzipping message', e, item.state)
-                            captureException(e, {
-                                extra: { hogFunctionId: item.hogFunctionId, teamId: item.teamId },
-                            })
-                        }
-                    })
-                )
+                histogramKafkaBatchSize.observe(messages.length)
+                histogramKafkaBatchSizeKb.observe(messages.reduce((acc, m) => (m.value?.length ?? 0) + acc, 0) / 1024)
 
-                const results = await this.runManyWithHeartbeat(invocationsWithResponses, (item) =>
-                    this.hogExecutor.executeAsyncResponse(...item)
-                )
-
-                await this.hogWatcher.observeResults(results)
-                return results
+                return await runInstrumentedFunction({
+                    statsKey: `cdpConsumer.handleEachBatch`,
+                    sendTimeoutGuardToSentry: false,
+                    func: async () => {
+                        await this._handleKafkaBatch(messages)
+                    },
+                })
             },
+            callEachBatchWhenEmpty: false,
         })
+
+        addSentryBreadcrumbsEventListeners(this.batchConsumer.consumer)
+
+        this.batchConsumer.consumer.on('disconnected', async (err) => {
+            // since we can't be guaranteed that the consumer will be stopped before some other code calls disconnect
+            // we need to listen to disconnect and make sure we're stopped
+            status.info('🔁', `${this.name} batch consumer disconnected, cleaning up`, { err })
+            await this.stop()
+        })
+    }
+
+    public async start(): Promise<void> {
+        // NOTE: This is only for starting shared services
+        await Promise.all([
+            this.hogFunctionManager.start(),
+            this.hub.CYCLOTRON_DATABASE_URL
+                ? cyclotron.initManager({ shards: [{ dbUrl: this.hub.CYCLOTRON_DATABASE_URL }] })
+                : Promise.resolve(),
+        ])
+
+        this.kafkaProducer = await createKafkaProducerWrapper(this.hub)
+        this.kafkaProducer.producer.connect()
+
+        await this.startKafkaConsumer()
     }
 
-    protected async executeMatchingFunctions(
+    public async stop(): Promise<void> {
+        status.info('🔁', `${this.name} - stopping`)
+        this.isStopping = true
+
+        // Mark as stopping so that we don't actually process any more incoming messages, but still keep the process alive
+        status.info('🔁', `${this.name} - stopping batch consumer`)
+        await this.batchConsumer?.stop()
+        status.info('🔁', `${this.name} - stopping kafka producer`)
+        await this.kafkaProducer?.disconnect()
+        status.info('🔁', `${this.name} - stopping hog function manager and hog watcher`)
+        await Promise.all([this.hogFunctionManager.stop()])
+
+        status.info('👍', `${this.name} - stopped!`)
+    }
+
+    public isHealthy() {
+        // TODO: Check either kafka consumer or cyclotron worker exists
+        // and that whatever exists is healthy
+        return this.batchConsumer?.isHealthy()
+    }
+}
+
+/**
+ * This consumer handles incoming events from the main clickhouse topic
+ */
+
+export class CdpProcessedEventsConsumer extends CdpConsumerBase {
+    protected name = 'CdpProcessedEventsConsumer'
+    protected topic = KAFKA_EVENTS_JSON
+    protected consumerGroupId = 'cdp-processed-events-consumer'
+
+    public async processBatch(invocationGlobals: HogFunctionInvocationGlobals[]): Promise<HogFunctionInvocation[]> {
+        if (!invocationGlobals.length) {
+            return []
+        }
+
+        const invocationsToBeQueued = await this.runWithHeartbeat(() =>
+            this.createHogFunctionInvocations(invocationGlobals)
+        )
+
+        if (this.hub.CDP_EVENT_PROCESSOR_EXECUTE_FIRST_STEP) {
+            // NOTE: This is for testing the two ways of enqueueing processing. It will be swapped out for a cyclotron env check
+            // Kafka based workflow
+            const invocationResults = await runInstrumentedFunction({
+                statsKey: `cdpConsumer.handleEachBatch.executeInvocations`,
+                func: async () => {
+                    const hogResults = await this.runManyWithHeartbeat(invocationsToBeQueued, (item) =>
+                        this.hogExecutor.execute(item)
+                    )
+                    return [...hogResults]
+                },
+            })
+
+            await this.hogWatcher.observeResults(invocationResults)
+            await this.processInvocationResults(invocationResults)
+        } else {
+            await this.queueInvocations(invocationsToBeQueued)
+        }
+
+        await this.produceQueuedMessages()
+
+        return invocationsToBeQueued
+    }
+
+    /**
+     * Finds all matching hog functions for the given globals.
+     * Filters them for their disabled state as well as masking configs
+     *
+     */
+    protected async createHogFunctionInvocations(
         invocationGlobals: HogFunctionInvocationGlobals[]
-    ): Promise<HogFunctionInvocationResult[]> {
+    ): Promise<HogFunctionInvocation[]> {
         return await runInstrumentedFunction({
-            statsKey: `cdpConsumer.handleEachBatch.executeMatchingFunctions`,
+            statsKey: `cdpConsumer.handleEachBatch.queueMatchingFunctions`,
             func: async () => {
-                const possibleInvocations: { globals: HogFunctionInvocationGlobals; hogFunction: HogFunctionType }[] =
-                    []
+                const possibleInvocations: HogFunctionInvocation[] = []
 
                 // TODO: Add a helper to hog functions to determine if they require groups or not and then only load those
                 await this.groupsManager.enrichGroups(invocationGlobals)
@@ -338,10 +436,7 @@ abstract class CdpConsumerBase {
                     const { matchingFunctions, nonMatchingFunctions } = this.hogExecutor.findMatchingFunctions(globals)
 
                     possibleInvocations.push(
-                        ...matchingFunctions.map((hogFunction) => ({
-                            globals,
-                            hogFunction,
-                        }))
+                        ...matchingFunctions.map((hogFunction) => createInvocation(globals, hogFunction))
                     )
 
                     nonMatchingFunctions.forEach((item) =>
@@ -391,365 +486,212 @@ abstract class CdpConsumerBase {
                     })
                 })
 
-                const overflowGlobalsAndFunctions: Record<string, HogFunctionOverflowedGlobals> = {}
-
-                const notOverflowedInvocations = notMaskedInvocations.filter((item) => {
-                    const state = states[item.hogFunction.id].state
-
-                    if (state === HogWatcherState.degraded) {
-                        const key = `${item.globals.project.id}-${item.globals.event.uuid}`
-                        overflowGlobalsAndFunctions[key] = overflowGlobalsAndFunctions[key] || {
-                            globals: item.globals,
-                            hogFunctionIds: [],
-                        }
-
-                        overflowGlobalsAndFunctions[key].hogFunctionIds.push(item.hogFunction.id)
-                        counterFunctionInvocation.inc({ outcome: 'overflowed' }, 1)
-                        return false
-                    }
-
-                    return true
-                })
-
-                Object.values(overflowGlobalsAndFunctions).forEach((item) => {
-                    this.messagesToProduce.push({
-                        topic: KAFKA_CDP_FUNCTION_OVERFLOW,
-                        value: {
-                            source: 'event_invocations',
-                            payload: item,
-                        },
-                        key: item.globals.event.uuid,
-                    })
-                })
-
-                const results = (
-                    await this.runManyWithHeartbeat(notOverflowedInvocations, (item) =>
-                        this.hogExecutor.executeFunction(item.globals, item.hogFunction)
-                    )
-                ).filter((x) => !!x) as HogFunctionInvocationResult[]
-
-                await this.hogWatcher.observeResults(results)
-                return results
+                return notMaskedInvocations
             },
         })
     }
 
-    public async start(): Promise<void> {
-        status.info('🔁', `${this.name} - starting`, {
-            librdKafkaVersion: librdkafkaVersion,
-            kafkaCapabilities: features,
-        })
-
-        // NOTE: This is the only place where we need to use the shared server config
-        const globalConnectionConfig = createRdConnectionConfigFromEnvVars(this.hub)
-        const globalProducerConfig = createRdProducerConfigFromEnvVars(this.hub)
-
-        await Promise.all([
-            this.hogFunctionManager.start(),
-            this.hub.CYCLOTRON_DATABASE_URL
-                ? cyclotron.initManager({ shards: [{ dbUrl: this.hub.CYCLOTRON_DATABASE_URL }] })
-                : Promise.resolve(),
-        ])
-
-        this.kafkaProducer = new KafkaProducerWrapper(
-            await createKafkaProducer(globalConnectionConfig, globalProducerConfig)
-        )
-
-        this.kafkaProducer.producer.connect()
-
-        this.batchConsumer = await startBatchConsumer({
-            connectionConfig: createRdConnectionConfigFromEnvVars(this.hub),
-            groupId: this.consumerGroupId,
-            topic: this.topic,
-            autoCommit: true,
-            sessionTimeout: this.hub.KAFKA_CONSUMPTION_SESSION_TIMEOUT_MS,
-            maxPollIntervalMs: this.hub.KAFKA_CONSUMPTION_MAX_POLL_INTERVAL_MS,
-            // the largest size of a message that can be fetched by the consumer.
-            // the largest size our MSK cluster allows is 20MB
-            // we only use 9 or 10MB but there's no reason to limit this 🤷️
-            consumerMaxBytes: this.hub.KAFKA_CONSUMPTION_MAX_BYTES,
-            consumerMaxBytesPerPartition: this.hub.KAFKA_CONSUMPTION_MAX_BYTES_PER_PARTITION,
-            // our messages are very big, so we don't want to buffer too many
-            // queuedMinMessages: this.hub.KAFKA_QUEUE_SIZE,
-            consumerMaxWaitMs: this.hub.KAFKA_CONSUMPTION_MAX_WAIT_MS,
-            consumerErrorBackoffMs: this.hub.KAFKA_CONSUMPTION_ERROR_BACKOFF_MS,
-            fetchBatchSize: this.hub.INGESTION_BATCH_SIZE,
-            batchingTimeoutMs: this.hub.KAFKA_CONSUMPTION_BATCHING_TIMEOUT_MS,
-            topicCreationTimeoutMs: this.hub.KAFKA_TOPIC_CREATION_TIMEOUT_MS,
-            topicMetadataRefreshInterval: this.hub.KAFKA_TOPIC_METADATA_REFRESH_INTERVAL_MS,
-            eachBatch: async (messages, { heartbeat }) => {
-                return await this.handleEachBatch(messages, heartbeat)
-            },
-            callEachBatchWhenEmpty: false,
-        })
-
-        addSentryBreadcrumbsEventListeners(this.batchConsumer.consumer)
-
-        this.batchConsumer.consumer.on('disconnected', async (err) => {
-            // since we can't be guaranteed that the consumer will be stopped before some other code calls disconnect
-            // we need to listen to disconnect and make sure we're stopped
-            status.info('🔁', `${this.name} batch consumer disconnected, cleaning up`, { err })
-            await this.stop()
-        })
-    }
-
-    public async stop(): Promise<void> {
-        status.info('🔁', `${this.name} - stopping`)
-        this.isStopping = true
-
-        // Mark as stopping so that we don't actually process any more incoming messages, but still keep the process alive
-        status.info('🔁', `${this.name} - stopping batch consumer`)
-        await this.batchConsumer?.stop()
-        status.info('🔁', `${this.name} - stopping kafka producer`)
-        await this.kafkaProducer?.disconnect()
-        status.info('🔁', `${this.name} - stopping hog function manager and hog watcher`)
-        await Promise.all([this.hogFunctionManager.stop()])
-
-        status.info('👍', `${this.name} - stopped!`)
-    }
-
-    public isHealthy() {
-        return this.batchConsumer?.isHealthy()
-    }
-}
-
-/**
- * This consumer handles incoming events from the main clickhouse topic
- */
-
-export class CdpProcessedEventsConsumer extends CdpConsumerBase {
-    protected name = 'CdpProcessedEventsConsumer'
-    protected topic = KAFKA_EVENTS_JSON
-    protected consumerGroupId = 'cdp-processed-events-consumer'
-
-    public async _handleEachBatch(messages: Message[]): Promise<void> {
+    // This consumer always parses from kafka
+    public async _handleKafkaBatch(messages: Message[]): Promise<void> {
         const invocationGlobals = await this.runWithHeartbeat(() =>
             runInstrumentedFunction({
                 statsKey: `cdpConsumer.handleEachBatch.parseKafkaMessages`,
-                func: async () => await this.parseMessages(messages),
-            })
-        )
-
-        if (!invocationGlobals.length) {
-            return
-        }
-
-        const invocationResults = await this.runWithHeartbeat(() => this.executeMatchingFunctions(invocationGlobals))
-
-        await this.processInvocationResults(invocationResults)
-    }
-
-    private async parseMessages(messages: Message[]): Promise<HogFunctionInvocationGlobals[]> {
-        const events: HogFunctionInvocationGlobals[] = []
-        await Promise.all(
-            messages.map(async (message) => {
-                try {
-                    const clickHouseEvent = JSON.parse(message.value!.toString()) as RawClickHouseEvent
-
-                    if (!this.hogFunctionManager.teamHasHogFunctions(clickHouseEvent.team_id)) {
-                        // No need to continue if the team doesn't have any functions
-                        return
-                    }
-
-                    const team = await this.hub.teamManager.fetchTeam(clickHouseEvent.team_id)
-                    if (!team) {
-                        return
-                    }
-                    events.push(
-                        convertToHogFunctionInvocationGlobals(
-                            clickHouseEvent,
-                            team,
-                            this.hub.SITE_URL ?? 'http://localhost:8000'
-                        )
+                func: async () => {
+                    const events: HogFunctionInvocationGlobals[] = []
+                    await Promise.all(
+                        messages.map(async (message) => {
+                            try {
+                                const clickHouseEvent = JSON.parse(message.value!.toString()) as RawClickHouseEvent
+
+                                if (!this.hogFunctionManager.teamHasHogFunctions(clickHouseEvent.team_id)) {
+                                    // No need to continue if the team doesn't have any functions
+                                    return
+                                }
+
+                                const team = await this.hub.teamManager.fetchTeam(clickHouseEvent.team_id)
+                                if (!team) {
+                                    return
+                                }
+                                events.push(
+                                    convertToHogFunctionInvocationGlobals(
+                                        clickHouseEvent,
+                                        team,
+                                        this.hub.SITE_URL ?? 'http://localhost:8000'
+                                    )
+                                )
+                            } catch (e) {
+                                status.error('Error parsing message', e)
+                            }
+                        })
                     )
-                } catch (e) {
-                    status.error('Error parsing message', e)
-                }
+
+                    return events
+                },
             })
         )
 
-        return events
+        await this.processBatch(invocationGlobals)
     }
 }
 
 /**
- * This consumer handles callbacks from async functions.
+ * This consumer handles actually invoking hog in a loop
  */
 export class CdpFunctionCallbackConsumer extends CdpConsumerBase {
     protected name = 'CdpFunctionCallbackConsumer'
     protected topic = KAFKA_CDP_FUNCTION_CALLBACKS
     protected consumerGroupId = 'cdp-function-callback-consumer'
 
-    public async _handleEachBatch(messages: Message[]): Promise<void> {
-        const events = await this.runWithHeartbeat(() =>
-            runInstrumentedFunction({
-                statsKey: `cdpConsumer.handleEachBatch.parseKafkaMessages`,
-                func: () => Promise.resolve(this.parseMessages(messages)),
-            })
-        )
-
-        if (!events.length) {
+    public async processBatch(invocations: HogFunctionInvocation[]): Promise<void> {
+        if (!invocations.length) {
             return
         }
 
-        const invocationResults = await this.runWithHeartbeat(() => this.executeAsyncResponses(events))
-
-        await this.processInvocationResults(invocationResults)
-    }
+        const invocationResults = await runInstrumentedFunction({
+            statsKey: `cdpConsumer.handleEachBatch.executeInvocations`,
+            func: async () => {
+                // NOTE: In the future this service will never do fetching (unless we decide we want to do it in node at some point)
+                // This is just "for now" to support the transition to cyclotron
+                const fetchQueue = invocations.filter((item) => item.queue === 'fetch')
+                const fetchResults = await this.runManyWithHeartbeat(fetchQueue, (item) =>
+                    this.fetchExecutor.execute(item)
+                )
 
-    private parseMessages(messages: Message[]): HogFunctionInvocationAsyncResponse[] {
-        const events: HogFunctionInvocationAsyncResponse[] = []
-        messages.map((message) => {
-            try {
-                const event = JSON.parse(message.value!.toString())
-                events.push(event as HogFunctionInvocationAsyncResponse)
-            } catch (e) {
-                status.error('Error parsing message', e)
-            }
+                const hogQueue = invocations.filter((item) => item.queue === 'hog')
+                const hogResults = await this.runManyWithHeartbeat(hogQueue, (item) => this.hogExecutor.execute(item))
+                return [...hogResults, ...(fetchResults.filter(Boolean) as HogFunctionInvocationResult[])]
+            },
         })
 
-        return events
+        await this.hogWatcher.observeResults(invocationResults)
+        await this.processInvocationResults(invocationResults)
+        await this.produceQueuedMessages()
     }
-}
 
-/**
- * This consumer handles overflow for both incoming events as well as callbacks.
- * In the future we might want multiple consumers but for now this is fine.
- */
-
-export class CdpOverflowConsumer extends CdpConsumerBase {
-    protected name = 'CdpOverflowConsumer'
-    protected topic = KAFKA_CDP_FUNCTION_OVERFLOW
-    protected consumerGroupId = 'cdp-overflow-consumer'
-
-    public async _handleEachBatch(messages: Message[]): Promise<void> {
-        const overflowedGlobals = await this.runWithHeartbeat(() =>
+    public async _handleKafkaBatch(messages: Message[]): Promise<void> {
+        const events = await this.runWithHeartbeat(() =>
             runInstrumentedFunction({
                 statsKey: `cdpConsumer.handleEachBatch.parseKafkaMessages`,
-                func: () => Promise.resolve(this.parseMessages(messages)),
-            })
-        )
-
-        const invocationResults = await this.executeOverflowedFunctions(overflowedGlobals)
-
-        await this.processInvocationResults(invocationResults)
-    }
+                func: async () => {
+                    // TRICKY: In the future we won't use kafka. For now though we need to parse messages as Cyclotron style jobs
+                    // or hoghooks async callbacks
+
+                    const invocations: HogFunctionInvocation[] = []
+
+                    // Parse the base message value
+                    const entries: (HogHooksFetchResponse | HogFunctionInvocationSerializedCompressed)[] = messages
+                        .map((message) => {
+                            try {
+                                return JSON.parse(message.value!.toString())
+                            } catch (e) {
+                                status.error('Error parsing message', e)
+                            }
 
-    protected async executeOverflowedFunctions(
-        invocationGlobals: HogFunctionOverflowedGlobals[]
-    ): Promise<HogFunctionInvocationResult[]> {
-        return await runInstrumentedFunction({
-            statsKey: `cdpConsumer.handleEachBatch.executeOverflowedFunctions`,
-            func: async () => {
-                // TODO: Add a helper to hog functions to determine if they require groups or not and then only load those
-                await this.groupsManager.enrichGroups(invocationGlobals.map((x) => x.globals))
-
-                const invocations = invocationGlobals
-                    .map((item) =>
-                        item.hogFunctionIds.map((hogFunctionId) => ({
-                            globals: item.globals,
-                            hogFunctionId,
-                        }))
+                            return undefined
+                        })
+                        .filter(Boolean)
+
+                    // Deserialize the compressed data
+                    await Promise.all(
+                        entries.map(async (item) => {
+                            try {
+                                const invocationSerialized = await unGzipObject<HogFunctionInvocationSerialized>(
+                                    item.state
+                                )
+
+                                if ('asyncFunctionResponse' in item) {
+                                    // This means it is a callback from hoghooks so we need to add the response to the invocation
+                                    invocationSerialized.queue = 'hog'
+                                    invocationSerialized.queueParameters = item.asyncFunctionResponse
+                                }
+
+                                const hogFunction =
+                                    invocationSerialized.hogFunction ??
+                                    (invocationSerialized.hogFunctionId
+                                        ? this.hogFunctionManager.getHogFunction(invocationSerialized.hogFunctionId)
+                                        : undefined)
+
+                                if (!hogFunction) {
+                                    status.error('Error finding hog function', {
+                                        id: invocationSerialized.hogFunctionId,
+                                    })
+                                    return
+                                }
+
+                                const invocation: HogFunctionInvocation = {
+                                    ...invocationSerialized,
+                                    hogFunction,
+                                }
+
+                                delete (invocation as any).hogFunctionId
+
+                                invocations.push(invocation)
+                            } catch (e) {
+                                status.error('Error unzipping message', e, item.state)
+                                captureException(e)
+                            }
+                        })
                     )
-                    .flat()
 
-                const states = await this.hogWatcher.getStates(invocationGlobals.map((x) => x.hogFunctionIds).flat())
-
-                const results = (
-                    await this.runManyWithHeartbeat(invocations, (item) => {
-                        const state = states[item.hogFunctionId].state
-                        if (state >= HogWatcherState.disabledForPeriod) {
-                            this.produceAppMetric({
-                                team_id: item.globals.project.id,
-                                app_source_id: item.hogFunctionId,
-                                metric_kind: 'failure',
-                                metric_name:
-                                    state === HogWatcherState.disabledForPeriod
-                                        ? 'disabled_temporarily'
-                                        : 'disabled_permanently',
-                                count: 1,
-                            })
-                            return
+                    invocations.forEach((item) => {
+                        if (!item.hogFunction?.id) {
+                            console.error('No hog function id', item)
                         }
-                        return this.hogExecutor.executeFunction(item.globals, item.hogFunctionId)
                     })
-                ).filter((x) => !!x) as HogFunctionInvocationResult[]
-
-                await this.hogWatcher.observeResults(results)
-                return results
-            },
-        })
-    }
 
-    private parseMessages(messages: Message[]): HogFunctionOverflowedGlobals[] {
-        const invocationGlobals: HogFunctionOverflowedGlobals[] = []
-        messages.map((message) => {
-            try {
-                const parsed = JSON.parse(message.value!.toString()) as CdpOverflowMessage
-
-                if (parsed.source === 'event_invocations') {
-                    invocationGlobals.push(parsed.payload)
-                }
-            } catch (e) {
-                // TODO: We probably want to crash here right as this means something went really wrong and needs investigating?
-                status.error('Error parsing message', e)
-            }
-        })
+                    return invocations
+                },
+            })
+        )
 
-        return invocationGlobals
+        await this.processBatch(events)
     }
 }
 
-// TODO: Split out non-Kafka specific parts of CdpConsumerBase so that it can be used by the
-// Cyclotron worker below. Or maybe we can just wait, and rip the Kafka bits out once Cyclotron is
-// shipped (and rename it something other than consomer, probably). For now, this is an easy way to
-// use existing code and get an end-to-end demo shipped.
-export class CdpCyclotronWorker extends CdpConsumerBase {
-    protected name = 'CdpCyclotronWorker'
-    protected topic = 'UNUSED-CdpCyclotronWorker'
-    protected consumerGroupId = 'UNUSED-CdpCyclotronWorker'
-    private runningWorker: Promise<void> | undefined
-    private isUnhealthy = false
-
-    public async _handleEachBatch(_: Message[]): Promise<void> {
-        // Not called, we override `start` below to use Cyclotron instead.
-    }
-
-    private async innerStart() {
-        try {
-            const limit = 100 // TODO: Make configurable.
-            while (!this.isStopping) {
-                const jobs = await cyclotron.dequeueJobsWithVmState('hog', limit)
-                for (const job of jobs) {
-                    // TODO: Reassemble a HogFunctionInvocationAsyncResponse (or whatever proper type)
-                    // from the fields on the job, and then execute the next Hog step.
-                    console.log(job.id)
-                }
-            }
-        } catch (err) {
-            this.isUnhealthy = true
-            console.error('Error in Cyclotron worker', err)
-            throw err
-        }
-    }
-
-    public async start() {
-        await cyclotron.initManager({ shards: [{ dbUrl: this.hub.CYCLOTRON_DATABASE_URL }] })
-        await cyclotron.initWorker({ dbUrl: this.hub.CYCLOTRON_DATABASE_URL })
-
-        // Consumer `start` expects an async task is started, and not that `start` itself blocks
-        // indefinitely.
-        this.runningWorker = this.innerStart()
-
-        return Promise.resolve()
-    }
-
-    public async stop() {
-        await super.stop()
-        await this.runningWorker
-    }
-
-    public isHealthy() {
-        return this.isUnhealthy
-    }
-}
+// // TODO: Split out non-Kafka specific parts of CdpConsumerBase so that it can be used by the
+// // Cyclotron worker below. Or maybe we can just wait, and rip the Kafka bits out once Cyclotron is
+// // shipped (and rename it something other than consumer, probably). For now, this is an easy way to
+// // use existing code and get an end-to-end demo shipped.
+// export class CdpCyclotronWorker extends CdpFunctionCallbackConsumer {
+//     protected name = 'CdpCyclotronWorker'
+//     protected topic = 'UNUSED-CdpCyclotronWorker'
+//     protected consumerGroupId = 'UNUSED-CdpCyclotronWorker'
+//     private runningWorker: Promise<void> | undefined
+//     private isUnhealthy = false
+
+//     private async innerStart() {
+//         try {
+//             const limit = 100 // TODO: Make configurable.
+//             while (!this.isStopping) {
+//                 const jobs = await cyclotron.dequeueJobsWithVmState('hog', limit)
+//                 // TODO: Decode jobs into the right types
+
+//                 await this.processBatch(jobs)
+//             }
+//         } catch (err) {
+//             this.isUnhealthy = true
+//             console.error('Error in Cyclotron worker', err)
+//             throw err
+//         }
+//     }
+
+//     public async start() {
+//         await cyclotron.initManager({ shards: [{ dbUrl: this.hub.CYCLOTRON_DATABASE_URL }] })
+//         await cyclotron.initWorker({ dbUrl: this.hub.CYCLOTRON_DATABASE_URL })
+
+//         // Consumer `start` expects an async task is started, and not that `start` itself blocks
+//         // indefinitely.
+//         this.runningWorker = this.innerStart()
+
+//         return Promise.resolve()
+//     }
+
+//     public async stop() {
+//         await super.stop()
+//         await this.runningWorker
+//     }
+
+//     public isHealthy() {
+//         return this.isUnhealthy
+//     }
+// }
diff --git a/plugin-server/src/cdp/fetch-executor.ts b/plugin-server/src/cdp/fetch-executor.ts
new file mode 100644
index 0000000000000..b2e99ef0a1836
--- /dev/null
+++ b/plugin-server/src/cdp/fetch-executor.ts
@@ -0,0 +1,143 @@
+import { Histogram } from 'prom-client'
+
+import { buildIntegerMatcher } from '../config/config'
+import { PluginsServerConfig, ValueMatcher } from '../types'
+import { trackedFetch } from '../utils/fetch'
+import { status } from '../utils/status'
+import { RustyHook } from '../worker/rusty-hook'
+import {
+    HogFunctionInvocation,
+    HogFunctionInvocationAsyncRequest,
+    HogFunctionInvocationResult,
+    HogFunctionQueueParametersFetchRequest,
+    HogFunctionQueueParametersFetchResponse,
+} from './types'
+import { gzipObject } from './utils'
+
+export const BUCKETS_KB_WRITTEN = [0, 128, 512, 1024, 2024, 4096, 10240, Infinity]
+
+const histogramFetchPayloadSize = new Histogram({
+    name: 'cdp_async_function_fetch_payload_size_kb',
+    help: 'The size in kb of the batches we are receiving from Kafka',
+    buckets: BUCKETS_KB_WRITTEN,
+})
+
+const histogramHogHooksPayloadSize = new Histogram({
+    name: 'cdp_async_function_hoghooks_payload_size_kb',
+    help: 'The size in kb of the batches we are receiving from Kafka',
+    buckets: BUCKETS_KB_WRITTEN,
+})
+
+/**
+ * This class is only used by the kafka based queuing system. For the Cyclotron system there is no need for this.
+ */
+export class FetchExecutor {
+    hogHookEnabledForTeams: ValueMatcher<number>
+
+    constructor(private serverConfig: PluginsServerConfig, private rustyHook: RustyHook) {
+        this.hogHookEnabledForTeams = buildIntegerMatcher(serverConfig.CDP_ASYNC_FUNCTIONS_RUSTY_HOOK_TEAMS, true)
+    }
+
+    async execute(invocation: HogFunctionInvocation): Promise<HogFunctionInvocationResult | undefined> {
+        if (invocation.queue !== 'fetch' || !invocation.queueParameters) {
+            throw new Error('Bad invocation')
+        }
+
+        const params = invocation.queueParameters as HogFunctionQueueParametersFetchRequest
+        if (params.body) {
+            histogramFetchPayloadSize.observe(params.body.length / 1024)
+        }
+
+        try {
+            if (this.hogHookEnabledForTeams(invocation.teamId)) {
+                // This is very temporary until we are commited to Cyclotron
+                const payload: HogFunctionInvocationAsyncRequest = {
+                    state: await gzipObject(invocation),
+                    teamId: invocation.teamId,
+                    hogFunctionId: invocation.hogFunction.id,
+                    asyncFunctionRequest: {
+                        name: 'fetch',
+                        args: [
+                            params.url,
+                            {
+                                ...params,
+                            },
+                        ],
+                    },
+                }
+                const hoghooksPayload = JSON.stringify(payload)
+                histogramHogHooksPayloadSize.observe(hoghooksPayload.length / 1024)
+                const enqueued = await this.rustyHook.enqueueForHog(hoghooksPayload)
+                if (enqueued) {
+                    // We return nothing here hoghooks will take care of that
+                    return
+                }
+            }
+
+            status.info('🦔', `[HogExecutor] Webhook not sent via rustyhook, sending directly instead`)
+        } catch (err) {
+            status.error('🦔', `[HogExecutor] Error during fetch`, { error: String(err) })
+        }
+
+        return await this.executeLocally(invocation)
+    }
+
+    async executeLocally(invocation: HogFunctionInvocation): Promise<HogFunctionInvocationResult> {
+        if (invocation.queue !== 'fetch' || !invocation.queueParameters) {
+            throw new Error('Bad invocation')
+        }
+
+        const params = invocation.queueParameters as HogFunctionQueueParametersFetchRequest
+
+        const resParams: HogFunctionQueueParametersFetchResponse = {
+            response: {
+                status: 0,
+                body: {},
+            },
+            error: null,
+            timings: [],
+        }
+
+        try {
+            const start = performance.now()
+            const fetchResponse = await trackedFetch(params.url, {
+                method: params.method,
+                body: params.body,
+                headers: params.headers,
+                timeout: this.serverConfig.EXTERNAL_REQUEST_TIMEOUT_MS,
+            })
+
+            let responseBody = await fetchResponse.text()
+            try {
+                responseBody = JSON.parse(responseBody)
+            } catch (err) {
+                // Ignore
+            }
+
+            const duration = performance.now() - start
+
+            resParams.timings!.push({
+                kind: 'async_function',
+                duration_ms: duration,
+            })
+
+            resParams.response = {
+                status: fetchResponse.status,
+                body: responseBody,
+            }
+        } catch (err) {
+            status.error('🦔', `[HogExecutor] Error during fetch`, { error: String(err) })
+            resParams.error = 'Something went wrong with the fetch request.'
+        }
+
+        return {
+            invocation: {
+                ...invocation,
+                queue: 'hog',
+                queueParameters: resParams,
+            },
+            finished: false,
+            logs: [],
+        }
+    }
+}
diff --git a/plugin-server/src/cdp/hog-executor.ts b/plugin-server/src/cdp/hog-executor.ts
index 1e9fb6719aaa3..382f6b3fc3549 100644
--- a/plugin-server/src/cdp/hog-executor.ts
+++ b/plugin-server/src/cdp/hog-executor.ts
@@ -5,14 +5,13 @@ import { Histogram } from 'prom-client'
 import RE2 from 're2'
 
 import { status } from '../utils/status'
-import { UUIDT } from '../utils/utils'
 import { HogFunctionManager } from './hog-function-manager'
 import {
     HogFunctionInvocation,
-    HogFunctionInvocationAsyncResponse,
     HogFunctionInvocationGlobals,
     HogFunctionInvocationGlobalsWithInputs,
     HogFunctionInvocationResult,
+    HogFunctionQueueParametersFetchResponse,
     HogFunctionType,
 } from './types'
 import { convertToHogFunctionFilterGlobal } from './utils'
@@ -128,115 +127,11 @@ export class HogExecutor {
         }
     }
 
-    /**
-     * Intended to be invoked as a starting point from an event
-     */
-    executeFunction(
-        event: HogFunctionInvocationGlobals,
-        functionOrId: HogFunctionType | HogFunctionType['id']
-    ): HogFunctionInvocationResult | undefined {
-        const hogFunction =
-            typeof functionOrId === 'string'
-                ? this.hogFunctionManager.getTeamHogFunction(event.project.id, functionOrId)
-                : functionOrId
-
-        if (!hogFunction) {
-            return
-        }
-
-        // Add the source of the trigger to the globals
-        const modifiedGlobals: HogFunctionInvocationGlobals = {
-            ...event,
-            source: {
-                name: hogFunction.name ?? `Hog function: ${hogFunction.id}`,
-                url: `${event.project.url}/pipeline/destinations/hog-${hogFunction.id}/configuration/`,
-            },
-        }
-
-        return this.execute(hogFunction, {
-            id: new UUIDT().toString(),
-            globals: modifiedGlobals,
-            teamId: hogFunction.team_id,
-            hogFunctionId: hogFunction.id,
-            timings: [],
-        })
-    }
-
-    /**
-     * Intended to be invoked as a continuation from an async function
-     */
-    executeAsyncResponse(
-        invocation: HogFunctionInvocation,
-        asyncFunctionResponse: HogFunctionInvocationAsyncResponse['asyncFunctionResponse']
-    ): HogFunctionInvocationResult {
-        if (!invocation.hogFunctionId) {
-            throw new Error('No hog function id provided')
-        }
-
-        const { logs = [], response = null, error: asyncError, timings = [] } = asyncFunctionResponse
-
-        if (response?.status && response.status >= 400) {
-            // Generic warn log for bad status codes
-            logs.push({
-                level: 'warn',
-                timestamp: DateTime.now(),
-                message: `Fetch returned bad status: ${response.status}`,
-            })
-        }
-
-        const errorRes = (error = 'Something went wrong'): HogFunctionInvocationResult => ({
-            invocation,
-            finished: false,
-            error,
-            logs: [
-                ...logs,
-                {
-                    level: 'error',
-                    timestamp: DateTime.now(),
-                    message: error,
-                },
-            ],
-        })
-
-        const hogFunction = this.hogFunctionManager.getTeamHogFunction(
-            invocation.globals.project.id,
-            invocation.hogFunctionId
-        )
-
-        if (!hogFunction || !invocation.vmState || asyncError) {
-            return errorRes(
-                !hogFunction
-                    ? `Hog Function with ID ${invocation.hogFunctionId} not found`
-                    : asyncError
-                    ? asyncError
-                    : 'No VM state provided for async response'
-            )
-        }
-
-        if (typeof response?.body === 'string') {
-            try {
-                response.body = JSON.parse(response.body)
-            } catch (e) {
-                // pass - if it isn't json we just pass it on
-            }
-        }
-
-        // Add the response to the stack to continue execution
-        invocation.vmState.stack.push(response)
-        invocation.timings.push(...timings)
-
-        const res = this.execute(hogFunction, invocation)
-
-        // Add any timings and logs from the async function
-        res.logs = [...(logs ?? []), ...res.logs]
-
-        return res
-    }
-
-    execute(hogFunction: HogFunctionType, invocation: HogFunctionInvocation): HogFunctionInvocationResult {
+    execute(invocation: HogFunctionInvocation): HogFunctionInvocationResult {
         const loggingContext = {
-            hogFunctionId: hogFunction.id,
-            hogFunctionName: hogFunction.name,
+            invocationId: invocation.id,
+            hogFunctionId: invocation.hogFunction.id,
+            hogFunctionName: invocation.hogFunction.name,
             hogFunctionUrl: invocation.globals.source?.url,
         }
 
@@ -244,7 +139,6 @@ export class HogExecutor {
 
         const result: HogFunctionInvocationResult = {
             invocation,
-            asyncFunctionRequest: undefined,
             finished: false,
             capturedPostHogEvents: [],
             logs: [],
@@ -257,12 +151,58 @@ export class HogExecutor {
         })
 
         try {
+            // If the queueParameter is set then we have an expected format that we want to parse and add to the stack
+            if (invocation.queueParameters) {
+                const {
+                    logs = [],
+                    response = null,
+                    error,
+                    timings = [],
+                } = invocation.queueParameters as HogFunctionQueueParametersFetchResponse
+
+                // Reset the queue parameters to be sure
+                invocation.queue = 'hog'
+                invocation.queueParameters = undefined
+
+                // Special handling for fetch
+                // TODO: Would be good to have a dedicated value in the fetch response for the status code
+                if (response?.status && response.status >= 400) {
+                    // Generic warn log for bad status codes
+                    logs.push({
+                        level: 'warn',
+                        timestamp: DateTime.now(),
+                        message: `Fetch returned bad status: ${response.status}`,
+                    })
+                }
+
+                if (!invocation.vmState) {
+                    throw new Error("VM state wasn't provided for queue parameters")
+                }
+
+                if (error) {
+                    throw new Error(error)
+                }
+
+                if (typeof response?.body === 'string') {
+                    try {
+                        response.body = JSON.parse(response.body)
+                    } catch (e) {
+                        // pass - if it isn't json we just pass it on
+                    }
+                }
+
+                // Add the response to the stack to continue execution
+                invocation.vmState!.stack.push(response)
+                invocation.timings.push(...timings)
+                result.logs = [...logs, ...result.logs]
+            }
+
             const start = performance.now()
             let globals: HogFunctionInvocationGlobalsWithInputs
             let execRes: ExecResult | undefined = undefined
 
             try {
-                globals = this.buildHogFunctionGlobals(hogFunction, invocation)
+                globals = this.buildHogFunctionGlobals(invocation)
             } catch (e) {
                 result.logs.push({
                     level: 'error',
@@ -273,11 +213,11 @@ export class HogExecutor {
                 throw e
             }
 
-            const sensitiveValues = this.getSensitiveValues(hogFunction, globals.inputs)
+            const sensitiveValues = this.getSensitiveValues(invocation.hogFunction, globals.inputs)
 
             try {
                 let hogLogs = 0
-                execRes = execHog(invocation.vmState ?? hogFunction.bytecode, {
+                execRes = execHog(invocation.vmState ?? invocation.hogFunction.bytecode, {
                     globals,
                     maxAsyncSteps: MAX_ASYNC_STEPS, // NOTE: This will likely be configurable in the future
                     asyncFunctions: {
@@ -353,6 +293,7 @@ export class HogExecutor {
             hogExecutionDuration.observe(duration)
 
             result.finished = execRes.finished
+            result.invocation.vmState = execRes.state
             invocation.timings.push({
                 kind: 'hog',
                 duration_ms: duration,
@@ -373,10 +314,34 @@ export class HogExecutor {
                 })
 
                 if (execRes.asyncFunctionName) {
-                    result.invocation.vmState = execRes.state
-                    result.asyncFunctionRequest = {
-                        name: execRes.asyncFunctionName,
-                        args: args,
+                    switch (execRes.asyncFunctionName) {
+                        case 'fetch':
+                            // Sanitize the args
+                            const [url, fetchOptions] = args as [string | undefined, Record<string, any> | undefined]
+
+                            if (typeof url !== 'string') {
+                                throw new Error('fetch: Invalid URL')
+                            }
+
+                            const method = fetchOptions?.method || 'POST'
+                            const headers = fetchOptions?.headers || {
+                                'Content-Type': 'application/json',
+                            }
+                            let body = fetchOptions?.body
+                            // Modify the body to ensure it is a string (we allow Hog to send an object to keep things simple)
+                            body = body ? (typeof body === 'string' ? body : JSON.stringify(body)) : body
+
+                            result.invocation.queue = 'fetch'
+                            result.invocation.queueParameters = {
+                                url,
+                                method,
+                                headers,
+                                body,
+                            }
+
+                            break
+                        default:
+                            throw new Error(`Unknown async function '${execRes.asyncFunctionName}'`)
                     }
                 } else {
                     result.logs.push({
@@ -401,19 +366,20 @@ export class HogExecutor {
             }
         } catch (err) {
             result.error = err.message
-            status.error('🦔', `[HogExecutor] Error executing function ${hogFunction.id} - ${hogFunction.name}`, err)
+            status.error(
+                '🦔',
+                `[HogExecutor] Error executing function ${invocation.hogFunction.id} - ${invocation.hogFunction.name}`,
+                err
+            )
         }
 
         return result
     }
 
-    buildHogFunctionGlobals(
-        hogFunction: HogFunctionType,
-        invocation: HogFunctionInvocation
-    ): HogFunctionInvocationGlobalsWithInputs {
+    buildHogFunctionGlobals(invocation: HogFunctionInvocation): HogFunctionInvocationGlobalsWithInputs {
         const builtInputs: Record<string, any> = {}
 
-        Object.entries(hogFunction.inputs ?? {}).forEach(([key, item]) => {
+        Object.entries(invocation.hogFunction.inputs ?? {}).forEach(([key, item]) => {
             builtInputs[key] = item.value
 
             if (item.bytecode) {
diff --git a/plugin-server/src/cdp/hog-masker.ts b/plugin-server/src/cdp/hog-masker.ts
index 0ab4cfcb5c299..2f204ab855552 100644
--- a/plugin-server/src/cdp/hog-masker.ts
+++ b/plugin-server/src/cdp/hog-masker.ts
@@ -2,7 +2,7 @@ import { createHash } from 'crypto'
 
 import { execHog } from './hog-executor'
 import { CdpRedis } from './redis'
-import { HogFunctionInvocationGlobals, HogFunctionType } from './types'
+import { HogFunctionInvocation } from './types'
 
 export const BASE_REDIS_KEY = process.env.NODE_ENV == 'test' ? '@posthog-test/hog-masker' : '@posthog/hog-masker'
 const REDIS_KEY_TOKENS = `${BASE_REDIS_KEY}/mask`
@@ -20,12 +20,7 @@ type MaskContext = {
     threshold: number | null
 }
 
-type HogInvocationContext = {
-    globals: HogFunctionInvocationGlobals
-    hogFunction: HogFunctionType
-}
-
-type HogInvocationContextWithMasker = HogInvocationContext & {
+type HogInvocationContextWithMasker = HogFunctionInvocation & {
     masker?: MaskContext
 }
 
@@ -39,9 +34,9 @@ type HogInvocationContextWithMasker = HogInvocationContext & {
 export class HogMasker {
     constructor(private redis: CdpRedis) {}
 
-    public async filterByMasking(invocations: HogInvocationContext[]): Promise<{
-        masked: HogInvocationContext[]
-        notMasked: HogInvocationContext[]
+    public async filterByMasking(invocations: HogFunctionInvocation[]): Promise<{
+        masked: HogFunctionInvocation[]
+        notMasked: HogFunctionInvocation[]
     }> {
         const invocationsWithMasker: HogInvocationContextWithMasker[] = [...invocations]
         const masks: Record<string, MaskContext> = {}
@@ -123,7 +118,7 @@ export class HogMasker {
                 }
                 return acc
             },
-            { masked: [], notMasked: [] } as { masked: HogInvocationContext[]; notMasked: HogInvocationContext[] }
+            { masked: [], notMasked: [] } as { masked: HogFunctionInvocation[]; notMasked: HogFunctionInvocation[] }
         )
     }
 }
diff --git a/plugin-server/src/cdp/hog-watcher.ts b/plugin-server/src/cdp/hog-watcher.ts
index 0e80c1a3cac41..38a2a3901b776 100644
--- a/plugin-server/src/cdp/hog-watcher.ts
+++ b/plugin-server/src/cdp/hog-watcher.ts
@@ -124,7 +124,7 @@ export class HogWatcher {
         const costs: Record<HogFunctionType['id'], number> = {}
 
         results.forEach((result) => {
-            let cost = (costs[result.invocation.hogFunctionId] = costs[result.invocation.hogFunctionId] || 0)
+            let cost = (costs[result.invocation.hogFunction.id] = costs[result.invocation.hogFunction.id] || 0)
 
             if (result.finished) {
                 // If it is finished we can calculate the score based off of the timings
@@ -142,7 +142,7 @@ export class HogWatcher {
                 cost += this.hub.CDP_WATCHER_COST_ERROR
             }
 
-            costs[result.invocation.hogFunctionId] = cost
+            costs[result.invocation.hogFunction.id] = cost
         })
 
         const res = await this.redis.usePipeline({ name: 'checkRateLimits' }, (pipeline) => {
diff --git a/plugin-server/src/cdp/types.ts b/plugin-server/src/cdp/types.ts
index a0079fb51d22a..9d277bc4edfa8 100644
--- a/plugin-server/src/cdp/types.ts
+++ b/plugin-server/src/cdp/types.ts
@@ -7,6 +7,7 @@ import {
     ElementPropertyFilter,
     EventPropertyFilter,
     PersonPropertyFilter,
+    Team,
 } from '../types'
 
 export type HogBytecode = any[]
@@ -85,11 +86,6 @@ export type HogFunctionInvocationGlobalsWithInputs = HogFunctionInvocationGlobal
     inputs: Record<string, any>
 }
 
-export type HogFunctionOverflowedGlobals = {
-    hogFunctionIds: HogFunctionType['id'][]
-    globals: HogFunctionInvocationGlobals
-}
-
 export type HogFunctionFilterGlobals = {
     // Filter Hog is built in the same way as analytics so the global object is meant to be an event
     event: string
@@ -147,23 +143,14 @@ export interface HogFunctionTiming {
     duration_ms: number
 }
 
-// This is the "persistent" state of a hog function invocation
-export type HogFunctionInvocation = {
-    id: string
-    globals: HogFunctionInvocationGlobals
-    teamId: number
-    hogFunctionId: HogFunctionType['id']
-    // The current vmstate (set if the invocation is paused)
-    vmState?: VMState
-    timings: HogFunctionTiming[]
-}
-
-export type HogFunctionAsyncFunctionRequest = {
-    name: string
-    args: any[]
+export type HogFunctionQueueParametersFetchRequest = {
+    url: string
+    method: string
+    body: string
+    headers: Record<string, string>
 }
 
-export type HogFunctionAsyncFunctionResponse = {
+export type HogFunctionQueueParametersFetchResponse = {
     /** An error message to indicate something went wrong and the invocation should be stopped */
     error?: any
     /** The data to be passed to the Hog function from the response */
@@ -175,12 +162,33 @@ export type HogFunctionAsyncFunctionResponse = {
     logs?: LogEntry[]
 }
 
+export type HogFunctionInvocationQueueParameters =
+    | HogFunctionQueueParametersFetchRequest
+    | HogFunctionQueueParametersFetchResponse
+
+export type HogFunctionInvocation = {
+    id: string
+    globals: HogFunctionInvocationGlobals
+    teamId: Team['id']
+    hogFunction: HogFunctionType
+    queue: 'hog' | 'fetch'
+    queueParameters?: HogFunctionInvocationQueueParameters
+    // The current vmstate (set if the invocation is paused)
+    vmState?: VMState
+    timings: HogFunctionTiming[]
+}
+
+export type HogFunctionAsyncFunctionRequest = {
+    name: string
+    args: any[]
+}
+
 // The result of an execution
 export type HogFunctionInvocationResult = {
     invocation: HogFunctionInvocation
     finished: boolean
     error?: any
-    asyncFunctionRequest?: HogFunctionAsyncFunctionRequest
+    // asyncFunctionRequest?: HogFunctionAsyncFunctionRequest
     logs: LogEntry[]
     capturedPostHogEvents?: HogFunctionCapturedEvent[]
 }
@@ -192,13 +200,21 @@ export type HogFunctionInvocationAsyncRequest = {
     asyncFunctionRequest?: HogFunctionAsyncFunctionRequest
 }
 
-export type HogFunctionInvocationAsyncResponse = {
+export type HogHooksFetchResponse = {
     state: string // Serialized HogFunctionInvocation
     teamId: number
     hogFunctionId: HogFunctionType['id']
+    asyncFunctionResponse: HogFunctionQueueParametersFetchResponse
+}
 
-    // FOLLOWUP: do we want to type this more strictly?
-    asyncFunctionResponse: HogFunctionAsyncFunctionResponse
+export type HogFunctionInvocationSerialized = Omit<HogFunctionInvocation, 'hogFunction'> & {
+    // When serialized to kafka / cyclotron we only store the ID
+    hogFunctionId?: HogFunctionType['id']
+    hogFunction?: HogFunctionType
+}
+
+export type HogFunctionInvocationSerializedCompressed = {
+    state: string // Serialized HogFunctionInvocation
 }
 
 // Mostly copied from frontend types
@@ -249,16 +265,13 @@ export type IntegrationType = {
     created_by_id?: number
 }
 
-type CdpOverflowMessageInvocations = {
-    source: 'event_invocations'
-    payload: HogFunctionOverflowedGlobals
-}
-
-export type CdpOverflowMessage = CdpOverflowMessageInvocations
-
 export type HogFunctionMessageToProduce = {
     topic: string
-    value: CdpOverflowMessage | HogFunctionLogEntrySerialized | HogFunctionInvocationAsyncResponse | AppMetric2Type
+    value:
+        | HogFunctionLogEntrySerialized
+        | HogHooksFetchResponse
+        | AppMetric2Type
+        | HogFunctionInvocationSerializedCompressed
     key: string
 }
 
diff --git a/plugin-server/src/cdp/utils.ts b/plugin-server/src/cdp/utils.ts
index a381a1b9b4c87..93664abef9234 100644
--- a/plugin-server/src/cdp/utils.ts
+++ b/plugin-server/src/cdp/utils.ts
@@ -10,9 +10,11 @@ import { castTimestampOrNow, clickHouseTimestampToISO, UUIDT } from '../utils/ut
 import {
     HogFunctionCapturedEvent,
     HogFunctionFilterGlobals,
+    HogFunctionInvocation,
     HogFunctionInvocationGlobals,
     HogFunctionInvocationResult,
     HogFunctionLogEntrySerialized,
+    HogFunctionType,
 } from './types'
 
 export const PERSON_DEFAULT_DISPLAY_NAME_PROPERTIES = [
@@ -235,7 +237,7 @@ export const prepareLogEntriesForClickhouse = (
             ...logEntry,
             team_id: result.invocation.teamId,
             log_source: 'hog_function',
-            log_source_id: result.invocation.hogFunctionId,
+            log_source_id: result.invocation.hogFunction.id,
             instance_id: result.invocation.id,
             timestamp: castTimestampOrNow(logEntry.timestamp, TimestampFormat.ClickHouse),
         }
@@ -244,3 +246,26 @@ export const prepareLogEntriesForClickhouse = (
 
     return preparedLogs
 }
+
+export function createInvocation(
+    globals: HogFunctionInvocationGlobals,
+    hogFunction: HogFunctionType
+): HogFunctionInvocation {
+    // Add the source of the trigger to the globals
+    const modifiedGlobals: HogFunctionInvocationGlobals = {
+        ...globals,
+        source: {
+            name: hogFunction.name ?? `Hog function: ${hogFunction.id}`,
+            url: `${globals.project.url}/pipeline/destinations/hog-${hogFunction.id}/configuration/`,
+        },
+    }
+
+    return {
+        id: new UUIDT().toString(),
+        globals: modifiedGlobals,
+        teamId: hogFunction.team_id,
+        hogFunction,
+        queue: 'hog',
+        timings: [],
+    }
+}
diff --git a/plugin-server/src/config/config.ts b/plugin-server/src/config/config.ts
index 7de2856530e14..afa2ba1d72fe3 100644
--- a/plugin-server/src/config/config.ts
+++ b/plugin-server/src/config/config.ts
@@ -108,10 +108,6 @@ export function getDefaultConfig(): PluginsServerConfig {
         CLICKHOUSE_DISABLE_EXTERNAL_SCHEMAS_TEAMS: '',
         CLICKHOUSE_JSON_EVENTS_KAFKA_TOPIC: KAFKA_EVENTS_JSON,
         CLICKHOUSE_HEATMAPS_KAFKA_TOPIC: KAFKA_CLICKHOUSE_HEATMAP_EVENTS,
-        CONVERSION_BUFFER_ENABLED: false,
-        CONVERSION_BUFFER_ENABLED_TEAMS: '',
-        CONVERSION_BUFFER_TOPIC_ENABLED_TEAMS: '',
-        BUFFER_CONVERSION_SECONDS: isDevEnv() ? 2 : 60, // KEEP IN SYNC WITH posthog/settings/ingestion.py
         PERSON_INFO_CACHE_TTL: 5 * 60, // 5 min
         KAFKA_HEALTHCHECK_SECONDS: 20,
         OBJECT_STORAGE_ENABLED: true,
@@ -189,6 +185,7 @@ export function getDefaultConfig(): PluginsServerConfig {
         CDP_ASYNC_FUNCTIONS_RUSTY_HOOK_TEAMS: '',
         CDP_ASYNC_FUNCTIONS_CYCLOTRON_TEAMS: '',
         CDP_REDIS_PASSWORD: '',
+        CDP_EVENT_PROCESSOR_EXECUTE_FIRST_STEP: true,
         CDP_REDIS_HOST: '',
         CDP_REDIS_PORT: 6479,
 
diff --git a/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-consumer.ts b/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-consumer.ts
index e452140931c7c..259d231e9d01a 100644
--- a/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-consumer.ts
+++ b/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-consumer.ts
@@ -3,7 +3,7 @@ import { Counter } from 'prom-client'
 
 import { buildStringMatcher } from '../../config/config'
 import { KAFKA_EVENTS_PLUGIN_INGESTION, prefix as KAFKA_PREFIX } from '../../config/kafka-topics'
-import { Hub } from '../../types'
+import { Hub, PluginServerService } from '../../types'
 import { status } from '../../utils/status'
 import { eachBatchParallelIngestion, IngestionOverflowMode } from './batch-processing/each-batch-ingestion'
 import { IngestionConsumer } from './kafka-queue'
@@ -18,7 +18,7 @@ export const startAnalyticsEventsIngestionConsumer = async ({
     hub, // TODO: remove needing to pass in the whole hub and be more selective on dependency injection.
 }: {
     hub: Hub
-}) => {
+}): Promise<PluginServerService> => {
     /*
         Consumes analytics events from the Kafka topic `events_plugin_ingestion`
         and processes them for ingestion into ClickHouse.
@@ -66,5 +66,10 @@ export const startAnalyticsEventsIngestionConsumer = async ({
 
     const { isHealthy } = await queue.start()
 
-    return { queue, isHealthy }
+    return {
+        id: 'analytics-ingestion',
+        batchConsumer: queue.consumer,
+        healthcheck: isHealthy,
+        onShutdown: () => queue.stop(),
+    }
 }
diff --git a/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-historical-consumer.ts b/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-historical-consumer.ts
index 92139751e9760..2b989eaeaab29 100644
--- a/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-historical-consumer.ts
+++ b/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-historical-consumer.ts
@@ -2,7 +2,7 @@ import { Message } from 'node-rdkafka'
 
 import { buildStringMatcher } from '../../config/config'
 import { KAFKA_EVENTS_PLUGIN_INGESTION_HISTORICAL, prefix as KAFKA_PREFIX } from '../../config/kafka-topics'
-import { Hub } from '../../types'
+import { Hub, PluginServerService } from '../../types'
 import { status } from '../../utils/status'
 import { eachBatchParallelIngestion, IngestionOverflowMode } from './batch-processing/each-batch-ingestion'
 import { IngestionConsumer } from './kafka-queue'
@@ -11,7 +11,7 @@ export const startAnalyticsEventsIngestionHistoricalConsumer = async ({
     hub, // TODO: remove needing to pass in the whole hub and be more selective on dependency injection.
 }: {
     hub: Hub
-}) => {
+}): Promise<PluginServerService> => {
     /*
         Consumes analytics events from the Kafka topic `events_plugin_ingestion_historical`
         and processes them for ingestion into ClickHouse.
@@ -39,5 +39,10 @@ export const startAnalyticsEventsIngestionHistoricalConsumer = async ({
 
     const { isHealthy } = await queue.start()
 
-    return { queue, isHealthy }
+    return {
+        id: 'analytics-ingestion-historical',
+        onShutdown: async () => await queue.stop(),
+        healthcheck: isHealthy,
+        batchConsumer: queue.consumer,
+    }
 }
diff --git a/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-overflow-consumer.ts b/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-overflow-consumer.ts
index 25f107c90466e..5d6667c283b72 100644
--- a/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-overflow-consumer.ts
+++ b/plugin-server/src/main/ingestion-queues/analytics-events-ingestion-overflow-consumer.ts
@@ -50,5 +50,10 @@ export const startAnalyticsEventsIngestionOverflowConsumer = async ({
 
     const { isHealthy } = await queue.start()
 
-    return { queue, isHealthy }
+    return {
+        id: 'analytics-ingestion-overflow',
+        onShutdown: async () => await queue.stop(),
+        healthcheck: isHealthy,
+        batchConsumer: queue.consumer,
+    }
 }
diff --git a/plugin-server/src/main/ingestion-queues/batch-processing/each-batch-ingestion.ts b/plugin-server/src/main/ingestion-queues/batch-processing/each-batch-ingestion.ts
index 245c2edc77baf..2757853e02ebc 100644
--- a/plugin-server/src/main/ingestion-queues/batch-processing/each-batch-ingestion.ts
+++ b/plugin-server/src/main/ingestion-queues/batch-processing/each-batch-ingestion.ts
@@ -170,7 +170,11 @@ export async function eachBatchParallelIngestion(
                 for (const { message, pluginEvent } of currentBatch) {
                     try {
                         const result = (await retryIfRetriable(async () => {
-                            const runner = new EventPipelineRunner(queue.pluginsServer, pluginEvent)
+                            const runner = new EventPipelineRunner(
+                                queue.pluginsServer,
+                                pluginEvent,
+                                queue.eventsProcessor
+                            )
                             return await runner.runEventPipeline(pluginEvent)
                         })) as IngestResult
 
diff --git a/plugin-server/src/main/ingestion-queues/events-ingestion-consumer.ts b/plugin-server/src/main/ingestion-queues/events-ingestion-consumer.ts
index 695185b8074f1..56ea4847db10e 100644
--- a/plugin-server/src/main/ingestion-queues/events-ingestion-consumer.ts
+++ b/plugin-server/src/main/ingestion-queues/events-ingestion-consumer.ts
@@ -2,7 +2,7 @@ import { Message } from 'node-rdkafka'
 
 import { buildStringMatcher } from '../../config/config'
 import { prefix as KAFKA_PREFIX, suffix as KAFKA_SUFFIX } from '../../config/kafka-topics'
-import { Hub } from '../../types'
+import { Hub, PluginServerService } from '../../types'
 import { status } from '../../utils/status'
 import { eachBatchParallelIngestion, IngestionOverflowMode } from './batch-processing/each-batch-ingestion'
 import { IngestionConsumer } from './kafka-queue'
@@ -27,16 +27,19 @@ export const PIPELINES: { [key: string]: PipelineType } = {
     },
 }
 
+export type PipelineKeyType = keyof typeof PIPELINES
+
 export const startEventsIngestionPipelineConsumer = async ({
     hub, // TODO: remove needing to pass in the whole hub and be more selective on dependency injection.
-    pipeline,
+    pipelineKey,
 }: {
     hub: Hub
-    pipeline: PipelineType
-}) => {
+    pipelineKey: PipelineKeyType
+}): Promise<PluginServerService> => {
     /*
         Consumes events from the topic and consumer passed in.
     */
+    const pipeline = PIPELINES[pipelineKey]
     const kafka_topic = `${KAFKA_PREFIX}${pipeline.topic}${KAFKA_SUFFIX}`
     const kafka_consumer = `${KAFKA_PREFIX}${pipeline.consumer_group}`
     status.info(
@@ -59,5 +62,10 @@ export const startEventsIngestionPipelineConsumer = async ({
 
     const { isHealthy } = await queue.start()
 
-    return { queue, isHealthy }
+    return {
+        id: `events-ingestion-pipeline-${pipelineKey}`,
+        onShutdown: async () => await queue.stop(),
+        healthcheck: isHealthy,
+        batchConsumer: queue.consumer,
+    }
 }
diff --git a/plugin-server/src/main/ingestion-queues/jobs-consumer.ts b/plugin-server/src/main/ingestion-queues/jobs-consumer.ts
index 605a812068c51..1ed19c2fc6fce 100644
--- a/plugin-server/src/main/ingestion-queues/jobs-consumer.ts
+++ b/plugin-server/src/main/ingestion-queues/jobs-consumer.ts
@@ -8,6 +8,7 @@ import { status } from '../../utils/status'
 import { GraphileWorker } from '../graphile-worker/graphile-worker'
 import { instrumentEachBatchKafkaJS, setupEventHandlers } from './kafka-queue'
 import { latestOffsetTimestampGauge } from './metrics'
+import { makeHealthCheck } from './on-event-handler-consumer'
 
 const jobsConsumerSuccessCounter = new Counter({
     name: 'jobs_consumer_enqueue_success_total',
@@ -125,10 +126,11 @@ export const startJobsConsumer = async ({
         },
     })
 
+    const healthcheck = makeHealthCheck(consumer, serverConfig.KAFKA_CONSUMPTION_SESSION_TIMEOUT_MS)
+
     return {
-        ...consumer,
-        stop: async () => {
-            await consumer.stop()
-        },
+        id: 'jobs-consumer',
+        healthcheck: async () => await healthcheck(),
+        onShutdown: async () => await consumer.stop(),
     }
 }
diff --git a/plugin-server/src/main/ingestion-queues/kafka-queue.ts b/plugin-server/src/main/ingestion-queues/kafka-queue.ts
index 5af4147b84e5b..1e7a58a0e076b 100644
--- a/plugin-server/src/main/ingestion-queues/kafka-queue.ts
+++ b/plugin-server/src/main/ingestion-queues/kafka-queue.ts
@@ -10,6 +10,7 @@ import { KafkaConfig } from '../../utils/db/hub'
 import { timeoutGuard } from '../../utils/db/utils'
 import { status } from '../../utils/status'
 import { killGracefully } from '../../utils/utils'
+import { EventsProcessor } from '../../worker/ingestion/process-event'
 import { addMetricsEventListeners } from './kafka-metrics'
 
 type ConsumerManagementPayload = {
@@ -166,20 +167,18 @@ type EachBatchFunction = (messages: Message[], queue: IngestionConsumer) => Prom
 
 export class IngestionConsumer {
     public pluginsServer: Hub
-    public consumerReady: boolean
     public topic: string
     public consumerGroupId: string
     public eachBatch: EachBatchFunction
     public consumer?: BatchConsumer
+    public eventsProcessor: EventsProcessor
 
     constructor(pluginsServer: Hub, topic: string, consumerGroupId: string, batchHandler: EachBatchFunction) {
         this.pluginsServer = pluginsServer
         this.topic = topic
         this.consumerGroupId = consumerGroupId
-
-        this.consumerReady = false
-
         this.eachBatch = batchHandler
+        this.eventsProcessor = new EventsProcessor(pluginsServer)
     }
 
     async start(): Promise<BatchConsumer> {
@@ -200,7 +199,6 @@ export class IngestionConsumer {
             topicMetadataRefreshInterval: this.pluginsServer.KAFKA_TOPIC_METADATA_REFRESH_INTERVAL_MS,
             eachBatch: (payload) => this.eachBatchConsumer(payload),
         })
-        this.consumerReady = true
         return this.consumer
     }
 
@@ -216,8 +214,6 @@ export class IngestionConsumer {
         } catch (error) {
             status.error('⚠️', 'An error occurred while stopping Kafka queue:\n', error)
         }
-
-        this.consumerReady = false
     }
 }
 
diff --git a/plugin-server/src/main/ingestion-queues/on-event-handler-consumer.ts b/plugin-server/src/main/ingestion-queues/on-event-handler-consumer.ts
index 4ebc588000c6e..6d24d6d722cf4 100644
--- a/plugin-server/src/main/ingestion-queues/on-event-handler-consumer.ts
+++ b/plugin-server/src/main/ingestion-queues/on-event-handler-consumer.ts
@@ -1,7 +1,7 @@
 import { Consumer, Kafka } from 'kafkajs'
 
 import { KAFKA_EVENTS_JSON, prefix as KAFKA_PREFIX } from '../../config/kafka-topics'
-import { Hub, PluginsServerConfig } from '../../types'
+import { Hub, PluginServerService, PluginsServerConfig } from '../../types'
 import { PostgresRouter } from '../../utils/db/postgres'
 import { status } from '../../utils/status'
 import { ActionManager } from '../../worker/ingestion/action-manager'
@@ -20,7 +20,7 @@ export const startAsyncOnEventHandlerConsumer = async ({
     hub, // TODO: remove needing to pass in the whole hub and be more selective on dependency injection.
 }: {
     hub: Hub
-}) => {
+}): Promise<PluginServerService> => {
     /*
         Consumes analytics events from the Kafka topic `clickhouse_events_json`
         and processes any onEvent plugin handlers configured for the team.
@@ -35,9 +35,11 @@ export const startAsyncOnEventHandlerConsumer = async ({
     await hub.actionManager.start()
     await queue.start()
 
-    const isHealthy = makeHealthCheck(queue.consumer, queue.sessionTimeout)
-
-    return { queue, isHealthy: () => isHealthy() }
+    return {
+        id: 'on-event-ingestion',
+        healthcheck: makeHealthCheck(queue.consumer, queue.sessionTimeout),
+        onShutdown: async () => await queue.stop(),
+    }
 }
 
 export const startAsyncWebhooksHandlerConsumer = async ({
@@ -62,7 +64,7 @@ export const startAsyncWebhooksHandlerConsumer = async ({
     groupTypeManager: GroupTypeManager
     actionMatcher: ActionMatcher
     actionManager: ActionManager
-}) => {
+}): Promise<PluginServerService> => {
     /*
         Consumes analytics events from the Kafka topic `clickhouse_events_json`
         and processes any onEvent plugin handlers configured for the team.
@@ -106,23 +108,24 @@ export const startAsyncWebhooksHandlerConsumer = async ({
             ),
     })
 
-    const isHealthy = makeHealthCheck(consumer, serverConfig.KAFKA_CONSUMPTION_SESSION_TIMEOUT_MS)
+    const onShutdown = async () => {
+        await actionManager.stop()
+        try {
+            await consumer.stop()
+        } catch (e) {
+            status.error('🚨', 'Error stopping consumer', e)
+        }
+        try {
+            await consumer.disconnect()
+        } catch (e) {
+            status.error('🚨', 'Error disconnecting consumer', e)
+        }
+    }
 
     return {
-        stop: async () => {
-            await actionManager.stop()
-            try {
-                await consumer.stop()
-            } catch (e) {
-                status.error('🚨', 'Error stopping consumer', e)
-            }
-            try {
-                await consumer.disconnect()
-            } catch (e) {
-                status.error('🚨', 'Error disconnecting consumer', e)
-            }
-        },
-        isHealthy,
+        id: 'webhooks-ingestion',
+        healthcheck: makeHealthCheck(consumer, serverConfig.KAFKA_CONSUMPTION_SESSION_TIMEOUT_MS),
+        onShutdown,
     }
 }
 
diff --git a/plugin-server/src/main/ingestion-queues/scheduled-tasks-consumer.ts b/plugin-server/src/main/ingestion-queues/scheduled-tasks-consumer.ts
index 83ea62fdfdd6f..8a225f02766ff 100644
--- a/plugin-server/src/main/ingestion-queues/scheduled-tasks-consumer.ts
+++ b/plugin-server/src/main/ingestion-queues/scheduled-tasks-consumer.ts
@@ -2,12 +2,13 @@ import { Batch, EachBatchHandler, Kafka } from 'kafkajs'
 import { KafkaProducerWrapper } from 'utils/db/kafka-producer-wrapper'
 
 import { KAFKA_SCHEDULED_TASKS, KAFKA_SCHEDULED_TASKS_DLQ } from '../../config/kafka-topics'
-import { PluginsServerConfig } from '../../types'
+import { PluginServerService, PluginsServerConfig } from '../../types'
 import { DependencyUnavailableError } from '../../utils/db/error'
 import { status } from '../../utils/status'
 import Piscina from '../../worker/piscina'
 import { instrumentEachBatchKafkaJS, setupEventHandlers } from './kafka-queue'
 import { latestOffsetTimestampGauge, scheduledTaskCounter } from './metrics'
+import { makeHealthCheck } from './on-event-handler-consumer'
 
 // The valid task types that can be scheduled.
 // TODO: not sure if there is another place that defines these but it would be good to unify.
@@ -25,7 +26,7 @@ export const startScheduledTasksConsumer = async ({
     piscina: Piscina
     serverConfig: PluginsServerConfig
     partitionConcurrency: number
-}) => {
+}): Promise<PluginServerService> => {
     /*
 
         Consumes from the scheduled tasks topic, and executes them within a
@@ -138,11 +139,12 @@ export const startScheduledTasksConsumer = async ({
         },
     })
 
+    const healthcheck = makeHealthCheck(consumer, serverConfig.KAFKA_CONSUMPTION_SESSION_TIMEOUT_MS)
+
     return {
-        ...consumer,
-        stop: async () => {
-            await consumer.stop()
-        },
+        id: 'scheduled-tasks-consumer',
+        healthcheck: async () => await healthcheck(),
+        onShutdown: async () => await consumer.stop(),
     }
 }
 
diff --git a/plugin-server/src/main/ingestion-queues/session-recording/session-recordings-consumer.ts b/plugin-server/src/main/ingestion-queues/session-recording/session-recordings-consumer.ts
index feed88b570d5f..df72cd6c2dcf4 100644
--- a/plugin-server/src/main/ingestion-queues/session-recording/session-recordings-consumer.ts
+++ b/plugin-server/src/main/ingestion-queues/session-recording/session-recordings-consumer.ts
@@ -13,7 +13,7 @@ import {
 import { BatchConsumer, startBatchConsumer } from '../../../kafka/batch-consumer'
 import { createRdConnectionConfigFromEnvVars, createRdProducerConfigFromEnvVars } from '../../../kafka/config'
 import { createKafkaProducer } from '../../../kafka/producer'
-import { PluginsServerConfig, RedisPool, TeamId, ValueMatcher } from '../../../types'
+import { PluginServerService, PluginsServerConfig, RedisPool, TeamId, ValueMatcher } from '../../../types'
 import { BackgroundRefresher } from '../../../utils/background-refresher'
 import { KafkaProducerWrapper } from '../../../utils/db/kafka-producer-wrapper'
 import { PostgresRouter } from '../../../utils/db/postgres'
@@ -235,6 +235,15 @@ export class SessionRecordingIngester {
         }, 10000)
     }
 
+    public get service(): PluginServerService {
+        return {
+            id: 'session-recordings-blob-overflow',
+            onShutdown: async () => await this.stop(),
+            healthcheck: () => this.isHealthy() ?? false,
+            batchConsumer: this.batchConsumer,
+        }
+    }
+
     private get connectedBatchConsumer(): KafkaConsumer | undefined {
         // Helper to only use the batch consumer if we are actually connected to it - otherwise it will throw errors
         const consumer = this.batchConsumer?.consumer
diff --git a/plugin-server/src/main/pluginsServer.ts b/plugin-server/src/main/pluginsServer.ts
index 6f26f480451db..cafdc0451806d 100644
--- a/plugin-server/src/main/pluginsServer.ts
+++ b/plugin-server/src/main/pluginsServer.ts
@@ -1,7 +1,6 @@
 import * as Sentry from '@sentry/node'
 import fs from 'fs'
 import { Server } from 'http'
-import { BatchConsumer } from 'kafka/batch-consumer'
 import { CompressionCodecs, CompressionTypes, KafkaJSProtocolError } from 'kafkajs'
 // @ts-expect-error no type definitions
 import SnappyCodec from 'kafkajs-snappy'
@@ -11,15 +10,10 @@ import v8Profiler from 'v8-profiler-next'
 
 import { getPluginServerCapabilities } from '../capabilities'
 import { CdpApi } from '../cdp/cdp-api'
-import {
-    CdpCyclotronWorker,
-    CdpFunctionCallbackConsumer,
-    CdpOverflowConsumer,
-    CdpProcessedEventsConsumer,
-} from '../cdp/cdp-consumers'
+import { CdpFunctionCallbackConsumer, CdpProcessedEventsConsumer } from '../cdp/cdp-consumers'
 import { defaultConfig, sessionRecordingConsumerConfig } from '../config/config'
-import { Hub, PluginServerCapabilities, PluginsServerConfig } from '../types'
-import { createHub, createKafkaClient, createKafkaProducerWrapper } from '../utils/db/hub'
+import { Hub, PluginServerCapabilities, PluginServerService, PluginsServerConfig } from '../types'
+import { closeHub, createHub, createKafkaClient, createKafkaProducerWrapper } from '../utils/db/hub'
 import { PostgresRouter } from '../utils/db/postgres'
 import { cancelAllScheduledJobs } from '../utils/node-schedule'
 import { posthog } from '../utils/posthog'
@@ -41,13 +35,8 @@ import { startGraphileWorker } from './graphile-worker/worker-setup'
 import { startAnalyticsEventsIngestionConsumer } from './ingestion-queues/analytics-events-ingestion-consumer'
 import { startAnalyticsEventsIngestionHistoricalConsumer } from './ingestion-queues/analytics-events-ingestion-historical-consumer'
 import { startAnalyticsEventsIngestionOverflowConsumer } from './ingestion-queues/analytics-events-ingestion-overflow-consumer'
-import {
-    PIPELINES,
-    PipelineType,
-    startEventsIngestionPipelineConsumer,
-} from './ingestion-queues/events-ingestion-consumer'
+import { PIPELINES, startEventsIngestionPipelineConsumer } from './ingestion-queues/events-ingestion-consumer'
 import { startJobsConsumer } from './ingestion-queues/jobs-consumer'
-import { IngestionConsumer, KafkaJSIngestionConsumer } from './ingestion-queues/kafka-queue'
 import {
     startAsyncOnEventHandlerConsumer,
     startAsyncWebhooksHandlerConsumer,
@@ -61,11 +50,8 @@ CompressionCodecs[CompressionTypes.Snappy] = SnappyCodec
 
 const { version } = require('../../package.json')
 
-// TODO: refactor this into a class, removing the need for many different Servers
 export type ServerInstance = {
-    hub: Hub
-    piscina: Piscina
-    queue: KafkaJSIngestionConsumer | IngestionConsumer | null
+    hub?: Hub
     stop: () => Promise<void>
 }
 
@@ -78,7 +64,7 @@ export async function startPluginsServer(
     config: Partial<PluginsServerConfig>,
     makePiscina: (serverConfig: PluginsServerConfig, hub: Hub) => Promise<Piscina> = defaultMakePiscina,
     capabilities?: PluginServerCapabilities
-): Promise<Partial<ServerInstance>> {
+): Promise<ServerInstance> {
     const timer = new Date()
 
     const serverConfig: PluginsServerConfig = {
@@ -90,27 +76,20 @@ export async function startPluginsServer(
     status.info('ℹ️', `${serverConfig.WORKER_CONCURRENCY} workers, ${serverConfig.TASKS_PER_WORKER} tasks per worker`)
     runStartupProfiles(serverConfig)
 
-    // Structure containing initialized clients for Postgres, Kafka, Redis, etc.
-    let hub: Hub | undefined
-
     // Used to trigger reloads of plugin code/config
     let pubSub: PubSub | undefined
 
     // A Node Worker Thread pool
     let piscina: Piscina | undefined
 
-    const shutdownCallbacks: (() => Promise<any>)[] = []
+    const services: PluginServerService[] = []
 
     // Kafka consumer. Handles events that we couldn't find an existing person
     // to associate. The buffer handles delaying the ingestion of these events
     // (default 60 seconds) to allow for the person to be created in the
     // meantime.
     let httpServer: Server | undefined // server
-
     let graphileWorker: GraphileWorker | undefined
-
-    let closeHub: (() => Promise<void>) | undefined
-
     let lastActivityCheck: NodeJS.Timeout | undefined
     let stopEventLoopMetrics: (() => void) | undefined
 
@@ -134,7 +113,7 @@ export async function startPluginsServer(
         await Promise.allSettled([
             pubSub?.stop(),
             graphileWorker?.stop(),
-            ...shutdownCallbacks.map((cb) => cb()),
+            ...services.map((service) => service.onShutdown()),
             posthog.shutdownAsync(),
         ])
 
@@ -142,20 +121,9 @@ export async function startPluginsServer(
             await stopPiscina(piscina)
         }
 
-        await closeHub?.()
-    }
-
-    // If join rejects or throws, then the consumer is unhealthy and we should shut down the process.
-    // Ideally we would also join all the other background tasks as well to ensure we stop the
-    // server if we hit any errors and don't end up with zombie instances, but I'll leave that
-    // refactoring for another time. Note that we have the liveness health checks already, so in K8s
-    // cases zombies should be reaped anyway, albeit not in the most efficient way.
-    function shutdownOnConsumerExit(consumer: BatchConsumer) {
-        consumer.join().catch(async (error) => {
-            status.error('💥', 'Unexpected task joined!', { error: error.stack ?? error })
-            await closeJobs()
-            process.exit(1)
-        })
+        if (serverInstance.hub) {
+            await closeHub(serverInstance.hub)
+        }
     }
 
     for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
@@ -218,13 +186,17 @@ export async function startPluginsServer(
     })
 
     capabilities = capabilities ?? getPluginServerCapabilities(serverConfig)
-    let serverInstance: (Partial<ServerInstance> & Pick<ServerInstance, 'hub'>) | undefined
+    const serverInstance: ServerInstance = {
+        stop: closeJobs,
+    }
 
-    // A collection of healthchecks that should be used to validate the
-    // health of the plugin-server. These are used by the /_health endpoint
-    // to determine if we should trigger a restart of the pod. These should
-    // be super lightweight and ideally not do any IO.
-    const healthChecks: { [service: string]: () => Promise<boolean> | boolean } = {}
+    const setupHub = async (): Promise<Hub> => {
+        if (!serverInstance.hub) {
+            serverInstance.hub = await createHub(serverConfig, capabilities)
+        }
+
+        return serverInstance.hub
+    }
 
     // Creating a dedicated single-connection redis client to this Redis, as it's not relevant for hobby
     // and cloud deploys don't have concurrent uses. We should abstract multi-Redis into a router util.
@@ -245,8 +217,7 @@ export async function startPluginsServer(
         // 4. conversion_events_buffer
         //
         if (capabilities.processPluginJobs || capabilities.pluginScheduledTasks) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-            serverInstance = serverInstance ? serverInstance : { hub }
+            const hub = await setupHub()
 
             graphileWorker = new GraphileWorker(hub)
             // `connectProducer` just runs the PostgreSQL migrations. Ideally it
@@ -263,113 +234,93 @@ export async function startPluginsServer(
             status.info('👷', 'Graphile worker is ready!')
 
             if (capabilities.pluginScheduledTasks) {
-                const schedulerTasksConsumer = await startScheduledTasksConsumer({
-                    piscina: piscina,
-                    producer: hub.kafkaProducer,
-                    kafka: hub.kafka,
-                    serverConfig,
-                    partitionConcurrency: serverConfig.KAFKA_PARTITIONS_CONSUMED_CONCURRENTLY,
-                })
-                shutdownCallbacks.push(async () => await schedulerTasksConsumer.disconnect())
+                services.push(
+                    await startScheduledTasksConsumer({
+                        piscina: piscina,
+                        producer: hub.kafkaProducer,
+                        kafka: hub.kafka,
+                        serverConfig,
+                        partitionConcurrency: serverConfig.KAFKA_PARTITIONS_CONSUMED_CONCURRENTLY,
+                    })
+                )
             }
 
             if (capabilities.processPluginJobs) {
-                const jobsConsumer = await startJobsConsumer({
-                    kafka: hub.kafka,
-                    producer: hub.kafkaProducer,
-                    graphileWorker: graphileWorker,
-                    serverConfig,
-                })
-                shutdownCallbacks.push(async () => await jobsConsumer.disconnect())
+                services.push(
+                    await startJobsConsumer({
+                        kafka: hub.kafka,
+                        producer: hub.kafkaProducer,
+                        graphileWorker: graphileWorker,
+                        serverConfig,
+                    })
+                )
             }
         }
 
         if (capabilities.ingestion) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-            serverInstance = serverInstance ? serverInstance : { hub }
-
+            const hub = await setupHub()
             piscina = piscina ?? (await makePiscina(serverConfig, hub))
-            const { queue, isHealthy } = await startAnalyticsEventsIngestionConsumer({
-                hub: hub,
-            })
-
-            serverInstance.queue = queue // only used by tests
-            shutdownOnConsumerExit(queue.consumer!)
-            healthChecks['analytics-ingestion'] = isHealthy
-            shutdownCallbacks.push(async () => await queue.stop())
+            services.push(
+                await startAnalyticsEventsIngestionConsumer({
+                    hub: hub,
+                })
+            )
         }
 
         if (capabilities.ingestionHistorical) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-            serverInstance = serverInstance ? serverInstance : { hub }
-
+            const hub = await setupHub()
             piscina = piscina ?? (await makePiscina(serverConfig, hub))
-            const { queue, isHealthy } = await startAnalyticsEventsIngestionHistoricalConsumer({
-                hub: hub,
-            })
-
-            shutdownOnConsumerExit(queue.consumer!)
-            healthChecks['analytics-ingestion-historical'] = isHealthy
-            shutdownCallbacks.push(async () => await queue.stop())
+            services.push(
+                await startAnalyticsEventsIngestionHistoricalConsumer({
+                    hub: hub,
+                })
+            )
         }
 
         if (capabilities.eventsIngestionPipelines) {
-            async function start(pipelineKey: string, pipeline: PipelineType) {
-                ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-                serverInstance = serverInstance ? serverInstance : { hub }
-                piscina = piscina ?? (await makePiscina(serverConfig, hub))
-                const { queue, isHealthy: isHealthy } = await startEventsIngestionPipelineConsumer({
-                    hub: hub,
-                    pipeline: pipeline,
-                })
+            const pipelinesToRun =
+                serverConfig.PLUGIN_SERVER_EVENTS_INGESTION_PIPELINE === null
+                    ? Object.keys(PIPELINES)
+                    : [serverConfig.PLUGIN_SERVER_EVENTS_INGESTION_PIPELINE]
 
-                shutdownCallbacks.push(async () => await queue.stop())
-                shutdownOnConsumerExit(queue!.consumer!)
-                healthChecks[`events-ingestion-pipeline-${pipelineKey}`] = isHealthy
-            }
-            if (serverConfig.PLUGIN_SERVER_EVENTS_INGESTION_PIPELINE === null) {
-                for (const pipelineKey in PIPELINES) {
-                    await start(pipelineKey, PIPELINES[pipelineKey])
-                }
-            } else {
-                // Validate we have a valid pipeline
-                const pipelineKey = serverConfig.PLUGIN_SERVER_EVENTS_INGESTION_PIPELINE
+            for (const pipelineKey of pipelinesToRun) {
                 if (pipelineKey === null || !PIPELINES[pipelineKey]) {
                     throw new Error(`Invalid events ingestion pipeline: ${pipelineKey}`)
                 }
-                const pipeline: PipelineType = PIPELINES[pipelineKey]
-                await start(pipelineKey, pipeline)
+
+                const hub = await setupHub()
+                piscina = piscina ?? (await makePiscina(serverConfig, hub))
+                services.push(
+                    await startEventsIngestionPipelineConsumer({
+                        hub: hub,
+                        pipelineKey: pipelineKey,
+                    })
+                )
             }
         }
 
         if (capabilities.ingestionOverflow) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-            serverInstance = serverInstance ? serverInstance : { hub }
-
+            const hub = await setupHub()
             piscina = piscina ?? (await makePiscina(serverConfig, hub))
-            const { queue, isHealthy } = await startAnalyticsEventsIngestionOverflowConsumer({
-                hub: hub,
-            })
-
-            shutdownCallbacks.push(async () => await queue.stop())
-            shutdownOnConsumerExit(queue.consumer!)
-            healthChecks['analytics-ingestion-overflow'] = isHealthy
+            services.push(
+                await startAnalyticsEventsIngestionOverflowConsumer({
+                    hub: hub,
+                })
+            )
         }
 
         if (capabilities.processAsyncOnEventHandlers) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-            serverInstance = serverInstance ? serverInstance : { hub }
-
+            const hub = await setupHub()
             piscina = piscina ?? (await makePiscina(serverConfig, hub))
-            const { queue, isHealthy } = await startAsyncOnEventHandlerConsumer({
-                hub: hub,
-            })
-
-            shutdownCallbacks.push(async () => await queue.stop())
-            healthChecks['on-event-ingestion'] = isHealthy
+            services.push(
+                await startAsyncOnEventHandlerConsumer({
+                    hub: hub,
+                })
+            )
         }
 
         if (capabilities.processAsyncWebhooksHandlers) {
+            const hub = serverInstance.hub
             // If we have a hub, then reuse some of it's attributes, otherwise
             // we need to create them. We only initialize the ones we need.
             const postgres = hub?.postgres ?? new PostgresRouter(serverConfig)
@@ -390,31 +341,30 @@ export async function startPluginsServer(
             const actionMatcher = hub?.actionMatcher ?? new ActionMatcher(postgres, actionManager, teamManager)
             const groupTypeManager = new GroupTypeManager(postgres, teamManager, serverConfig.SITE_URL)
 
-            const { stop, isHealthy } = await startAsyncWebhooksHandlerConsumer({
-                postgres,
-                kafka,
-                teamManager,
-                organizationManager,
-                serverConfig,
-                rustyHook,
-                appMetrics,
-                actionMatcher,
-                actionManager,
-                groupTypeManager,
-            })
-
-            shutdownCallbacks.push(async () => await stop())
-            healthChecks['webhooks-ingestion'] = isHealthy
+            services.push(
+                await startAsyncWebhooksHandlerConsumer({
+                    postgres,
+                    kafka,
+                    teamManager,
+                    organizationManager,
+                    serverConfig,
+                    rustyHook,
+                    appMetrics,
+                    actionMatcher,
+                    actionManager,
+                    groupTypeManager,
+                })
+            )
         }
 
         if (capabilities.syncInlinePlugins) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-            serverInstance = serverInstance ? serverInstance : { hub }
+            const hub = await setupHub()
 
             await syncInlinePlugins(hub)
         }
 
-        if (hub && serverInstance) {
+        if (serverInstance.hub) {
+            const hub = serverInstance.hub
             pubSub = new PubSub(hub, {
                 [hub.PLUGINS_RELOAD_PUBSUB_CHANNEL]: async () => {
                     status.info('⚡', 'Reloading plugins!')
@@ -445,17 +395,14 @@ export async function startPluginsServer(
                 startPreflightSchedules(hub)
             }
 
-            serverInstance.piscina = piscina
             serverInstance.stop = closeJobs
 
             pluginServerStartupTimeMs.inc(Date.now() - timer.valueOf())
             status.info('🚀', 'All systems go')
-
-            hub.lastActivity = new Date().valueOf()
-            hub.lastActivityType = 'serverStart'
         }
 
         if (capabilities.sessionRecordingBlobIngestion) {
+            const hub = serverInstance.hub
             const recordingConsumerConfig = sessionRecordingConsumerConfig(serverConfig)
             const postgres = hub?.postgres ?? new PostgresRouter(serverConfig)
             const s3 = hub?.objectStorage ?? getObjectStorage(recordingConsumerConfig)
@@ -467,16 +414,16 @@ export async function startPluginsServer(
             const ingester = new SessionRecordingIngester(serverConfig, postgres, s3, false, captureRedis)
             await ingester.start()
 
-            const batchConsumer = ingester.batchConsumer
-
-            if (batchConsumer) {
-                shutdownCallbacks.push(async () => await ingester.stop())
-                shutdownOnConsumerExit(batchConsumer)
-                healthChecks['session-recordings-blob'] = () => ingester.isHealthy() ?? false
-            }
+            services.push({
+                id: 'session-recordings-blob',
+                onShutdown: async () => await ingester.stop(),
+                healthcheck: () => ingester.isHealthy() ?? false,
+                batchConsumer: ingester.batchConsumer,
+            })
         }
 
         if (capabilities.sessionRecordingBlobOverflowIngestion) {
+            const hub = serverInstance.hub
             const recordingConsumerConfig = sessionRecordingConsumerConfig(serverConfig)
             const postgres = hub?.postgres ?? new PostgresRouter(serverConfig)
             const s3 = hub?.objectStorage ?? getObjectStorage(recordingConsumerConfig)
@@ -488,35 +435,21 @@ export async function startPluginsServer(
             // NOTE: We don't pass captureRedis to disable overflow computation on the overflow topic
             const ingester = new SessionRecordingIngester(serverConfig, postgres, s3, true, undefined)
             await ingester.start()
-
-            const batchConsumer = ingester.batchConsumer
-
-            if (batchConsumer) {
-                shutdownCallbacks.push(async () => await ingester.stop())
-                shutdownOnConsumerExit(batchConsumer)
-                healthChecks['session-recordings-blob-overflow'] = () => ingester.isHealthy() ?? false
-            }
+            services.push(ingester.service)
         }
 
         if (capabilities.cdpProcessedEvents) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
+            const hub = await setupHub()
             const consumer = new CdpProcessedEventsConsumer(hub)
             await consumer.start()
-
-            shutdownOnConsumerExit(consumer.batchConsumer!)
-            shutdownCallbacks.push(async () => await consumer.stop())
-            healthChecks['cdp-processed-events'] = () => consumer.isHealthy() ?? false
+            services.push(consumer.service)
         }
 
         if (capabilities.cdpFunctionCallbacks) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
+            const hub = await setupHub()
             const consumer = new CdpFunctionCallbackConsumer(hub)
             await consumer.start()
-
-            shutdownOnConsumerExit(consumer.batchConsumer!)
-
-            shutdownCallbacks.push(async () => await consumer.stop())
-            healthChecks['cdp-function-callbacks'] = () => consumer.isHealthy() ?? false
+            services.push(consumer.service)
 
             // NOTE: The function callback service is more idle so can handle http requests as well
             if (capabilities.http) {
@@ -525,36 +458,40 @@ export async function startPluginsServer(
             }
         }
 
-        if (capabilities.cdpFunctionOverflow) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-            const consumer = new CdpOverflowConsumer(hub)
-            await consumer.start()
-
-            shutdownOnConsumerExit(consumer.batchConsumer!)
-            shutdownCallbacks.push(async () => await consumer.stop())
-            healthChecks['cdp-overflow'] = () => consumer.isHealthy() ?? false
-        }
-
-        if (capabilities.cdpCyclotronWorker) {
-            ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
-            if (hub.CYCLOTRON_DATABASE_URL) {
-                const worker = new CdpCyclotronWorker(hub)
-                await worker.start()
-            } else {
-                // This is a temporary solution until we *require* Cyclotron to be configured.
-                status.warn('💥', 'CYCLOTRON_DATABASE_URL is not set, not running Cyclotron worker')
-            }
-        }
+        // if (capabilities.cdpCyclotronWorker) {
+        //     ;[hub, closeHub] = hub ? [hub, closeHub] : await createHub(serverConfig, capabilities)
+        //     if (hub.CYCLOTRON_DATABASE_URL) {
+        //         const worker = new CdpCyclotronWorker(hub)
+        //         await worker.start()
+        //     } else {
+        //         // This is a temporary solution until we *require* Cyclotron to be configured.
+        //         status.warn('💥', 'CYCLOTRON_DATABASE_URL is not set, not running Cyclotron worker')
+        //     }
+        // }
 
         if (capabilities.http) {
-            const app = setupCommonRoutes(healthChecks, serverInstance?.queue ?? undefined)
+            const app = setupCommonRoutes(services)
 
             httpServer = app.listen(serverConfig.HTTP_SERVER_PORT, () => {
                 status.info('🩺', `Status server listening on port ${serverConfig.HTTP_SERVER_PORT}`)
             })
         }
 
-        return serverInstance ?? { stop: closeJobs }
+        // If join rejects or throws, then the consumer is unhealthy and we should shut down the process.
+        // Ideally we would also join all the other background tasks as well to ensure we stop the
+        // server if we hit any errors and don't end up with zombie instances, but I'll leave that
+        // refactoring for another time. Note that we have the liveness health checks already, so in K8s
+        // cases zombies should be reaped anyway, albeit not in the most efficient way.
+
+        services.forEach((service) => {
+            service.batchConsumer?.join().catch(async (error) => {
+                status.error('💥', 'Unexpected task joined!', { error: error.stack ?? error })
+                await closeJobs()
+                process.exit(1)
+            })
+        })
+
+        return serverInstance
     } catch (error) {
         Sentry.captureException(error)
         status.error('💥', 'Launchpad failure!', { error: error.stack ?? error })
diff --git a/plugin-server/src/main/services/http-server.ts b/plugin-server/src/main/services/http-server.ts
index 8889f96f22032..d4bb5ee5151a8 100644
--- a/plugin-server/src/main/services/http-server.ts
+++ b/plugin-server/src/main/services/http-server.ts
@@ -1,7 +1,7 @@
 import express, { Request, Response } from 'express'
 import { DateTime } from 'luxon'
-import { IngestionConsumer, KafkaJSIngestionConsumer } from 'main/ingestion-queues/kafka-queue'
 import * as prometheus from 'prom-client'
+import { PluginServerService } from 'types'
 
 import { status } from '../../utils/status'
 import { delay } from '../../utils/utils'
@@ -14,12 +14,9 @@ export const expressApp: express.Application = express()
 
 expressApp.use(express.json())
 
-export function setupCommonRoutes(
-    healthChecks: { [service: string]: () => Promise<boolean> | boolean },
-    analyticsEventsIngestionConsumer?: KafkaJSIngestionConsumer | IngestionConsumer
-): express.Application {
-    expressApp.get('/_health', buildGetHealth(healthChecks))
-    expressApp.get('/_ready', buildGetReady(analyticsEventsIngestionConsumer))
+export function setupCommonRoutes(services: Pick<PluginServerService, 'id' | 'healthcheck'>[]): express.Application {
+    expressApp.get('/_health', buildGetHealth(services))
+    expressApp.get('/_ready', buildGetHealth(services))
     expressApp.get('/_metrics', getMetrics)
     expressApp.get('/metrics', getMetrics)
     expressApp.get('/_profile/:type', getProfileByType)
@@ -28,7 +25,7 @@ export function setupCommonRoutes(
 }
 
 const buildGetHealth =
-    (healthChecks: { [service: string]: () => Promise<boolean> | boolean }) => async (req: Request, res: Response) => {
+    (services: Pick<PluginServerService, 'id' | 'healthcheck'>[]) => async (req: Request, res: Response) => {
         // Check that all health checks pass. Note that a failure of these
         // _may_ result in the process being terminated by e.g. Kubernetes
         // so the stakes are high.
@@ -58,11 +55,11 @@ const buildGetHealth =
             // assume that all promises have resolved. If there was a
             // rejected promise, the http server should catch it and return
             // a 500 status code.
-            Object.entries(healthChecks).map(async ([service, check]) => {
+            services.map(async (service) => {
                 try {
-                    return { service, status: (await check()) ? 'ok' : 'error' }
+                    return { service: service.id, status: (await service.healthcheck()) ? 'ok' : 'error' }
                 } catch (error) {
-                    return { service, status: 'error', error: error.message }
+                    return { service: service.id, status: 'error', error: error.message }
                 }
             })
         )
@@ -80,27 +77,6 @@ const buildGetHealth =
         return res.status(statusCode).json({ status: statusCode === 200 ? 'ok' : 'error', checks: checkResultsMapping })
     }
 
-const buildGetReady =
-    (analyticsEventsIngestionConsumer?: KafkaJSIngestionConsumer | IngestionConsumer) =>
-    (req: Request, res: Response) => {
-        // Check that, if the server should have a kafka queue,
-        // the Kafka consumer is ready to consume messages
-        if (!analyticsEventsIngestionConsumer || analyticsEventsIngestionConsumer.consumerReady) {
-            status.info('💚', 'Server readiness check succeeded')
-            const responseBody = {
-                status: 'ok',
-            }
-            res.statusCode = 200
-            return res.status(200).json(responseBody)
-        }
-
-        status.info('💔', 'Server readiness check failed')
-        const responseBody = {
-            status: 'error',
-        }
-        return res.status(503).json(responseBody)
-    }
-
 const getMetrics = async (req: Request, res: Response) => {
     try {
         const metrics = await prometheus.register.metrics()
diff --git a/plugin-server/src/types.ts b/plugin-server/src/types.ts
index 2ca7a3e593f3b..58253a210abd3 100644
--- a/plugin-server/src/types.ts
+++ b/plugin-server/src/types.ts
@@ -13,9 +13,9 @@ import {
 } from '@posthog/plugin-scaffold'
 import { Pool as GenericPool } from 'generic-pool'
 import { Redis } from 'ioredis'
+import { BatchConsumer } from 'kafka/batch-consumer'
 import { Kafka } from 'kafkajs'
 import { DateTime } from 'luxon'
-import { Job } from 'node-schedule'
 import { VM } from 'vm2'
 
 import { ObjectStorage } from './main/services/object_storage'
@@ -28,7 +28,6 @@ import { ActionMatcher } from './worker/ingestion/action-matcher'
 import { AppMetrics } from './worker/ingestion/app-metrics'
 import { GroupTypeManager } from './worker/ingestion/group-type-manager'
 import { OrganizationManager } from './worker/ingestion/organization-manager'
-import { EventsProcessor } from './worker/ingestion/process-event'
 import { TeamManager } from './worker/ingestion/team-manager'
 import { RustyHook } from './worker/rusty-hook'
 import { PluginsApiKeyManager } from './worker/vm/extensions/helpers/api-key-manager'
@@ -84,7 +83,6 @@ export enum PluginServerMode {
     recordings_blob_ingestion_overflow = 'recordings-blob-ingestion-overflow',
     cdp_processed_events = 'cdp-processed-events',
     cdp_function_callbacks = 'cdp-function-callbacks',
-    cdp_function_overflow = 'cdp-function-overflow',
     cdp_cyclotron_worker = 'cdp-cyclotron-worker',
     functional_tests = 'functional-tests',
 }
@@ -96,6 +94,13 @@ export const stringToPluginServerMode = Object.fromEntries(
     ])
 ) as Record<string, PluginServerMode>
 
+export type PluginServerService = {
+    id: string
+    onShutdown: () => Promise<any>
+    healthcheck: () => boolean | Promise<boolean>
+    batchConsumer?: BatchConsumer
+}
+
 export type CdpConfig = {
     CDP_WATCHER_COST_ERROR: number // The max cost of an erroring function
     CDP_WATCHER_COST_TIMING: number // The max cost of a slow function
@@ -112,6 +117,7 @@ export type CdpConfig = {
     CDP_REDIS_HOST: string
     CDP_REDIS_PORT: number
     CDP_REDIS_PASSWORD: string
+    CDP_EVENT_PROCESSOR_EXECUTE_FIRST_STEP: boolean
 }
 
 export interface PluginsServerConfig extends CdpConfig {
@@ -202,10 +208,6 @@ export interface PluginsServerConfig extends CdpConfig {
     HEALTHCHECK_MAX_STALE_SECONDS: number // maximum number of seconds the plugin server can go without ingesting events before the healthcheck fails
     SITE_URL: string | null
     KAFKA_PARTITIONS_CONSUMED_CONCURRENTLY: number // (advanced) how many kafka partitions the plugin server should consume from concurrently
-    CONVERSION_BUFFER_ENABLED: boolean
-    CONVERSION_BUFFER_ENABLED_TEAMS: string
-    CONVERSION_BUFFER_TOPIC_ENABLED_TEAMS: string
-    BUFFER_CONVERSION_SECONDS: number
     PERSON_INFO_CACHE_TTL: number
     KAFKA_HEALTHCHECK_SECONDS: number
     OBJECT_STORAGE_ENABLED: boolean // Disables or enables the use of object storage. It will become mandatory to use object storage
@@ -296,9 +298,7 @@ export interface Hub extends PluginsServerConfig {
     clickhouse: ClickHouse
     kafka: Kafka
     kafkaProducer: KafkaProducerWrapper
-    objectStorage: ObjectStorage
-    // metrics
-    pluginMetricsJob: Job | undefined
+    objectStorage?: ObjectStorage
     // currently enabled plugin status
     plugins: Map<PluginId, Plugin>
     pluginConfigs: Map<PluginConfigId, PluginConfig>
@@ -312,7 +312,6 @@ export interface Hub extends PluginsServerConfig {
     organizationManager: OrganizationManager
     pluginsApiKeyManager: PluginsApiKeyManager
     rootAccessManager: RootAccessManager
-    eventsProcessor: EventsProcessor
     actionManager: ActionManager
     actionMatcher: ActionMatcher
     appMetrics: AppMetrics
@@ -320,11 +319,6 @@ export interface Hub extends PluginsServerConfig {
     groupTypeManager: GroupTypeManager
     // geoip database, setup in workers
     mmdb?: ReaderModel
-    // diagnostics
-    lastActivity: number
-    lastActivityType: string
-    statelessVms: StatelessInstanceMap
-    conversionBufferEnabledTeams: Set<number>
     // functions
     enqueuePluginJob: (job: EnqueuedPluginJob) => Promise<void>
     // ValueMatchers used for various opt-in/out features
@@ -348,7 +342,6 @@ export interface PluginServerCapabilities {
     sessionRecordingBlobOverflowIngestion?: boolean
     cdpProcessedEvents?: boolean
     cdpFunctionCallbacks?: boolean
-    cdpFunctionOverflow?: boolean
     cdpCyclotronWorker?: boolean
     appManagementSingleton?: boolean
     preflightSchedules?: boolean // Used for instance health checks on hobby deploy, not useful on cloud
diff --git a/plugin-server/src/utils/db/hub.ts b/plugin-server/src/utils/db/hub.ts
index 096e1720dbbb3..d8f4815c0a822 100644
--- a/plugin-server/src/utils/db/hub.ts
+++ b/plugin-server/src/utils/db/hub.ts
@@ -27,7 +27,6 @@ import { ActionMatcher } from '../../worker/ingestion/action-matcher'
 import { AppMetrics } from '../../worker/ingestion/app-metrics'
 import { GroupTypeManager } from '../../worker/ingestion/group-type-manager'
 import { OrganizationManager } from '../../worker/ingestion/organization-manager'
-import { EventsProcessor } from '../../worker/ingestion/process-event'
 import { TeamManager } from '../../worker/ingestion/team-manager'
 import { RustyHook } from '../../worker/rusty-hook'
 import { isTestEnv } from '../env-utils'
@@ -75,7 +74,7 @@ export function createEventsToDropByToken(eventsToDropByTokenStr?: string): Map<
 export async function createHub(
     config: Partial<PluginsServerConfig> = {},
     capabilities: PluginServerCapabilities | null = null
-): Promise<[Hub, () => Promise<void>]> {
+): Promise<Hub> {
     status.info('ℹ️', `Connecting to all services:`)
 
     const serverConfig: PluginsServerConfig = {
@@ -88,10 +87,6 @@ export async function createHub(
     status.updatePrompt(serverConfig.PLUGIN_SERVER_MODE)
     const instanceId = new UUIDT()
 
-    const conversionBufferEnabledTeams = new Set(
-        serverConfig.CONVERSION_BUFFER_ENABLED_TEAMS.split(',').filter(String).map(Number)
-    )
-
     status.info('🤔', `Connecting to ClickHouse...`)
     const clickhouse = new ClickHouse({
         // We prefer to run queries on the offline cluster.
@@ -174,7 +169,7 @@ export async function createHub(
         })
     }
 
-    const hub: Partial<Hub> = {
+    const hub: Hub = {
         ...serverConfig,
         instanceId,
         capabilities,
@@ -203,34 +198,31 @@ export async function createHub(
         rustyHook,
         actionMatcher,
         actionManager,
-        conversionBufferEnabledTeams,
         pluginConfigsToSkipElementsParsing: buildIntegerMatcher(process.env.SKIP_ELEMENTS_PARSING_PLUGINS, true),
         eventsToDropByToken: createEventsToDropByToken(process.env.DROP_EVENTS_BY_TOKEN_DISTINCT_ID),
+        appMetrics: new AppMetrics(
+            kafkaProducer,
+            serverConfig.APP_METRICS_FLUSH_FREQUENCY_MS,
+            serverConfig.APP_METRICS_FLUSH_MAX_QUEUE_SIZE
+        ),
     }
 
-    // :TODO: This is only used on worker threads, not main
-    hub.eventsProcessor = new EventsProcessor(hub as Hub)
-
-    hub.appMetrics = new AppMetrics(
-        kafkaProducer,
-        serverConfig.APP_METRICS_FLUSH_FREQUENCY_MS,
-        serverConfig.APP_METRICS_FLUSH_MAX_QUEUE_SIZE
-    )
+    return hub as Hub
+}
 
-    const closeHub = async () => {
-        if (!isTestEnv()) {
-            await hub.appMetrics?.flush()
-        }
-        await Promise.allSettled([kafkaProducer.disconnect(), redisPool.drain(), hub.postgres?.end()])
-        await redisPool.clear()
+export const closeHub = async (hub: Hub): Promise<void> => {
+    if (!isTestEnv()) {
+        await hub.appMetrics?.flush()
+    }
+    await Promise.allSettled([hub.kafkaProducer.disconnect(), hub.redisPool.drain(), hub.postgres?.end()])
+    await hub.redisPool.clear()
 
+    if (isTestEnv()) {
         // Break circular references to allow the hub to be GCed when running unit tests
         // TODO: change these structs to not directly reference the hub
-        hub.eventsProcessor = undefined
-        hub.appMetrics = undefined
+        ;(hub as any).eventsProcessor = undefined
+        ;(hub as any).appMetrics = undefined
     }
-
-    return [hub as Hub, closeHub]
 }
 
 export type KafkaConfig = {
diff --git a/plugin-server/src/utils/utils.ts b/plugin-server/src/utils/utils.ts
index a49a5161b4b3a..6bb263ec307c7 100644
--- a/plugin-server/src/utils/utils.ts
+++ b/plugin-server/src/utils/utils.ts
@@ -17,7 +17,6 @@ import {
     RedisPool,
     TimestampFormat,
 } from '../types'
-import { Hub } from './../types'
 import { status } from './status'
 
 /** Time until autoexit (due to error) gives up on graceful exit and kills the process right away. */
@@ -577,31 +576,6 @@ export class RaceConditionError extends Error {
     name = 'RaceConditionError'
 }
 
-export interface StalenessCheckResult {
-    isServerStale: boolean
-    timeSinceLastActivity: number | null
-    lastActivity?: string | null
-    lastActivityType?: string
-    instanceId?: string
-}
-
-export function stalenessCheck(hub: Hub | undefined, stalenessSeconds: number): StalenessCheckResult {
-    let isServerStale = false
-
-    const timeSinceLastActivity = hub?.lastActivity ? new Date().valueOf() - hub.lastActivity : null
-    if (timeSinceLastActivity && timeSinceLastActivity > stalenessSeconds * 1000) {
-        isServerStale = true
-    }
-
-    return {
-        isServerStale,
-        timeSinceLastActivity,
-        instanceId: hub?.instanceId.toString(),
-        lastActivity: hub?.lastActivity ? new Date(hub.lastActivity).toISOString() : null,
-        lastActivityType: hub?.lastActivityType,
-    }
-}
-
 /** Get a value from a properties object by its path. This allows accessing nested properties. */
 export function getPropertyValueByPath(properties: Properties, [firstKey, ...nestedKeys]: string[]): any {
     if (firstKey === undefined) {
diff --git a/plugin-server/src/worker/ingestion/event-pipeline/createEventStep.ts b/plugin-server/src/worker/ingestion/event-pipeline/createEventStep.ts
index ce1a8438c152c..ea717cfa565dd 100644
--- a/plugin-server/src/worker/ingestion/event-pipeline/createEventStep.ts
+++ b/plugin-server/src/worker/ingestion/event-pipeline/createEventStep.ts
@@ -7,5 +7,5 @@ export function createEventStep(
     person: Person,
     processPerson: boolean
 ): [RawClickHouseEvent, Promise<void>] {
-    return runner.hub.eventsProcessor.createEvent(event, person, processPerson)
+    return runner.eventsProcessor.createEvent(event, person, processPerson)
 }
diff --git a/plugin-server/src/worker/ingestion/event-pipeline/prepareEventStep.ts b/plugin-server/src/worker/ingestion/event-pipeline/prepareEventStep.ts
index b097643e0ca5f..6725bbf345661 100644
--- a/plugin-server/src/worker/ingestion/event-pipeline/prepareEventStep.ts
+++ b/plugin-server/src/worker/ingestion/event-pipeline/prepareEventStep.ts
@@ -19,7 +19,7 @@ export async function prepareEventStep(
         tsParsingIngestionWarnings.push(captureIngestionWarning(runner.hub.db.kafkaProducer, team_id, type, details))
     }
 
-    const preIngestionEvent = await runner.hub.eventsProcessor.processEvent(
+    const preIngestionEvent = await runner.eventsProcessor.processEvent(
         String(event.distinct_id),
         event,
         team_id,
diff --git a/plugin-server/src/worker/ingestion/event-pipeline/runner.ts b/plugin-server/src/worker/ingestion/event-pipeline/runner.ts
index 0518902516410..5d61a4a11a4fc 100644
--- a/plugin-server/src/worker/ingestion/event-pipeline/runner.ts
+++ b/plugin-server/src/worker/ingestion/event-pipeline/runner.ts
@@ -8,6 +8,7 @@ import { DependencyUnavailableError } from '../../../utils/db/error'
 import { timeoutGuard } from '../../../utils/db/utils'
 import { normalizeProcessPerson } from '../../../utils/event'
 import { status } from '../../../utils/status'
+import { EventsProcessor } from '../process-event'
 import { captureIngestionWarning, generateEventDeadLetterQueueMessage } from '../utils'
 import { createEventStep } from './createEventStep'
 import { enrichExceptionEventStep } from './enrichExceptionEventStep'
@@ -50,10 +51,12 @@ class StepErrorNoRetry extends Error {
 export class EventPipelineRunner {
     hub: Hub
     originalEvent: PipelineEvent
+    eventsProcessor: EventsProcessor
 
-    constructor(hub: Hub, event: PipelineEvent) {
+    constructor(hub: Hub, event: PipelineEvent, eventProcessor: EventsProcessor) {
         this.hub = hub
         this.originalEvent = event
+        this.eventsProcessor = eventProcessor
     }
 
     isEventDisallowed(event: PipelineEvent): boolean {
diff --git a/plugin-server/tests/cdp/cdp-function-callbacks-consumer.test.ts b/plugin-server/tests/cdp/cdp-api.test.ts
similarity index 89%
rename from plugin-server/tests/cdp/cdp-function-callbacks-consumer.test.ts
rename to plugin-server/tests/cdp/cdp-api.test.ts
index ec1d9338f7751..f3c7dc3b22e05 100644
--- a/plugin-server/tests/cdp/cdp-function-callbacks-consumer.test.ts
+++ b/plugin-server/tests/cdp/cdp-api.test.ts
@@ -3,9 +3,9 @@ import supertest from 'supertest'
 
 import { CdpApi } from '../../src/cdp/cdp-api'
 import { CdpFunctionCallbackConsumer } from '../../src/cdp/cdp-consumers'
-import { HogFunctionType } from '../../src/cdp/types'
+import { HogFunctionInvocationGlobals, HogFunctionType } from '../../src/cdp/types'
 import { Hub, Team } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { getFirstTeam, resetTestDatabase } from '../helpers/sql'
 import { HOG_EXAMPLES, HOG_FILTERS_EXAMPLES, HOG_INPUTS_EXAMPLES } from './examples'
 import { insertHogFunction as _insertHogFunction } from './fixtures'
@@ -64,10 +64,9 @@ const mockFetch: jest.Mock = require('../../src/utils/fetch').trackedFetch
 
 jest.setTimeout(1000)
 
-describe('CDP Processed Events Consuner', () => {
+describe('CDP API', () => {
     let processor: CdpFunctionCallbackConsumer
     let hub: Hub
-    let closeHub: () => Promise<void>
     let team: Team
 
     const insertHogFunction = async (hogFunction: Partial<HogFunctionType>) => {
@@ -79,7 +78,7 @@ describe('CDP Processed Events Consuner', () => {
 
     beforeEach(async () => {
         await resetTestDatabase()
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         team = await getFirstTeam(hub)
 
         processor = new CdpFunctionCallbackConsumer(hub)
@@ -92,7 +91,7 @@ describe('CDP Processed Events Consuner', () => {
     afterEach(async () => {
         jest.setTimeout(10000)
         await processor.stop()
-        await closeHub()
+        await closeHub(hub)
     })
 
     afterAll(() => {
@@ -103,20 +102,24 @@ describe('CDP Processed Events Consuner', () => {
         let app: express.Express
         let hogFunction: HogFunctionType
 
-        const globals = {
-            event: {
-                uuid: 'b3a1fe86-b10c-43cc-acaf-d208977608d0',
-                name: '$pageview',
+        const globals: Partial<HogFunctionInvocationGlobals> = {
+            groups: {},
+            person: {
+                uuid: '123',
+                name: 'Jane Doe',
+                url: 'https://example.com/person/123',
                 properties: {
-                    $lib_version: '1.0.0',
+                    email: 'example@posthog.com',
                 },
             },
-            groups: {},
-            person: {
+            event: {
                 uuid: 'b3a1fe86-b10c-43cc-acaf-d208977608d0',
-                distinct_ids: ['b3a1fe86-b10c-43cc-acaf-d208977608d0'],
+                name: '$pageview',
+                distinct_id: '123',
+                timestamp: '2021-09-28T14:00:00Z',
+                url: 'https://example.com/events/b3a1fe86-b10c-43cc-acaf-d208977608d0/2021-09-28T14:00:00Z',
                 properties: {
-                    email: 'test@posthog.com',
+                    $lib_version: '1.0.0',
                 },
             },
         }
@@ -159,6 +162,7 @@ describe('CDP Processed Events Consuner', () => {
                 .send({ globals, mock_async_functions: true })
 
             expect(res.status).toEqual(200)
+            console.log(res.body.logs[3].message)
             expect(res.body).toMatchObject({
                 status: 'success',
                 error: 'undefined',
@@ -169,7 +173,7 @@ describe('CDP Processed Events Consuner', () => {
                     },
                     {
                         level: 'debug',
-                        message: "Suspending function due to async function call 'fetch'. Payload: 1689 bytes",
+                        message: "Suspending function due to async function call 'fetch'. Payload: 2010 bytes",
                     },
                     {
                         level: 'info',
@@ -177,7 +181,7 @@ describe('CDP Processed Events Consuner', () => {
                     },
                     {
                         level: 'info',
-                        message: expect.stringContaining('fetch("https://example.com/posthog-webhook",'),
+                        message: expect.stringContaining('fetch({'),
                     },
                     {
                         level: 'debug',
@@ -217,7 +221,7 @@ describe('CDP Processed Events Consuner', () => {
                     },
                     {
                         level: 'debug',
-                        message: "Suspending function due to async function call 'fetch'. Payload: 1689 bytes",
+                        message: "Suspending function due to async function call 'fetch'. Payload: 2010 bytes",
                     },
                     {
                         level: 'debug',
diff --git a/plugin-server/tests/cdp/cdp-consumer.e2e.test.ts b/plugin-server/tests/cdp/cdp-consumer.e2e.test.ts
new file mode 100644
index 0000000000000..8d6581aef9ef0
--- /dev/null
+++ b/plugin-server/tests/cdp/cdp-consumer.e2e.test.ts
@@ -0,0 +1,222 @@
+import { CdpFunctionCallbackConsumer, CdpProcessedEventsConsumer } from '../../src/cdp/cdp-consumers'
+import { HogFunctionInvocationGlobals, HogFunctionType } from '../../src/cdp/types'
+import { Hub, Team } from '../../src/types'
+import { closeHub, createHub } from '../../src/utils/db/hub'
+import { getFirstTeam, resetTestDatabase } from '../helpers/sql'
+import { HOG_EXAMPLES, HOG_FILTERS_EXAMPLES, HOG_INPUTS_EXAMPLES } from './examples'
+import { createHogExecutionGlobals, insertHogFunction as _insertHogFunction } from './fixtures'
+
+const mockConsumer = {
+    on: jest.fn(),
+    commitSync: jest.fn(),
+    commit: jest.fn(),
+    queryWatermarkOffsets: jest.fn(),
+    committed: jest.fn(),
+    assignments: jest.fn(),
+    isConnected: jest.fn(() => true),
+    getMetadata: jest.fn(),
+}
+
+jest.mock('../../src/kafka/batch-consumer', () => {
+    return {
+        startBatchConsumer: jest.fn(() =>
+            Promise.resolve({
+                join: () => ({
+                    finally: jest.fn(),
+                }),
+                stop: jest.fn(),
+                consumer: mockConsumer,
+            })
+        ),
+    }
+})
+
+jest.mock('../../src/utils/fetch', () => {
+    return {
+        trackedFetch: jest.fn(() =>
+            Promise.resolve({
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ success: true })),
+                json: () => Promise.resolve({ success: true }),
+            })
+        ),
+    }
+})
+
+jest.mock('../../src/utils/db/kafka-producer-wrapper', () => {
+    const mockKafkaProducer = {
+        producer: {
+            connect: jest.fn(),
+        },
+        disconnect: jest.fn(),
+        produce: jest.fn(() => Promise.resolve()),
+    }
+    return {
+        KafkaProducerWrapper: jest.fn(() => mockKafkaProducer),
+    }
+})
+
+const mockFetch: jest.Mock = require('../../src/utils/fetch').trackedFetch
+
+const mockProducer = require('../../src/utils/db/kafka-producer-wrapper').KafkaProducerWrapper()
+
+jest.setTimeout(1000)
+
+const decodeKafkaMessage = (message: any): any => {
+    return {
+        ...message,
+        value: JSON.parse(message.value.toString()),
+    }
+}
+
+const decodeAllKafkaMessages = (): any[] => {
+    return mockProducer.produce.mock.calls.map((x) => decodeKafkaMessage(x[0]))
+}
+
+const convertToKafkaMessage = (message: any): any => {
+    return {
+        ...message,
+        value: Buffer.from(JSON.stringify(message.value)),
+    }
+}
+
+/**
+ * NOTE: This isn't fully e2e... We still mock kafka but we trigger one queue from the other in a loop
+ */
+describe('CDP Consumers E2E', () => {
+    let processedEventsConsumer: CdpProcessedEventsConsumer
+    let functionProcessor: CdpFunctionCallbackConsumer
+    let hub: Hub
+    let team: Team
+
+    const insertHogFunction = async (hogFunction: Partial<HogFunctionType>) => {
+        const item = await _insertHogFunction(hub.postgres, team.id, hogFunction)
+        // Trigger the reload that django would do
+        await processedEventsConsumer.hogFunctionManager.reloadAllHogFunctions()
+        await functionProcessor.hogFunctionManager.reloadAllHogFunctions()
+        return item
+    }
+
+    beforeEach(async () => {
+        await resetTestDatabase()
+        hub = await createHub()
+        team = await getFirstTeam(hub)
+
+        processedEventsConsumer = new CdpProcessedEventsConsumer(hub)
+        await processedEventsConsumer.start()
+        functionProcessor = new CdpFunctionCallbackConsumer(hub)
+        await functionProcessor.start()
+
+        mockFetch.mockClear()
+    })
+
+    afterEach(async () => {
+        jest.setTimeout(10000)
+        await processedEventsConsumer.stop()
+        await functionProcessor.stop()
+        await closeHub(hub)
+    })
+
+    afterAll(() => {
+        jest.useRealTimers()
+    })
+
+    describe('e2e fetch function', () => {
+        /**
+         * Tests here are somewhat expensive so should mostly simulate happy paths and the more e2e scenarios
+         */
+
+        let fnFetchNoFilters: HogFunctionType
+        let globals: HogFunctionInvocationGlobals
+
+        let kafkaMessages = {
+            metrics: [] as any[],
+            logs: [] as any[],
+            invocations: [] as any[],
+        }
+
+        beforeEach(async () => {
+            fnFetchNoFilters = await insertHogFunction({
+                ...HOG_EXAMPLES.simple_fetch,
+                ...HOG_INPUTS_EXAMPLES.simple_fetch,
+                ...HOG_FILTERS_EXAMPLES.no_filters,
+            })
+
+            globals = createHogExecutionGlobals({
+                project: {
+                    id: team.id,
+                } as any,
+                event: {
+                    uuid: 'b3a1fe86-b10c-43cc-acaf-d208977608d0',
+                    name: '$pageview',
+                    properties: {
+                        $current_url: 'https://posthog.com',
+                        $lib_version: '1.0.0',
+                    },
+                } as any,
+            })
+
+            kafkaMessages = {
+                metrics: [],
+                logs: [],
+                invocations: [],
+            }
+        })
+
+        const gatherProducedMessages = () => {
+            const allMessages = decodeAllKafkaMessages()
+
+            allMessages.forEach((message) => {
+                if (message.topic === 'clickhouse_app_metrics2_test') {
+                    kafkaMessages.metrics.push(message)
+                } else if (message.topic === 'log_entries_test') {
+                    kafkaMessages.logs.push(message)
+                } else if (message.topic === 'cdp_function_callbacks_test') {
+                    kafkaMessages.invocations.push(message)
+                } else {
+                    throw new Error(`Unknown topic: ${message.topic}`)
+                }
+            })
+
+            mockProducer.produce.mockClear()
+        }
+
+        it('should invoke a function via kafka transportation until completed', async () => {
+            // NOTE: We can skip kafka as the entry point
+            const invocations = await processedEventsConsumer.processBatch([globals])
+            expect(invocations).toHaveLength(1)
+            gatherProducedMessages()
+
+            expect(kafkaMessages.invocations).toHaveLength(1)
+            expect(kafkaMessages.invocations[0].topic).toEqual('cdp_function_callbacks_test')
+            mockProducer.produce.mockClear()
+
+            while (kafkaMessages.invocations.length) {
+                await functionProcessor._handleKafkaBatch([convertToKafkaMessage(kafkaMessages.invocations[0])])
+                kafkaMessages.invocations = []
+                gatherProducedMessages()
+            }
+
+            expect(kafkaMessages.metrics).toMatchObject([
+                {
+                    key: fnFetchNoFilters.id.toString(),
+                    value: {
+                        app_source: 'hog_function',
+                        app_source_id: fnFetchNoFilters.id.toString(),
+                        count: 1,
+                        metric_kind: 'success',
+                        metric_name: 'succeeded',
+                        team_id: 2,
+                    },
+                },
+            ])
+            expect(kafkaMessages.logs.map((x) => x.value.message)).toEqual([
+                'Executing function',
+                "Suspending function due to async function call 'fetch'. Payload: 1902 bytes",
+                'Resuming function',
+                'Fetch response:, {"status":200,"body":{"success":true}}',
+                expect.stringContaining('Function completed'),
+            ])
+        })
+    })
+})
diff --git a/plugin-server/tests/cdp/cdp-processed-events-consumer.test.ts b/plugin-server/tests/cdp/cdp-processed-events-consumer.test.ts
index 8a4c87efa4450..b0a1c09f15d6f 100644
--- a/plugin-server/tests/cdp/cdp-processed-events-consumer.test.ts
+++ b/plugin-server/tests/cdp/cdp-processed-events-consumer.test.ts
@@ -1,10 +1,16 @@
 import { CdpProcessedEventsConsumer } from '../../src/cdp/cdp-consumers'
-import { HogFunctionType } from '../../src/cdp/types'
+import { HogWatcherState } from '../../src/cdp/hog-watcher'
+import { HogFunctionInvocationGlobals, HogFunctionType } from '../../src/cdp/types'
 import { Hub, Team } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { getFirstTeam, resetTestDatabase } from '../helpers/sql'
 import { HOG_EXAMPLES, HOG_FILTERS_EXAMPLES, HOG_INPUTS_EXAMPLES } from './examples'
-import { createIncomingEvent, createMessage, insertHogFunction as _insertHogFunction } from './fixtures'
+import {
+    createHogExecutionGlobals,
+    createIncomingEvent,
+    createMessage,
+    insertHogFunction as _insertHogFunction,
+} from './fixtures'
 
 const mockConsumer = {
     on: jest.fn(),
@@ -62,8 +68,6 @@ const mockProducer = require('../../src/utils/db/kafka-producer-wrapper').KafkaP
 
 jest.setTimeout(1000)
 
-const noop = () => {}
-
 const decodeKafkaMessage = (message: any): any => {
     return {
         ...message,
@@ -71,10 +75,13 @@ const decodeKafkaMessage = (message: any): any => {
     }
 }
 
-describe('CDP Processed Events Consuner', () => {
+const decodeAllKafkaMessages = (): any[] => {
+    return mockProducer.produce.mock.calls.map((x) => decodeKafkaMessage(x[0]))
+}
+
+describe('CDP Processed Events Consumer', () => {
     let processor: CdpProcessedEventsConsumer
     let hub: Hub
-    let closeHub: () => Promise<void>
     let team: Team
 
     const insertHogFunction = async (hogFunction: Partial<HogFunctionType>) => {
@@ -86,7 +93,7 @@ describe('CDP Processed Events Consuner', () => {
 
     beforeEach(async () => {
         await resetTestDatabase()
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         team = await getFirstTeam(hub)
 
         processor = new CdpProcessedEventsConsumer(hub)
@@ -98,7 +105,7 @@ describe('CDP Processed Events Consuner', () => {
     afterEach(async () => {
         jest.setTimeout(10000)
         await processor.stop()
-        await closeHub()
+        await closeHub(hub)
     })
 
     afterAll(() => {
@@ -106,19 +113,163 @@ describe('CDP Processed Events Consuner', () => {
     })
 
     describe('general event processing', () => {
-        /**
-         * Tests here are somewhat expensive so should mostly simulate happy paths and the more e2e scenarios
-         */
-        it('can parse incoming messages correctly', async () => {
-            await insertHogFunction({
-                ...HOG_EXAMPLES.simple_fetch,
-                ...HOG_INPUTS_EXAMPLES.simple_fetch,
-                ...HOG_FILTERS_EXAMPLES.no_filters,
+        beforeEach(() => {
+            hub.CDP_EVENT_PROCESSOR_EXECUTE_FIRST_STEP = false
+        })
+
+        describe('common processing', () => {
+            let fnFetchNoFilters: HogFunctionType
+            let fnPrinterPageviewFilters: HogFunctionType
+            let globals: HogFunctionInvocationGlobals
+
+            beforeEach(async () => {
+                fnFetchNoFilters = await insertHogFunction({
+                    ...HOG_EXAMPLES.simple_fetch,
+                    ...HOG_INPUTS_EXAMPLES.simple_fetch,
+                    ...HOG_FILTERS_EXAMPLES.no_filters,
+                })
+
+                fnPrinterPageviewFilters = await insertHogFunction({
+                    ...HOG_EXAMPLES.input_printer,
+                    ...HOG_INPUTS_EXAMPLES.secret_inputs,
+                    ...HOG_FILTERS_EXAMPLES.pageview_or_autocapture_filter,
+                })
+
+                globals = createHogExecutionGlobals({
+                    project: {
+                        id: team.id,
+                    } as any,
+                    event: {
+                        uuid: 'b3a1fe86-b10c-43cc-acaf-d208977608d0',
+                        name: '$pageview',
+                        properties: {
+                            $current_url: 'https://posthog.com',
+                            $lib_version: '1.0.0',
+                        },
+                    } as any,
+                })
+            })
+
+            const matchInvocation = (hogFunction: HogFunctionType, globals: HogFunctionInvocationGlobals) => {
+                return {
+                    hogFunction: {
+                        id: hogFunction.id,
+                    },
+                    globals: {
+                        event: globals.event,
+                    },
+                }
+            }
+
+            it('should process events', async () => {
+                const invocations = await processor.processBatch([globals])
+
+                expect(invocations).toHaveLength(2)
+                expect(invocations).toMatchObject([
+                    matchInvocation(fnFetchNoFilters, globals),
+                    matchInvocation(fnPrinterPageviewFilters, globals),
+                ])
+
+                expect(mockProducer.produce).toHaveBeenCalledTimes(2)
+
+                expect(decodeAllKafkaMessages()).toMatchObject([
+                    {
+                        key: expect.any(String),
+                        topic: 'cdp_function_callbacks_test',
+                        value: {
+                            state: expect.any(String),
+                        },
+                        waitForAck: true,
+                    },
+                    {
+                        key: expect.any(String),
+                        topic: 'cdp_function_callbacks_test',
+                        value: {
+                            state: expect.any(String),
+                        },
+                        waitForAck: true,
+                    },
+                ])
+            })
+
+            it("should filter out functions that don't match the filter", async () => {
+                globals.event.properties.$current_url = 'https://nomatch.com'
+
+                const invocations = await processor.processBatch([globals])
+
+                expect(invocations).toHaveLength(1)
+                expect(invocations).toMatchObject([matchInvocation(fnFetchNoFilters, globals)])
+                expect(mockProducer.produce).toHaveBeenCalledTimes(2)
+
+                expect(decodeAllKafkaMessages()).toMatchObject([
+                    {
+                        key: expect.any(String),
+                        topic: 'clickhouse_app_metrics2_test',
+                        value: {
+                            app_source: 'hog_function',
+                            app_source_id: fnPrinterPageviewFilters.id,
+                            count: 1,
+                            metric_kind: 'other',
+                            metric_name: 'filtered',
+                            team_id: 2,
+                            timestamp: expect.any(String),
+                        },
+                    },
+                    {
+                        topic: 'cdp_function_callbacks_test',
+                    },
+                ])
             })
-            // Create a message that should be processed by this function
-            // Run the function and check that it was executed
-            await processor.handleEachBatch(
-                [
+
+            it.each([
+                [HogWatcherState.disabledForPeriod, 'disabled_temporarily'],
+                [HogWatcherState.disabledIndefinitely, 'disabled_permanently'],
+            ])('should filter out functions that are disabled', async (state, metric_name) => {
+                await processor.hogWatcher.forceStateChange(fnFetchNoFilters.id, state)
+                await processor.hogWatcher.forceStateChange(fnPrinterPageviewFilters.id, state)
+
+                const invocations = await processor.processBatch([globals])
+
+                expect(invocations).toHaveLength(0)
+                expect(mockProducer.produce).toHaveBeenCalledTimes(2)
+
+                expect(decodeAllKafkaMessages()).toMatchObject([
+                    {
+                        topic: 'clickhouse_app_metrics2_test',
+                        value: {
+                            app_source: 'hog_function',
+                            app_source_id: fnFetchNoFilters.id,
+                            count: 1,
+                            metric_kind: 'failure',
+                            metric_name: metric_name,
+                            team_id: 2,
+                        },
+                    },
+                    {
+                        topic: 'clickhouse_app_metrics2_test',
+                        value: {
+                            app_source: 'hog_function',
+                            app_source_id: fnPrinterPageviewFilters.id,
+                            count: 1,
+                            metric_kind: 'failure',
+                            metric_name: metric_name,
+                            team_id: 2,
+                        },
+                    },
+                ])
+            })
+        })
+
+        describe('kafka parsing', () => {
+            it('can parse incoming messages correctly', async () => {
+                await insertHogFunction({
+                    ...HOG_EXAMPLES.simple_fetch,
+                    ...HOG_INPUTS_EXAMPLES.simple_fetch,
+                    ...HOG_FILTERS_EXAMPLES.no_filters,
+                })
+                // Create a message that should be processed by this function
+                // Run the function and check that it was executed
+                await processor._handleKafkaBatch([
                     createMessage(
                         createIncomingEvent(team.id, {
                             uuid: 'b3a1fe86-b10c-43cc-acaf-d208977608d0',
@@ -128,37 +279,36 @@ describe('CDP Processed Events Consuner', () => {
                             }),
                         })
                     ),
-                ],
-                noop
-            )
-
-            expect(mockFetch).toHaveBeenCalledTimes(1)
-            expect(mockFetch.mock.calls[0]).toMatchInlineSnapshot(`
-                Array [
-                  "https://example.com/posthog-webhook",
-                  Object {
-                    "body": "{\\"event\\":{\\"uuid\\":\\"b3a1fe86-b10c-43cc-acaf-d208977608d0\\",\\"name\\":\\"$pageview\\",\\"distinct_id\\":\\"distinct_id_1\\",\\"properties\\":{\\"$lib_version\\":\\"1.0.0\\",\\"$elements_chain\\":\\"[]\\"},\\"timestamp\\":null,\\"url\\":\\"http://localhost:8000/project/2/events/b3a1fe86-b10c-43cc-acaf-d208977608d0/null\\"},\\"groups\\":{},\\"nested\\":{\\"foo\\":\\"http://localhost:8000/project/2/events/b3a1fe86-b10c-43cc-acaf-d208977608d0/null\\"},\\"person\\":null,\\"event_url\\":\\"http://localhost:8000/project/2/events/b3a1fe86-b10c-43cc-acaf-d208977608d0/null-test\\"}",
-                    "headers": Object {
-                      "version": "v=1.0.0",
+                ])
+
+                // Generall check that the message seemed to get processed
+                expect(decodeAllKafkaMessages()).toMatchObject([
+                    {
+                        key: expect.any(String),
+                        topic: 'cdp_function_callbacks_test',
+                        value: {
+                            state: expect.any(String),
+                        },
+                        waitForAck: true,
                     },
-                    "method": "POST",
-                    "timeout": 10000,
-                  },
-                ]
-            `)
+                ])
+            })
         })
 
-        it('generates logs and metrics and produces them to kafka', async () => {
-            const hogFunction = await insertHogFunction({
-                ...HOG_EXAMPLES.simple_fetch,
-                ...HOG_INPUTS_EXAMPLES.simple_fetch,
-                ...HOG_FILTERS_EXAMPLES.no_filters,
+        describe('no delayed execution', () => {
+            beforeEach(() => {
+                hub.CDP_EVENT_PROCESSOR_EXECUTE_FIRST_STEP = true
             })
 
-            // Create a message that should be processed by this function
-            // Run the function and check that it was executed
-            await processor.handleEachBatch(
-                [
+            it('should invoke the initial function before enqueuing', async () => {
+                await insertHogFunction({
+                    ...HOG_EXAMPLES.simple_fetch,
+                    ...HOG_INPUTS_EXAMPLES.simple_fetch,
+                    ...HOG_FILTERS_EXAMPLES.no_filters,
+                })
+                // Create a message that should be processed by this function
+                // Run the function and check that it was executed
+                await processor._handleKafkaBatch([
                     createMessage(
                         createIncomingEvent(team.id, {
                             uuid: 'b3a1fe86-b10c-43cc-acaf-d208977608d0',
@@ -168,77 +318,37 @@ describe('CDP Processed Events Consuner', () => {
                             }),
                         })
                     ),
-                ],
-                noop
-            )
-
-            expect(mockFetch).toHaveBeenCalledTimes(1)
-            // Once for the async callback, twice for the logs, once for metrics
-            expect(mockProducer.produce).toHaveBeenCalledTimes(4)
-
-            expect(decodeKafkaMessage(mockProducer.produce.mock.calls[0][0])).toEqual({
-                key: expect.any(String),
-                topic: 'clickhouse_app_metrics2_test',
-                value: {
-                    app_source: 'hog_function',
-                    team_id: 2,
-                    app_source_id: hogFunction.id,
-                    metric_kind: 'success',
-                    metric_name: 'succeeded',
-                    count: 1,
-                    timestamp: expect.any(String),
-                },
-                waitForAck: true,
-            })
-
-            expect(decodeKafkaMessage(mockProducer.produce.mock.calls[1][0])).toEqual({
-                key: expect.any(String),
-                topic: 'log_entries_test',
-                value: {
-                    instance_id: expect.any(String),
-                    level: 'debug',
-                    log_source: 'hog_function',
-                    log_source_id: expect.any(String),
-                    message: 'Executing function',
-                    team_id: 2,
-                    timestamp: expect.any(String),
-                },
-
-                waitForAck: true,
-            })
+                ])
 
-            expect(decodeKafkaMessage(mockProducer.produce.mock.calls[2][0])).toMatchObject({
-                topic: 'log_entries_test',
-                value: {
-                    log_source: 'hog_function',
-                    message: "Suspending function due to async function call 'fetch'. Payload: 1855 bytes",
-                    team_id: 2,
-                },
-            })
-
-            const msg = decodeKafkaMessage(mockProducer.produce.mock.calls[3][0])
-
-            expect(msg).toEqual({
-                key: expect.any(String),
-                topic: 'cdp_function_callbacks_test',
-                value: {
-                    state: expect.any(String),
-                    hogFunctionId: hogFunction.id,
-                    teamId: 2,
-                    asyncFunctionResponse: {
-                        response: {
-                            status: 200,
-                            body: { success: true },
+                // General check that the message seemed to get processed
+                expect(decodeAllKafkaMessages()).toMatchObject([
+                    {
+                        key: expect.any(String),
+                        topic: 'log_entries_test',
+                        value: {
+                            message: 'Executing function',
+                        },
+                        waitForAck: true,
+                    },
+                    {
+                        key: expect.any(String),
+                        topic: 'log_entries_test',
+                        value: {
+                            message: expect.stringContaining(
+                                "Suspending function due to async function call 'fetch'. Payload"
+                            ),
+                        },
+                        waitForAck: true,
+                    },
+                    {
+                        key: expect.any(String),
+                        topic: 'cdp_function_callbacks_test',
+                        value: {
+                            state: expect.any(String),
                         },
-                        timings: [
-                            {
-                                kind: 'async_function',
-                                duration_ms: expect.any(Number),
-                            },
-                        ],
+                        waitForAck: true,
                     },
-                },
-                waitForAck: true,
+                ])
             })
         })
     })
diff --git a/plugin-server/tests/cdp/fixtures.ts b/plugin-server/tests/cdp/fixtures.ts
index 8f3fed7da62dc..52b8c20cf4b3d 100644
--- a/plugin-server/tests/cdp/fixtures.ts
+++ b/plugin-server/tests/cdp/fixtures.ts
@@ -1,22 +1,25 @@
 import { randomUUID } from 'crypto'
 import { Message } from 'node-rdkafka'
 
-import { HogFunctionInvocationGlobals, HogFunctionType, IntegrationType } from '../../src/cdp/types'
+import {
+    HogFunctionInvocation,
+    HogFunctionInvocationGlobals,
+    HogFunctionType,
+    IntegrationType,
+} from '../../src/cdp/types'
 import { ClickHouseTimestamp, RawClickHouseEvent, Team } from '../../src/types'
 import { PostgresRouter } from '../../src/utils/db/postgres'
+import { UUIDT } from '../../src/utils/utils'
 import { insertRow } from '../helpers/sql'
 
 export const createHogFunction = (hogFunction: Partial<HogFunctionType>) => {
     const item: HogFunctionType = {
         id: randomUUID(),
+        name: 'Hog Function',
         team_id: 1,
-        created_at: new Date().toISOString(),
-        updated_at: new Date().toISOString(),
-        created_by_id: 1001,
         enabled: true,
-        deleted: false,
-        description: '',
         hog: '',
+        bytecode: [],
         ...hogFunction,
     }
 
@@ -68,14 +71,19 @@ export const insertHogFunction = async (
     team_id: Team['id'],
     hogFunction: Partial<HogFunctionType> = {}
 ): Promise<HogFunctionType> => {
-    const res = await insertRow(
-        postgres,
-        'posthog_hogfunction',
-        createHogFunction({
+    // This is only used for testing so we need to override some values
+
+    const res = await insertRow(postgres, 'posthog_hogfunction', {
+        ...createHogFunction({
             ...hogFunction,
             team_id: team_id,
-        })
-    )
+        }),
+        description: '',
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        created_by_id: 1001,
+        deleted: false,
+    })
     return res
 }
 
@@ -99,13 +107,14 @@ export const createHogExecutionGlobals = (
     data: Partial<HogFunctionInvocationGlobals> = {}
 ): HogFunctionInvocationGlobals => {
     return {
+        groups: {},
         ...data,
         person: {
             uuid: 'uuid',
             name: 'test',
             url: 'http://localhost:8000/persons/1',
             properties: {
-                $lib_version: '1.2.3',
+                email: 'test@posthog.com',
             },
             ...(data.person ?? {}),
         },
@@ -128,3 +137,28 @@ export const createHogExecutionGlobals = (
         },
     }
 }
+
+export const createInvocation = (
+    _hogFunction: Partial<HogFunctionType> = {},
+    _globals: Partial<HogFunctionInvocationGlobals> = {}
+): HogFunctionInvocation => {
+    const hogFunction = createHogFunction(_hogFunction)
+    // Add the source of the trigger to the globals
+    let globals = createHogExecutionGlobals(_globals)
+    globals = {
+        ...globals,
+        source: {
+            name: hogFunction.name ?? `Hog function: ${hogFunction.id}`,
+            url: `${globals.project.url}/pipeline/destinations/hog-${hogFunction.id}/configuration/`,
+        },
+    }
+
+    return {
+        id: new UUIDT().toString(),
+        globals,
+        teamId: hogFunction.team_id,
+        hogFunction,
+        queue: 'hog',
+        timings: [],
+    }
+}
diff --git a/plugin-server/tests/cdp/groups-manager.test.ts b/plugin-server/tests/cdp/groups-manager.test.ts
index eb3d718211ce1..f489d6b019045 100644
--- a/plugin-server/tests/cdp/groups-manager.test.ts
+++ b/plugin-server/tests/cdp/groups-manager.test.ts
@@ -50,6 +50,7 @@ describe('Groups Manager', () => {
 
         it('does nothing if no group properties found', async () => {
             const globals = createHogExecutionGlobals({
+                groups: undefined,
                 event: {
                     properties: {
                         $groups: { GroupA: 'id-1', GroupB: 'id-2' },
@@ -84,6 +85,7 @@ describe('Groups Manager', () => {
                 { team_id: 1, group_type_index: 1, group_key: 'id-2', group_properties: { prop: 'value-2' } },
             ]
             const globals = createHogExecutionGlobals({
+                groups: undefined,
                 event: {
                     properties: {
                         $groups: { GroupA: 'id-1', GroupB: 'id-2' },
@@ -125,14 +127,17 @@ describe('Groups Manager', () => {
             const items = [
                 // Should get both groups enriched
                 createHogExecutionGlobals({
+                    groups: undefined,
                     event: { properties: { $groups: { GroupA: 'id-1', GroupB: 'id-2' } } } as any,
                 }),
                 // Should get its group enriched (via reference)
                 createHogExecutionGlobals({
+                    groups: undefined,
                     event: { properties: { $groups: { GroupA: 'id-1' } } } as any,
                 }),
                 // Should get the right group for its team
                 createHogExecutionGlobals({
+                    groups: undefined,
                     project: { id: 2 } as any,
                     event: { properties: { $groups: { GroupA: 'id-1' } } } as any,
                 }),
@@ -191,10 +196,12 @@ describe('Groups Manager', () => {
     it('cached group type queries', async () => {
         const globals = [
             createHogExecutionGlobals({
+                groups: undefined,
                 project: { id: 1 } as any,
                 event: { properties: { $groups: { GroupA: 'id-1', GroupB: 'id-2' } } } as any,
             }),
             createHogExecutionGlobals({
+                groups: undefined,
                 project: { id: 2 } as any,
                 event: { properties: { $groups: { GroupA: 'id-1', GroupB: 'id-2' } } } as any,
             }),
@@ -209,6 +216,7 @@ describe('Groups Manager', () => {
 
         globals.push(
             createHogExecutionGlobals({
+                groups: undefined,
                 project: { id: 3 } as any,
                 event: { properties: { $groups: { GroupA: 'id-1', GroupB: 'id-2' } } } as any,
             })
diff --git a/plugin-server/tests/cdp/hog-executor.test.ts b/plugin-server/tests/cdp/hog-executor.test.ts
index f14d45b149647..9ca121a2718e3 100644
--- a/plugin-server/tests/cdp/hog-executor.test.ts
+++ b/plugin-server/tests/cdp/hog-executor.test.ts
@@ -2,14 +2,14 @@ import { DateTime } from 'luxon'
 
 import { HogExecutor } from '../../src/cdp/hog-executor'
 import { HogFunctionManager } from '../../src/cdp/hog-function-manager'
-import {
-    HogFunctionAsyncFunctionResponse,
-    HogFunctionInvocationResult,
-    HogFunctionType,
-    LogEntry,
-} from '../../src/cdp/types'
+import { HogFunctionAsyncFunctionResponse, HogFunctionType } from '../../src/cdp/types'
 import { HOG_EXAMPLES, HOG_FILTERS_EXAMPLES, HOG_INPUTS_EXAMPLES } from './examples'
-import { createHogExecutionGlobals, createHogFunction, insertHogFunction as _insertHogFunction } from './fixtures'
+import {
+    createHogExecutionGlobals,
+    createHogFunction,
+    createInvocation,
+    insertHogFunction as _insertHogFunction,
+} from './fixtures'
 
 const createAsyncFunctionResponse = (response?: Record<string, any>): HogFunctionAsyncFunctionResponse => {
     return {
@@ -57,28 +57,35 @@ describe('Hog Executor', () => {
             mockFunctionManager.getTeamHogFunction.mockReturnValue(hogFunction)
         })
 
-        it('can execute messages', () => {
-            const globals = createHogExecutionGlobals({ groups: {} })
-            const results = executor
-                .findMatchingFunctions(createHogExecutionGlobals({ groups: {} }))
-                .matchingFunctions.map((x) => executor.executeFunction(globals, x) as HogFunctionInvocationResult)
-            expect(results).toHaveLength(1)
-            expect(results[0]).toMatchObject({
+        it('can execute an invocation', () => {
+            const invocation = createInvocation(hogFunction)
+            const result = executor.execute(invocation)
+            expect(result).toEqual({
+                capturedPostHogEvents: [],
                 invocation: {
                     id: expect.any(String),
-                    hogFunctionId: hogFunction.id,
+                    teamId: 1,
+                    globals: invocation.globals,
+                    hogFunction: invocation.hogFunction,
+                    queue: 'fetch',
+                    queueParameters: expect.any(Object),
+                    timings: [
+                        {
+                            kind: 'hog',
+                            duration_ms: 0,
+                        },
+                    ],
+                    vmState: expect.any(Object),
                 },
                 finished: false,
-                asyncFunctionRequest: {},
+                logs: expect.any(Array),
             })
         })
 
         it('collects logs from the function', () => {
-            const globals = createHogExecutionGlobals({ groups: {} })
-            const results = executor
-                .findMatchingFunctions(createHogExecutionGlobals({ groups: {} }))
-                .matchingFunctions.map((x) => executor.executeFunction(globals, x) as HogFunctionInvocationResult)
-            expect(results[0].logs).toMatchObject([
+            const invocation = createInvocation(hogFunction)
+            const result = executor.execute(invocation)
+            expect(result.logs).toMatchObject([
                 {
                     timestamp: expect.any(DateTime),
                     level: 'debug',
@@ -87,7 +94,7 @@ describe('Hog Executor', () => {
                 {
                     timestamp: expect.any(DateTime),
                     level: 'debug',
-                    message: "Suspending function due to async function call 'fetch'. Payload: 1814 bytes",
+                    message: "Suspending function due to async function call 'fetch'. Payload: 1818 bytes",
                 },
             ])
         })
@@ -97,13 +104,9 @@ describe('Hog Executor', () => {
                 ...HOG_EXAMPLES.input_printer,
                 ...HOG_INPUTS_EXAMPLES.secret_inputs,
             })
+            const invocation = createInvocation(fn)
+            const result = executor.execute(invocation)
 
-            mockFunctionManager.getTeamHogFunctions.mockReturnValue([fn])
-
-            const result = executor.executeFunction(
-                createHogExecutionGlobals({ groups: {} }),
-                fn
-            ) as HogFunctionInvocationResult
             expect(result.logs.map((x) => x.message)).toMatchInlineSnapshot(`
                 Array [
                   "Executing function",
@@ -118,120 +121,87 @@ describe('Hog Executor', () => {
         })
 
         it('queues up an async function call', () => {
-            const globals = createHogExecutionGlobals({ groups: {} })
-            const results = executor
-                .findMatchingFunctions(createHogExecutionGlobals({ groups: {} }))
-                .matchingFunctions.map((x) => executor.executeFunction(globals, x) as HogFunctionInvocationResult)
-            expect(results[0]).toMatchObject({
-                invocation: {
-                    id: results[0].invocation.id,
-                    teamId: 1,
-                    hogFunctionId: hogFunction.id,
-                    vmState: expect.any(Object),
-                    globals: {
-                        project: { id: 1, name: 'test', url: 'http://localhost:8000/projects/1' },
-                        event: {
-                            uuid: 'uuid',
-                            name: 'test',
-                            distinct_id: 'distinct_id',
-                            url: 'http://localhost:8000/events/1',
-                            properties: { $lib_version: '1.2.3' },
-                            timestamp: '2024-06-07T12:00:00.000Z',
-                        },
-                        source: {
-                            name: 'Test hog function',
-                            url: `http://localhost:8000/projects/1/pipeline/destinations/hog-${hogFunction.id}/configuration/`,
-                        },
-                    },
-                    timings: [
-                        {
-                            kind: 'hog',
-                            duration_ms: 0,
-                        },
-                    ],
+            const invocation = createInvocation(hogFunction)
+            const result = executor.execute(invocation)
+
+            expect(result.invocation).toMatchObject({
+                queue: 'fetch',
+                queueParameters: {
+                    url: 'https://example.com/posthog-webhook',
+                    method: 'POST',
+                    headers: { version: 'v=1.2.3' },
                 },
+            })
 
-                asyncFunctionRequest: {
-                    name: 'fetch',
-                    args: [
-                        'https://example.com/posthog-webhook',
-                        {
-                            headers: { version: 'v=1.2.3' },
-                            body: {
-                                event: {
-                                    uuid: 'uuid',
-                                    name: 'test',
-                                    distinct_id: 'distinct_id',
-                                    url: 'http://localhost:8000/events/1',
-                                    properties: { $lib_version: '1.2.3' },
-                                    timestamp: '2024-06-07T12:00:00.000Z',
-                                },
-                                groups: {},
-                                nested: { foo: 'http://localhost:8000/events/1' },
-                                person: {
-                                    uuid: 'uuid',
-                                    name: 'test',
-                                    url: 'http://localhost:8000/persons/1',
-                                    properties: { $lib_version: '1.2.3' },
-                                },
-                                event_url: 'http://localhost:8000/events/1-test',
-                            },
-                            method: 'POST',
-                        },
-                    ],
+            expect(JSON.parse(result.invocation.queueParameters!.body)).toEqual({
+                event: {
+                    uuid: 'uuid',
+                    name: 'test',
+                    distinct_id: 'distinct_id',
+                    url: 'http://localhost:8000/events/1',
+                    properties: { $lib_version: '1.2.3' },
+                    timestamp: '2024-06-07T12:00:00.000Z',
+                },
+                groups: {},
+                nested: { foo: 'http://localhost:8000/events/1' },
+                person: {
+                    uuid: 'uuid',
+                    name: 'test',
+                    url: 'http://localhost:8000/persons/1',
+                    properties: { email: 'test@posthog.com' },
                 },
+                event_url: 'http://localhost:8000/events/1-test',
             })
         })
 
         it('executes the full function in a loop', () => {
-            const logs: LogEntry[] = []
-            const globals = createHogExecutionGlobals({ groups: {} })
-            const results = executor
-                .findMatchingFunctions(createHogExecutionGlobals({ groups: {} }))
-                .matchingFunctions.map((x) => executor.executeFunction(globals, x) as HogFunctionInvocationResult)
-            const splicedLogs = results[0].logs.splice(0, 100)
-            logs.push(...splicedLogs)
-
-            const asyncExecResult = executor.executeAsyncResponse(results[0].invocation, createAsyncFunctionResponse())
-
-            logs.push(...asyncExecResult.logs)
-            expect(asyncExecResult.error).toBeUndefined()
-            expect(asyncExecResult.finished).toBe(true)
-            expect(logs.map((log) => log.message)).toEqual([
-                'Executing function',
-                "Suspending function due to async function call 'fetch'. Payload: 1814 bytes",
-                'Resuming function',
-                'Fetch response:, {"status":200,"body":"success"}',
-                'Function completed in 100ms. Sync: 0ms. Mem: 746 bytes. Ops: 22.',
-            ])
+            const result = executor.execute(createInvocation(hogFunction))
+            const logs = result.logs.splice(0, 100)
+
+            expect(result.finished).toBe(false)
+            expect(result.invocation.queue).toBe('fetch')
+            expect(result.invocation.vmState).toBeDefined()
+
+            // Simulate what the callback does
+            result.invocation.queue = 'hog'
+            result.invocation.queueParameters = createAsyncFunctionResponse()
+
+            const secondResult = executor.execute(result.invocation)
+            logs.push(...secondResult.logs)
+
+            expect(secondResult.finished).toBe(true)
+            expect(secondResult.error).toBeUndefined()
+            expect(logs.map((log) => log.message)).toMatchInlineSnapshot(`
+                Array [
+                  "Executing function",
+                  "Suspending function due to async function call 'fetch'. Payload: 1818 bytes",
+                  "Resuming function",
+                  "Fetch response:, {\\"status\\":200,\\"body\\":\\"success\\"}",
+                  "Function completed in 100ms. Sync: 0ms. Mem: 750 bytes. Ops: 22.",
+                ]
+            `)
         })
 
         it('parses the responses body if a string', () => {
-            const logs: LogEntry[] = []
-            const globals = createHogExecutionGlobals({ groups: {} })
-            const results = executor
-                .findMatchingFunctions(createHogExecutionGlobals({ groups: {} }))
-                .matchingFunctions.map((x) => executor.executeFunction(globals, x) as HogFunctionInvocationResult)
-            const splicedLogs = results[0].logs.splice(0, 100)
-            logs.push(...splicedLogs)
-
-            const asyncExecResult = executor.executeAsyncResponse(
-                results[0].invocation,
-                createAsyncFunctionResponse({
-                    body: JSON.stringify({ foo: 'bar' }),
-                })
-            )
+            const result = executor.execute(createInvocation(hogFunction))
+            const logs = result.logs.splice(0, 100)
+            result.invocation.queue = 'hog'
+            result.invocation.queueParameters = createAsyncFunctionResponse({
+                body: JSON.stringify({ foo: 'bar' }),
+            })
 
-            logs.push(...asyncExecResult.logs)
-            expect(asyncExecResult.error).toBeUndefined()
-            expect(asyncExecResult.finished).toBe(true)
-            expect(logs.map((log) => log.message)).toEqual([
-                'Executing function',
-                "Suspending function due to async function call 'fetch'. Payload: 1814 bytes",
-                'Resuming function',
-                'Fetch response:, {"status":200,"body":{"foo":"bar"}}', // The body is parsed
-                'Function completed in 100ms. Sync: 0ms. Mem: 746 bytes. Ops: 22.',
-            ])
+            const secondResult = executor.execute(result.invocation)
+            logs.push(...secondResult.logs)
+
+            expect(logs.map((log) => log.message)).toMatchInlineSnapshot(`
+                Array [
+                  "Executing function",
+                  "Suspending function due to async function call 'fetch'. Payload: 1818 bytes",
+                  "Resuming function",
+                  "Fetch response:, {\\"status\\":200,\\"body\\":{\\"foo\\":\\"bar\\"}}",
+                  "Function completed in 100ms. Sync: 0ms. Mem: 750 bytes. Ops: 22.",
+                ]
+            `)
         })
     })
 
@@ -465,7 +435,7 @@ describe('Hog Executor', () => {
         })
     })
 
-    describe('async function responses', () => {
+    describe('async functions', () => {
         it('prevents large looped fetch calls', () => {
             const fn = createHogFunction({
                 ...HOG_EXAMPLES.recursive_fetch,
@@ -473,27 +443,26 @@ describe('Hog Executor', () => {
                 ...HOG_FILTERS_EXAMPLES.no_filters,
             })
 
-            mockFunctionManager.getTeamHogFunctions.mockReturnValue([fn])
-
             // Simulate the recusive loop
-            const globals = createHogExecutionGlobals({ groups: {} })
-            const results = executor
-                .findMatchingFunctions(createHogExecutionGlobals({ groups: {} }))
-                .matchingFunctions.map((x) => executor.executeFunction(globals, x) as HogFunctionInvocationResult)
-            expect(results).toHaveLength(1)
-
-            // Run the result one time simulating a successful fetch
-            const asyncResult1 = executor.executeAsyncResponse(results[0].invocation, createAsyncFunctionResponse())
-            expect(asyncResult1.finished).toBe(false)
-            expect(asyncResult1.error).toBe(undefined)
-            expect(asyncResult1.asyncFunctionRequest).toBeDefined()
-
-            // Run the result one more time simulating a second successful fetch
-            const asyncResult2 = executor.executeAsyncResponse(asyncResult1.invocation, createAsyncFunctionResponse())
+            const invocation = createInvocation(fn)
+
+            // Start the function
+            const result1 = executor.execute(invocation)
+            // Run the response one time simulating a successful fetch
+            result1.invocation.queue = 'hog'
+            result1.invocation.queueParameters = createAsyncFunctionResponse()
+            const result2 = executor.execute(result1.invocation)
+            expect(result2.finished).toBe(false)
+            expect(result2.error).toBe(undefined)
+            expect(result2.invocation.queue).toBe('fetch')
+
             // This time we should see an error for hitting the loop limit
-            expect(asyncResult2.finished).toBe(false)
-            expect(asyncResult2.error).toEqual('Exceeded maximum number of async steps: 2')
-            expect(asyncResult2.logs.map((log) => log.message)).toEqual([
+            result2.invocation.queue = 'hog'
+            result2.invocation.queueParameters = createAsyncFunctionResponse()
+            const result3 = executor.execute(result1.invocation)
+            expect(result3.finished).toBe(false)
+            expect(result3.error).toEqual('Exceeded maximum number of async steps: 2')
+            expect(result3.logs.map((log) => log.message)).toEqual([
                 'Resuming function',
                 'Error executing function: HogVMException: Exceeded maximum number of async steps: 2',
             ])
@@ -514,14 +483,10 @@ describe('Hog Executor', () => {
 
             mockFunctionManager.getTeamHogFunctions.mockReturnValue([fn])
 
-            const globals = createHogExecutionGlobals({ groups: {} })
-            const results = executor
-                .findMatchingFunctions(createHogExecutionGlobals({ groups: {} }))
-                .matchingFunctions.map((x) => executor.executeFunction(globals, x) as HogFunctionInvocationResult)
-            expect(results).toHaveLength(1)
-            expect(results[0].error).toContain('Execution timed out after 0.1 seconds. Performed ')
+            const result = executor.execute(createInvocation(fn))
+            expect(result.error).toContain('Execution timed out after 0.1 seconds. Performed ')
 
-            expect(results[0].logs.map((log) => log.message)).toEqual([
+            expect(result.logs.map((log) => log.message)).toEqual([
                 'Executing function',
                 'I AM FIBONACCI',
                 'I AM FIBONACCI',
@@ -548,8 +513,7 @@ describe('Hog Executor', () => {
                 ...HOG_FILTERS_EXAMPLES.no_filters,
             })
 
-            const globals = createHogExecutionGlobals({ groups: {} })
-            const result = executor.executeFunction(globals, fn)
+            const result = executor.execute(createInvocation(fn))
             expect(result?.capturedPostHogEvents).toEqual([
                 {
                     distinct_id: 'distinct_id',
@@ -578,7 +542,7 @@ describe('Hog Executor', () => {
                     },
                 },
             } as any)
-            const result = executor.executeFunction(globals, fn)
+            const result = executor.execute(createInvocation(fn, globals))
             expect(result?.capturedPostHogEvents).toEqual([])
             expect(result?.logs[1].message).toMatchInlineSnapshot(
                 `"postHogCapture was called from an event that already executed this function. To prevent infinite loops, the event was not captured."`
diff --git a/plugin-server/tests/cdp/hog-function-manager.test.ts b/plugin-server/tests/cdp/hog-function-manager.test.ts
index ee4b9ded89f4e..1624999c93058 100644
--- a/plugin-server/tests/cdp/hog-function-manager.test.ts
+++ b/plugin-server/tests/cdp/hog-function-manager.test.ts
@@ -1,14 +1,13 @@
 import { HogFunctionManager } from '../../src/cdp/hog-function-manager'
 import { HogFunctionType, IntegrationType } from '../../src/cdp/types'
 import { Hub } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { PostgresUse } from '../../src/utils/db/postgres'
 import { createTeam, resetTestDatabase } from '../helpers/sql'
 import { insertHogFunction, insertIntegration } from './fixtures'
 
 describe('HogFunctionManager', () => {
     let hub: Hub
-    let closeServer: () => Promise<void>
     let manager: HogFunctionManager
 
     let hogFunctions: HogFunctionType[]
@@ -18,7 +17,7 @@ describe('HogFunctionManager', () => {
     let teamId2: number
 
     beforeEach(async () => {
-        ;[hub, closeServer] = await createHub()
+        hub = await createHub()
         await resetTestDatabase()
         manager = new HogFunctionManager(hub.postgres, hub)
 
@@ -82,7 +81,7 @@ describe('HogFunctionManager', () => {
     })
 
     afterEach(async () => {
-        await closeServer()
+        await closeHub(hub)
     })
 
     it('returns the hog functions', async () => {
@@ -94,7 +93,7 @@ describe('HogFunctionManager', () => {
                 team_id: teamId1,
                 name: 'Test Hog Function team 1',
                 enabled: true,
-                bytecode: null,
+                bytecode: {},
                 filters: null,
                 inputs_schema: [
                     {
diff --git a/plugin-server/tests/cdp/hog-masker.test.ts b/plugin-server/tests/cdp/hog-masker.test.ts
index 9a342572ea403..df05043290e63 100644
--- a/plugin-server/tests/cdp/hog-masker.test.ts
+++ b/plugin-server/tests/cdp/hog-masker.test.ts
@@ -7,10 +7,10 @@ import { BASE_REDIS_KEY, HogMasker } from '../../src/cdp/hog-masker'
 import { CdpRedis, createCdpRedisPool } from '../../src/cdp/redis'
 import { HogFunctionType } from '../../src/cdp/types'
 import { Hub } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { delay } from '../../src/utils/utils'
 import { HOG_MASK_EXAMPLES } from './examples'
-import { createHogExecutionGlobals, createHogFunction } from './fixtures'
+import { createHogExecutionGlobals, createHogFunction, createInvocation } from './fixtures'
 import { deleteKeysWithPrefix } from './helpers/redis'
 
 const mockNow: jest.Mock = require('../../src/utils/now').now as any
@@ -19,13 +19,11 @@ describe('HogMasker', () => {
     describe('integration', () => {
         let now: number
         let hub: Hub
-        let closeHub: () => Promise<void>
         let masker: HogMasker
         let redis: CdpRedis
 
         beforeEach(async () => {
-            ;[hub, closeHub] = await createHub()
-
+            hub = await createHub()
             now = 1720000000000
             mockNow.mockReturnValue(now)
 
@@ -46,13 +44,13 @@ describe('HogMasker', () => {
         }
 
         afterEach(async () => {
-            await closeHub()
+            await closeHub(hub)
             jest.clearAllMocks()
         })
 
         it('should return all functions without masks', async () => {
             const normalFunction = createHogFunction({})
-            const invocations = [{ globals: createHogExecutionGlobals(), hogFunction: normalFunction }]
+            const invocations = [createInvocation(normalFunction)]
             const res = await masker.filterByMasking(invocations)
 
             expect(res.notMasked).toHaveLength(1)
@@ -63,21 +61,27 @@ describe('HogMasker', () => {
             const functionWithAllMasking = createHogFunction({
                 ...HOG_MASK_EXAMPLES.all,
             })
-            const globals1 = createHogExecutionGlobals({ event: { uuid: '1' } as any })
-            const globals2 = createHogExecutionGlobals({ event: { uuid: '2' } as any })
-            const globals3 = createHogExecutionGlobals({ event: { uuid: '3' } as any })
-            const invocations = [
-                { globals: globals1, hogFunction: functionWithAllMasking },
-                { globals: globals2, hogFunction: functionWithAllMasking },
-                { globals: globals3, hogFunction: functionWithAllMasking },
-            ]
+
+            const invocation1 = createInvocation(
+                functionWithAllMasking,
+                createHogExecutionGlobals({ event: { uuid: '1' } as any })
+            )
+            const invocation2 = createInvocation(
+                functionWithAllMasking,
+                createHogExecutionGlobals({ event: { uuid: '2' } as any })
+            )
+            const invocation3 = createInvocation(
+                functionWithAllMasking,
+                createHogExecutionGlobals({ event: { uuid: '3' } as any })
+            )
+            const invocations = [invocation1, invocation2, invocation3]
 
             const res = await masker.filterByMasking(invocations)
             expect(res.notMasked).toHaveLength(1)
             expect(res.masked).toHaveLength(2)
-            expect(res.notMasked[0].globals).toEqual(globals1)
-            expect(res.masked[0].globals).toEqual(globals2)
-            expect(res.masked[1].globals).toEqual(globals3)
+            expect(res.notMasked[0].globals).toEqual(invocation1.globals)
+            expect(res.masked[0].globals).toEqual(invocation2.globals)
+            expect(res.masked[1].globals).toEqual(invocation3.globals)
 
             const res2 = await masker.filterByMasking(invocations)
             expect(res2.notMasked).toHaveLength(0)
@@ -94,9 +98,9 @@ describe('HogMasker', () => {
             const functionWithNoMasking = createHogFunction({})
             const globals = createHogExecutionGlobals()
             const invocations = [
-                { globals, hogFunction: functionWithAllMasking },
-                { globals, hogFunction: functionWithAllMasking2 },
-                { globals, hogFunction: functionWithNoMasking },
+                createInvocation(functionWithAllMasking, globals),
+                createInvocation(functionWithAllMasking2, globals),
+                createInvocation(functionWithNoMasking, globals),
             ]
 
             const res = await masker.filterByMasking(invocations)
@@ -131,7 +135,7 @@ describe('HogMasker', () => {
                 })
             })
             it('should re-allow after the ttl expires', async () => {
-                const invocations = [{ globals: createHogExecutionGlobals(), hogFunction: hogFunctionAll }]
+                const invocations = [createInvocation(hogFunctionAll)]
                 expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(1)
                 expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
                 expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
@@ -145,10 +149,10 @@ describe('HogMasker', () => {
                 const globalsPerson2 = createHogExecutionGlobals({ person: { uuid: '2' } as any })
 
                 const invocations = [
-                    { globals: globalsPerson1, hogFunction: hogFunctionPerson },
-                    { globals: globalsPerson1, hogFunction: hogFunctionAll },
-                    { globals: globalsPerson2, hogFunction: hogFunctionPerson },
-                    { globals: globalsPerson2, hogFunction: hogFunctionAll },
+                    createInvocation(hogFunctionPerson, globalsPerson1),
+                    createInvocation(hogFunctionAll, globalsPerson1),
+                    createInvocation(hogFunctionPerson, globalsPerson2),
+                    createInvocation(hogFunctionAll, globalsPerson2),
                 ]
                 const res = await masker.filterByMasking(invocations)
                 expect(res.masked.length).toEqual(1)
@@ -161,24 +165,24 @@ describe('HogMasker', () => {
             it('should mask until threshold passed', async () => {
                 hogFunctionAll.masking!.threshold = 5
 
-                const invocations = [{ globals: createHogExecutionGlobals(), hogFunction: hogFunctionAll }]
+                const invocation = createInvocation(hogFunctionAll)
                 // First one goes through
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(1)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(1)
 
                 // Next 4 should be masked
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(0)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(0)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(0)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(0)
                 // Now we have hit the threshold so it should not be masked
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(1)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(1)
                 // Next 4 should be masked
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(0)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(0)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(0)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(0)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(0)
                 // Again the Nth one shouldn't be masked
-                expect((await masker.filterByMasking(invocations)).notMasked).toHaveLength(1)
+                expect((await masker.filterByMasking([invocation])).notMasked).toHaveLength(1)
             })
 
             it('should mask threshold based in a batch', async () => {
@@ -187,21 +191,11 @@ describe('HogMasker', () => {
 
                 // If we have 10 invocations in a batch then we should have 2 invocations that are not masked
                 expect(
-                    (
-                        await masker.filterByMasking(
-                            Array(10).fill({ globals: createHogExecutionGlobals(), hogFunction: hogFunctionAll })
-                        )
-                    ).notMasked
+                    (await masker.filterByMasking(Array(10).fill(createInvocation(hogFunctionAll)))).notMasked
                 ).toHaveLength(2)
 
                 // Next one should cross the threshold
-                expect(
-                    (
-                        await masker.filterByMasking([
-                            { globals: createHogExecutionGlobals(), hogFunction: hogFunctionAll },
-                        ])
-                    ).notMasked
-                ).toHaveLength(1)
+                expect((await masker.filterByMasking([createInvocation(hogFunctionAll)])).notMasked).toHaveLength(1)
             })
         })
     })
diff --git a/plugin-server/tests/cdp/hog-watcher.test.ts b/plugin-server/tests/cdp/hog-watcher.test.ts
index ed5fdd1646717..4cbc48cec65b8 100644
--- a/plugin-server/tests/cdp/hog-watcher.test.ts
+++ b/plugin-server/tests/cdp/hog-watcher.test.ts
@@ -7,8 +7,9 @@ import { BASE_REDIS_KEY, HogWatcher, HogWatcherState } from '../../src/cdp/hog-w
 import { CdpRedis, createCdpRedisPool } from '../../src/cdp/redis'
 import { HogFunctionInvocationResult } from '../../src/cdp/types'
 import { Hub } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { delay } from '../../src/utils/utils'
+import { createInvocation } from './fixtures'
 import { deleteKeysWithPrefix } from './helpers/redis'
 
 const mockNow: jest.Mock = require('../../src/utils/now').now as any
@@ -21,10 +22,9 @@ const createResult = (options: {
 }): HogFunctionInvocationResult => {
     return {
         invocation: {
+            ...createInvocation({ id: options.id }),
             id: 'invocation-id',
             teamId: 2,
-            hogFunctionId: options.id,
-            globals: {} as any,
             timings: [
                 {
                     kind: 'async_function',
@@ -42,13 +42,12 @@ describe('HogWatcher', () => {
     describe('integration', () => {
         let now: number
         let hub: Hub
-        let closeHub: () => Promise<void>
         let watcher: HogWatcher
         let mockStateChangeCallback: jest.Mock
         let redis: CdpRedis
 
         beforeEach(async () => {
-            ;[hub, closeHub] = await createHub()
+            hub = await createHub()
 
             now = 1720000000000
             mockNow.mockReturnValue(now)
@@ -72,7 +71,7 @@ describe('HogWatcher', () => {
 
         afterEach(async () => {
             jest.useRealTimers()
-            await closeHub()
+            await closeHub(hub)
             jest.clearAllMocks()
         })
 
diff --git a/plugin-server/tests/cdp/utils.test.ts b/plugin-server/tests/cdp/utils.test.ts
index 9e1cf795e36b5..6640662b2e79e 100644
--- a/plugin-server/tests/cdp/utils.test.ts
+++ b/plugin-server/tests/cdp/utils.test.ts
@@ -2,7 +2,7 @@ import { DateTime } from 'luxon'
 
 import { HogFunctionInvocationResult } from '../../src/cdp/types'
 import { gzipObject, prepareLogEntriesForClickhouse, unGzipObject } from '../../src/cdp/utils'
-import { insertHogFunction as _insertHogFunction } from './fixtures'
+import { createHogFunction, createInvocation, insertHogFunction as _insertHogFunction } from './fixtures'
 
 describe('Utils', () => {
     describe('gzip compressions', () => {
@@ -19,12 +19,8 @@ describe('Utils', () => {
         const startTime = DateTime.fromMillis(1620000000000)
         const example: HogFunctionInvocationResult = {
             invocation: {
+                ...createInvocation(createHogFunction({ id: 'hog-1' })),
                 id: 'inv-1',
-                globals: {} as any,
-                teamId: 1,
-                hogFunctionId: 'hog-1',
-                vmState: undefined,
-                timings: [],
             },
             finished: false,
             logs: [
diff --git a/plugin-server/tests/http-server.test.ts b/plugin-server/tests/http-server.test.ts
index 3900168cd2039..de28222ea116c 100644
--- a/plugin-server/tests/http-server.test.ts
+++ b/plugin-server/tests/http-server.test.ts
@@ -75,7 +75,6 @@ describe('http server', () => {
                 })
             )
 
-            expect(pluginsServer.queue?.consumerReady).toBeTruthy()
             await pluginsServer.stop()
         })
     })
diff --git a/plugin-server/tests/main/capabilities.test.ts b/plugin-server/tests/main/capabilities.test.ts
index 37dca3160e01f..1d249f5b3387b 100644
--- a/plugin-server/tests/main/capabilities.test.ts
+++ b/plugin-server/tests/main/capabilities.test.ts
@@ -2,7 +2,7 @@ import { GraphileWorker } from '../../src/main/graphile-worker/graphile-worker'
 import { startGraphileWorker } from '../../src/main/graphile-worker/worker-setup'
 import { Hub, LogLevel } from '../../src/types'
 import { PluginServerMode, stringToPluginServerMode } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import Piscina from '../../src/worker/piscina'
 
 jest.mock('../../src/main/ingestion-queues/kafka-queue')
@@ -21,17 +21,16 @@ describe('stringToPluginServerMode', () => {
 describe('capabilities', () => {
     let hub: Hub
     let piscina: Piscina
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub({
+        hub = await createHub({
             LOG_LEVEL: LogLevel.Warn,
         })
         piscina = { run: jest.fn(), on: jest.fn() } as any
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     describe('startGraphileWorker()', () => {
diff --git a/plugin-server/tests/main/db.test.ts b/plugin-server/tests/main/db.test.ts
index 364f014654ede..ff6aef1c5d855 100644
--- a/plugin-server/tests/main/db.test.ts
+++ b/plugin-server/tests/main/db.test.ts
@@ -5,7 +5,7 @@ import { defaultConfig } from '../../src/config/config'
 import { Hub, Person, PropertyOperator, PropertyUpdateOperation, RawAction, Team } from '../../src/types'
 import { DB } from '../../src/utils/db/db'
 import { DependencyUnavailableError } from '../../src/utils/db/error'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { PostgresRouter, PostgresUse } from '../../src/utils/db/postgres'
 import { generateKafkaPersonUpdateMessage } from '../../src/utils/db/utils'
 import { RaceConditionError, UUIDT } from '../../src/utils/utils'
@@ -17,11 +17,10 @@ jest.mock('../../src/utils/status')
 
 describe('DB', () => {
     let hub: Hub
-    let closeServer: () => Promise<void>
     let db: DB
 
     beforeEach(async () => {
-        ;[hub, closeServer] = await createHub()
+        hub = await createHub()
         await resetTestDatabase(undefined, {}, {}, { withExtendedTestData: false })
         db = hub.db
 
@@ -31,7 +30,7 @@ describe('DB', () => {
     })
 
     afterEach(async () => {
-        await closeServer()
+        await closeHub(hub)
         jest.clearAllMocks()
     })
 
diff --git a/plugin-server/tests/main/ingestion-queues/analytics-events-ingestion-consumer.test.ts b/plugin-server/tests/main/ingestion-queues/analytics-events-ingestion-consumer.test.ts
index 0aac89c33b289..ef43415544733 100644
--- a/plugin-server/tests/main/ingestion-queues/analytics-events-ingestion-consumer.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/analytics-events-ingestion-consumer.test.ts
@@ -8,7 +8,7 @@ import {
     IngestionOverflowMode,
 } from '../../../src/main/ingestion-queues/batch-processing/each-batch-ingestion'
 import { Hub } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { ConfiguredLimiter } from '../../../src/utils/token-bucket'
 import { captureIngestionWarning } from './../../../src/worker/ingestion/utils'
 
@@ -53,7 +53,6 @@ const captureEndpointEvent2 = {
 
 describe('eachBatchParallelIngestion with overflow reroute', () => {
     let hub: Hub
-    let closeServer: () => Promise<void>
     let queue: any
 
     function createBatchWithMultipleEvents(events: any[], timestamp?: any, withKey = true): Message[] {
@@ -69,7 +68,7 @@ describe('eachBatchParallelIngestion with overflow reroute', () => {
     }
 
     beforeEach(async () => {
-        ;[hub, closeServer] = await createHub()
+        hub = await createHub()
         queue = {
             bufferSleep: jest.fn(),
             pluginsServer: hub,
@@ -78,7 +77,7 @@ describe('eachBatchParallelIngestion with overflow reroute', () => {
     })
 
     afterEach(async () => {
-        await closeServer()
+        await closeHub(hub)
         jest.clearAllMocks()
     })
 
diff --git a/plugin-server/tests/main/ingestion-queues/each-batch-webhooks.test.ts b/plugin-server/tests/main/ingestion-queues/each-batch-webhooks.test.ts
index 63092e94ede3f..ef1dbca1e887c 100644
--- a/plugin-server/tests/main/ingestion-queues/each-batch-webhooks.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/each-batch-webhooks.test.ts
@@ -1,6 +1,6 @@
 import { eachMessageWebhooksHandlers } from '../../../src/main/ingestion-queues/batch-processing/each-batch-webhooks'
 import { ClickHouseTimestamp, ClickHouseTimestampSecondPrecision, Hub, RawClickHouseEvent } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { ActionManager } from '../../../src/worker/ingestion/action-manager'
 import { ActionMatcher } from '../../../src/worker/ingestion/action-matcher'
@@ -33,10 +33,9 @@ const clickhouseEvent: RawClickHouseEvent = {
 
 describe('eachMessageWebhooksHandlers', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         console.warn = jest.fn() as any
         await resetTestDatabase()
 
@@ -73,7 +72,7 @@ describe('eachMessageWebhooksHandlers', () => {
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     it('calls runWebhooksHandlersEventPipeline', async () => {
diff --git a/plugin-server/tests/main/ingestion-queues/each-batch.test.ts b/plugin-server/tests/main/ingestion-queues/each-batch.test.ts
index e693267599197..cb4b33373545c 100644
--- a/plugin-server/tests/main/ingestion-queues/each-batch.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/each-batch.test.ts
@@ -135,7 +135,6 @@ describe('eachBatchX', () => {
                 WORKER_CONCURRENCY: 1,
                 TASKS_PER_WORKER: 10,
                 INGESTION_CONCURRENCY: 4,
-                BUFFER_CONVERSION_SECONDS: 60,
                 kafkaProducer: {
                     queueMessage: jest.fn(),
                 },
diff --git a/plugin-server/tests/main/ingestion-queues/kafka-queue.test.ts b/plugin-server/tests/main/ingestion-queues/kafka-queue.test.ts
index 4f5f50cb7dd12..a9a1f145e8f4f 100644
--- a/plugin-server/tests/main/ingestion-queues/kafka-queue.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/kafka-queue.test.ts
@@ -23,8 +23,6 @@ const extraServerConfig: Partial<PluginsServerConfig> = {
     WORKER_CONCURRENCY: 1,
     KAFKA_CONSUMPTION_TOPIC: KAFKA_EVENTS_PLUGIN_INGESTION,
     LOG_LEVEL: LogLevel.Log,
-    CONVERSION_BUFFER_ENABLED: true,
-    BUFFER_CONVERSION_SECONDS: 1,
 }
 
 // TODO: merge these tests with postgres/e2e.test.ts
diff --git a/plugin-server/tests/main/ingestion-queues/run-async-handlers-event-pipeline.test.ts b/plugin-server/tests/main/ingestion-queues/run-async-handlers-event-pipeline.test.ts
index 064d889ad62dc..f84d05f649f6b 100644
--- a/plugin-server/tests/main/ingestion-queues/run-async-handlers-event-pipeline.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/run-async-handlers-event-pipeline.test.ts
@@ -23,7 +23,7 @@ import { KAFKA_EVENTS_JSON } from '../../../src/config/kafka-topics'
 import { buildOnEventIngestionConsumer } from '../../../src/main/ingestion-queues/on-event-handler-consumer'
 import { Hub, ISOTimestamp } from '../../../src/types'
 import { DependencyUnavailableError } from '../../../src/utils/db/error'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { UUIDT } from '../../../src/utils/utils'
 import { processOnEventStep } from '../../../src/worker/ingestion/event-pipeline/runAsyncHandlersStep'
@@ -51,12 +51,11 @@ describe('runAppsOnEventPipeline()', () => {
 
     let hub: Hub
     let redis: Redis.Redis
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
         // Use fake timers to ensure that we don't need to wait on e.g. retry logic.
         jest.useFakeTimers({ advanceTimers: true })
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         redis = await hub.redisPool.acquire()
         await hub.postgres.query(PostgresUse.COMMON_WRITE, POSTGRES_DELETE_TABLES_QUERY, null, 'deleteTables') // Need to clear the DB to avoid unique constraint violations on ids
     })
@@ -64,7 +63,7 @@ describe('runAppsOnEventPipeline()', () => {
     afterEach(async () => {
         await hub.redisPool.release(redis)
         await teardownPlugins(hub)
-        await closeHub()
+        await closeHub(hub)
         jest.clearAllTimers()
         jest.useRealTimers()
         jest.restoreAllMocks()
@@ -169,16 +168,15 @@ describe('eachBatchAsyncHandlers', () => {
     // to https://github.com/piscinajs/piscina#method-runtask-options should be
     // the case.
     let hub: Hub
-    let closeHub: () => Promise<void>
     let piscina: Piscina
 
     beforeEach(async () => {
         jest.useFakeTimers({ advanceTimers: true })
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
     })
 
     afterEach(async () => {
-        await closeHub?.()
+        await closeHub(hub)
         jest.useRealTimers()
     })
 
diff --git a/plugin-server/tests/main/ingestion-queues/run-ingestion-pipeline.test.ts b/plugin-server/tests/main/ingestion-queues/run-ingestion-pipeline.test.ts
index fa5c000fd9ae1..28d18b2cdd1c3 100644
--- a/plugin-server/tests/main/ingestion-queues/run-ingestion-pipeline.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/run-ingestion-pipeline.test.ts
@@ -3,20 +3,20 @@ import { Pool } from 'pg'
 
 import { Hub } from '../../../src/types'
 import { DependencyUnavailableError } from '../../../src/utils/db/error'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { UUIDT } from '../../../src/utils/utils'
 import { EventPipelineRunner } from '../../../src/worker/ingestion/event-pipeline/runner'
+import { EventsProcessor } from '../../../src/worker/ingestion/process-event'
 import { createOrganization, createTeam, POSTGRES_DELETE_TABLES_QUERY } from '../../helpers/sql'
 
 describe('workerTasks.runEventPipeline()', () => {
     let hub: Hub
     let redis: Redis.Redis
-    let closeHub: () => Promise<void>
     const OLD_ENV = process.env
 
     beforeAll(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         redis = await hub.redisPool.acquire()
         await hub.postgres.query(PostgresUse.COMMON_WRITE, POSTGRES_DELETE_TABLES_QUERY, undefined, '') // Need to clear the DB to avoid unique constraint violations on ids
         process.env = { ...OLD_ENV } // Make a copy
@@ -24,7 +24,7 @@ describe('workerTasks.runEventPipeline()', () => {
 
     afterAll(async () => {
         await hub.redisPool.release(redis)
-        await closeHub()
+        await closeHub(hub)
         process.env = OLD_ENV // Restore old environment
     })
 
@@ -59,9 +59,9 @@ describe('workerTasks.runEventPipeline()', () => {
             now: new Date().toISOString(),
             uuid: new UUIDT().toString(),
         }
-        await expect(new EventPipelineRunner(hub, event).runEventPipeline(event)).rejects.toEqual(
-            new DependencyUnavailableError(errorMessage, 'Postgres', new Error(errorMessage))
-        )
+        await expect(
+            new EventPipelineRunner(hub, event, new EventsProcessor(hub)).runEventPipeline(event)
+        ).rejects.toEqual(new DependencyUnavailableError(errorMessage, 'Postgres', new Error(errorMessage)))
         pgQueryMock.mockRestore()
     })
 })
diff --git a/plugin-server/tests/main/ingestion-queues/session-recording/services/offset-high-water-mark.test.ts b/plugin-server/tests/main/ingestion-queues/session-recording/services/offset-high-water-mark.test.ts
index 6f5493de3ac11..33ac09de4f5e1 100644
--- a/plugin-server/tests/main/ingestion-queues/session-recording/services/offset-high-water-mark.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/session-recording/services/offset-high-water-mark.test.ts
@@ -6,12 +6,11 @@ import {
     OffsetHighWaterMarks,
 } from '../../../../../src/main/ingestion-queues/session-recording/services/offset-high-water-marker'
 import { Hub } from '../../../../../src/types'
-import { createHub } from '../../../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../../../src/utils/db/hub'
 
 describe('session offset high-water mark', () => {
     jest.setTimeout(1000)
     let hub: Hub
-    let closeHub: () => Promise<void>
     const keyPrefix = 'test-high-water-mark'
     let offsetHighWaterMarker: OffsetHighWaterMarker
 
@@ -41,13 +40,13 @@ describe('session offset high-water mark', () => {
     }
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         offsetHighWaterMarker = new OffsetHighWaterMarker(hub.redisPool, keyPrefix)
     })
 
     afterEach(async () => {
         await deletePrefixedKeys()
-        await closeHub()
+        await closeHub(hub)
     })
 
     const expectMemoryAndRedisToEqual = async (tp: TopicPartition, toEqual: any) => {
diff --git a/plugin-server/tests/main/ingestion-queues/session-recording/services/overflow-manager.test.ts b/plugin-server/tests/main/ingestion-queues/session-recording/services/overflow-manager.test.ts
index 11ca8f48b86c1..63b507a2dff03 100644
--- a/plugin-server/tests/main/ingestion-queues/session-recording/services/overflow-manager.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/session-recording/services/overflow-manager.test.ts
@@ -2,7 +2,7 @@ import { Redis } from 'ioredis'
 
 import { OverflowManager } from '../../../../../src/main/ingestion-queues/session-recording/services/overflow-manager'
 import { Hub } from '../../../../../src/types'
-import { createHub } from '../../../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../../../src/utils/db/hub'
 
 jest.mock('../../../../../src/utils/status')
 jest.mock('../../../../../src/kafka/producer')
@@ -11,12 +11,11 @@ const CAPTURE_OVERFLOW_REDIS_KEY = '@posthog/capture-overflow/replay'
 
 describe('overflow manager', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
     let redis: Redis
     let overflowManager: OverflowManager
 
     beforeAll(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         redis = await hub.redisPool.acquire()
     })
     beforeEach(async () => {
@@ -27,7 +26,7 @@ describe('overflow manager', () => {
     afterAll(async () => {
         await redis.flushdb()
         await hub.redisPool.release(redis)
-        await closeHub?.()
+        await closeHub(hub)
     })
 
     test('it does not trigger if several keys are under threshold', async () => {
diff --git a/plugin-server/tests/main/ingestion-queues/session-recording/session-recordings-consumer.test.ts b/plugin-server/tests/main/ingestion-queues/session-recording/session-recordings-consumer.test.ts
index 8035b11e2aa95..fcb2c5bdf9c56 100644
--- a/plugin-server/tests/main/ingestion-queues/session-recording/session-recordings-consumer.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/session-recording/session-recordings-consumer.test.ts
@@ -8,7 +8,7 @@ import { waitForExpect } from '../../../../functional_tests/expectations'
 import { defaultConfig } from '../../../../src/config/config'
 import { SessionRecordingIngester } from '../../../../src/main/ingestion-queues/session-recording/session-recordings-consumer'
 import { Hub, PluginsServerConfig, Team } from '../../../../src/types'
-import { createHub } from '../../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../../src/utils/db/hub'
 import { deleteKeysWithPrefix } from '../../../helpers/redis'
 import { getFirstTeam, resetTestDatabase } from '../../../helpers/sql'
 import { createIncomingRecordingMessage, createKafkaMessage, createTP } from './fixtures'
@@ -61,7 +61,6 @@ describe.each([[true], [false]])('ingester with consumeOverflow=%p', (consumeOve
     let ingester: SessionRecordingIngester
 
     let hub: Hub
-    let closeHub: () => Promise<void>
     let team: Team
     let teamToken = ''
     let mockOffsets: Record<number, number> = {}
@@ -92,7 +91,7 @@ describe.each([[true], [false]])('ingester with consumeOverflow=%p', (consumeOve
                 topics: [{ name: options.topic, partitions: [{ id: 0 }, { id: 1 }, { id: 2 }] }],
             })
         })
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         team = await getFirstTeam(hub)
         teamToken = team.api_token
         redisConn = await hub.redisPool.acquire(0)
@@ -110,7 +109,7 @@ describe.each([[true], [false]])('ingester with consumeOverflow=%p', (consumeOve
         await redisConn.del(CAPTURE_OVERFLOW_REDIS_KEY)
         await hub.redisPool.release(redisConn)
         await deleteKeys(hub)
-        await closeHub()
+        await closeHub(hub)
     })
 
     afterAll(() => {
diff --git a/plugin-server/tests/main/process-event.test.ts b/plugin-server/tests/main/process-event.test.ts
index e1c582becda7c..9c052ee5acebe 100644
--- a/plugin-server/tests/main/process-event.test.ts
+++ b/plugin-server/tests/main/process-event.test.ts
@@ -21,7 +21,7 @@ import {
     PropertyDefinitionTypeEnum,
     Team,
 } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { PostgresUse } from '../../src/utils/db/postgres'
 import { personInitialAndUTMProperties } from '../../src/utils/db/utils'
 import { posthog } from '../../src/utils/posthog'
@@ -54,8 +54,6 @@ export async function createPerson(
     )
 }
 
-export type ReturnWithHub = { hub?: Hub; closeHub?: () => Promise<void> }
-
 type EventsByPerson = [string[], string[]]
 
 export const getEventsByPerson = async (hub: Hub): Promise<EventsByPerson[]> => {
@@ -90,22 +88,10 @@ let processEventCounter = 0
 let mockClientEventCounter = 0
 let team: Team
 let hub: Hub
-let closeHub: () => Promise<void>
 let redis: IORedis.Redis
 let eventsProcessor: EventsProcessor
 let now = DateTime.utc()
 
-async function createTestHub(additionalProps?: Record<string, any>): Promise<[Hub, () => Promise<void>]> {
-    const [hub, closeHub] = await createHub({
-        ...TEST_CONFIG,
-        ...(additionalProps ?? {}),
-    })
-
-    redis = await hub.redisPool.acquire()
-
-    return [hub, closeHub]
-}
-
 async function processEvent(
     distinctId: string,
     ip: string | null,
@@ -126,7 +112,7 @@ async function processEvent(
         ...data,
     } as any as PluginEvent
 
-    const runner = new EventPipelineRunner(hub, pluginEvent)
+    const runner = new EventPipelineRunner(hub, pluginEvent, new EventsProcessor(hub))
     await runner.runEventPipeline(pluginEvent)
 
     await delayUntilEventIngested(() => hub.db.fetchEvents(), ++processEventCounter)
@@ -151,7 +137,10 @@ beforeEach(async () => {
         `
     await resetTestDatabase(testCode, TEST_CONFIG)
     await resetTestDatabaseClickhouse(TEST_CONFIG)
-    ;[hub, closeHub] = await createTestHub()
+
+    hub = await createHub({ ...TEST_CONFIG })
+    redis = await hub.redisPool.acquire()
+
     eventsProcessor = new EventsProcessor(hub)
     processEventCounter = 0
     mockClientEventCounter = 0
@@ -168,7 +157,7 @@ beforeEach(async () => {
 
 afterEach(async () => {
     await hub.redisPool.release(redis)
-    await closeHub?.()
+    await closeHub(hub)
 })
 
 const capture = async (hub: Hub, eventName: string, properties: any = {}) => {
@@ -183,7 +172,7 @@ const capture = async (hub: Hub, eventName: string, properties: any = {}) => {
         team_id: team.id,
         uuid: new UUIDT().toString(),
     }
-    const runner = new EventPipelineRunner(hub, event)
+    const runner = new EventPipelineRunner(hub, event, new EventsProcessor(hub))
     await runner.runEventPipeline(event)
     await delayUntilEventIngested(() => hub.db.fetchEvents(), ++mockClientEventCounter)
 }
@@ -2074,7 +2063,7 @@ describe('validates eventUuid', () => {
             properties: { price: 299.99, name: 'AirPods Pro' },
         }
 
-        const runner = new EventPipelineRunner(hub, pluginEvent)
+        const runner = new EventPipelineRunner(hub, pluginEvent, new EventsProcessor(hub))
         const result = await runner.runEventPipeline(pluginEvent)
 
         expect(result.error).toBeDefined()
@@ -2093,7 +2082,7 @@ describe('validates eventUuid', () => {
             properties: { price: 299.99, name: 'AirPods Pro' },
         }
 
-        const runner = new EventPipelineRunner(hub, pluginEvent)
+        const runner = new EventPipelineRunner(hub, pluginEvent, new EventsProcessor(hub))
         const result = await runner.runEventPipeline(pluginEvent)
 
         expect(result.error).toBeDefined()
diff --git a/plugin-server/tests/main/teardown.test.ts b/plugin-server/tests/main/teardown.test.ts
index 58137f82bf24f..0440102b83efe 100644
--- a/plugin-server/tests/main/teardown.test.ts
+++ b/plugin-server/tests/main/teardown.test.ts
@@ -5,6 +5,7 @@ import { waitForExpect } from '../../functional_tests/expectations'
 import { startPluginsServer } from '../../src/main/pluginsServer'
 import { Hub, LogLevel, PluginLogEntry, PluginLogEntrySource, PluginLogEntryType } from '../../src/types'
 import { EventPipelineRunner } from '../../src/worker/ingestion/event-pipeline/runner'
+import { EventsProcessor } from '../../src/worker/ingestion/process-event'
 import { makePiscina } from '../../src/worker/piscina'
 import { pluginConfig39 } from '../helpers/plugins'
 import { resetTestDatabase } from '../helpers/sql'
@@ -36,7 +37,7 @@ async function getLogEntriesForPluginConfig(hub: Hub, pluginConfigId: number) {
 
 describe('teardown', () => {
     const processEvent = async (hub: Hub, event: PluginEvent) => {
-        const result = await new EventPipelineRunner(hub, event).runEventPipeline(event)
+        const result = await new EventPipelineRunner(hub, event, new EventsProcessor(hub)).runEventPipeline(event)
         const resultEvent = result.args[0]
         return resultEvent
     }
diff --git a/plugin-server/tests/server.test.ts b/plugin-server/tests/server.test.ts
index 009416547b36d..3b8f7d58dda29 100644
--- a/plugin-server/tests/server.test.ts
+++ b/plugin-server/tests/server.test.ts
@@ -96,7 +96,6 @@ describe('server', () => {
                 processAsyncWebhooksHandlers: true,
                 cdpProcessedEvents: true,
                 cdpFunctionCallbacks: true,
-                cdpFunctionOverflow: true,
                 cdpCyclotronWorker: true,
                 syncInlinePlugins: true,
             }
diff --git a/plugin-server/tests/sql.test.ts b/plugin-server/tests/sql.test.ts
index d23b133b4c5bf..2003a61df3630 100644
--- a/plugin-server/tests/sql.test.ts
+++ b/plugin-server/tests/sql.test.ts
@@ -1,5 +1,5 @@
 import { Hub } from '../src/types'
-import { createHub } from '../src/utils/db/hub'
+import { closeHub, createHub } from '../src/utils/db/hub'
 import { PostgresUse } from '../src/utils/db/postgres'
 import { disablePlugin, getActivePluginRows, getPluginAttachmentRows, getPluginConfigRows } from '../src/utils/db/sql'
 import { commonOrganizationId } from './helpers/plugins'
@@ -10,15 +10,14 @@ jest.mock('../src/utils/status')
 
 describe('sql', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         await resetTestDatabase(`const processEvent = event => event`)
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     test('getPluginAttachmentRows', async () => {
diff --git a/plugin-server/tests/utils/db/activity-log.test.ts b/plugin-server/tests/utils/db/activity-log.test.ts
index 896b4d40634cf..d8b9c7ec1fc32 100644
--- a/plugin-server/tests/utils/db/activity-log.test.ts
+++ b/plugin-server/tests/utils/db/activity-log.test.ts
@@ -1,6 +1,6 @@
 import { Hub } from '../../../src/types'
 import { createPluginActivityLog } from '../../../src/utils/db/activity-log'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { pluginConfig39 } from '../../helpers/plugins'
 import { resetTestDatabase } from '../../helpers/sql'
@@ -22,15 +22,14 @@ interface ActivityLog {
 
 describe('createPluginActivityLog()', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
         await resetTestDatabase()
-        ;[hub, closeHub] = await createHub({})
+        hub = await createHub({})
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     async function fetchPluginActivityLogs(hub: Hub): Promise<Array<ActivityLog>> {
diff --git a/plugin-server/tests/worker/capabilities.test.ts b/plugin-server/tests/worker/capabilities.test.ts
index 8376f49de584b..28ce683719246 100644
--- a/plugin-server/tests/worker/capabilities.test.ts
+++ b/plugin-server/tests/worker/capabilities.test.ts
@@ -1,5 +1,5 @@
 import { Hub, LogLevel, PluginCapabilities } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { loadSchedule } from '../../src/worker/plugins/loadSchedule'
 import { setupPlugins } from '../../src/worker/plugins/setup'
 import { getVMPluginCapabilities, shouldSetupPluginInServer } from '../../src/worker/vm/capabilities'
@@ -13,16 +13,15 @@ jest.mock('../../src/worker/plugins/loadPluginsFromDB', () => ({
 
 describe('capabilities', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeAll(async () => {
         console.info = jest.fn() as any
         console.warn = jest.fn() as any
-        ;[hub, closeHub] = await createHub({ LOG_LEVEL: LogLevel.Warn })
+        hub = await createHub({ LOG_LEVEL: LogLevel.Warn })
     })
 
     afterAll(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     describe('getVMPluginCapabilities()', () => {
diff --git a/plugin-server/tests/worker/console.test.ts b/plugin-server/tests/worker/console.test.ts
index 4535f10f6e327..0237eaf682b2a 100644
--- a/plugin-server/tests/worker/console.test.ts
+++ b/plugin-server/tests/worker/console.test.ts
@@ -2,7 +2,7 @@ import { ConsoleExtension } from '@posthog/plugin-scaffold'
 
 import { KAFKA_PLUGIN_LOG_ENTRIES } from '../../src/config/kafka-topics'
 import { Hub, PluginLogEntrySource, PluginLogEntryType } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { createConsole } from '../../src/worker/vm/extensions/console'
 import { pluginConfig39 } from '../../tests/helpers/plugins'
 
@@ -12,14 +12,13 @@ jest.mock('../../src/utils/db/kafka-producer-wrapper')
 
 describe('console extension', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeAll(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
     })
 
     afterAll(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     Object.values(PluginLogEntryType).map((type) => {
diff --git a/plugin-server/tests/worker/dead-letter-queue.test.ts b/plugin-server/tests/worker/dead-letter-queue.test.ts
index a9ef21a6fdd2c..b9c79471fb42a 100644
--- a/plugin-server/tests/worker/dead-letter-queue.test.ts
+++ b/plugin-server/tests/worker/dead-letter-queue.test.ts
@@ -1,9 +1,10 @@
 import { PluginEvent } from '@posthog/plugin-scaffold/src/types'
 
 import { Hub, LogLevel } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { UUIDT } from '../../src/utils/utils'
 import { EventPipelineRunner } from '../../src/worker/ingestion/event-pipeline/runner'
+import { EventsProcessor } from '../../src/worker/ingestion/process-event'
 import { generateEventDeadLetterQueueMessage } from '../../src/worker/ingestion/utils'
 import { delayUntilEventIngested, resetTestDatabaseClickhouse } from '../helpers/clickhouse'
 import { resetTestDatabase } from '../helpers/sql'
@@ -45,22 +46,23 @@ function createEvent(): PluginEvent {
 
 describe('events dead letter queue', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub({ LOG_LEVEL: LogLevel.Log })
+        hub = await createHub({ LOG_LEVEL: LogLevel.Log })
         console.warn = jest.fn() as any
         await resetTestDatabase()
         await resetTestDatabaseClickhouse()
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     test('events get sent to dead letter queue on error', async () => {
         const event = createEvent()
-        const ingestResponse1 = await new EventPipelineRunner(hub, event).runEventPipeline(event)
+        const ingestResponse1 = await new EventPipelineRunner(hub, event, new EventsProcessor(hub)).runEventPipeline(
+            event
+        )
         expect(ingestResponse1).toEqual({
             lastStep: 'prepareEventStep',
             error: 'database unavailable',
diff --git a/plugin-server/tests/worker/ingestion/action-manager.test.ts b/plugin-server/tests/worker/ingestion/action-manager.test.ts
index d9ad3893be6f1..e3c1e65f392ec 100644
--- a/plugin-server/tests/worker/ingestion/action-manager.test.ts
+++ b/plugin-server/tests/worker/ingestion/action-manager.test.ts
@@ -1,23 +1,22 @@
 import { Hub, PropertyOperator } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { ActionManager } from '../../../src/worker/ingestion/action-manager'
 import { resetTestDatabase } from '../../helpers/sql'
 
 describe('ActionManager', () => {
     let hub: Hub
-    let closeServer: () => Promise<void>
     let actionManager: ActionManager
 
     beforeEach(async () => {
-        ;[hub, closeServer] = await createHub()
+        hub = await createHub()
         await resetTestDatabase()
         actionManager = new ActionManager(hub.postgres, hub)
         await actionManager.start()
     })
 
     afterEach(async () => {
-        await closeServer()
+        await closeHub(hub)
     })
 
     const TEAM_ID = 2
diff --git a/plugin-server/tests/worker/ingestion/action-matcher.test.ts b/plugin-server/tests/worker/ingestion/action-matcher.test.ts
index 6b84b80991b10..718ca3bde3983 100644
--- a/plugin-server/tests/worker/ingestion/action-matcher.test.ts
+++ b/plugin-server/tests/worker/ingestion/action-matcher.test.ts
@@ -14,7 +14,7 @@ import {
     StringMatching,
     Team,
 } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { UUIDT } from '../../../src/utils/utils'
 import { ActionManager } from '../../../src/worker/ingestion/action-manager'
 import { ActionMatcher, castingCompare } from '../../../src/worker/ingestion/action-matcher'
@@ -44,14 +44,13 @@ function createTestEvent(overrides: Partial<PostIngestionEvent> = {}): PostInges
 
 describe('ActionMatcher', () => {
     let hub: Hub
-    let closeServer: () => Promise<void>
     let actionManager: ActionManager
     let actionMatcher: ActionMatcher
     let actionCounter: number
 
     beforeEach(async () => {
         await resetTestDatabase(undefined, undefined, undefined, { withExtendedTestData: false })
-        ;[hub, closeServer] = await createHub()
+        hub = await createHub()
         actionManager = new ActionManager(hub.db.postgres, hub)
         await actionManager.start()
         actionMatcher = new ActionMatcher(hub.db.postgres, actionManager, hub.teamManager)
@@ -59,7 +58,7 @@ describe('ActionMatcher', () => {
     })
 
     afterEach(async () => {
-        await closeServer()
+        await closeHub(hub)
     })
 
     /** Return a test action created on a common base using provided steps. */
diff --git a/plugin-server/tests/worker/ingestion/app-metrics.test.ts b/plugin-server/tests/worker/ingestion/app-metrics.test.ts
index dda7d6dc30e97..bf2642d24b1aa 100644
--- a/plugin-server/tests/worker/ingestion/app-metrics.test.ts
+++ b/plugin-server/tests/worker/ingestion/app-metrics.test.ts
@@ -1,5 +1,5 @@
 import { Hub } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { KafkaProducerWrapper } from '../../../src/utils/db/kafka-producer-wrapper'
 import { UUIDT } from '../../../src/utils/utils'
 import { AppMetricIdentifier, AppMetrics } from '../../../src/worker/ingestion/app-metrics'
@@ -275,10 +275,9 @@ describe('AppMetrics()', () => {
 
     describe('reading writes from clickhouse', () => {
         let hub: Hub
-        let closeHub: () => Promise<void>
 
         beforeEach(async () => {
-            ;[hub, closeHub] = await createHub({
+            hub = await createHub({
                 APP_METRICS_FLUSH_FREQUENCY_MS: 100,
                 APP_METRICS_FLUSH_MAX_QUEUE_SIZE: 5,
             })
@@ -286,7 +285,7 @@ describe('AppMetrics()', () => {
             jest.spyOn(hub.kafkaProducer, 'queueMessage').mockReturnValue(Promise.resolve())
         })
         afterEach(async () => {
-            await closeHub()
+            await closeHub(hub)
         })
         async function fetchRowsFromClickhouse() {
             return (await hub.db.clickhouseQuery(`SELECT * FROM app_metrics FINAL`)).data
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/enrichExceptionEventStep.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/enrichExceptionEventStep.test.ts
index e59f42fb71001..c9e4ea17127f7 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/enrichExceptionEventStep.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/enrichExceptionEventStep.test.ts
@@ -37,7 +37,6 @@ describe('enrichExceptionEvent()', () => {
                     produce: jest.fn((e) => Promise.resolve(e)),
                 },
             },
-            nextStep: (...args: any[]) => args,
         }
     })
 
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/event-pipeline-integration.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/event-pipeline-integration.test.ts
index bc4bf1254d2e0..5c1ebcbb49394 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/event-pipeline-integration.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/event-pipeline-integration.test.ts
@@ -3,7 +3,7 @@ import { DateTime } from 'luxon'
 import fetch from 'node-fetch'
 
 import { Hook, Hub } from '../../../../src/types'
-import { createHub } from '../../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../../src/utils/db/hub'
 import { PostgresUse } from '../../../../src/utils/db/postgres'
 import { convertToPostIngestionEvent } from '../../../../src/utils/event'
 import { UUIDT } from '../../../../src/utils/utils'
@@ -15,6 +15,7 @@ import {
 } from '../../../../src/worker/ingestion/event-pipeline/runAsyncHandlersStep'
 import { EventPipelineRunner } from '../../../../src/worker/ingestion/event-pipeline/runner'
 import { HookCommander } from '../../../../src/worker/ingestion/hooks'
+import { EventsProcessor } from '../../../../src/worker/ingestion/process-event'
 import { setupPlugins } from '../../../../src/worker/plugins/setup'
 import { delayUntilEventIngested, resetTestDatabaseClickhouse } from '../../../helpers/clickhouse'
 import { commonUserId } from '../../../helpers/plugins'
@@ -27,10 +28,9 @@ describe('Event Pipeline integration test', () => {
     let actionManager: ActionManager
     let actionMatcher: ActionMatcher
     let hookCannon: HookCommander
-    let closeServer: () => Promise<void>
 
     const ingestEvent = async (event: PluginEvent) => {
-        const runner = new EventPipelineRunner(hub, event)
+        const runner = new EventPipelineRunner(hub, event, new EventsProcessor(hub))
         const result = await runner.runEventPipeline(event)
         const postIngestionEvent = convertToPostIngestionEvent(result.args[0])
         return Promise.all([
@@ -43,7 +43,7 @@ describe('Event Pipeline integration test', () => {
         await resetTestDatabase()
         await resetTestDatabaseClickhouse()
         process.env.SITE_URL = 'https://example.com'
-        ;[hub, closeServer] = await createHub()
+        hub = await createHub()
 
         actionManager = new ActionManager(hub.db.postgres, hub)
         await actionManager.start()
@@ -62,7 +62,7 @@ describe('Event Pipeline integration test', () => {
     })
 
     afterEach(async () => {
-        await closeServer()
+        await closeHub(hub)
     })
 
     it('handles plugins setting properties', async () => {
@@ -255,13 +255,13 @@ describe('Event Pipeline integration test', () => {
             uuid: new UUIDT().toString(),
         }
 
-        await new EventPipelineRunner(hub, event).runEventPipeline(event)
+        await new EventPipelineRunner(hub, event, new EventsProcessor(hub)).runEventPipeline(event)
 
         expect(hub.db.fetchPerson).toHaveBeenCalledTimes(1) // we query before creating
         expect(hub.db.createPerson).toHaveBeenCalledTimes(1)
 
         // second time single fetch
-        await new EventPipelineRunner(hub, event).runEventPipeline(event)
+        await new EventPipelineRunner(hub, event, new EventsProcessor(hub)).runEventPipeline(event)
         expect(hub.db.fetchPerson).toHaveBeenCalledTimes(2)
     })
 })
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/extractHeatmapDataStep.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/extractHeatmapDataStep.test.ts
index c98c085298417..2fe66ad4dfa37 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/extractHeatmapDataStep.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/extractHeatmapDataStep.test.ts
@@ -138,7 +138,6 @@ describe('extractHeatmapDataStep()', () => {
                     fetchTeam: jest.fn(() => Promise.resolve({ heatmaps_opt_in: true })),
                 },
             },
-            nextStep: (...args: any[]) => args,
         }
     })
 
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/normalizeEventStep.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/normalizeEventStep.test.ts
index 3d14f463cbfa5..0ddc692fe004a 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/normalizeEventStep.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/normalizeEventStep.test.ts
@@ -13,7 +13,7 @@ function copy(a: any) {
 describe('normalizeEventStep()', () => {
     it('normalizes the event with properties set by plugins', async () => {
         await resetTestDatabase()
-        const [hub, _] = await createHub()
+        const hub = await createHub()
         const organizationId = await createOrganization(hub.db.postgres)
         const teamId = await createTeam(hub.db.postgres, organizationId)
         const uuid = new UUIDT().toString()
@@ -61,7 +61,7 @@ describe('normalizeEventStep()', () => {
 
     it('replaces null byte with unicode replacement character in distinct_id', async () => {
         await resetTestDatabase()
-        const [hub, _] = await createHub()
+        const hub = await createHub()
         const organizationId = await createOrganization(hub.db.postgres)
         const teamId = await createTeam(hub.db.postgres, organizationId)
         const uuid = new UUIDT().toString()
@@ -90,7 +90,7 @@ describe('normalizeEventStep()', () => {
 
     it('normalizes $process_person_profile=false events by dropping $set and related', async () => {
         await resetTestDatabase()
-        const [hub, _] = await createHub()
+        const hub = await createHub()
         const organizationId = await createOrganization(hub.db.postgres)
         const teamId = await createTeam(hub.db.postgres, organizationId)
         const uuid = new UUIDT().toString()
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/pluginsProcessEventStep.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/pluginsProcessEventStep.test.ts
index eb65cd7aa1e03..457c2529b80b9 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/pluginsProcessEventStep.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/pluginsProcessEventStep.test.ts
@@ -19,19 +19,11 @@ const pluginEvent: PluginEvent = {
 }
 
 describe('pluginsProcessEventStep()', () => {
-    let runner: any
-
-    beforeEach(() => {
-        runner = {
-            nextStep: (...args: any[]) => args,
-        }
-    })
-
     it('forwards processed plugin event to `processPersonsStep`', async () => {
         const processedEvent = { ...pluginEvent, event: 'processed' }
         jest.mocked(runProcessEvent).mockResolvedValue(processedEvent)
 
-        const response = await pluginsProcessEventStep(runner, pluginEvent)
+        const response = await pluginsProcessEventStep({} as any, pluginEvent)
 
         expect(response).toEqual(processedEvent)
     })
@@ -40,7 +32,7 @@ describe('pluginsProcessEventStep()', () => {
         jest.mocked(runProcessEvent).mockResolvedValue(null)
         const droppedEventCounterSpy = jest.spyOn(droppedEventCounter, 'inc')
 
-        const response = await pluginsProcessEventStep(runner, pluginEvent)
+        const response = await pluginsProcessEventStep({} as any, pluginEvent)
 
         expect(response).toEqual(null)
         expect(droppedEventCounterSpy).toHaveBeenCalledTimes(1)
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/populateTeamDataStep.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/populateTeamDataStep.test.ts
index cc43c8fb55763..cb900e56899f6 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/populateTeamDataStep.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/populateTeamDataStep.test.ts
@@ -33,7 +33,6 @@ let runner: any
 beforeEach(() => {
     resetMetrics()
     runner = {
-        nextStep: (...args: any[]) => args,
         hub: {
             teamManager: {
                 getTeamByToken: jest.fn((token) => {
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/prepareEventStep.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/prepareEventStep.test.ts
index d09a149d44c8b..8c203468348aa 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/prepareEventStep.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/prepareEventStep.test.ts
@@ -2,9 +2,11 @@ import { PluginEvent } from '@posthog/plugin-scaffold'
 import { DateTime } from 'luxon'
 
 import { Hub, Person, Team } from '../../../../src/types'
-import { createHub } from '../../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../../src/utils/db/hub'
 import { UUIDT } from '../../../../src/utils/utils'
 import { prepareEventStep } from '../../../../src/worker/ingestion/event-pipeline/prepareEventStep'
+import { EventPipelineRunner } from '../../../../src/worker/ingestion/event-pipeline/runner'
+import { EventsProcessor } from '../../../../src/worker/ingestion/process-event'
 import { resetTestDatabase } from '../../../helpers/sql'
 
 jest.mock('../../../../src/utils/status')
@@ -49,13 +51,12 @@ const teamTwo: Team = {
 }
 
 describe('prepareEventStep()', () => {
-    let runner: any
+    let runner: Pick<EventPipelineRunner, 'hub' | 'eventsProcessor'>
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
         await resetTestDatabase()
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
 
         // :KLUDGE: We test below whether kafka messages are produced, so make sure the person exists beforehand.
         await hub.db.createPerson(person.created_at, {}, {}, {}, pluginEvent.team_id, null, false, person.uuid, [
@@ -64,18 +65,18 @@ describe('prepareEventStep()', () => {
         hub.db.kafkaProducer!.queueMessage = jest.fn()
 
         // eslint-disable-next-line @typescript-eslint/require-await
-        hub.eventsProcessor.teamManager.fetchTeam = jest.fn(async (teamId) => {
+        hub.teamManager.fetchTeam = jest.fn(async (teamId) => {
             return teamId === 2 ? teamTwo : null
         })
 
         runner = {
-            nextStep: (...args: any[]) => args,
             hub,
+            eventsProcessor: new EventsProcessor(hub),
         }
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     it('goes to `createEventStep` for normal events', async () => {
@@ -95,7 +96,7 @@ describe('prepareEventStep()', () => {
     })
 
     it('scrubs IPs when team.anonymize_ips=true', async () => {
-        jest.mocked(runner.hub.eventsProcessor.teamManager.fetchTeam).mockReturnValue({
+        jest.mocked(runner.hub.teamManager.fetchTeam).mockReturnValue({
             ...teamTwo,
             anonymize_ips: true,
         })
@@ -116,7 +117,7 @@ describe('prepareEventStep()', () => {
     it('extracts elements_chain from properties', async () => {
         const event: PluginEvent = { ...pluginEvent, ip: null, properties: { $elements_chain: 'random string', a: 1 } }
         const preppedEvent = await prepareEventStep(runner, event)
-        const [chEvent, _] = await runner.hub.eventsProcessor.createEvent(preppedEvent, person)
+        const [chEvent, _] = runner.eventsProcessor.createEvent(preppedEvent, person)
 
         expect(chEvent.elements_chain).toEqual('random string')
         expect(chEvent.properties).toEqual('{"a":1}')
@@ -133,7 +134,7 @@ describe('prepareEventStep()', () => {
             },
         }
         const preppedEvent = await prepareEventStep(runner, event)
-        const [chEvent, _] = await runner.hub.eventsProcessor.createEvent(preppedEvent, person)
+        const [chEvent, _] = runner.eventsProcessor.createEvent(preppedEvent, person)
 
         expect(chEvent.elements_chain).toEqual('random string')
         expect(chEvent.properties).toEqual('{"a":1}')
@@ -147,7 +148,7 @@ describe('prepareEventStep()', () => {
             properties: { a: 1, $elements: [{ tag_name: 'div', nth_child: 1, nth_of_type: 2, $el_text: 'text' }] },
         }
         const preppedEvent = await prepareEventStep(runner, event)
-        const [chEvent, _] = await runner.hub.eventsProcessor.createEvent(preppedEvent, person)
+        const [chEvent, _] = runner.eventsProcessor.createEvent(preppedEvent, person)
 
         expect(chEvent.elements_chain).toEqual('div:nth-child="1"nth-of-type="2"text="text"')
         expect(chEvent.properties).toEqual('{"a":1}')
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/processPersonsStep.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/processPersonsStep.test.ts
index ea3a592f79ed4..61b0b5f4b8310 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/processPersonsStep.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/processPersonsStep.test.ts
@@ -2,16 +2,17 @@ import { PluginEvent } from '@posthog/plugin-scaffold'
 import { DateTime } from 'luxon'
 
 import { Hub } from '../../../../src/types'
-import { createHub } from '../../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../../src/utils/db/hub'
 import { UUIDT } from '../../../../src/utils/utils'
 import { normalizeEventStep } from '../../../../src/worker/ingestion/event-pipeline/normalizeEventStep'
 import { processPersonsStep } from '../../../../src/worker/ingestion/event-pipeline/processPersonsStep'
+import { EventPipelineRunner } from '../../../../src/worker/ingestion/event-pipeline/runner'
+import { EventsProcessor } from '../../../../src/worker/ingestion/process-event'
 import { createOrganization, createTeam, fetchPostgresPersons, resetTestDatabase } from '../../../helpers/sql'
 
 describe('processPersonsStep()', () => {
-    let runner: any
+    let runner: Pick<EventPipelineRunner, 'hub' | 'eventsProcessor'>
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     let uuid: string
     let teamId: number
@@ -20,10 +21,10 @@ describe('processPersonsStep()', () => {
 
     beforeEach(async () => {
         await resetTestDatabase()
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         runner = {
-            nextStep: (...args: any[]) => args,
             hub: hub,
+            eventsProcessor: new EventsProcessor(hub),
         }
         const organizationId = await createOrganization(runner.hub.db.postgres)
         teamId = await createTeam(runner.hub.db.postgres, organizationId)
@@ -47,7 +48,7 @@ describe('processPersonsStep()', () => {
         timestamp = DateTime.fromISO(pluginEvent.timestamp!)
     })
     afterEach(async () => {
-        await closeHub?.()
+        await closeHub(hub)
     })
 
     it('creates person', async () => {
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/runAsyncHandlersStep.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/runAsyncHandlersStep.test.ts
index 248f4d6fd4d22..759bb5140e9d5 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/runAsyncHandlersStep.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/runAsyncHandlersStep.test.ts
@@ -26,7 +26,6 @@ describe('runAsyncHandlersStep()', () => {
 
     beforeEach(() => {
         runner = {
-            nextStep: (...args: any[]) => args,
             hub: {
                 capabilities: {
                     processAsyncOnEventHandlers: true,
diff --git a/plugin-server/tests/worker/ingestion/event-pipeline/runner.test.ts b/plugin-server/tests/worker/ingestion/event-pipeline/runner.test.ts
index e70d721828b96..ef9864ccb6b1a 100644
--- a/plugin-server/tests/worker/ingestion/event-pipeline/runner.test.ts
+++ b/plugin-server/tests/worker/ingestion/event-pipeline/runner.test.ts
@@ -11,6 +11,7 @@ import { prepareEventStep } from '../../../../src/worker/ingestion/event-pipelin
 import { processPersonsStep } from '../../../../src/worker/ingestion/event-pipeline/processPersonsStep'
 import { processOnEventStep } from '../../../../src/worker/ingestion/event-pipeline/runAsyncHandlersStep'
 import { EventPipelineRunner } from '../../../../src/worker/ingestion/event-pipeline/runner'
+import { EventsProcessor } from '../../../../src/worker/ingestion/process-event'
 
 jest.mock('../../../../src/worker/ingestion/event-pipeline/populateTeamDataStep')
 jest.mock('../../../../src/worker/ingestion/event-pipeline/pluginsProcessEventStep')
@@ -101,7 +102,7 @@ describe('EventPipelineRunner', () => {
             },
             eventsToDropByToken: createEventsToDropByToken('drop_token:drop_id,drop_token_all:*'),
         }
-        runner = new TestEventPipelineRunner(hub, pluginEvent)
+        runner = new TestEventPipelineRunner(hub, pluginEvent, new EventsProcessor(hub))
 
         jest.mocked(populateTeamDataStep).mockResolvedValue(pluginEvent)
         jest.mocked(pluginsProcessEventStep).mockResolvedValue(pluginEvent)
@@ -271,7 +272,7 @@ describe('EventPipelineRunner', () => {
                         kafkaProducer: { queueMessage: jest.fn() },
                     },
                 }
-                const runner = new TestEventPipelineRunner(hub, event)
+                const runner = new TestEventPipelineRunner(hub, event, new EventsProcessor(hub))
                 jest.mocked(populateTeamDataStep).mockResolvedValue(event)
 
                 await runner.runEventPipeline(event)
@@ -309,7 +310,7 @@ describe('EventPipelineRunner', () => {
 
                 // setup just enough mocks that the right pipeline runs
 
-                runner = new TestEventPipelineRunner(hub, heatmapEvent)
+                runner = new TestEventPipelineRunner(hub, heatmapEvent, new EventsProcessor(hub))
 
                 jest.mocked(populateTeamDataStep).mockResolvedValue(heatmapEvent as any)
 
@@ -352,7 +353,7 @@ describe('EventPipelineRunner $process_person_profile=false', () => {
                     kafkaProducer: { queueMessage: jest.fn() },
                 },
             }
-            const runner = new TestEventPipelineRunner(hub, event)
+            const runner = new TestEventPipelineRunner(hub, event, new EventsProcessor(hub))
             jest.mocked(populateTeamDataStep).mockResolvedValue(event)
 
             await runner.runEventPipeline(event)
diff --git a/plugin-server/tests/worker/ingestion/group-type-manager.test.ts b/plugin-server/tests/worker/ingestion/group-type-manager.test.ts
index 3999d5a78cb93..5ee484a996db3 100644
--- a/plugin-server/tests/worker/ingestion/group-type-manager.test.ts
+++ b/plugin-server/tests/worker/ingestion/group-type-manager.test.ts
@@ -1,5 +1,5 @@
 import { Hub } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { captureTeamEvent } from '../../../src/utils/posthog'
 import { GroupTypeManager } from '../../../src/worker/ingestion/group-type-manager'
 import { resetTestDatabase } from '../../helpers/sql'
@@ -11,11 +11,10 @@ jest.mock('../../../src/utils/posthog', () => ({
 
 describe('GroupTypeManager()', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
     let groupTypeManager: GroupTypeManager
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         await resetTestDatabase()
         groupTypeManager = new GroupTypeManager(hub.postgres, hub.teamManager)
 
@@ -23,7 +22,7 @@ describe('GroupTypeManager()', () => {
         jest.spyOn(groupTypeManager, 'insertGroupType')
     })
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     describe('fetchGroupTypes()', () => {
diff --git a/plugin-server/tests/worker/ingestion/organization-manager.test.ts b/plugin-server/tests/worker/ingestion/organization-manager.test.ts
index 0c734a90b4dc8..214ff486b49f1 100644
--- a/plugin-server/tests/worker/ingestion/organization-manager.test.ts
+++ b/plugin-server/tests/worker/ingestion/organization-manager.test.ts
@@ -1,5 +1,5 @@
 import { Hub } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { UUIDT } from '../../../src/utils/utils'
 import { OrganizationManager } from '../../../src/worker/ingestion/organization-manager'
@@ -10,16 +10,15 @@ jest.mock('../../../src/utils/status')
 
 describe('OrganizationManager()', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
     let organizationManager: OrganizationManager
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         await resetTestDatabase()
         organizationManager = new OrganizationManager(hub.postgres, hub.teamManager)
     })
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     describe('fetchOrganization()', () => {
diff --git a/plugin-server/tests/worker/ingestion/person-state.test.ts b/plugin-server/tests/worker/ingestion/person-state.test.ts
index 7405f6799dab4..fcf548ec0b199 100644
--- a/plugin-server/tests/worker/ingestion/person-state.test.ts
+++ b/plugin-server/tests/worker/ingestion/person-state.test.ts
@@ -3,7 +3,7 @@ import { DateTime } from 'luxon'
 
 import { Database, Hub, InternalPerson } from '../../../src/types'
 import { DependencyUnavailableError } from '../../../src/utils/db/error'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { defaultRetryConfig } from '../../../src/utils/retries'
 import { UUIDT } from '../../../src/utils/utils'
@@ -20,7 +20,6 @@ const timestampch = '2020-01-01 12:00:05.000'
 
 describe('PersonState.update()', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     let teamId: number
     let organizationId: string
@@ -36,7 +35,7 @@ describe('PersonState.update()', () => {
     let secondUserUuid: string
 
     beforeAll(async () => {
-        ;[hub, closeHub] = await createHub({})
+        hub = await createHub({})
         await hub.db.clickhouseQuery('SYSTEM STOP MERGES')
 
         organizationId = await createOrganization(hub.db.postgres)
@@ -62,7 +61,7 @@ describe('PersonState.update()', () => {
     })
 
     afterAll(async () => {
-        await closeHub()
+        await closeHub(hub)
         await hub.db.clickhouseQuery('SYSTEM START MERGES')
     })
 
@@ -1861,17 +1860,16 @@ describe('PersonState.update()', () => {
         // For some reason these tests failed if I ran them with a hub shared
         // with other tests, so I'm creating a new hub for each test.
         let hub: Hub
-        let closeHub: () => Promise<void>
 
         beforeEach(async () => {
-            ;[hub, closeHub] = await createHub({})
+            hub = await createHub({})
 
             jest.spyOn(hub.db, 'fetchPerson')
             jest.spyOn(hub.db, 'updatePersonDeprecated')
         })
 
         afterEach(async () => {
-            await closeHub()
+            await closeHub(hub)
         })
 
         it(`no-op if persons already merged`, async () => {
diff --git a/plugin-server/tests/worker/ingestion/process-event.test.ts b/plugin-server/tests/worker/ingestion/process-event.test.ts
index f54b733f149b2..1187cf5336d29 100644
--- a/plugin-server/tests/worker/ingestion/process-event.test.ts
+++ b/plugin-server/tests/worker/ingestion/process-event.test.ts
@@ -2,7 +2,7 @@ import * as IORedis from 'ioredis'
 import { DateTime } from 'luxon'
 
 import { Hub, ISOTimestamp, Person, PreIngestionEvent } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { UUIDT } from '../../../src/utils/utils'
 import { EventsProcessor } from '../../../src/worker/ingestion/process-event'
 import { delayUntilEventIngested, resetTestDatabaseClickhouse } from '../../helpers/clickhouse'
@@ -13,7 +13,6 @@ jest.mock('../../../src/utils/status')
 jest.setTimeout(600000) // 600 sec timeout.
 
 let hub: Hub
-let closeHub: () => Promise<void>
 let redis: IORedis.Redis
 let eventsProcessor: EventsProcessor
 
@@ -24,7 +23,7 @@ beforeAll(async () => {
 beforeEach(async () => {
     await resetTestDatabase()
     await resetTestDatabaseClickhouse()
-    ;[hub, closeHub] = await createHub()
+    hub = await createHub()
     redis = await hub.redisPool.acquire()
     await redis.flushdb()
 
@@ -33,7 +32,7 @@ beforeEach(async () => {
 
 afterEach(async () => {
     await hub.redisPool.release(redis)
-    await closeHub?.()
+    await closeHub(hub)
 })
 
 describe('EventsProcessor#createEvent()', () => {
diff --git a/plugin-server/tests/worker/ingestion/properties-updater.test.ts b/plugin-server/tests/worker/ingestion/properties-updater.test.ts
index 16cde1c7e84ab..2bbf7aa31a571 100644
--- a/plugin-server/tests/worker/ingestion/properties-updater.test.ts
+++ b/plugin-server/tests/worker/ingestion/properties-updater.test.ts
@@ -3,7 +3,7 @@ import { DateTime } from 'luxon'
 
 import { Group, Hub, Team } from '../../../src/types'
 import { DB } from '../../../src/utils/db/db'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { UUIDT } from '../../../src/utils/utils'
 import { upsertGroup } from '../../../src/worker/ingestion/properties-updater'
 import { createPromise } from '../../helpers/promises'
@@ -13,7 +13,6 @@ jest.mock('../../../src/utils/status')
 
 describe('properties-updater', () => {
     let hub: Hub
-    let closeServer: () => Promise<void>
     let db: DB
 
     let team: Team
@@ -24,7 +23,7 @@ describe('properties-updater', () => {
     const PAST_TIMESTAMP = DateTime.fromISO('2000-10-14T11:42:06.502Z')
 
     beforeEach(async () => {
-        ;[hub, closeServer] = await createHub()
+        hub = await createHub()
         await resetTestDatabase()
         db = hub.db
 
@@ -36,7 +35,7 @@ describe('properties-updater', () => {
     })
 
     afterEach(async () => {
-        await closeServer()
+        await closeHub(hub)
     })
 
     describe('upsertGroup()', () => {
diff --git a/plugin-server/tests/worker/ingestion/property-definitions-cache.test.ts b/plugin-server/tests/worker/ingestion/property-definitions-cache.test.ts
index 92216c9a2ec62..e36c8f0a755bd 100644
--- a/plugin-server/tests/worker/ingestion/property-definitions-cache.test.ts
+++ b/plugin-server/tests/worker/ingestion/property-definitions-cache.test.ts
@@ -1,5 +1,5 @@
 import { Hub, PropertyDefinitionTypeEnum } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { UUIDT } from '../../../src/utils/utils'
 import { PropertyDefinitionsCache } from '../../../src/worker/ingestion/property-definitions-cache'
@@ -15,18 +15,17 @@ jest.mock('../../../src/utils/posthog', () => ({
 
 describe('PropertyDefinitionsManager()', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
     let cache: PropertyDefinitionsCache
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         await resetTestDatabase()
 
         cache = new PropertyDefinitionsCache(hub)
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     describe('with pre-existing data', () => {
diff --git a/plugin-server/tests/worker/ingestion/property-definitions-manager.test.ts b/plugin-server/tests/worker/ingestion/property-definitions-manager.test.ts
index 192ad46342e15..8ec4eaad75859 100644
--- a/plugin-server/tests/worker/ingestion/property-definitions-manager.test.ts
+++ b/plugin-server/tests/worker/ingestion/property-definitions-manager.test.ts
@@ -1,7 +1,7 @@
 import { DateTime, Settings } from 'luxon'
 
 import { DateTimePropertyTypeFormat, Hub, PropertyDefinitionTypeEnum, PropertyType } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import { posthog } from '../../../src/utils/posthog'
 import { UUIDT } from '../../../src/utils/utils'
@@ -21,14 +21,13 @@ jest.mock('../../../src/utils/posthog', () => ({
 
 describe('PropertyDefinitionsManager()', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
     let manager: PropertyDefinitionsManager
     let teamId: number
     let organizationId: string
     let groupTypeManager: GroupTypeManager
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         organizationId = await createOrganization(hub.db.postgres)
         teamId = await createTeam(hub.db.postgres, organizationId)
         groupTypeManager = new GroupTypeManager(hub.postgres, hub.teamManager, hub.SITE_URL)
@@ -38,7 +37,7 @@ describe('PropertyDefinitionsManager()', () => {
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     describe('updateEventNamesAndProperties()', () => {
diff --git a/plugin-server/tests/worker/ingestion/utils.test.ts b/plugin-server/tests/worker/ingestion/utils.test.ts
index f398b01d29be0..8eed11d028ac3 100644
--- a/plugin-server/tests/worker/ingestion/utils.test.ts
+++ b/plugin-server/tests/worker/ingestion/utils.test.ts
@@ -1,5 +1,5 @@
 import { Hub, LogLevel } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { captureIngestionWarning } from '../../../src/worker/ingestion/utils'
 import { delayUntilEventIngested, resetTestDatabaseClickhouse } from '../../helpers/clickhouse'
 
@@ -7,15 +7,14 @@ jest.setTimeout(60000) // 60 sec timeout
 
 describe('captureIngestionWarning()', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub({ LOG_LEVEL: LogLevel.Log })
+        hub = await createHub({ LOG_LEVEL: LogLevel.Log })
         await resetTestDatabaseClickhouse()
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     async function fetchWarnings() {
diff --git a/plugin-server/tests/worker/plugins-api-key-manager.test.ts b/plugin-server/tests/worker/plugins-api-key-manager.test.ts
index f4a1b77220587..606bfc86a89ff 100644
--- a/plugin-server/tests/worker/plugins-api-key-manager.test.ts
+++ b/plugin-server/tests/worker/plugins-api-key-manager.test.ts
@@ -1,5 +1,5 @@
 import { Hub } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { PostgresUse } from '../../src/utils/db/postgres'
 import { PluginsApiKeyManager } from '../../src/worker/vm/extensions/helpers/api-key-manager'
 import { createUserTeamAndOrganization, POSTGRES_DELETE_TABLES_QUERY } from '../helpers/sql'
@@ -9,10 +9,9 @@ const ORG_ID_2 = '4dc8564d-bd82-1065-2f40-97f7c50f67cf'
 
 describe('PluginsApiKeyManager', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub({
+        hub = await createHub({
             TASK_TIMEOUT: 1,
         })
         await hub.db.postgres.query(PostgresUse.COMMON_WRITE, POSTGRES_DELETE_TABLES_QUERY, [], 'truncateTablesTest')
@@ -21,7 +20,7 @@ describe('PluginsApiKeyManager', () => {
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     test('fetchOrCreatePersonalApiKey', async () => {
diff --git a/plugin-server/tests/worker/plugins.test.ts b/plugin-server/tests/worker/plugins.test.ts
index 286f289e46cd4..eceb14e4d142c 100644
--- a/plugin-server/tests/worker/plugins.test.ts
+++ b/plugin-server/tests/worker/plugins.test.ts
@@ -2,7 +2,7 @@ import { PluginEvent } from '@posthog/plugin-scaffold/src/types'
 
 import { Hub, LogLevel } from '../../src/types'
 import { processError } from '../../src/utils/db/error'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { delay, IllegalOperationError } from '../../src/utils/utils'
 import { loadPlugin } from '../../src/worker/plugins/loadPlugin'
 import { loadSchedule } from '../../src/worker/plugins/loadSchedule'
@@ -32,16 +32,15 @@ jest.setTimeout(20_000)
 
 describe('plugins', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub({ LOG_LEVEL: LogLevel.Log })
+        hub = await createHub({ LOG_LEVEL: LogLevel.Log })
         console.warn = jest.fn() as any
         await resetTestDatabase()
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     test('setupPlugins and runProcessEvent', async () => {
diff --git a/plugin-server/tests/worker/plugins/inline.test.ts b/plugin-server/tests/worker/plugins/inline.test.ts
index d03d66b357552..8201f5e07dafb 100644
--- a/plugin-server/tests/worker/plugins/inline.test.ts
+++ b/plugin-server/tests/worker/plugins/inline.test.ts
@@ -1,7 +1,7 @@
 import { PluginEvent } from '@posthog/plugin-scaffold'
 
 import { Hub, LogLevel, Plugin, PluginConfig } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { PostgresUse } from '../../../src/utils/db/postgres'
 import {
     constructInlinePluginInstance,
@@ -15,17 +15,16 @@ import { resetTestDatabase } from '../../helpers/sql'
 
 describe('Inline plugin', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeAll(async () => {
         console.info = jest.fn() as any
         console.warn = jest.fn() as any
-        ;[hub, closeHub] = await createHub({ LOG_LEVEL: LogLevel.Log })
+        hub = await createHub({ LOG_LEVEL: LogLevel.Log })
         await resetTestDatabase()
     })
 
     afterAll(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     // Sync all the inline plugins, then assert that for each plugin URL, a
diff --git a/plugin-server/tests/worker/plugins/inline_plugins/user-agent.test.ts b/plugin-server/tests/worker/plugins/inline_plugins/user-agent.test.ts
index b196353751b73..4b7a677b77476 100644
--- a/plugin-server/tests/worker/plugins/inline_plugins/user-agent.test.ts
+++ b/plugin-server/tests/worker/plugins/inline_plugins/user-agent.test.ts
@@ -1,23 +1,22 @@
 import { PluginEvent } from '@posthog/plugin-scaffold'
 
 import { LogLevel, PluginConfig } from '../../../../src/types'
-import { createHub } from '../../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../../src/utils/db/hub'
 import { constructInlinePluginInstance } from '../../../../src/worker/vm/inline/inline'
 import { resetTestDatabase } from '../../../helpers/sql'
 
 describe('user-agent tests', () => {
     let hub: any
-    let closeHub: () => Promise<void>
 
     beforeAll(async () => {
         console.info = jest.fn() as any
         console.warn = jest.fn() as any
-        ;[hub, closeHub] = await createHub({ LOG_LEVEL: LogLevel.Log })
+        hub = await createHub({ LOG_LEVEL: LogLevel.Log })
         await resetTestDatabase()
     })
 
     afterAll(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     test('should not process event when $userAgent is missing', async () => {
diff --git a/plugin-server/tests/worker/plugins/mmdb.test.ts b/plugin-server/tests/worker/plugins/mmdb.test.ts
index 8179191a27640..e95e3fec24f32 100644
--- a/plugin-server/tests/worker/plugins/mmdb.test.ts
+++ b/plugin-server/tests/worker/plugins/mmdb.test.ts
@@ -5,7 +5,7 @@ import fetch from 'node-fetch'
 import { join } from 'path'
 
 import { Hub, LogLevel } from '../../../src/types'
-import { createHub } from '../../../src/utils/db/hub'
+import { closeHub, createHub } from '../../../src/utils/db/hub'
 import { setupMmdb } from '../../../src/worker/plugins/mmdb'
 import { resetTestDatabase } from '../../helpers/sql'
 
@@ -38,17 +38,16 @@ async function getCityName(hub: Hub, ipAddress: string) {
 
 describe('mmdb', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     jest.setTimeout(100_000)
 
     beforeAll(async () => {
-        ;[hub, closeHub] = await createHub({ LOG_LEVEL: LogLevel.Warn })
+        hub = await createHub({ LOG_LEVEL: LogLevel.Warn })
         hub.capabilities.mmdb = true
     })
 
     afterAll(async () => {
-        await closeHub()
+        await closeHub(hub)
         jest.clearAllMocks()
     })
 
diff --git a/plugin-server/tests/worker/transforms.test.ts b/plugin-server/tests/worker/transforms.test.ts
index 9b88c329f4563..d3072eaa0acd9 100644
--- a/plugin-server/tests/worker/transforms.test.ts
+++ b/plugin-server/tests/worker/transforms.test.ts
@@ -1,5 +1,5 @@
 import { Hub } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { code } from '../../src/utils/utils'
 import { transformCode } from '../../src/worker/vm/transforms'
 import { resetTestDatabase } from '../helpers/sql'
@@ -10,15 +10,14 @@ const EMPTY_IMPORTS = {}
 
 describe('transforms', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
         await resetTestDatabase(`const processEvent = event => event`)
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     describe('transformCode', () => {
diff --git a/plugin-server/tests/worker/vm.extra-lazy.test.ts b/plugin-server/tests/worker/vm.extra-lazy.test.ts
index 78bcc0da60f6c..480fdc423bd30 100644
--- a/plugin-server/tests/worker/vm.extra-lazy.test.ts
+++ b/plugin-server/tests/worker/vm.extra-lazy.test.ts
@@ -1,7 +1,7 @@
 import fetch from 'node-fetch'
 
 import { Hub, PluginTaskType } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { pluginDigest } from '../../src/utils/utils'
 import { LazyPluginVM } from '../../src/worker/vm/lazy'
 import { plugin60, pluginConfig39 } from '../helpers/plugins'
@@ -9,14 +9,13 @@ import { resetTestDatabase } from '../helpers/sql'
 
 describe('VMs are extra lazy 💤', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
         jest.clearAllMocks()
     })
     test('VM with scheduled tasks gets setup immediately', async () => {
diff --git a/plugin-server/tests/worker/vm.test.ts b/plugin-server/tests/worker/vm.test.ts
index 5f1f727d4dbeb..6f4f35460da19 100644
--- a/plugin-server/tests/worker/vm.test.ts
+++ b/plugin-server/tests/worker/vm.test.ts
@@ -4,7 +4,7 @@ import fetch from 'node-fetch'
 import { KAFKA_EVENTS_PLUGIN_INGESTION, KAFKA_PLUGIN_LOG_ENTRIES } from '../../src/config/kafka-topics'
 import { Hub, PluginLogEntrySource, PluginLogEntryType } from '../../src/types'
 import { PluginConfig, PluginConfigVMResponse } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { delay, UUIDT } from '../../src/utils/utils'
 import { createPluginConfigVM } from '../../src/worker/vm/vm'
 import { pluginConfig39 } from '../helpers/plugins'
@@ -42,14 +42,13 @@ export const createReadyPluginConfigVm = async (
 }
 describe('vm tests', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub()
+        hub = await createHub()
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     test('empty plugins', async () => {
diff --git a/plugin-server/tests/worker/vm.timeout.test.ts b/plugin-server/tests/worker/vm.timeout.test.ts
index 739c35095a7c1..aebab19669622 100644
--- a/plugin-server/tests/worker/vm.timeout.test.ts
+++ b/plugin-server/tests/worker/vm.timeout.test.ts
@@ -1,5 +1,5 @@
 import { Hub, PluginConfig, PluginConfigVMResponse } from '../../src/types'
-import { createHub } from '../../src/utils/db/hub'
+import { closeHub, createHub } from '../../src/utils/db/hub'
 import { createPluginConfigVM, TimeoutError } from '../../src/worker/vm/vm'
 import { pluginConfig39 } from '../helpers/plugins'
 import { resetTestDatabase } from '../helpers/sql'
@@ -30,16 +30,15 @@ export const createReadyPluginConfigVm = async (
 
 describe('vm timeout tests', () => {
     let hub: Hub
-    let closeHub: () => Promise<void>
 
     beforeEach(async () => {
-        ;[hub, closeHub] = await createHub({
+        hub = await createHub({
             TASK_TIMEOUT: 1,
         })
     })
 
     afterEach(async () => {
-        await closeHub()
+        await closeHub(hub)
     })
 
     test('while loop', async () => {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 50be2444d44be..833dec3dea675 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -53,8 +53,8 @@ dependencies:
     specifier: 4.6.0
     version: 4.6.0(monaco-editor@0.49.0)(react-dom@18.2.0)(react@18.2.0)
   '@posthog/hogvm':
-    specifier: ^1.0.42
-    version: 1.0.42(luxon@3.5.0)
+    specifier: ^1.0.44
+    version: 1.0.44(luxon@3.5.0)
   '@posthog/icons':
     specifier: 0.7.3
     version: 0.7.3(react-dom@18.2.0)(react@18.2.0)
@@ -272,8 +272,8 @@ dependencies:
     specifier: ^9.3.0
     version: 9.3.0(postcss@8.4.31)
   posthog-js:
-    specifier: 1.159.0
-    version: 1.159.0
+    specifier: 1.160.3
+    version: 1.160.3
   posthog-js-lite:
     specifier: 3.0.0
     version: 3.0.0
@@ -5414,8 +5414,8 @@ packages:
     resolution: {integrity: sha512-50/17A98tWUfQ176raKiOGXuYpLyyVMkxxG6oylzL3BPOlA6ADGdK7EYunSa4I064xerltq9TGXs8HmOk5E+vw==}
     dev: false
 
-  /@posthog/hogvm@1.0.42(luxon@3.5.0):
-    resolution: {integrity: sha512-vrIl2XVtlBqkPOmF65pd8WYFFnv+Mtc2kgmJga9CDo8obsn/aMcYf4UrKNcXsK9XAz4vxw7ItwcgrD/Hb6WjuQ==}
+  /@posthog/hogvm@1.0.44(luxon@3.5.0):
+    resolution: {integrity: sha512-Ss7gTPyvPyviNipVQOqnsCa66IMmMf+DEg7iX/vQMcWDuFwvHNbdze1iwFVoXCjLci+h8SW2rOMPB0S5A2jJXg==}
     peerDependencies:
       luxon: ^3.4.4
     dependencies:
@@ -13428,7 +13428,7 @@ packages:
       source-map: 0.6.1
       wordwrap: 1.0.0
     optionalDependencies:
-      uglify-js: 3.19.2
+      uglify-js: 3.19.3
     dev: true
 
   /hard-rejection@2.1.0:
@@ -17707,8 +17707,8 @@ packages:
     resolution: {integrity: sha512-dyajjnfzZD1tht4N7p7iwf7nBnR1MjVaVu+MKr+7gBgA39bn28wizCIJZztZPtHy4PY0YwtSGgwfBCuG/hnHgA==}
     dev: false
 
-  /posthog-js@1.159.0:
-    resolution: {integrity: sha512-K123Y8ayqT+NPZNgeGgOxct/+zwxJohafnCsohPvRbLdMq9u4B6MagdEUbY5svzfwLL3XLCOrXsvh6ETd15IrQ==}
+  /posthog-js@1.160.3:
+    resolution: {integrity: sha512-mGvxOIlWPtdPx8EI0MQ81wNKlnH2K0n4RqwQOl044b34BCKiFVzZ7Hc7geMuZNaRAvCi5/5zyGeWHcAYZQxiMQ==}
     dependencies:
       fflate: 0.4.8
       preact: 10.23.2
@@ -20728,8 +20728,8 @@ packages:
     resolution: {integrity: sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA==}
     dev: false
 
-  /uglify-js@3.19.2:
-    resolution: {integrity: sha512-S8KA6DDI47nQXJSi2ctQ629YzwOVs+bQML6DAtvy0wgNdpi+0ySpQK0g2pxBq2xfF2z3YCscu7NNA8nXT9PlIQ==}
+  /uglify-js@3.19.3:
+    resolution: {integrity: sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==}
     engines: {node: '>=0.8.0'}
     hasBin: true
     requiresBuild: true
diff --git a/posthog/api/insight.py b/posthog/api/insight.py
index 6bf91e1649672..1b753e9171cfa 100644
--- a/posthog/api/insight.py
+++ b/posthog/api/insight.py
@@ -1090,6 +1090,7 @@ def activity(self, request: request.Request, **kwargs):
         return activity_page_response(activity_page, limit, page, request)
 
     @action(methods=["POST"], detail=False)
+    @monitor(feature=Feature.INSIGHT, endpoint="insight", method="CANCEL")
     def cancel(self, request: request.Request, **kwargs):
         if "client_query_id" not in request.data:
             raise serializers.ValidationError({"client_query_id": "Field is required."})
diff --git a/posthog/api/monitoring.py b/posthog/api/monitoring.py
index 2f94e58c8a1cb..d1778320f1e46 100644
--- a/posthog/api/monitoring.py
+++ b/posthog/api/monitoring.py
@@ -2,6 +2,7 @@
 from prometheus_client import Counter
 from sentry_sdk import set_tag
 from collections.abc import Callable
+from functools import wraps
 
 
 class Feature(StrEnum):
@@ -31,6 +32,7 @@ def monitor(*, feature: Feature | None, endpoint: str, method: str) -> Callable:
     """
 
     def decorator(func: Callable) -> Callable:
+        @wraps(func)
         def wrapper(*args, **kwargs):
             API_REQUESTS_COUNTER.labels(endpoint=endpoint, method=method).inc()
 
diff --git a/posthog/hogql/database/models.py b/posthog/hogql/database/models.py
index 1fff9a76405ee..fe90976bec3cd 100644
--- a/posthog/hogql/database/models.py
+++ b/posthog/hogql/database/models.py
@@ -8,7 +8,7 @@
 
 if TYPE_CHECKING:
     from posthog.hogql.context import HogQLContext
-    from posthog.hogql.ast import SelectQuery
+    from posthog.hogql.ast import SelectQuery, LazyJoinType
     from posthog.hogql.base import ConstantType
 
 
@@ -192,6 +192,7 @@ class LazyJoinToAdd:
     from_table: str
     to_table: str
     lazy_join: LazyJoin
+    lazy_join_type: "LazyJoinType"
     fields_accessed: dict[str, list[str | int]] = field(default_factory=dict)
 
 
diff --git a/posthog/hogql/database/schema/util/test/test_session_v2_where_clause_extractor.py b/posthog/hogql/database/schema/util/test/test_session_v2_where_clause_extractor.py
new file mode 100644
index 0000000000000..0d8aa21b24f51
--- /dev/null
+++ b/posthog/hogql/database/schema/util/test/test_session_v2_where_clause_extractor.py
@@ -0,0 +1,599 @@
+from typing import Union, Optional
+
+from posthog.hogql import ast
+from posthog.hogql.constants import MAX_SELECT_RETURNED_ROWS
+from posthog.hogql.context import HogQLContext
+from posthog.hogql.database.schema.util.where_clause_extractor import SessionMinTimestampWhereClauseExtractorV2
+from posthog.hogql.modifiers import create_default_modifiers_for_team
+from posthog.hogql.parser import parse_select, parse_expr
+from posthog.hogql.printer import prepare_ast_for_printing, print_prepared_ast
+from posthog.hogql.visitor import clone_expr
+from posthog.schema import SessionTableVersion
+from posthog.test.base import ClickhouseTestMixin, APIBaseTest
+
+
+def f(s: Union[str, ast.Expr, None], placeholders: Optional[dict[str, ast.Expr]] = None) -> Union[ast.Expr, None]:
+    if s is None:
+        return None
+    if isinstance(s, str):
+        expr = parse_expr(s, placeholders=placeholders)
+    else:
+        expr = s
+    return clone_expr(expr, clear_types=True, clear_locations=True)
+
+
+def parse(
+    s: str,
+    placeholders: Optional[dict[str, ast.Expr]] = None,
+) -> ast.SelectQuery | ast.SelectUnionQuery:
+    parsed = parse_select(s, placeholders=placeholders)
+    return parsed
+
+
+class TestSessionWhereClauseExtractorV2(ClickhouseTestMixin, APIBaseTest):
+    @property
+    def inliner(self):
+        team = self.team
+        modifiers = create_default_modifiers_for_team(team)
+        modifiers.sessionTableVersion = SessionTableVersion.V2
+        context = HogQLContext(
+            team_id=team.pk,
+            team=team,
+            enable_select_queries=True,
+            modifiers=modifiers,
+        )
+        return SessionMinTimestampWhereClauseExtractorV2(context)
+
+    def test_handles_select_with_no_where_claus(self):
+        inner_where = self.inliner.get_inner_where(parse("SELECT * FROM sessions"))
+        assert inner_where is None
+
+    def test_handles_select_with_eq(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE $start_timestamp = '2021-01-01'")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) - toIntervalDay(3)) <= '2021-01-01') AND ((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-01')"
+        )
+        assert expected == actual
+
+    def test_handles_select_with_eq_flipped(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE '2021-01-01' = $start_timestamp")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) - toIntervalDay(3)) <= '2021-01-01') AND ((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-01')"
+        )
+        assert expected == actual
+
+    def test_handles_select_with_simple_gt(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE $start_timestamp > '2021-01-01'")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-01')"
+        )
+        assert expected == actual
+
+    def test_handles_select_with_simple_gte(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE $start_timestamp >= '2021-01-01'")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-01')"
+        )
+        assert expected == actual
+
+    def test_handles_select_with_simple_lt(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE $start_timestamp < '2021-01-01'")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) - toIntervalDay(3)) <= '2021-01-01')"
+        )
+        assert expected == actual
+
+    def test_handles_select_with_simple_lte(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE $start_timestamp <= '2021-01-01'")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) - toIntervalDay(3)) <= '2021-01-01')"
+        )
+        assert expected == actual
+
+    def test_select_with_placeholder(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM sessions WHERE $start_timestamp > {timestamp}",
+                    placeholders={"timestamp": ast.Constant(value="2021-01-01")},
+                )
+            )
+        )
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-01')"
+        )
+        assert expected == actual
+
+    def test_unrelated_equals(self):
+        actual = self.inliner.get_inner_where(
+            parse("SELECT * FROM sessions WHERE $initial_utm_campaign = $initial_utm_source")
+        )
+        assert actual is None
+
+    def test_timestamp_and(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM sessions WHERE and($start_timestamp >= '2021-01-01', $start_timestamp <= '2021-01-03')"
+                )
+            )
+        )
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-01') AND ((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) - toIntervalDay(3)) <= '2021-01-03')"
+        )
+        assert expected == actual
+
+    def test_timestamp_or(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse("SELECT * FROM sessions WHERE and(min_timestamp <= '2021-01-01', min_timestamp >= '2021-01-03')")
+            )
+        )
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) - toIntervalDay(3)) <= '2021-01-01') AND ((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-03')"
+        )
+        assert expected == actual
+
+    def test_unrelated_function(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE like('a', 'b')")))
+        assert actual is None
+
+    def test_timestamp_unrelated_function(self):
+        actual = f(
+            self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE like(toString(min_timestamp), 'b')"))
+        )
+        assert actual is None
+
+    def test_timestamp_unrelated_function_timestamp(self):
+        actual = f(
+            self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE like(toString(min_timestamp), 'b')"))
+        )
+        assert actual is None
+
+    def test_ambiguous_or(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM sessions WHERE or($start_timestamp > '2021-01-03', like(toString($start_timestamp), 'b'))"
+                )
+            )
+        )
+        assert actual is None
+
+    def test_ambiguous_and(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM sessions WHERE and($start_timestamp > '2021-01-03', like(toString($start_timestamp), 'b'))"
+                )
+            )
+        )
+        assert actual == f(
+            "(fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-03'"
+        )
+
+    def test_join(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM events JOIN sessions ON events.session_id = sessions.session_id WHERE $start_timestamp > '2021-01-03'"
+                )
+            )
+        )
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-03')"
+        )
+        assert expected == actual
+
+    def test_join_using_events_timestamp_filter(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM events JOIN sessions ON events.session_id = sessions.session_id WHERE timestamp > '2021-01-03'"
+                )
+            )
+        )
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2021-01-03')"
+        )
+        assert expected == actual
+
+    def test_minus(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE $start_timestamp >= today() - 2")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= (today() - 2))"
+        )
+        assert expected == actual
+
+    def test_minus_function(self):
+        actual = f(
+            self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE $start_timestamp >= minus(today() , 2)"))
+        )
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= minus(today(), 2))"
+        )
+        assert expected == actual
+
+    def test_less_function(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE less($start_timestamp, today())")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) - toIntervalDay(3)) <= today())"
+        )
+        assert expected == actual
+
+    def test_less_function_second_arg(self):
+        actual = f(self.inliner.get_inner_where(parse("SELECT * FROM sessions WHERE less(today(), $start_timestamp)")))
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= today())"
+        )
+        assert expected == actual
+
+    def test_subquery_args(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse("SELECT * FROM sessions WHERE true = (select false) and less(today(), min_timestamp)")
+            )
+        )
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= today())"
+        )
+        assert expected == actual
+
+    def test_real_example(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM events JOIN sessions ON events.session_id = sessions.session_id WHERE event = '$pageview' AND toTimeZone(timestamp, 'US/Pacific') >= toDateTime('2024-03-12 00:00:00', 'US/Pacific') AND toTimeZone(timestamp, 'US/Pacific') <= toDateTime('2024-03-19 23:59:59', 'US/Pacific')"
+                )
+            )
+        )
+        expected = f(
+            "(toTimeZone(fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), 'US/Pacific') + toIntervalDay(3)) >= toDateTime('2024-03-12 00:00:00', 'US/Pacific') AND (toTimeZone(fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), 'US/Pacific') - toIntervalDay(3)) <= toDateTime('2024-03-19 23:59:59', 'US/Pacific') "
+        )
+        assert expected == actual
+
+    def test_collapse_and(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM sessions WHERE event = '$pageview' AND (TRUE AND (TRUE AND TRUE AND (timestamp >= '2024-03-12' AND TRUE)))"
+                )
+            )
+        )
+        expected = f(
+            "(fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2024-03-12'"
+        )
+        assert expected == actual
+
+    def test_select_query(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    "SELECT * FROM sessions WHERE timestamp = (SELECT max(timestamp) FROM events WHERE event = '$pageview')"
+                )
+            )
+        )
+        assert actual is None
+
+    def test_breakdown_subquery(self):
+        actual = f(
+            self.inliner.get_inner_where(
+                parse(
+                    f"""
+SELECT
+            count(DISTINCT e.$session_id) AS total,
+            toStartOfDay(timestamp) AS day_start,
+            multiIf(and(greaterOrEquals(session.$session_duration, 2.0), less(session.$session_duration, 4.5)), '[2.0,4.5]', and(greaterOrEquals(session.$session_duration, 4.5), less(session.$session_duration, 27.0)), '[4.5,27.0]', and(greaterOrEquals(session.$session_duration, 27.0), less(session.$session_duration, 44.0)), '[27.0,44.0]', and(greaterOrEquals(session.$session_duration, 44.0), less(session.$session_duration, 48.0)), '[44.0,48.0]', and(greaterOrEquals(session.$session_duration, 48.0), less(session.$session_duration, 57.5)), '[48.0,57.5]', and(greaterOrEquals(session.$session_duration, 57.5), less(session.$session_duration, 61.0)), '[57.5,61.0]', and(greaterOrEquals(session.$session_duration, 61.0), less(session.$session_duration, 74.0)), '[61.0,74.0]', and(greaterOrEquals(session.$session_duration, 74.0), less(session.$session_duration, 90.0)), '[74.0,90.0]', and(greaterOrEquals(session.$session_duration, 90.0), less(session.$session_duration, 98.5)), '[90.0,98.5]', and(greaterOrEquals(session.$session_duration, 98.5), less(session.$session_duration, 167.01)), '[98.5,167.01]', '["",""]') AS breakdown_value
+        FROM
+            events AS e SAMPLE 1
+        WHERE
+            and(greaterOrEquals(timestamp, toStartOfDay(assumeNotNull(toDateTime('2024-04-13 00:00:00')))), lessOrEquals(timestamp, assumeNotNull(toDateTime('2024-04-20 23:59:59'))), equals(event, '$pageview'), in(person_id, (SELECT
+                        person_id
+                    FROM
+                        raw_cohort_people
+                    WHERE
+                        and(equals(cohort_id, 2), equals(version, 0)))))
+        GROUP BY
+            day_start,
+            breakdown_value
+                """
+                )
+            )
+        )
+        expected = f(
+            "((fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= toStartOfDay(assumeNotNull(toDateTime('2024-04-13 00:00:00'))) AND (fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) - toIntervalDay(3)) <= assumeNotNull(toDateTime('2024-04-20 23:59:59')))"
+        )
+        assert expected == actual
+
+    def test_not_like(self):
+        # based on a bug here: https://posthog.slack.com/archives/C05LJK1N3CP/p1719916566421079
+        where = ast.And(
+            exprs=[
+                ast.CompareOperation(
+                    left=ast.Field(chain=["event"]),
+                    op=ast.CompareOperationOp.Eq,
+                    right=ast.Constant(value="$pageview"),
+                ),
+                ast.CompareOperation(
+                    left=ast.Field(chain=["timestamp"]),
+                    op=ast.CompareOperationOp.GtEq,
+                    right=ast.Constant(value="2024-03-12"),
+                ),
+                ast.And(
+                    exprs=[
+                        ast.CompareOperation(
+                            left=ast.Field(chain=["host"]),
+                            op=ast.CompareOperationOp.NotILike,
+                            right=ast.Constant(value="localhost:3000"),
+                        ),
+                        ast.CompareOperation(
+                            left=ast.Field(chain=["host"]),
+                            op=ast.CompareOperationOp.NotILike,
+                            right=ast.Constant(value="localhost:3001"),
+                        ),
+                    ]
+                ),
+            ]
+        )
+        select = ast.SelectQuery(select=[], where=where)
+        actual = f(self.inliner.get_inner_where(select))
+        expected = f(
+            "(fromUnixTimestamp(intDiv(_toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)) + toIntervalDay(3)) >= '2024-03-12'"
+        )
+        assert expected == actual
+
+
+class TestSessionsV2QueriesHogQLToClickhouse(ClickhouseTestMixin, APIBaseTest):
+    def print_query(self, query: str) -> str:
+        team = self.team
+        modifiers = create_default_modifiers_for_team(team)
+        modifiers.sessionTableVersion = SessionTableVersion.V2
+        context = HogQLContext(
+            team_id=team.pk,
+            team=team,
+            enable_select_queries=True,
+            modifiers=modifiers,
+        )
+        prepared_ast = prepare_ast_for_printing(node=parse(query), context=context, dialect="clickhouse")
+        if prepared_ast is None:
+            return ""
+        pretty = print_prepared_ast(prepared_ast, context=context, dialect="clickhouse", pretty=True)
+        return pretty
+
+    def test_select_with_timestamp(self):
+        actual = self.print_query("SELECT session_id FROM sessions WHERE $start_timestamp > '2021-01-01'")
+        expected = f"""SELECT
+    sessions.session_id AS session_id
+FROM
+    (SELECT
+        toString(reinterpretAsUUID(bitOr(bitShiftLeft(raw_sessions.session_id_v7, 64), bitShiftRight(raw_sessions.session_id_v7, 64)))) AS session_id,
+        min(toTimeZone(raw_sessions.min_timestamp, %(hogql_val_0)s)) AS `$start_timestamp`,
+        raw_sessions.session_id_v7 AS session_id_v7
+    FROM
+        raw_sessions
+    WHERE
+        and(equals(raw_sessions.team_id, {self.team.id}), ifNull(greaterOrEquals(plus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), %(hogql_val_1)s), 0))
+    GROUP BY
+        raw_sessions.session_id_v7,
+        raw_sessions.session_id_v7) AS sessions
+WHERE
+    ifNull(greater(sessions.`$start_timestamp`, %(hogql_val_2)s), 0)
+LIMIT {MAX_SELECT_RETURNED_ROWS}"""
+        assert expected == actual
+
+    def test_join_with_events(self):
+        actual = self.print_query(
+            """
+SELECT
+    sessions.session_id,
+    uniq(uuid)
+FROM events
+JOIN sessions
+ON events.$session_id = sessions.session_id
+WHERE events.timestamp > '2021-01-01'
+GROUP BY sessions.session_id
+"""
+        )
+        expected = f"""SELECT
+    sessions.session_id AS session_id,
+    uniq(events.uuid)
+FROM
+    events
+    JOIN (SELECT
+        toString(reinterpretAsUUID(bitOr(bitShiftLeft(raw_sessions.session_id_v7, 64), bitShiftRight(raw_sessions.session_id_v7, 64)))) AS session_id,
+        raw_sessions.session_id_v7 AS session_id_v7
+    FROM
+        raw_sessions
+    WHERE
+        and(equals(raw_sessions.team_id, {self.team.id}), ifNull(greaterOrEquals(plus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), %(hogql_val_0)s), 0))
+    GROUP BY
+        raw_sessions.session_id_v7,
+        raw_sessions.session_id_v7) AS sessions ON equals(events.`$session_id`, sessions.session_id)
+WHERE
+    and(equals(events.team_id, {self.team.id}), greater(toTimeZone(events.timestamp, %(hogql_val_1)s), %(hogql_val_2)s))
+GROUP BY
+    sessions.session_id
+LIMIT {MAX_SELECT_RETURNED_ROWS}"""
+        assert expected == actual
+
+    def test_union(self):
+        actual = self.print_query(
+            """
+SELECT 0 as duration
+UNION ALL
+SELECT events.session.$session_duration as duration
+FROM events
+WHERE events.timestamp < today()
+            """
+        )
+        expected = f"""SELECT
+    0 AS duration
+LIMIT {MAX_SELECT_RETURNED_ROWS}
+UNION ALL
+SELECT
+    events__session.`$session_duration` AS duration
+FROM
+    events
+    LEFT JOIN (SELECT
+        dateDiff(%(hogql_val_0)s, min(toTimeZone(raw_sessions.min_timestamp, %(hogql_val_1)s)), max(toTimeZone(raw_sessions.max_timestamp, %(hogql_val_2)s))) AS `$session_duration`,
+        raw_sessions.session_id_v7 AS session_id_v7
+    FROM
+        raw_sessions
+    WHERE
+        and(equals(raw_sessions.team_id, {self.team.id}), ifNull(lessOrEquals(minus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), today()), 0))
+    GROUP BY
+        raw_sessions.session_id_v7,
+        raw_sessions.session_id_v7) AS events__session ON equals(toUInt128(accurateCastOrNull(events.`$session_id`, %(hogql_val_3)s)), events__session.session_id_v7)
+WHERE
+    and(equals(events.team_id, {self.team.id}), less(toTimeZone(events.timestamp, %(hogql_val_4)s), today()))
+LIMIT {MAX_SELECT_RETURNED_ROWS}"""
+        assert expected == actual
+
+    def test_session_breakdown(self):
+        actual = self.print_query(
+            """SELECT count(DISTINCT e."$session_id") AS total,
+       toStartOfDay(timestamp)         AS day_start,
+       multiIf(and(greaterOrEquals(session."$session_duration", 2.0),
+                   less(session."$session_duration", 4.5)),
+               '[2.0,4.5]',
+               and(greaterOrEquals(session."$session_duration", 4.5),
+                   less(session."$session_duration", 27.0)),
+               '[4.5,27.0]',
+               and(greaterOrEquals(session."$session_duration", 27.0),
+                   less(session."$session_duration", 44.0)),
+               '[27.0,44.0]',
+               and(greaterOrEquals(session."$session_duration", 44.0),
+                   less(session."$session_duration", 48.0)),
+               '[44.0,48.0]',
+               and(greaterOrEquals(session."$session_duration", 48.0),
+                   less(session."$session_duration", 57.5)),
+               '[48.0,57.5]',
+               and(greaterOrEquals(session."$session_duration", 57.5),
+                   less(session."$session_duration", 61.0)),
+               '[57.5,61.0]',
+               and(greaterOrEquals(session."$session_duration", 61.0),
+                   less(session."$session_duration", 74.0)),
+               '[61.0,74.0]',
+               and(greaterOrEquals(session."$session_duration", 74.0),
+                   less(session."$session_duration", 90.0)),
+               '[74.0,90.0]',
+               and(greaterOrEquals(session."$session_duration", 90.0),
+                   less(session."$session_duration", 98.5)),
+               '[90.0,98.5]', and(greaterOrEquals(session."$session_duration", 98.5),
+                                  less(session."$session_duration", 167.01)), '[98.5,167.01]',
+               '["",""]')              AS breakdown_value
+FROM events AS e SAMPLE 1
+WHERE and(greaterOrEquals(timestamp, toStartOfDay(assumeNotNull(toDateTime('2024-04-13 00:00:00')))),
+          lessOrEquals(timestamp, assumeNotNull(toDateTime('2024-04-20 23:59:59'))),
+          equals(event, '$pageview'), in(person_id, (SELECT person_id
+                                                     FROM raw_cohort_people
+                                                     WHERE and(equals(cohort_id, 2), equals(version, 0)))))
+GROUP BY day_start,
+         breakdown_value"""
+        )
+        expected = f"""SELECT
+    count(DISTINCT e.`$session_id`) AS total,
+    toStartOfDay(toTimeZone(e.timestamp, %(hogql_val_8)s)) AS day_start,
+    multiIf(and(ifNull(greaterOrEquals(e__session.`$session_duration`, 2.0), 0), ifNull(less(e__session.`$session_duration`, 4.5), 0)), %(hogql_val_9)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 4.5), 0), ifNull(less(e__session.`$session_duration`, 27.0), 0)), %(hogql_val_10)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 27.0), 0), ifNull(less(e__session.`$session_duration`, 44.0), 0)), %(hogql_val_11)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 44.0), 0), ifNull(less(e__session.`$session_duration`, 48.0), 0)), %(hogql_val_12)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 48.0), 0), ifNull(less(e__session.`$session_duration`, 57.5), 0)), %(hogql_val_13)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 57.5), 0), ifNull(less(e__session.`$session_duration`, 61.0), 0)), %(hogql_val_14)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 61.0), 0), ifNull(less(e__session.`$session_duration`, 74.0), 0)), %(hogql_val_15)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 74.0), 0), ifNull(less(e__session.`$session_duration`, 90.0), 0)), %(hogql_val_16)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 90.0), 0), ifNull(less(e__session.`$session_duration`, 98.5), 0)), %(hogql_val_17)s, and(ifNull(greaterOrEquals(e__session.`$session_duration`, 98.5), 0), ifNull(less(e__session.`$session_duration`, 167.01), 0)), %(hogql_val_18)s, %(hogql_val_19)s) AS breakdown_value
+FROM
+    events AS e SAMPLE 1
+    INNER JOIN (SELECT
+        argMax(person_distinct_id2.person_id, person_distinct_id2.version) AS person_id,
+        person_distinct_id2.distinct_id AS distinct_id
+    FROM
+        person_distinct_id2
+    WHERE
+        equals(person_distinct_id2.team_id, {self.team.id})
+    GROUP BY
+        person_distinct_id2.distinct_id
+    HAVING
+        ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0)
+    SETTINGS optimize_aggregation_in_order=1) AS e__pdi ON equals(e.distinct_id, e__pdi.distinct_id)
+    LEFT JOIN (SELECT
+        dateDiff(%(hogql_val_0)s, min(toTimeZone(raw_sessions.min_timestamp, %(hogql_val_1)s)), max(toTimeZone(raw_sessions.max_timestamp, %(hogql_val_2)s))) AS `$session_duration`,
+        raw_sessions.session_id_v7 AS session_id_v7
+    FROM
+        raw_sessions
+    WHERE
+        and(equals(raw_sessions.team_id, {self.team.id}), ifNull(greaterOrEquals(plus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull(%(hogql_val_3)s, 6, %(hogql_val_4)s)))), 0), ifNull(lessOrEquals(minus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), assumeNotNull(parseDateTime64BestEffortOrNull(%(hogql_val_5)s, 6, %(hogql_val_6)s))), 0))
+    GROUP BY
+        raw_sessions.session_id_v7,
+        raw_sessions.session_id_v7) AS e__session ON equals(toUInt128(accurateCastOrNull(e.`$session_id`, %(hogql_val_7)s)), e__session.session_id_v7)
+WHERE
+    and(equals(e.team_id, {self.team.id}), and(greaterOrEquals(toTimeZone(e.timestamp, %(hogql_val_20)s), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull(%(hogql_val_21)s, 6, %(hogql_val_22)s)))), lessOrEquals(toTimeZone(e.timestamp, %(hogql_val_23)s), assumeNotNull(parseDateTime64BestEffortOrNull(%(hogql_val_24)s, 6, %(hogql_val_25)s))), equals(e.event, %(hogql_val_26)s), ifNull(in(e__pdi.person_id, (SELECT
+                    cohortpeople.person_id AS person_id
+                FROM
+                    cohortpeople
+                WHERE
+                    and(equals(cohortpeople.team_id, {self.team.id}), and(equals(cohortpeople.cohort_id, 2), equals(cohortpeople.version, 0))))), 0)))
+GROUP BY
+    day_start,
+    breakdown_value
+LIMIT {MAX_SELECT_RETURNED_ROWS}"""
+        assert expected == actual
+
+    def test_session_replay_query(self):
+        actual = self.print_query(
+            """
+SELECT
+    s.session_id,
+    min(s.min_first_timestamp) as start_time
+FROM raw_session_replay_events s
+WHERE s.session.$entry_pathname = '/home' AND min_first_timestamp >= '2021-01-01:12:34' AND min_first_timestamp < now()
+GROUP BY session_id
+        """
+        )
+        expected = f"""SELECT
+    s.session_id AS session_id,
+    min(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s)) AS start_time
+FROM
+    session_replay_events AS s
+    LEFT JOIN (SELECT
+        path(nullIf(nullIf(argMinMerge(raw_sessions.entry_url), %(hogql_val_0)s), %(hogql_val_1)s)) AS `$entry_pathname`,
+        raw_sessions.session_id_v7 AS session_id_v7
+    FROM
+        raw_sessions
+    WHERE
+        and(equals(raw_sessions.team_id, {self.team.id}), ifNull(greaterOrEquals(plus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), %(hogql_val_2)s), 0), ifNull(lessOrEquals(minus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), now64(6, %(hogql_val_3)s)), 0))
+    GROUP BY
+        raw_sessions.session_id_v7,
+        raw_sessions.session_id_v7) AS s__session ON equals(toUInt128(accurateCastOrNull(s.session_id, %(hogql_val_4)s)), s__session.session_id_v7)
+WHERE
+    and(equals(s.team_id, {self.team.id}), ifNull(equals(s__session.`$entry_pathname`, %(hogql_val_6)s), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), %(hogql_val_8)s), 0), ifNull(less(toTimeZone(s.min_first_timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), 0))
+GROUP BY
+    s.session_id
+LIMIT {MAX_SELECT_RETURNED_ROWS}"""
+        assert expected == actual
+
+    def test_urls_in_sessions_in_timestamp_query(self):
+        actual = self.print_query(
+            """
+            select
+   session_id,
+   `$urls`,
+   $start_timestamp
+from sessions
+where `$start_timestamp` >= now() - toIntervalDay(7)
+"""
+        )
+        expected = f"""SELECT
+    sessions.session_id AS session_id,
+    sessions.`$urls` AS `$urls`,
+    sessions.`$start_timestamp` AS `$start_timestamp`
+FROM
+    (SELECT
+        toString(reinterpretAsUUID(bitOr(bitShiftLeft(raw_sessions.session_id_v7, 64), bitShiftRight(raw_sessions.session_id_v7, 64)))) AS session_id,
+        arrayDistinct(arrayFlatten(groupArray(raw_sessions.urls))) AS `$urls`,
+        min(toTimeZone(raw_sessions.min_timestamp, %(hogql_val_0)s)) AS `$start_timestamp`,
+        raw_sessions.session_id_v7 AS session_id_v7
+    FROM
+        raw_sessions
+    WHERE
+        and(equals(raw_sessions.team_id, {self.team.id}), ifNull(greaterOrEquals(plus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), minus(now64(6, %(hogql_val_1)s), toIntervalDay(7))), 0))
+    GROUP BY
+        raw_sessions.session_id_v7,
+        raw_sessions.session_id_v7) AS sessions
+WHERE
+    ifNull(greaterOrEquals(sessions.`$start_timestamp`, minus(now64(6, %(hogql_val_2)s), toIntervalDay(7))), 0)
+LIMIT {MAX_SELECT_RETURNED_ROWS}"""
+        assert expected == actual
diff --git a/posthog/hogql/database/schema/util/where_clause_extractor.py b/posthog/hogql/database/schema/util/where_clause_extractor.py
index fd480e32a97c5..9ed7be296f483 100644
--- a/posthog/hogql/database/schema/util/where_clause_extractor.py
+++ b/posthog/hogql/database/schema/util/where_clause_extractor.py
@@ -461,7 +461,8 @@ def visit_tuple(self, node: ast.Tuple) -> bool:
 
 
 def is_simple_timestamp_field_expression(expr: ast.Expr, context: HogQLContext, tombstone_string: str) -> bool:
-    return IsSimpleTimestampFieldExpressionVisitor(context, tombstone_string).visit(expr)
+    result = IsSimpleTimestampFieldExpressionVisitor(context, tombstone_string).visit(expr)
+    return result
 
 
 class IsSimpleTimestampFieldExpressionVisitor(Visitor[bool]):
@@ -538,6 +539,8 @@ def visit_placeholder(self, node: ast.Placeholder) -> bool:
     def visit_alias(self, node: ast.Alias) -> bool:
         from posthog.hogql.database.schema.events import EventsTable
         from posthog.hogql.database.schema.sessions_v1 import SessionsTableV1
+        from posthog.hogql.database.schema.sessions_v2 import SessionsTableV2
+
         from posthog.hogql.database.schema.session_replay_events import RawSessionReplayEventsTable
 
         if node.type and isinstance(node.type, ast.FieldAliasType):
@@ -562,6 +565,11 @@ def visit_alias(self, node: ast.Alias) -> bool:
                     and isinstance(table_type.table, SessionsTableV1)
                     and resolved_field.name == "$start_timestamp"
                 )
+                or (
+                    isinstance(table_type, ast.LazyTableType)
+                    and isinstance(table_type.table, SessionsTableV2)
+                    and resolved_field.name == "$start_timestamp"
+                )
                 or (
                     isinstance(table_type, ast.TableType)
                     and isinstance(table_type.table, RawSessionReplayEventsTable)
diff --git a/posthog/hogql/test/__snapshots__/test_query.ambr b/posthog/hogql/test/__snapshots__/test_query.ambr
index cab20c93492e5..af8a80d5ef1c8 100644
--- a/posthog/hogql/test/__snapshots__/test_query.ambr
+++ b/posthog/hogql/test/__snapshots__/test_query.ambr
@@ -107,7 +107,7 @@
   FROM (
   SELECT toString(reinterpretAsUUID(bitOr(bitShiftLeft(raw_sessions.session_id_v7, 64), bitShiftRight(raw_sessions.session_id_v7, 64)))) AS session_id, nullIf(nullIf(argMinMerge(raw_sessions.entry_url), %(hogql_val_0)s), %(hogql_val_1)s) AS `$entry_current_url`, min(toTimeZone(raw_sessions.min_timestamp, %(hogql_val_2)s)) AS `$start_timestamp`, raw_sessions.session_id_v7 AS session_id_v7 
   FROM raw_sessions 
-  WHERE equals(raw_sessions.team_id, 420) 
+  WHERE and(equals(raw_sessions.team_id, 420), ifNull(lessOrEquals(minus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), toDateTime64('2024-07-06 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(plus(fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(raw_sessions.session_id_v7, 80)), 1000)), toIntervalDay(3)), toDateTime64('2024-07-04 00:00:00.000000', 6, 'UTC')), 0)) 
   GROUP BY raw_sessions.session_id_v7, raw_sessions.session_id_v7) AS sessions 
   WHERE and(ifNull(less(sessions.`$start_timestamp`, toDateTime64('2024-07-06 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(sessions.`$start_timestamp`, toDateTime64('2024-07-04 00:00:00.000000', 6, 'UTC')), 0)) 
   LIMIT 100 
diff --git a/posthog/hogql/transforms/lazy_tables.py b/posthog/hogql/transforms/lazy_tables.py
index affb991d37316..aa0ccfada96e2 100644
--- a/posthog/hogql/transforms/lazy_tables.py
+++ b/posthog/hogql/transforms/lazy_tables.py
@@ -41,6 +41,17 @@ def visit_field(self, node: ast.Field):
                 node.chain = [constraint.table_name, constraint.alias]
 
 
+class FieldFinder(TraversingVisitor):
+    field_chains: list[list[str | int]] = []
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.field_chains = []
+
+    def visit_field(self, node: ast.Field):
+        self.field_chains.append(node.chain)
+
+
 class LazyFinder(TraversingVisitor):
     found_lazy: bool = False
     max_type_visits: int = 1
@@ -202,6 +213,7 @@ def visit_select_query(self, node: ast.SelectQuery):
                             lazy_join=table_type.lazy_join,
                             from_table=from_table,
                             to_table=to_table,
+                            lazy_join_type=table_type,
                         )
                     new_join = joins_to_add[to_table]
                     if table_type == field.table_type:
@@ -244,6 +256,7 @@ def visit_select_query(self, node: ast.SelectQuery):
                                 lazy_join=table_type.table_type.lazy_join,
                                 from_table=from_table,
                                 to_table=to_table,
+                                lazy_join_type=table_type.table_type,
                             )
                         new_join = joins_to_add[to_table]
                         if table_type == field.table_type:
@@ -366,14 +379,46 @@ def create_override(table_name: str, field_chain: list[str | int]) -> None:
             if join_to_add.type is not None:
                 select_type.tables[to_table] = join_to_add.type
 
+            field_chain_finder = FieldFinder()
+            field_chain_finder.visit(join_to_add.constraint)
+
+            select_from_alias: str | int | None = None
+            if node.select_from and node.select_from.alias:
+                select_from_alias = node.select_from.alias
+            else:
+                if node.select_from and node.select_from.table and isinstance(node.select_from.table, ast.Field):
+                    select_from_alias = node.select_from.table.chain[0]
+
+            # Store all the constraint tables we've seen for this join to decide where in the order of joins the next join should be added
+            constraint_tables: list[str | int] = []
+            for field_chain in field_chain_finder.field_chains:
+                if field_chain[0] == select_from_alias:
+                    continue
+
+                added = False
+                for constraint_table_join in joins_to_add.values():
+                    if field_chain[0] == constraint_table_join.lazy_join_type.field:
+                        constraint_tables.append(constraint_table_join.to_table)
+                        added = True
+                        break
+
+                if not added:
+                    constraint_tables.append(field_chain[0])
+
             join_ptr = node.select_from
             added = False
             while join_ptr:
                 if join_scope.from_table == join_ptr.alias or (
                     isinstance(join_ptr.table, ast.Field) and join_scope.from_table == join_ptr.table.chain[0]
                 ):
-                    join_to_add.next_join = join_ptr.next_join
-                    join_ptr.next_join = join_to_add
+                    # If the `join_to_add` is reliant on the existing `next_join`, then just append after instead of before
+                    if join_ptr.next_join and join_ptr.next_join.alias in constraint_tables:
+                        if join_ptr.next_join.next_join:
+                            join_to_add.next_join = join_ptr.next_join.next_join
+                        join_ptr.next_join.next_join = join_to_add
+                    else:
+                        join_to_add.next_join = join_ptr.next_join
+                        join_ptr.next_join = join_to_add
                     added = True
                     break
                 if join_ptr.next_join:
diff --git a/posthog/hogql/transforms/test/__snapshots__/test_lazy_tables.ambr b/posthog/hogql/transforms/test/__snapshots__/test_lazy_tables.ambr
index f21100141939e..e7635b7c529f1 100644
--- a/posthog/hogql/transforms/test/__snapshots__/test_lazy_tables.ambr
+++ b/posthog/hogql/transforms/test/__snapshots__/test_lazy_tables.ambr
@@ -93,19 +93,19 @@
   '''
   
   SELECT if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, events__person.properties AS properties 
-  FROM events LEFT JOIN (
-  SELECT argMax(person.properties, person.version) AS properties, person.id AS id 
-  FROM person 
-  WHERE equals(person.team_id, 420) 
-  GROUP BY person.id 
-  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, %(hogql_val_0)s), person.version), plus(now64(6, %(hogql_val_1)s), toIntervalDay(1))), 0)) 
-  SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id) LEFT OUTER JOIN (
+  FROM events LEFT OUTER JOIN (
   SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id 
   FROM person_distinct_id_overrides 
   WHERE equals(person_distinct_id_overrides.team_id, 420) 
   GROUP BY person_distinct_id_overrides.distinct_id 
   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) 
-  SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id) 
+  SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id) LEFT JOIN (
+  SELECT argMax(person.properties, person.version) AS properties, person.id AS id 
+  FROM person 
+  WHERE equals(person.team_id, 420) 
+  GROUP BY person.id 
+  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, %(hogql_val_0)s), person.version), plus(now64(6, %(hogql_val_1)s), toIntervalDay(1))), 0)) 
+  SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id) 
   WHERE equals(events.team_id, 420) 
   LIMIT 50000
   '''
diff --git a/posthog/hogql_queries/error_tracking_query_runner.py b/posthog/hogql_queries/error_tracking_query_runner.py
index fb85871753d02..30f3af1e14551 100644
--- a/posthog/hogql_queries/error_tracking_query_runner.py
+++ b/posthog/hogql_queries/error_tracking_query_runner.py
@@ -11,9 +11,6 @@
 from posthog.hogql.parser import parse_expr
 from posthog.models.error_tracking import ErrorTrackingGroup
 from posthog.models.filters.mixins.utils import cached_property
-from posthog.models.person.util import get_persons_by_distinct_ids
-from django.db.models import Prefetch
-from posthog.models import Person
 
 
 class ErrorTrackingQueryRunner(QueryRunner):
@@ -27,7 +24,6 @@ def __init__(self, *args, **kwargs):
         self.paginator = HogQLHasMorePaginator.from_limit_context(
             limit_context=LimitContext.QUERY,
             limit=self.query.limit if self.query.limit else None,
-            offset=self.query.offset if self.query.offset else None,
         )
 
     def to_query(self) -> ast.SelectQuery:
@@ -60,25 +56,6 @@ def select(self):
             ),
         ]
 
-        if self.query.eventColumns:
-            # replace person distinct_id that can be looked up in Postgres later
-            event_columns = ["distinct_id" if el == "person" else el for el in self.query.eventColumns]
-            args: list[ast.Expr] = [ast.Field(chain=[field]) for field in event_columns]
-            exprs.append(
-                ast.Alias(
-                    alias="events",
-                    expr=ast.Call(
-                        name="groupArray",
-                        args=[
-                            ast.Call(
-                                name="tuple",
-                                args=args,
-                            )
-                        ],
-                    ),
-                )
-            )
-
         if not self.query.fingerprint:
             exprs.append(self.fingerprint_grouping_expr)
 
@@ -187,52 +164,10 @@ def results(self, columns: list[str], query_results: list):
         for result_dict in mapped_results:
             fingerprint = self.query.fingerprint if self.query.fingerprint else result_dict["fingerprint"]
             group = self.group_or_default(fingerprint)
-
-            if self.query.eventColumns:
-                result_dict["events"] = self.parse_embedded_events_and_persons(
-                    self.query.eventColumns, result_dict.get("events", [])
-                )
-
             results.append(result_dict | group)
 
         return results
 
-    def parse_embedded_events_and_persons(self, columns: list[str], events: list):
-        person_indices: list[int] = []
-        for index, col in enumerate(columns):
-            if col == "person":
-                person_indices.append(index)
-
-        if len(person_indices) > 0 and len(events) > 0:
-            person_idx = person_indices[0]
-            distinct_ids = list({event[person_idx] for event in events})
-            persons = get_persons_by_distinct_ids(self.team.pk, distinct_ids)
-            persons = persons.prefetch_related(Prefetch("persondistinctid_set", to_attr="distinct_ids_cache"))
-            distinct_to_person: dict[str, Person] = {}
-            for person in persons:
-                if person:
-                    for person_distinct_id in person.distinct_ids:
-                        distinct_to_person[person_distinct_id] = person
-
-            for column_index in person_indices:
-                for index, result in enumerate(events):
-                    distinct_id: str = result[column_index]
-                    events[index] = list(result)
-                    if distinct_to_person.get(distinct_id):
-                        person = distinct_to_person[distinct_id]
-                        events[index][column_index] = {
-                            "uuid": person.uuid,
-                            "created_at": person.created_at,
-                            "properties": person.properties or {},
-                            "distinct_id": distinct_id,
-                        }
-                    else:
-                        events[index][column_index] = {
-                            "distinct_id": distinct_id,
-                        }
-
-        return [dict(zip(columns, value)) for value in events]
-
     @property
     def order_by(self):
         return (
diff --git a/posthog/hogql_queries/insights/funnels/test/test_funnel.py b/posthog/hogql_queries/insights/funnels/test/test_funnel.py
index 0a25bd220b7a4..77033100a5009 100644
--- a/posthog/hogql_queries/insights/funnels/test/test_funnel.py
+++ b/posthog/hogql_queries/insights/funnels/test/test_funnel.py
@@ -9,6 +9,7 @@
 from posthog.api.instance_settings import get_instance_setting
 from posthog.clickhouse.client.execute import sync_execute
 from posthog.constants import INSIGHT_FUNNELS, FunnelOrderType, FunnelVizType
+from posthog.hogql.modifiers import create_default_modifiers_for_team
 from posthog.hogql.query import execute_hogql_query
 from posthog.hogql_queries.actors_query_runner import ActorsQueryRunner
 from posthog.hogql_queries.insights.funnels import Funnel
@@ -41,7 +42,9 @@
     FunnelsActorsQuery,
     FunnelsFilter,
     FunnelsQuery,
+    HogQLQueryModifiers,
     InsightDateRange,
+    PersonsOnEventsMode,
     PropertyOperator,
 )
 from posthog.test.base import (
@@ -809,6 +812,56 @@ def test_basic_funnel_default_funnel_days(self):
             self.assertEqual(results[1]["name"], "paid")
             self.assertEqual(results[1]["count"], 1)
 
+        def test_basic_funnel_with_person_id_override_properties_joined_modifier_and_person_breakdown(self):
+            filters = {
+                "events": [
+                    {"id": "user signed up", "type": "events", "order": 0},
+                    {"id": "paid", "type": "events", "order": 1},
+                ],
+                "insight": INSIGHT_FUNNELS,
+                "date_from": "2020-01-01",
+                "date_to": "2020-01-14",
+                "breakdown": "$browser",
+                "breakdown_type": "person",
+            }
+
+            # event
+            _create_person(distinct_ids=["user_1"], team_id=self.team.pk)
+            _create_event(
+                team=self.team,
+                event="user signed up",
+                distinct_id="user_1",
+                timestamp="2020-01-02T14:00:00Z",
+            )
+            _create_event(
+                team=self.team,
+                event="paid",
+                distinct_id="user_1",
+                timestamp="2020-01-10T14:00:00Z",
+            )
+
+            query = cast(FunnelsQuery, filter_to_query(filters))
+            results = (
+                FunnelsQueryRunner(
+                    query=query,
+                    team=self.team,
+                    modifiers=create_default_modifiers_for_team(
+                        self.team,
+                        HogQLQueryModifiers(
+                            personsOnEventsMode=PersonsOnEventsMode.PERSON_ID_OVERRIDE_PROPERTIES_JOINED
+                        ),
+                    ),
+                )
+                .calculate()
+                .results
+            )
+
+            self.assertEqual(results[0][0]["name"], "user signed up")
+            self.assertEqual(results[0][0]["count"], 1)
+
+            self.assertEqual(results[0][1]["name"], "paid")
+            self.assertEqual(results[0][1]["count"], 1)
+
         def test_basic_funnel_with_repeat_steps(self):
             filters = {
                 "events": [
diff --git a/posthog/hogql_queries/test/test_error_tracking_query_runner.py b/posthog/hogql_queries/test/test_error_tracking_query_runner.py
index e140f26eb50e3..e220899796d5d 100644
--- a/posthog/hogql_queries/test/test_error_tracking_query_runner.py
+++ b/posthog/hogql_queries/test/test_error_tracking_query_runner.py
@@ -21,7 +21,6 @@
 from posthog.models import ErrorTrackingGroup
 from datetime import datetime
 from zoneinfo import ZoneInfo
-from posthog.models.person import Person
 
 
 class TestErrorTrackingQueryRunner(ClickhouseTestMixin, APIBaseTest):
@@ -143,68 +142,6 @@ def test_column_names(self):
             ],
         )
 
-        runner = ErrorTrackingQueryRunner(
-            team=self.team,
-            query=ErrorTrackingQuery(
-                kind="ErrorTrackingQuery",
-                fingerprint=["SyntaxError"],
-                eventColumns=["uuid", "distinct_id", "person"],
-                dateRange=DateRange(),
-                filterTestAccounts=True,
-            ),
-        )
-
-        result = self._calculate(runner)
-        columns = result["columns"]
-        # only adds the events column when fields are specificed in `eventColumns`
-        self.assertEqual(
-            columns,
-            ["occurrences", "sessions", "users", "last_seen", "first_seen", "description", "exception_type", "events"],
-        )
-
-    @snapshot_clickhouse_queries
-    def test_person_colum_expanded(self):
-        distinct_id = "person_id"
-        fingerprint = ["PersonError"]
-
-        person = Person.objects.create(
-            team_id=self.team.pk,
-            distinct_ids=[distinct_id],
-            properties={"$some_prop": "something", "$another_prop": "something"},
-        )
-
-        _create_event(
-            distinct_id=distinct_id,
-            event="$exception",
-            team=self.team,
-            properties={
-                "$exception_fingerprint": fingerprint,
-            },
-        )
-
-        runner = ErrorTrackingQueryRunner(
-            team=self.team,
-            query=ErrorTrackingQuery(
-                kind="ErrorTrackingQuery",
-                fingerprint=fingerprint,
-                eventColumns=["uuid", "distinct_id", "person"],
-                dateRange=DateRange(),
-                filterTestAccounts=True,
-            ),
-        )
-
-        results = self._calculate(runner)["results"]
-
-        self.assertEqual(
-            results[0]["events"][0]["person"],
-            {
-                "uuid": person.uuid,
-                "created_at": person.created_at,
-                "properties": person.properties,
-                "distinct_id": person.distinct_ids[0],
-            },
-        )
-
     @snapshot_clickhouse_queries
     def test_fingerprints(self):
         runner = ErrorTrackingQueryRunner(
@@ -295,7 +232,6 @@ def test_merges_and_defaults_groups(self):
                     "assignee": self.user.id,
                     "description": "this is the same error message",
                     "exception_type": "SyntaxError",
-                    "events": None,
                     "fingerprint": ["SyntaxError"],
                     "first_seen": datetime(2020, 1, 10, 12, 11, tzinfo=ZoneInfo("UTC")),
                     "last_seen": datetime(2020, 1, 10, 12, 11, tzinfo=ZoneInfo("UTC")),
@@ -311,7 +247,6 @@ def test_merges_and_defaults_groups(self):
                     "assignee": None,
                     "description": None,
                     "exception_type": "TypeError",
-                    "events": None,
                     "fingerprint": ["TypeError"],
                     "first_seen": datetime(2020, 1, 10, 12, 11, tzinfo=ZoneInfo("UTC")),
                     "last_seen": datetime(2020, 1, 10, 12, 11, tzinfo=ZoneInfo("UTC")),
diff --git a/posthog/migrations/0465_datawarehouse_stripe_account.py b/posthog/migrations/0465_datawarehouse_stripe_account.py
new file mode 100644
index 0000000000000..a28ec898fbf24
--- /dev/null
+++ b/posthog/migrations/0465_datawarehouse_stripe_account.py
@@ -0,0 +1,35 @@
+# Generated by Django 4.2.14 on 2024-08-12 12:04
+
+from django.db import connection, migrations
+
+
+def insert_stripe_account_schemas(apps, schema_editor):
+    with connection.cursor() as cursor:
+        cursor.execute("SELECT id, team_id FROM posthog_externaldatasource where source_type = 'Stripe'")
+        stripe_sources = cursor.fetchall()
+
+    ExternalDataSchema = apps.get_model("posthog", "ExternalDataSchema")
+    for source in stripe_sources:
+        schema = ExternalDataSchema.objects.create(
+            name="Account",
+            source_id=source[0],
+            team_id=source[1],
+            should_sync=False,
+            sync_type=None,
+            sync_type_config={},
+        )
+        schema.save()
+
+
+def reverse(apps, _):
+    pass
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("posthog", "0464_action_pinned_at"),
+    ]
+
+    operations = [
+        migrations.RunPython(insert_stripe_account_schemas, reverse),
+    ]
diff --git a/posthog/schema.py b/posthog/schema.py
index 557a1fb215f17..f99badf4c1c84 100644
--- a/posthog/schema.py
+++ b/posthog/schema.py
@@ -408,7 +408,6 @@ class ErrorTrackingGroup(BaseModel):
     )
     assignee: Optional[float] = None
     description: Optional[str] = None
-    events: Optional[list[dict[str, Any]]] = None
     exception_type: Optional[str] = None
     fingerprint: list[str]
     first_seen: AwareDatetime
@@ -4743,7 +4742,6 @@ class ErrorTrackingQuery(BaseModel):
     )
     assignee: Optional[int] = None
     dateRange: DateRange
-    eventColumns: Optional[list[str]] = None
     filterGroup: Optional[PropertyGroupFilter] = None
     filterTestAccounts: Optional[bool] = None
     fingerprint: Optional[list[str]] = None
@@ -4752,7 +4750,6 @@ class ErrorTrackingQuery(BaseModel):
     modifiers: Optional[HogQLQueryModifiers] = Field(
         default=None, description="Modifiers used when performing the query"
     )
-    offset: Optional[int] = None
     order: Optional[Order] = None
     response: Optional[ErrorTrackingQueryResponse] = None
     select: Optional[list[str]] = None
diff --git a/posthog/temporal/batch_exports/bigquery_batch_export.py b/posthog/temporal/batch_exports/bigquery_batch_export.py
index df8a1dfb5c387..3e80dd51bdf3d 100644
--- a/posthog/temporal/batch_exports/bigquery_batch_export.py
+++ b/posthog/temporal/batch_exports/bigquery_batch_export.py
@@ -205,6 +205,7 @@ async def amerge_person_tables(
         final_table: bigquery.Table,
         stage_table: bigquery.Table,
         merge_key: collections.abc.Iterable[bigquery.SchemaField],
+        update_fields: collections.abc.Iterable[bigquery.SchemaField] | None = None,
         person_version_key: str = "person_version",
         person_distinct_id_version_key: str = "person_distinct_id_version",
     ):
@@ -221,7 +222,13 @@ async def amerge_person_tables(
         update_clause = ""
         values = ""
         field_names = ""
-        for n, field in enumerate(final_table.schema):
+
+        if not update_fields:
+            update_clause_fields = final_table.schema
+        else:
+            update_clause_fields = update_fields
+
+        for n, field in enumerate(update_clause_fields):
             if n > 0:
                 update_clause += ", "
                 values += ", "
@@ -231,6 +238,9 @@ async def amerge_person_tables(
             field_names += f"`{field.name}`"
             values += f"stage.`{field.name}`"
 
+        if not update_clause:
+            raise ValueError("Empty update clause")
+
         merge_query = f"""
         MERGE `{final_table.full_table_id.replace(":", ".", 1)}` final
         USING `{stage_table.full_table_id.replace(":", ".", 1)}` stage
@@ -481,6 +491,7 @@ async def flush_to_bigquery(
                         final_table=bigquery_table,
                         stage_table=bigquery_stage_table,
                         merge_key=merge_key,
+                        update_fields=schema,
                     )
 
                 return writer.records_total
diff --git a/posthog/temporal/data_imports/pipelines/stripe/__init__.py b/posthog/temporal/data_imports/pipelines/stripe/__init__.py
index 5b2e6aa65d4c0..45bdd07562517 100644
--- a/posthog/temporal/data_imports/pipelines/stripe/__init__.py
+++ b/posthog/temporal/data_imports/pipelines/stripe/__init__.py
@@ -10,6 +10,41 @@
 
 def get_resource(name: str, is_incremental: bool) -> EndpointResource:
     resources: dict[str, EndpointResource] = {
+        "Account": {
+            "name": "Account",
+            "table_name": "account",
+            "primary_key": "id",
+            "write_disposition": {
+                "disposition": "merge",
+                "strategy": "upsert",
+            }
+            if is_incremental
+            else "replace",
+            "columns": get_dlt_mapping_for_external_table("stripe_account"),  # type: ignore
+            "endpoint": {
+                "data_selector": "data",
+                "path": "/v1/accounts",
+                "params": {
+                    # the parameters below can optionally be configured
+                    "created[gte]": {
+                        "type": "incremental",
+                        "cursor_path": "created",
+                        "initial_value": 0,  # type: ignore
+                    }
+                    if is_incremental
+                    else None,
+                    # "currency": "OPTIONAL_CONFIG",
+                    # "ending_before": "OPTIONAL_CONFIG",
+                    # "expand": "OPTIONAL_CONFIG",
+                    "limit": 100,
+                    # "payout": "OPTIONAL_CONFIG",
+                    # "source": "OPTIONAL_CONFIG",
+                    # "starting_after": "OPTIONAL_CONFIG",
+                    # "type": "OPTIONAL_CONFIG",
+                },
+            },
+            "table_format": "delta",
+        },
         "BalanceTransaction": {
             "name": "BalanceTransaction",
             "table_name": "balance_transaction",
diff --git a/posthog/temporal/data_imports/pipelines/stripe/settings.py b/posthog/temporal/data_imports/pipelines/stripe/settings.py
index 3eefb464967f0..7db8ea7dca2d8 100644
--- a/posthog/temporal/data_imports/pipelines/stripe/settings.py
+++ b/posthog/temporal/data_imports/pipelines/stripe/settings.py
@@ -12,6 +12,14 @@
 INCREMENTAL_ENDPOINTS = ("BalanceTransaction", "Subscription", "Customer", "Product", "Price", "Invoice", "Charge")
 
 INCREMENTAL_FIELDS: dict[str, list[IncrementalField]] = {
+    "Account": [
+        {
+            "label": "created_at",
+            "type": IncrementalFieldType.DateTime,
+            "field": "created",
+            "field_type": IncrementalFieldType.Integer,
+        }
+    ],
     "BalanceTransaction": [
         {
             "label": "created_at",
diff --git a/posthog/temporal/tests/batch_exports/test_bigquery_batch_export_workflow.py b/posthog/temporal/tests/batch_exports/test_bigquery_batch_export_workflow.py
index bfaffcc1b4cd2..0f184b79356a1 100644
--- a/posthog/temporal/tests/batch_exports/test_bigquery_batch_export_workflow.py
+++ b/posthog/temporal/tests/batch_exports/test_bigquery_batch_export_workflow.py
@@ -5,6 +5,7 @@
 import os
 import typing
 import uuid
+import warnings
 
 import pyarrow as pa
 import pytest
@@ -213,7 +214,12 @@ def bigquery_dataset(bigquery_config, bigquery_client) -> typing.Generator[bigqu
 
     yield dataset
 
-    # bigquery_client.delete_dataset(dataset_id, delete_contents=True, not_found_ok=True)
+    try:
+        bigquery_client.delete_dataset(dataset_id, delete_contents=True, not_found_ok=True)
+    except Exception as exc:
+        warnings.warn(
+            f"Failed to clean up dataset: {dataset_id} due to '{exc.__class__.__name__}': {str(exc)}", stacklevel=1
+        )
 
 
 @pytest.fixture
diff --git a/posthog/temporal/tests/data_imports/test_end_to_end.py b/posthog/temporal/tests/data_imports/test_end_to_end.py
index 6ce2ef6e83e02..0292fe2d83f52 100644
--- a/posthog/temporal/tests/data_imports/test_end_to_end.py
+++ b/posthog/temporal/tests/data_imports/test_end_to_end.py
@@ -9,8 +9,19 @@
 import pytest
 import pytest_asyncio
 import psycopg
+from posthog.hogql.modifiers import create_default_modifiers_for_team
 from posthog.hogql.query import execute_hogql_query
+from posthog.hogql_queries.insights.funnels.funnel import Funnel
+from posthog.hogql_queries.insights.funnels.funnel_query_context import FunnelQueryContext
 from posthog.models.team.team import Team
+from posthog.schema import (
+    BreakdownFilter,
+    BreakdownType,
+    EventsNode,
+    FunnelsQuery,
+    HogQLQueryModifiers,
+    PersonsOnEventsMode,
+)
 from posthog.temporal.data_imports import ACTIVITIES
 from posthog.temporal.data_imports.external_data_job import ExternalDataJobWorkflow
 from posthog.temporal.utils import ExternalDataWorkflowInputs
@@ -28,6 +39,8 @@
 from dlt.sources.helpers.rest_client.client import RESTClient
 from dlt.common.configuration.specs.aws_credentials import AwsCredentials
 
+from posthog.warehouse.models.join import DataWarehouseJoin
+
 
 BUCKET_NAME = "test-pipeline"
 SESSION = aioboto3.Session()
@@ -571,6 +584,47 @@ def get_jobs():
     assert len(s3_objects["Contents"]) != 0
 
 
+@pytest.mark.django_db(transaction=True)
+@pytest.mark.asyncio
+async def test_funnels_lazy_joins_ordering(team, stripe_customer):
+    # Tests that funnels work in PERSON_ID_OVERRIDE_PROPERTIES_JOINED PoE mode when using extended person properties
+    await _run(
+        team=team,
+        schema_name="Customer",
+        table_name="stripe_customer",
+        source_type="Stripe",
+        job_inputs={"stripe_secret_key": "test-key", "stripe_account_id": "acct_id"},
+        mock_data_response=stripe_customer["data"],
+    )
+
+    await sync_to_async(DataWarehouseJoin.objects.create)(
+        team=team,
+        source_table_name="persons",
+        source_table_key="properties.email",
+        joining_table_name="stripe_customer",
+        joining_table_key="email",
+        field_name="stripe_customer",
+    )
+
+    query = FunnelsQuery(
+        series=[EventsNode(), EventsNode()],
+        breakdownFilter=BreakdownFilter(
+            breakdown_type=BreakdownType.DATA_WAREHOUSE_PERSON_PROPERTY, breakdown="stripe_customer.email"
+        ),
+    )
+    funnel_class = Funnel(context=FunnelQueryContext(query=query, team=team))
+
+    query_ast = funnel_class.get_query()
+    await sync_to_async(execute_hogql_query)(
+        query_type="FunnelsQuery",
+        query=query_ast,
+        team=team,
+        modifiers=create_default_modifiers_for_team(
+            team, HogQLQueryModifiers(personsOnEventsMode=PersonsOnEventsMode.PERSON_ID_OVERRIDE_PROPERTIES_JOINED)
+        ),
+    )
+
+
 @pytest.mark.django_db(transaction=True)
 @pytest.mark.asyncio
 async def test_postgres_schema_evolution(team, postgres_config, postgres_connection):
diff --git a/posthog/warehouse/models/external_table_definitions.py b/posthog/warehouse/models/external_table_definitions.py
index 0d8e49fa4dca7..477e1a6d609a9 100644
--- a/posthog/warehouse/models/external_table_definitions.py
+++ b/posthog/warehouse/models/external_table_definitions.py
@@ -17,6 +17,42 @@
         "__dlt_id": StringDatabaseField(name="_dlt_id", hidden=True),
         "__dlt_load_id": StringDatabaseField(name="_dlt_load_id", hidden=True),
     },
+    "stripe_account": {
+        "id": StringDatabaseField(name="id"),
+        "object": StringDatabaseField(name="object"),
+        "business_profile": StringJSONDatabaseField(name="business_profile"),
+        "business_type": StringDatabaseField(name="business_type"),
+        "capabilities": StringJSONDatabaseField(name="capabilities"),
+        "charges_enabled": BooleanDatabaseField(name="charges_enabled"),
+        "controller": StringJSONDatabaseField(name="controller"),
+        "country": StringDatabaseField(name="country"),
+        "__created": IntegerDatabaseField(name="created", hidden=True),
+        "created_at": ast.ExpressionField(
+            isolate_scope=True,
+            expr=ast.Call(
+                name="toDateTime",
+                args=[
+                    ast.Call(
+                        name="toString",
+                        args=[ast.Call(name="fromUnixTimestamp", args=[ast.Field(chain=["__created"])])],
+                    )
+                ],
+            ),
+            name="created_at",
+        ),
+        "default_currency": StringDatabaseField(name="default_currency"),
+        "details_submitted": BooleanDatabaseField(name="details_submitted"),
+        "email": StringDatabaseField(name="email"),
+        "external_accounts": StringJSONDatabaseField(name="external_accounts"),
+        "future_requirements": StringJSONDatabaseField(name="future_requirements"),
+        "login_links": StringJSONDatabaseField(name="login_links"),
+        "metadata": StringJSONDatabaseField(name="metadata"),
+        "payouts_enabled": BooleanDatabaseField(name="payouts_enabled"),
+        "requirements": StringJSONDatabaseField(name="requirements"),
+        "settings": StringJSONDatabaseField(name="settings"),
+        "tos_acceptance": StringJSONDatabaseField(name="tos_acceptance"),
+        "type": StringDatabaseField(name="type"),
+    },
     "stripe_customer": {
         "id": StringDatabaseField(name="id"),
         "name": StringDatabaseField(name="name"),
diff --git a/rust/.sqlx/query-16d533b5a15b0b9926a181f578b5b577efe424710b45f02e1ddeece8bca96f87.json b/rust/.sqlx/query-16d533b5a15b0b9926a181f578b5b577efe424710b45f02e1ddeece8bca96f87.json
index 7a3a8b98d9da5..23b0665a2d357 100644
--- a/rust/.sqlx/query-16d533b5a15b0b9926a181f578b5b577efe424710b45f02e1ddeece8bca96f87.json
+++ b/rust/.sqlx/query-16d533b5a15b0b9926a181f578b5b577efe424710b45f02e1ddeece8bca96f87.json
@@ -4,7 +4,7 @@
     "describe": {
         "columns": [],
         "parameters": {
-            "Left": ["Text", "Uuid", "Uuid"]
+            "Left": ["Bytea", "Uuid", "Uuid"]
         },
         "nullable": []
     },
diff --git a/rust/.sqlx/query-350983ef271029734aff70eb7e298bfe578ecaa8678268863bce917ced9d5d46.json b/rust/.sqlx/query-229c28c25aec24180c29e6ed636c165376f43116b85921c62b36b1b8e85562b0.json
similarity index 87%
rename from rust/.sqlx/query-350983ef271029734aff70eb7e298bfe578ecaa8678268863bce917ced9d5d46.json
rename to rust/.sqlx/query-229c28c25aec24180c29e6ed636c165376f43116b85921c62b36b1b8e85562b0.json
index d3a54ba7ef247..ffda6f4b70b26 100644
--- a/rust/.sqlx/query-350983ef271029734aff70eb7e298bfe578ecaa8678268863bce917ced9d5d46.json
+++ b/rust/.sqlx/query-229c28c25aec24180c29e6ed636c165376f43116b85921c62b36b1b8e85562b0.json
@@ -1,6 +1,6 @@
 {
     "db_name": "PostgreSQL",
-    "query": "\nWITH available AS (\n    SELECT\n        id,\n        state\n    FROM cyclotron_jobs\n    WHERE\n        state = 'available'::JobState\n        AND queue_name = $1\n        AND scheduled <= NOW()\n    ORDER BY\n        priority ASC,\n        scheduled ASC\n    LIMIT $2\n    FOR UPDATE SKIP LOCKED\n)\nUPDATE cyclotron_jobs\nSET\n    state = 'running'::JobState,\n    lock_id = $3,\n    last_heartbeat = NOW(),\n    last_transition = NOW(),\n    transition_count = transition_count + 1\nFROM available\nWHERE\n    cyclotron_jobs.id = available.id\nRETURNING\n    cyclotron_jobs.id,\n    team_id,\n    available.state as \"state: JobState\",\n    queue_name,\n    priority,\n    function_id,\n    created,\n    last_transition,\n    scheduled,\n    transition_count,\n    NULL as vm_state,\n    metadata,\n    parameters,\n    lock_id,\n    last_heartbeat,\n    janitor_touch_count\n    ",
+    "query": "\nWITH available AS (\n    SELECT\n        id,\n        state\n    FROM cyclotron_jobs\n    WHERE\n        state = 'available'::JobState\n        AND queue_name = $1\n        AND scheduled <= NOW()\n    ORDER BY\n        priority ASC,\n        scheduled ASC\n    LIMIT $2\n    FOR UPDATE SKIP LOCKED\n)\nUPDATE cyclotron_jobs\nSET\n    state = 'running'::JobState,\n    lock_id = $3,\n    last_heartbeat = NOW(),\n    last_transition = NOW(),\n    transition_count = transition_count + 1\nFROM available\nWHERE\n    cyclotron_jobs.id = available.id\nRETURNING\n    cyclotron_jobs.id,\n    team_id,\n    available.state as \"state: JobState\",\n    queue_name,\n    priority,\n    function_id,\n    created,\n    last_transition,\n    scheduled,\n    transition_count,\n    NULL::bytea as vm_state,\n    metadata,\n    parameters,\n    blob,\n    lock_id,\n    last_heartbeat,\n    janitor_touch_count\n    ",
     "describe": {
         "columns": [
             {
@@ -63,30 +63,35 @@
             {
                 "ordinal": 10,
                 "name": "vm_state",
-                "type_info": "Text"
+                "type_info": "Bytea"
             },
             {
                 "ordinal": 11,
                 "name": "metadata",
-                "type_info": "Text"
+                "type_info": "Bytea"
             },
             {
                 "ordinal": 12,
                 "name": "parameters",
-                "type_info": "Text"
+                "type_info": "Bytea"
             },
             {
                 "ordinal": 13,
+                "name": "blob",
+                "type_info": "Bytea"
+            },
+            {
+                "ordinal": 14,
                 "name": "lock_id",
                 "type_info": "Uuid"
             },
             {
-                "ordinal": 14,
+                "ordinal": 15,
                 "name": "last_heartbeat",
                 "type_info": "Timestamptz"
             },
             {
-                "ordinal": 15,
+                "ordinal": 16,
                 "name": "janitor_touch_count",
                 "type_info": "Int2"
             }
@@ -110,8 +115,9 @@
             true,
             true,
             true,
+            true,
             false
         ]
     },
-    "hash": "350983ef271029734aff70eb7e298bfe578ecaa8678268863bce917ced9d5d46"
+    "hash": "229c28c25aec24180c29e6ed636c165376f43116b85921c62b36b1b8e85562b0"
 }
diff --git a/rust/.sqlx/query-42e393046a686e6a69daa920dc2ab521aa6f393027c399a0c40139f5f8a0a45e.json b/rust/.sqlx/query-42e393046a686e6a69daa920dc2ab521aa6f393027c399a0c40139f5f8a0a45e.json
new file mode 100644
index 0000000000000..aa1ff7e7cf3e1
--- /dev/null
+++ b/rust/.sqlx/query-42e393046a686e6a69daa920dc2ab521aa6f393027c399a0c40139f5f8a0a45e.json
@@ -0,0 +1,12 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "INSERT INTO posthog_eventproperty (event, property, team_id) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING",
+    "describe": {
+        "columns": [],
+        "parameters": {
+            "Left": ["Varchar", "Varchar", "Int4"]
+        },
+        "nullable": []
+    },
+    "hash": "42e393046a686e6a69daa920dc2ab521aa6f393027c399a0c40139f5f8a0a45e"
+}
diff --git a/rust/.sqlx/query-58dfd4671ac3497614b184384ac7f8d490dda8b27a150454e413d02f89c92050.json b/rust/.sqlx/query-58dfd4671ac3497614b184384ac7f8d490dda8b27a150454e413d02f89c92050.json
new file mode 100644
index 0000000000000..5a2231c7c2fdd
--- /dev/null
+++ b/rust/.sqlx/query-58dfd4671ac3497614b184384ac7f8d490dda8b27a150454e413d02f89c92050.json
@@ -0,0 +1,12 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "UPDATE cyclotron_jobs SET blob = $1 WHERE id = $2 AND lock_id = $3",
+    "describe": {
+        "columns": [],
+        "parameters": {
+            "Left": ["Bytea", "Uuid", "Uuid"]
+        },
+        "nullable": []
+    },
+    "hash": "58dfd4671ac3497614b184384ac7f8d490dda8b27a150454e413d02f89c92050"
+}
diff --git a/rust/.sqlx/query-8ab11a89bc4720985e130c58021f46045c332cc45e69b08708b289cc933b3b5c.json b/rust/.sqlx/query-8ab11a89bc4720985e130c58021f46045c332cc45e69b08708b289cc933b3b5c.json
index 8c3a3dbde8b62..66ae665232405 100644
--- a/rust/.sqlx/query-8ab11a89bc4720985e130c58021f46045c332cc45e69b08708b289cc933b3b5c.json
+++ b/rust/.sqlx/query-8ab11a89bc4720985e130c58021f46045c332cc45e69b08708b289cc933b3b5c.json
@@ -4,7 +4,7 @@
     "describe": {
         "columns": [],
         "parameters": {
-            "Left": ["Text", "Uuid", "Uuid"]
+            "Left": ["Bytea", "Uuid", "Uuid"]
         },
         "nullable": []
     },
diff --git a/rust/.sqlx/query-917e3d14c15558a1e0bb1d7015ed687eb545ee9d4ccbb8b69c958a357d49f687.json b/rust/.sqlx/query-917e3d14c15558a1e0bb1d7015ed687eb545ee9d4ccbb8b69c958a357d49f687.json
new file mode 100644
index 0000000000000..188cd0be38966
--- /dev/null
+++ b/rust/.sqlx/query-917e3d14c15558a1e0bb1d7015ed687eb545ee9d4ccbb8b69c958a357d49f687.json
@@ -0,0 +1,12 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "\n            INSERT INTO posthog_eventdefinition (id, name, volume_30_day, query_usage_30_day, team_id, last_seen_at, created_at)\n            VALUES ($1, $2, NULL, NULL, $3, $4, NOW()) ON CONFLICT\n            ON CONSTRAINT posthog_eventdefinition_team_id_name_80fa0b87_uniq\n            DO UPDATE SET last_seen_at = $4\n        ",
+    "describe": {
+        "columns": [],
+        "parameters": {
+            "Left": ["Uuid", "Varchar", "Int4", "Timestamptz"]
+        },
+        "nullable": []
+    },
+    "hash": "917e3d14c15558a1e0bb1d7015ed687eb545ee9d4ccbb8b69c958a357d49f687"
+}
diff --git a/rust/.sqlx/query-aa595eaf28c1f4b872c278be407b59cc00f3125413f4032ac3647a6b5ee1a632.json b/rust/.sqlx/query-aa595eaf28c1f4b872c278be407b59cc00f3125413f4032ac3647a6b5ee1a632.json
index bd8a7cdd90282..51fb1b018120b 100644
--- a/rust/.sqlx/query-aa595eaf28c1f4b872c278be407b59cc00f3125413f4032ac3647a6b5ee1a632.json
+++ b/rust/.sqlx/query-aa595eaf28c1f4b872c278be407b59cc00f3125413f4032ac3647a6b5ee1a632.json
@@ -6,7 +6,7 @@
             {
                 "ordinal": 0,
                 "name": "vm_state",
-                "type_info": "Text"
+                "type_info": "Bytea"
             }
         ],
         "parameters": {
diff --git a/rust/.sqlx/query-b160b785a0377b854341105e99e4ef7a5da523e168a5f9be47f6caaef09487d7.json b/rust/.sqlx/query-b160b785a0377b854341105e99e4ef7a5da523e168a5f9be47f6caaef09487d7.json
index ea9c7f8fceb06..4364f2fee8816 100644
--- a/rust/.sqlx/query-b160b785a0377b854341105e99e4ef7a5da523e168a5f9be47f6caaef09487d7.json
+++ b/rust/.sqlx/query-b160b785a0377b854341105e99e4ef7a5da523e168a5f9be47f6caaef09487d7.json
@@ -4,7 +4,7 @@
     "describe": {
         "columns": [],
         "parameters": {
-            "Left": ["Text", "Uuid", "Uuid"]
+            "Left": ["Bytea", "Uuid", "Uuid"]
         },
         "nullable": []
     },
diff --git a/rust/.sqlx/query-c6ff00fcbbc77c8f5c1b3fe2f3352ea79485e403b9e17b6c37259ea0612065ee.json b/rust/.sqlx/query-c6ff00fcbbc77c8f5c1b3fe2f3352ea79485e403b9e17b6c37259ea0612065ee.json
new file mode 100644
index 0000000000000..f6ad8e4e89247
--- /dev/null
+++ b/rust/.sqlx/query-c6ff00fcbbc77c8f5c1b3fe2f3352ea79485e403b9e17b6c37259ea0612065ee.json
@@ -0,0 +1,18 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "SELECT group_type_index FROM posthog_grouptypemapping WHERE group_type = $1 AND team_id = $2",
+    "describe": {
+        "columns": [
+            {
+                "ordinal": 0,
+                "name": "group_type_index",
+                "type_info": "Int4"
+            }
+        ],
+        "parameters": {
+            "Left": ["Text", "Int4"]
+        },
+        "nullable": [false]
+    },
+    "hash": "c6ff00fcbbc77c8f5c1b3fe2f3352ea79485e403b9e17b6c37259ea0612065ee"
+}
diff --git a/rust/.sqlx/query-c624261597b9356ff3e7c3e392a84bb0b551e91c503e8b21c29814f1eb660a8e.json b/rust/.sqlx/query-ce036f16a37a41b9dc5a164de0b52345454cd3323568c4bef5b8480380287068.json
similarity index 89%
rename from rust/.sqlx/query-c624261597b9356ff3e7c3e392a84bb0b551e91c503e8b21c29814f1eb660a8e.json
rename to rust/.sqlx/query-ce036f16a37a41b9dc5a164de0b52345454cd3323568c4bef5b8480380287068.json
index b94965873e7d6..fe174820c3a07 100644
--- a/rust/.sqlx/query-c624261597b9356ff3e7c3e392a84bb0b551e91c503e8b21c29814f1eb660a8e.json
+++ b/rust/.sqlx/query-ce036f16a37a41b9dc5a164de0b52345454cd3323568c4bef5b8480380287068.json
@@ -1,6 +1,6 @@
 {
     "db_name": "PostgreSQL",
-    "query": "\nWITH available AS (\n    SELECT\n        id,\n        state\n    FROM cyclotron_jobs\n    WHERE\n        state = 'available'::JobState\n        AND queue_name = $1\n        AND scheduled <= NOW()\n    ORDER BY\n        priority ASC,\n        scheduled ASC\n    LIMIT $2\n    FOR UPDATE SKIP LOCKED\n)\nUPDATE cyclotron_jobs\nSET\n    state = 'running'::JobState,\n    lock_id = $3,\n    last_heartbeat = NOW(),\n    last_transition = NOW(),\n    transition_count = transition_count + 1\nFROM available\nWHERE\n    cyclotron_jobs.id = available.id\nRETURNING\n    cyclotron_jobs.id,\n    team_id,\n    available.state as \"state: JobState\",\n    queue_name,\n    priority,\n    function_id,\n    created,\n    last_transition,\n    scheduled,\n    transition_count,\n    vm_state,\n    metadata,\n    parameters,\n    lock_id,\n    last_heartbeat,\n    janitor_touch_count\n    ",
+    "query": "\nWITH available AS (\n    SELECT\n        id,\n        state\n    FROM cyclotron_jobs\n    WHERE\n        state = 'available'::JobState\n        AND queue_name = $1\n        AND scheduled <= NOW()\n    ORDER BY\n        priority ASC,\n        scheduled ASC\n    LIMIT $2\n    FOR UPDATE SKIP LOCKED\n)\nUPDATE cyclotron_jobs\nSET\n    state = 'running'::JobState,\n    lock_id = $3,\n    last_heartbeat = NOW(),\n    last_transition = NOW(),\n    transition_count = transition_count + 1\nFROM available\nWHERE\n    cyclotron_jobs.id = available.id\nRETURNING\n    cyclotron_jobs.id,\n    team_id,\n    available.state as \"state: JobState\",\n    queue_name,\n    priority,\n    function_id,\n    created,\n    last_transition,\n    scheduled,\n    transition_count,\n    vm_state,\n    metadata,\n    parameters,\n    blob,\n    lock_id,\n    last_heartbeat,\n    janitor_touch_count\n    ",
     "describe": {
         "columns": [
             {
@@ -63,30 +63,35 @@
             {
                 "ordinal": 10,
                 "name": "vm_state",
-                "type_info": "Text"
+                "type_info": "Bytea"
             },
             {
                 "ordinal": 11,
                 "name": "metadata",
-                "type_info": "Text"
+                "type_info": "Bytea"
             },
             {
                 "ordinal": 12,
                 "name": "parameters",
-                "type_info": "Text"
+                "type_info": "Bytea"
             },
             {
                 "ordinal": 13,
+                "name": "blob",
+                "type_info": "Bytea"
+            },
+            {
+                "ordinal": 14,
                 "name": "lock_id",
                 "type_info": "Uuid"
             },
             {
-                "ordinal": 14,
+                "ordinal": 15,
                 "name": "last_heartbeat",
                 "type_info": "Timestamptz"
             },
             {
-                "ordinal": 15,
+                "ordinal": 16,
                 "name": "janitor_touch_count",
                 "type_info": "Int2"
             }
@@ -110,8 +115,9 @@
             true,
             true,
             true,
+            true,
             false
         ]
     },
-    "hash": "c624261597b9356ff3e7c3e392a84bb0b551e91c503e8b21c29814f1eb660a8e"
+    "hash": "ce036f16a37a41b9dc5a164de0b52345454cd3323568c4bef5b8480380287068"
 }
diff --git a/rust/.sqlx/query-eecef0ce664dfe65dff4452d92a29c948a291ea8218bbbb4e25cd1ad36dbe9f4.json b/rust/.sqlx/query-eecef0ce664dfe65dff4452d92a29c948a291ea8218bbbb4e25cd1ad36dbe9f4.json
new file mode 100644
index 0000000000000..78ca221cb2f49
--- /dev/null
+++ b/rust/.sqlx/query-eecef0ce664dfe65dff4452d92a29c948a291ea8218bbbb4e25cd1ad36dbe9f4.json
@@ -0,0 +1,12 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "\n            INSERT INTO posthog_propertydefinition (id, name, type, group_type_index, is_numerical, volume_30_day, query_usage_30_day, team_id, property_type)\n            VALUES ($1, $2, $3, $4, $5, NULL, NULL, $6, $7)\n            ON CONFLICT (team_id, name, type, coalesce(group_type_index, -1))\n            DO UPDATE SET property_type=EXCLUDED.property_type WHERE posthog_propertydefinition.property_type IS NULL\n        ",
+    "describe": {
+        "columns": [],
+        "parameters": {
+            "Left": ["Uuid", "Varchar", "Int2", "Int2", "Bool", "Int4", "Varchar"]
+        },
+        "nullable": []
+    },
+    "hash": "eecef0ce664dfe65dff4452d92a29c948a291ea8218bbbb4e25cd1ad36dbe9f4"
+}
diff --git a/rust/.sqlx/query-7217e766aeb53298238222c0c71a2ce446cac731845c53cb926fc47ace708dd6.json b/rust/.sqlx/query-f074766d1fc32df17f92667f412af30c682288988fc6f102e8a063be97c3e51c.json
similarity index 72%
rename from rust/.sqlx/query-7217e766aeb53298238222c0c71a2ce446cac731845c53cb926fc47ace708dd6.json
rename to rust/.sqlx/query-f074766d1fc32df17f92667f412af30c682288988fc6f102e8a063be97c3e51c.json
index 230374e98d610..6139be53026c1 100644
--- a/rust/.sqlx/query-7217e766aeb53298238222c0c71a2ce446cac731845c53cb926fc47ace708dd6.json
+++ b/rust/.sqlx/query-f074766d1fc32df17f92667f412af30c682288988fc6f102e8a063be97c3e51c.json
@@ -1,6 +1,6 @@
 {
     "db_name": "PostgreSQL",
-    "query": "\nINSERT INTO cyclotron_jobs\n    (\n        id,\n        team_id,\n        function_id,\n        created,\n        lock_id,\n        last_heartbeat,\n        janitor_touch_count,\n        transition_count,\n        last_transition,\n        queue_name,\n        state,\n        scheduled,\n        priority,\n        vm_state,\n        metadata,\n        parameters\n    )\nVALUES\n    ($1, $2, $3, NOW(), NULL, NULL, 0, 0, NOW(), $4, $5, $6, $7, $8, $9, $10)\n    ",
+    "query": "\nINSERT INTO cyclotron_jobs\n    (\n        id,\n        team_id,\n        function_id,\n        created,\n        lock_id,\n        last_heartbeat,\n        janitor_touch_count,\n        transition_count,\n        last_transition,\n        queue_name,\n        state,\n        scheduled,\n        priority,\n        vm_state,\n        metadata,\n        parameters,\n        blob\n    )\nVALUES\n    ($1, $2, $3, NOW(), NULL, NULL, 0, 0, NOW(), $4, $5, $6, $7, $8, $9, $10, $11)\n    ",
     "describe": {
         "columns": [],
         "parameters": {
@@ -19,12 +19,13 @@
                 },
                 "Timestamptz",
                 "Int2",
-                "Text",
-                "Text",
-                "Text"
+                "Bytea",
+                "Bytea",
+                "Bytea",
+                "Bytea"
             ]
         },
         "nullable": []
     },
-    "hash": "7217e766aeb53298238222c0c71a2ce446cac731845c53cb926fc47ace708dd6"
+    "hash": "f074766d1fc32df17f92667f412af30c682288988fc6f102e8a063be97c3e51c"
 }
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 8dc04e80b75b7..55c64258d5ec2 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -711,6 +711,23 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "common-kafka"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "envconfig",
+ "futures",
+ "health",
+ "rdkafka",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "time",
+ "tracing",
+ "uuid",
+]
+
 [[package]]
 name = "common-metrics"
 version = "0.1.0"
@@ -861,6 +878,7 @@ dependencies = [
  "axum 0.7.5",
  "chrono",
  "common-dns",
+ "common-kafka",
  "common-metrics",
  "cyclotron-core",
  "envconfig",
@@ -869,11 +887,13 @@ dependencies = [
  "http 1.1.0",
  "httpmock",
  "rand",
+ "rdkafka",
  "reqwest 0.12.3",
  "serde",
  "serde_json",
  "sqlx",
  "thiserror",
+ "time",
  "tokio",
  "tracing",
  "tracing-subscriber",
@@ -886,12 +906,16 @@ version = "0.1.0"
 dependencies = [
  "axum 0.7.5",
  "chrono",
+ "common-kafka",
  "common-metrics",
  "cyclotron-core",
  "envconfig",
  "eyre",
  "health",
+ "rdkafka",
+ "serde_json",
  "sqlx",
+ "time",
  "tokio",
  "tracing",
  "tracing-subscriber",
@@ -1585,10 +1609,8 @@ version = "0.1.0"
 dependencies = [
  "async-trait",
  "chrono",
- "envconfig",
- "health",
+ "common-kafka",
  "http 1.1.0",
- "rdkafka",
  "reqwest 0.12.3",
  "serde",
  "serde_json",
@@ -1597,7 +1619,6 @@ dependencies = [
  "time",
  "tokio",
  "tracing",
- "uuid",
 ]
 
 [[package]]
@@ -1606,6 +1627,7 @@ version = "0.1.0"
 dependencies = [
  "async-trait",
  "axum 0.7.5",
+ "common-kafka",
  "common-metrics",
  "envconfig",
  "eyre",
@@ -1631,6 +1653,7 @@ dependencies = [
  "axum 0.7.5",
  "chrono",
  "common-dns",
+ "common-kafka",
  "common-metrics",
  "envconfig",
  "futures",
@@ -2839,6 +2862,7 @@ dependencies = [
  "tokio",
  "tracing",
  "tracing-subscriber",
+ "uuid",
 ]
 
 [[package]]
diff --git a/rust/capture/src/config.rs b/rust/capture/src/config.rs
index 0a659e9ea18f6..ae502e5f20b8d 100644
--- a/rust/capture/src/config.rs
+++ b/rust/capture/src/config.rs
@@ -89,4 +89,8 @@ pub struct KafkaConfig {
     pub kafka_tls: bool,
     #[envconfig(default = "")]
     pub kafka_client_id: String,
+    #[envconfig(default = "60000")]
+    pub kafka_metadata_max_age_ms: u32,
+    #[envconfig(default = "2")]
+    pub kafka_producer_max_retries: u32,
 }
diff --git a/rust/capture/src/sinks/kafka.rs b/rust/capture/src/sinks/kafka.rs
index 2e008a900ccd6..b1d5171390347 100644
--- a/rust/capture/src/sinks/kafka.rs
+++ b/rust/capture/src/sinks/kafka.rs
@@ -129,6 +129,14 @@ impl KafkaSink {
             .set("bootstrap.servers", &config.kafka_hosts)
             .set("statistics.interval.ms", "10000")
             .set("partitioner", "murmur2_random") // Compatibility with python-kafka
+            .set(
+                "metadata.max.age.ms",
+                config.kafka_metadata_max_age_ms.to_string(),
+            )
+            .set(
+                "message.send.max.retries",
+                config.kafka_producer_max_retries.to_string(),
+            )
             .set("linger.ms", config.kafka_producer_linger_ms.to_string())
             .set(
                 "message.max.bytes",
@@ -371,6 +379,8 @@ mod tests {
             kafka_heatmaps_topic: "events_plugin_ingestion".to_string(),
             kafka_tls: false,
             kafka_client_id: "".to_string(),
+            kafka_metadata_max_age_ms: 60000,
+            kafka_producer_max_retries: 2,
         };
         let sink = KafkaSink::new(config, handle, limiter).expect("failed to create sink");
         (cluster, sink)
diff --git a/rust/capture/tests/common.rs b/rust/capture/tests/common.rs
index fe7e5bb9d8ccc..e9b636ac9a735 100644
--- a/rust/capture/tests/common.rs
+++ b/rust/capture/tests/common.rs
@@ -51,6 +51,8 @@ pub static DEFAULT_CONFIG: Lazy<Config> = Lazy::new(|| Config {
         kafka_heatmaps_topic: "events_plugin_ingestion".to_string(),
         kafka_tls: false,
         kafka_client_id: "".to_string(),
+        kafka_metadata_max_age_ms: 60000,
+        kafka_producer_max_retries: 2,
     },
     otel_url: None,
     otel_sampling_rate: 0.0,
diff --git a/rust/common/kafka/Cargo.toml b/rust/common/kafka/Cargo.toml
new file mode 100644
index 0000000000000..715e7bc04265a
--- /dev/null
+++ b/rust/common/kafka/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "common-kafka"
+version = "0.1.0"
+edition = "2021"
+
+[lints]
+workspace = true
+
+[dependencies]
+chrono = { workspace = true }
+envconfig = { workspace = true }
+health = { path = "../health" }
+rdkafka = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+time = { workspace = true }
+tracing = { workspace = true }
+uuid = { workspace = true }
+thiserror = { workspace = true }
+futures = { workspace = true }
diff --git a/rust/hook-common/src/config.rs b/rust/common/kafka/src/config.rs
similarity index 100%
rename from rust/hook-common/src/config.rs
rename to rust/common/kafka/src/config.rs
diff --git a/rust/hook-common/src/kafka_messages/app_metrics.rs b/rust/common/kafka/src/kafka_messages/app_metrics.rs
similarity index 100%
rename from rust/hook-common/src/kafka_messages/app_metrics.rs
rename to rust/common/kafka/src/kafka_messages/app_metrics.rs
diff --git a/rust/hook-common/src/kafka_messages/app_metrics2.rs b/rust/common/kafka/src/kafka_messages/app_metrics2.rs
similarity index 98%
rename from rust/hook-common/src/kafka_messages/app_metrics2.rs
rename to rust/common/kafka/src/kafka_messages/app_metrics2.rs
index 3c2510fb010c0..db69513231ae7 100644
--- a/rust/hook-common/src/kafka_messages/app_metrics2.rs
+++ b/rust/common/kafka/src/kafka_messages/app_metrics2.rs
@@ -7,6 +7,7 @@ use super::{deserialize_datetime, serialize_datetime};
 #[serde(rename_all = "lowercase")]
 pub enum Source {
     Hoghooks,
+    Cyclotron,
 }
 
 #[derive(Deserialize, Serialize, Debug, PartialEq, Clone)]
@@ -14,6 +15,7 @@ pub enum Source {
 pub enum Kind {
     Success,
     Failure,
+    Unknown,
 }
 
 #[derive(Deserialize, Serialize, Debug, PartialEq, Clone)]
diff --git a/rust/common/kafka/src/kafka_messages/log_entries.rs b/rust/common/kafka/src/kafka_messages/log_entries.rs
new file mode 100644
index 0000000000000..fbc896bb56b27
--- /dev/null
+++ b/rust/common/kafka/src/kafka_messages/log_entries.rs
@@ -0,0 +1,23 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+enum Level {
+    Error,
+    Debug,
+    Warn,
+    Info,
+    Warning,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+struct LogEntry {
+    team_id: u32,
+    log_source: String,
+    log_source_id: String,
+    instance_id: String,
+    timestamp: DateTime<Utc>,
+    level: Level,
+    message: String,
+}
diff --git a/rust/hook-common/src/kafka_messages/mod.rs b/rust/common/kafka/src/kafka_messages/mod.rs
similarity index 97%
rename from rust/hook-common/src/kafka_messages/mod.rs
rename to rust/common/kafka/src/kafka_messages/mod.rs
index 92b9c605956e0..6507a2cc4cfcf 100644
--- a/rust/hook-common/src/kafka_messages/mod.rs
+++ b/rust/common/kafka/src/kafka_messages/mod.rs
@@ -1,5 +1,6 @@
 pub mod app_metrics;
 pub mod app_metrics2;
+pub mod log_entries;
 pub mod plugin_logs;
 
 use chrono::{DateTime, NaiveDateTime, Utc};
diff --git a/rust/hook-common/src/kafka_messages/plugin_logs.rs b/rust/common/kafka/src/kafka_messages/plugin_logs.rs
similarity index 100%
rename from rust/hook-common/src/kafka_messages/plugin_logs.rs
rename to rust/common/kafka/src/kafka_messages/plugin_logs.rs
diff --git a/rust/common/kafka/src/kafka_producer.rs b/rust/common/kafka/src/kafka_producer.rs
new file mode 100644
index 0000000000000..4f30850125415
--- /dev/null
+++ b/rust/common/kafka/src/kafka_producer.rs
@@ -0,0 +1,121 @@
+use crate::config::KafkaConfig;
+
+use futures::future::join_all;
+use health::HealthHandle;
+use rdkafka::error::KafkaError;
+use rdkafka::producer::{FutureProducer, FutureRecord};
+use rdkafka::ClientConfig;
+use serde::Serialize;
+use serde_json::error::Error as SerdeError;
+use thiserror::Error;
+use tracing::debug;
+
+pub struct KafkaContext {
+    liveness: HealthHandle,
+}
+
+impl rdkafka::ClientContext for KafkaContext {
+    fn stats(&self, _: rdkafka::Statistics) {
+        // Signal liveness, as the main rdkafka loop is running and calling us
+        self.liveness.report_healthy_blocking();
+
+        // TODO: Take stats recording pieces that we want from `capture-rs`.
+    }
+}
+
+pub async fn create_kafka_producer(
+    config: &KafkaConfig,
+    liveness: HealthHandle,
+) -> Result<FutureProducer<KafkaContext>, KafkaError> {
+    let mut client_config = ClientConfig::new();
+    client_config
+        .set("bootstrap.servers", &config.kafka_hosts)
+        .set("statistics.interval.ms", "10000")
+        .set("linger.ms", config.kafka_producer_linger_ms.to_string())
+        .set(
+            "message.timeout.ms",
+            config.kafka_message_timeout_ms.to_string(),
+        )
+        .set(
+            "compression.codec",
+            config.kafka_compression_codec.to_owned(),
+        )
+        .set(
+            "queue.buffering.max.kbytes",
+            (config.kafka_producer_queue_mib * 1024).to_string(),
+        );
+
+    if config.kafka_tls {
+        client_config
+            .set("security.protocol", "ssl")
+            .set("enable.ssl.certificate.verification", "false");
+    };
+
+    debug!("rdkafka configuration: {:?}", client_config);
+    let api: FutureProducer<KafkaContext> =
+        client_config.create_with_context(KafkaContext { liveness })?;
+
+    // TODO: ping the kafka brokers to confirm configuration is OK (copy capture)
+
+    Ok(api)
+}
+
+#[derive(Error, Debug)]
+pub enum KafkaProduceError {
+    #[error("failed to serialize: {error}")]
+    SerializationError { error: SerdeError },
+    #[error("failed to produce to kafka: {error}")]
+    KafkaProduceError { error: KafkaError },
+    #[error("failed to produce to kafka (timeout)")]
+    KafkaProduceCanceled,
+}
+
+pub async fn send_iter_to_kafka<T>(
+    kafka_producer: &FutureProducer<KafkaContext>,
+    topic: &str,
+    iter: impl IntoIterator<Item = T>,
+) -> Result<(), KafkaProduceError>
+where
+    T: Serialize,
+{
+    let mut payloads = Vec::new();
+
+    for i in iter {
+        let payload = serde_json::to_string(&i)
+            .map_err(|e| KafkaProduceError::SerializationError { error: e })?;
+        payloads.push(payload);
+    }
+
+    if payloads.is_empty() {
+        return Ok(());
+    }
+
+    let mut delivery_futures = Vec::new();
+
+    for payload in payloads {
+        match kafka_producer.send_result(FutureRecord {
+            topic,
+            payload: Some(&payload),
+            partition: None,
+            key: None::<&str>,
+            timestamp: None,
+            headers: None,
+        }) {
+            Ok(future) => delivery_futures.push(future),
+            Err((error, _)) => return Err(KafkaProduceError::KafkaProduceError { error }),
+        }
+    }
+
+    for result in join_all(delivery_futures).await {
+        match result {
+            Ok(Ok(_)) => {}
+            Ok(Err((error, _))) => return Err(KafkaProduceError::KafkaProduceError { error }),
+            Err(_) => {
+                // Cancelled due to timeout while retrying
+                return Err(KafkaProduceError::KafkaProduceCanceled);
+            }
+        }
+    }
+
+    Ok(())
+}
diff --git a/rust/common/kafka/src/lib.rs b/rust/common/kafka/src/lib.rs
new file mode 100644
index 0000000000000..ddfa0625f41c3
--- /dev/null
+++ b/rust/common/kafka/src/lib.rs
@@ -0,0 +1,7 @@
+pub mod config;
+pub mod kafka_messages;
+pub mod kafka_producer;
+pub mod test;
+
+pub const APP_METRICS_TOPIC: &str = "app_metrics";
+pub const APP_METRICS2_TOPIC: &str = "app_metrics2";
diff --git a/rust/hook-common/src/test.rs b/rust/common/kafka/src/test.rs
similarity index 100%
rename from rust/hook-common/src/test.rs
rename to rust/common/kafka/src/test.rs
diff --git a/rust/cyclotron-core/.sqlx/query-2bd3251126625d8dd5143f58f4f9c4bbd0c3a17b7ea65767cf5e7512e5a6ea89.json b/rust/cyclotron-core/.sqlx/query-2bd3251126625d8dd5143f58f4f9c4bbd0c3a17b7ea65767cf5e7512e5a6ea89.json
new file mode 100644
index 0000000000000..cfcbdd6288f56
--- /dev/null
+++ b/rust/cyclotron-core/.sqlx/query-2bd3251126625d8dd5143f58f4f9c4bbd0c3a17b7ea65767cf5e7512e5a6ea89.json
@@ -0,0 +1,18 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "UPDATE cyclotron_jobs SET state = 'running', lock_id = $1, last_heartbeat=NOW() WHERE id = $2 returning queue_name",
+    "describe": {
+        "columns": [
+            {
+                "ordinal": 0,
+                "name": "queue_name",
+                "type_info": "Text"
+            }
+        ],
+        "parameters": {
+            "Left": ["Uuid", "Uuid"]
+        },
+        "nullable": [false]
+    },
+    "hash": "2bd3251126625d8dd5143f58f4f9c4bbd0c3a17b7ea65767cf5e7512e5a6ea89"
+}
diff --git a/rust/cyclotron-core/.sqlx/query-2ca9ea5e8706bba21b14d9a349f3d0e39f01b19b243d724b09f3ce6617d03dc7.json b/rust/cyclotron-core/.sqlx/query-2ca9ea5e8706bba21b14d9a349f3d0e39f01b19b243d724b09f3ce6617d03dc7.json
new file mode 100644
index 0000000000000..e69786b54b25e
--- /dev/null
+++ b/rust/cyclotron-core/.sqlx/query-2ca9ea5e8706bba21b14d9a349f3d0e39f01b19b243d724b09f3ce6617d03dc7.json
@@ -0,0 +1,12 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "UPDATE cyclotron_jobs SET state = 'available', lock_id = NULL, queue_name = $1 WHERE id = $2",
+    "describe": {
+        "columns": [],
+        "parameters": {
+            "Left": ["Text", "Uuid"]
+        },
+        "nullable": []
+    },
+    "hash": "2ca9ea5e8706bba21b14d9a349f3d0e39f01b19b243d724b09f3ce6617d03dc7"
+}
diff --git a/rust/cyclotron-core/.sqlx/query-385e94f4adab0f85174968f6eee873bf6d1d43884cd628df5b36978dd761b025.json b/rust/cyclotron-core/.sqlx/query-385e94f4adab0f85174968f6eee873bf6d1d43884cd628df5b36978dd761b025.json
new file mode 100644
index 0000000000000..5c6b66d3f8739
--- /dev/null
+++ b/rust/cyclotron-core/.sqlx/query-385e94f4adab0f85174968f6eee873bf6d1d43884cd628df5b36978dd761b025.json
@@ -0,0 +1,18 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "\nSELECT id FROM cyclotron_jobs WHERE state = 'running' AND COALESCE(last_heartbeat, $1) <= $1 AND janitor_touch_count >= $2\n        ",
+    "describe": {
+        "columns": [
+            {
+                "ordinal": 0,
+                "name": "id",
+                "type_info": "Uuid"
+            }
+        ],
+        "parameters": {
+            "Left": ["Timestamptz", "Int2"]
+        },
+        "nullable": [false]
+    },
+    "hash": "385e94f4adab0f85174968f6eee873bf6d1d43884cd628df5b36978dd761b025"
+}
diff --git a/rust/cyclotron-core/.sqlx/query-78f54fcebc11e2411008448281e4711bdfb8cf78e362ccda8bc14e92324d51f8.json b/rust/cyclotron-core/.sqlx/query-78f54fcebc11e2411008448281e4711bdfb8cf78e362ccda8bc14e92324d51f8.json
new file mode 100644
index 0000000000000..d70d4c9d33a43
--- /dev/null
+++ b/rust/cyclotron-core/.sqlx/query-78f54fcebc11e2411008448281e4711bdfb8cf78e362ccda8bc14e92324d51f8.json
@@ -0,0 +1,18 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "SELECT COUNT(*) FROM cyclotron_jobs WHERE queue_name = $1",
+    "describe": {
+        "columns": [
+            {
+                "ordinal": 0,
+                "name": "count",
+                "type_info": "Int8"
+            }
+        ],
+        "parameters": {
+            "Left": ["Text"]
+        },
+        "nullable": [null]
+    },
+    "hash": "78f54fcebc11e2411008448281e4711bdfb8cf78e362ccda8bc14e92324d51f8"
+}
diff --git a/rust/cyclotron-core/.sqlx/query-b8c1b723826d595dca0389d729fa76bd8a7d96d73983a0c408f32f17da5f483b.json b/rust/cyclotron-core/.sqlx/query-b8c1b723826d595dca0389d729fa76bd8a7d96d73983a0c408f32f17da5f483b.json
new file mode 100644
index 0000000000000..8f201d80503ce
--- /dev/null
+++ b/rust/cyclotron-core/.sqlx/query-b8c1b723826d595dca0389d729fa76bd8a7d96d73983a0c408f32f17da5f483b.json
@@ -0,0 +1,12 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "INSERT INTO cyclotron_dead_letter_metadata (job_id, original_queue_name, reason, dlq_time) VALUES ($1, $2, $3, NOW())",
+    "describe": {
+        "columns": [],
+        "parameters": {
+            "Left": ["Uuid", "Text", "Text"]
+        },
+        "nullable": []
+    },
+    "hash": "b8c1b723826d595dca0389d729fa76bd8a7d96d73983a0c408f32f17da5f483b"
+}
diff --git a/rust/cyclotron-core/.sqlx/query-e842f1ed33747bde4570c6d861d856c4cbd8beb519df8212212017dda9d06c51.json b/rust/cyclotron-core/.sqlx/query-e842f1ed33747bde4570c6d861d856c4cbd8beb519df8212212017dda9d06c51.json
new file mode 100644
index 0000000000000..145fe9bf7bc9f
--- /dev/null
+++ b/rust/cyclotron-core/.sqlx/query-e842f1ed33747bde4570c6d861d856c4cbd8beb519df8212212017dda9d06c51.json
@@ -0,0 +1,38 @@
+{
+    "db_name": "PostgreSQL",
+    "query": "\nWITH to_delete AS (\n    DELETE FROM cyclotron_jobs\n    WHERE state IN ('failed', 'completed')\n    RETURNING last_transition, team_id, function_id::text, state::text\n),\naggregated_data AS (\n    SELECT\n        date_trunc('hour', last_transition) AS hour,\n        team_id,\n        function_id,\n        state,\n        COUNT(*) AS count\n    FROM to_delete\n    GROUP BY hour, team_id, function_id, state\n)\nSELECT\n    hour as \"hour!\",\n    team_id as \"team_id!\",\n    function_id,\n    state as \"state!\",\n    count as \"count!\"\nFROM aggregated_data",
+    "describe": {
+        "columns": [
+            {
+                "ordinal": 0,
+                "name": "hour!",
+                "type_info": "Timestamptz"
+            },
+            {
+                "ordinal": 1,
+                "name": "team_id!",
+                "type_info": "Int4"
+            },
+            {
+                "ordinal": 2,
+                "name": "function_id",
+                "type_info": "Text"
+            },
+            {
+                "ordinal": 3,
+                "name": "state!",
+                "type_info": "Text"
+            },
+            {
+                "ordinal": 4,
+                "name": "count!",
+                "type_info": "Int8"
+            }
+        ],
+        "parameters": {
+            "Left": []
+        },
+        "nullable": [null, false, null, null, null]
+    },
+    "hash": "e842f1ed33747bde4570c6d861d856c4cbd8beb519df8212212017dda9d06c51"
+}
diff --git a/rust/cyclotron-core/.sqlx/query-f4e808f58dd290c6e2b49b63e9e0eb022936ba318021512a0cc0c2e0766abe7c.json b/rust/cyclotron-core/.sqlx/query-f4e808f58dd290c6e2b49b63e9e0eb022936ba318021512a0cc0c2e0766abe7c.json
deleted file mode 100644
index a585e9f7e7d73..0000000000000
--- a/rust/cyclotron-core/.sqlx/query-f4e808f58dd290c6e2b49b63e9e0eb022936ba318021512a0cc0c2e0766abe7c.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-    "db_name": "PostgreSQL",
-    "query": "DELETE FROM cyclotron_jobs WHERE state = 'completed'",
-    "describe": {
-        "columns": [],
-        "parameters": {
-            "Left": []
-        },
-        "nullable": []
-    },
-    "hash": "f4e808f58dd290c6e2b49b63e9e0eb022936ba318021512a0cc0c2e0766abe7c"
-}
diff --git a/rust/cyclotron-core/.sqlx/query-fdda5a80f5495f2d4b15ce1a0963f990986c8b8433f01e449fbd1eee70ce6aeb.json b/rust/cyclotron-core/.sqlx/query-fdda5a80f5495f2d4b15ce1a0963f990986c8b8433f01e449fbd1eee70ce6aeb.json
deleted file mode 100644
index 09fc24b340d3f..0000000000000
--- a/rust/cyclotron-core/.sqlx/query-fdda5a80f5495f2d4b15ce1a0963f990986c8b8433f01e449fbd1eee70ce6aeb.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-    "db_name": "PostgreSQL",
-    "query": "\nDELETE FROM cyclotron_jobs WHERE state = 'running' AND COALESCE(last_heartbeat, $1) <= $1 AND janitor_touch_count >= $2\n        ",
-    "describe": {
-        "columns": [],
-        "parameters": {
-            "Left": ["Timestamptz", "Int2"]
-        },
-        "nullable": []
-    },
-    "hash": "fdda5a80f5495f2d4b15ce1a0963f990986c8b8433f01e449fbd1eee70ce6aeb"
-}
diff --git a/rust/cyclotron-core/.sqlx/query-ffb66bdedf6506f95b9293ef88b0c51e2f5fb7d3271e1287165d2a35b6aaa25e.json b/rust/cyclotron-core/.sqlx/query-ffb66bdedf6506f95b9293ef88b0c51e2f5fb7d3271e1287165d2a35b6aaa25e.json
deleted file mode 100644
index 605d79d57c098..0000000000000
--- a/rust/cyclotron-core/.sqlx/query-ffb66bdedf6506f95b9293ef88b0c51e2f5fb7d3271e1287165d2a35b6aaa25e.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-    "db_name": "PostgreSQL",
-    "query": "DELETE FROM cyclotron_jobs WHERE state = 'failed'",
-    "describe": {
-        "columns": [],
-        "parameters": {
-            "Left": []
-        },
-        "nullable": []
-    },
-    "hash": "ffb66bdedf6506f95b9293ef88b0c51e2f5fb7d3271e1287165d2a35b6aaa25e"
-}
diff --git a/rust/cyclotron-core/Cargo.toml b/rust/cyclotron-core/Cargo.toml
index bfec9301eee72..18598fd0b37f5 100644
--- a/rust/cyclotron-core/Cargo.toml
+++ b/rust/cyclotron-core/Cargo.toml
@@ -14,4 +14,4 @@ tokio = { workspace = true }
 thiserror = { workspace = true }
 uuid = { workspace = true }
 rand = { workspace = true }
-futures = { workspace = true }
\ No newline at end of file
+futures = { workspace = true }
diff --git a/rust/cyclotron-core/src/janitor.rs b/rust/cyclotron-core/src/janitor.rs
index 8fd98307fba67..dd48f031b1060 100644
--- a/rust/cyclotron-core/src/janitor.rs
+++ b/rust/cyclotron-core/src/janitor.rs
@@ -4,11 +4,10 @@ use sqlx::PgPool;
 
 use crate::{
     ops::{
-        janitor::{
-            delete_completed_jobs, delete_failed_jobs, detect_poison_pills, reset_stalled_jobs,
-        },
+        janitor::{delete_completed_and_failed_jobs, detect_poison_pills, reset_stalled_jobs},
         meta::{count_total_waiting_jobs, dead_letter, run_migrations},
     },
+    types::AggregatedDelete,
     PoolConfig, QueueError,
 };
 
@@ -31,12 +30,10 @@ impl Janitor {
         run_migrations(&self.pool).await;
     }
 
-    pub async fn delete_completed_jobs(&self) -> Result<u64, QueueError> {
-        delete_completed_jobs(&self.pool).await
-    }
-
-    pub async fn delete_failed_jobs(&self) -> Result<u64, QueueError> {
-        delete_failed_jobs(&self.pool).await
+    pub async fn delete_completed_and_failed_jobs(
+        &self,
+    ) -> Result<Vec<AggregatedDelete>, QueueError> {
+        delete_completed_and_failed_jobs(&self.pool).await
     }
 
     pub async fn reset_stalled_jobs(&self, timeout: Duration) -> Result<u64, QueueError> {
diff --git a/rust/cyclotron-core/src/lib.rs b/rust/cyclotron-core/src/lib.rs
index e737f38360165..f845ccee042f8 100644
--- a/rust/cyclotron-core/src/lib.rs
+++ b/rust/cyclotron-core/src/lib.rs
@@ -4,6 +4,7 @@ mod ops;
 
 // Types
 mod types;
+pub use types::AggregatedDelete;
 pub use types::BulkInsertResult;
 pub use types::Bytes;
 pub use types::Job;
diff --git a/rust/cyclotron-core/src/ops/janitor.rs b/rust/cyclotron-core/src/ops/janitor.rs
index 16bdb9180f0f9..488d629730342 100644
--- a/rust/cyclotron-core/src/ops/janitor.rs
+++ b/rust/cyclotron-core/src/ops/janitor.rs
@@ -2,32 +2,49 @@ use chrono::{Duration, Utc};
 use uuid::Uuid;
 
 use crate::error::QueueError;
+use crate::types::AggregatedDelete;
 
 // As a general rule, janitor operations are not queue specific (as in, they don't account for the
 // queue name). We can revisit this later, if we decide we need the ability to do janitor operations
 // on a per-queue basis.
-pub async fn delete_completed_jobs<'c, E>(executor: E) -> Result<u64, QueueError>
-where
-    E: sqlx::Executor<'c, Database = sqlx::Postgres>,
-{
-    let result = sqlx::query!("DELETE FROM cyclotron_jobs WHERE state = 'completed'")
-        .execute(executor)
-        .await
-        .map_err(QueueError::from)?;
-
-    Ok(result.rows_affected())
-}
 
-pub async fn delete_failed_jobs<'c, E>(executor: E) -> Result<u64, QueueError>
+pub async fn delete_completed_and_failed_jobs<'c, E>(
+    executor: E,
+) -> Result<Vec<AggregatedDelete>, QueueError>
 where
     E: sqlx::Executor<'c, Database = sqlx::Postgres>,
 {
-    let result = sqlx::query!("DELETE FROM cyclotron_jobs WHERE state = 'failed'")
-        .execute(executor)
-        .await
-        .map_err(QueueError::from)?;
+    let result: Vec<AggregatedDelete> = sqlx::query_as!(
+        AggregatedDelete,
+        r#"
+WITH to_delete AS (
+    DELETE FROM cyclotron_jobs
+    WHERE state IN ('failed', 'completed')
+    RETURNING last_transition, team_id, function_id::text, state::text
+),
+aggregated_data AS (
+    SELECT
+        date_trunc('hour', last_transition) AS hour,
+        team_id,
+        function_id,
+        state,
+        COUNT(*) AS count
+    FROM to_delete
+    GROUP BY hour, team_id, function_id, state
+)
+SELECT
+    hour as "hour!",
+    team_id as "team_id!",
+    function_id,
+    state as "state!",
+    count as "count!"
+FROM aggregated_data"#
+    )
+    .fetch_all(executor)
+    .await
+    .map_err(QueueError::from)?;
 
-    Ok(result.rows_affected())
+    Ok(result)
 }
 
 // Jobs are considered stalled if their lock is held and their last_heartbeat is older than `timeout`.
diff --git a/rust/cyclotron-core/src/types.rs b/rust/cyclotron-core/src/types.rs
index 5adf86c6050b4..a2def554794e0 100644
--- a/rust/cyclotron-core/src/types.rs
+++ b/rust/cyclotron-core/src/types.rs
@@ -1,8 +1,7 @@
-use std::str::FromStr;
-
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use sqlx::postgres::{PgHasArrayType, PgTypeInfo};
+use std::str::FromStr;
 use uuid::Uuid;
 
 use crate::QueueError;
@@ -143,3 +142,14 @@ impl Default for BulkInsertResult {
         Self::new()
     }
 }
+
+// Result of janitor's `delete_completed_and_failed_jobs`
+#[derive(sqlx::FromRow, Debug)]
+pub struct AggregatedDelete {
+    // `last_transition` column truncated to the hour.
+    pub hour: DateTime<Utc>,
+    pub team_id: i64,
+    pub function_id: Option<String>,
+    pub state: String,
+    pub count: i64,
+}
diff --git a/rust/cyclotron-fetch/Cargo.toml b/rust/cyclotron-fetch/Cargo.toml
index e9f8de05bcff0..69f6f4ac2adf1 100644
--- a/rust/cyclotron-fetch/Cargo.toml
+++ b/rust/cyclotron-fetch/Cargo.toml
@@ -18,6 +18,7 @@ thiserror = { workspace = true }
 cyclotron-core = { path = "../cyclotron-core" }
 common-metrics = { path = "../common/metrics" }
 common-dns = { path = "../common/dns" }
+common-kafka = { path = "../common/kafka" }
 health = { path = "../common/health" }
 reqwest = { workspace = true }
 serde = { workspace = true }
@@ -25,7 +26,9 @@ serde_json = { workspace = true }
 http = { workspace = true }
 rand = { workspace = true }
 futures = { workspace = true }
+time = { workspace = true }
+rdkafka = { workspace = true }
 
 [dev-dependencies]
 sqlx = { workspace = true }
-httpmock = { workspace = true }
\ No newline at end of file
+httpmock = { workspace = true }
diff --git a/rust/cyclotron-fetch/src/config.rs b/rust/cyclotron-fetch/src/config.rs
index a57cbafe5e287..752ba5f32217a 100644
--- a/rust/cyclotron-fetch/src/config.rs
+++ b/rust/cyclotron-fetch/src/config.rs
@@ -3,6 +3,8 @@ use cyclotron_core::PoolConfig;
 use envconfig::Envconfig;
 use uuid::Uuid;
 
+use common_kafka::config::KafkaConfig;
+
 #[derive(Envconfig)]
 pub struct Config {
     #[envconfig(from = "BIND_HOST", default = "::")]
@@ -61,6 +63,9 @@ pub struct Config {
 
     #[envconfig(default = "4000")]
     pub retry_backoff_base_ms: i64,
+
+    #[envconfig(nested = true)]
+    pub kafka: KafkaConfig,
 }
 
 #[allow(dead_code)]
@@ -86,7 +91,7 @@ pub struct AppConfig {
 }
 
 impl Config {
-    pub fn to_components(self) -> (AppConfig, PoolConfig) {
+    pub fn to_components(self) -> (AppConfig, PoolConfig, KafkaConfig) {
         let app_config = AppConfig {
             host: self.host,
             port: self.port,
@@ -112,6 +117,6 @@ impl Config {
             idle_timeout_seconds: Some(self.pg_idle_timeout_seconds),
         };
 
-        (app_config, pool_config)
+        (app_config, pool_config, self.kafka)
     }
 }
diff --git a/rust/cyclotron-fetch/src/context.rs b/rust/cyclotron-fetch/src/context.rs
index f10f4149b1ada..d88acd1633c02 100644
--- a/rust/cyclotron-fetch/src/context.rs
+++ b/rust/cyclotron-fetch/src/context.rs
@@ -1,7 +1,11 @@
 use std::sync::{Arc, RwLock};
 
+use common_kafka::config::KafkaConfig;
+use common_kafka::kafka_producer::create_kafka_producer;
+use common_kafka::kafka_producer::KafkaContext;
 use cyclotron_core::{PoolConfig, Worker, SHARD_ID_KEY};
 use health::HealthHandle;
+use rdkafka::producer::FutureProducer;
 use tokio::sync::Semaphore;
 
 use crate::{config::AppConfig, fetch::FetchError};
@@ -9,6 +13,7 @@ use crate::{config::AppConfig, fetch::FetchError};
 pub struct AppContext {
     pub worker: Worker,
     pub client: reqwest::Client,
+    pub kafka_producer: FutureProducer<KafkaContext>,
     pub concurrency_limit: Arc<Semaphore>,
     pub liveness: HealthHandle,
     pub config: AppConfig,
@@ -19,7 +24,9 @@ impl AppContext {
     pub async fn create(
         config: AppConfig,
         pool_config: PoolConfig,
+        kafka_config: KafkaConfig,
         liveness: HealthHandle,
+        kafka_liveness: HealthHandle,
     ) -> Result<Self, FetchError> {
         let concurrency_limit = Arc::new(Semaphore::new(config.concurrent_requests_limit as usize));
 
@@ -51,9 +58,14 @@ impl AppContext {
             ("queue_served".to_string(), config.queue_served.clone()),
         ];
 
+        let kafka_producer = create_kafka_producer(&kafka_config, kafka_liveness)
+            .await
+            .expect("failed to create kafka producer");
+
         Ok(Self {
             worker,
             client,
+            kafka_producer,
             concurrency_limit,
             liveness,
             config,
diff --git a/rust/cyclotron-fetch/src/main.rs b/rust/cyclotron-fetch/src/main.rs
index c0c02c6f5404b..2013f1b6c7218 100644
--- a/rust/cyclotron-fetch/src/main.rs
+++ b/rust/cyclotron-fetch/src/main.rs
@@ -54,7 +54,7 @@ async fn main() {
 
     let liveness = HealthRegistry::new("liveness");
 
-    let (app_config, pool_config) = config.to_components();
+    let (app_config, pool_config, kafka_config) = config.to_components();
     let bind = format!("{}:{}", app_config.host, app_config.port);
 
     info!(
@@ -69,11 +69,21 @@ async fn main() {
         )
         .await;
 
+    let kafka_liveness = liveness
+        .register("rdkafka".to_string(), time::Duration::seconds(30))
+        .await;
+
     let app = setup_metrics_routes(app(liveness, app_config.worker_id.clone()));
 
-    let context = AppContext::create(app_config, pool_config, worker_liveness)
-        .await
-        .expect("failed to create app context");
+    let context = AppContext::create(
+        app_config,
+        pool_config,
+        kafka_config,
+        worker_liveness,
+        kafka_liveness,
+    )
+    .await
+    .expect("failed to create app context");
 
     context.worker.run_migrations().await;
 
diff --git a/rust/cyclotron-fetch/tests/utils.rs b/rust/cyclotron-fetch/tests/utils.rs
index 6041a491d3f9b..7faef3d4bec08 100644
--- a/rust/cyclotron-fetch/tests/utils.rs
+++ b/rust/cyclotron-fetch/tests/utils.rs
@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use chrono::{Duration, Utc};
 
+use common_kafka::test::create_mock_kafka;
 use cyclotron_core::{Bytes, Job, JobInit, QueueError, Worker};
 use cyclotron_fetch::{
     config::AppConfig,
@@ -39,9 +40,12 @@ pub async fn get_app_test_context(db: PgPool) -> AppContext {
         allow_internal_ips: true,
     };
 
+    let (_, mock_producer) = create_mock_kafka().await;
+
     AppContext {
         worker,
         client,
+        kafka_producer: mock_producer,
         concurrency_limit,
         liveness,
         config,
diff --git a/rust/cyclotron-janitor/Cargo.toml b/rust/cyclotron-janitor/Cargo.toml
index 3363a16aac4a6..d6eb553d3e72f 100644
--- a/rust/cyclotron-janitor/Cargo.toml
+++ b/rust/cyclotron-janitor/Cargo.toml
@@ -17,7 +17,11 @@ axum = { workspace = true }
 eyre = { workspace = true }
 cyclotron-core = { path = "../cyclotron-core" }
 common-metrics = { path = "../common/metrics" }
+common-kafka = { path = "../common/kafka" }
 health = { path = "../common/health" }
+time = { workspace = true }
+rdkafka = { workspace = true }
 
 [dev-dependencies]
-sqlx = { workspace = true }
\ No newline at end of file
+sqlx = { workspace = true }
+serde_json = { workspace = true }
diff --git a/rust/cyclotron-janitor/src/config.rs b/rust/cyclotron-janitor/src/config.rs
index 40ab9ee558a52..005f438c8f1d2 100644
--- a/rust/cyclotron-janitor/src/config.rs
+++ b/rust/cyclotron-janitor/src/config.rs
@@ -4,6 +4,8 @@ use cyclotron_core::PoolConfig;
 use envconfig::Envconfig;
 use uuid::Uuid;
 
+use common_kafka::config::KafkaConfig;
+
 #[derive(Envconfig)]
 pub struct Config {
     #[envconfig(from = "BIND_HOST", default = "::")]
@@ -46,6 +48,9 @@ pub struct Config {
 
     #[envconfig(default = "60")]
     pub janitor_stall_timeout_seconds: u16,
+
+    #[envconfig(nested = true)]
+    pub kafka: KafkaConfig,
 }
 
 #[allow(dead_code)]
@@ -73,6 +78,7 @@ impl Config {
 
         JanitorConfig {
             pool: pool_config,
+            kafka: self.kafka.clone(),
             settings,
         }
     }
@@ -80,6 +86,7 @@ impl Config {
 
 pub struct JanitorConfig {
     pub pool: PoolConfig,
+    pub kafka: KafkaConfig,
     pub settings: JanitorSettings,
 }
 
diff --git a/rust/cyclotron-janitor/src/janitor.rs b/rust/cyclotron-janitor/src/janitor.rs
index be36c07ec009d..6fc0b248b54ab 100644
--- a/rust/cyclotron-janitor/src/janitor.rs
+++ b/rust/cyclotron-janitor/src/janitor.rs
@@ -1,5 +1,14 @@
-use cyclotron_core::{QueueError, SHARD_ID_KEY};
-use tracing::{info, warn};
+use common_kafka::kafka_messages::app_metrics2::{
+    AppMetric2, Kind as AppMetric2Kind, Source as AppMetric2Source,
+};
+use common_kafka::kafka_producer::create_kafka_producer;
+use common_kafka::kafka_producer::{send_iter_to_kafka, KafkaContext, KafkaProduceError};
+use common_kafka::APP_METRICS2_TOPIC;
+use cyclotron_core::{AggregatedDelete, QueueError, SHARD_ID_KEY};
+use health::HealthRegistry;
+use tracing::{error, info, warn};
+
+use rdkafka::producer::FutureProducer;
 
 use crate::{
     config::{JanitorConfig, JanitorSettings},
@@ -17,12 +26,16 @@ pub struct CleanupResult {
 
 pub struct Janitor {
     pub inner: cyclotron_core::Janitor,
+    pub kafka_producer: FutureProducer<KafkaContext>,
     pub settings: JanitorSettings,
     pub metrics_labels: Vec<(String, String)>,
 }
 
 impl Janitor {
-    pub async fn new(config: JanitorConfig) -> Result<Self, QueueError> {
+    pub async fn new(
+        config: JanitorConfig,
+        health_registry: &HealthRegistry,
+    ) -> Result<Self, QueueError> {
         let settings = config.settings;
         let inner = cyclotron_core::Janitor::new(config.pool).await?;
 
@@ -31,8 +44,17 @@ impl Janitor {
             (SHARD_ID_KEY.to_string(), settings.shard_id.clone()),
         ];
 
+        let kafka_liveness = health_registry
+            .register("rdkafka".to_string(), time::Duration::seconds(30))
+            .await;
+
+        let kafka_producer = create_kafka_producer(&config.kafka, kafka_liveness)
+            .await
+            .expect("failed to create kafka producer");
+
         Ok(Self {
             inner,
+            kafka_producer,
             settings,
             metrics_labels,
         })
@@ -47,17 +69,43 @@ impl Janitor {
         let _loop_start = common_metrics::timing_guard(RUN_TIME, &self.metrics_labels);
         common_metrics::inc(RUN_STARTS, &self.metrics_labels, 1);
 
-        let completed = {
-            let _time = common_metrics::timing_guard(COMPLETED_TIME, &self.metrics_labels);
-            self.inner.delete_completed_jobs().await?
+        let aggregated_deletes = {
+            let _time = common_metrics::timing_guard(CLEANUP_TIME, &self.metrics_labels);
+            self.inner.delete_completed_and_failed_jobs().await?
         };
-        common_metrics::inc(COMPLETED_COUNT, &self.metrics_labels, completed);
 
-        let failed = {
-            let _time = common_metrics::timing_guard(FAILED_TIME, &self.metrics_labels);
-            self.inner.delete_failed_jobs().await?
-        };
-        common_metrics::inc(FAILED_COUNT, &self.metrics_labels, failed);
+        let mut completed_count = 0u64;
+        let mut failed_count = 0u64;
+        for delete in &aggregated_deletes {
+            if delete.state == "completed" {
+                completed_count += delete.count as u64;
+            } else if delete.state == "failed" {
+                failed_count += delete.count as u64;
+            }
+        }
+        common_metrics::inc(COMPLETED_COUNT, &self.metrics_labels, completed_count);
+        common_metrics::inc(FAILED_COUNT, &self.metrics_labels, failed_count);
+
+        match send_iter_to_kafka(
+            &self.kafka_producer,
+            APP_METRICS2_TOPIC,
+            aggregated_deletes
+                .into_iter()
+                .map(aggregated_delete_to_app_metric2),
+        )
+        .await
+        {
+            Ok(()) => {}
+            Err(KafkaProduceError::SerializationError { error }) => {
+                error!("Failed to serialize app_metrics2: {error}");
+            }
+            Err(KafkaProduceError::KafkaProduceError { error }) => {
+                error!("Failed to produce to app_metrics2 kafka: {error}");
+            }
+            Err(KafkaProduceError::KafkaProduceCanceled) => {
+                error!("Failed to produce to app_metrics2 kafka (timeout)");
+            }
+        }
 
         let poisoned = {
             let _time = common_metrics::timing_guard(POISONED_TIME, &self.metrics_labels);
@@ -98,10 +146,29 @@ impl Janitor {
         common_metrics::inc(RUN_ENDS, &self.metrics_labels, 1);
         info!("Janitor loop complete");
         Ok(CleanupResult {
-            completed,
-            failed,
+            completed: completed_count,
+            failed: failed_count,
             poisoned,
             stalled,
         })
     }
 }
+
+fn aggregated_delete_to_app_metric2(delete: AggregatedDelete) -> AppMetric2 {
+    let kind = match delete.state.as_str() {
+        "completed" => AppMetric2Kind::Success,
+        "failed" => AppMetric2Kind::Failure,
+        _ => AppMetric2Kind::Unknown,
+    };
+
+    AppMetric2 {
+        team_id: delete.team_id as u32,
+        timestamp: delete.hour,
+        app_source: AppMetric2Source::Cyclotron,
+        app_source_id: delete.function_id.unwrap_or("".to_owned()),
+        instance_id: None,
+        metric_kind: kind,
+        metric_name: "finished_state".to_owned(),
+        count: delete.count as u32,
+    }
+}
diff --git a/rust/cyclotron-janitor/src/main.rs b/rust/cyclotron-janitor/src/main.rs
index 0db35e52b8bc5..fa0f682601e61 100644
--- a/rust/cyclotron-janitor/src/main.rs
+++ b/rust/cyclotron-janitor/src/main.rs
@@ -66,7 +66,7 @@ async fn main() {
         janitor_id, bind
     );
 
-    let janitor = Janitor::new(janitor_config)
+    let janitor = Janitor::new(janitor_config, &liveness)
         .await
         .expect("failed to create janitor");
 
diff --git a/rust/cyclotron-janitor/src/metrics_constants.rs b/rust/cyclotron-janitor/src/metrics_constants.rs
index 2da1822484ee5..b3e838370a40d 100644
--- a/rust/cyclotron-janitor/src/metrics_constants.rs
+++ b/rust/cyclotron-janitor/src/metrics_constants.rs
@@ -3,10 +3,8 @@ pub const RUN_TIME: &str = "cyclotron_janitor_total_run_ms";
 pub const RUN_ENDS: &str = "cyclotron_janitor_run_ends";
 
 pub const COMPLETED_COUNT: &str = "cyclotron_janitor_completed_jobs";
-pub const COMPLETED_TIME: &str = "cyclotron_janitor_completed_jobs_cleanup_ms";
-
 pub const FAILED_COUNT: &str = "cyclotron_janitor_failed_jobs";
-pub const FAILED_TIME: &str = "cyclotron_janitor_failed_jobs_cleanup_ms";
+pub const CLEANUP_TIME: &str = "cyclotron_janitor_completed_failed_jobs_cleanup_ms";
 
 pub const POISONED_COUNT: &str = "cyclotron_janitor_poison_pills";
 pub const POISONED_TIME: &str = "cyclotron_janitor_poison_pills_cleanup_ms";
diff --git a/rust/cyclotron-janitor/tests/janitor.rs b/rust/cyclotron-janitor/tests/janitor.rs
index 32846d7f8c647..7dceae4969c19 100644
--- a/rust/cyclotron-janitor/tests/janitor.rs
+++ b/rust/cyclotron-janitor/tests/janitor.rs
@@ -1,10 +1,18 @@
-use chrono::{Duration, Utc};
-
+use chrono::{DateTime, Duration, Timelike, Utc};
+use common_kafka::kafka_messages::app_metrics2::{
+    AppMetric2, Kind as AppMetric2Kind, Source as AppMetric2Source,
+};
 use cyclotron_core::{JobInit, JobState, QueueManager, Worker};
 use cyclotron_janitor::{config::JanitorSettings, janitor::Janitor};
+use rdkafka::consumer::{Consumer, StreamConsumer};
+use rdkafka::types::{RDKafkaApiKey, RDKafkaRespErr};
+use rdkafka::{ClientConfig, Message};
 use sqlx::PgPool;
+use std::str::FromStr;
 use uuid::Uuid;
 
+use common_kafka::{test::create_mock_kafka, APP_METRICS2_TOPIC};
+
 #[sqlx::test(migrations = "../cyclotron-core/migrations")]
 async fn janitor_test(db: PgPool) {
     let worker = Worker::from_pool(db.clone());
@@ -15,6 +23,19 @@ async fn janitor_test(db: PgPool) {
     let stall_timeout = Duration::milliseconds(10);
     let max_touches = 3;
 
+    let (mock_cluster, mock_producer) = create_mock_kafka().await;
+    mock_cluster
+        .create_topic(APP_METRICS2_TOPIC, 1, 1)
+        .expect("failed to create mock app_metrics2 topic");
+
+    let kafka_consumer: StreamConsumer = ClientConfig::new()
+        .set("bootstrap.servers", mock_cluster.bootstrap_servers())
+        .set("group.id", "mock")
+        .set("auto.offset.reset", "earliest")
+        .create()
+        .expect("failed to create mock consumer");
+    kafka_consumer.subscribe(&[APP_METRICS2_TOPIC]).unwrap();
+
     let settings = JanitorSettings {
         stall_timeout,
         max_touches,
@@ -23,6 +44,7 @@ async fn janitor_test(db: PgPool) {
     };
     let janitor = Janitor {
         inner: cyclotron_core::Janitor::from_pool(db.clone()),
+        kafka_producer: mock_producer,
         settings,
         metrics_labels: vec![],
     };
@@ -30,12 +52,13 @@ async fn janitor_test(db: PgPool) {
     let now = Utc::now() - Duration::seconds(10);
     let queue_name = "default".to_string();
 
+    let uuid = Uuid::now_v7();
     let job_init = JobInit {
         team_id: 1,
         queue_name: queue_name.clone(),
         priority: 0,
         scheduled: now,
-        function_id: Some(Uuid::now_v7()),
+        function_id: Some(uuid.clone()),
         vm_state: None,
         parameters: None,
         blob: None,
@@ -43,6 +66,7 @@ async fn janitor_test(db: PgPool) {
     };
 
     // First test - if we mark a job as completed, the janitor will clean it up
+    let mut job_now = Utc::now();
     manager.create_job(job_init.clone()).await.unwrap();
     let job = worker
         .dequeue_jobs(&queue_name, 1)
@@ -60,7 +84,34 @@ async fn janitor_test(db: PgPool) {
     assert_eq!(result.poisoned, 0);
     assert_eq!(result.stalled, 0);
 
+    {
+        let kafka_msg = kafka_consumer.recv().await.unwrap();
+        let payload_str = String::from_utf8(kafka_msg.payload().unwrap().to_vec()).unwrap();
+        let app_metric: AppMetric2 = serde_json::from_str(&payload_str).unwrap();
+
+        assert_eq!(
+            app_metric,
+            AppMetric2 {
+                team_id: 1,
+                timestamp: job_now
+                    .with_minute(0)
+                    .unwrap()
+                    .with_second(0)
+                    .unwrap()
+                    .with_nanosecond(0)
+                    .unwrap(),
+                app_source: AppMetric2Source::Cyclotron,
+                app_source_id: uuid.to_string(),
+                instance_id: None,
+                metric_kind: AppMetric2Kind::Success,
+                metric_name: "finished_state".to_owned(),
+                count: 1
+            }
+        );
+    }
+
     // Second test - if we mark a job as failed, the janitor will clean it up
+    job_now = Utc::now();
     manager.create_job(job_init.clone()).await.unwrap();
     let job = worker
         .dequeue_jobs(&queue_name, 1)
@@ -78,6 +129,32 @@ async fn janitor_test(db: PgPool) {
     assert_eq!(result.poisoned, 0);
     assert_eq!(result.stalled, 0);
 
+    {
+        let kafka_msg = kafka_consumer.recv().await.unwrap();
+        let payload_str = String::from_utf8(kafka_msg.payload().unwrap().to_vec()).unwrap();
+        let app_metric: AppMetric2 = serde_json::from_str(&payload_str).unwrap();
+
+        assert_eq!(
+            app_metric,
+            AppMetric2 {
+                team_id: 1,
+                timestamp: job_now
+                    .with_minute(0)
+                    .unwrap()
+                    .with_second(0)
+                    .unwrap()
+                    .with_nanosecond(0)
+                    .unwrap(),
+                app_source: AppMetric2Source::Cyclotron,
+                app_source_id: uuid.to_string(),
+                instance_id: None,
+                metric_kind: AppMetric2Kind::Failure,
+                metric_name: "finished_state".to_owned(),
+                count: 1
+            }
+        );
+    }
+
     // Third test - if we pick up a job, and then hold it for longer than
     // the stall timeout, the janitor will reset it. After this, the worker
     // cannot flush updates to the job, and must re-dequeue it.
diff --git a/rust/feature-flags/src/v0_endpoint.rs b/rust/feature-flags/src/v0_endpoint.rs
index 56734eae32d45..9adfa67e882a3 100644
--- a/rust/feature-flags/src/v0_endpoint.rs
+++ b/rust/feature-flags/src/v0_endpoint.rs
@@ -85,5 +85,5 @@ fn record_request_metadata(
     tracing::Span::current().record("method", method.as_str());
     tracing::Span::current().record("path", path.as_str().trim_end_matches('/'));
     tracing::Span::current().record("ip", ip.to_string());
-    tracing::Span::current().record("sent_at", &meta.sent_at.unwrap_or(0).to_string());
+    tracing::Span::current().record("sent_at", meta.sent_at.unwrap_or(0).to_string());
 }
diff --git a/rust/hook-common/Cargo.toml b/rust/hook-common/Cargo.toml
index e6b2625c23905..b63d7bfd5d973 100644
--- a/rust/hook-common/Cargo.toml
+++ b/rust/hook-common/Cargo.toml
@@ -9,10 +9,7 @@ workspace = true
 [dependencies]
 async-trait = { workspace = true }
 chrono = { workspace = true }
-envconfig = { workspace = true }
-health = { path = "../common/health" }
 http = { workspace = true }
-rdkafka = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
@@ -21,7 +18,7 @@ thiserror = { workspace = true }
 time = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
-uuid = { workspace = true }
+common-kafka = { path = "../common/kafka" }
 
 [dev-dependencies]
 tokio = { workspace = true } # We need a runtime for async tests
diff --git a/rust/hook-common/src/kafka_producer.rs b/rust/hook-common/src/kafka_producer.rs
deleted file mode 100644
index 92608bcb999c8..0000000000000
--- a/rust/hook-common/src/kafka_producer.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use crate::config::KafkaConfig;
-
-use health::HealthHandle;
-use rdkafka::error::KafkaError;
-use rdkafka::producer::FutureProducer;
-use rdkafka::ClientConfig;
-use tracing::debug;
-
-pub struct KafkaContext {
-    liveness: HealthHandle,
-}
-
-impl rdkafka::ClientContext for KafkaContext {
-    fn stats(&self, _: rdkafka::Statistics) {
-        // Signal liveness, as the main rdkafka loop is running and calling us
-        self.liveness.report_healthy_blocking();
-
-        // TODO: Take stats recording pieces that we want from `capture-rs`.
-    }
-}
-
-pub async fn create_kafka_producer(
-    config: &KafkaConfig,
-    liveness: HealthHandle,
-) -> Result<FutureProducer<KafkaContext>, KafkaError> {
-    let mut client_config = ClientConfig::new();
-    client_config
-        .set("bootstrap.servers", &config.kafka_hosts)
-        .set("statistics.interval.ms", "10000")
-        .set("linger.ms", config.kafka_producer_linger_ms.to_string())
-        .set(
-            "message.timeout.ms",
-            config.kafka_message_timeout_ms.to_string(),
-        )
-        .set(
-            "compression.codec",
-            config.kafka_compression_codec.to_owned(),
-        )
-        .set(
-            "queue.buffering.max.kbytes",
-            (config.kafka_producer_queue_mib * 1024).to_string(),
-        );
-
-    if config.kafka_tls {
-        client_config
-            .set("security.protocol", "ssl")
-            .set("enable.ssl.certificate.verification", "false");
-    };
-
-    debug!("rdkafka configuration: {:?}", client_config);
-    let api: FutureProducer<KafkaContext> =
-        client_config.create_with_context(KafkaContext { liveness })?;
-
-    // TODO: ping the kafka brokers to confirm configuration is OK (copy capture)
-
-    Ok(api)
-}
diff --git a/rust/hook-common/src/lib.rs b/rust/hook-common/src/lib.rs
index e1446d80c338f..37d193eeed596 100644
--- a/rust/hook-common/src/lib.rs
+++ b/rust/hook-common/src/lib.rs
@@ -1,7 +1,3 @@
-pub mod config;
-pub mod kafka_messages;
-pub mod kafka_producer;
 pub mod pgqueue;
 pub mod retry;
-pub mod test;
 pub mod webhook;
diff --git a/rust/hook-common/src/webhook.rs b/rust/hook-common/src/webhook.rs
index 5286629978931..b47e4ba909f39 100644
--- a/rust/hook-common/src/webhook.rs
+++ b/rust/hook-common/src/webhook.rs
@@ -5,8 +5,8 @@ use std::str::FromStr;
 
 use serde::{de::Visitor, Deserialize, Serialize};
 
-use crate::kafka_messages::app_metrics;
 use crate::pgqueue::ParseError;
+use common_kafka::kafka_messages::app_metrics;
 
 /// Supported HTTP methods for webhooks.
 #[derive(Debug, PartialEq, Clone, Copy)]
diff --git a/rust/hook-janitor/Cargo.toml b/rust/hook-janitor/Cargo.toml
index a4fa315da70f1..dba9bef7e7046 100644
--- a/rust/hook-janitor/Cargo.toml
+++ b/rust/hook-janitor/Cargo.toml
@@ -24,4 +24,5 @@ time = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
-common-metrics = { path = "../common/metrics" }
\ No newline at end of file
+common-metrics = { path = "../common/metrics" }
+common-kafka = { path = "../common/kafka" }
diff --git a/rust/hook-janitor/src/config.rs b/rust/hook-janitor/src/config.rs
index 28c34488d476b..9d7a76cc1b98e 100644
--- a/rust/hook-janitor/src/config.rs
+++ b/rust/hook-janitor/src/config.rs
@@ -1,6 +1,6 @@
 use envconfig::Envconfig;
 
-use hook_common::config::KafkaConfig;
+use common_kafka::config::KafkaConfig;
 
 #[derive(Envconfig)]
 pub struct Config {
diff --git a/rust/hook-janitor/src/main.rs b/rust/hook-janitor/src/main.rs
index b7ea4db85ec1d..6ca27fa6e6d6f 100644
--- a/rust/hook-janitor/src/main.rs
+++ b/rust/hook-janitor/src/main.rs
@@ -9,8 +9,8 @@ use std::{str::FromStr, time::Duration};
 use tokio::sync::Semaphore;
 use webhooks::WebhookCleaner;
 
+use common_kafka::kafka_producer::create_kafka_producer;
 use common_metrics::setup_metrics_routes;
-use hook_common::kafka_producer::create_kafka_producer;
 
 mod cleanup;
 mod config;
diff --git a/rust/hook-janitor/src/webhooks.rs b/rust/hook-janitor/src/webhooks.rs
index c523a4c59da55..c588c4e27c34c 100644
--- a/rust/hook-janitor/src/webhooks.rs
+++ b/rust/hook-janitor/src/webhooks.rs
@@ -3,10 +3,9 @@ use std::time::{Duration, Instant};
 
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
-use futures::future::join_all;
 use hook_common::webhook::WebhookJobError;
 use rdkafka::error::KafkaError;
-use rdkafka::producer::{FutureProducer, FutureRecord};
+use rdkafka::producer::FutureProducer;
 use serde::Serialize;
 use serde_json::error::Error as SerdeError;
 use sqlx::postgres::{PgConnectOptions, PgPool, PgPoolOptions, Postgres};
@@ -17,10 +16,10 @@ use tracing::{debug, error, info};
 
 use crate::cleanup::Cleaner;
 
+use common_kafka::kafka_messages::app_metrics::{AppMetric, AppMetricCategory};
+use common_kafka::kafka_messages::app_metrics2::{self, AppMetric2};
+use common_kafka::kafka_producer::{send_iter_to_kafka, KafkaContext, KafkaProduceError};
 use common_metrics::get_current_timestamp_seconds;
-use hook_common::kafka_messages::app_metrics::{AppMetric, AppMetricCategory};
-use hook_common::kafka_messages::app_metrics2::{self, AppMetric2};
-use hook_common::kafka_producer::KafkaContext;
 
 #[derive(Error, Debug)]
 pub enum WebhookCleanerError {
@@ -204,8 +203,6 @@ struct QueueDepth {
     count_retries: i64,
 }
 
-// TODO: Extract this to a more generic function that produces any iterable that can be
-// serialized, and returns more generic errors.
 async fn send_metrics_to_kafka<T>(
     kafka_producer: &FutureProducer<KafkaContext>,
     topic: &str,
@@ -214,46 +211,18 @@ async fn send_metrics_to_kafka<T>(
 where
     T: Serialize,
 {
-    let mut payloads = Vec::new();
-
-    for metric in metrics {
-        let payload = serde_json::to_string(&metric)
-            .map_err(|e| WebhookCleanerError::SerializeRowsError { error: e })?;
-        payloads.push(payload);
-    }
-
-    if payloads.is_empty() {
-        return Ok(());
-    }
-
-    let mut delivery_futures = Vec::new();
-
-    for payload in payloads {
-        match kafka_producer.send_result(FutureRecord {
-            topic,
-            payload: Some(&payload),
-            partition: None,
-            key: None::<&str>,
-            timestamp: None,
-            headers: None,
-        }) {
-            Ok(future) => delivery_futures.push(future),
-            Err((error, _)) => return Err(WebhookCleanerError::KafkaProduceError { error }),
+    match send_iter_to_kafka(kafka_producer, topic, metrics).await {
+        Ok(()) => Ok(()),
+        Err(KafkaProduceError::SerializationError { error }) => {
+            Err(WebhookCleanerError::SerializeRowsError { error })
         }
-    }
-
-    for result in join_all(delivery_futures).await {
-        match result {
-            Ok(Ok(_)) => {}
-            Ok(Err((error, _))) => return Err(WebhookCleanerError::KafkaProduceError { error }),
-            Err(_) => {
-                // Cancelled due to timeout while retrying
-                return Err(WebhookCleanerError::KafkaProduceCanceled);
-            }
+        Err(KafkaProduceError::KafkaProduceError { error }) => {
+            Err(WebhookCleanerError::KafkaProduceError { error })
+        }
+        Err(KafkaProduceError::KafkaProduceCanceled) => {
+            Err(WebhookCleanerError::KafkaProduceCanceled)
         }
     }
-
-    Ok(())
 }
 
 // A simple wrapper type that ensures we don't use any old Transaction object when we need one
@@ -658,12 +627,12 @@ impl Cleaner for WebhookCleaner {
 mod tests {
     use super::*;
 
-    use hook_common::kafka_messages::app_metrics::{
+    use common_kafka::kafka_messages::app_metrics::{
         Error as WebhookError, ErrorDetails, ErrorType,
     };
+    use common_kafka::test::create_mock_kafka;
     use hook_common::pgqueue::PgQueueJob;
     use hook_common::pgqueue::{NewJob, PgQueue, PgTransactionBatch};
-    use hook_common::test::create_mock_kafka;
     use hook_common::webhook::{HttpMethod, WebhookJobMetadata, WebhookJobParameters};
     use rdkafka::consumer::{Consumer, StreamConsumer};
     use rdkafka::types::{RDKafkaApiKey, RDKafkaRespErr};
diff --git a/rust/hook-worker/Cargo.toml b/rust/hook-worker/Cargo.toml
index f7aaf59c75298..fdc6f150dfec9 100644
--- a/rust/hook-worker/Cargo.toml
+++ b/rust/hook-worker/Cargo.toml
@@ -26,7 +26,8 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 url = { version = "2.2" }
 common-metrics = { path = "../common/metrics" }
-common-dns = { path =  "../common/dns" }
+common-dns = { path = "../common/dns" }
+common-kafka = { path = "../common/kafka" }
 
 [dev-dependencies]
 httpmock = { workspace = true }
diff --git a/rust/hook-worker/src/config.rs b/rust/hook-worker/src/config.rs
index 1fa6c04638698..4739df2fb3b38 100644
--- a/rust/hook-worker/src/config.rs
+++ b/rust/hook-worker/src/config.rs
@@ -3,7 +3,7 @@ use std::time;
 
 use envconfig::Envconfig;
 
-use hook_common::config::KafkaConfig;
+use common_kafka::config::KafkaConfig;
 
 #[derive(Envconfig, Clone)]
 pub struct Config {
diff --git a/rust/hook-worker/src/main.rs b/rust/hook-worker/src/main.rs
index 798586bc6ed5e..0aeae27e0a3a0 100644
--- a/rust/hook-worker/src/main.rs
+++ b/rust/hook-worker/src/main.rs
@@ -6,9 +6,9 @@ use hook_common::pgqueue::PgQueue;
 use hook_common::retry::RetryPolicy;
 use std::future::ready;
 
+use common_kafka::kafka_producer::create_kafka_producer;
 use common_metrics::{serve, setup_metrics_routes};
 use health::HealthRegistry;
-use hook_common::kafka_producer::create_kafka_producer;
 use hook_worker::config::Config;
 use hook_worker::error::WorkerError;
 use hook_worker::worker::WebhookWorker;
diff --git a/rust/hook-worker/src/worker.rs b/rust/hook-worker/src/worker.rs
index bba15cd67c9a4..c68cdfc3f0cda 100644
--- a/rust/hook-worker/src/worker.rs
+++ b/rust/hook-worker/src/worker.rs
@@ -15,7 +15,7 @@ use tokio::sync;
 use tokio::time::{sleep, Duration};
 use tracing::error;
 
-use hook_common::kafka_producer::KafkaContext;
+use common_kafka::kafka_producer::KafkaContext;
 use hook_common::pgqueue::PgTransactionBatch;
 use hook_common::{
     pgqueue::{Job, PgQueue, PgQueueJob, PgTransactionJob, RetryError, RetryInvalidError},
@@ -793,9 +793,9 @@ mod tests {
     // Note we are ignoring some warnings in this module.
     // This is due to a long-standing cargo bug that reports imports and helper functions as unused.
     // See: https://github.com/rust-lang/rust/issues/46379.
+    use common_kafka::test::create_mock_kafka;
     use health::HealthRegistry;
     use hook_common::pgqueue::{DatabaseError, NewJob};
-    use hook_common::test::create_mock_kafka;
     use hook_common::webhook::WebhookJobMetadata;
     use sqlx::PgPool;
 
diff --git a/rust/property-defs-rs/Cargo.toml b/rust/property-defs-rs/Cargo.toml
index 534977b5fedd8..6deb3bc0c22f7 100644
--- a/rust/property-defs-rs/Cargo.toml
+++ b/rust/property-defs-rs/Cargo.toml
@@ -22,6 +22,7 @@ chrono = { workspace = true }
 quick_cache = { workspace = true }
 common-metrics = { path = "../common/metrics" }
 ahash = { workspace = true }
+uuid = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/rust/property-defs-rs/README.md b/rust/property-defs-rs/README.md
new file mode 100644
index 0000000000000..b4fd40c273a05
--- /dev/null
+++ b/rust/property-defs-rs/README.md
@@ -0,0 +1,5 @@
+# Event and property definitions generator (propdefs for short)
+
+This consumes events from `clickhouse_events_json` and writes event and property definitions to postgres. It filters DB updates to avoid duplicate writes (writes are idempotent, but the DB load of writing every property definition every time would be too high).
+
+Hoglets should check out [the runbook](http://runbooks/ingestion/property-defs-rs) for a detailed breakdown of how it's tuned for our current scale, and what metrics to look at and levers to pull if responding to an incident.
diff --git a/rust/property-defs-rs/src/app_context.rs b/rust/property-defs-rs/src/app_context.rs
index 1ac2a97d4a842..cfd86d7839193 100644
--- a/rust/property-defs-rs/src/app_context.rs
+++ b/rust/property-defs-rs/src/app_context.rs
@@ -1,32 +1,128 @@
 use health::{HealthHandle, HealthRegistry};
+use quick_cache::sync::Cache;
+use sqlx::{postgres::PgPoolOptions, PgPool};
+use time::Duration;
 
-use crate::{config::Config, metrics_consts::UPDATES_ISSUED, types::Update};
+use crate::{
+    config::Config,
+    metrics_consts::{
+        CACHE_WARMING_STATE, GROUP_TYPE_READS, GROUP_TYPE_RESOLVE_TIME, UPDATES_ISSUED,
+        UPDATE_TRANSACTION_TIME,
+    },
+    types::{GroupType, Update},
+};
 
 pub struct AppContext {
-    //pub pool: PgPool,
+    pub pool: PgPool,
     pub liveness: HealthRegistry,
     pub worker_liveness: HealthHandle,
+    pub cache_warming_delay: Duration,
+    pub cache_warming_cutoff: f64,
+    pub skip_writes: bool,
+    pub skip_reads: bool,
+    pub group_type_cache: Cache<String, i32>,
 }
 
 impl AppContext {
-    pub async fn new(_config: &Config) -> Result<Self, sqlx::Error> {
-        //let options = PgPoolOptions::new().max_connections(config.max_pg_connections);
-        //let pool = options.connect(&config.database_url).await?;
+    pub async fn new(config: &Config) -> Result<Self, sqlx::Error> {
+        let options = PgPoolOptions::new().max_connections(config.max_pg_connections);
+        let pool = options.connect(&config.database_url).await?;
 
         let liveness: HealthRegistry = HealthRegistry::new("liveness");
         let worker_liveness = liveness
-            .register("worker".to_string(), time::Duration::seconds(60))
+            .register("worker".to_string(), Duration::seconds(60))
             .await;
 
+        let group_type_cache = Cache::new(config.group_type_cache_size);
+
         Ok(Self {
-            //pool,
+            pool,
             liveness,
             worker_liveness,
+            cache_warming_delay: Duration::milliseconds(config.cache_warming_delay_ms as i64),
+            cache_warming_cutoff: 0.9,
+            skip_writes: config.skip_writes,
+            skip_reads: config.skip_reads,
+            group_type_cache,
         })
     }
 
-    pub async fn issue(&self, updates: Vec<Update>) -> Result<(), sqlx::Error> {
-        metrics::counter!(UPDATES_ISSUED).increment(updates.len() as u64);
+    pub async fn issue(
+        &self,
+        mut updates: Vec<Update>,
+        cache_consumed: f64,
+    ) -> Result<(), sqlx::Error> {
+        if cache_consumed < self.cache_warming_cutoff {
+            metrics::gauge!(CACHE_WARMING_STATE, &[("state", "warming")]).set(cache_consumed);
+            let to_sleep = self.cache_warming_delay * (1.0 - cache_consumed);
+            tokio::time::sleep(to_sleep.try_into().unwrap()).await;
+        } else {
+            metrics::gauge!(CACHE_WARMING_STATE, &[("state", "hot")]).set(1.0);
+        }
+
+        let update_count = updates.len();
+
+        let group_type_resolve_time = common_metrics::timing_guard(GROUP_TYPE_RESOLVE_TIME, &[]);
+        self.resolve_group_types_indexes(&mut updates).await?;
+        group_type_resolve_time.fin();
+
+        let transaction_time = common_metrics::timing_guard(UPDATE_TRANSACTION_TIME, &[]);
+        if !self.skip_writes && !self.skip_reads {
+            let mut tx = self.pool.begin().await?;
+
+            for update in updates {
+                update.issue(&mut *tx).await?;
+            }
+            tx.commit().await?;
+        }
+        transaction_time.fin();
+
+        metrics::counter!(UPDATES_ISSUED).increment(update_count as u64);
+        Ok(())
+    }
+
+    async fn resolve_group_types_indexes(&self, updates: &mut [Update]) -> Result<(), sqlx::Error> {
+        if self.skip_reads {
+            return Ok(());
+        }
+
+        for update in updates {
+            // Only property definitions have group types
+            let Update::Property(update) = update else {
+                continue;
+            };
+            // If we didn't find a group type, we have nothing to resolve.
+            let Some(GroupType::Unresolved(name)) = &update.group_type_index else {
+                continue;
+            };
+
+            let cached = self.group_type_cache.get(name);
+            if let Some(index) = cached {
+                update.group_type_index =
+                    update.group_type_index.take().map(|gti| gti.resolve(index));
+                continue;
+            }
+
+            metrics::counter!(GROUP_TYPE_READS).increment(1);
+
+            let found = sqlx::query_scalar!(
+                    "SELECT group_type_index FROM posthog_grouptypemapping WHERE group_type = $1 AND team_id = $2",
+                    name,
+                    update.team_id
+                )
+                .bind(name)
+                .fetch_optional(&self.pool)
+                .await?;
+
+            if let Some(index) = found {
+                self.group_type_cache.insert(name.to_string(), index);
+                update.group_type_index =
+                    update.group_type_index.take().map(|gti| gti.resolve(index));
+            } else {
+                // If we fail to resolve a group type, we just don't write it
+                update.group_type_index = None;
+            }
+        }
         Ok(())
     }
 }
diff --git a/rust/property-defs-rs/src/config.rs b/rust/property-defs-rs/src/config.rs
index 81864156a3c35..7afe4589944f9 100644
--- a/rust/property-defs-rs/src/config.rs
+++ b/rust/property-defs-rs/src/config.rs
@@ -36,6 +36,25 @@ pub struct Config {
     #[envconfig(default = "1000000")]
     pub cache_capacity: usize,
 
+    // We impose a slow-start, where each batch update operation is delayed by
+    // this many milliseconds, multiplied by the % of the cache currently unused. The idea
+    // is that we want to drip-feed updates to the DB during warmup, since
+    // cache fill rate is highest when it's most empty, and cache fill rate
+    // is exactly equivalent to the rate at which we can issue updates to the DB.
+    // The maths here is:
+    //     max(writes/s) = max_concurrent_transactions * update_batch_size / transaction_seconds
+    // By artificially inflating transaction_time, we put a cap on writes/s. This cap is
+    // then loosened as the cache fills, until we're operating in "normal" mode and
+    // only presenting "true" DB backpressure (in the form of write time) to the main loop.
+    #[envconfig(default = "1000")]
+    pub cache_warming_delay_ms: u32,
+
+    // This is the slow-start cutoff. Once the cache is this full, we
+    // don't delay the batch updates any more. 50% is fine for testing,
+    // in production you want to be using closer to 80-90%
+    #[envconfig(default = "0.5")]
+    pub cache_warming_cutoff: f64,
+
     // Each worker maintains a small local batch of updates, which it
     // flushes to the main thread (updating/filtering by the
     // cross-thread cache while it does). This is that batch size.
@@ -53,6 +72,21 @@ pub struct Config {
     #[envconfig(default = "10000")]
     pub update_count_skip_threshold: usize,
 
+    // Do everything except actually write to the DB
+    #[envconfig(default = "true")]
+    pub skip_writes: bool,
+
+    // Do everything except actually read or write from the DB
+    #[envconfig(default = "true")]
+    pub skip_reads: bool,
+
+    // We maintain a small cache for mapping from group names to group type indexes.
+    // You have very few reasons to ever change this... group type index resolution
+    // is done as a final step before writing an update, and is low-cost even without
+    // caching, compared to the rest of the process.
+    #[envconfig(default = "100000")]
+    pub group_type_cache_size: usize,
+
     #[envconfig(from = "BIND_HOST", default = "::")]
     pub host: String,
 
diff --git a/rust/property-defs-rs/src/main.rs b/rust/property-defs-rs/src/main.rs
index b3155a4207aed..2fa7b94614081 100644
--- a/rust/property-defs-rs/src/main.rs
+++ b/rust/property-defs-rs/src/main.rs
@@ -108,6 +108,8 @@ async fn spawn_producer_loop(
                         Err(TrySendError::Full(update)) => {
                             warn!("Worker blocked");
                             metrics::counter!(WORKER_BLOCKED).increment(1);
+                            // Workers should just die if the channel is dropped, since that indicates
+                            // the main loop is dead.
                             channel.send(update).await.unwrap();
                         }
                         Err(e) => {
@@ -187,16 +189,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
         batch_time.fin();
 
-        metrics::gauge!(CACHE_CONSUMED).set(cache.len() as f64);
-
         metrics::gauge!(TRANSACTION_LIMIT_SATURATION).set(
             (config.max_concurrent_transactions - transaction_limit.available_permits()) as f64,
         );
 
-        // We unconditionally wait to acquire a transaction permit - this is our backpressure mechanism. If we
+        let cache_utilization = cache.len() as f64 / config.cache_capacity as f64;
+        metrics::gauge!(CACHE_CONSUMED).set(cache_utilization);
+
+        // We unconditionally wait to wait for a transaction permit - this is our backpressure mechanism. If we
         // fail to acquire a permit for long enough, we will fail liveness checks (but that implies our ongoing
         // transactions are halted, at which point DB health is a concern).
         let permit_acquire_time = common_metrics::timing_guard(PERMIT_WAIT_TIME, &[]);
+        // This semaphore will never be closed.
         let permit = transaction_limit.clone().acquire_owned().await.unwrap();
         permit_acquire_time.fin();
 
@@ -204,7 +208,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         tokio::spawn(async move {
             let _permit = permit;
             let issue_time = common_metrics::timing_guard(UPDATE_ISSUE_TIME, &[]);
-            context.issue(batch).await.unwrap();
+            if let Err(e) = context.issue(batch, cache_utilization).await {
+                warn!("Issue failed: {:?}", e);
+            }
             issue_time.fin();
         });
     }
diff --git a/rust/property-defs-rs/src/metrics_consts.rs b/rust/property-defs-rs/src/metrics_consts.rs
index 0c4ac2f297ad3..e9920c0c6cb1c 100644
--- a/rust/property-defs-rs/src/metrics_consts.rs
+++ b/rust/property-defs-rs/src/metrics_consts.rs
@@ -15,3 +15,8 @@ pub const UPDATE_ISSUE_TIME: &str = "prop_defs_update_issue_time_ms";
 pub const CACHE_CONSUMED: &str = "prop_defs_cache_space";
 pub const RECV_DEQUEUED: &str = "prop_defs_recv_dequeued";
 pub const COMPACTED_UPDATES: &str = "prop_defs_compaction_dropped_updates";
+pub const CACHE_WARMING_STATE: &str = "prop_defs_cache_state";
+pub const UPDATE_TRANSACTION_TIME: &str = "prop_defs_update_transaction_time_ms";
+pub const GROUP_TYPE_RESOLVE_TIME: &str = "prop_defs_group_type_resolve_time_ms";
+pub const UPDATES_SKIPPED: &str = "prop_defs_skipped_updates";
+pub const GROUP_TYPE_READS: &str = "prop_defs_group_type_reads";
diff --git a/rust/property-defs-rs/src/types.rs b/rust/property-defs-rs/src/types.rs
index 5242ec921b67b..dcff22785af79 100644
--- a/rust/property-defs-rs/src/types.rs
+++ b/rust/property-defs-rs/src/types.rs
@@ -3,10 +3,16 @@ use std::{fmt, hash::Hash, str::FromStr};
 use chrono::{DateTime, Duration, DurationRound, RoundingError, Utc};
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
+use sqlx::{Executor, Postgres};
 use tracing::warn;
+use uuid::Uuid;
 
-use crate::metrics_consts::EVENTS_SKIPPED;
+use crate::metrics_consts::{EVENTS_SKIPPED, UPDATES_SKIPPED};
 
+// We skip updates for events we generate
+pub const EVENTS_WITHOUT_PROPERTIES: [&str; 1] = ["$$plugin_metrics"];
+
+// These properties have special meaning, and are ignored
 pub const SKIP_PROPERTIES: [&str; 9] = [
     "$set",
     "$set_once",
@@ -44,7 +50,7 @@ pub enum PropertyValueType {
     String,
     Numeric,
     Boolean,
-    Duration,
+    Duration, // Unused, but exists.
 }
 
 impl fmt::Display for PropertyValueType {
@@ -66,13 +72,22 @@ pub enum GroupType {
     Resolved(String, i32),
 }
 
+impl GroupType {
+    pub fn resolve(self, index: i32) -> Self {
+        match self {
+            GroupType::Unresolved(name) => GroupType::Resolved(name, index),
+            GroupType::Resolved(name, _) => GroupType::Resolved(name, index),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PropertyDefinition {
     pub team_id: i32,
     pub name: String,
     pub is_numerical: bool,
     pub property_type: Option<PropertyValueType>,
-    pub event_type: Option<PropertyParentType>,
+    pub event_type: PropertyParentType,
     pub group_type_index: Option<GroupType>,
     pub property_type_format: Option<String>, // Deprecated
     pub volume_30_day: Option<i64>,           // Deprecated
@@ -102,6 +117,19 @@ pub enum Update {
     EventProperty(EventProperty),
 }
 
+impl Update {
+    pub async fn issue<'c, E>(&self, executor: E) -> Result<(), sqlx::Error>
+    where
+        E: Executor<'c, Database = Postgres>,
+    {
+        match self {
+            Update::Event(e) => e.issue(executor).await,
+            Update::Property(p) => p.issue(executor).await,
+            Update::EventProperty(ep) => ep.issue(executor).await,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Event {
     pub team_id: i32,
@@ -115,7 +143,9 @@ impl From<&Event> for EventDefinition {
             name: sanitize_event_name(&event.event),
             team_id: event.team_id,
             // We round last seen to the nearest day, as per the TS impl. Unwrap is safe here because we
-            // the duration is positive, non-zero, and smaller than time since epoch
+            // the duration is positive, non-zero, and smaller than time since epoch. We use this
+            // in the hash value, so updates which would modify this in the DB are issued even
+            // if another otherwise-identical event definition is in the cache
             last_seen_at: floor_datetime(Utc::now(), Duration::days(1)).unwrap(),
         }
     }
@@ -123,6 +153,17 @@ impl From<&Event> for EventDefinition {
 
 impl Event {
     pub fn into_updates(self, skip_threshold: usize) -> Vec<Update> {
+        if EVENTS_WITHOUT_PROPERTIES.contains(&self.event.as_str()) {
+            metrics::counter!(EVENTS_SKIPPED, &[("reason", "no_properties_event")]).increment(1);
+            return vec![];
+        }
+
+        if !will_fit_in_postgres_column(&self.event) {
+            metrics::counter!(EVENTS_SKIPPED, &[("reason", "name_wont_fit_in_postgres")])
+                .increment(1);
+            return vec![];
+        }
+
         let team_id = self.team_id;
         let event = self.event.clone();
 
@@ -132,7 +173,7 @@ impl Event {
                 "Event {} for team {} has more than 10,000 properties, skipping",
                 event, team_id
             );
-            metrics::counter!(EVENTS_SKIPPED).increment(1);
+            metrics::counter!(EVENTS_SKIPPED, &[("reason", "too_many_properties")]).increment(1);
             return vec![];
         }
 
@@ -209,6 +250,15 @@ impl Event {
                 continue;
             }
 
+            if !will_fit_in_postgres_column(key) {
+                metrics::counter!(
+                    UPDATES_SKIPPED,
+                    &[("reason", "property_name_wont_fit_in_postgres")]
+                )
+                .increment(2); // We're skipping one EventProperty, and one PropertyDefinition
+                continue;
+            }
+
             updates.push(Update::EventProperty(EventProperty {
                 team_id: self.team_id,
                 event: self.event.clone(),
@@ -223,7 +273,7 @@ impl Event {
                 name: key.clone(),
                 is_numerical,
                 property_type,
-                event_type: Some(parent_type),
+                event_type: parent_type,
                 group_type_index: group_type.clone(),
                 property_type_format: None,
                 volume_30_day: None,
@@ -333,7 +383,10 @@ impl Hash for GroupType {
     }
 }
 
-fn floor_datetime(dt: DateTime<Utc>, duration: Duration) -> Result<DateTime<Utc>, RoundingError> {
+pub fn floor_datetime(
+    dt: DateTime<Utc>,
+    duration: Duration,
+) -> Result<DateTime<Utc>, RoundingError> {
     let rounded = dt.duration_round(duration)?;
 
     // If we rounded up
@@ -343,3 +396,86 @@ fn floor_datetime(dt: DateTime<Utc>, duration: Duration) -> Result<DateTime<Utc>
         Ok(rounded)
     }
 }
+
+// We impose some limits on some fields for legacy reasons, and drop updates that don't conform to them
+pub const DJANGO_MAX_CHARFIELD_LENGTH: usize = 400;
+fn will_fit_in_postgres_column(str: &str) -> bool {
+    str.len() <= DJANGO_MAX_CHARFIELD_LENGTH / 2
+}
+
+// Postgres doesn't like nulls in strings, so we replace them with uFFFD.
+// This allocates, so only do it right when hitting the DB. We handle nulls
+// in strings just fine.
+pub fn sanitize_string(s: &str) -> String {
+    s.replace('\u{0000}', "\u{FFFD}")
+}
+
+// The queries below are pulled more-or-less exactly from the TS impl.
+
+impl EventDefinition {
+    pub async fn issue<'c, E>(&self, executor: E) -> Result<(), sqlx::Error>
+    where
+        E: Executor<'c, Database = Postgres>,
+    {
+        sqlx::query!(
+            r#"
+            INSERT INTO posthog_eventdefinition (id, name, volume_30_day, query_usage_30_day, team_id, last_seen_at, created_at)
+            VALUES ($1, $2, NULL, NULL, $3, $4, NOW()) ON CONFLICT
+            ON CONSTRAINT posthog_eventdefinition_team_id_name_80fa0b87_uniq
+            DO UPDATE SET last_seen_at = $4
+        "#,
+            Uuid::now_v7(),
+            self.name,
+            self.team_id,
+            self.last_seen_at
+        ).execute(executor).await.map(|_| ())
+    }
+}
+
+impl PropertyDefinition {
+    pub async fn issue<'c, E>(&self, executor: E) -> Result<(), sqlx::Error>
+    where
+        E: Executor<'c, Database = Postgres>,
+    {
+        let group_type_index = match &self.group_type_index {
+            Some(GroupType::Resolved(_, i)) => Some(*i as i16),
+            _ => {
+                warn!("Group type not resolved for property definition, skipping");
+                None
+            }
+        };
+
+        sqlx::query!(
+            r#"
+            INSERT INTO posthog_propertydefinition (id, name, type, group_type_index, is_numerical, volume_30_day, query_usage_30_day, team_id, property_type)
+            VALUES ($1, $2, $3, $4, $5, NULL, NULL, $6, $7)
+            ON CONFLICT (team_id, name, type, coalesce(group_type_index, -1))
+            DO UPDATE SET property_type=EXCLUDED.property_type WHERE posthog_propertydefinition.property_type IS NULL
+        "#,
+            Uuid::now_v7(),
+            self.name,
+            self.event_type as i16,
+            group_type_index,
+            self.is_numerical,
+            self.team_id,
+            self.property_type.as_ref().map(|t| t.to_string())
+        ).execute(executor).await.map(|_| ())
+    }
+}
+
+impl EventProperty {
+    pub async fn issue<'c, E>(&self, executor: E) -> Result<(), sqlx::Error>
+    where
+        E: Executor<'c, Database = Postgres>,
+    {
+        sqlx::query!(
+            r#"INSERT INTO posthog_eventproperty (event, property, team_id) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING"#,
+            self.event,
+            self.property,
+            self.team_id
+        )
+        .execute(executor)
+        .await
+        .map(|_| ())
+    }
+}
diff --git a/rust/property-defs-rs/tests/test_migrations/20240830124836_setup_propdefs_tables.sql b/rust/property-defs-rs/tests/test_migrations/20240830124836_setup_propdefs_tables.sql
new file mode 100644
index 0000000000000..ec83e55a73dae
--- /dev/null
+++ b/rust/property-defs-rs/tests/test_migrations/20240830124836_setup_propdefs_tables.sql
@@ -0,0 +1,41 @@
+-- These mimic the posthog main-db property, event and event-property tables, and are only used
+-- for testing (so we can use `sqlx::test`)
+
+-- Create a unique contraint on posthog_eventdefinition for team_id and name, matching the django one
+
+CREATE TABLE IF NOT EXISTS posthog_eventdefinition (
+    id UUID PRIMARY KEY,
+    name TEXT NOT NULL,
+    volume_30_day INTEGER,
+    query_usage_30_day INTEGER,
+    team_id INTEGER NOT NULL,
+    last_seen_at TIMESTAMPTZ NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL,
+    CONSTRAINT posthog_eventdefinition_team_id_name_80fa0b87_uniq UNIQUE (team_id, name)
+);
+
+
+CREATE TABLE IF NOT EXISTS posthog_propertydefinition (
+    id UUID PRIMARY KEY,
+    name VARCHAR(400) NOT NULL,
+    is_numerical BOOLEAN NOT NULL,
+    query_usage_30_day INTEGER,
+    property_type VARCHAR(50),
+    property_type_format VARCHAR(50),
+    volume_30_day INTEGER,
+    team_id INTEGER NOT NULL,
+    group_type_index SMALLINT,
+    type SMALLINT NOT NULL DEFAULT 1
+);
+
+CREATE UNIQUE INDEX posthog_propertydefinition_uniq ON posthog_propertydefinition (team_id, name, type, coalesce(group_type_index, -1));
+
+
+CREATE TABLE IF NOT EXISTS posthog_eventproperty (
+    id SERIAL PRIMARY KEY,
+    event VARCHAR(400)NOT NULL,
+    property VARCHAR(400) NOT NULL,
+    team_id INTEGER NOT NULL
+);
+
+CREATE UNIQUE INDEX posthog_event_property_unique_team_event_property ON posthog_eventproperty (team_id, event, property);
\ No newline at end of file
diff --git a/rust/property-defs-rs/tests/updates.rs b/rust/property-defs-rs/tests/updates.rs
new file mode 100644
index 0000000000000..c907909c0e459
--- /dev/null
+++ b/rust/property-defs-rs/tests/updates.rs
@@ -0,0 +1,148 @@
+use chrono::{DateTime, Duration, Utc};
+use property_defs_rs::types::{floor_datetime, Event, PropertyParentType, PropertyValueType};
+use serde_json::json;
+use sqlx::PgPool;
+
+#[sqlx::test(migrations = "./tests/test_migrations")]
+async fn test_updates(db: PgPool) {
+    let properties = r#"
+        {
+            "TIMESTAMP": 5424245435435435,
+            "some_string": "some_value",
+            "some_int": 42,
+            "some_float": 3.14,
+            "some_bool": true,
+            "some_bool_as_string": "true"
+        }
+    "#;
+
+    let event_src = json!({
+        "team_id": 1,
+        "event": "update",
+        "properties": properties
+    });
+
+    // Test fanout limiting
+    let event = serde_json::from_value::<Event>(event_src.clone()).unwrap();
+    let updates = event.into_updates(10);
+    assert_eq!(updates.len(), 0);
+
+    // Test that the event is correctly split into updates
+    let event = serde_json::from_value::<Event>(event_src).unwrap();
+    let updates = event.into_updates(1000);
+    assert!(updates.len() == 13);
+
+    // issue them, and then query the database to see that everthing we expect to exist does
+    for update in updates {
+        update.issue(&db).await.unwrap();
+    }
+
+    let today = floor_datetime(Utc::now(), Duration::days(1)).unwrap();
+
+    assert_eventdefinition_exists(&db, "update", 1, today).await;
+    assert_propertydefinition_exists(
+        &db,
+        "TIMESTAMP",
+        PropertyParentType::Event,
+        false,
+        1,
+        PropertyValueType::DateTime,
+    )
+    .await;
+    assert_propertydefinition_exists(
+        &db,
+        "some_string",
+        PropertyParentType::Event,
+        false,
+        1,
+        PropertyValueType::String,
+    )
+    .await;
+    assert_propertydefinition_exists(
+        &db,
+        "some_int",
+        PropertyParentType::Event,
+        true,
+        1,
+        PropertyValueType::Numeric,
+    )
+    .await;
+    assert_propertydefinition_exists(
+        &db,
+        "some_float",
+        PropertyParentType::Event,
+        true,
+        1,
+        PropertyValueType::Numeric,
+    )
+    .await;
+    assert_propertydefinition_exists(
+        &db,
+        "some_bool",
+        PropertyParentType::Event,
+        false,
+        1,
+        PropertyValueType::Boolean,
+    )
+    .await;
+    assert_propertydefinition_exists(
+        &db,
+        "some_bool_as_string",
+        PropertyParentType::Event,
+        false,
+        1,
+        PropertyValueType::Boolean,
+    )
+    .await;
+}
+
+async fn assert_eventdefinition_exists(
+    db: &PgPool,
+    name: &str,
+    team_id: i32,
+    last_seen_at: DateTime<Utc>,
+) {
+    let count: Option<i64> = sqlx::query_scalar(
+        r#"
+        SELECT COUNT(*)
+        FROM posthog_eventdefinition
+        WHERE name = $1 AND team_id = $2 AND last_seen_at = $3
+        "#,
+    )
+    .bind(name)
+    .bind(team_id)
+    .bind(last_seen_at)
+    .fetch_one(db)
+    .await
+    .unwrap();
+
+    assert_eq!(count, Some(1));
+}
+
+async fn assert_propertydefinition_exists(
+    db: &PgPool,
+    name: &str,
+    event_type: PropertyParentType,
+    is_numerical: bool,
+    team_id: i32,
+    property_type: PropertyValueType,
+) {
+    println!("Checking property definition for {}", name);
+    let count: Option<i64> = sqlx::query_scalar(
+        r#"
+        SELECT COUNT(*)
+        FROM posthog_propertydefinition
+        WHERE name = $1 AND type = $2 AND is_numerical = $3 AND team_id = $4 AND property_type = $5
+        "#,
+    )
+    .bind(name)
+    .bind(event_type as i32)
+    .bind(is_numerical)
+    .bind(team_id)
+    .bind(property_type.to_string())
+    .fetch_one(db)
+    .await
+    .unwrap();
+
+    assert_eq!(count, Some(1));
+}