fix(event handling): use internal pubsub for view update (#1118)

* start sub * start implement subsciptions * start subscription * implementation for member done * admin done * fix: tests * extend handlers * prepary notification * no errors in adminapi * changed current sequence in all packages * ignore mocks * works * subscriptions as singleton * tests * refactor: rename function scope var
2025-12-01 14:25:05 +00:00 · 2020-12-18 16:47:45 +01:00
parent e15fc0b92b
commit dd5e4acd24
160 changed files with 4010 additions and 1596 deletions
--- a/internal/management/repository/eventsourcing/eventstore/org.go
+++ b/internal/management/repository/eventsourcing/eventstore/org.go
@@ -108,7 +108,7 @@ func (repo *OrgRepository) GetMyOrgIamPolicy(ctx context.Context) (*iam_model.Or
 func (repo *OrgRepository) SearchMyOrgDomains(ctx context.Context, request *org_model.OrgDomainSearchRequest) (*org_model.OrgDomainSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
 	request.Queries = append(request.Queries, &org_model.OrgDomainSearchQuery{Key: org_model.OrgDomainSearchKeyOrgID, Method: global_model.SearchMethodEquals, Value: authz.GetCtxData(ctx).OrgID})
-	sequence, sequenceErr := repo.View.GetLatestOrgDomainSequence()
+	sequence, sequenceErr := repo.View.GetLatestOrgDomainSequence("")
 	logging.Log("EVENT-SLowp").OnError(sequenceErr).WithField("traceID", tracing.TraceIDFromCtx(ctx)).Warn("could not read latest org domain sequence")
 	domains, count, err := repo.View.SearchOrgDomains(request)
 	if err != nil {
@@ -205,7 +205,7 @@ func (repo *OrgRepository) RemoveMyOrgMember(ctx context.Context, userID string)
 func (repo *OrgRepository) SearchMyOrgMembers(ctx context.Context, request *org_model.OrgMemberSearchRequest) (*org_model.OrgMemberSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
 	request.Queries[len(request.Queries)-1] = &org_model.OrgMemberSearchQuery{Key: org_model.OrgMemberSearchKeyOrgID, Method: global_model.SearchMethodEquals, Value: authz.GetCtxData(ctx).OrgID}
-	sequence, sequenceErr := repo.View.GetLatestOrgMemberSequence()
+	sequence, sequenceErr := repo.View.GetLatestOrgMemberSequence("")
 	logging.Log("EVENT-Smu3d").OnError(sequenceErr).Warn("could not read latest org member sequence")
 	members, count, err := repo.View.SearchOrgMembers(request)
 	if err != nil {
@@ -292,7 +292,7 @@ func (repo *OrgRepository) SearchIDPConfigs(ctx context.Context, request *iam_mo
 	request.EnsureLimit(repo.SearchLimit)
 	request.AppendMyOrgQuery(authz.GetCtxData(ctx).OrgID, repo.SystemDefaults.IamID)

-	sequence, sequenceErr := repo.View.GetLatestIDPConfigSequence()
+	sequence, sequenceErr := repo.View.GetLatestIDPConfigSequence("")
 	logging.Log("EVENT-Dk8si").OnError(sequenceErr).Warn("could not read latest idp config sequence")
 	idps, count, err := repo.View.SearchIDPConfigs(request)
 	if err != nil {
@@ -414,7 +414,7 @@ func (repo *OrgRepository) SearchIDPProviders(ctx context.Context, request *iam_
 		request.AppendAggregateIDQuery(authz.GetCtxData(ctx).OrgID)
 	}
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestIDPProviderSequence()
+	sequence, sequenceErr := repo.View.GetLatestIDPProviderSequence("")
 	logging.Log("EVENT-Tuiks").OnError(sequenceErr).Warn("could not read latest iam sequence")
 	providers, count, err := repo.View.SearchIDPProviders(request)
 	if err != nil {
--- a/internal/management/repository/eventsourcing/eventstore/project.go
+++ b/internal/management/repository/eventsourcing/eventstore/project.go
@@ -118,7 +118,7 @@ func (repo *ProjectRepo) RemoveProject(ctx context.Context, projectID string) er

 func (repo *ProjectRepo) SearchProjects(ctx context.Context, request *proj_model.ProjectViewSearchRequest) (*proj_model.ProjectViewSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestProjectSequence()
+	sequence, sequenceErr := repo.View.GetLatestProjectSequence("")
 	logging.Log("EVENT-Edc56").OnError(sequenceErr).Warn("could not read latest project sequence")

 	permissions := authz.GetRequestPermissionsFromCtx(ctx)
@@ -198,7 +198,7 @@ func (repo *ProjectRepo) RemoveProjectMember(ctx context.Context, projectID, use

 func (repo *ProjectRepo) SearchProjectMembers(ctx context.Context, request *proj_model.ProjectMemberSearchRequest) (*proj_model.ProjectMemberSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestProjectMemberSequence()
+	sequence, sequenceErr := repo.View.GetLatestProjectMemberSequence("")
 	logging.Log("EVENT-3dgt6").OnError(sequenceErr).Warn("could not read latest project member sequence")
 	members, count, err := repo.View.SearchProjectMembers(request)
 	if err != nil {
@@ -270,7 +270,7 @@ func (repo *ProjectRepo) RemoveProjectRole(ctx context.Context, projectID, key s
 func (repo *ProjectRepo) SearchProjectRoles(ctx context.Context, projectID string, request *proj_model.ProjectRoleSearchRequest) (*proj_model.ProjectRoleSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
 	request.AppendProjectQuery(projectID)
-	sequence, sequenceErr := repo.View.GetLatestProjectRoleSequence()
+	sequence, sequenceErr := repo.View.GetLatestProjectRoleSequence("")
 	logging.Log("LSp0d-47suf").OnError(sequenceErr).Warn("could not read latest project role sequence")
 	roles, count, err := repo.View.SearchProjectRoles(request)
 	if err != nil {
@@ -366,7 +366,7 @@ func (repo *ProjectRepo) RemoveApplication(ctx context.Context, projectID, appID

 func (repo *ProjectRepo) SearchApplications(ctx context.Context, request *proj_model.ApplicationSearchRequest) (*proj_model.ApplicationSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestApplicationSequence()
+	sequence, sequenceErr := repo.View.GetLatestApplicationSequence("")
 	logging.Log("EVENT-SKe8s").OnError(sequenceErr).Warn("could not read latest application sequence")
 	apps, count, err := repo.View.SearchApplications(request)
 	if err != nil {
@@ -423,7 +423,7 @@ func (repo *ProjectRepo) ProjectGrantByID(ctx context.Context, grantID string) (

 func (repo *ProjectRepo) SearchProjectGrants(ctx context.Context, request *proj_model.ProjectGrantViewSearchRequest) (*proj_model.ProjectGrantViewSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestProjectGrantSequence()
+	sequence, sequenceErr := repo.View.GetLatestProjectGrantSequence("")
 	logging.Log("EVENT-Skw9f").OnError(sequenceErr).Warn("could not read latest project grant sequence")
 	projects, count, err := repo.View.SearchProjectGrants(request)
 	if err != nil {
@@ -444,7 +444,7 @@ func (repo *ProjectRepo) SearchProjectGrants(ctx context.Context, request *proj_

 func (repo *ProjectRepo) SearchGrantedProjects(ctx context.Context, request *proj_model.ProjectGrantViewSearchRequest) (*proj_model.ProjectGrantViewSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestProjectGrantSequence()
+	sequence, sequenceErr := repo.View.GetLatestProjectGrantSequence("")
 	logging.Log("EVENT-Skw9f").OnError(sequenceErr).Warn("could not read latest project grant sequence")

 	permissions := authz.GetRequestPermissionsFromCtx(ctx)
@@ -612,7 +612,7 @@ func (repo *ProjectRepo) RemoveProjectGrantMember(ctx context.Context, projectID

 func (repo *ProjectRepo) SearchProjectGrantMembers(ctx context.Context, request *proj_model.ProjectGrantMemberSearchRequest) (*proj_model.ProjectGrantMemberSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestProjectGrantMemberSequence()
+	sequence, sequenceErr := repo.View.GetLatestProjectGrantMemberSequence("")
 	logging.Log("EVENT-Du8sk").OnError(sequenceErr).Warn("could not read latest project grant sequence")
 	members, count, err := repo.View.SearchProjectGrantMembers(request)
 	if err != nil {
--- a/internal/management/repository/eventsourcing/eventstore/user.go
+++ b/internal/management/repository/eventsourcing/eventstore/user.go
@@ -158,7 +158,7 @@ func (repo *UserRepo) RemoveUser(ctx context.Context, id string) error {

 func (repo *UserRepo) SearchUsers(ctx context.Context, request *usr_model.UserSearchRequest) (*usr_model.UserSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestUserSequence()
+	sequence, sequenceErr := repo.View.GetLatestUserSequence("")
 	logging.Log("EVENT-Lcn7d").OnError(sequenceErr).Warn("could not read latest user sequence")
 	users, count, err := repo.View.SearchUsers(request)
 	if err != nil {
@@ -276,7 +276,7 @@ func (repo *UserRepo) ProfileByID(ctx context.Context, userID string) (*usr_mode

 func (repo *UserRepo) SearchExternalIDPs(ctx context.Context, request *usr_model.ExternalIDPSearchRequest) (*usr_model.ExternalIDPSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, seqErr := repo.View.GetLatestExternalIDPSequence()
+	sequence, seqErr := repo.View.GetLatestExternalIDPSequence("")
 	logging.Log("EVENT-Qs7uf").OnError(seqErr).Warn("could not read latest external idp sequence")
 	externalIDPS, count, err := repo.View.SearchExternalIDPs(request)
 	if err != nil {
@@ -313,7 +313,7 @@ func (repo *UserRepo) GetMachineKey(ctx context.Context, userID, keyID string) (

 func (repo *UserRepo) SearchMachineKeys(ctx context.Context, request *usr_model.MachineKeySearchRequest) (*usr_model.MachineKeySearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, seqErr := repo.View.GetLatestMachineKeySequence()
+	sequence, seqErr := repo.View.GetLatestMachineKeySequence("")
 	logging.Log("EVENT-Sk8fs").OnError(seqErr).Warn("could not read latest user sequence")
 	keys, count, err := repo.View.SearchMachineKeys(request)
 	if err != nil {
@@ -415,7 +415,7 @@ func (repo *UserRepo) ChangeAddress(ctx context.Context, address *usr_model.Addr

 func (repo *UserRepo) SearchUserMemberships(ctx context.Context, request *usr_model.UserMembershipSearchRequest) (*usr_model.UserMembershipSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestUserMembershipSequence()
+	sequence, sequenceErr := repo.View.GetLatestUserMembershipSequence("")
 	logging.Log("EVENT-Dn7sf").OnError(sequenceErr).Warn("could not read latest user sequence")

 	result := handleSearchUserMembershipsPermissions(ctx, request, sequence)
--- a/internal/management/repository/eventsourcing/eventstore/user_grant.go
+++ b/internal/management/repository/eventsourcing/eventstore/user_grant.go
@@ -116,7 +116,7 @@ func (repo *UserGrantRepo) BulkRemoveUserGrant(ctx context.Context, grantIDs ...

 func (repo *UserGrantRepo) SearchUserGrants(ctx context.Context, request *grant_model.UserGrantSearchRequest) (*grant_model.UserGrantSearchResponse, error) {
 	request.EnsureLimit(repo.SearchLimit)
-	sequence, sequenceErr := repo.View.GetLatestUserGrantSequence()
+	sequence, sequenceErr := repo.View.GetLatestUserGrantSequence("")
 	logging.Log("EVENT-5Viwf").OnError(sequenceErr).Warn("could not read latest user grant sequence")

 	result := handleSearchUserGrantPermissions(ctx, request, sequence)
--- a/internal/management/repository/eventsourcing/handler/application.go
+++ b/internal/management/repository/eventsourcing/handler/application.go
@@ -5,7 +5,9 @@ import (

 	"github.com/caos/logging"

+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	"github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
@@ -13,21 +15,57 @@ import (
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
 )

-type Application struct {
-	handler
-	projectEvents *proj_event.ProjectEventstore
-}
-
 const (
 	applicationTable = "management.applications"
 )

+type Application struct {
+	handler
+	projectEvents *proj_event.ProjectEventstore
+	subscription  *eventstore.Subscription
+}
+
+func newApplication(
+	handler handler,
+	projectEvents *proj_event.ProjectEventstore,
+) *Application {
+	h := &Application{
+		handler:       handler,
+		projectEvents: projectEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (a *Application) subscribe() {
+	a.subscription = a.es.Subscribe(a.AggregateTypes()...)
+	go func() {
+		for event := range a.subscription.Events {
+			query.ReduceEvent(a, event)
+		}
+	}()
+}
+
 func (a *Application) ViewModel() string {
 	return applicationTable
 }

+func (_ *Application) AggregateTypes() []models.AggregateType {
+	return []models.AggregateType{es_model.ProjectAggregate}
+}
+
+func (a *Application) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := a.view.GetLatestApplicationSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (a *Application) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := a.view.GetLatestApplicationSequence()
+	sequence, err := a.view.GetLatestApplicationSequence("")
 	if err != nil {
 		return nil, err
 	}
@@ -65,30 +103,30 @@ func (a *Application) Reduce(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return a.view.DeleteApplication(app.ID, event.Sequence, event.CreationDate)
+		return a.view.DeleteApplication(app.ID, event)
 	case es_model.ProjectChanged:
 		apps, err := a.view.ApplicationsByProjectID(event.AggregateID)
 		if err != nil {
 			return err
 		}
 		if len(apps) == 0 {
-			return a.view.ProcessedApplicationSequence(event.Sequence, event.CreationDate)
+			return a.view.ProcessedApplicationSequence(event)
 		}
 		for _, app := range apps {
 			if err := app.AppendEvent(event); err != nil {
 				return err
 			}
 		}
-		return a.view.PutApplications(apps, event.Sequence, event.CreationDate)
+		return a.view.PutApplications(apps, event)
 	case es_model.ProjectRemoved:
 		return a.view.DeleteApplicationsByProjectID(event.AggregateID)
 	default:
-		return a.view.ProcessedApplicationSequence(event.Sequence, event.CreationDate)
+		return a.view.ProcessedApplicationSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return a.view.PutApplication(app, event.CreationDate)
+	return a.view.PutApplication(app, event)
 }

 func (a *Application) OnError(event *models.Event, spoolerError error) error {
--- a/internal/management/repository/eventsourcing/handler/handler.go
+++ b/internal/management/repository/eventsourcing/handler/handler.go
@@ -25,6 +25,12 @@ type handler struct {
 	bulkLimit           uint64
 	cycleDuration       time.Duration
 	errorCountUntilSkip uint64
+
+	es eventstore.Eventstore
+}
+
+func (h *handler) Eventstore() eventstore.Eventstore {
+	return h.es
 }

 type EventstoreRepos struct {
@@ -34,49 +40,76 @@ type EventstoreRepos struct {
 	IamEvents     *iam_event.IAMEventstore
 }

-func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, eventstore eventstore.Eventstore, repos EventstoreRepos, defaults systemdefaults.SystemDefaults) []query.Handler {
+func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, es eventstore.Eventstore, repos EventstoreRepos, defaults systemdefaults.SystemDefaults) []query.Handler {
 	return []query.Handler{
-		&Project{handler: handler{view, bulkLimit, configs.cycleDuration("Project"), errorCount},
-			eventstore: eventstore},
-		&ProjectGrant{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectGrant"), errorCount},
-			eventstore: eventstore, projectEvents: repos.ProjectEvents, orgEvents: repos.OrgEvents},
-		&ProjectRole{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectRole"), errorCount},
-			projectEvents: repos.ProjectEvents},
-		&ProjectMember{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectMember"), errorCount},
-			userEvents: repos.UserEvents},
-		&ProjectGrantMember{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectGrantMember"), errorCount},
-			userEvents: repos.UserEvents},
-		&Application{handler: handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount},
-			projectEvents: repos.ProjectEvents},
-		&User{handler: handler{view, bulkLimit, configs.cycleDuration("User"), errorCount},
-			eventstore: eventstore, orgEvents: repos.OrgEvents, iamEvents: repos.IamEvents, iamID: defaults.IamID},
-		&UserGrant{handler: handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount},
-			projectEvents: repos.ProjectEvents, userEvents: repos.UserEvents, orgEvents: repos.OrgEvents},
-		&Org{handler: handler{view, bulkLimit, configs.cycleDuration("Org"), errorCount}},
-		&OrgMember{handler: handler{view, bulkLimit, configs.cycleDuration("OrgMember"), errorCount},
-			userEvents: repos.UserEvents},
-		&OrgDomain{handler: handler{view, bulkLimit, configs.cycleDuration("OrgDomain"), errorCount}},
-		&UserMembership{handler: handler{view, bulkLimit, configs.cycleDuration("UserMembership"), errorCount},
-			orgEvents: repos.OrgEvents, projectEvents: repos.ProjectEvents},
-		&MachineKeys{handler: handler{view, bulkLimit, configs.cycleDuration("MachineKeys"), errorCount}},
-		&IDPConfig{handler: handler{view, bulkLimit, configs.cycleDuration("IDPConfig"), errorCount}},
-		&LoginPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("LoginPolicy"), errorCount}},
-		&LabelPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("LabelPolicy"), errorCount}},
-		&IDPProvider{handler: handler{view, bulkLimit, configs.cycleDuration("IDPProvider"), errorCount},
-			systemDefaults: defaults, iamEvents: repos.IamEvents, orgEvents: repos.OrgEvents},
-		&ExternalIDP{handler: handler{view, bulkLimit, configs.cycleDuration("ExternalIDP"), errorCount},
-			systemDefaults: defaults, iamEvents: repos.IamEvents, orgEvents: repos.OrgEvents},
-		&PasswordComplexityPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("PasswordComplexityPolicy"), errorCount}},
-		&PasswordAgePolicy{handler: handler{view, bulkLimit, configs.cycleDuration("PasswordAgePolicy"), errorCount}},
-		&PasswordLockoutPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("PasswordLockoutPolicy"), errorCount}},
-		&OrgIAMPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("OrgIAMPolicy"), errorCount}},
+		newProject(
+			handler{view, bulkLimit, configs.cycleDuration("Project"), errorCount, es}),
+		newProjectGrant(
+			handler{view, bulkLimit, configs.cycleDuration("ProjectGrant"), errorCount, es},
+			repos.ProjectEvents,
+			repos.OrgEvents),
+		newProjectRole(handler{view, bulkLimit, configs.cycleDuration("ProjectRole"), errorCount, es},
+			repos.ProjectEvents),
+		newProjectMember(handler{view, bulkLimit, configs.cycleDuration("ProjectMember"), errorCount, es},
+			repos.UserEvents),
+		newProjectGrantMember(handler{view, bulkLimit, configs.cycleDuration("ProjectGrantMember"), errorCount, es},
+			repos.UserEvents),
+		newApplication(handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount, es},
+			repos.ProjectEvents),
+		newUser(handler{view, bulkLimit, configs.cycleDuration("User"), errorCount, es},
+			repos.OrgEvents,
+			repos.IamEvents,
+			defaults.IamID),
+		newUserGrant(handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount, es},
+			repos.ProjectEvents,
+			repos.UserEvents,
+			repos.OrgEvents),
+		newOrg(
+			handler{view, bulkLimit, configs.cycleDuration("Org"), errorCount, es}),
+		newOrgMember(
+			handler{view, bulkLimit, configs.cycleDuration("OrgMember"), errorCount, es},
+			repos.UserEvents),
+		newOrgDomain(
+			handler{view, bulkLimit, configs.cycleDuration("OrgDomain"), errorCount, es}),
+		newUserMembership(
+			handler{view, bulkLimit, configs.cycleDuration("UserMembership"), errorCount, es},
+			repos.OrgEvents,
+			repos.ProjectEvents),
+		newMachineKeys(
+			handler{view, bulkLimit, configs.cycleDuration("MachineKeys"), errorCount, es}),
+		newIDPConfig(
+			handler{view, bulkLimit, configs.cycleDuration("IDPConfig"), errorCount, es}),
+		newLoginPolicy(
+			handler{view, bulkLimit, configs.cycleDuration("LoginPolicy"), errorCount, es}),
+		newLabelPolicy(
+			handler{view, bulkLimit, configs.cycleDuration("LabelPolicy"), errorCount, es}),
+		newIDPProvider(
+			handler{view, bulkLimit, configs.cycleDuration("IDPProvider"), errorCount, es},
+
+			defaults,
+			repos.IamEvents,
+			repos.OrgEvents),
+		newExternalIDP(
+			handler{view, bulkLimit, configs.cycleDuration("ExternalIDP"), errorCount, es},
+
+			defaults,
+			repos.IamEvents,
+			repos.OrgEvents),
+		newPasswordComplexityPolicy(
+			handler{view, bulkLimit, configs.cycleDuration("PasswordComplexityPolicy"), errorCount, es}),
+		newPasswordAgePolicy(
+			handler{view, bulkLimit, configs.cycleDuration("PasswordAgePolicy"), errorCount, es}),
+		newPasswordLockoutPolicy(
+			handler{view, bulkLimit, configs.cycleDuration("PasswordLockoutPolicy"), errorCount, es}),
+		newOrgIAMPolicy(
+			handler{view, bulkLimit, configs.cycleDuration("OrgIAMPolicy"), errorCount, es}),
 	}
 }

 func (configs Configs) cycleDuration(viewModel string) time.Duration {
 	c, ok := configs[viewModel]
 	if !ok {
-		return 1 * time.Second
+		return 3 * time.Minute
 	}
 	return c.MinimumCycleDuration.Duration
 }
--- a/internal/management/repository/eventsourcing/handler/idp_config.go
+++ b/internal/management/repository/eventsourcing/handler/idp_config.go
@@ -2,8 +2,10 @@ package handler

 import (
 	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	iam_model "github.com/caos/zitadel/internal/iam/model"
 	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
@@ -11,29 +13,61 @@ import (
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 )

-type IDPConfig struct {
-	handler
-}
-
 const (
 	idpConfigTable = "management.idp_configs"
 )

+type IDPConfig struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newIDPConfig(handler handler) *IDPConfig {
+	h := &IDPConfig{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *IDPConfig) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (m *IDPConfig) ViewModel() string {
 	return idpConfigTable
 }

-func (m *IDPConfig) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestIDPConfigSequence()
+func (_ *IDPConfig) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
+}
+
+func (m *IDPConfig) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := m.view.GetLatestIDPConfigSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
+func (m *IDPConfig) EventQuery() (*es_models.SearchQuery, error) {
+	sequence, err := m.view.GetLatestIDPConfigSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
+		AggregateTypeFilter(m.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

-func (m *IDPConfig) Reduce(event *models.Event) (err error) {
+func (m *IDPConfig) Reduce(event *es_models.Event) (err error) {
 	switch event.AggregateType {
 	case model.OrgAggregate:
 		err = m.processIdpConfig(iam_model.IDPProviderTypeOrg, event)
@@ -43,7 +77,7 @@ func (m *IDPConfig) Reduce(event *models.Event) (err error) {
 	return err
 }

-func (m *IDPConfig) processIdpConfig(providerType iam_model.IDPProviderType, event *models.Event) (err error) {
+func (m *IDPConfig) processIdpConfig(providerType iam_model.IDPProviderType, event *es_models.Event) (err error) {
 	idp := new(iam_view_model.IDPConfigView)
 	switch event.Type {
 	case model.IDPConfigAdded,
@@ -66,17 +100,17 @@ func (m *IDPConfig) processIdpConfig(providerType iam_model.IDPProviderType, eve
 		if err != nil {
 			return err
 		}
-		return m.view.DeleteIDPConfig(idp.IDPConfigID, event.Sequence, event.CreationDate)
+		return m.view.DeleteIDPConfig(idp.IDPConfigID, event)
 	default:
-		return m.view.ProcessedIDPConfigSequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedIDPConfigSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutIDPConfig(idp, idp.Sequence, event.CreationDate)
+	return m.view.PutIDPConfig(idp, event)
 }

-func (i *IDPConfig) OnError(event *models.Event, err error) error {
+func (i *IDPConfig) OnError(event *es_models.Event, err error) error {
 	logging.LogWithFields("SPOOL-Nxu8s", "id", event.AggregateID).WithError(err).Warn("something went wrong in idp config handler")
 	return spooler.HandleError(event, err, i.view.GetLatestIDPConfigFailedEvent, i.view.ProcessedIDPConfigFailedEvent, i.view.ProcessedIDPConfigSequence, i.errorCountUntilSkip)
 }
--- a/internal/management/repository/eventsourcing/handler/idp_providers.go
+++ b/internal/management/repository/eventsourcing/handler/idp_providers.go
@@ -2,18 +2,23 @@ package handler

 import (
 	"context"
+
 	"github.com/caos/logging"
 	"github.com/caos/zitadel/internal/config/systemdefaults"
-	"github.com/caos/zitadel/internal/iam/repository/eventsourcing"
-	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
-	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
-
-	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	iam_model "github.com/caos/zitadel/internal/iam/model"
+	"github.com/caos/zitadel/internal/iam/repository/eventsourcing"
 	"github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	iam_view_model "github.com/caos/zitadel/internal/iam/repository/view/model"
+	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
+)
+
+const (
+	idpProviderTable = "management.idp_providers"
 )

 type IDPProvider struct {
@@ -21,27 +26,63 @@ type IDPProvider struct {
 	systemDefaults systemdefaults.SystemDefaults
 	iamEvents      *eventsourcing.IAMEventstore
 	orgEvents      *org_es.OrgEventstore
+	subscription   *eventstore.Subscription
 }

-const (
-	idpProviderTable = "management.idp_providers"
-)
+func newIDPProvider(
+	handler handler,
+	systemDefaults systemdefaults.SystemDefaults,
+	iamEvents *eventsourcing.IAMEventstore,
+	orgEvents *org_es.OrgEventstore,
+) *IDPProvider {
+	h := &IDPProvider{
+		handler:        handler,
+		systemDefaults: systemDefaults,
+		iamEvents:      iamEvents,
+		orgEvents:      orgEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *IDPProvider) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}

 func (m *IDPProvider) ViewModel() string {
 	return idpProviderTable
 }

-func (m *IDPProvider) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestIDPProviderSequence()
+func (_ *IDPProvider) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.IAMAggregate, org_es_model.OrgAggregate}
+}
+
+func (m *IDPProvider) CurrentSequence(event *es_models.Event) (uint64, error) {
+	sequence, err := m.view.GetLatestIDPProviderSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
+func (m *IDPProvider) EventQuery() (*es_models.SearchQuery, error) {
+	sequence, err := m.view.GetLatestIDPProviderSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.IAMAggregate, org_es_model.OrgAggregate).
+		AggregateTypeFilter(m.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

-func (m *IDPProvider) Reduce(event *models.Event) (err error) {
+func (m *IDPProvider) Reduce(event *es_models.Event) (err error) {
 	switch event.AggregateType {
 	case model.IAMAggregate, org_es_model.OrgAggregate:
 		err = m.processIdpProvider(event)
@@ -49,7 +90,7 @@ func (m *IDPProvider) Reduce(event *models.Event) (err error) {
 	return err
 }

-func (m *IDPProvider) processIdpProvider(event *models.Event) (err error) {
+func (m *IDPProvider) processIdpProvider(event *es_models.Event) (err error) {
 	provider := new(iam_view_model.IDPProviderView)
 	switch event.Type {
 	case model.LoginPolicyIDPProviderAdded, org_es_model.LoginPolicyIDPProviderAdded:
@@ -64,7 +105,7 @@ func (m *IDPProvider) processIdpProvider(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return m.view.DeleteIDPProvider(event.AggregateID, provider.IDPConfigID, event.Sequence, event.CreationDate)
+		return m.view.DeleteIDPProvider(event.AggregateID, provider.IDPConfigID, event)
 	case model.IDPConfigChanged, org_es_model.IDPConfigChanged:
 		esConfig := new(iam_view_model.IDPConfigView)
 		providerType := iam_model.IDPProviderTypeSystem
@@ -88,16 +129,16 @@ func (m *IDPProvider) processIdpProvider(event *models.Event) (err error) {
 		for _, provider := range providers {
 			m.fillConfigData(provider, config)
 		}
-		return m.view.PutIDPProviders(event.Sequence, event.CreationDate, providers...)
+		return m.view.PutIDPProviders(event, providers...)
 	case org_es_model.LoginPolicyRemoved:
-		return m.view.DeleteIDPProvidersByAggregateID(event.AggregateID, event.Sequence, event.CreationDate)
+		return m.view.DeleteIDPProvidersByAggregateID(event.AggregateID, event)
 	default:
-		return m.view.ProcessedIDPProviderSequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedIDPProviderSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutIDPProvider(provider, provider.Sequence, event.CreationDate)
+	return m.view.PutIDPProvider(provider, event)
 }

 func (m *IDPProvider) fillData(provider *iam_view_model.IDPProviderView) (err error) {
@@ -121,7 +162,7 @@ func (m *IDPProvider) fillConfigData(provider *iam_view_model.IDPProviderView, c
 	provider.IDPState = int32(config.State)
 }

-func (m *IDPProvider) OnError(event *models.Event, err error) error {
+func (m *IDPProvider) OnError(event *es_models.Event, err error) error {
 	logging.LogWithFields("SPOOL-Msj8c", "id", event.AggregateID).WithError(err).Warn("something went wrong in idp provider handler")
 	return spooler.HandleError(event, err, m.view.GetLatestIDPProviderFailedEvent, m.view.ProcessedIDPProviderFailedEvent, m.view.ProcessedIDPProviderSequence, m.errorCountUntilSkip)
 }
--- a/internal/management/repository/eventsourcing/handler/label_policy.go
+++ b/internal/management/repository/eventsourcing/handler/label_policy.go
@@ -2,34 +2,67 @@ package handler

 import (
 	"github.com/caos/logging"
-	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
-
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
+	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 )

-type LabelPolicy struct {
-	handler
-}
-
 const (
 	labelPolicyTable = "management.label_policies"
 )

+type LabelPolicy struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newLabelPolicy(handler handler) *LabelPolicy {
+	h := &LabelPolicy{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *LabelPolicy) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (m *LabelPolicy) ViewModel() string {
 	return labelPolicyTable
 }

+func (_ *LabelPolicy) AggregateTypes() []models.AggregateType {
+	return []models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
+}
+
+func (m *LabelPolicy) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := m.view.GetLatestLabelPolicySequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (m *LabelPolicy) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestLabelPolicySequence()
+	sequence, err := m.view.GetLatestLabelPolicySequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
+		AggregateTypeFilter(m.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -53,12 +86,12 @@ func (m *LabelPolicy) processLabelPolicy(event *models.Event) (err error) {
 		}
 		err = policy.AppendEvent(event)
 	default:
-		return m.view.ProcessedLabelPolicySequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedLabelPolicySequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutLabelPolicy(policy, policy.Sequence, event.CreationDate)
+	return m.view.PutLabelPolicy(policy, event)
 }

 func (m *LabelPolicy) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/login_policy.go
+++ b/internal/management/repository/eventsourcing/handler/login_policy.go
@@ -2,34 +2,67 @@ package handler

 import (
 	"github.com/caos/logging"
-	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
-
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
+	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 )

-type LoginPolicy struct {
-	handler
-}
-
 const (
 	loginPolicyTable = "management.login_policies"
 )

+type LoginPolicy struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newLoginPolicy(handler handler) *LoginPolicy {
+	h := &LoginPolicy{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *LoginPolicy) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (m *LoginPolicy) ViewModel() string {
 	return loginPolicyTable
 }

+func (_ *LoginPolicy) AggregateTypes() []models.AggregateType {
+	return []models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
+}
+
+func (m *LoginPolicy) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := m.view.GetLatestLoginPolicySequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (m *LoginPolicy) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestLoginPolicySequence()
+	sequence, err := m.view.GetLatestLoginPolicySequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
+		AggregateTypeFilter(m.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -57,14 +90,14 @@ func (m *LoginPolicy) processLoginPolicy(event *models.Event) (err error) {
 		}
 		err = policy.AppendEvent(event)
 	case model.LoginPolicyRemoved:
-		return m.view.DeleteLoginPolicy(event.AggregateID, event.Sequence, event.CreationDate)
+		return m.view.DeleteLoginPolicy(event.AggregateID, event)
 	default:
-		return m.view.ProcessedLoginPolicySequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedLoginPolicySequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutLoginPolicy(policy, policy.Sequence, event.CreationDate)
+	return m.view.PutLoginPolicy(policy, event)
 }

 func (m *LoginPolicy) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/machine_keys.go
+++ b/internal/management/repository/eventsourcing/handler/machine_keys.go
@@ -4,33 +4,66 @@ import (
 	"time"

 	"github.com/caos/logging"
-
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	usr_model "github.com/caos/zitadel/internal/user/repository/view/model"
 )

-type MachineKeys struct {
-	handler
-}
-
 const (
 	machineKeysTable = "management.machine_keys"
 )

+type MachineKeys struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newMachineKeys(handler handler) *MachineKeys {
+	h := &MachineKeys{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *MachineKeys) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (d *MachineKeys) ViewModel() string {
 	return machineKeysTable
 }

+func (_ *MachineKeys) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.UserAggregate}
+}
+
+func (k *MachineKeys) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := k.view.GetLatestMachineKeySequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (d *MachineKeys) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := d.view.GetLatestMachineKeySequence()
+	sequence, err := d.view.GetLatestMachineKeySequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.UserAggregate).
+		AggregateTypeFilter(d.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -48,23 +81,23 @@ func (d *MachineKeys) processMachineKeys(event *models.Event) (err error) {
 	case model.MachineKeyAdded:
 		err = key.AppendEvent(event)
 		if key.ExpirationDate.Before(time.Now()) {
-			return d.view.ProcessedMachineKeySequence(event.Sequence, event.CreationDate)
+			return d.view.ProcessedMachineKeySequence(event)
 		}
 	case model.MachineKeyRemoved:
 		err = key.SetData(event)
 		if err != nil {
 			return err
 		}
-		return d.view.DeleteMachineKey(key.ID, event.Sequence, event.CreationDate)
+		return d.view.DeleteMachineKey(key.ID, event)
 	case model.UserRemoved:
-		return d.view.DeleteMachineKeysByUserID(event.AggregateID, event.Sequence, event.CreationDate)
+		return d.view.DeleteMachineKeysByUserID(event.AggregateID, event)
 	default:
-		return d.view.ProcessedMachineKeySequence(event.Sequence, event.CreationDate)
+		return d.view.ProcessedMachineKeySequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return d.view.PutMachineKey(key, key.Sequence, event.CreationDate)
+	return d.view.PutMachineKey(key, event)
 }

 func (d *MachineKeys) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/org.go
+++ b/internal/management/repository/eventsourcing/handler/org.go
@@ -2,28 +2,62 @@ package handler

 import (
 	"github.com/caos/logging"
-
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	org_model "github.com/caos/zitadel/internal/org/repository/view/model"
 )

-type Org struct {
-	handler
-}
-
 const (
 	orgTable = "management.orgs"
 )

+type Org struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newOrg(handler handler) *Org {
+	h := &Org{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *Org) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (o *Org) ViewModel() string {
 	return orgTable
 }

+func (_ *Org) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.OrgAggregate}
+}
+
+func (o *Org) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := o.view.GetLatestOrgSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (o *Org) EventQuery() (*es_models.SearchQuery, error) {
-	sequence, err := o.view.GetLatestOrgSequence()
+	sequence, err := o.view.GetLatestOrgSequence("")
 	if err != nil {
 		return nil, err
 	}
@@ -47,12 +81,12 @@ func (o *Org) Reduce(event *es_models.Event) (err error) {
 		}
 		err = org.AppendEvent(event)
 	default:
-		return o.view.ProcessedOrgSequence(event.Sequence, event.CreationDate)
+		return o.view.ProcessedOrgSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return o.view.PutOrg(org, event.CreationDate)
+	return o.view.PutOrg(org, event)
 }

 func (o *Org) OnError(event *es_models.Event, spoolerErr error) error {
--- a/internal/management/repository/eventsourcing/handler/org_domain.go
+++ b/internal/management/repository/eventsourcing/handler/org_domain.go
@@ -2,33 +2,66 @@ package handler

 import (
 	"github.com/caos/logging"
-
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	org_model "github.com/caos/zitadel/internal/org/repository/view/model"
 )

-type OrgDomain struct {
-	handler
-}
-
 const (
 	orgDomainTable = "management.org_domains"
 )

+type OrgDomain struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newOrgDomain(handler handler) *OrgDomain {
+	h := &OrgDomain{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *OrgDomain) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (d *OrgDomain) ViewModel() string {
 	return orgDomainTable
 }

+func (_ *OrgDomain) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.OrgAggregate}
+}
+
+func (p *OrgDomain) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestOrgDomainSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (d *OrgDomain) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := d.view.GetLatestOrgDomainSequence()
+	sequence, err := d.view.GetLatestOrgDomainSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate).
+		AggregateTypeFilter(d.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -72,7 +105,7 @@ func (d *OrgDomain) processOrgDomain(event *models.Event) (err error) {
 		for _, existingDomain := range existingDomains {
 			existingDomain.Primary = false
 		}
-		err = d.view.PutOrgDomains(existingDomains, 0, event.CreationDate)
+		err = d.view.PutOrgDomains(existingDomains, event)
 		if err != nil {
 			return err
 		}
@@ -82,14 +115,14 @@ func (d *OrgDomain) processOrgDomain(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return d.view.DeleteOrgDomain(event.AggregateID, domain.Domain, event.Sequence, event.CreationDate)
+		return d.view.DeleteOrgDomain(event.AggregateID, domain.Domain, event)
 	default:
-		return d.view.ProcessedOrgDomainSequence(event.Sequence, event.CreationDate)
+		return d.view.ProcessedOrgDomainSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return d.view.PutOrgDomain(domain, domain.Sequence, event.CreationDate)
+	return d.view.PutOrgDomain(domain, event)
 }

 func (d *OrgDomain) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/org_iam_policy.go
+++ b/internal/management/repository/eventsourcing/handler/org_iam_policy.go
@@ -2,34 +2,67 @@ package handler

 import (
 	"github.com/caos/logging"
-	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
-
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
+	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 )

-type OrgIAMPolicy struct {
-	handler
-}
-
 const (
 	orgIAMPolicyTable = "management.org_iam_policies"
 )

+type OrgIAMPolicy struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newOrgIAMPolicy(handler handler) *OrgIAMPolicy {
+	h := &OrgIAMPolicy{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *OrgIAMPolicy) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (m *OrgIAMPolicy) ViewModel() string {
 	return orgIAMPolicyTable
 }

+func (_ *OrgIAMPolicy) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
+}
+
+func (p *OrgIAMPolicy) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestOrgIAMPolicySequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (m *OrgIAMPolicy) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestOrgIAMPolicySequence()
+	sequence, err := m.view.GetLatestOrgIAMPolicySequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
+		AggregateTypeFilter(m.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -53,14 +86,14 @@ func (m *OrgIAMPolicy) processOrgIAMPolicy(event *models.Event) (err error) {
 		}
 		err = policy.AppendEvent(event)
 	case model.OrgIAMPolicyRemoved:
-		return m.view.DeleteOrgIAMPolicy(event.AggregateID, event.Sequence, event.CreationDate)
+		return m.view.DeleteOrgIAMPolicy(event.AggregateID, event)
 	default:
-		return m.view.ProcessedOrgIAMPolicySequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedOrgIAMPolicySequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutOrgIAMPolicy(policy, policy.Sequence, event.CreationDate)
+	return m.view.PutOrgIAMPolicy(policy, event)
 }

 func (m *OrgIAMPolicy) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/org_member.go
+++ b/internal/management/repository/eventsourcing/handler/org_member.go
@@ -4,9 +4,10 @@ import (
 	"context"

 	"github.com/caos/logging"
-
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	org_model "github.com/caos/zitadel/internal/org/repository/view/model"
@@ -15,26 +16,62 @@ import (
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 )

-type OrgMember struct {
-	handler
-	userEvents *usr_event.UserEventstore
-}
-
 const (
 	orgMemberTable = "management.org_members"
 )

+type OrgMember struct {
+	handler
+	userEvents   *usr_event.UserEventstore
+	subscription *eventstore.Subscription
+}
+
+func newOrgMember(
+	handler handler,
+	userEvents *usr_event.UserEventstore,
+) *OrgMember {
+	h := &OrgMember{
+		handler:    handler,
+		userEvents: userEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *OrgMember) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (m *OrgMember) ViewModel() string {
 	return orgMemberTable
 }

+func (_ *OrgMember) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.OrgAggregate, usr_es_model.UserAggregate}
+}
+
+func (p *OrgMember) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestOrgMemberSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (m *OrgMember) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestOrgMemberSequence()
+	sequence, err := m.view.GetLatestOrgMemberSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate, usr_es_model.UserAggregate).
+		AggregateTypeFilter(m.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -72,14 +109,14 @@ func (m *OrgMember) processOrgMember(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return m.view.DeleteOrgMember(event.AggregateID, member.UserID, event.Sequence, event.CreationDate)
+		return m.view.DeleteOrgMember(event.AggregateID, member.UserID, event)
 	default:
-		return m.view.ProcessedOrgMemberSequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedOrgMemberSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutOrgMember(member, member.Sequence, event.CreationDate)
+	return m.view.PutOrgMember(member, event)
 }

 func (m *OrgMember) processUser(event *models.Event) (err error) {
@@ -94,7 +131,7 @@ func (m *OrgMember) processUser(event *models.Event) (err error) {
 			return err
 		}
 		if len(members) == 0 {
-			return m.view.ProcessedOrgMemberSequence(event.Sequence, event.CreationDate)
+			return m.view.ProcessedOrgMemberSequence(event)
 		}
 		user, err := m.userEvents.UserByID(context.Background(), event.AggregateID)
 		if err != nil {
@@ -103,13 +140,12 @@ func (m *OrgMember) processUser(event *models.Event) (err error) {
 		for _, member := range members {
 			m.fillUserData(member, user)
 		}
-		return m.view.PutOrgMembers(members, event.Sequence, event.CreationDate)
+		return m.view.PutOrgMembers(members, event)
 	case usr_es_model.UserRemoved:
-		return m.view.DeleteOrgMembersByUserID(event.AggregateID, event.Sequence, event.CreationDate)
+		return m.view.DeleteOrgMembersByUserID(event.AggregateID, event)
 	default:
-		return m.view.ProcessedOrgMemberSequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedOrgMemberSequence(event)
 	}
-	return nil
 }

 func (m *OrgMember) fillData(member *org_model.OrgMemberView) (err error) {
--- a/internal/management/repository/eventsourcing/handler/password_age_policy.go
+++ b/internal/management/repository/eventsourcing/handler/password_age_policy.go
@@ -2,34 +2,67 @@ package handler

 import (
 	"github.com/caos/logging"
-	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
-
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
+	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 )

-type PasswordAgePolicy struct {
-	handler
-}
-
 const (
 	passwordAgePolicyTable = "management.password_age_policies"
 )

+type PasswordAgePolicy struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newPasswordAgePolicy(handler handler) *PasswordAgePolicy {
+	h := &PasswordAgePolicy{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *PasswordAgePolicy) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (m *PasswordAgePolicy) ViewModel() string {
 	return passwordAgePolicyTable
 }

-func (m *PasswordAgePolicy) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestPasswordAgePolicySequence()
+func (_ *PasswordAgePolicy) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
+}
+
+func (o *PasswordAgePolicy) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := o.view.GetLatestPasswordAgePolicySequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
+func (p *PasswordAgePolicy) EventQuery() (*models.SearchQuery, error) {
+	sequence, err := p.view.GetLatestPasswordAgePolicySequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
+		AggregateTypeFilter(p.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -53,14 +86,14 @@ func (m *PasswordAgePolicy) processPasswordAgePolicy(event *models.Event) (err e
 		}
 		err = policy.AppendEvent(event)
 	case model.PasswordAgePolicyRemoved:
-		return m.view.DeletePasswordAgePolicy(event.AggregateID, event.Sequence, event.CreationDate)
+		return m.view.DeletePasswordAgePolicy(event.AggregateID, event)
 	default:
-		return m.view.ProcessedPasswordAgePolicySequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedPasswordAgePolicySequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutPasswordAgePolicy(policy, policy.Sequence, event.CreationDate)
+	return m.view.PutPasswordAgePolicy(policy, event)
 }

 func (m *PasswordAgePolicy) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/password_complexity_policy.go
+++ b/internal/management/repository/eventsourcing/handler/password_complexity_policy.go
@@ -2,34 +2,67 @@ package handler

 import (
 	"github.com/caos/logging"
-	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
-
+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
+	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 )

-type PasswordComplexityPolicy struct {
-	handler
-}
-
 const (
 	passwordComplexityPolicyTable = "management.password_complexity_policies"
 )

+type PasswordComplexityPolicy struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newPasswordComplexityPolicy(handler handler) *PasswordComplexityPolicy {
+	h := &PasswordComplexityPolicy{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *PasswordComplexityPolicy) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (p *PasswordComplexityPolicy) ViewModel() string {
 	return passwordComplexityPolicyTable
 }

+func (_ *PasswordComplexityPolicy) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
+}
+
+func (p *PasswordComplexityPolicy) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestPasswordComplexityPolicySequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (p *PasswordComplexityPolicy) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := p.view.GetLatestPasswordComplexityPolicySequence()
+	sequence, err := p.view.GetLatestPasswordComplexityPolicySequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
+		AggregateTypeFilter(p.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -53,14 +86,14 @@ func (p *PasswordComplexityPolicy) processPasswordComplexityPolicy(event *models
 		}
 		err = policy.AppendEvent(event)
 	case model.PasswordComplexityPolicyRemoved:
-		return p.view.DeletePasswordComplexityPolicy(event.AggregateID, event.Sequence, event.CreationDate)
+		return p.view.DeletePasswordComplexityPolicy(event.AggregateID, event)
 	default:
-		return p.view.ProcessedPasswordComplexityPolicySequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedPasswordComplexityPolicySequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return p.view.PutPasswordComplexityPolicy(policy, policy.Sequence, event.CreationDate)
+	return p.view.PutPasswordComplexityPolicy(policy, event)
 }

 func (p *PasswordComplexityPolicy) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/password_lockout_policy.go
+++ b/internal/management/repository/eventsourcing/handler/password_lockout_policy.go
@@ -2,34 +2,68 @@ package handler

 import (
 	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/eventstore"
 	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"

 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 )

-type PasswordLockoutPolicy struct {
-	handler
-}
-
 const (
 	passwordLockoutPolicyTable = "management.password_lockout_policies"
 )

+type PasswordLockoutPolicy struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newPasswordLockoutPolicy(handler handler) *PasswordLockoutPolicy {
+	h := &PasswordLockoutPolicy{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *PasswordLockoutPolicy) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (p *PasswordLockoutPolicy) ViewModel() string {
 	return passwordLockoutPolicyTable
 }

+func (_ *PasswordLockoutPolicy) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
+}
+
+func (p *PasswordLockoutPolicy) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestPasswordLockoutPolicySequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (p *PasswordLockoutPolicy) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := p.view.GetLatestPasswordLockoutPolicySequence()
+	sequence, err := p.view.GetLatestPasswordLockoutPolicySequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
+		AggregateTypeFilter(p.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -53,14 +87,14 @@ func (p *PasswordLockoutPolicy) processPasswordLockoutPolicy(event *models.Event
 		}
 		err = policy.AppendEvent(event)
 	case model.PasswordLockoutPolicyRemoved:
-		return p.view.DeletePasswordLockoutPolicy(event.AggregateID, event.Sequence, event.CreationDate)
+		return p.view.DeletePasswordLockoutPolicy(event.AggregateID, event)
 	default:
-		return p.view.ProcessedPasswordLockoutPolicySequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedPasswordLockoutPolicySequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return p.view.PutPasswordLockoutPolicy(policy, policy.Sequence, event.CreationDate)
+	return p.view.PutPasswordLockoutPolicy(policy, event)
 }

 func (p *PasswordLockoutPolicy) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/project.go
+++ b/internal/management/repository/eventsourcing/handler/project.go
@@ -5,27 +5,59 @@ import (

 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
 )

-type Project struct {
-	handler
-	eventstore eventstore.Eventstore
-}
-
 const (
 	projectTable = "management.projects"
 )

+type Project struct {
+	handler
+	subscription *eventstore.Subscription
+}
+
+func newProject(handler handler) *Project {
+	h := &Project{
+		handler: handler,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *Project) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (p *Project) ViewModel() string {
 	return projectTable
 }

+func (_ *Project) AggregateTypes() []models.AggregateType {
+	return []models.AggregateType{es_model.ProjectAggregate}
+}
+
+func (p *Project) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestProjectSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (p *Project) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := p.view.GetLatestProjectSequence()
+	sequence, err := p.view.GetLatestProjectSequence("")
 	if err != nil {
 		return nil, err
 	}
@@ -46,14 +78,14 @@ func (p *Project) Reduce(event *models.Event) (err error) {
 		}
 		err = project.AppendEvent(event)
 	case es_model.ProjectRemoved:
-		return p.view.DeleteProject(event.AggregateID, event.Sequence, event.CreationDate)
+		return p.view.DeleteProject(event.AggregateID, event)
 	default:
-		return p.view.ProcessedProjectSequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedProjectSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return p.view.PutProject(project, event.CreationDate)
+	return p.view.PutProject(project, event)
 }

 func (p *Project) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/project_grant.go
+++ b/internal/management/repository/eventsourcing/handler/project_grant.go
@@ -2,12 +2,12 @@ package handler

 import (
 	"context"
-	"time"

 	"github.com/caos/logging"

 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	org_model "github.com/caos/zitadel/internal/org/model"
 	org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
@@ -17,23 +17,60 @@ import (
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
 )

-type ProjectGrant struct {
-	handler
-	eventstore    eventstore.Eventstore
-	projectEvents *proj_event.ProjectEventstore
-	orgEvents     *org_event.OrgEventstore
-}
-
 const (
 	grantedProjectTable = "management.project_grants"
 )

+type ProjectGrant struct {
+	handler
+	projectEvents *proj_event.ProjectEventstore
+	orgEvents     *org_event.OrgEventstore
+	subscription  *eventstore.Subscription
+}
+
+func newProjectGrant(
+	handler handler,
+	projectEvents *proj_event.ProjectEventstore,
+	orgEvents *org_event.OrgEventstore,
+) *ProjectGrant {
+	h := &ProjectGrant{
+		handler:       handler,
+		projectEvents: projectEvents,
+		orgEvents:     orgEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *ProjectGrant) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (p *ProjectGrant) ViewModel() string {
 	return grantedProjectTable
 }

+func (_ *ProjectGrant) AggregateTypes() []models.AggregateType {
+	return []models.AggregateType{es_model.ProjectAggregate}
+}
+
+func (p *ProjectGrant) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestProjectGrantSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (p *ProjectGrant) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := p.view.GetLatestProjectGrantSequence()
+	sequence, err := p.view.GetLatestProjectGrantSequence("")
 	if err != nil {
 		return nil, err
 	}
@@ -48,7 +85,7 @@ func (p *ProjectGrant) Reduce(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return p.updateExistingProjects(project, event.Sequence, event.CreationDate)
+		return p.updateExistingProjects(project, event)
 	case es_model.ProjectGrantAdded:
 		err = grantedProject.AppendEvent(event)
 		if err != nil {
@@ -86,16 +123,16 @@ func (p *ProjectGrant) Reduce(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return p.view.DeleteProjectGrant(grant.GrantID, event.Sequence, event.CreationDate)
+		return p.view.DeleteProjectGrant(grant.GrantID, event)
 	case es_model.ProjectRemoved:
 		return p.view.DeleteProjectGrantsByProjectID(event.AggregateID)
 	default:
-		return p.view.ProcessedProjectGrantSequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedProjectGrantSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return p.view.PutProjectGrant(grantedProject, event.CreationDate)
+	return p.view.PutProjectGrant(grantedProject, event)
 }

 func (p *ProjectGrant) fillOrgData(grantedProject *view_model.ProjectGrantView, org, resourceOwner *org_model.Org) {
@@ -107,7 +144,7 @@ func (p *ProjectGrant) getProject(projectID string) (*proj_model.Project, error)
 	return p.projectEvents.ProjectByID(context.Background(), projectID)
 }

-func (p *ProjectGrant) updateExistingProjects(project *view_model.ProjectView, sequence uint64, eventTimestamp time.Time) error {
+func (p *ProjectGrant) updateExistingProjects(project *view_model.ProjectView, event *models.Event) error {
 	projectGrants, err := p.view.ProjectGrantsByProjectID(project.ProjectID)
 	if err != nil {
 		logging.LogWithFields("SPOOL-los03", "id", project.ProjectID).WithError(err).Warn("could not update existing projects")
@@ -115,7 +152,7 @@ func (p *ProjectGrant) updateExistingProjects(project *view_model.ProjectView, s
 	for _, existingGrant := range projectGrants {
 		existingGrant.Name = project.Name
 	}
-	return p.view.PutProjectGrants(projectGrants, sequence, eventTimestamp)
+	return p.view.PutProjectGrants(projectGrants, event)
 }

 func (p *ProjectGrant) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/project_grant_member.go
+++ b/internal/management/repository/eventsourcing/handler/project_grant_member.go
@@ -5,8 +5,10 @@ import (

 	"github.com/caos/logging"

+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
@@ -15,26 +17,62 @@ import (
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 )

-type ProjectGrantMember struct {
-	handler
-	userEvents *usr_event.UserEventstore
-}
-
 const (
 	projectGrantMemberTable = "management.project_grant_members"
 )

+type ProjectGrantMember struct {
+	handler
+	userEvents   *usr_event.UserEventstore
+	subscription *eventstore.Subscription
+}
+
+func newProjectGrantMember(
+	handler handler,
+	userEvents *usr_event.UserEventstore,
+) *ProjectGrantMember {
+	h := &ProjectGrantMember{
+		handler:    handler,
+		userEvents: userEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *ProjectGrantMember) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (p *ProjectGrantMember) ViewModel() string {
 	return projectGrantMemberTable
 }

+func (_ *ProjectGrantMember) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{proj_es_model.ProjectAggregate, usr_es_model.UserAggregate}
+}
+
+func (p *ProjectGrantMember) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestProjectGrantMemberSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (p *ProjectGrantMember) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := p.view.GetLatestProjectGrantMemberSequence()
+	sequence, err := p.view.GetLatestProjectGrantMemberSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(proj_es_model.ProjectAggregate, usr_es_model.UserAggregate).
+		AggregateTypeFilter(p.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -72,16 +110,16 @@ func (p *ProjectGrantMember) processProjectGrantMember(event *models.Event) (err
 		if err != nil {
 			return err
 		}
-		return p.view.DeleteProjectGrantMember(member.GrantID, member.UserID, event.Sequence, event.CreationDate)
+		return p.view.DeleteProjectGrantMember(member.GrantID, member.UserID, event)
 	case proj_es_model.ProjectRemoved:
 		return p.view.DeleteProjectGrantMembersByProjectID(event.AggregateID)
 	default:
-		return p.view.ProcessedProjectGrantMemberSequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedProjectGrantMemberSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return p.view.PutProjectGrantMember(member, member.Sequence, event.CreationDate)
+	return p.view.PutProjectGrantMember(member, event)
 }

 func (p *ProjectGrantMember) processUser(event *models.Event) (err error) {
@@ -96,7 +134,7 @@ func (p *ProjectGrantMember) processUser(event *models.Event) (err error) {
 			return err
 		}
 		if len(members) == 0 {
-			return p.view.ProcessedProjectGrantMemberSequence(event.Sequence, event.CreationDate)
+			return p.view.ProcessedProjectGrantMemberSequence(event)
 		}
 		user, err := p.userEvents.UserByID(context.Background(), event.AggregateID)
 		if err != nil {
@@ -105,11 +143,10 @@ func (p *ProjectGrantMember) processUser(event *models.Event) (err error) {
 		for _, member := range members {
 			p.fillUserData(member, user)
 		}
-		return p.view.PutProjectGrantMembers(members, event.Sequence, event.CreationDate)
+		return p.view.PutProjectGrantMembers(members, event)
 	default:
-		return p.view.ProcessedProjectGrantMemberSequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedProjectGrantMemberSequence(event)
 	}
-	return nil
 }

 func (p *ProjectGrantMember) fillData(member *view_model.ProjectGrantMemberView) (err error) {
--- a/internal/management/repository/eventsourcing/handler/project_member.go
+++ b/internal/management/repository/eventsourcing/handler/project_member.go
@@ -5,8 +5,10 @@ import (

 	"github.com/caos/logging"

+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
@@ -15,26 +17,62 @@ import (
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 )

-type ProjectMember struct {
-	handler
-	userEvents *usr_event.UserEventstore
-}
-
 const (
 	projectMemberTable = "management.project_members"
 )

+type ProjectMember struct {
+	handler
+	userEvents   *usr_event.UserEventstore
+	subscription *eventstore.Subscription
+}
+
+func newProjectMember(
+	handler handler,
+	userEvents *usr_event.UserEventstore,
+) *ProjectMember {
+	h := &ProjectMember{
+		handler:    handler,
+		userEvents: userEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *ProjectMember) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (p *ProjectMember) ViewModel() string {
 	return projectMemberTable
 }

+func (_ *ProjectMember) AggregateTypes() []models.AggregateType {
+	return []models.AggregateType{proj_es_model.ProjectAggregate, usr_es_model.UserAggregate}
+}
+
+func (p *ProjectMember) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestProjectMemberSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (p *ProjectMember) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := p.view.GetLatestProjectMemberSequence()
+	sequence, err := p.view.GetLatestProjectMemberSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(proj_es_model.ProjectAggregate, usr_es_model.UserAggregate).
+		AggregateTypeFilter(p.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -72,16 +110,16 @@ func (p *ProjectMember) processProjectMember(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return p.view.DeleteProjectMember(event.AggregateID, member.UserID, event.Sequence, event.CreationDate)
+		return p.view.DeleteProjectMember(event.AggregateID, member.UserID, event)
 	case proj_es_model.ProjectRemoved:
 		return p.view.DeleteProjectMembersByProjectID(event.AggregateID)
 	default:
-		return p.view.ProcessedProjectMemberSequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedProjectMemberSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return p.view.PutProjectMember(member, member.Sequence, event.CreationDate)
+	return p.view.PutProjectMember(member, event)
 }

 func (p *ProjectMember) processUser(event *models.Event) (err error) {
@@ -96,7 +134,7 @@ func (p *ProjectMember) processUser(event *models.Event) (err error) {
 			return err
 		}
 		if len(members) == 0 {
-			return p.view.ProcessedProjectMemberSequence(event.Sequence, event.CreationDate)
+			return p.view.ProcessedProjectMemberSequence(event)
 		}
 		user, err := p.userEvents.UserByID(context.Background(), event.AggregateID)
 		if err != nil {
@@ -105,9 +143,9 @@ func (p *ProjectMember) processUser(event *models.Event) (err error) {
 		for _, member := range members {
 			p.fillUserData(member, user)
 		}
-		return p.view.PutProjectMembers(members, event.Sequence, event.CreationDate)
+		return p.view.PutProjectMembers(members, event)
 	default:
-		return p.view.ProcessedProjectMemberSequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedProjectMemberSequence(event)
 	}
 	return nil
 }
--- a/internal/management/repository/eventsourcing/handler/project_role.go
+++ b/internal/management/repository/eventsourcing/handler/project_role.go
@@ -3,7 +3,9 @@ package handler
 import (
 	"github.com/caos/logging"

+	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	"github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
@@ -11,21 +13,57 @@ import (
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
 )

-type ProjectRole struct {
-	handler
-	projectEvents *proj_event.ProjectEventstore
-}
-
 const (
 	projectRoleTable = "management.project_roles"
 )

+type ProjectRole struct {
+	handler
+	projectEvents *proj_event.ProjectEventstore
+	subscription  *eventstore.Subscription
+}
+
+func newProjectRole(
+	handler handler,
+	projectEvents *proj_event.ProjectEventstore,
+) *ProjectRole {
+	h := &ProjectRole{
+		handler:       handler,
+		projectEvents: projectEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *ProjectRole) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (p *ProjectRole) ViewModel() string {
 	return projectRoleTable
 }

+func (_ *ProjectRole) AggregateTypes() []models.AggregateType {
+	return []models.AggregateType{es_model.ProjectAggregate}
+}
+
+func (p *ProjectRole) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := p.view.GetLatestProjectRoleSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (p *ProjectRole) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := p.view.GetLatestProjectRoleSequence()
+	sequence, err := p.view.GetLatestProjectRoleSequence("")
 	if err != nil {
 		return nil, err
 	}
@@ -52,16 +90,16 @@ func (p *ProjectRole) Reduce(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return p.view.DeleteProjectRole(event.AggregateID, event.ResourceOwner, role.Key, event.Sequence, event.CreationDate)
+		return p.view.DeleteProjectRole(event.AggregateID, event.ResourceOwner, role.Key, event)
 	case es_model.ProjectRemoved:
 		return p.view.DeleteProjectRolesByProjectID(event.AggregateID)
 	default:
-		return p.view.ProcessedProjectRoleSequence(event.Sequence, event.CreationDate)
+		return p.view.ProcessedProjectRoleSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return p.view.PutProjectRole(role, event.CreationDate)
+	return p.view.PutProjectRole(role, event)
 }

 func (p *ProjectRole) OnError(event *models.Event, err error) error {
--- a/internal/management/repository/eventsourcing/handler/user.go
+++ b/internal/management/repository/eventsourcing/handler/user.go
@@ -2,14 +2,14 @@ package handler

 import (
 	"context"
-	iam_es "github.com/caos/zitadel/internal/iam/repository/eventsourcing"

 	"github.com/caos/logging"
-
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
+	iam_es "github.com/caos/zitadel/internal/iam/repository/eventsourcing"
 	org_model "github.com/caos/zitadel/internal/org/model"
 	org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
@@ -17,29 +17,68 @@ import (
 	view_model "github.com/caos/zitadel/internal/user/repository/view/model"
 )

-type User struct {
-	handler
-	eventstore eventstore.Eventstore
-	orgEvents  *org_events.OrgEventstore
-	iamEvents  *iam_es.IAMEventstore
-	iamID      string
-}
-
 const (
 	userTable = "management.users"
 )

+type User struct {
+	handler
+	orgEvents    *org_events.OrgEventstore
+	iamEvents    *iam_es.IAMEventstore
+	iamID        string
+	subscription *eventstore.Subscription
+}
+
+func newUser(
+	handler handler,
+	orgEvents *org_events.OrgEventstore,
+	iamEvents *iam_es.IAMEventstore,
+	iamID string,
+) *User {
+	h := &User{
+		handler:   handler,
+		orgEvents: orgEvents,
+		iamEvents: iamEvents,
+		iamID:     iamID,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *User) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (u *User) ViewModel() string {
 	return userTable
 }

+func (_ *User) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{es_model.UserAggregate, org_es_model.OrgAggregate}
+}
+
+func (u *User) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := u.view.GetLatestUserSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
 func (u *User) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := u.view.GetLatestUserSequence()
+	sequence, err := u.view.GetLatestUserSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(es_model.UserAggregate, org_es_model.OrgAggregate).
+		AggregateTypeFilter(u.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

@@ -115,14 +154,14 @@ func (u *User) ProcessUser(event *models.Event) (err error) {
 		}
 		err = u.fillLoginNames(user)
 	case es_model.UserRemoved:
-		return u.view.DeleteUser(event.AggregateID, event.Sequence, event.CreationDate)
+		return u.view.DeleteUser(event.AggregateID, event)
 	default:
-		return u.view.ProcessedUserSequence(event.Sequence, event.CreationDate)
+		return u.view.ProcessedUserSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return u.view.PutUser(user, user.Sequence, event.CreationDate)
+	return u.view.PutUser(user, event)
 }

 func (u *User) ProcessOrg(event *models.Event) (err error) {
@@ -136,7 +175,7 @@ func (u *User) ProcessOrg(event *models.Event) (err error) {
 	case org_es_model.OrgDomainPrimarySet:
 		return u.fillPreferredLoginNamesOnOrgUsers(event)
 	default:
-		return u.view.ProcessedUserSequence(event.Sequence, event.CreationDate)
+		return u.view.ProcessedUserSequence(event)
 	}
 }

@@ -159,7 +198,7 @@ func (u *User) fillLoginNamesOnOrgUsers(event *models.Event) error {
 	for _, user := range users {
 		user.SetLoginNames(policy, org.Domains)
 	}
-	return u.view.PutUsers(users, event.Sequence, event.CreationDate)
+	return u.view.PutUsers(users, event)
 }

 func (u *User) fillPreferredLoginNamesOnOrgUsers(event *models.Event) error {
@@ -184,7 +223,7 @@ func (u *User) fillPreferredLoginNamesOnOrgUsers(event *models.Event) error {
 	for _, user := range users {
 		user.PreferredLoginName = user.GenerateLoginName(org.GetPrimaryDomain().Domain, policy.UserLoginMustBeDomain)
 	}
-	return u.view.PutUsers(users, event.Sequence, event.CreationDate)
+	return u.view.PutUsers(users, event)
 }

 func (u *User) fillLoginNames(user *view_model.UserView) (err error) {
--- a/internal/management/repository/eventsourcing/handler/user_external_idps.go
+++ b/internal/management/repository/eventsourcing/handler/user_external_idps.go
@@ -2,21 +2,27 @@ package handler

 import (
 	"context"
+
 	"github.com/caos/logging"
 	"github.com/caos/zitadel/internal/config/systemdefaults"
 	caos_errs "github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/eventstore/models"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
+	"github.com/caos/zitadel/internal/eventstore/spooler"
+	iam_model "github.com/caos/zitadel/internal/iam/model"
 	"github.com/caos/zitadel/internal/iam/repository/eventsourcing"
+	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	iam_view_model "github.com/caos/zitadel/internal/iam/repository/view/model"
 	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	usr_view_model "github.com/caos/zitadel/internal/user/repository/view/model"
+)

-	"github.com/caos/zitadel/internal/eventstore/models"
-	es_models "github.com/caos/zitadel/internal/eventstore/models"
-	"github.com/caos/zitadel/internal/eventstore/spooler"
-	iam_model "github.com/caos/zitadel/internal/iam/model"
-	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
+const (
+	externalIDPTable = "management.user_external_idps"
 )

 type ExternalIDP struct {
@@ -24,27 +30,63 @@ type ExternalIDP struct {
 	systemDefaults systemdefaults.SystemDefaults
 	iamEvents      *eventsourcing.IAMEventstore
 	orgEvents      *org_es.OrgEventstore
+	subscription   *eventstore.Subscription
 }

-const (
-	externalIDPTable = "management.user_external_idps"
-)
+func newExternalIDP(
+	handler handler,
+	systemDefaults systemdefaults.SystemDefaults,
+	iamEvents *eventsourcing.IAMEventstore,
+	orgEvents *org_es.OrgEventstore,
+) *ExternalIDP {
+	h := &ExternalIDP{
+		handler:        handler,
+		systemDefaults: systemDefaults,
+		iamEvents:      iamEvents,
+		orgEvents:      orgEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *ExternalIDP) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}

 func (i *ExternalIDP) ViewModel() string {
 	return externalIDPTable
 }

-func (i *ExternalIDP) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := i.view.GetLatestExternalIDPSequence()
+func (_ *ExternalIDP) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{model.UserAggregate, iam_es_model.IAMAggregate, org_es_model.OrgAggregate}
+}
+
+func (i *ExternalIDP) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := i.view.GetLatestExternalIDPSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
+func (i *ExternalIDP) EventQuery() (*es_models.SearchQuery, error) {
+	sequence, err := i.view.GetLatestExternalIDPSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(model.UserAggregate, iam_es_model.IAMAggregate, org_es_model.OrgAggregate).
+		AggregateTypeFilter(i.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

-func (i *ExternalIDP) Reduce(event *models.Event) (err error) {
+func (i *ExternalIDP) Reduce(event *es_models.Event) (err error) {
 	switch event.AggregateType {
 	case model.UserAggregate:
 		err = i.processUser(event)
@@ -54,7 +96,7 @@ func (i *ExternalIDP) Reduce(event *models.Event) (err error) {
 	return err
 }

-func (i *ExternalIDP) processUser(event *models.Event) (err error) {
+func (i *ExternalIDP) processUser(event *es_models.Event) (err error) {
 	externalIDP := new(usr_view_model.ExternalIDPView)
 	switch event.Type {
 	case model.HumanExternalIDPAdded:
@@ -68,19 +110,19 @@ func (i *ExternalIDP) processUser(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		return i.view.DeleteExternalIDP(externalIDP.ExternalUserID, externalIDP.IDPConfigID, event.Sequence, event.CreationDate)
+		return i.view.DeleteExternalIDP(externalIDP.ExternalUserID, externalIDP.IDPConfigID, event)
 	case model.UserRemoved:
-		return i.view.DeleteExternalIDPsByUserID(event.AggregateID, event.Sequence, event.CreationDate)
+		return i.view.DeleteExternalIDPsByUserID(event.AggregateID, event)
 	default:
-		return i.view.ProcessedExternalIDPSequence(event.Sequence, event.CreationDate)
+		return i.view.ProcessedExternalIDPSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return i.view.PutExternalIDP(externalIDP, externalIDP.Sequence, event.CreationDate)
+	return i.view.PutExternalIDP(externalIDP, event)
 }

-func (i *ExternalIDP) processIdpConfig(event *models.Event) (err error) {
+func (i *ExternalIDP) processIdpConfig(event *es_models.Event) (err error) {
 	switch event.Type {
 	case iam_es_model.IDPConfigChanged, org_es_model.IDPConfigChanged:
 		configView := new(iam_view_model.IDPConfigView)
@@ -105,9 +147,9 @@ func (i *ExternalIDP) processIdpConfig(event *models.Event) (err error) {
 		for _, provider := range exterinalIDPs {
 			i.fillConfigData(provider, config)
 		}
-		return i.view.PutExternalIDPs(event.Sequence, event.CreationDate, exterinalIDPs...)
+		return i.view.PutExternalIDPs(event, exterinalIDPs...)
 	default:
-		return i.view.ProcessedExternalIDPSequence(event.Sequence, event.CreationDate)
+		return i.view.ProcessedExternalIDPSequence(event)
 	}
 	return nil
 }
@@ -128,7 +170,7 @@ func (i *ExternalIDP) fillConfigData(externalIDP *usr_view_model.ExternalIDPView
 	externalIDP.IDPName = config.Name
 }

-func (i *ExternalIDP) OnError(event *models.Event, err error) error {
+func (i *ExternalIDP) OnError(event *es_models.Event, err error) error {
 	logging.LogWithFields("SPOOL-4Rsu8", "id", event.AggregateID).WithError(err).Warn("something went wrong in idp provider handler")
 	return spooler.HandleError(event, err, i.view.GetLatestExternalIDPFailedEvent, i.view.ProcessedExternalIDPFailedEvent, i.view.ProcessedExternalIDPSequence, i.errorCountUntilSkip)
 }
--- a/internal/management/repository/eventsourcing/handler/user_grant.go
+++ b/internal/management/repository/eventsourcing/handler/user_grant.go
@@ -3,7 +3,12 @@ package handler
 import (
 	"context"

+	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
+	"github.com/caos/zitadel/internal/eventstore/spooler"
 	org_model "github.com/caos/zitadel/internal/org/model"
 	org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	proj_model "github.com/caos/zitadel/internal/project/model"
@@ -13,42 +18,75 @@ import (
 	usr_events "github.com/caos/zitadel/internal/user/repository/eventsourcing"
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	grant_es_model "github.com/caos/zitadel/internal/usergrant/repository/eventsourcing/model"
-
-	"github.com/caos/logging"
-
-	"github.com/caos/zitadel/internal/eventstore"
-	"github.com/caos/zitadel/internal/eventstore/models"
-	"github.com/caos/zitadel/internal/eventstore/spooler"
 	view_model "github.com/caos/zitadel/internal/usergrant/repository/view/model"
 )

-type UserGrant struct {
-	handler
-	eventstore    eventstore.Eventstore
-	projectEvents *proj_event.ProjectEventstore
-	userEvents    *usr_events.UserEventstore
-	orgEvents     *org_events.OrgEventstore
-}
-
 const (
 	userGrantTable = "management.user_grants"
 )

+type UserGrant struct {
+	handler
+	projectEvents *proj_event.ProjectEventstore
+	userEvents    *usr_events.UserEventstore
+	orgEvents     *org_events.OrgEventstore
+	subscription  *eventstore.Subscription
+}
+
+func newUserGrant(
+	handler handler,
+	projectEvents *proj_event.ProjectEventstore,
+	userEvents *usr_events.UserEventstore,
+	orgEvents *org_events.OrgEventstore,
+) *UserGrant {
+	h := &UserGrant{
+		handler:       handler,
+		projectEvents: projectEvents,
+		userEvents:    userEvents,
+		orgEvents:     orgEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *UserGrant) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}
+
 func (u *UserGrant) ViewModel() string {
 	return userGrantTable
 }

-func (u *UserGrant) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := u.view.GetLatestUserGrantSequence()
+func (_ *UserGrant) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{grant_es_model.UserGrantAggregate, usr_es_model.UserAggregate, proj_es_model.ProjectAggregate}
+}
+
+func (u *UserGrant) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := u.view.GetLatestUserGrantSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
+func (u *UserGrant) EventQuery() (*es_models.SearchQuery, error) {
+	sequence, err := u.view.GetLatestUserGrantSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(grant_es_model.UserGrantAggregate, usr_es_model.UserAggregate, proj_es_model.ProjectAggregate).
+		AggregateTypeFilter(u.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

-func (u *UserGrant) Reduce(event *models.Event) (err error) {
+func (u *UserGrant) Reduce(event *es_models.Event) (err error) {
 	switch event.AggregateType {
 	case grant_es_model.UserGrantAggregate:
 		err = u.processUserGrant(event)
@@ -60,7 +98,7 @@ func (u *UserGrant) Reduce(event *models.Event) (err error) {
 	return err
 }

-func (u *UserGrant) processUserGrant(event *models.Event) (err error) {
+func (u *UserGrant) processUserGrant(event *es_models.Event) (err error) {
 	grant := new(view_model.UserGrantView)
 	switch event.Type {
 	case grant_es_model.UserGrantAdded:
@@ -79,17 +117,17 @@ func (u *UserGrant) processUserGrant(event *models.Event) (err error) {
 		}
 		err = grant.AppendEvent(event)
 	case grant_es_model.UserGrantRemoved, grant_es_model.UserGrantCascadeRemoved:
-		return u.view.DeleteUserGrant(event.AggregateID, event.Sequence, event.CreationDate)
+		return u.view.DeleteUserGrant(event.AggregateID, event)
 	default:
-		return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
+		return u.view.ProcessedUserGrantSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return u.view.PutUserGrant(grant, grant.Sequence, event.CreationDate)
+	return u.view.PutUserGrant(grant, event)
 }

-func (u *UserGrant) processUser(event *models.Event) (err error) {
+func (u *UserGrant) processUser(event *es_models.Event) (err error) {
 	switch event.Type {
 	case usr_es_model.UserProfileChanged,
 		usr_es_model.UserEmailChanged,
@@ -101,7 +139,7 @@ func (u *UserGrant) processUser(event *models.Event) (err error) {
 			return err
 		}
 		if len(grants) == 0 {
-			return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
+			return u.view.ProcessedUserGrantSequence(event)
 		}
 		user, err := u.userEvents.UserByID(context.Background(), event.AggregateID)
 		if err != nil {
@@ -110,14 +148,14 @@ func (u *UserGrant) processUser(event *models.Event) (err error) {
 		for _, grant := range grants {
 			u.fillUserData(grant, user)
 		}
-		return u.view.PutUserGrants(grants, event.Sequence, event.CreationDate)
+		return u.view.PutUserGrants(grants, event)
 	default:
-		return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
+		return u.view.ProcessedUserGrantSequence(event)
 	}
 	return nil
 }

-func (u *UserGrant) processProject(event *models.Event) (err error) {
+func (u *UserGrant) processProject(event *es_models.Event) (err error) {
 	switch event.Type {
 	case proj_es_model.ProjectChanged:
 		grants, err := u.view.UserGrantsByProjectID(event.AggregateID)
@@ -125,7 +163,7 @@ func (u *UserGrant) processProject(event *models.Event) (err error) {
 			return err
 		}
 		if len(grants) == 0 {
-			return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
+			return u.view.ProcessedUserGrantSequence(event)
 		}
 		project, err := u.projectEvents.ProjectByID(context.Background(), event.AggregateID)
 		if err != nil {
@@ -134,9 +172,9 @@ func (u *UserGrant) processProject(event *models.Event) (err error) {
 		for _, grant := range grants {
 			u.fillProjectData(grant, project)
 		}
-		return u.view.PutUserGrants(grants, event.Sequence, event.CreationDate)
+		return u.view.PutUserGrants(grants, event)
 	default:
-		return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
+		return u.view.ProcessedUserGrantSequence(event)
 	}
 	return nil
 }
@@ -189,7 +227,7 @@ func (u *UserGrant) fillOrgData(grant *view_model.UserGrantView, org *org_model.
 	}
 }

-func (u *UserGrant) OnError(event *models.Event, err error) error {
+func (u *UserGrant) OnError(event *es_models.Event, err error) error {
 	logging.LogWithFields("SPOOL-8is4s", "id", event.AggregateID).WithError(err).Warn("something went wrong in user handler")
 	return spooler.HandleError(event, err, u.view.GetLatestUserGrantFailedEvent, u.view.ProcessedUserGrantFailedEvent, u.view.ProcessedUserGrantSequence, u.errorCountUntilSkip)
 }
--- a/internal/management/repository/eventsourcing/handler/user_membership.go
+++ b/internal/management/repository/eventsourcing/handler/user_membership.go
@@ -2,48 +2,87 @@ package handler

 import (
 	"context"
+
+	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/eventstore/models"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/query"
+	"github.com/caos/zitadel/internal/eventstore/spooler"
 	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	org_model "github.com/caos/zitadel/internal/org/model"
 	org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
-	"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
-
-	"github.com/caos/logging"
-
-	"github.com/caos/zitadel/internal/eventstore/models"
-	es_models "github.com/caos/zitadel/internal/eventstore/models"
-	"github.com/caos/zitadel/internal/eventstore/spooler"
-	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	usr_model "github.com/caos/zitadel/internal/user/model"
+	"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/view/model"
 )

+const (
+	userMembershipTable = "management.user_memberships"
+)
+
 type UserMembership struct {
 	handler
 	orgEvents     *org_event.OrgEventstore
 	projectEvents *proj_event.ProjectEventstore
+	subscription  *eventstore.Subscription
 }

-const (
-	userMembershipTable = "management.user_memberships"
-)
+func newUserMembership(
+	handler handler,
+	orgEvents *org_event.OrgEventstore,
+	projectEvents *proj_event.ProjectEventstore,
+) *UserMembership {
+	h := &UserMembership{
+		handler:       handler,
+		orgEvents:     orgEvents,
+		projectEvents: projectEvents,
+	}
+
+	h.subscribe()
+
+	return h
+}
+
+func (m *UserMembership) subscribe() {
+	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
+	go func() {
+		for event := range m.subscription.Events {
+			query.ReduceEvent(m, event)
+		}
+	}()
+}

 func (m *UserMembership) ViewModel() string {
 	return userMembershipTable
 }

-func (m *UserMembership) EventQuery() (*models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestUserMembershipSequence()
+func (_ *UserMembership) AggregateTypes() []es_models.AggregateType {
+	return []es_models.AggregateType{iam_es_model.IAMAggregate, org_es_model.OrgAggregate, proj_es_model.ProjectAggregate, model.UserAggregate}
+}
+
+func (u *UserMembership) CurrentSequence(event *models.Event) (uint64, error) {
+	sequence, err := u.view.GetLatestUserMembershipSequence(string(event.AggregateType))
+	if err != nil {
+		return 0, err
+	}
+	return sequence.CurrentSequence, nil
+}
+
+func (m *UserMembership) EventQuery() (*es_models.SearchQuery, error) {
+	sequence, err := m.view.GetLatestUserMembershipSequence("")
 	if err != nil {
 		return nil, err
 	}
 	return es_models.NewSearchQuery().
-		AggregateTypeFilter(iam_es_model.IAMAggregate, org_es_model.OrgAggregate, proj_es_model.ProjectAggregate, model.UserAggregate).
+		AggregateTypeFilter(m.AggregateTypes()...).
 		LatestSequenceFilter(sequence.CurrentSequence), nil
 }

-func (m *UserMembership) Reduce(event *models.Event) (err error) {
+func (m *UserMembership) Reduce(event *es_models.Event) (err error) {
 	switch event.AggregateType {
 	case iam_es_model.IAMAggregate:
 		err = m.processIam(event)
@@ -57,7 +96,7 @@ func (m *UserMembership) Reduce(event *models.Event) (err error) {
 	return err
 }

-func (m *UserMembership) processIam(event *models.Event) (err error) {
+func (m *UserMembership) processIam(event *es_models.Event) (err error) {
 	member := new(usr_es_model.UserMembershipView)
 	err = member.AppendEvent(event)
 	if err != nil {
@@ -73,21 +112,21 @@ func (m *UserMembership) processIam(event *models.Event) (err error) {
 		}
 		err = member.AppendEvent(event)
 	case iam_es_model.IAMMemberRemoved:
-		return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeIam, event.Sequence, event.CreationDate)
+		return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeIam, event)
 	default:
-		return m.view.ProcessedUserMembershipSequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedUserMembershipSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutUserMembership(member, event.Sequence, event.CreationDate)
+	return m.view.PutUserMembership(member, event)
 }

 func (m *UserMembership) fillIamDisplayName(member *usr_es_model.UserMembershipView) {
 	member.DisplayName = member.AggregateID
 }

-func (m *UserMembership) processOrg(event *models.Event) (err error) {
+func (m *UserMembership) processOrg(event *es_models.Event) (err error) {
 	member := new(usr_es_model.UserMembershipView)
 	err = member.AppendEvent(event)
 	if err != nil {
@@ -103,16 +142,16 @@ func (m *UserMembership) processOrg(event *models.Event) (err error) {
 		}
 		err = member.AppendEvent(event)
 	case org_es_model.OrgMemberRemoved:
-		return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeOrganisation, event.Sequence, event.CreationDate)
+		return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeOrganisation, event)
 	case org_es_model.OrgChanged:
 		return m.updateOrgDisplayName(event)
 	default:
-		return m.view.ProcessedUserMembershipSequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedUserMembershipSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutUserMembership(member, event.Sequence, event.CreationDate)
+	return m.view.PutUserMembership(member, event)
 }

 func (m *UserMembership) fillOrgDisplayName(member *usr_es_model.UserMembershipView) (err error) {
@@ -124,7 +163,7 @@ func (m *UserMembership) fillOrgDisplayName(member *usr_es_model.UserMembershipV
 	return nil
 }

-func (m *UserMembership) updateOrgDisplayName(event *models.Event) error {
+func (m *UserMembership) updateOrgDisplayName(event *es_models.Event) error {
 	org, err := m.orgEvents.OrgByID(context.Background(), org_model.NewOrg(event.AggregateID))
 	if err != nil {
 		return err
@@ -137,10 +176,10 @@ func (m *UserMembership) updateOrgDisplayName(event *models.Event) error {
 	for _, membership := range memberships {
 		membership.DisplayName = org.Name
 	}
-	return m.view.BulkPutUserMemberships(memberships, event.Sequence, event.CreationDate)
+	return m.view.BulkPutUserMemberships(memberships, event)
 }

-func (m *UserMembership) processProject(event *models.Event) (err error) {
+func (m *UserMembership) processProject(event *es_models.Event) (err error) {
 	member := new(usr_es_model.UserMembershipView)
 	err = member.AppendEvent(event)
 	if err != nil {
@@ -156,7 +195,7 @@ func (m *UserMembership) processProject(event *models.Event) (err error) {
 		}
 		err = member.AppendEvent(event)
 	case proj_es_model.ProjectMemberRemoved:
-		return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeProject, event.Sequence, event.CreationDate)
+		return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeProject, event)
 	case proj_es_model.ProjectGrantMemberChanged:
 		member, err = m.view.UserMembershipByIDs(member.UserID, event.AggregateID, member.ObjectID, usr_model.MemberTypeProjectGrant)
 		if err != nil {
@@ -164,20 +203,20 @@ func (m *UserMembership) processProject(event *models.Event) (err error) {
 		}
 		err = member.AppendEvent(event)
 	case proj_es_model.ProjectGrantMemberRemoved:
-		return m.view.DeleteUserMembership(member.UserID, event.AggregateID, member.ObjectID, usr_model.MemberTypeProjectGrant, event.Sequence, event.CreationDate)
+		return m.view.DeleteUserMembership(member.UserID, event.AggregateID, member.ObjectID, usr_model.MemberTypeProjectGrant, event)
 	case proj_es_model.ProjectChanged:
 		return m.updateProjectDisplayName(event)
 	case proj_es_model.ProjectRemoved:
-		return m.view.DeleteUserMembershipsByAggregateID(event.AggregateID, event.Sequence, event.CreationDate)
+		return m.view.DeleteUserMembershipsByAggregateID(event.AggregateID, event)
 	case proj_es_model.ProjectGrantRemoved:
-		return m.view.DeleteUserMembershipsByAggregateIDAndObjectID(event.AggregateID, member.ObjectID, event.Sequence, event.CreationDate)
+		return m.view.DeleteUserMembershipsByAggregateIDAndObjectID(event.AggregateID, member.ObjectID, event)
 	default:
-		return m.view.ProcessedUserMembershipSequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedUserMembershipSequence(event)
 	}
 	if err != nil {
 		return err
 	}
-	return m.view.PutUserMembership(member, event.Sequence, event.CreationDate)
+	return m.view.PutUserMembership(member, event)
 }

 func (m *UserMembership) fillProjectDisplayName(member *usr_es_model.UserMembershipView) (err error) {
@@ -189,7 +228,7 @@ func (m *UserMembership) fillProjectDisplayName(member *usr_es_model.UserMembers
 	return nil
 }

-func (m *UserMembership) updateProjectDisplayName(event *models.Event) error {
+func (m *UserMembership) updateProjectDisplayName(event *es_models.Event) error {
 	project, err := m.projectEvents.ProjectByID(context.Background(), event.AggregateID)
 	if err != nil {
 		return err
@@ -202,19 +241,19 @@ func (m *UserMembership) updateProjectDisplayName(event *models.Event) error {
 	for _, membership := range memberships {
 		membership.DisplayName = project.Name
 	}
-	return m.view.BulkPutUserMemberships(memberships, event.Sequence, event.CreationDate)
+	return m.view.BulkPutUserMemberships(memberships, event)
 }

-func (m *UserMembership) processUser(event *models.Event) (err error) {
+func (m *UserMembership) processUser(event *es_models.Event) (err error) {
 	switch event.Type {
 	case model.UserRemoved:
-		return m.view.DeleteUserMembershipsByUserID(event.AggregateID, event.Sequence, event.CreationDate)
+		return m.view.DeleteUserMembershipsByUserID(event.AggregateID, event)
 	default:
-		return m.view.ProcessedUserMembershipSequence(event.Sequence, event.CreationDate)
+		return m.view.ProcessedUserMembershipSequence(event)
 	}
 }

-func (m *UserMembership) OnError(event *models.Event, err error) error {
+func (m *UserMembership) OnError(event *es_models.Event, err error) error {
 	logging.LogWithFields("SPOOL-Fwer2", "id", event.AggregateID).WithError(err).Warn("something went wrong in user membership handler")
 	return spooler.HandleError(event, err, m.view.GetLatestUserMembershipFailedEvent, m.view.ProcessedUserMembershipFailedEvent, m.view.ProcessedUserMembershipSequence, m.errorCountUntilSkip)
 }
--- a/internal/management/repository/eventsourcing/spooler/lock.go
+++ b/internal/management/repository/eventsourcing/spooler/lock.go
@@ -2,7 +2,6 @@ package spooler

 import (
 	"database/sql"
-	es_locker "github.com/caos/zitadel/internal/eventstore/locker"
 	"time"
 )

@@ -15,5 +14,5 @@ type locker struct {
 }

 func (l *locker) Renew(lockerID, viewModel string, waitTime time.Duration) error {
-	return es_locker.Renew(l.dbClient, lockTable, lockerID, viewModel, waitTime)
+	return nil
 }
--- a/internal/management/repository/eventsourcing/view/application.go
+++ b/internal/management/repository/eventsourcing/view/application.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	"github.com/caos/zitadel/internal/project/repository/view"
 	"github.com/caos/zitadel/internal/project/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -24,40 +24,40 @@ func (v *View) SearchApplications(request *proj_model.ApplicationSearchRequest)
 	return view.SearchApplications(v.Db, applicationTable, request)
 }

-func (v *View) PutApplication(app *model.ApplicationView, eventTimestamp time.Time) error {
+func (v *View) PutApplication(app *model.ApplicationView, event *models.Event) error {
 	err := view.PutApplication(v.Db, applicationTable, app)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedApplicationSequence(app.Sequence, eventTimestamp)
+	return v.ProcessedApplicationSequence(event)
 }

-func (v *View) PutApplications(apps []*model.ApplicationView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutApplications(apps []*model.ApplicationView, event *models.Event) error {
 	err := view.PutApplications(v.Db, applicationTable, apps...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedApplicationSequence(sequence, eventTimestamp)
+	return v.ProcessedApplicationSequence(event)
 }

-func (v *View) DeleteApplication(appID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteApplication(appID string, event *models.Event) error {
 	err := view.DeleteApplication(v.Db, applicationTable, appID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedApplicationSequence(eventSequence, eventTimestamp)
+	return v.ProcessedApplicationSequence(event)
 }

 func (v *View) DeleteApplicationsByProjectID(projectID string) error {
 	return view.DeleteApplicationsByProjectID(v.Db, applicationTable, projectID)
 }

-func (v *View) GetLatestApplicationSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(applicationTable)
+func (v *View) GetLatestApplicationSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(applicationTable, aggregateType)
 }

-func (v *View) ProcessedApplicationSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(applicationTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedApplicationSequence(event *models.Event) error {
+	return v.saveCurrentSequence(applicationTable, event)
 }

 func (v *View) UpdateApplicationSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/external_idps.go
+++ b/internal/management/repository/eventsourcing/view/external_idps.go
@@ -2,11 +2,11 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	usr_model "github.com/caos/zitadel/internal/user/model"
 	"github.com/caos/zitadel/internal/user/repository/view"
 	"github.com/caos/zitadel/internal/user/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -33,43 +33,43 @@ func (v *View) SearchExternalIDPs(request *usr_model.ExternalIDPSearchRequest) (
 	return view.SearchExternalIDPs(v.Db, externalIDPTable, request)
 }

-func (v *View) PutExternalIDP(externalIDP *model.ExternalIDPView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutExternalIDP(externalIDP *model.ExternalIDPView, event *models.Event) error {
 	err := view.PutExternalIDP(v.Db, externalIDPTable, externalIDP)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedExternalIDPSequence(sequence, eventTimestamp)
+	return v.ProcessedExternalIDPSequence(event)
 }

-func (v *View) PutExternalIDPs(sequence uint64, eventTimestamp time.Time, externalIDPs ...*model.ExternalIDPView) error {
+func (v *View) PutExternalIDPs(event *models.Event, externalIDPs ...*model.ExternalIDPView) error {
 	err := view.PutExternalIDPs(v.Db, externalIDPTable, externalIDPs...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedExternalIDPSequence(sequence, eventTimestamp)
+	return v.ProcessedExternalIDPSequence(event)
 }

-func (v *View) DeleteExternalIDP(externalUserID, idpConfigID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteExternalIDP(externalUserID, idpConfigID string, event *models.Event) error {
 	err := view.DeleteExternalIDP(v.Db, externalIDPTable, externalUserID, idpConfigID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedExternalIDPSequence(eventSequence, eventTimestamp)
+	return v.ProcessedExternalIDPSequence(event)
 }

-func (v *View) DeleteExternalIDPsByUserID(userID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteExternalIDPsByUserID(userID string, event *models.Event) error {
 	err := view.DeleteExternalIDPsByUserID(v.Db, externalIDPTable, userID)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedExternalIDPSequence(eventSequence, eventTimestamp)
+	return v.ProcessedExternalIDPSequence(event)
 }
-func (v *View) GetLatestExternalIDPSequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(externalIDPTable)
+func (v *View) GetLatestExternalIDPSequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(externalIDPTable, aggregateType)
 }

-func (v *View) ProcessedExternalIDPSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(externalIDPTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedExternalIDPSequence(event *models.Event) error {
+	return v.saveCurrentSequence(externalIDPTable, event)
 }

 func (v *View) UpdateExternalIDPSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/idp_configs.go
+++ b/internal/management/repository/eventsourcing/view/idp_configs.go
@@ -2,11 +2,11 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	iam_model "github.com/caos/zitadel/internal/iam/model"
 	"github.com/caos/zitadel/internal/iam/repository/view"
 	iam_es_model "github.com/caos/zitadel/internal/iam/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -21,28 +21,28 @@ func (v *View) SearchIDPConfigs(request *iam_model.IDPConfigSearchRequest) ([]*i
 	return view.SearchIDPs(v.Db, idpConfigTable, request)
 }

-func (v *View) PutIDPConfig(idp *iam_es_model.IDPConfigView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutIDPConfig(idp *iam_es_model.IDPConfigView, event *models.Event) error {
 	err := view.PutIDP(v.Db, idpConfigTable, idp)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedIDPConfigSequence(sequence, eventTimestamp)
+	return v.ProcessedIDPConfigSequence(event)
 }

-func (v *View) DeleteIDPConfig(idpID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteIDPConfig(idpID string, event *models.Event) error {
 	err := view.DeleteIDP(v.Db, idpConfigTable, idpID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedIDPConfigSequence(eventSequence, eventTimestamp)
+	return v.ProcessedIDPConfigSequence(event)
 }

-func (v *View) GetLatestIDPConfigSequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(idpConfigTable)
+func (v *View) GetLatestIDPConfigSequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(idpConfigTable, aggregateType)
 }

-func (v *View) ProcessedIDPConfigSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(idpConfigTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedIDPConfigSequence(event *models.Event) error {
+	return v.saveCurrentSequence(idpConfigTable, event)
 }

 func (v *View) UpdateIDPConfigSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/idp_providers.go
+++ b/internal/management/repository/eventsourcing/view/idp_providers.go
@@ -2,11 +2,11 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	iam_model "github.com/caos/zitadel/internal/iam/model"
 	"github.com/caos/zitadel/internal/iam/repository/view"
 	"github.com/caos/zitadel/internal/iam/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -25,44 +25,44 @@ func (v *View) SearchIDPProviders(request *iam_model.IDPProviderSearchRequest) (
 	return view.SearchIDPProviders(v.Db, idpProviderTable, request)
 }

-func (v *View) PutIDPProvider(provider *model.IDPProviderView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutIDPProvider(provider *model.IDPProviderView, event *models.Event) error {
 	err := view.PutIDPProvider(v.Db, idpProviderTable, provider)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedIDPProviderSequence(sequence, eventTimestamp)
+	return v.ProcessedIDPProviderSequence(event)
 }

-func (v *View) PutIDPProviders(sequence uint64, eventTimestamp time.Time, providers ...*model.IDPProviderView) error {
+func (v *View) PutIDPProviders(event *models.Event, providers ...*model.IDPProviderView) error {
 	err := view.PutIDPProviders(v.Db, idpProviderTable, providers...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedIDPProviderSequence(sequence, eventTimestamp)
+	return v.ProcessedIDPProviderSequence(event)
 }

-func (v *View) DeleteIDPProvider(aggregateID, idpConfigID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteIDPProvider(aggregateID, idpConfigID string, event *models.Event) error {
 	err := view.DeleteIDPProvider(v.Db, idpProviderTable, aggregateID, idpConfigID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedIDPProviderSequence(eventSequence, eventTimestamp)
+	return v.ProcessedIDPProviderSequence(event)
 }

-func (v *View) DeleteIDPProvidersByAggregateID(aggregateID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteIDPProvidersByAggregateID(aggregateID string, event *models.Event) error {
 	err := view.DeleteIDPProvidersByAggregateID(v.Db, idpProviderTable, aggregateID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedIDPProviderSequence(eventSequence, eventTimestamp)
+	return v.ProcessedIDPProviderSequence(event)
 }

-func (v *View) GetLatestIDPProviderSequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(idpProviderTable)
+func (v *View) GetLatestIDPProviderSequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(idpProviderTable, aggregateType)
 }

-func (v *View) ProcessedIDPProviderSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(idpProviderTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedIDPProviderSequence(event *models.Event) error {
+	return v.saveCurrentSequence(idpProviderTable, event)
 }

 func (v *View) UpdateIDPProviderSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/label_policies.go
+++ b/internal/management/repository/eventsourcing/view/label_policies.go
@@ -2,10 +2,10 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/iam/repository/view"
 	"github.com/caos/zitadel/internal/iam/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -16,28 +16,28 @@ func (v *View) LabelPolicyByAggregateID(aggregateID string) (*model.LabelPolicyV
 	return view.GetLabelPolicyByAggregateID(v.Db, labelPolicyTable, aggregateID)
 }

-func (v *View) PutLabelPolicy(policy *model.LabelPolicyView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutLabelPolicy(policy *model.LabelPolicyView, event *models.Event) error {
 	err := view.PutLabelPolicy(v.Db, labelPolicyTable, policy)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedLabelPolicySequence(sequence, eventTimestamp)
+	return v.ProcessedLabelPolicySequence(event)
 }

-func (v *View) DeleteLabelPolicy(aggregateID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteLabelPolicy(aggregateID string, event *models.Event) error {
 	err := view.DeleteLabelPolicy(v.Db, labelPolicyTable, aggregateID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedLabelPolicySequence(eventSequence, eventTimestamp)
+	return v.ProcessedLabelPolicySequence(event)
 }

-func (v *View) GetLatestLabelPolicySequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(labelPolicyTable)
+func (v *View) GetLatestLabelPolicySequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(labelPolicyTable, aggregateType)
 }

-func (v *View) ProcessedLabelPolicySequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(labelPolicyTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedLabelPolicySequence(event *models.Event) error {
+	return v.saveCurrentSequence(labelPolicyTable, event)
 }

 func (v *View) UpdateLabelPolicySpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/login_policies.go
+++ b/internal/management/repository/eventsourcing/view/login_policies.go
@@ -2,10 +2,10 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/iam/repository/view"
 	"github.com/caos/zitadel/internal/iam/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -16,28 +16,28 @@ func (v *View) LoginPolicyByAggregateID(aggregateID string) (*model.LoginPolicyV
 	return view.GetLoginPolicyByAggregateID(v.Db, loginPolicyTable, aggregateID)
 }

-func (v *View) PutLoginPolicy(policy *model.LoginPolicyView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutLoginPolicy(policy *model.LoginPolicyView, event *models.Event) error {
 	err := view.PutLoginPolicy(v.Db, loginPolicyTable, policy)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedLoginPolicySequence(sequence, eventTimestamp)
+	return v.ProcessedLoginPolicySequence(event)
 }

-func (v *View) DeleteLoginPolicy(aggregateID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteLoginPolicy(aggregateID string, event *models.Event) error {
 	err := view.DeleteLoginPolicy(v.Db, loginPolicyTable, aggregateID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedLoginPolicySequence(eventSequence, eventTimestamp)
+	return v.ProcessedLoginPolicySequence(event)
 }

-func (v *View) GetLatestLoginPolicySequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(loginPolicyTable)
+func (v *View) GetLatestLoginPolicySequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(loginPolicyTable, aggregateType)
 }

-func (v *View) ProcessedLoginPolicySequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(loginPolicyTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedLoginPolicySequence(event *models.Event) error {
+	return v.saveCurrentSequence(loginPolicyTable, event)
 }

 func (v *View) UpdateLoginPolicySpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/machine_keys.go
+++ b/internal/management/repository/eventsourcing/view/machine_keys.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	usr_model "github.com/caos/zitadel/internal/user/model"
 	"github.com/caos/zitadel/internal/user/repository/view"
 	"github.com/caos/zitadel/internal/user/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -24,39 +24,39 @@ func (v *View) SearchMachineKeys(request *usr_model.MachineKeySearchRequest) ([]
 	return view.SearchMachineKeys(v.Db, machineKeyTable, request)
 }

-func (v *View) PutMachineKey(org *model.MachineKeyView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutMachineKey(org *model.MachineKeyView, event *models.Event) error {
 	err := view.PutMachineKey(v.Db, machineKeyTable, org)
 	if err != nil {
 		return err
 	}
-	if sequence != 0 {
-		return v.ProcessedMachineKeySequence(sequence, eventTimestamp)
+	if event.Sequence != 0 {
+		return v.ProcessedMachineKeySequence(event)
 	}
 	return nil
 }

-func (v *View) DeleteMachineKey(keyID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteMachineKey(keyID string, event *models.Event) error {
 	err := view.DeleteMachineKey(v.Db, machineKeyTable, keyID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedMachineKeySequence(eventSequence, eventTimestamp)
+	return v.ProcessedMachineKeySequence(event)
 }

-func (v *View) DeleteMachineKeysByUserID(userID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteMachineKeysByUserID(userID string, event *models.Event) error {
 	err := view.DeleteMachineKey(v.Db, machineKeyTable, userID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedMachineKeySequence(eventSequence, eventTimestamp)
+	return v.ProcessedMachineKeySequence(event)
 }

-func (v *View) GetLatestMachineKeySequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(machineKeyTable)
+func (v *View) GetLatestMachineKeySequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(machineKeyTable, aggregateType)
 }

-func (v *View) ProcessedMachineKeySequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(machineKeyTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedMachineKeySequence(event *models.Event) error {
+	return v.saveCurrentSequence(machineKeyTable, event)
 }

 func (v *View) UpdateMachineKeySpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/org.go
+++ b/internal/management/repository/eventsourcing/view/org.go
@@ -1,10 +1,10 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	org_view "github.com/caos/zitadel/internal/org/repository/view"
 	"github.com/caos/zitadel/internal/org/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -15,12 +15,12 @@ func (v *View) OrgByID(orgID string) (*model.OrgView, error) {
 	return org_view.OrgByID(v.Db, orgTable, orgID)
 }

-func (v *View) PutOrg(org *model.OrgView, eventTimestamp time.Time) error {
+func (v *View) PutOrg(org *model.OrgView, event *models.Event) error {
 	err := org_view.PutOrg(v.Db, orgTable, org)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedOrgSequence(org.Sequence, eventTimestamp)
+	return v.ProcessedOrgSequence(event)
 }

 func (v *View) GetLatestOrgFailedEvent(sequence uint64) (*repository.FailedEvent, error) {
@@ -35,10 +35,10 @@ func (v *View) UpdateOrgSpoolerRunTimestamp() error {
 	return v.updateSpoolerRunSequence(orgTable)
 }

-func (v *View) GetLatestOrgSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(orgTable)
+func (v *View) GetLatestOrgSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(orgTable, aggregateType)
 }

-func (v *View) ProcessedOrgSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(orgTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedOrgSequence(event *models.Event) error {
+	return v.saveCurrentSequence(orgTable, event)
 }
--- a/internal/management/repository/eventsourcing/view/org_domain.go
+++ b/internal/management/repository/eventsourcing/view/org_domain.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	org_model "github.com/caos/zitadel/internal/org/model"
 	"github.com/caos/zitadel/internal/org/repository/view"
 	"github.com/caos/zitadel/internal/org/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -28,39 +28,39 @@ func (v *View) SearchOrgDomains(request *org_model.OrgDomainSearchRequest) ([]*m
 	return view.SearchOrgDomains(v.Db, orgDomainTable, request)
 }

-func (v *View) PutOrgDomain(org *model.OrgDomainView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutOrgDomain(org *model.OrgDomainView, event *models.Event) error {
 	err := view.PutOrgDomain(v.Db, orgDomainTable, org)
 	if err != nil {
 		return err
 	}
-	if sequence != 0 {
-		return v.ProcessedOrgDomainSequence(sequence, eventTimestamp)
+	if event.Sequence != 0 {
+		return v.ProcessedOrgDomainSequence(event)
 	}
 	return nil
 }

-func (v *View) PutOrgDomains(domains []*model.OrgDomainView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutOrgDomains(domains []*model.OrgDomainView, event *models.Event) error {
 	err := view.PutOrgDomains(v.Db, orgDomainTable, domains...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedUserSequence(sequence, eventTimestamp)
+	return v.ProcessedUserSequence(event)
 }

-func (v *View) DeleteOrgDomain(orgID, domain string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteOrgDomain(orgID, domain string, event *models.Event) error {
 	err := view.DeleteOrgDomain(v.Db, orgDomainTable, orgID, domain)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedOrgDomainSequence(eventSequence, eventTimestamp)
+	return v.ProcessedOrgDomainSequence(event)
 }

-func (v *View) GetLatestOrgDomainSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(orgDomainTable)
+func (v *View) GetLatestOrgDomainSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(orgDomainTable, aggregateType)
 }

-func (v *View) ProcessedOrgDomainSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(orgDomainTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedOrgDomainSequence(event *models.Event) error {
+	return v.saveCurrentSequence(orgDomainTable, event)
 }

 func (v *View) UpdateOrgDomainSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/org_iam_policy.go
+++ b/internal/management/repository/eventsourcing/view/org_iam_policy.go
@@ -2,10 +2,10 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/iam/repository/view"
 	"github.com/caos/zitadel/internal/iam/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -16,28 +16,28 @@ func (v *View) OrgIAMPolicyByAggregateID(aggregateID string) (*model.OrgIAMPolic
 	return view.GetOrgIAMPolicyByAggregateID(v.Db, orgIAMPolicyTable, aggregateID)
 }

-func (v *View) PutOrgIAMPolicy(policy *model.OrgIAMPolicyView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutOrgIAMPolicy(policy *model.OrgIAMPolicyView, event *models.Event) error {
 	err := view.PutOrgIAMPolicy(v.Db, orgIAMPolicyTable, policy)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedOrgIAMPolicySequence(sequence, eventTimestamp)
+	return v.ProcessedOrgIAMPolicySequence(event)
 }

-func (v *View) DeleteOrgIAMPolicy(aggregateID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteOrgIAMPolicy(aggregateID string, event *models.Event) error {
 	err := view.DeleteOrgIAMPolicy(v.Db, orgIAMPolicyTable, aggregateID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedOrgIAMPolicySequence(eventSequence, eventTimestamp)
+	return v.ProcessedOrgIAMPolicySequence(event)
 }

-func (v *View) GetLatestOrgIAMPolicySequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(orgIAMPolicyTable)
+func (v *View) GetLatestOrgIAMPolicySequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(orgIAMPolicyTable, aggregateType)
 }

-func (v *View) ProcessedOrgIAMPolicySequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(orgIAMPolicyTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedOrgIAMPolicySequence(event *models.Event) error {
+	return v.saveCurrentSequence(orgIAMPolicyTable, event)
 }

 func (v *View) UpdateOrgIAMPolicySpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/org_member.go
+++ b/internal/management/repository/eventsourcing/view/org_member.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	org_model "github.com/caos/zitadel/internal/org/model"
 	"github.com/caos/zitadel/internal/org/repository/view"
 	"github.com/caos/zitadel/internal/org/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -24,44 +24,44 @@ func (v *View) OrgMembersByUserID(userID string) ([]*model.OrgMemberView, error)
 	return view.OrgMembersByUserID(v.Db, orgMemberTable, userID)
 }

-func (v *View) PutOrgMember(member *model.OrgMemberView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutOrgMember(member *model.OrgMemberView, event *models.Event) error {
 	err := view.PutOrgMember(v.Db, orgMemberTable, member)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedOrgMemberSequence(sequence, eventTimestamp)
+	return v.ProcessedOrgMemberSequence(event)
 }

-func (v *View) PutOrgMembers(members []*model.OrgMemberView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutOrgMembers(members []*model.OrgMemberView, event *models.Event) error {
 	err := view.PutOrgMembers(v.Db, orgMemberTable, members...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedOrgMemberSequence(sequence, eventTimestamp)
+	return v.ProcessedOrgMemberSequence(event)
 }

-func (v *View) DeleteOrgMember(orgID, userID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteOrgMember(orgID, userID string, event *models.Event) error {
 	err := view.DeleteOrgMember(v.Db, orgMemberTable, orgID, userID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedOrgMemberSequence(eventSequence, eventTimestamp)
+	return v.ProcessedOrgMemberSequence(event)
 }

-func (v *View) DeleteOrgMembersByUserID(userID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteOrgMembersByUserID(userID string, event *models.Event) error {
 	err := view.DeleteOrgMembersByUserID(v.Db, orgMemberTable, userID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedOrgMemberSequence(eventSequence, eventTimestamp)
+	return v.ProcessedOrgMemberSequence(event)
 }

-func (v *View) GetLatestOrgMemberSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(orgMemberTable)
+func (v *View) GetLatestOrgMemberSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(orgMemberTable, aggregateType)
 }

-func (v *View) ProcessedOrgMemberSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(orgMemberTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedOrgMemberSequence(event *models.Event) error {
+	return v.saveCurrentSequence(orgMemberTable, event)
 }

 func (v *View) UpdateOrgMemberSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/password_age_policy.go
+++ b/internal/management/repository/eventsourcing/view/password_age_policy.go
@@ -2,10 +2,10 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/iam/repository/view"
 	"github.com/caos/zitadel/internal/iam/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -16,28 +16,28 @@ func (v *View) PasswordAgePolicyByAggregateID(aggregateID string) (*model.Passwo
 	return view.GetPasswordAgePolicyByAggregateID(v.Db, passwordAgePolicyTable, aggregateID)
 }

-func (v *View) PutPasswordAgePolicy(policy *model.PasswordAgePolicyView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutPasswordAgePolicy(policy *model.PasswordAgePolicyView, event *models.Event) error {
 	err := view.PutPasswordAgePolicy(v.Db, passwordAgePolicyTable, policy)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedPasswordAgePolicySequence(sequence, eventTimestamp)
+	return v.ProcessedPasswordAgePolicySequence(event)
 }

-func (v *View) DeletePasswordAgePolicy(aggregateID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeletePasswordAgePolicy(aggregateID string, event *models.Event) error {
 	err := view.DeletePasswordAgePolicy(v.Db, passwordAgePolicyTable, aggregateID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedPasswordAgePolicySequence(eventSequence, eventTimestamp)
+	return v.ProcessedPasswordAgePolicySequence(event)
 }

-func (v *View) GetLatestPasswordAgePolicySequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(passwordAgePolicyTable)
+func (v *View) GetLatestPasswordAgePolicySequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(passwordAgePolicyTable, aggregateType)
 }

-func (v *View) ProcessedPasswordAgePolicySequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(passwordAgePolicyTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedPasswordAgePolicySequence(event *models.Event) error {
+	return v.saveCurrentSequence(passwordAgePolicyTable, event)
 }

 func (v *View) UpdatePasswordAgePolicySpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/password_complexity_policy.go
+++ b/internal/management/repository/eventsourcing/view/password_complexity_policy.go
@@ -2,10 +2,10 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/iam/repository/view"
 	"github.com/caos/zitadel/internal/iam/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -16,28 +16,28 @@ func (v *View) PasswordComplexityPolicyByAggregateID(aggregateID string) (*model
 	return view.GetPasswordComplexityPolicyByAggregateID(v.Db, passwordComplexityPolicyTable, aggregateID)
 }

-func (v *View) PutPasswordComplexityPolicy(policy *model.PasswordComplexityPolicyView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutPasswordComplexityPolicy(policy *model.PasswordComplexityPolicyView, event *models.Event) error {
 	err := view.PutPasswordComplexityPolicy(v.Db, passwordComplexityPolicyTable, policy)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedPasswordComplexityPolicySequence(sequence, eventTimestamp)
+	return v.ProcessedPasswordComplexityPolicySequence(event)
 }

-func (v *View) DeletePasswordComplexityPolicy(aggregateID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeletePasswordComplexityPolicy(aggregateID string, event *models.Event) error {
 	err := view.DeletePasswordComplexityPolicy(v.Db, passwordComplexityPolicyTable, aggregateID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedPasswordComplexityPolicySequence(eventSequence, eventTimestamp)
+	return v.ProcessedPasswordComplexityPolicySequence(event)
 }

-func (v *View) GetLatestPasswordComplexityPolicySequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(passwordComplexityPolicyTable)
+func (v *View) GetLatestPasswordComplexityPolicySequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(passwordComplexityPolicyTable, aggregateType)
 }

-func (v *View) ProcessedPasswordComplexityPolicySequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(passwordComplexityPolicyTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedPasswordComplexityPolicySequence(event *models.Event) error {
+	return v.saveCurrentSequence(passwordComplexityPolicyTable, event)
 }

 func (v *View) UpdatePasswordComplexityPolicySpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/password_lockout_policy.go
+++ b/internal/management/repository/eventsourcing/view/password_lockout_policy.go
@@ -2,10 +2,10 @@ package view

 import (
 	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/iam/repository/view"
 	"github.com/caos/zitadel/internal/iam/repository/view/model"
 	global_view "github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -16,28 +16,28 @@ func (v *View) PasswordLockoutPolicyByAggregateID(aggregateID string) (*model.Pa
 	return view.GetPasswordLockoutPolicyByAggregateID(v.Db, passwordLockoutPolicyTable, aggregateID)
 }

-func (v *View) PutPasswordLockoutPolicy(policy *model.PasswordLockoutPolicyView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutPasswordLockoutPolicy(policy *model.PasswordLockoutPolicyView, event *models.Event) error {
 	err := view.PutPasswordLockoutPolicy(v.Db, passwordLockoutPolicyTable, policy)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedPasswordLockoutPolicySequence(sequence, eventTimestamp)
+	return v.ProcessedPasswordLockoutPolicySequence(event)
 }

-func (v *View) DeletePasswordLockoutPolicy(aggregateID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeletePasswordLockoutPolicy(aggregateID string, event *models.Event) error {
 	err := view.DeletePasswordLockoutPolicy(v.Db, passwordLockoutPolicyTable, aggregateID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedPasswordLockoutPolicySequence(eventSequence, eventTimestamp)
+	return v.ProcessedPasswordLockoutPolicySequence(event)
 }

-func (v *View) GetLatestPasswordLockoutPolicySequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(passwordLockoutPolicyTable)
+func (v *View) GetLatestPasswordLockoutPolicySequence(aggregateType string) (*global_view.CurrentSequence, error) {
+	return v.latestSequence(passwordLockoutPolicyTable, aggregateType)
 }

-func (v *View) ProcessedPasswordLockoutPolicySequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(passwordLockoutPolicyTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedPasswordLockoutPolicySequence(event *models.Event) error {
+	return v.saveCurrentSequence(passwordLockoutPolicyTable, event)
 }

 func (v *View) UpdatePasswordLockoutPolicySpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/project.go
+++ b/internal/management/repository/eventsourcing/view/project.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	"github.com/caos/zitadel/internal/project/repository/view"
 	"github.com/caos/zitadel/internal/project/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -20,28 +20,28 @@ func (v *View) SearchProjects(request *proj_model.ProjectViewSearchRequest) ([]*
 	return view.SearchProjects(v.Db, projectTable, request)
 }

-func (v *View) PutProject(project *model.ProjectView, eventTimestamp time.Time) error {
+func (v *View) PutProject(project *model.ProjectView, event *models.Event) error {
 	err := view.PutProject(v.Db, projectTable, project)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectSequence(project.Sequence, eventTimestamp)
+	return v.ProcessedProjectSequence(event)
 }

-func (v *View) DeleteProject(projectID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteProject(projectID string, event *models.Event) error {
 	err := view.DeleteProject(v.Db, projectTable, projectID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedProjectSequence(eventSequence, eventTimestamp)
+	return v.ProcessedProjectSequence(event)
 }

-func (v *View) GetLatestProjectSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(projectTable)
+func (v *View) GetLatestProjectSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(projectTable, aggregateType)
 }

-func (v *View) ProcessedProjectSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(projectTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedProjectSequence(event *models.Event) error {
+	return v.saveCurrentSequence(projectTable, event)
 }

 func (v *View) UpdateProjectSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/project_grant.go
+++ b/internal/management/repository/eventsourcing/view/project_grant.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	"github.com/caos/zitadel/internal/project/repository/view"
 	"github.com/caos/zitadel/internal/project/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -32,40 +32,40 @@ func (v *View) SearchProjectGrants(request *proj_model.ProjectGrantViewSearchReq
 	return view.SearchProjectGrants(v.Db, grantedProjectTable, request)
 }

-func (v *View) PutProjectGrant(grant *model.ProjectGrantView, eventTimestamp time.Time) error {
+func (v *View) PutProjectGrant(grant *model.ProjectGrantView, event *models.Event) error {
 	err := view.PutProjectGrant(v.Db, grantedProjectTable, grant)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectGrantSequence(grant.Sequence, eventTimestamp)
+	return v.ProcessedProjectGrantSequence(event)
 }

-func (v *View) PutProjectGrants(grants []*model.ProjectGrantView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutProjectGrants(grants []*model.ProjectGrantView, event *models.Event) error {
 	err := view.PutProjectGrants(v.Db, grantedProjectTable, grants...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectGrantSequence(sequence, eventTimestamp)
+	return v.ProcessedProjectGrantSequence(event)
 }

-func (v *View) DeleteProjectGrant(grantID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteProjectGrant(grantID string, event *models.Event) error {
 	err := view.DeleteProjectGrant(v.Db, grantedProjectTable, grantID)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectGrantSequence(eventSequence, eventTimestamp)
+	return v.ProcessedProjectGrantSequence(event)
 }

 func (v *View) DeleteProjectGrantsByProjectID(projectID string) error {
 	return view.DeleteProjectGrantsByProjectID(v.Db, grantedProjectTable, projectID)
 }

-func (v *View) GetLatestProjectGrantSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(grantedProjectTable)
+func (v *View) GetLatestProjectGrantSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(grantedProjectTable, aggregateType)
 }

-func (v *View) ProcessedProjectGrantSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(grantedProjectTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedProjectGrantSequence(event *models.Event) error {
+	return v.saveCurrentSequence(grantedProjectTable, event)
 }

 func (v *View) UpdateProjectGrantSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/project_grant_member.go
+++ b/internal/management/repository/eventsourcing/view/project_grant_member.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	"github.com/caos/zitadel/internal/project/repository/view"
 	"github.com/caos/zitadel/internal/project/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -28,40 +28,40 @@ func (v *View) ProjectGrantMembersByUserID(userID string) ([]*model.ProjectGrant
 	return view.ProjectGrantMembersByUserID(v.Db, projectGrantMemberTable, userID)
 }

-func (v *View) PutProjectGrantMember(member *model.ProjectGrantMemberView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutProjectGrantMember(member *model.ProjectGrantMemberView, event *models.Event) error {
 	err := view.PutProjectGrantMember(v.Db, projectGrantMemberTable, member)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectGrantMemberSequence(sequence, eventTimestamp)
+	return v.ProcessedProjectGrantMemberSequence(event)
 }

-func (v *View) PutProjectGrantMembers(members []*model.ProjectGrantMemberView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutProjectGrantMembers(members []*model.ProjectGrantMemberView, event *models.Event) error {
 	err := view.PutProjectGrantMembers(v.Db, projectGrantMemberTable, members...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectGrantMemberSequence(sequence, eventTimestamp)
+	return v.ProcessedProjectGrantMemberSequence(event)
 }

-func (v *View) DeleteProjectGrantMember(grantID, userID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteProjectGrantMember(grantID, userID string, event *models.Event) error {
 	err := view.DeleteProjectGrantMember(v.Db, projectGrantMemberTable, grantID, userID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedProjectGrantMemberSequence(eventSequence, eventTimestamp)
+	return v.ProcessedProjectGrantMemberSequence(event)
 }

 func (v *View) DeleteProjectGrantMembersByProjectID(projectID string) error {
 	return view.DeleteProjectGrantMembersByProjectID(v.Db, projectGrantMemberTable, projectID)
 }

-func (v *View) GetLatestProjectGrantMemberSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(projectGrantMemberTable)
+func (v *View) GetLatestProjectGrantMemberSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(projectGrantMemberTable, aggregateType)
 }

-func (v *View) ProcessedProjectGrantMemberSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(projectGrantMemberTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedProjectGrantMemberSequence(event *models.Event) error {
+	return v.saveCurrentSequence(projectGrantMemberTable, event)
 }

 func (v *View) UpdateProjectGrantMemberSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/project_member.go
+++ b/internal/management/repository/eventsourcing/view/project_member.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	"github.com/caos/zitadel/internal/project/repository/view"
 	"github.com/caos/zitadel/internal/project/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -28,40 +28,40 @@ func (v *View) ProjectMembersByUserID(userID string) ([]*model.ProjectMemberView
 	return view.ProjectMembersByUserID(v.Db, projectMemberTable, userID)
 }

-func (v *View) PutProjectMember(project *model.ProjectMemberView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutProjectMember(project *model.ProjectMemberView, event *models.Event) error {
 	err := view.PutProjectMember(v.Db, projectMemberTable, project)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectMemberSequence(sequence, eventTimestamp)
+	return v.ProcessedProjectMemberSequence(event)
 }

-func (v *View) PutProjectMembers(project []*model.ProjectMemberView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutProjectMembers(project []*model.ProjectMemberView, event *models.Event) error {
 	err := view.PutProjectMembers(v.Db, projectMemberTable, project...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectMemberSequence(sequence, eventTimestamp)
+	return v.ProcessedProjectMemberSequence(event)
 }

-func (v *View) DeleteProjectMember(projectID, userID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteProjectMember(projectID, userID string, event *models.Event) error {
 	err := view.DeleteProjectMember(v.Db, projectMemberTable, projectID, userID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedProjectMemberSequence(eventSequence, eventTimestamp)
+	return v.ProcessedProjectMemberSequence(event)
 }

 func (v *View) DeleteProjectMembersByProjectID(projectID string) error {
 	return view.DeleteProjectMembersByProjectID(v.Db, projectMemberTable, projectID)
 }

-func (v *View) GetLatestProjectMemberSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(projectMemberTable)
+func (v *View) GetLatestProjectMemberSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(projectMemberTable, aggregateType)
 }

-func (v *View) ProcessedProjectMemberSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(projectMemberTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedProjectMemberSequence(event *models.Event) error {
+	return v.saveCurrentSequence(projectMemberTable, event)
 }

 func (v *View) UpdateProjectMemberSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/project_role.go
+++ b/internal/management/repository/eventsourcing/view/project_role.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	"github.com/caos/zitadel/internal/project/repository/view"
 	"github.com/caos/zitadel/internal/project/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -32,32 +32,32 @@ func (v *View) SearchProjectRoles(request *proj_model.ProjectRoleSearchRequest)
 	return view.SearchProjectRoles(v.Db, projectRoleTable, request)
 }

-func (v *View) PutProjectRole(project *model.ProjectRoleView, eventTimestamp time.Time) error {
+func (v *View) PutProjectRole(project *model.ProjectRoleView, event *models.Event) error {
 	err := view.PutProjectRole(v.Db, projectRoleTable, project)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedProjectRoleSequence(project.Sequence, eventTimestamp)
+	return v.ProcessedProjectRoleSequence(event)
 }

-func (v *View) DeleteProjectRole(projectID, orgID, key string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteProjectRole(projectID, orgID, key string, event *models.Event) error {
 	err := view.DeleteProjectRole(v.Db, projectRoleTable, projectID, orgID, key)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedProjectRoleSequence(eventSequence, eventTimestamp)
+	return v.ProcessedProjectRoleSequence(event)
 }

 func (v *View) DeleteProjectRolesByProjectID(projectID string) error {
 	return view.DeleteProjectRolesByProjectID(v.Db, projectRoleTable, projectID)
 }

-func (v *View) GetLatestProjectRoleSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(projectRoleTable)
+func (v *View) GetLatestProjectRoleSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(projectRoleTable, aggregateType)
 }

-func (v *View) ProcessedProjectRoleSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(projectRoleTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedProjectRoleSequence(event *models.Event) error {
+	return v.saveCurrentSequence(projectRoleTable, event)
 }

 func (v *View) UpdateProjectRoleSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/sequence.go
+++ b/internal/management/repository/eventsourcing/view/sequence.go
@@ -1,24 +1,26 @@
 package view

 import (
-	"github.com/caos/zitadel/internal/view/repository"
 	"time"
+
+	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/view/repository"
 )

 const (
 	sequencesTable = "management.current_sequences"
 )

-func (v *View) saveCurrentSequence(viewName string, sequence uint64, eventTimestamp time.Time) error {
-	return repository.SaveCurrentSequence(v.Db, sequencesTable, viewName, sequence, eventTimestamp)
+func (v *View) saveCurrentSequence(viewName string, event *models.Event) error {
+	return repository.SaveCurrentSequence(v.Db, sequencesTable, viewName, string(event.AggregateType), event.Sequence, event.CreationDate)
 }

-func (v *View) latestSequence(viewName string) (*repository.CurrentSequence, error) {
-	return repository.LatestSequence(v.Db, sequencesTable, viewName)
+func (v *View) latestSequence(viewName, aggregateType string) (*repository.CurrentSequence, error) {
+	return repository.LatestSequence(v.Db, sequencesTable, viewName, aggregateType)
 }

 func (v *View) updateSpoolerRunSequence(viewName string) error {
-	currentSequence, err := repository.LatestSequence(v.Db, sequencesTable, viewName)
+	currentSequence, err := repository.LatestSequence(v.Db, sequencesTable, viewName, "")
 	if err != nil {
 		return err
 	}
@@ -26,5 +28,8 @@ func (v *View) updateSpoolerRunSequence(viewName string) error {
 		currentSequence.ViewName = viewName
 	}
 	currentSequence.LastSuccessfulSpoolerRun = time.Now()
+	//update all aggregate types
+	//TODO: not sure if all scenarios work as expected
+	currentSequence.AggregateType = ""
 	return repository.UpdateCurrentSequence(v.Db, sequencesTable, currentSequence)
 }
--- a/internal/management/repository/eventsourcing/view/user.go
+++ b/internal/management/repository/eventsourcing/view/user.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	usr_model "github.com/caos/zitadel/internal/user/model"
 	"github.com/caos/zitadel/internal/user/repository/view"
 	"github.com/caos/zitadel/internal/user/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -40,39 +40,39 @@ func (v *View) UserMFAs(userID string) ([]*usr_model.MultiFactor, error) {
 	return view.UserMFAs(v.Db, userTable, userID)
 }

-func (v *View) PutUsers(user []*model.UserView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutUsers(user []*model.UserView, event *models.Event) error {
 	err := view.PutUsers(v.Db, userTable, user...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedUserSequence(sequence, eventTimestamp)
+	return v.ProcessedUserSequence(event)
 }

-func (v *View) PutUser(user *model.UserView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutUser(user *model.UserView, event *models.Event) error {
 	err := view.PutUser(v.Db, userTable, user)
 	if err != nil {
 		return err
 	}
-	if sequence != 0 {
-		return v.ProcessedUserSequence(sequence, eventTimestamp)
+	if event.Sequence != 0 {
+		return v.ProcessedUserSequence(event)
 	}
 	return nil
 }

-func (v *View) DeleteUser(userID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteUser(userID string, event *models.Event) error {
 	err := view.DeleteUser(v.Db, userTable, userID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedUserSequence(eventSequence, eventTimestamp)
+	return v.ProcessedUserSequence(event)
 }

-func (v *View) GetLatestUserSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(userTable)
+func (v *View) GetLatestUserSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(userTable, aggregateType)
 }

-func (v *View) ProcessedUserSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(userTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedUserSequence(event *models.Event) error {
+	return v.saveCurrentSequence(userTable, event)
 }

 func (v *View) UpdateUserSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/user_grant.go
+++ b/internal/management/repository/eventsourcing/view/user_grant.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	grant_model "github.com/caos/zitadel/internal/usergrant/model"
 	"github.com/caos/zitadel/internal/usergrant/repository/view"
 	"github.com/caos/zitadel/internal/usergrant/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -40,36 +40,36 @@ func (v *View) UserGrantsByOrgIDAndProjectID(orgID, projectID string) ([]*model.
 	return view.UserGrantsByOrgIDAndProjectID(v.Db, userGrantTable, orgID, projectID)
 }

-func (v *View) PutUserGrant(grant *model.UserGrantView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutUserGrant(grant *model.UserGrantView, event *models.Event) error {
 	err := view.PutUserGrant(v.Db, userGrantTable, grant)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedUserGrantSequence(sequence, eventTimestamp)
+	return v.ProcessedUserGrantSequence(event)
 }

-func (v *View) PutUserGrants(grants []*model.UserGrantView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutUserGrants(grants []*model.UserGrantView, event *models.Event) error {
 	err := view.PutUserGrants(v.Db, userGrantTable, grants...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedUserGrantSequence(sequence, eventTimestamp)
+	return v.ProcessedUserGrantSequence(event)
 }

-func (v *View) DeleteUserGrant(grantID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteUserGrant(grantID string, event *models.Event) error {
 	err := view.DeleteUserGrant(v.Db, userGrantTable, grantID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedUserGrantSequence(eventSequence, eventTimestamp)
+	return v.ProcessedUserGrantSequence(event)
 }

-func (v *View) GetLatestUserGrantSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(userGrantTable)
+func (v *View) GetLatestUserGrantSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(userGrantTable, aggregateType)
 }

-func (v *View) ProcessedUserGrantSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(userGrantTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedUserGrantSequence(event *models.Event) error {
+	return v.saveCurrentSequence(userGrantTable, event)
 }

 func (v *View) UpdateUserGrantSpoolerRunTimestamp() error {
--- a/internal/management/repository/eventsourcing/view/user_membership.go
+++ b/internal/management/repository/eventsourcing/view/user_membership.go
@@ -1,11 +1,11 @@
 package view

 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	usr_model "github.com/caos/zitadel/internal/user/model"
 	"github.com/caos/zitadel/internal/user/repository/view"
 	"github.com/caos/zitadel/internal/user/repository/view/model"
 	"github.com/caos/zitadel/internal/view/repository"
-	"time"
 )

 const (
@@ -24,60 +24,60 @@ func (v *View) SearchUserMemberships(request *usr_model.UserMembershipSearchRequ
 	return view.SearchUserMemberships(v.Db, userMembershipTable, request)
 }

-func (v *View) PutUserMembership(membership *model.UserMembershipView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) PutUserMembership(membership *model.UserMembershipView, event *models.Event) error {
 	err := view.PutUserMembership(v.Db, userMembershipTable, membership)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedUserMembershipSequence(sequence, eventTimestamp)
+	return v.ProcessedUserMembershipSequence(event)
 }

-func (v *View) BulkPutUserMemberships(memberships []*model.UserMembershipView, sequence uint64, eventTimestamp time.Time) error {
+func (v *View) BulkPutUserMemberships(memberships []*model.UserMembershipView, event *models.Event) error {
 	err := view.PutUserMemberships(v.Db, userMembershipTable, memberships...)
 	if err != nil {
 		return err
 	}
-	return v.ProcessedUserMembershipSequence(sequence, eventTimestamp)
+	return v.ProcessedUserMembershipSequence(event)
 }

-func (v *View) DeleteUserMembership(userID, aggregateID, objectID string, memberType usr_model.MemberType, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteUserMembership(userID, aggregateID, objectID string, memberType usr_model.MemberType, event *models.Event) error {
 	err := view.DeleteUserMembership(v.Db, userMembershipTable, userID, aggregateID, objectID, memberType)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedUserMembershipSequence(eventSequence, eventTimestamp)
+	return v.ProcessedUserMembershipSequence(event)
 }

-func (v *View) DeleteUserMembershipsByUserID(userID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteUserMembershipsByUserID(userID string, event *models.Event) error {
 	err := view.DeleteUserMembershipsByUserID(v.Db, userMembershipTable, userID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedUserMembershipSequence(eventSequence, eventTimestamp)
+	return v.ProcessedUserMembershipSequence(event)
 }

-func (v *View) DeleteUserMembershipsByAggregateID(aggregateID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteUserMembershipsByAggregateID(aggregateID string, event *models.Event) error {
 	err := view.DeleteUserMembershipsByAggregateID(v.Db, userMembershipTable, aggregateID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedUserMembershipSequence(eventSequence, eventTimestamp)
+	return v.ProcessedUserMembershipSequence(event)
 }

-func (v *View) DeleteUserMembershipsByAggregateIDAndObjectID(aggregateID, objectID string, eventSequence uint64, eventTimestamp time.Time) error {
+func (v *View) DeleteUserMembershipsByAggregateIDAndObjectID(aggregateID, objectID string, event *models.Event) error {
 	err := view.DeleteUserMembershipsByAggregateIDAndObjectID(v.Db, userMembershipTable, aggregateID, objectID)
 	if err != nil {
 		return nil
 	}
-	return v.ProcessedUserMembershipSequence(eventSequence, eventTimestamp)
+	return v.ProcessedUserMembershipSequence(event)
 }

-func (v *View) GetLatestUserMembershipSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(userMembershipTable)
+func (v *View) GetLatestUserMembershipSequence(aggregateType string) (*repository.CurrentSequence, error) {
+	return v.latestSequence(userMembershipTable, aggregateType)
 }

-func (v *View) ProcessedUserMembershipSequence(eventSequence uint64, eventTimestamp time.Time) error {
-	return v.saveCurrentSequence(userMembershipTable, eventSequence, eventTimestamp)
+func (v *View) ProcessedUserMembershipSequence(event *models.Event) error {
+	return v.saveCurrentSequence(userMembershipTable, event)
 }

 func (v *View) UpdateUserMembershipSpoolerRunTimestamp() error {