From 918f1ff3a2ac6fbb722d355b53aec49ccad30fe7 Mon Sep 17 00:00:00 2001
From: Sandy Spicer <sandy@posthog.com>
Date: Tue, 21 Oct 2025 12:30:07 -0700
Subject: [PATCH] feat: ui & crud for schema management (#39288)

Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
---
 .../panel-layout/ProjectTree/defaultTree.tsx  |  11 +-
 .../layout/scenes/components/SceneSection.tsx |   4 +-
 frontend/src/lib/api.ts                       |  55 ++++
 frontend/src/lib/constants.tsx                |   1 +
 .../data-management/DataManagementScene.tsx   |   8 +
 .../definition/DefinitionView.tsx             |   7 +
 .../events/EventDefinitionSchema.tsx          | 135 +++++++++
 .../events/eventDefinitionSchemaLogic.test.ts | 113 +++++++
 .../events/eventDefinitionSchemaLogic.ts      | 139 +++++++++
 .../schema/PropertyGroupModal.tsx             | 190 ++++++++++++
 .../schema/SchemaManagement.tsx               | 225 ++++++++++++++
 .../schema/SelectPropertyGroupModal.tsx       | 169 +++++++++++
 .../schema/schemaManagementLogic.ts           | 282 ++++++++++++++++++
 frontend/src/scenes/scenes.ts                 |   1 +
 frontend/src/scenes/urls.ts                   |   1 +
 .../__snapshots__/pageview-trends-insight.png | Bin 35919 -> 35485 bytes
 posthog/api/__init__.py                       |  14 +
 posthog/api/event_schema.py                   |  98 ++++++
 posthog/api/schema_property_group.py          | 173 +++++++++++
 .../api/test/test_schema_property_group.py    | 248 +++++++++++++++
 posthog/demo/products/hedgebox/matrix.py      |  56 ++++
 posthog/demo/products/hedgebox/models.py      |  31 +-
 posthog/migrations/0889_add_schema_models.py  | 155 ++++++++++
 posthog/migrations/max_migration.txt          |   2 +-
 posthog/models/__init__.py                    |   4 +
 posthog/models/schema.py                      | 123 ++++++++
 products/actions/manifest.tsx                 |   2 +-
 products/revenue_analytics/manifest.tsx       |   4 +-
 28 files changed, 2233 insertions(+), 18 deletions(-)
 create mode 100644 frontend/src/scenes/data-management/events/EventDefinitionSchema.tsx
 create mode 100644 frontend/src/scenes/data-management/events/eventDefinitionSchemaLogic.test.ts
 create mode 100644 frontend/src/scenes/data-management/events/eventDefinitionSchemaLogic.ts
 create mode 100644 frontend/src/scenes/data-management/schema/PropertyGroupModal.tsx
 create mode 100644 frontend/src/scenes/data-management/schema/SchemaManagement.tsx
 create mode 100644 frontend/src/scenes/data-management/schema/SelectPropertyGroupModal.tsx
 create mode 100644 frontend/src/scenes/data-management/schema/schemaManagementLogic.ts
 create mode 100644 posthog/api/event_schema.py
 create mode 100644 posthog/api/schema_property_group.py
 create mode 100644 posthog/api/test/test_schema_property_group.py
 create mode 100644 posthog/migrations/0889_add_schema_models.py
 create mode 100644 posthog/models/schema.py

diff --git a/frontend/src/layout/panel-layout/ProjectTree/defaultTree.tsx b/frontend/src/layout/panel-layout/ProjectTree/defaultTree.tsx
index eea32a6706..4711e08a84 100644
--- a/frontend/src/layout/panel-layout/ProjectTree/defaultTree.tsx
+++ b/frontend/src/layout/panel-layout/ProjectTree/defaultTree.tsx
@@ -361,18 +361,25 @@ export const getDefaultTreeData = (): FileSystemImport[] => [
     ...getTreeItemsMetadata(),
     {
         path: 'Event definitions',
-        category: 'Definitions',
+        category: 'Schema',
         iconType: 'event_definition',
         href: urls.eventDefinitions(),
         sceneKey: 'EventDefinition',
     },
     {
         path: 'Property definitions',
-        category: 'Definitions',
+        category: 'Schema',
         iconType: 'property_definition',
         href: urls.propertyDefinitions(),
         sceneKey: 'PropertyDefinition',
     },
+    {
+        path: 'Property groups',
+        category: 'Schema',
+        iconType: 'event_definition',
+        href: urls.schemaManagement(),
+        flag: FEATURE_FLAGS.SCHEMA_MANAGEMENT,
+    },
     {
         path: 'Annotations',
         category: 'Metadata',
diff --git a/frontend/src/layout/scenes/components/SceneSection.tsx b/frontend/src/layout/scenes/components/SceneSection.tsx
index 4da58586fe..f8b231426d 100644
--- a/frontend/src/layout/scenes/components/SceneSection.tsx
+++ b/frontend/src/layout/scenes/components/SceneSection.tsx
@@ -48,7 +48,7 @@ export function SceneSection({
                         </Component>
                         {description && <p className="text-sm text-secondary my-0 max-w-prose">{description}</p>}
                     </div>
-                    {actions && <div className="flex gap-x-2 flex-none self-center">{actions}</div>}
+                    {actions && <div className="flex gap-x-2 flex-none self-end">{actions}</div>}
                 </div>
                 <WrappingLoadingSkeleton>{children}</WrappingLoadingSkeleton>
             </div>
@@ -77,7 +77,7 @@ export function SceneSection({
                         </Component>
                         {description && <p className="text-sm text-secondary my-0 max-w-prose">{description}</p>}
                     </div>
-                    {actions && <div className="flex gap-x-2 flex-none self-center">{actions}</div>}
+                    {actions && <div className="flex gap-x-2 flex-none self-end">{actions}</div>}
                 </div>
             )}
             {children}
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index 61efa9f774..a268210929 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -8,6 +8,8 @@ import { dayjs } from 'lib/dayjs'
 import { apiStatusLogic } from 'lib/logic/apiStatusLogic'
 import { humanFriendlyDuration, objectClean, toParams } from 'lib/utils'
 import { CohortCalculationHistoryResponse } from 'scenes/cohorts/cohortCalculationHistorySceneLogic'
+import { EventSchema } from 'scenes/data-management/events/eventDefinitionSchemaLogic'
+import { SchemaPropertyGroup } from 'scenes/data-management/schema/schemaManagementLogic'
 import { MaxBillingContext } from 'scenes/max/maxBillingContextLogic'
 import { NotebookListItemType, NotebookNodeResource, NotebookType } from 'scenes/notebooks/types'
 import { RecordingComment } from 'scenes/session-recordings/player/inspector/playerInspectorLogic'
@@ -653,6 +655,22 @@ export class ApiRequest {
         return this.projectsDetail(teamId).addPathComponent('sessions').addPathComponent('property_definitions')
     }
 
+    public schemaPropertyGroups(projectId?: ProjectType['id']): ApiRequest {
+        return this.projectsDetail(projectId).addPathComponent('schema_property_groups')
+    }
+
+    public schemaPropertyGroupsDetail(id: string, projectId?: ProjectType['id']): ApiRequest {
+        return this.schemaPropertyGroups(projectId).addPathComponent(id)
+    }
+
+    public eventSchemas(projectId?: ProjectType['id']): ApiRequest {
+        return this.projectsDetail(projectId).addPathComponent('event_schemas')
+    }
+
+    public eventSchemasDetail(id: string, projectId?: ProjectType['id']): ApiRequest {
+        return this.eventSchemas(projectId).addPathComponent(id)
+    }
+
     public dataManagementActivity(teamId?: TeamType['id']): ApiRequest {
         return this.projectsDetail(teamId).addPathComponent('data_management').addPathComponent('activity')
     }
@@ -2256,6 +2274,43 @@ const api = {
         },
     },
 
+    schemaPropertyGroups: {
+        async list(projectId?: ProjectType['id']): Promise<{ results: SchemaPropertyGroup[] }> {
+            return new ApiRequest().schemaPropertyGroups(projectId).get()
+        },
+        async get(id: string, projectId?: ProjectType['id']): Promise<SchemaPropertyGroup> {
+            return new ApiRequest().schemaPropertyGroupsDetail(id, projectId).get()
+        },
+        async create(data: Partial<SchemaPropertyGroup>, projectId?: ProjectType['id']): Promise<SchemaPropertyGroup> {
+            return new ApiRequest().schemaPropertyGroups(projectId).create({ data })
+        },
+        async update(
+            id: string,
+            data: Partial<SchemaPropertyGroup>,
+            projectId?: ProjectType['id']
+        ): Promise<SchemaPropertyGroup> {
+            return new ApiRequest().schemaPropertyGroupsDetail(id, projectId).update({ data })
+        },
+        async delete(id: string, projectId?: ProjectType['id']): Promise<void> {
+            return new ApiRequest().schemaPropertyGroupsDetail(id, projectId).delete()
+        },
+    },
+
+    eventSchemas: {
+        async list(eventDefinitionId: string, projectId?: ProjectType['id']): Promise<{ results: EventSchema[] }> {
+            return new ApiRequest()
+                .eventSchemas(projectId)
+                .withQueryString(toParams({ event_definition: eventDefinitionId }))
+                .get()
+        },
+        async create(data: Partial<EventSchema>, projectId?: ProjectType['id']): Promise<EventSchema> {
+            return new ApiRequest().eventSchemas(projectId).create({ data })
+        },
+        async delete(id: string, projectId?: ProjectType['id']): Promise<void> {
+            return new ApiRequest().eventSchemasDetail(id, projectId).delete()
+        },
+    },
+
     cohorts: {
         async get(cohortId: CohortType['id']): Promise<CohortType> {
             return await new ApiRequest().cohortsDetail(cohortId).get()
diff --git a/frontend/src/lib/constants.tsx b/frontend/src/lib/constants.tsx
index 33f0413702..a7650a410a 100644
--- a/frontend/src/lib/constants.tsx
+++ b/frontend/src/lib/constants.tsx
@@ -226,6 +226,7 @@ export const FEATURE_FLAGS = {
     EXPERIMENT_INTERVAL_TIMESERIES: 'experiments-interval-timeseries', // owner: @jurajmajerik #team-experiments
     EXPERIMENTAL_DASHBOARD_ITEM_RENDERING: 'experimental-dashboard-item-rendering', // owner: @thmsobrmlr #team-product-analytics
     PATHS_V2: 'paths-v2', // owner: @thmsobrmlr #team-product-analytics
+    SCHEMA_MANAGEMENT: 'schema-management', // owner: @aspicer
     SDK_DOCTOR_BETA: 'sdk-doctor-beta', // owner: @slshults
     ONBOARDING_DATA_WAREHOUSE_FOR_PRODUCT_ANALYTICS: 'onboarding-data-warehouse-for-product-analytics', // owner: @joshsny
     DELAYED_LOADING_ANIMATION: 'delayed-loading-animation', // owner: @raquelmsmith
diff --git a/frontend/src/scenes/data-management/DataManagementScene.tsx b/frontend/src/scenes/data-management/DataManagementScene.tsx
index 343757e054..76226570aa 100644
--- a/frontend/src/scenes/data-management/DataManagementScene.tsx
+++ b/frontend/src/scenes/data-management/DataManagementScene.tsx
@@ -32,11 +32,13 @@ import { EventDefinitionsTable } from './events/EventDefinitionsTable'
 import { IngestionWarningsView } from './ingestion-warnings/IngestionWarningsView'
 import { DataWarehouseManagedViewsetsScene } from './managed-viewsets/DataWarehouseManagedViewsetsScene'
 import { PropertyDefinitionsTable } from './properties/PropertyDefinitionsTable'
+import { SchemaManagement } from './schema/SchemaManagement'
 
 export enum DataManagementTab {
     Actions = 'actions',
     EventDefinitions = 'events',
     PropertyDefinitions = 'properties',
+    SchemaManagement = 'schema',
     Annotations = 'annotations',
     Comments = 'comments',
     History = 'history',
@@ -100,6 +102,12 @@ const tabs: Record<DataManagementTab, TabConfig> = {
         content: <PropertyDefinitionsTable />,
         tooltipDocLink: 'https://posthog.com/docs/new-to-posthog/understand-posthog#properties',
     },
+    [DataManagementTab.SchemaManagement]: {
+        url: urls.schemaManagement(),
+        label: 'Property Groups',
+        content: <SchemaManagement />,
+        flag: FEATURE_FLAGS.SCHEMA_MANAGEMENT,
+    },
     [DataManagementTab.Annotations]: {
         url: urls.annotations(),
         content: <Annotations />,
diff --git a/frontend/src/scenes/data-management/definition/DefinitionView.tsx b/frontend/src/scenes/data-management/definition/DefinitionView.tsx
index 5905d8d3a5..556ec904f0 100644
--- a/frontend/src/scenes/data-management/definition/DefinitionView.tsx
+++ b/frontend/src/scenes/data-management/definition/DefinitionView.tsx
@@ -6,12 +6,14 @@ import { IconBadge, IconEye, IconHide, IconInfo } from '@posthog/icons'
 import { LemonTag, LemonTagType, Spinner, Tooltip } from '@posthog/lemon-ui'
 
 import { EditableField } from 'lib/components/EditableField/EditableField'
+import { FlaggedFeature } from 'lib/components/FlaggedFeature'
 import { NotFound } from 'lib/components/NotFound'
 import { ObjectTags } from 'lib/components/ObjectTags/ObjectTags'
 import { TZLabel } from 'lib/components/TZLabel'
 import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
 import { upgradeModalLogic } from 'lib/components/UpgradeModal/upgradeModalLogic'
 import { UserActivityIndicator } from 'lib/components/UserActivityIndicator/UserActivityIndicator'
+import { FEATURE_FLAGS } from 'lib/constants'
 import { LemonButton } from 'lib/lemon-ui/LemonButton'
 import { LemonDialog } from 'lib/lemon-ui/LemonDialog'
 import { SpinnerOverlay } from 'lib/lemon-ui/Spinner/Spinner'
@@ -19,6 +21,7 @@ import { IconPlayCircle } from 'lib/lemon-ui/icons'
 import { DefinitionLogicProps, definitionLogic } from 'scenes/data-management/definition/definitionLogic'
 import { EventDefinitionInsights } from 'scenes/data-management/events/EventDefinitionInsights'
 import { EventDefinitionProperties } from 'scenes/data-management/events/EventDefinitionProperties'
+import { EventDefinitionSchema } from 'scenes/data-management/events/EventDefinitionSchema'
 import { LinkedHogFunctions } from 'scenes/hog-functions/list/LinkedHogFunctions'
 import { SceneExport } from 'scenes/sceneTypes'
 import { urls } from 'scenes/urls'
@@ -353,6 +356,10 @@ export function DefinitionView(props: DefinitionLogicProps): JSX.Element {
 
             {isEvent && definition.id !== 'new' && (
                 <>
+                    <FlaggedFeature flag={FEATURE_FLAGS.SCHEMA_MANAGEMENT}>
+                        <EventDefinitionSchema definition={definition} />
+                        <SceneDivider />
+                    </FlaggedFeature>
                     <EventDefinitionProperties definition={definition} />
                     <SceneDivider />
                     <EventDefinitionInsights definition={definition} />
diff --git a/frontend/src/scenes/data-management/events/EventDefinitionSchema.tsx b/frontend/src/scenes/data-management/events/EventDefinitionSchema.tsx
new file mode 100644
index 0000000000..ba1afc2eb6
--- /dev/null
+++ b/frontend/src/scenes/data-management/events/EventDefinitionSchema.tsx
@@ -0,0 +1,135 @@
+import { useActions, useValues } from 'kea'
+import { useMemo, useState } from 'react'
+
+import { IconPencil, IconPlus, IconTrash } from '@posthog/icons'
+import { LemonButton, LemonTag } from '@posthog/lemon-ui'
+
+import { SceneSection } from '~/layout/scenes/components/SceneSection'
+import { EventDefinition } from '~/types'
+
+import { PropertyGroupModal } from '../schema/PropertyGroupModal'
+import { SelectPropertyGroupModal } from '../schema/SelectPropertyGroupModal'
+import { SchemaPropertyGroupProperty, schemaManagementLogic } from '../schema/schemaManagementLogic'
+import { EventSchema, eventDefinitionSchemaLogic } from './eventDefinitionSchemaLogic'
+
+function PropertyRow({ property }: { property: SchemaPropertyGroupProperty }): JSX.Element {
+    return (
+        <div className="flex items-center gap-4 py-3 px-4 border-b last:border-b-0 bg-white">
+            <div className="flex-1">
+                <span className="font-semibold">{property.name}</span>
+            </div>
+            <div className="w-32">
+                <LemonTag type="muted">{property.property_type}</LemonTag>
+            </div>
+            <div className="w-24">
+                {property.is_required ? (
+                    <LemonTag type="danger">Required</LemonTag>
+                ) : (
+                    <LemonTag type="muted">Optional</LemonTag>
+                )}
+            </div>
+            <div className="flex-1 text-muted">{property.description || '—'}</div>
+        </div>
+    )
+}
+
+export function EventDefinitionSchema({ definition }: { definition: EventDefinition }): JSX.Element {
+    const logic = eventDefinitionSchemaLogic({ eventDefinitionId: definition.id })
+    const { eventSchemas, eventSchemasLoading } = useValues(logic)
+    const { addPropertyGroup, removePropertyGroup, loadAllPropertyGroups } = useActions(logic)
+    const [isModalOpen, setIsModalOpen] = useState(false)
+
+    const schemaLogic = schemaManagementLogic({ key: `event-${definition.id}` })
+    const { setPropertyGroupModalOpen, setEditingPropertyGroup } = useActions(schemaLogic)
+
+    const selectedPropertyGroupIds = useMemo<Set<string>>(
+        () => new Set(eventSchemas.map((schema: EventSchema) => schema.property_group.id)),
+        [eventSchemas]
+    )
+
+    return (
+        <SceneSection
+            title="Schema"
+            description="Define which property groups this event should have. Property groups establish a schema that helps document expected properties."
+            actions={
+                <LemonButton
+                    type="primary"
+                    icon={<IconPlus />}
+                    onClick={() => setIsModalOpen(true)}
+                    disabled={eventSchemasLoading}
+                >
+                    Add Property Group
+                </LemonButton>
+            }
+        >
+            <div className="space-y-4">
+                <SelectPropertyGroupModal
+                    isOpen={isModalOpen}
+                    onClose={() => setIsModalOpen(false)}
+                    onSelect={(propertyGroupId) => addPropertyGroup(propertyGroupId)}
+                    selectedPropertyGroupIds={selectedPropertyGroupIds}
+                    onPropertyGroupCreated={() => {
+                        loadAllPropertyGroups()
+                    }}
+                />
+
+                {eventSchemas.length > 0 ? (
+                    <div className="space-y-4">
+                        {eventSchemas.map((schema: EventSchema) => (
+                            <div key={schema.id} className="border rounded overflow-hidden">
+                                <div className="flex items-center justify-between p-4 bg-bg-light border-b">
+                                    <div className="flex items-center gap-2">
+                                        <span className="font-semibold">{schema.property_group.name}</span>
+                                        <LemonTag type="default">
+                                            {schema.property_group.properties?.length || 0}{' '}
+                                            {schema.property_group.properties?.length === 1 ? 'property' : 'properties'}
+                                        </LemonTag>
+                                    </div>
+                                    <div className="flex gap-1">
+                                        <LemonButton
+                                            icon={<IconPencil />}
+                                            size="small"
+                                            onClick={() => {
+                                                setEditingPropertyGroup(schema.property_group)
+                                                setPropertyGroupModalOpen(true)
+                                            }}
+                                            tooltip="Edit this property group"
+                                        />
+                                        <LemonButton
+                                            icon={<IconTrash />}
+                                            size="small"
+                                            status="danger"
+                                            onClick={() => removePropertyGroup(schema.id)}
+                                            tooltip="Remove this property group from the event schema"
+                                        />
+                                    </div>
+                                </div>
+                                {schema.property_group.properties && schema.property_group.properties.length > 0 && (
+                                    <>
+                                        <div className="flex gap-4 py-2 px-4 bg-accent-3000 border-b text-xs font-semibold uppercase tracking-wider">
+                                            <div className="flex-1">Property</div>
+                                            <div className="w-32">Type</div>
+                                            <div className="w-24">Required</div>
+                                            <div className="flex-1">Description</div>
+                                        </div>
+                                        {schema.property_group.properties.map(
+                                            (property: SchemaPropertyGroupProperty) => (
+                                                <PropertyRow key={property.id} property={property} />
+                                            )
+                                        )}
+                                    </>
+                                )}
+                            </div>
+                        ))}
+                    </div>
+                ) : (
+                    <div className="text-center text-muted py-8 border rounded bg-bg-light">
+                        No property groups added yet. Add a property group above to define the schema for this event.
+                    </div>
+                )}
+            </div>
+
+            <PropertyGroupModal logicKey={`event-${definition.id}`} />
+        </SceneSection>
+    )
+}
diff --git a/frontend/src/scenes/data-management/events/eventDefinitionSchemaLogic.test.ts b/frontend/src/scenes/data-management/events/eventDefinitionSchemaLogic.test.ts
new file mode 100644
index 0000000000..9732a538a6
--- /dev/null
+++ b/frontend/src/scenes/data-management/events/eventDefinitionSchemaLogic.test.ts
@@ -0,0 +1,113 @@
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import { schemaManagementLogic } from '../schema/schemaManagementLogic'
+import { eventDefinitionSchemaLogic } from './eventDefinitionSchemaLogic'
+
+describe('eventDefinitionSchemaLogic', () => {
+    let logic: ReturnType<typeof eventDefinitionSchemaLogic.build>
+    let schemaLogic: ReturnType<typeof schemaManagementLogic.build>
+
+    beforeEach(() => {
+        initKeaTests()
+
+        useMocks({
+            get: {
+                '/api/projects/:teamId/event_schemas': {
+                    results: [
+                        {
+                            id: 'schema-1',
+                            event_definition: 'event-def-1',
+                            property_group_id: 'group-1',
+                            property_group: {
+                                id: 'group-1',
+                                name: 'Test Group',
+                                properties: [{ id: 'prop-1', name: 'prop1', property_type: 'String' }],
+                            },
+                        },
+                    ],
+                },
+                '/api/projects/:teamId/schema_property_groups/': {
+                    results: [
+                        {
+                            id: 'group-1',
+                            name: 'Test Group',
+                            properties: [{ id: 'prop-1', name: 'prop1', property_type: 'String' }],
+                        },
+                    ],
+                },
+            },
+            patch: {
+                '/api/projects/:teamId/schema_property_groups/:id/': () => [
+                    200,
+                    {
+                        id: 'group-1',
+                        name: 'Updated Group',
+                        properties: [{ id: 'prop-1', name: 'updatedProp', property_type: 'Numeric' }],
+                    },
+                ],
+            },
+            post: {
+                '/api/projects/:teamId/schema_property_groups/': () => [
+                    200,
+                    {
+                        id: 'group-2',
+                        name: 'New Group',
+                        properties: [],
+                    },
+                ],
+            },
+        })
+
+        // Build the logic instances with the same key
+        schemaLogic = schemaManagementLogic({ key: 'event-event-def-1' })
+        logic = eventDefinitionSchemaLogic({ eventDefinitionId: 'event-def-1' })
+    })
+
+    it('should reload event schemas when property group is updated', () => {
+        schemaLogic.mount()
+        logic.mount()
+
+        const loadEventSchemasSpy = jest.spyOn(logic.actions, 'loadEventSchemas')
+
+        const mockPropertyGroups = [
+            {
+                id: 'group-1',
+                name: 'Updated Group',
+                properties: [
+                    {
+                        id: 'prop-1',
+                        name: 'updatedProp',
+                        property_type: 'Numeric',
+                        is_required: false,
+                        description: '',
+                        order: 0,
+                    },
+                ],
+            },
+        ]
+
+        schemaLogic.actions.updatePropertyGroupSuccess(mockPropertyGroups)
+
+        expect(loadEventSchemasSpy).toHaveBeenCalled()
+    })
+
+    it('should reload event schemas when a new property group is created', () => {
+        schemaLogic.mount()
+        logic.mount()
+
+        const loadEventSchemasSpy = jest.spyOn(logic.actions, 'loadEventSchemas')
+
+        const mockNewPropertyGroup = [
+            {
+                id: 'group-2',
+                name: 'New Group',
+                properties: [],
+            },
+        ]
+
+        schemaLogic.actions.createPropertyGroupSuccess(mockNewPropertyGroup)
+
+        expect(loadEventSchemasSpy).toHaveBeenCalled()
+    })
+})
diff --git a/frontend/src/scenes/data-management/events/eventDefinitionSchemaLogic.ts b/frontend/src/scenes/data-management/events/eventDefinitionSchemaLogic.ts
new file mode 100644
index 0000000000..9efb22a9f8
--- /dev/null
+++ b/frontend/src/scenes/data-management/events/eventDefinitionSchemaLogic.ts
@@ -0,0 +1,139 @@
+import { actions, afterMount, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
+import { loaders } from 'kea-loaders'
+
+import api from 'lib/api'
+import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
+
+import { type SchemaPropertyGroup, schemaManagementLogic } from '../schema/schemaManagementLogic'
+import type { eventDefinitionSchemaLogicType } from './eventDefinitionSchemaLogicType'
+
+export type { SchemaPropertyGroup }
+
+function getErrorMessage(error: any, defaultMessage: string): string {
+    if (error.detail) {
+        const detail = error.detail
+
+        // Handle "property group is already added to this event schema"
+        if (
+            typeof detail === 'string' &&
+            (detail.includes('already added to this event schema') || detail.includes('already exists'))
+        ) {
+            // Extract property group name if available
+            const nameMatch = detail.match(/Property group '([^']+)'/)
+            if (nameMatch) {
+                return `Property group "${nameMatch[1]}" is already added to this event`
+            }
+            return detail
+        }
+
+        // Handle team mismatch errors
+        if (typeof detail === 'string' && detail.includes('must belong to the same team')) {
+            return 'Property group must belong to the same team as the event'
+        }
+
+        // Return the detail if it's a user-friendly string
+        if (typeof detail === 'string' && !detail.includes('IntegrityError') && !detail.includes('Key (')) {
+            return detail
+        }
+    }
+
+    if (error.message && !error.message.includes('IntegrityError')) {
+        return error.message
+    }
+
+    return defaultMessage
+}
+
+export interface EventSchema {
+    id: string
+    event_definition: string
+    property_group_id: string
+    property_group: SchemaPropertyGroup
+    created_at: string
+    updated_at: string
+}
+
+export interface EventDefinitionSchemaLogicProps {
+    eventDefinitionId: string
+}
+
+export const eventDefinitionSchemaLogic = kea<eventDefinitionSchemaLogicType>([
+    path(['scenes', 'data-management', 'events', 'eventDefinitionSchemaLogic']),
+    props({} as EventDefinitionSchemaLogicProps),
+    key((props) => props.eventDefinitionId),
+    connect((props: EventDefinitionSchemaLogicProps) => ({
+        actions: [
+            schemaManagementLogic({ key: `event-${props.eventDefinitionId}` }),
+            ['updatePropertyGroupSuccess', 'createPropertyGroupSuccess'],
+        ],
+    })),
+    actions({
+        addPropertyGroup: (propertyGroupId: string) => ({ propertyGroupId }),
+        removePropertyGroup: (eventSchemaId: string) => ({ eventSchemaId }),
+    }),
+    loaders(({ props }) => ({
+        eventSchemas: {
+            __default: [] as EventSchema[],
+            loadEventSchemas: async () => {
+                const response = await api.eventSchemas.list(props.eventDefinitionId)
+                return response.results || []
+            },
+        },
+        allPropertyGroups: {
+            __default: [] as SchemaPropertyGroup[],
+            loadAllPropertyGroups: async () => {
+                const response = await api.schemaPropertyGroups.list()
+                return response.results || []
+            },
+        },
+    })),
+    reducers({
+        eventSchemas: {
+            removePropertyGroup: (state, { eventSchemaId }) =>
+                state.filter((schema: EventSchema) => schema.id !== eventSchemaId),
+        },
+    }),
+    selectors({
+        availablePropertyGroups: [
+            (s) => [s.allPropertyGroups, s.eventSchemas],
+            (allPropertyGroups: SchemaPropertyGroup[], eventSchemas: EventSchema[]): SchemaPropertyGroup[] => {
+                const usedGroupIds = new Set(eventSchemas.map((schema: EventSchema) => schema.property_group_id))
+                return allPropertyGroups.filter((group: SchemaPropertyGroup) => !usedGroupIds.has(group.id))
+            },
+        ],
+    }),
+    listeners(({ actions, props }) => ({
+        addPropertyGroup: async ({ propertyGroupId }) => {
+            try {
+                await api.eventSchemas.create({
+                    event_definition: props.eventDefinitionId,
+                    property_group_id: propertyGroupId,
+                })
+                await actions.loadEventSchemas()
+                lemonToast.success('Property group added to event schema')
+            } catch (error: any) {
+                const errorMessage = getErrorMessage(error, 'Failed to add property group')
+                lemonToast.error(errorMessage)
+            }
+        },
+        removePropertyGroup: async ({ eventSchemaId }) => {
+            try {
+                await api.eventSchemas.delete(eventSchemaId)
+                lemonToast.success('Property group removed from event schema')
+            } catch (error: any) {
+                const errorMessage = getErrorMessage(error, 'Failed to remove property group')
+                lemonToast.error(errorMessage)
+            }
+        },
+        updatePropertyGroupSuccess: async () => {
+            await actions.loadEventSchemas()
+        },
+        createPropertyGroupSuccess: async () => {
+            await actions.loadEventSchemas()
+        },
+    })),
+    afterMount(({ actions }) => {
+        actions.loadEventSchemas()
+        actions.loadAllPropertyGroups()
+    }),
+])
diff --git a/frontend/src/scenes/data-management/schema/PropertyGroupModal.tsx b/frontend/src/scenes/data-management/schema/PropertyGroupModal.tsx
new file mode 100644
index 0000000000..0866c9e09f
--- /dev/null
+++ b/frontend/src/scenes/data-management/schema/PropertyGroupModal.tsx
@@ -0,0 +1,190 @@
+import { useActions, useValues } from 'kea'
+import { Form } from 'kea-forms'
+
+import { IconPlus, IconTrash } from '@posthog/icons'
+import { LemonButton, LemonCheckbox, LemonInput, LemonModal, LemonSelect, LemonTextArea } from '@posthog/lemon-ui'
+
+import { LemonField } from 'lib/lemon-ui/LemonField'
+import { LemonTable, LemonTableColumns } from 'lib/lemon-ui/LemonTable'
+
+import { PropertyType, SchemaPropertyGroupProperty, schemaManagementLogic } from './schemaManagementLogic'
+
+const PROPERTY_TYPE_OPTIONS: { value: PropertyType; label: string }[] = [
+    { value: 'String', label: 'String' },
+    { value: 'Numeric', label: 'Numeric' },
+    { value: 'Boolean', label: 'Boolean' },
+    { value: 'DateTime', label: 'DateTime' },
+    { value: 'Duration', label: 'Duration' },
+]
+
+function isValidPropertyName(name: string): boolean {
+    if (!name || !name.trim()) {
+        return false
+    }
+    return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name.trim())
+}
+
+interface PropertyGroupModalProps {
+    logicKey?: string
+    onAfterSave?: () => void | Promise<void>
+}
+
+export function PropertyGroupModal({ logicKey, onAfterSave }: PropertyGroupModalProps = {}): JSX.Element {
+    const logic = schemaManagementLogic({ key: logicKey || 'default' })
+    const {
+        propertyGroupModalOpen,
+        editingPropertyGroup,
+        propertyGroupForm,
+        isPropertyGroupFormSubmitting,
+        propertyGroupFormValidationError,
+    } = useValues(logic)
+    const {
+        setPropertyGroupModalOpen,
+        addPropertyToForm,
+        updatePropertyInForm,
+        removePropertyFromForm,
+        submitPropertyGroupForm,
+    } = useActions(logic)
+
+    const handleClose = (): void => {
+        setPropertyGroupModalOpen(false)
+    }
+
+    const handleAfterSubmit = async (): Promise<void> => {
+        await onAfterSave?.()
+    }
+
+    const columns: LemonTableColumns<SchemaPropertyGroupProperty> = [
+        {
+            title: 'Name',
+            key: 'name',
+            render: (_, property, index) => (
+                <LemonInput
+                    value={property.name}
+                    onChange={(value) => updatePropertyInForm(index, { name: value })}
+                    placeholder="Property name"
+                    status={!isValidPropertyName(property.name) ? 'danger' : undefined}
+                    fullWidth
+                />
+            ),
+        },
+        {
+            title: 'Type',
+            key: 'property_type',
+            width: 150,
+            render: (_, property, index) => (
+                <LemonSelect
+                    value={property.property_type}
+                    onChange={(value) => updatePropertyInForm(index, { property_type: value as PropertyType })}
+                    options={PROPERTY_TYPE_OPTIONS}
+                    fullWidth
+                />
+            ),
+        },
+        {
+            title: 'Required',
+            key: 'is_required',
+            width: 100,
+            align: 'center',
+            render: (_, property, index) => (
+                <div
+                    className="flex justify-center items-center cursor-pointer h-full py-2 -my-2"
+                    onClick={() => updatePropertyInForm(index, { is_required: !property.is_required })}
+                >
+                    <LemonCheckbox
+                        checked={property.is_required}
+                        onChange={(checked) => updatePropertyInForm(index, { is_required: checked })}
+                    />
+                </div>
+            ),
+        },
+        {
+            title: 'Description',
+            key: 'description',
+            render: (_, property, index) => (
+                <LemonInput
+                    value={property.description}
+                    onChange={(value) => updatePropertyInForm(index, { description: value })}
+                    placeholder="Optional description"
+                    fullWidth
+                />
+            ),
+        },
+        {
+            key: 'actions',
+            width: 50,
+            render: (_, _property, index) => (
+                <LemonButton icon={<IconTrash />} size="small" onClick={() => removePropertyFromForm(index)} />
+            ),
+        },
+    ]
+
+    return (
+        <LemonModal
+            isOpen={propertyGroupModalOpen}
+            onClose={handleClose}
+            title={editingPropertyGroup ? 'Edit Property Group' : 'New Property Group'}
+            width={900}
+        >
+            <Form
+                logic={schemaManagementLogic}
+                props={{ key: logicKey || 'default' }}
+                formKey="propertyGroupForm"
+                enableFormOnSubmit
+                className="space-y-4"
+            >
+                <LemonField name="name" label="Name">
+                    <LemonInput placeholder="e.g., Order, Product, User" autoFocus />
+                </LemonField>
+
+                <LemonField name="description" label="Description">
+                    <LemonTextArea placeholder="Describe what this property group represents" rows={2} />
+                </LemonField>
+
+                <div className="border-t pt-4">
+                    <div className="flex items-center justify-between mb-2">
+                        <h3 className="text-base font-semibold mb-0">Properties</h3>
+                        <LemonButton type="secondary" icon={<IconPlus />} size="small" onClick={addPropertyToForm}>
+                            Add property
+                        </LemonButton>
+                    </div>
+
+                    {propertyGroupForm.properties.length > 0 ? (
+                        <>
+                            <LemonTable
+                                columns={columns}
+                                dataSource={propertyGroupForm.properties}
+                                pagination={undefined}
+                            />
+                            {propertyGroupFormValidationError && (
+                                <div className="text-danger text-sm mt-2">{propertyGroupFormValidationError}</div>
+                            )}
+                        </>
+                    ) : (
+                        <div className="text-center text-muted py-6">
+                            No properties yet. Click "Add property" to get started.
+                        </div>
+                    )}
+                </div>
+
+                <div className="flex justify-end gap-2 pt-4 border-t">
+                    <LemonButton type="secondary" onClick={handleClose}>
+                        Cancel
+                    </LemonButton>
+                    <LemonButton
+                        type="primary"
+                        htmlType="submit"
+                        loading={isPropertyGroupFormSubmitting}
+                        disabledReason={propertyGroupFormValidationError || undefined}
+                        onClick={async () => {
+                            await submitPropertyGroupForm()
+                            await handleAfterSubmit()
+                        }}
+                    >
+                        {editingPropertyGroup ? 'Update' : 'Create'}
+                    </LemonButton>
+                </div>
+            </Form>
+        </LemonModal>
+    )
+}
diff --git a/frontend/src/scenes/data-management/schema/SchemaManagement.tsx b/frontend/src/scenes/data-management/schema/SchemaManagement.tsx
new file mode 100644
index 0000000000..3d89abae73
--- /dev/null
+++ b/frontend/src/scenes/data-management/schema/SchemaManagement.tsx
@@ -0,0 +1,225 @@
+import { useActions, useValues } from 'kea'
+
+import { IconApps, IconPencil, IconPlus, IconTrash } from '@posthog/icons'
+import { LemonButton, LemonInput, LemonTag, Link } from '@posthog/lemon-ui'
+
+import { NotFound } from 'lib/components/NotFound'
+import { FEATURE_FLAGS } from 'lib/constants'
+import { LemonTable, LemonTableColumns } from 'lib/lemon-ui/LemonTable'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+
+import { SceneContent } from '~/layout/scenes/components/SceneContent'
+import { SceneDivider } from '~/layout/scenes/components/SceneDivider'
+import { SceneTitleSection } from '~/layout/scenes/components/SceneTitleSection'
+import { urls } from '~/scenes/urls'
+
+import { PropertyGroupModal } from './PropertyGroupModal'
+import {
+    EventDefinitionBasic,
+    SchemaPropertyGroup,
+    SchemaPropertyGroupProperty,
+    schemaManagementLogic,
+} from './schemaManagementLogic'
+
+function EventRow({ event }: { event: EventDefinitionBasic }): JSX.Element {
+    return (
+        <div className="py-3 px-4 border-b last:border-b-0 bg-white">
+            <Link to={urls.eventDefinition(event.id)} className="font-semibold">
+                {event.name}
+            </Link>
+        </div>
+    )
+}
+
+function PropertyRow({ property }: { property: SchemaPropertyGroupProperty }): JSX.Element {
+    return (
+        <div className="flex items-center gap-4 py-3 px-4 border-b last:border-b-0 bg-white">
+            <div className="flex-1">
+                <Link
+                    to={`${urls.propertyDefinitions()}?property=${encodeURIComponent(property.name)}`}
+                    className="font-semibold"
+                >
+                    {property.name}
+                </Link>
+            </div>
+            <div className="w-32">
+                <LemonTag type="muted">{property.property_type}</LemonTag>
+            </div>
+            <div className="w-24">
+                {property.is_required ? (
+                    <LemonTag type="danger">Required</LemonTag>
+                ) : (
+                    <LemonTag type="muted">Optional</LemonTag>
+                )}
+            </div>
+            <div className="flex-1 text-muted">{property.description || '—'}</div>
+        </div>
+    )
+}
+
+export function SchemaManagement(): JSX.Element {
+    const { featureFlags } = useValues(featureFlagLogic)
+    const { filteredPropertyGroups, propertyGroupsLoading, searchTerm } = useValues(schemaManagementLogic)
+    const { setSearchTerm, setPropertyGroupModalOpen, setEditingPropertyGroup, deletePropertyGroup } =
+        useActions(schemaManagementLogic)
+
+    if (!featureFlags[FEATURE_FLAGS.SCHEMA_MANAGEMENT]) {
+        return <NotFound object="page" caption="Schema management is not available." />
+    }
+
+    const columns: LemonTableColumns<SchemaPropertyGroup> = [
+        {
+            key: 'expander',
+            width: 0,
+        },
+        {
+            title: 'Name',
+            key: 'name',
+            dataIndex: 'name',
+            render: (name) => <span className="font-semibold">{name}</span>,
+        },
+        {
+            title: 'Description',
+            key: 'description',
+            dataIndex: 'description',
+            render: (description) => <span className="text-muted">{description || '—'}</span>,
+        },
+        {
+            title: 'Properties',
+            key: 'property_count',
+            width: 120,
+            render: (_, propertyGroup) => (
+                <LemonTag type="default">
+                    {propertyGroup.properties?.length || 0}{' '}
+                    {propertyGroup.properties?.length === 1 ? 'property' : 'properties'}
+                </LemonTag>
+            ),
+        },
+        {
+            key: 'actions',
+            width: 100,
+            render: (_, propertyGroup) => (
+                <div className="flex gap-1">
+                    <LemonButton
+                        icon={<IconPencil />}
+                        size="small"
+                        onClick={() => {
+                            setEditingPropertyGroup(propertyGroup)
+                            setPropertyGroupModalOpen(true)
+                        }}
+                    />
+                    <LemonButton
+                        icon={<IconTrash />}
+                        size="small"
+                        status="danger"
+                        onClick={() => {
+                            if (
+                                confirm(
+                                    `Are you sure you want to delete "${propertyGroup.name}"? This action cannot be undone.`
+                                )
+                            ) {
+                                deletePropertyGroup(propertyGroup.id)
+                            }
+                        }}
+                    />
+                </div>
+            ),
+        },
+    ]
+
+    return (
+        <SceneContent>
+            <SceneTitleSection
+                name="Property Groups"
+                description="Define reusable property groups to establish schemas for your events."
+                resourceType={{
+                    type: 'schema',
+                    forceIcon: <IconApps />,
+                }}
+            />
+            <SceneDivider />
+            <div className="space-y-4">
+                <div className="flex items-center justify-between gap-2">
+                    <LemonInput
+                        type="search"
+                        placeholder="Search property groups..."
+                        className="max-w-60"
+                        value={searchTerm}
+                        onChange={setSearchTerm}
+                    />
+                    <LemonButton
+                        type="primary"
+                        icon={<IconPlus />}
+                        onClick={() => {
+                            setEditingPropertyGroup(null)
+                            setPropertyGroupModalOpen(true)
+                        }}
+                    >
+                        New Property Group
+                    </LemonButton>
+                </div>
+
+                <LemonTable
+                    columns={columns}
+                    dataSource={filteredPropertyGroups}
+                    loading={propertyGroupsLoading}
+                    rowKey="id"
+                    expandable={{
+                        expandedRowRender: (propertyGroup) => (
+                            <div className="space-y-4 mx-4 mb-2 mt-2">
+                                {/* Events Section */}
+                                <div>
+                                    <h3 className="text-sm font-semibold mb-2">Events</h3>
+                                    <div className="border rounded overflow-hidden">
+                                        {propertyGroup.events && propertyGroup.events.length > 0 ? (
+                                            <>
+                                                <div className="flex gap-4 py-2 px-4 bg-accent-3000 border-b text-xs font-semibold uppercase tracking-wider">
+                                                    <div className="flex-1">Event Name</div>
+                                                </div>
+                                                {propertyGroup.events.map((event) => (
+                                                    <EventRow key={event.id} event={event} />
+                                                ))}
+                                            </>
+                                        ) : (
+                                            <div className="text-center text-muted py-4">
+                                                No events using this property group
+                                            </div>
+                                        )}
+                                    </div>
+                                </div>
+
+                                {/* Properties Section */}
+                                <div>
+                                    <h3 className="text-sm font-semibold mb-2">Properties</h3>
+                                    <div className="border rounded overflow-hidden">
+                                        {propertyGroup.properties && propertyGroup.properties.length > 0 ? (
+                                            <>
+                                                <div className="flex gap-4 py-2 px-4 bg-accent-3000 border-b text-xs font-semibold uppercase tracking-wider">
+                                                    <div className="flex-1">Property</div>
+                                                    <div className="w-32">Type</div>
+                                                    <div className="w-24">Required</div>
+                                                    <div className="flex-1">Description</div>
+                                                </div>
+                                                {propertyGroup.properties.map((property) => (
+                                                    <PropertyRow key={property.id} property={property} />
+                                                ))}
+                                            </>
+                                        ) : (
+                                            <div className="text-center text-muted py-4">No properties defined</div>
+                                        )}
+                                    </div>
+                                </div>
+                            </div>
+                        ),
+                        rowExpandable: (propertyGroup) =>
+                            (propertyGroup.events && propertyGroup.events.length > 0) ||
+                            (propertyGroup.properties && propertyGroup.properties.length > 0),
+                    }}
+                    emptyState="No property groups yet. Create one to get started!"
+                />
+            </div>
+
+            <PropertyGroupModal />
+        </SceneContent>
+    )
+}
diff --git a/frontend/src/scenes/data-management/schema/SelectPropertyGroupModal.tsx b/frontend/src/scenes/data-management/schema/SelectPropertyGroupModal.tsx
new file mode 100644
index 0000000000..9cbabedbf5
--- /dev/null
+++ b/frontend/src/scenes/data-management/schema/SelectPropertyGroupModal.tsx
@@ -0,0 +1,169 @@
+import { useActions, useValues } from 'kea'
+import { useState } from 'react'
+
+import { IconPlusSmall } from '@posthog/icons'
+import { LemonButton, LemonInput, LemonModal, LemonTag } from '@posthog/lemon-ui'
+
+import { LemonTable, LemonTableColumns } from 'lib/lemon-ui/LemonTable'
+
+import { PropertyGroupModal } from './PropertyGroupModal'
+import { SchemaPropertyGroup, SchemaPropertyGroupProperty, schemaManagementLogic } from './schemaManagementLogic'
+
+function PropertyRow({ property }: { property: SchemaPropertyGroupProperty }): JSX.Element {
+    return (
+        <div className="flex items-center gap-4 py-3 px-4 border-b last:border-b-0 bg-white">
+            <div className="flex-1">
+                <span className="font-semibold">{property.name}</span>
+            </div>
+            <div className="w-32">
+                <LemonTag type="muted">{property.property_type}</LemonTag>
+            </div>
+            <div className="w-24">
+                {property.is_required ? (
+                    <LemonTag type="danger">Required</LemonTag>
+                ) : (
+                    <LemonTag type="muted">Optional</LemonTag>
+                )}
+            </div>
+            <div className="flex-1 text-muted">{property.description || '—'}</div>
+        </div>
+    )
+}
+
+interface SelectPropertyGroupModalProps {
+    isOpen: boolean
+    onClose: () => void
+    onSelect: (propertyGroupId: string) => void
+    selectedPropertyGroupIds?: Set<string>
+    onPropertyGroupCreated?: () => void
+}
+
+export function SelectPropertyGroupModal({
+    isOpen,
+    onClose,
+    onSelect,
+    selectedPropertyGroupIds = new Set(),
+    onPropertyGroupCreated,
+}: SelectPropertyGroupModalProps): JSX.Element {
+    const [searchTerm, setSearchTerm] = useState('')
+    const logic = schemaManagementLogic({ key: 'select-property-group-modal' })
+    const { propertyGroups } = useValues(logic)
+    const { setPropertyGroupModalOpen, loadPropertyGroups } = useActions(logic)
+
+    const filteredPropertyGroups = propertyGroups.filter(
+        (group) =>
+            !selectedPropertyGroupIds.has(group.id) &&
+            (searchTerm === '' || group.name.toLowerCase().includes(searchTerm.toLowerCase()))
+    )
+
+    const handleCreateNewGroup = (): void => {
+        setPropertyGroupModalOpen(true)
+    }
+
+    const handleAfterPropertyGroupSave = async (): Promise<void> => {
+        await loadPropertyGroups()
+        onPropertyGroupCreated?.()
+    }
+
+    const columns: LemonTableColumns<SchemaPropertyGroup> = [
+        {
+            key: 'expander',
+            width: 0,
+        },
+        {
+            title: 'Name',
+            key: 'name',
+            dataIndex: 'name',
+            render: (name) => <span className="font-semibold">{name}</span>,
+        },
+        {
+            title: 'Description',
+            key: 'description',
+            dataIndex: 'description',
+            render: (description) => <span className="text-muted">{description || '—'}</span>,
+        },
+        {
+            title: 'Properties',
+            key: 'property_count',
+            width: 120,
+            render: (_, propertyGroup) => (
+                <LemonTag type="default">
+                    {propertyGroup.properties?.length || 0}{' '}
+                    {propertyGroup.properties?.length === 1 ? 'property' : 'properties'}
+                </LemonTag>
+            ),
+        },
+        {
+            key: 'actions',
+            width: 100,
+            render: (_, propertyGroup) => (
+                <LemonButton
+                    type="primary"
+                    size="small"
+                    icon={<IconPlusSmall />}
+                    onClick={() => {
+                        onSelect(propertyGroup.id)
+                        onClose()
+                    }}
+                >
+                    Add
+                </LemonButton>
+            ),
+        },
+    ]
+
+    return (
+        <>
+            <LemonModal isOpen={isOpen} onClose={onClose} title="Add property group" width={900}>
+                <div className="space-y-4">
+                    <div className="flex gap-2">
+                        <LemonInput
+                            type="search"
+                            placeholder="Search property groups..."
+                            value={searchTerm}
+                            onChange={setSearchTerm}
+                            className="flex-1"
+                            autoFocus
+                        />
+                        <LemonButton type="primary" icon={<IconPlusSmall />} onClick={handleCreateNewGroup}>
+                            New Property Group
+                        </LemonButton>
+                    </div>
+
+                    <LemonTable
+                        columns={columns}
+                        dataSource={filteredPropertyGroups}
+                        expandable={{
+                            expandedRowRender: (propertyGroup) => (
+                                <div className="border rounded overflow-hidden mx-4 mb-2 mt-2">
+                                    {propertyGroup.properties && propertyGroup.properties.length > 0 ? (
+                                        <>
+                                            <div className="flex gap-4 py-2 px-4 bg-accent-3000 border-b text-xs font-semibold uppercase tracking-wider">
+                                                <div className="flex-1">Property</div>
+                                                <div className="w-32">Type</div>
+                                                <div className="w-24">Required</div>
+                                                <div className="flex-1">Description</div>
+                                            </div>
+                                            {propertyGroup.properties.map((property) => (
+                                                <PropertyRow key={property.id} property={property} />
+                                            ))}
+                                        </>
+                                    ) : (
+                                        <div className="text-center text-muted py-4">No properties defined</div>
+                                    )}
+                                </div>
+                            ),
+                            rowExpandable: () => true,
+                        }}
+                        emptyState={
+                            searchTerm
+                                ? 'No property groups match your search'
+                                : 'No property groups available. Create one in Schema Management first.'
+                        }
+                    />
+                </div>
+            </LemonModal>
+            <PropertyGroupModal logicKey="select-property-group-modal" onAfterSave={handleAfterPropertyGroupSave} />
+        </>
+    )
+}
diff --git a/frontend/src/scenes/data-management/schema/schemaManagementLogic.ts b/frontend/src/scenes/data-management/schema/schemaManagementLogic.ts
new file mode 100644
index 0000000000..4e72b31e5a
--- /dev/null
+++ b/frontend/src/scenes/data-management/schema/schemaManagementLogic.ts
@@ -0,0 +1,282 @@
+import { actions, afterMount, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
+import { forms } from 'kea-forms'
+import { loaders } from 'kea-loaders'
+
+import api from 'lib/api'
+import { lemonToast } from 'lib/lemon-ui/LemonToast'
+import { teamLogic } from 'scenes/teamLogic'
+
+import type { schemaManagementLogicType } from './schemaManagementLogicType'
+
+export type PropertyType = 'String' | 'Numeric' | 'Boolean' | 'DateTime' | 'Duration'
+
+function getErrorMessage(error: any, defaultMessage: string): string {
+    // Handle field-specific errors from DRF serializer
+    if (error.name) {
+        return error.name
+    }
+    if (error.properties) {
+        return error.properties
+    }
+
+    // Handle detail string errors
+    if (error.detail) {
+        const detail = error.detail
+
+        // Handle duplicate property name constraint
+        if (typeof detail === 'string' && detail.includes('unique_property_group_property_name')) {
+            const nameMatch = detail.match(/\(property_group_id, name\)=\([^,]+, ([^)]+)\)/)
+            if (nameMatch) {
+                return `A property named "${nameMatch[1]}" already exists in this group`
+            }
+            return 'A property with this name already exists in this group'
+        }
+
+        // Handle duplicate property group name constraint
+        if (typeof detail === 'string' && detail.includes('unique_property_group_name')) {
+            const nameMatch = detail.match(/\(team_id, name\)=\([^,]+, ([^)]+)\)/)
+            if (nameMatch) {
+                return `A property group named "${nameMatch[1]}" already exists`
+            }
+            return 'A property group with this name already exists'
+        }
+
+        // Return the detail if it's a user-friendly string
+        if (typeof detail === 'string' && !detail.includes('IntegrityError') && !detail.includes('Key (')) {
+            return detail
+        }
+    }
+
+    if (error.message && !error.message.includes('IntegrityError')) {
+        return error.message
+    }
+
+    return defaultMessage
+}
+
+export interface SchemaPropertyGroupProperty {
+    id: string
+    name: string
+    property_type: PropertyType
+    is_required: boolean
+    description: string
+}
+
+export interface EventDefinitionBasic {
+    id: string
+    name: string
+}
+
+export interface SchemaPropertyGroup {
+    id: string
+    name: string
+    description: string
+    properties: SchemaPropertyGroupProperty[]
+    events: EventDefinitionBasic[]
+    created_at: string
+    updated_at: string
+}
+
+export interface SchemaManagementLogicProps {
+    key?: string
+}
+
+export interface PropertyGroupFormType {
+    name: string
+    description: string
+    properties: SchemaPropertyGroupProperty[]
+}
+
+export const schemaManagementLogic = kea<schemaManagementLogicType>([
+    path(['scenes', 'data-management', 'schema', 'schemaManagementLogic']),
+    props({} as SchemaManagementLogicProps),
+    key((props) => props.key || 'default'),
+    connect({
+        values: [teamLogic, ['currentTeamId']],
+    }),
+    actions({
+        setSearchTerm: (searchTerm: string) => ({ searchTerm }),
+        setPropertyGroupModalOpen: (open: boolean) => ({ open }),
+        setEditingPropertyGroup: (propertyGroup: SchemaPropertyGroup | null) => ({ propertyGroup }),
+        deletePropertyGroup: (id: string) => ({ id }),
+        addPropertyToForm: true,
+        updatePropertyInForm: (index: number, updates: Partial<SchemaPropertyGroupProperty>) => ({ index, updates }),
+        removePropertyFromForm: (index: number) => ({ index }),
+    }),
+    loaders(({ values }) => ({
+        propertyGroups: [
+            [] as SchemaPropertyGroup[],
+            {
+                loadPropertyGroups: async () => {
+                    const response = await api.get(`api/projects/@current/schema_property_groups/`)
+                    return response.results || response || []
+                },
+                createPropertyGroup: async (data: Partial<SchemaPropertyGroup>) => {
+                    try {
+                        const response = await api.create(`api/projects/@current/schema_property_groups/`, data)
+                        lemonToast.success('Property group created')
+                        return [response, ...values.propertyGroups]
+                    } catch (error: any) {
+                        const errorMessage = getErrorMessage(error, 'Failed to create property group')
+                        lemonToast.error(errorMessage)
+                        throw new Error(errorMessage)
+                    }
+                },
+                updatePropertyGroup: async ({ id, data }: { id: string; data: Partial<SchemaPropertyGroup> }) => {
+                    try {
+                        const response = await api.update(`api/projects/@current/schema_property_groups/${id}/`, data)
+                        lemonToast.success('Property group updated')
+                        return values.propertyGroups.map((pg) => (pg.id === id ? response : pg))
+                    } catch (error: any) {
+                        const errorMessage = getErrorMessage(error, 'Failed to update property group')
+                        lemonToast.error(errorMessage)
+                        throw new Error(errorMessage)
+                    }
+                },
+            },
+        ],
+    })),
+    forms(({ actions, values }) => ({
+        propertyGroupForm: {
+            options: { showErrorsOnTouch: true },
+            defaults: { name: '', description: '', properties: [] } as PropertyGroupFormType,
+            errors: ({ name }) => ({
+                name: !name?.trim() ? 'Property group name is required' : undefined,
+            }),
+            submit: async (formValues) => {
+                // Check for validation errors
+                const validationError = values.propertyGroupFormValidationError
+                if (validationError) {
+                    lemonToast.error(validationError)
+                    throw new Error(validationError)
+                }
+
+                const data = {
+                    name: formValues.name,
+                    description: formValues.description,
+                    properties: formValues.properties.map((p) => ({ ...p, name: p.name.trim() })),
+                }
+
+                try {
+                    if (values.editingPropertyGroup) {
+                        await actions.updatePropertyGroup({ id: values.editingPropertyGroup.id, data })
+                    } else {
+                        await actions.createPropertyGroup(data)
+                    }
+                    actions.setPropertyGroupModalOpen(false)
+                } catch (error) {
+                    // Error is already handled by the loaders
+                    throw error
+                }
+            },
+        },
+    })),
+    reducers({
+        searchTerm: [
+            '',
+            {
+                setSearchTerm: (_, { searchTerm }) => searchTerm,
+            },
+        ],
+        propertyGroupModalOpen: [
+            false,
+            {
+                setPropertyGroupModalOpen: (_, { open }) => open,
+            },
+        ],
+        editingPropertyGroup: [
+            null as SchemaPropertyGroup | null,
+            {
+                setEditingPropertyGroup: (_, { propertyGroup }) => propertyGroup,
+                setPropertyGroupModalOpen: (state, { open }) => (open ? state : null),
+            },
+        ],
+        propertyGroupForm: [
+            { name: '', description: '', properties: [] } as PropertyGroupFormType,
+            {
+                addPropertyToForm: (state) => ({
+                    ...state,
+                    properties: [
+                        ...state.properties,
+                        {
+                            id: `new-${Date.now()}`,
+                            name: '',
+                            property_type: 'String' as PropertyType,
+                            is_required: false,
+                            description: '',
+                        },
+                    ],
+                }),
+                updatePropertyInForm: (state, { index, updates }) => ({
+                    ...state,
+                    properties: state.properties.map((prop, i) => (i === index ? { ...prop, ...updates } : prop)),
+                }),
+                removePropertyFromForm: (state, { index }) => ({
+                    ...state,
+                    properties: state.properties.filter((_, i) => i !== index),
+                }),
+                setEditingPropertyGroup: (_, { propertyGroup }) => ({
+                    name: propertyGroup?.name || '',
+                    description: propertyGroup?.description || '',
+                    properties: propertyGroup?.properties || [],
+                }),
+                setPropertyGroupModalOpen: (state, { open }) =>
+                    open ? state : { name: '', description: '', properties: [] },
+            },
+        ],
+    }),
+    selectors({
+        filteredPropertyGroups: [
+            (s) => [s.propertyGroups, s.searchTerm],
+            (propertyGroups, searchTerm): SchemaPropertyGroup[] => {
+                if (!searchTerm) {
+                    return propertyGroups
+                }
+                const lowerSearchTerm = searchTerm.toLowerCase()
+                return propertyGroups.filter(
+                    (pg) =>
+                        pg.name.toLowerCase().includes(lowerSearchTerm) ||
+                        pg.description.toLowerCase().includes(lowerSearchTerm) ||
+                        pg.properties.some((prop) => prop.name.toLowerCase().includes(lowerSearchTerm))
+                )
+            },
+        ],
+        propertyGroupFormValidationError: [
+            (s) => [s.propertyGroupForm],
+            (form): string | null => {
+                if (form.properties.length === 0) {
+                    return null
+                }
+
+                const emptyProperties = form.properties.filter((prop) => !prop.name || !prop.name.trim())
+                if (emptyProperties.length > 0) {
+                    return 'All properties must have a name'
+                }
+
+                const invalidProperties = form.properties.filter(
+                    (prop) => prop.name && prop.name.trim() && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(prop.name.trim())
+                )
+                if (invalidProperties.length > 0) {
+                    return 'Property names must start with a letter or underscore and contain only letters, numbers, and underscores'
+                }
+
+                return null
+            },
+        ],
+    }),
+    listeners(({ actions }) => ({
+        deletePropertyGroup: async ({ id }) => {
+            try {
+                await api.delete(`api/projects/@current/schema_property_groups/${id}/`)
+                actions.loadPropertyGroups()
+                lemonToast.success('Property group deleted')
+            } catch (error: any) {
+                const errorMessage = getErrorMessage(error, 'Failed to delete property group')
+                lemonToast.error(errorMessage)
+            }
+        },
+    })),
+    afterMount(({ actions }) => {
+        actions.loadPropertyGroups()
+    }),
+])
diff --git a/frontend/src/scenes/scenes.ts b/frontend/src/scenes/scenes.ts
index 1a5140f7f1..b0e641bb11 100644
--- a/frontend/src/scenes/scenes.ts
+++ b/frontend/src/scenes/scenes.ts
@@ -583,6 +583,7 @@ export const routes: Record<string, [Scene | string, string]> = {
     [urls.propertyDefinitions()]: [Scene.DataManagement, 'propertyDefinitions'],
     [urls.propertyDefinition(':id')]: [Scene.PropertyDefinition, 'propertyDefinition'],
     [urls.propertyDefinitionEdit(':id')]: [Scene.PropertyDefinitionEdit, 'propertyDefinitionEdit'],
+    [urls.schemaManagement()]: [Scene.DataManagement, 'schemaManagement'],
     [urls.dataManagementHistory()]: [Scene.DataManagement, 'dataManagementHistory'],
     [urls.database()]: [Scene.DataManagement, 'database'],
     [urls.activity(ActivityTab.ExploreEvents)]: [Scene.ExploreEvents, 'exploreEvents'],
diff --git a/frontend/src/scenes/urls.ts b/frontend/src/scenes/urls.ts
index 0435a27959..aaa93f8432 100644
--- a/frontend/src/scenes/urls.ts
+++ b/frontend/src/scenes/urls.ts
@@ -38,6 +38,7 @@ export const urls = {
     propertyDefinitions: (type?: string): string => combineUrl('/data-management/properties', type ? { type } : {}).url,
     propertyDefinition: (id: string | number): string => `/data-management/properties/${id}`,
     propertyDefinitionEdit: (id: string | number): string => `/data-management/properties/${id}/edit`,
+    schemaManagement: (): string => '/data-management/schema',
     dataManagementHistory: (): string => '/data-management/history',
     database: (): string => '/data-management/database',
     dataWarehouseManagedViewsets: (): string => '/data-management/managed-viewsets',
diff --git a/playwright/__snapshots__/pageview-trends-insight.png b/playwright/__snapshots__/pageview-trends-insight.png
index 72c1b0afdda5f8691e03224a5be5bb1a58d6fb5c..7ade46cb4fa0a047b0dfd730b75888a8fcea524e 100644
GIT binary patch
literal 35485
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

literal 35919
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
aj`&~G#tal}ta-whSfau&gt8y2zx`h=Ox<Dt

diff --git a/posthog/api/__init__.py b/posthog/api/__init__.py
index df47e53b64..de959e990e 100644
--- a/posthog/api/__init__.py
+++ b/posthog/api/__init__.py
@@ -59,6 +59,7 @@ from . import (
     dead_letter_queue,
     debug_ch_queries,
     event_definition,
+    event_schema,
     exports,
     feature_flag,
     flag_value,
@@ -81,6 +82,7 @@ from . import (
     proxy_record,
     query,
     scheduled_change,
+    schema_property_group,
     search,
     sharing,
     survey,
@@ -361,6 +363,18 @@ projects_router.register(
     "project_property_definitions",
     ["project_id"],
 )
+projects_router.register(
+    r"schema_property_groups",
+    schema_property_group.SchemaPropertyGroupViewSet,
+    "project_schema_property_groups",
+    ["project_id"],
+)
+projects_router.register(
+    r"event_schemas",
+    event_schema.EventSchemaViewSet,
+    "project_event_schemas",
+    ["project_id"],
+)
 
 projects_router.register(r"uploaded_media", uploaded_media.MediaViewSet, "project_media", ["project_id"])
 
diff --git a/posthog/api/event_schema.py b/posthog/api/event_schema.py
new file mode 100644
index 0000000000..5ea6a22bee
--- /dev/null
+++ b/posthog/api/event_schema.py
@@ -0,0 +1,98 @@
+from rest_framework import mixins, serializers, viewsets
+
+from posthog.api.routing import TeamAndOrgViewSetMixin
+from posthog.api.schema_property_group import SchemaPropertyGroupSerializer
+from posthog.models import EventDefinition, EventSchema, SchemaPropertyGroup
+
+
+class EventSchemaSerializer(serializers.ModelSerializer):
+    property_group = SchemaPropertyGroupSerializer(read_only=True)
+    property_group_id = serializers.PrimaryKeyRelatedField(
+        queryset=SchemaPropertyGroup.objects.none(), source="property_group", write_only=True
+    )
+
+    def get_fields(self):
+        fields = super().get_fields()
+        request = self.context.get("request")
+        if request and hasattr(request, "user"):
+            team_id = self.context.get("team_id")
+            if team_id:
+                fields["property_group_id"].queryset = SchemaPropertyGroup.objects.filter(team_id=team_id)  # type: ignore
+                fields["event_definition"].queryset = EventDefinition.objects.filter(team_id=team_id)  # type: ignore
+        return fields
+
+    class Meta:
+        model = EventSchema
+        fields = (
+            "id",
+            "event_definition",
+            "property_group",
+            "property_group_id",
+            "created_at",
+            "updated_at",
+        )
+        read_only_fields = ("id", "property_group", "created_at", "updated_at")
+
+    def validate(self, attrs):
+        event_definition = attrs.get("event_definition")
+        property_group = attrs.get("property_group")
+
+        if event_definition and property_group:
+            if EventSchema.objects.filter(event_definition=event_definition, property_group=property_group).exists():
+                raise serializers.ValidationError(
+                    f"Property group '{property_group.name}' is already added to this event schema"
+                )
+
+        return attrs
+
+    def create(self, validated_data):
+        instance = EventSchema.objects.create(**validated_data)
+        return EventSchema.objects.prefetch_related("property_group__properties").get(pk=instance.pk)
+
+
+class EventSchemaViewSet(
+    TeamAndOrgViewSetMixin,
+    mixins.ListModelMixin,
+    mixins.CreateModelMixin,
+    mixins.DestroyModelMixin,
+    viewsets.GenericViewSet,
+):
+    scope_object = "INTERNAL"
+    serializer_class = EventSchemaSerializer
+    queryset = EventSchema.objects.all()
+    lookup_field = "id"
+
+    def _filter_queryset_by_parents_lookups(self, queryset):
+        """Override to handle EventSchema which doesn't have a direct team field"""
+        parents_query_dict = self.parents_query_dict.copy()
+
+        # Rewrite team/project lookups to use event_definition__team
+        if "team_id" in parents_query_dict:
+            parents_query_dict["event_definition__team_id"] = parents_query_dict.pop("team_id")
+        if "project_id" in parents_query_dict:
+            parents_query_dict["event_definition__team__project_id"] = parents_query_dict.pop("project_id")
+
+        if parents_query_dict:
+            try:
+                return queryset.filter(**parents_query_dict)
+            except ValueError:
+                from rest_framework.exceptions import NotFound
+
+                raise NotFound()
+        else:
+            return queryset
+
+    def safely_get_queryset(self, queryset):
+        event_definition_id = self.request.query_params.get("event_definition")
+        if event_definition_id:
+            return (
+                queryset.filter(event_definition_id=event_definition_id)
+                .select_related("property_group")
+                .prefetch_related("property_group__properties")
+                .order_by("-created_at")
+            )
+        return (
+            queryset.select_related("property_group")
+            .prefetch_related("property_group__properties")
+            .order_by("-created_at")
+        )
diff --git a/posthog/api/schema_property_group.py b/posthog/api/schema_property_group.py
new file mode 100644
index 0000000000..c706a98b73
--- /dev/null
+++ b/posthog/api/schema_property_group.py
@@ -0,0 +1,173 @@
+import re
+import logging
+
+from django.db import IntegrityError, transaction
+
+from rest_framework import mixins, serializers, viewsets
+
+from posthog.api.routing import TeamAndOrgViewSetMixin
+from posthog.api.shared import UserBasicSerializer
+from posthog.models import SchemaPropertyGroup, SchemaPropertyGroupProperty
+
+PROPERTY_NAME_REGEX = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+
+
+class SchemaPropertyGroupPropertySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SchemaPropertyGroupProperty
+        fields = (
+            "id",
+            "name",
+            "property_type",
+            "is_required",
+            "description",
+            "created_at",
+            "updated_at",
+        )
+        read_only_fields = ("id", "created_at", "updated_at")
+
+    def validate_name(self, value: str) -> str:
+        if not value or not value.strip():
+            raise serializers.ValidationError("Property name is required")
+
+        cleaned_value = value.strip()
+        if not PROPERTY_NAME_REGEX.match(cleaned_value):
+            raise serializers.ValidationError(
+                "Property name must start with a letter or underscore and contain only letters, numbers, and underscores"
+            )
+
+        return cleaned_value
+
+
+class EventDefinitionBasicSerializer(serializers.Serializer):
+    id = serializers.UUIDField()
+    name = serializers.CharField()
+
+
+class SchemaPropertyGroupSerializer(serializers.ModelSerializer):
+    properties = SchemaPropertyGroupPropertySerializer(many=True, required=False)
+    created_by = UserBasicSerializer(read_only=True)
+    events = serializers.SerializerMethodField()
+
+    class Meta:
+        model = SchemaPropertyGroup
+        fields = (
+            "id",
+            "name",
+            "description",
+            "properties",
+            "events",
+            "created_at",
+            "updated_at",
+            "created_by",
+        )
+        read_only_fields = ("id", "created_at", "updated_at", "created_by")
+
+    def get_events(self, obj):
+        event_schemas = obj.event_schemas.select_related("event_definition").all()
+        event_definitions = sorted([es.event_definition for es in event_schemas], key=lambda e: e.name.lower())
+        return EventDefinitionBasicSerializer(event_definitions, many=True).data
+
+    def create(self, validated_data):
+        properties_data = validated_data.pop("properties", [])
+        request = self.context.get("request")
+
+        try:
+            property_group = SchemaPropertyGroup.objects.create(
+                **validated_data,
+                team_id=self.context["team_id"],
+                project_id=self.context["project_id"],
+                created_by=request.user if request else None,
+            )
+
+            for property_data in properties_data:
+                SchemaPropertyGroupProperty.objects.create(property_group=property_group, **property_data)
+
+            return property_group
+        except IntegrityError as e:
+            if "unique_schema_property_group_team_name" in str(e):
+                raise serializers.ValidationError(
+                    {"name": "A property group with this name already exists for this team"}
+                )
+            logging.error(f"Database integrity error while creating property group: {e}", exc_info=True)
+            raise serializers.ValidationError("Could not create property group due to a database error.")
+
+    def update(self, instance, validated_data):
+        properties_data = validated_data.pop("properties", None)
+
+        try:
+            with transaction.atomic():
+                instance.name = validated_data.get("name", instance.name)
+                instance.description = validated_data.get("description", instance.description)
+                instance.save()
+
+                if properties_data is not None:
+                    existing_properties = {prop.id: prop for prop in instance.properties.all()}
+                    incoming_property_ids = {prop.get("id") for prop in properties_data if prop.get("id")}
+
+                    # Delete properties that are no longer present
+                    properties_to_delete = set(existing_properties.keys()) - incoming_property_ids
+                    if properties_to_delete:
+                        SchemaPropertyGroupProperty.objects.filter(id__in=properties_to_delete).delete()
+
+                    # Update existing properties and create new ones
+                    for property_data in properties_data:
+                        property_id = property_data.pop("id", None)
+                        if property_id and property_id in existing_properties:
+                            # Update existing property
+                            existing_prop = existing_properties[property_id]
+                            for key, value in property_data.items():
+                                setattr(existing_prop, key, value)
+                            existing_prop.save()
+                        else:
+                            # Create new property
+                            SchemaPropertyGroupProperty.objects.create(property_group=instance, **property_data)
+
+            # Query fresh instance with properties to ensure all data is current
+            return SchemaPropertyGroup.objects.prefetch_related("properties").get(pk=instance.pk)
+        except IntegrityError as e:
+            error_str = str(e)
+
+            # Handle duplicate property name within group
+            if "unique_property_group_property_name" in error_str:
+                # Extract the property name from the error message
+                import re
+
+                match = re.search(r"\(property_group_id, name\)=\([^,]+, ([^)]+)\)", error_str)
+                if match:
+                    property_name = match.group(1)
+                    raise serializers.ValidationError(
+                        {"properties": f"A property named '{property_name}' already exists in this group"}
+                    )
+                raise serializers.ValidationError(
+                    {"properties": "A property with this name already exists in this group"}
+                )
+
+            # Handle duplicate property group name
+            if "unique_schema_property_group_team_name" in error_str:
+                raise serializers.ValidationError({"name": "A property group with this name already exists"})
+
+            logging.error(f"Database integrity error while updating property group: {e}", exc_info=True)
+            raise serializers.ValidationError("Could not update property group due to a database error.")
+
+
+class SchemaPropertyGroupViewSet(
+    TeamAndOrgViewSetMixin,
+    mixins.ListModelMixin,
+    mixins.CreateModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.UpdateModelMixin,
+    mixins.DestroyModelMixin,
+    viewsets.GenericViewSet,
+):
+    scope_object = "INTERNAL"
+    serializer_class = SchemaPropertyGroupSerializer
+    queryset = SchemaPropertyGroup.objects.all()
+    lookup_field = "id"
+
+    def safely_get_queryset(self, queryset):
+        return (
+            queryset.filter(team_id=self.team_id)
+            .prefetch_related("properties", "event_schemas__event_definition")
+            .order_by("name")
+        )
diff --git a/posthog/api/test/test_schema_property_group.py b/posthog/api/test/test_schema_property_group.py
new file mode 100644
index 0000000000..81c361b77a
--- /dev/null
+++ b/posthog/api/test/test_schema_property_group.py
@@ -0,0 +1,248 @@
+from posthog.test.base import APIBaseTest
+
+from rest_framework import status
+
+from posthog.models import EventDefinition, EventSchema, Project, SchemaPropertyGroup, SchemaPropertyGroupProperty
+
+
+class TestSchemaPropertyGroupAPI(APIBaseTest):
+    def test_create_property_group_with_properties(self):
+        response = self.client.post(
+            f"/api/projects/{self.project.id}/schema_property_groups/",
+            {
+                "name": "User Info",
+                "description": "Basic user information",
+                "properties": [
+                    {
+                        "name": "user_id",
+                        "property_type": "String",
+                        "is_required": True,
+                        "description": "User ID",
+                    },
+                    {
+                        "name": "email",
+                        "property_type": "String",
+                        "is_required": False,
+                        "description": "Email",
+                    },
+                ],
+            },
+        )
+
+        assert response.status_code == status.HTTP_201_CREATED
+        data = response.json()
+        assert data["name"] == "User Info"
+        assert data["description"] == "Basic user information"
+        assert len(data["properties"]) == 2
+        assert data["properties"][0]["name"] == "email"
+        assert data["properties"][0]["is_required"] is False
+        assert data["properties"][1]["name"] == "user_id"
+        assert data["properties"][1]["is_required"] is True
+
+    def test_update_property_group_preserves_existing_properties(self):
+        # Create initial property group
+        property_group = SchemaPropertyGroup.objects.create(
+            team=self.team, project=self.project, name="Test Group", description="Test"
+        )
+        prop1 = SchemaPropertyGroupProperty.objects.create(
+            property_group=property_group, name="prop1", property_type="String"
+        )
+        prop2 = SchemaPropertyGroupProperty.objects.create(
+            property_group=property_group, name="prop2", property_type="Numeric"
+        )
+
+        # Update: keep prop1, modify prop2, add prop3, delete nothing
+        response = self.client.patch(
+            f"/api/projects/{self.project.id}/schema_property_groups/{property_group.id}/",
+            {
+                "properties": [
+                    {"id": str(prop1.id), "name": "prop1", "property_type": "String"},
+                    {"id": str(prop2.id), "name": "prop2_updated", "property_type": "Numeric"},
+                    {"name": "prop3", "property_type": "Boolean"},
+                ]
+            },
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert len(data["properties"]) == 3
+
+        # Properties are recreated with new IDs, check by name and values
+        prop_names = {p["name"] for p in data["properties"]}
+        assert "prop1" in prop_names
+        assert "prop2_updated" in prop_names
+        assert "prop3" in prop_names
+
+        # Verify types are correct
+        prop2_updated = next(p for p in data["properties"] if p["name"] == "prop2_updated")
+        assert prop2_updated["property_type"] == "Numeric"
+        prop3 = next(p for p in data["properties"] if p["name"] == "prop3")
+        assert prop3["property_type"] == "Boolean"
+
+    def test_update_property_group_deletes_removed_properties(self):
+        # Create property group with 2 properties
+        property_group = SchemaPropertyGroup.objects.create(team=self.team, project=self.project, name="Test Group")
+        prop1 = SchemaPropertyGroupProperty.objects.create(
+            property_group=property_group, name="prop1", property_type="String"
+        )
+        SchemaPropertyGroupProperty.objects.create(property_group=property_group, name="prop2", property_type="Numeric")
+
+        # Update to only keep prop1
+        response = self.client.patch(
+            f"/api/projects/{self.project.id}/schema_property_groups/{property_group.id}/",
+            {
+                "properties": [
+                    {"id": str(prop1.id), "name": "prop1", "property_type": "String"},
+                ]
+            },
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert len(data["properties"]) == 1
+        assert data["properties"][0]["name"] == "prop1"
+
+    def test_unique_constraint_on_team_and_name(self):
+        SchemaPropertyGroup.objects.create(team=self.team, project=self.project, name="Duplicate Name")
+
+        response = self.client.post(
+            f"/api/projects/{self.project.id}/schema_property_groups/",
+            {"name": "Duplicate Name", "description": "Should fail"},
+        )
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert "already exists" in str(response.json())
+
+    def test_property_name_validation(self):
+        response = self.client.post(
+            f"/api/projects/{self.project.id}/schema_property_groups/",
+            {
+                "name": "Test Group",
+                "properties": [
+                    {"name": "123invalid", "property_type": "String"},
+                ],
+            },
+        )
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert "must start with a letter or underscore" in str(response.json())
+
+    def test_delete_property_group(self):
+        property_group = SchemaPropertyGroup.objects.create(team=self.team, project=self.project, name="To Delete")
+        SchemaPropertyGroupProperty.objects.create(property_group=property_group, name="prop1", property_type="String")
+
+        response = self.client.delete(f"/api/projects/{self.project.id}/schema_property_groups/{property_group.id}/")
+
+        assert response.status_code == status.HTTP_204_NO_CONTENT
+        assert not SchemaPropertyGroup.objects.filter(id=property_group.id).exists()
+        # Properties should be cascade deleted
+        assert not SchemaPropertyGroupProperty.objects.filter(property_group=property_group).exists()
+
+    def test_list_includes_events(self):
+        # Create property group
+        property_group = SchemaPropertyGroup.objects.create(team=self.team, project=self.project, name="Test Group")
+
+        # Create event and associate it
+        event_def = EventDefinition.objects.create(team=self.team, project=self.project, name="test_event")
+        EventSchema.objects.create(event_definition=event_def, property_group=property_group)
+
+        response = self.client.get(f"/api/projects/{self.project.id}/schema_property_groups/")
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        property_groups = data["results"] if "results" in data else data
+
+        test_group = next((pg for pg in property_groups if pg["id"] == str(property_group.id)), None)
+        assert test_group is not None
+        assert "events" in test_group
+        assert len(test_group["events"]) == 1
+        assert test_group["events"][0]["name"] == "test_event"
+
+
+class TestEventSchemaAPI(APIBaseTest):
+    def test_create_event_schema(self):
+        property_group = SchemaPropertyGroup.objects.create(team=self.team, project=self.project, name="Test Group")
+        event_def = EventDefinition.objects.create(team=self.team, project=self.project, name="test_event")
+
+        response = self.client.post(
+            f"/api/projects/{self.project.id}/event_schemas/",
+            {
+                "event_definition": event_def.id,
+                "property_group_id": str(property_group.id),
+            },
+        )
+
+        assert response.status_code == status.HTTP_201_CREATED
+        data = response.json()
+        assert data["property_group"]["id"] == str(property_group.id)
+
+    def test_prevent_duplicate_event_schema(self):
+        property_group = SchemaPropertyGroup.objects.create(team=self.team, project=self.project, name="Test Group")
+        event_def = EventDefinition.objects.create(team=self.team, project=self.project, name="test_event")
+
+        # Create first event schema
+        EventSchema.objects.create(event_definition=event_def, property_group=property_group)
+
+        # Try to create duplicate
+        response = self.client.post(
+            f"/api/projects/{self.project.id}/event_schemas/",
+            {
+                "event_definition": event_def.id,
+                "property_group_id": str(property_group.id),
+            },
+        )
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        # Check that it's a uniqueness error
+        response_data = response.json()
+        assert "unique" in str(response_data).lower()
+
+    def test_delete_event_schema(self):
+        property_group = SchemaPropertyGroup.objects.create(team=self.team, project=self.project, name="Test Group")
+        event_def = EventDefinition.objects.create(team=self.team, project=self.project, name="test_event")
+        event_schema = EventSchema.objects.create(event_definition=event_def, property_group=property_group)
+
+        response = self.client.delete(f"/api/projects/{self.project.id}/event_schemas/{event_schema.id}/")
+
+        assert response.status_code == status.HTTP_204_NO_CONTENT
+        assert not EventSchema.objects.filter(id=event_schema.id).exists()
+
+    def test_cross_team_property_group_rejection(self):
+        other_project, other_team = Project.objects.create_with_team(
+            organization=self.organization,
+            name="Other Project",
+            initiating_user=self.user,
+            team_fields={"name": "Other Team"},
+        )
+        other_property_group = SchemaPropertyGroup.objects.create(
+            team=other_team, project=other_project, name="Other Team Group"
+        )
+        event_def = EventDefinition.objects.create(team=self.team, project=self.project, name="test_event")
+
+        response = self.client.post(
+            f"/api/projects/{self.project.id}/event_schemas/",
+            {"event_definition": event_def.id, "property_group_id": str(other_property_group.id)},
+        )
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert "does not exist" in str(response.json())
+
+    def test_cross_team_event_definition_rejection(self):
+        other_project, other_team = Project.objects.create_with_team(
+            organization=self.organization,
+            name="Other Project",
+            initiating_user=self.user,
+            team_fields={"name": "Other Team"},
+        )
+        other_event_def = EventDefinition.objects.create(
+            team=other_team, project=other_project, name="other_team_event"
+        )
+        property_group = SchemaPropertyGroup.objects.create(team=self.team, project=self.project, name="Test Group")
+
+        response = self.client.post(
+            f"/api/projects/{self.project.id}/event_schemas/",
+            {"event_definition": other_event_def.id, "property_group_id": str(property_group.id)},
+        )
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert "does not exist" in str(response.json())
diff --git a/posthog/demo/products/hedgebox/matrix.py b/posthog/demo/products/hedgebox/matrix.py
index df95576580..17c763e3ca 100644
--- a/posthog/demo/products/hedgebox/matrix.py
+++ b/posthog/demo/products/hedgebox/matrix.py
@@ -45,6 +45,9 @@ from posthog.constants import PAGEVIEW_EVENT
 from posthog.demo.matrix.matrix import Cluster, Matrix
 from posthog.demo.matrix.randomization import Industry
 from posthog.models import Action, Cohort, Dashboard, DashboardTile, Experiment, FeatureFlag, Insight, InsightViewed
+from posthog.models.event_definition import EventDefinition
+from posthog.models.property_definition import PropertyType
+from posthog.models.schema import EventSchema, SchemaPropertyGroup, SchemaPropertyGroupProperty
 
 from .models import HedgeboxAccount, HedgeboxPerson
 from .taxonomy import (
@@ -947,3 +950,56 @@ class HedgeboxMatrix(Matrix):
             )
         ]
         team.revenue_analytics_config.save()
+
+        # Create File Stats property group
+        try:
+            file_stats_group = SchemaPropertyGroup.objects.create(
+                team=team,
+                project=team.project,
+                name="File Stats",
+                description="",
+                created_by=user,
+            )
+
+            SchemaPropertyGroupProperty.objects.create(
+                property_group=file_stats_group,
+                name="file_size_b",
+                property_type=PropertyType.Numeric,
+                is_required=True,
+                description="",
+            )
+
+            SchemaPropertyGroupProperty.objects.create(
+                property_group=file_stats_group,
+                name="file_type",
+                property_type=PropertyType.String,
+                is_required=False,
+                description="",
+            )
+
+            SchemaPropertyGroupProperty.objects.create(
+                property_group=file_stats_group,
+                name="file_name",
+                property_type=PropertyType.String,
+                is_required=False,
+                description="",
+            )
+
+            uploaded_file_def = EventDefinition.objects.get_or_create(
+                team=team, name=EVENT_UPLOADED_FILE, defaults={"team": team}
+            )[0]
+            downloaded_file_def = EventDefinition.objects.get_or_create(
+                team=team, name=EVENT_DOWNLOADED_FILE, defaults={"team": team}
+            )[0]
+
+            EventSchema.objects.create(
+                event_definition=uploaded_file_def,
+                property_group=file_stats_group,
+            )
+
+            EventSchema.objects.create(
+                event_definition=downloaded_file_def,
+                property_group=file_stats_group,
+            )
+        except IntegrityError:
+            pass
diff --git a/posthog/demo/products/hedgebox/models.py b/posthog/demo/products/hedgebox/models.py
index 548112e600..7a1b494b3e 100644
--- a/posthog/demo/products/hedgebox/models.py
+++ b/posthog/demo/products/hedgebox/models.py
@@ -582,7 +582,11 @@ class HedgeboxPerson(SimPerson):
         if self.cluster.random.random() < 0.7:
             self.active_client.capture(
                 EVENT_DOWNLOADED_FILE,
-                {"file_type": file.type, "file_size_b": file.size_b},
+                {
+                    "file_type": file.type,
+                    "file_size_b": file.size_b,
+                    "file_name": self.cluster.random.randbytes(8).hex(),
+                },
             )
         self.advance_timer(0.5 + self.cluster.random.betavariate(1.2, 2) * 80)
         self.need += (self.cluster.random.betavariate(1.2, 1) - 0.5) * 0.08
@@ -684,14 +688,14 @@ class HedgeboxPerson(SimPerson):
         assert self.account is not None
         self.advance_timer(self.cluster.random.betavariate(2.5, 1.1) * 95)
         self.account.files.add(file)
-        self.active_client.capture(
-            EVENT_UPLOADED_FILE,
-            properties={
-                "file_type": file.type,
-                "file_size_b": file.size_b,
-                "used_mb": self.account.current_used_mb,
-            },
-        )
+        properties = {
+            "file_type": file.type,
+            "file_size_b": file.size_b,
+            "used_mb": self.account.current_used_mb,
+        }
+        if self.cluster.random.random() < 0.5:
+            properties["file_name"] = self.cluster.random.randbytes(8).hex()
+        self.active_client.capture(EVENT_UPLOADED_FILE, properties=properties)
         self.active_client.group(
             GROUP_TYPE_ACCOUNT,
             self.account.id,
@@ -709,7 +713,14 @@ class HedgeboxPerson(SimPerson):
             )
 
     def download_file(self, file: HedgeboxFile):
-        self.active_client.capture(EVENT_DOWNLOADED_FILE, {"file_type": file.type, "file_size_b": file.size_b})
+        self.active_client.capture(
+            EVENT_DOWNLOADED_FILE,
+            {
+                "file_type": file.type,
+                "file_size_b": file.size_b,
+                "file_name": self.cluster.random.randbytes(8).hex(),
+            },
+        )
 
     def delete_file(self, file: HedgeboxFile):
         assert self.account is not None
diff --git a/posthog/migrations/0889_add_schema_models.py b/posthog/migrations/0889_add_schema_models.py
new file mode 100644
index 0000000000..c7ff5b9e23
--- /dev/null
+++ b/posthog/migrations/0889_add_schema_models.py
@@ -0,0 +1,155 @@
+# Generated by Django 4.2.22 on 2025-10-02 22:57
+
+import django.utils.timezone
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+import posthog.models.utils
+import posthog.models.property_definition
+
+
+class Migration(migrations.Migration):
+    atomic = False
+
+    dependencies = [
+        ("posthog", "0888_datawarehousemanagedviewset_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="SchemaPropertyGroup",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=posthog.models.utils.UUIDT, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                ("name", models.CharField(max_length=400)),
+                ("description", models.TextField(blank=True)),
+                ("created_at", models.DateTimeField(default=django.utils.timezone.now)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "created_by",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="created_schema_property_groups",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+                (
+                    "project",
+                    models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, to="posthog.project"),
+                ),
+                (
+                    "team",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="schema_property_groups",
+                        related_query_name="schema_property_group",
+                        to="posthog.team",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="EventSchema",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=posthog.models.utils.UUIDT, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                ("created_at", models.DateTimeField(default=django.utils.timezone.now)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "event_definition",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="schemas",
+                        related_query_name="schema",
+                        to="posthog.eventdefinition",
+                    ),
+                ),
+                (
+                    "property_group",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="event_schemas",
+                        related_query_name="event_schema",
+                        to="posthog.schemapropertygroup",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="SchemaPropertyGroupProperty",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=posthog.models.utils.UUIDT, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                ("name", models.CharField(max_length=400)),
+                (
+                    "property_type",
+                    models.CharField(
+                        choices=posthog.models.property_definition.PropertyType.choices,
+                        max_length=50,
+                    ),
+                ),
+                ("is_required", models.BooleanField(default=False)),
+                ("description", models.TextField(blank=True)),
+                ("created_at", models.DateTimeField(default=django.utils.timezone.now)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "property_group",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="properties",
+                        related_query_name="property",
+                        to="posthog.schemapropertygroup",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["name"],
+            },
+        ),
+        migrations.AddIndex(
+            model_name="schemapropertygroupproperty",
+            index=models.Index(fields=["property_group", "name"], name="schema_pgp_group_name_idx"),
+        ),
+        migrations.AddConstraint(
+            model_name="schemapropertygroupproperty",
+            constraint=models.UniqueConstraint(
+                fields=("property_group", "name"), name="unique_property_group_property_name"
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="schemapropertygroupproperty",
+            constraint=models.CheckConstraint(
+                check=models.Q(("property_type__in", posthog.models.property_definition.PropertyType.values)),
+                name="property_type_is_valid_schema",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="schemapropertygroup",
+            index=models.Index(fields=["team", "name"], name="schema_pg_team_name_idx"),
+        ),
+        migrations.AddConstraint(
+            model_name="schemapropertygroup",
+            constraint=models.UniqueConstraint(fields=("team", "name"), name="unique_schema_property_group_team_name"),
+        ),
+        migrations.AddConstraint(
+            model_name="eventschema",
+            constraint=models.UniqueConstraint(
+                fields=("event_definition", "property_group"), name="unique_event_schema"
+            ),
+        ),
+    ]
diff --git a/posthog/migrations/max_migration.txt b/posthog/migrations/max_migration.txt
index 25250d9bc8..63e139b3be 100644
--- a/posthog/migrations/max_migration.txt
+++ b/posthog/migrations/max_migration.txt
@@ -1 +1 @@
-0888_datawarehousemanagedviewset_and_more
+0889_add_schema_models
diff --git a/posthog/models/__init__.py b/posthog/models/__init__.py
index f854dd816b..1b8798d210 100644
--- a/posthog/models/__init__.py
+++ b/posthog/models/__init__.py
@@ -68,6 +68,7 @@ from .property_definition import PropertyDefinition
 from .proxy_record import ProxyRecord
 from .remote_config import RemoteConfig
 from .scheduled_change import ScheduledChange
+from .schema import EventSchema, SchemaPropertyGroup, SchemaPropertyGroupProperty
 from .share_password import SharePassword
 from .sharing_configuration import SharingConfiguration
 from .subscription import Subscription
@@ -169,6 +170,9 @@ __all__ = [
     "ProxyRecord",
     "RetentionFilter",
     "RemoteConfig",
+    "EventSchema",
+    "SchemaPropertyGroup",
+    "SchemaPropertyGroupProperty",
     "SessionRecording",
     "SessionRecordingPlaylist",
     "SessionRecordingPlaylistItem",
diff --git a/posthog/models/schema.py b/posthog/models/schema.py
new file mode 100644
index 0000000000..e8bc8a7d06
--- /dev/null
+++ b/posthog/models/schema.py
@@ -0,0 +1,123 @@
+from django.db import models
+from django.utils import timezone
+
+from posthog.models.event_definition import EventDefinition
+from posthog.models.property_definition import PropertyType
+from posthog.models.team import Team
+from posthog.models.utils import UUIDTModel
+
+
+class SchemaPropertyGroup(UUIDTModel):
+    """
+    A reusable group of properties that defines a schema.
+    Can be attached to multiple events via EventSchema.
+    """
+
+    team = models.ForeignKey(
+        Team,
+        on_delete=models.CASCADE,
+        related_name="schema_property_groups",
+        related_query_name="schema_property_group",
+    )
+    project = models.ForeignKey("Project", on_delete=models.CASCADE, null=True)
+    name = models.CharField(max_length=400)
+    description = models.TextField(blank=True)
+    created_at = models.DateTimeField(default=timezone.now)
+    updated_at = models.DateTimeField(auto_now=True)
+    created_by = models.ForeignKey(
+        "User",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="created_schema_property_groups",
+    )
+
+    class Meta:
+        indexes = [
+            models.Index(fields=["team", "name"], name="schema_pg_team_name_idx"),
+        ]
+        constraints = [
+            models.UniqueConstraint(
+                fields=["team", "name"],
+                name="unique_schema_property_group_team_name",
+            )
+        ]
+
+    def __str__(self) -> str:
+        return f"{self.name} / {self.team.name}"
+
+
+class SchemaPropertyGroupProperty(UUIDTModel):
+    """
+    Individual property within a property group.
+    Defines the expected name, type, and whether it's required.
+    """
+
+    property_group = models.ForeignKey(
+        SchemaPropertyGroup,
+        on_delete=models.CASCADE,
+        related_name="properties",
+        related_query_name="property",
+    )
+    name = models.CharField(max_length=400)
+    property_type = models.CharField(max_length=50, choices=PropertyType.choices)
+    is_required = models.BooleanField(default=False)
+    description = models.TextField(blank=True)
+    created_at = models.DateTimeField(default=timezone.now)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        indexes = [
+            models.Index(
+                fields=["property_group", "name"],
+                name="schema_pgp_group_name_idx",
+            ),
+        ]
+        constraints = [
+            models.UniqueConstraint(
+                fields=["property_group", "name"],
+                name="unique_property_group_property_name",
+            ),
+            models.CheckConstraint(
+                name="property_type_is_valid_schema",
+                check=models.Q(property_type__in=PropertyType.values),
+            ),
+        ]
+        ordering = ["name"]
+
+    def __str__(self) -> str:
+        required_str = " (required)" if self.is_required else ""
+        return f"{self.name} ({self.property_type}){required_str} / {self.property_group.name}"
+
+
+class EventSchema(UUIDTModel):
+    """
+    Associates a property group with an event definition.
+    Defines which property groups an event should have.
+    """
+
+    event_definition = models.ForeignKey(
+        EventDefinition,
+        on_delete=models.CASCADE,
+        related_name="schemas",
+        related_query_name="schema",
+    )
+    property_group = models.ForeignKey(
+        SchemaPropertyGroup,
+        on_delete=models.CASCADE,
+        related_name="event_schemas",
+        related_query_name="event_schema",
+    )
+    created_at = models.DateTimeField(default=timezone.now)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["event_definition", "property_group"],
+                name="unique_event_schema",
+            )
+        ]
+
+    def __str__(self) -> str:
+        return f"{self.event_definition.name} → {self.property_group.name}"
diff --git a/products/actions/manifest.tsx b/products/actions/manifest.tsx
index 9905350ddc..4225a6d678 100644
--- a/products/actions/manifest.tsx
+++ b/products/actions/manifest.tsx
@@ -70,7 +70,7 @@ export const manifest: ProductManifest = {
     treeItemsMetadata: [
         {
             path: 'Actions',
-            category: 'Definitions',
+            category: 'Schema',
             href: urls.actions(),
             iconType: 'action' as FileSystemIconType,
             sceneKey: 'Actions',
diff --git a/products/revenue_analytics/manifest.tsx b/products/revenue_analytics/manifest.tsx
index 2e88fe7318..050a919fda 100644
--- a/products/revenue_analytics/manifest.tsx
+++ b/products/revenue_analytics/manifest.tsx
@@ -42,8 +42,8 @@ export const manifest: ProductManifest = {
     },
     treeItemsMetadata: [
         {
-            path: 'Revenue settings',
-            category: 'Definitions',
+            path: 'Revenue definitions',
+            category: 'Schema',
             iconType: 'revenue_analytics_metadata' as FileSystemIconType,
             href: urls.revenueSettings(),
             sceneKey: 'RevenueAnalytics',