diff --git a/backend/v3/storage/database/repository/instance_test.go b/backend/v3/storage/database/repository/instance_test.go
index 2bf4d29c25..107cc81002 100644
--- a/backend/v3/storage/database/repository/instance_test.go
+++ b/backend/v3/storage/database/repository/instance_test.go
@@ -221,35 +221,67 @@ func TestUpdateInstance(t *testing.T) {
 }
 
 func TestGetInstance(t *testing.T) {
-	tests := []struct {
+	instanceRepo := repository.InstanceRepository(pool)
+	type test struct {
 		name               string
 		testFunc           func() *domain.Instance
+		conditionClauses   []database.Condition
 		noInstanceReturned bool
-	}{
-		{
-			name: "happy path",
-			testFunc: func() *domain.Instance {
-				instanceRepo := repository.InstanceRepository(pool)
-				instanceId := gofakeit.Name()
-				instanceName := gofakeit.Name()
+	}
 
-				ctx := context.Background()
-				inst := domain.Instance{
-					ID:              instanceId,
-					Name:            instanceName,
-					DefaultOrgID:    "defaultOrgId",
-					IAMProjectID:    "iamProject",
-					ConsoleClientID: "consoleCLient",
-					ConsoleAppID:    "consoleApp",
-					DefaultLanguage: "defaultLanguage",
-				}
+	tests := []test{
+		func() test {
+			instanceId := gofakeit.Name()
+			return test{
+				name: "happy path get using id",
+				testFunc: func() *domain.Instance {
+					instanceName := gofakeit.Name()
 
-				// create instance
-				err := instanceRepo.Create(ctx, &inst)
-				assert.NoError(t, err)
-				return &inst
-			},
-		},
+					ctx := context.Background()
+					inst := domain.Instance{
+						ID:              instanceId,
+						Name:            instanceName,
+						DefaultOrgID:    "defaultOrgId",
+						IAMProjectID:    "iamProject",
+						ConsoleClientID: "consoleCLient",
+						ConsoleAppID:    "consoleApp",
+						DefaultLanguage: "defaultLanguage",
+					}
+
+					// create instance
+					err := instanceRepo.Create(ctx, &inst)
+					assert.NoError(t, err)
+					return &inst
+				},
+				conditionClauses: []database.Condition{instanceRepo.IDCondition(instanceId)},
+			}
+		}(),
+		func() test {
+			instanceName := gofakeit.Name()
+			return test{
+				name: "happy path get using name",
+				testFunc: func() *domain.Instance {
+					instanceId := gofakeit.Name()
+
+					ctx := context.Background()
+					inst := domain.Instance{
+						ID:              instanceId,
+						Name:            instanceName,
+						DefaultOrgID:    "defaultOrgId",
+						IAMProjectID:    "iamProject",
+						ConsoleClientID: "consoleCLient",
+						ConsoleAppID:    "consoleApp",
+						DefaultLanguage: "defaultLanguage",
+					}
+
+					// create instance
+					err := instanceRepo.Create(ctx, &inst)
+					assert.NoError(t, err)
+					return &inst
+				},
+				conditionClauses: []database.Condition{instanceRepo.NameCondition(database.TextOperationEqual, instanceName)},
+			}
+		}(),
 		{
 			name: "get non existent instance",
 			testFunc: func() *domain.Instance {
@@ -260,6 +292,7 @@ func TestGetInstance(t *testing.T) {
 				}
 				return &inst
 			},
+			conditionClauses:   []database.Condition{instanceRepo.NameCondition(database.TextOperationEqual, "non-existent-instance-name")},
 			noInstanceReturned: true,
 		},
 	}
@@ -275,7 +308,7 @@ func TestGetInstance(t *testing.T) {
 
 			// check instance values
 			returnedInstance, err := instanceRepo.Get(ctx,
-				instanceRepo.IDCondition(instance.ID),
+				tt.conditionClauses...,
 			)
 			assert.NoError(t, err)
 			if tt.noInstanceReturned {
@@ -304,9 +337,10 @@ func TestListInstance(t *testing.T) {
 	}
 	tests := []test{
 		{
-			name: "happy path single instance",
+			name: "happy path single instance no filter",
 			testFunc: func() ([]*domain.Instance, database.PoolTest, func()) {
 				ctx := context.Background()
+				// create new db to make sure no instances exist
 				pool, stop, err := newEmbeededDB()
 				assert.NoError(t, err)
 
@@ -339,9 +373,10 @@ func TestListInstance(t *testing.T) {
 			},
 		},
 		{
-			name: "happy path multiple instance",
+			name: "happy path multiple instance no filter",
 			testFunc: func() ([]*domain.Instance, database.PoolTest, func()) {
 				ctx := context.Background()
+				// create new db to make sure no instances exist
 				pool, stop, err := newEmbeededDB()
 				assert.NoError(t, err)
 
@@ -496,11 +531,45 @@ func TestDeleteInstance(t *testing.T) {
 		conditionClauses database.Condition
 	}
 	tests := []test{
+		func() test {
+			instanceRepo := repository.InstanceRepository(pool)
+			instanceId := gofakeit.Name()
+			return test{
+				name: "happy path delete single instance filter id",
+				testFunc: func() {
+					ctx := context.Background()
+
+					noOfInstances := 1
+					instances := make([]*domain.Instance, noOfInstances)
+					for i := range noOfInstances {
+
+						instanceName := gofakeit.Name()
+
+						inst := domain.Instance{
+							ID:              instanceId,
+							Name:            instanceName,
+							DefaultOrgID:    "defaultOrgId",
+							IAMProjectID:    "iamProject",
+							ConsoleClientID: "consoleCLient",
+							ConsoleAppID:    "consoleApp",
+							DefaultLanguage: "defaultLanguage",
+						}
+
+						// create instance
+						err := instanceRepo.Create(ctx, &inst)
+						assert.NoError(t, err)
+
+						instances[i] = &inst
+					}
+				},
+				conditionClauses: instanceRepo.IDCondition(instanceId),
+			}
+		}(),
 		func() test {
 			instanceRepo := repository.InstanceRepository(pool)
 			instanceName := gofakeit.Name()
 			return test{
-				name: "happy path delete single instance",
+				name: "happy path delete single instance filter name",
 				testFunc: func() {
 					ctx := context.Background()
 
diff --git a/backend/v3/storage/database/repository/user_test.go b/backend/v3/storage/database/repository/user_test.go
index b25cdfd220..3355af2416 100644
--- a/backend/v3/storage/database/repository/user_test.go
+++ b/backend/v3/storage/database/repository/user_test.go
@@ -1,77 +1,77 @@
 package repository_test
 
-import (
-	"context"
-	"testing"
+// import (
+// 	"context"
+// 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"go.uber.org/mock/gomock"
+// 	"github.com/stretchr/testify/assert"
+// 	"go.uber.org/mock/gomock"
 
-	"github.com/zitadel/zitadel/backend/v3/storage/database"
-	"github.com/zitadel/zitadel/backend/v3/storage/database/dbmock"
-	"github.com/zitadel/zitadel/backend/v3/storage/database/repository"
-)
+// 	"github.com/zitadel/zitadel/backend/v3/storage/database"
+// 	"github.com/zitadel/zitadel/backend/v3/storage/database/dbmock"
+// 	"github.com/zitadel/zitadel/backend/v3/storage/database/repository"
+// )
 
-func TestQueryUser(t *testing.T) {
-	t.Skip("tests are meant as examples and are not real tests")
-	t.Run("User filters", func(t *testing.T) {
-		client := dbmock.NewMockClient(gomock.NewController(t))
+// func TestQueryUser(t *testing.T) {
+// 	t.Skip("tests are meant as examples and are not real tests")
+// 	t.Run("User filters", func(t *testing.T) {
+// 		client := dbmock.NewMockClient(gomock.NewController(t))
 
-		user := repository.UserRepository(client)
-		u, err := user.Get(context.Background(),
-			database.WithCondition(
-				database.And(
-					database.Or(
-						user.IDCondition("test"),
-						user.IDCondition("2"),
-					),
-					user.UsernameCondition(database.TextOperationStartsWithIgnoreCase, "test"),
-				),
-			),
-			database.WithOrderBy(user.CreatedAtColumn()),
-		)
+// 		user := repository.UserRepository(client)
+// 		u, err := user.Get(context.Background(),
+// 			database.WithCondition(
+// 				database.And(
+// 					database.Or(
+// 						user.IDCondition("test"),
+// 						user.IDCondition("2"),
+// 					),
+// 					user.UsernameCondition(database.TextOperationStartsWithIgnoreCase, "test"),
+// 				),
+// 			),
+// 			database.WithOrderBy(user.CreatedAtColumn()),
+// 		)
 
-		assert.NoError(t, err)
-		assert.NotNil(t, u)
-	})
+// 		assert.NoError(t, err)
+// 		assert.NotNil(t, u)
+// 	})
 
-	t.Run("machine and human filters", func(t *testing.T) {
-		client := dbmock.NewMockClient(gomock.NewController(t))
+// 	t.Run("machine and human filters", func(t *testing.T) {
+// 		client := dbmock.NewMockClient(gomock.NewController(t))
 
-		user := repository.UserRepository(client)
-		machine := user.Machine()
-		human := user.Human()
-		email, err := human.GetEmail(context.Background(), database.And(
-			user.UsernameCondition(database.TextOperationStartsWithIgnoreCase, "test"),
-			database.Or(
-				machine.DescriptionCondition(database.TextOperationStartsWithIgnoreCase, "test"),
-				human.EmailVerifiedCondition(true),
-				database.IsNotNull(machine.DescriptionColumn()),
-			),
-		))
+// 		user := repository.UserRepository(client)
+// 		machine := user.Machine()
+// 		human := user.Human()
+// 		email, err := human.GetEmail(context.Background(), database.And(
+// 			user.UsernameCondition(database.TextOperationStartsWithIgnoreCase, "test"),
+// 			database.Or(
+// 				machine.DescriptionCondition(database.TextOperationStartsWithIgnoreCase, "test"),
+// 				human.EmailVerifiedCondition(true),
+// 				database.IsNotNull(machine.DescriptionColumn()),
+// 			),
+// 		))
 
-		assert.NoError(t, err)
-		assert.NotNil(t, email)
-	})
-}
+// 		assert.NoError(t, err)
+// 		assert.NotNil(t, email)
+// 	})
+// }
 
-type dbInstruction string
+// type dbInstruction string
 
-func TestArg(t *testing.T) {
-	var bla any = "asdf"
-	instr, ok := bla.(dbInstruction)
-	assert.False(t, ok)
-	assert.Empty(t, instr)
-	bla = dbInstruction("asdf")
-	instr, ok = bla.(dbInstruction)
-	assert.True(t, ok)
-	assert.Equal(t, instr, dbInstruction("asdf"))
-}
+// func TestArg(t *testing.T) {
+// 	var bla any = "asdf"
+// 	instr, ok := bla.(dbInstruction)
+// 	assert.False(t, ok)
+// 	assert.Empty(t, instr)
+// 	bla = dbInstruction("asdf")
+// 	instr, ok = bla.(dbInstruction)
+// 	assert.True(t, ok)
+// 	assert.Equal(t, instr, dbInstruction("asdf"))
+// }
 
-func TestWriteUser(t *testing.T) {
-	t.Skip("tests are meant as examples and are not real tests")
-	t.Run("update user", func(t *testing.T) {
-		user := repository.UserRepository(nil)
-		user.Human().Update(context.Background(), user.IDCondition("test"), user.SetUsername("test"))
-	})
-}
+// func TestWriteUser(t *testing.T) {
+// 	t.Skip("tests are meant as examples and are not real tests")
+// 	t.Run("update user", func(t *testing.T) {
+// 		user := repository.UserRepository(nil)
+// 		user.Human().Update(context.Background(), user.IDCondition("test"), user.SetUsername("test"))
+// 	})
+// }