diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 086c8443..112c86d6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -51,6 +51,10 @@ The application is built using the following primary technologies:
   - [MikroORM](https://mikro-orm.io/)
 - [Docker](https://www.docker.com/)
 
+## Data model
+
+
+
 ## Application Architecture
 
 The application is a [monolith](https://martinfowler.com/bliki/MonolithFirst.html) following a layered architecture. The application is split into the following layers:
diff --git a/application/AppUserInteractor.ts b/application/AppUserInteractor.ts
new file mode 100644
index 00000000..b8717333
--- /dev/null
+++ b/application/AppUserInteractor.ts
@@ -0,0 +1,69 @@
+import type { AppUserRepository } from "~/server/data/repositories/AppUserRepository";
+import { Interactor } from "./Interactor";
+import type { AppUser } from "~/domain/application";
+
+/**
+ * Interactor for the AppUser
+ */
+export class AppUserInteractor extends Interactor<AppUser> {
+    /**
+     * Create a new AppUserInteractor
+     * @param props.userId - The id of the accessing user whose permissions are being checked
+     * @param props.repository - The repository for the AppUser
+     */
+    constructor(props: {
+        // TODO: This should be Repository<AppUser>
+        repository: AppUserRepository,
+        userId: AppUser['id']
+    }) {
+        super({ repository: props.repository, userId: props.userId })
+    }
+
+    protected async _isSystemAdmin(): Promise<boolean> {
+        const currentUser = await this.getAppUserById(this._userId)
+        return currentUser.isSystemAdmin
+    }
+
+    // TODO: This should not be necessary
+    get repository(): AppUserRepository {
+        return this._repository as AppUserRepository
+    }
+
+    /**
+     * Get the app user by id
+     * @param id - The id of the app user
+     * @returns The app user
+     * @throws {Error} If the user does not exist
+     */
+    async getAppUserById(id: AppUser['id']): Promise<AppUser> {
+        return this.repository.getUserById(id)
+    }
+
+    /**
+     * Get the organization ids associated with the app user
+     * @param id - The id of the app user
+     * @returns The organization ids associated with the app user
+     * @throws {Error} If the user does not exist
+     * @throws {Error} If the current user is not a system admin or the user being queried is not the current user
+     */
+    async getUserOrganizationIds(id: AppUser['id']): Promise<AppUser['id'][]> {
+        if (!(await this.repository.hasUser(id)))
+            throw new Error(`User with id ${id} does not exist`)
+        if (id !== this._userId && !this._isSystemAdmin())
+            throw new Error(`User with id ${this._userId} does not have permission to get organization ids for user with id ${id}`)
+
+        return this.repository.getUserOrganizationIds(id)
+    }
+
+    /**
+     * Check if the requested user exists
+     * @param id - The id of the user
+     * @returns Whether the user exists
+     * @throws {Error} If the current user is not a system admin or the user being queried is not the current user
+     */
+    async hasUser(id: AppUser['id']): Promise<boolean> {
+        if (id !== this._userId && !this._isSystemAdmin())
+            throw new Error(`User with id ${this._userId} does not have permission to check if user with id ${id} exists`)
+        return this.repository.hasUser(id)
+    }
+}
\ No newline at end of file
diff --git a/application/Interactor.ts b/application/Interactor.ts
new file mode 100644
index 00000000..de8cae0b
--- /dev/null
+++ b/application/Interactor.ts
@@ -0,0 +1,29 @@
+import type { AppUser } from "~/domain/application"
+import type { Requirement } from "~/domain/requirements"
+import type { Repository } from "~/server/data/repositories/Repository"
+
+/**
+ * An Interactor is a class that contains the business logic for a collection of related use cases
+ * It has the Single Responsibility (SRP) of interacting with a particular entity.
+ * @see https://softwareengineering.stackexchange.com/a/364727/420292
+ */
+// TODO: E should be a type that extends Entity | ValueObject
+// Though more accurately, should be a type that implements Equatable
+export abstract class Interactor<E> {
+    protected readonly _repository
+    protected readonly _userId
+
+    /**
+     * Create a new Interactor
+     *
+     * @param props.repository - The repository to use
+     * @param props.userId - The id of the user to utilize
+     */
+    constructor(props: {
+        repository: Repository<E>,
+        userId: AppUser['id']
+    }) {
+        this._repository = props.repository
+        this._userId = props.userId
+    }
+}
\ No newline at end of file
diff --git a/application/Mapper.ts b/application/Mapper.ts
deleted file mode 100644
index f3e4f34b..00000000
--- a/application/Mapper.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export default abstract class Mapper<Source, Target> {
-    abstract mapTo(source: Source): Target;
-    abstract mapFrom(target: Target): Source;
-}
\ No newline at end of file
diff --git a/application/OrganizationInteractor.ts b/application/OrganizationInteractor.ts
index 15e362e8..793689c7 100644
--- a/application/OrganizationInteractor.ts
+++ b/application/OrganizationInteractor.ts
@@ -1,72 +1,76 @@
-import { Assumption, Constraint, Effect, EnvironmentComponent, FunctionalBehavior, GlossaryTerm, Invariant, Justification, Limit, MoscowPriority, NonFunctionalBehavior, Obstacle, Organization, Outcome, ParsedRequirement, Person, ReqType, Requirement, Solution, Stakeholder, StakeholderCategory, StakeholderSegmentation, SystemComponent, UseCase, UserStory } from "~/domain/requirements";
-import { Collection, QueryOrder, type ChangeSetType, type EntityManager } from "@mikro-orm/core";
-import { AppUserOrganizationRole, AppRole, AppUser, AuditLog } from "~/domain/application";
-import { validate } from 'uuid'
+import * as req from "~/domain/requirements";
+import { AppUserOrganizationRole, AppRole, AppUser } from "~/domain/application";
 import type NaturalLanguageToRequirementService from "~/server/data/services/NaturalLanguageToRequirementService";
-import { groupBy, slugify } from "#shared/utils";
+import { groupBy } from "#shared/utils";
 import { Belongs, Follows } from "~/domain/relations";
-
-type OrganizationInteractorConstructor = {
-    entityManager: EntityManager,
-    userId: AppUser['id'],
-    organizationId?: Organization['id'],
-    organizationSlug?: Organization['slug']
-}
+import type { OrganizationRepository } from "~/server/data/repositories/OrganizationRepository";
+import { validate as validateUuid } from 'uuid'
+import type { AuditMetadata } from "~/domain/AuditMetadata";
+import { Interactor } from "./Interactor";
 
 /**
  * The OrganizationInteractor class contains the business logic for interacting with an organization.
- *
- * An Interactor is a class that contains the business logic of an application.
- * It has the Single Responsibility (SRP) of interacting with a particular entity.
- * @see https://softwareengineering.stackexchange.com/a/364727/420292
  */
-export class OrganizationInteractor {
-    private readonly _entityManager: EntityManager
-    private readonly _user: Promise<AppUser>
-    /** This is not readonly because it can be reassigned in {@link #deleteOrganization} */
-    private _organization?: Promise<Organization>
-
+export class OrganizationInteractor extends Interactor<req.Organization> {
     /**
      * Create a new OrganizationInteractor
      *
-     * @param props.entityManager - The entity manager to use
+     * @param props.repository - The repository to use
      * @param props.userId - The id of the user to utilize
-     * @param [props.organizationId] - The id of the organization to utilize
-     * @param [props.organizationSlug] - The slug of the organization to utilize
      */
-    constructor(props: OrganizationInteractorConstructor) {
-        this._entityManager = props.entityManager
-
-        const em = this.getEntityManager(),
-            { userId, organizationId, organizationSlug } = props
-
-        this._user = em.findOneOrFail(AppUser, userId)
-        this._organization = organizationId ? em.findOneOrFail(Organization, organizationId) :
-            organizationSlug ? em.findOneOrFail(Organization, { slug: organizationSlug }) :
-                undefined
+    constructor(props: {
+        // TODO: This should be Repository<Organization>
+        repository: OrganizationRepository,
+        userId: AppUser['id']
+    }) { super(props) }
+
+    // FIXME: this shouldn't be necessary
+    get repository(): OrganizationRepository {
+        return this._repository as OrganizationRepository
     }
 
     /**
-     * Gets the next requirement id for the given solution and requirement type
+     * Add an appuser to the organization with a role
      *
-     * @param prefix - The prefix for the requirement id. Ex: 'P.1.'
+     * @param props.appUserId The id of the app user to invite
+     * @param props.role The role to assign to the app user
+     * @throws {Error} If the user is not an admin of the organization
+     * @throws {Error} If the organization does not exist
+     * @throws {Error} If the target app user does not exist
+     * @throws {Error} If the target app user is already associated with the organization
      */
-    private async _getNextReqId<R extends typeof Requirement>(solution: Solution, prefix: R['reqIdPrefix']): Promise<InstanceType<R>['reqId']> {
-        const entityCount = await solution.contains.loadCount({
-            where: { reqId: { $like: `${prefix}%` } }
-        });
+    async addAppUserOrganizationRole(props: Pick<AppUserOrganizationRole, 'appUserId' | 'organizationId' | 'role'>): Promise<void> {
+        if (!await this.isOrganizationAdmin())
+            throw new Error('Forbidden: You do not have permission to perform this action')
 
-        return `${prefix}${entityCount + 1}`
+        this.repository.addAppUserOrganizationRole({
+            createdById: this._userId,
+            effectiveDate: new Date(),
+            ...props
+        })
     }
 
     /**
-     * Create a new entity manager fork
+     * Creates a new organization in the database and sets the creator as an admin
      *
-     * @returns The entity manager
+     * @param props.name The name of the organization
+     * @param props.description The description of the organization
+     * @returns The new organization id
      */
-    // TODO: this will likely be moved into a Repository class in the future
-    getEntityManager(): EntityManager {
-        return this._entityManager.fork();
+    async addOrganization(props: Pick<req.Organization, 'name' | 'description'>): Promise<req.Organization['id']> {
+        const repo = this.repository,
+            effectiveDate = new Date(),
+            newOrgId = await repo.addOrganization({ ...props, createdById: this._userId, effectiveDate })
+
+        await repo.addAppUserOrganizationRole({
+            effectiveDate,
+            appUserId: this._userId,
+            organizationId: newOrgId,
+            role: AppRole.ORGANIZATION_ADMIN,
+            createdById: this._userId
+        })
+
+        return newOrgId
     }
 
     /**
@@ -82,49 +86,99 @@ export class OrganizationInteractor {
      * @throws {Error} If the user is not a contributor of the solution or better
      * @throws {Error} If a referenced requirement does not belong to the solution
      */
-    async addRequirement<RCons extends typeof Requirement>({
+    async addRequirement<RCons extends typeof req.Requirement>({
         solutionId, ReqClass, reqProps
     }: {
-        solutionId: Solution['id'],
+        solutionId: req.Solution['id'],
         ReqClass: RCons,
-        reqProps: Omit<ConstructorParameters<RCons>[0], 'reqId' | 'lastModified' | 'modifiedBy' | 'createdBy'>
-    }): Promise<InstanceType<RCons>> {
+        reqProps: Omit<InstanceType<RCons>, 'reqId' | 'id' | keyof AuditMetadata>
+    }): Promise<req.Requirement['id']> {
         if (!this.isOrganizationContributor())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const solution = await this.getSolutionById(solutionId)
+        await this._assertReferenceRequirementsBelongToSolution({ solutionId, reqProps })
 
-        if (!solution)
-            throw new Error('Not Found: The solution does not exist.')
+        return await this.repository.addRequirement({
+            solutionId,
+            ReqClass,
+            reqProps,
+            createdById: this._userId,
+            effectiveDate: new Date()
+        })
+    }
 
-        const em = this.getEntityManager(),
-            appUser = await this._user,
-            // If the entity is silent, do not assign a reqId
-            reqId = reqProps.isSilence ? undefined :
-                await this._getNextReqId(solution, ReqClass.reqIdPrefix);
+    /**
+     * Add a solution to an organization
+     *
+     * @param props The properties of the solution
+     * @returns The new solution
+     * @throws {Error} If the user is not an admin of the organization
+     * @throws {Error} If the organization does not exist
+     */
+    async addSolution({ name, description }: Pick<req.Solution, 'name' | 'description'>): Promise<req.Solution['id']> {
+        const repo = this.repository,
+            effectiveDate = new Date()
 
-        // if a property is a uuid, assert that it belongs to the solution
-        for (const [key, value] of Object.entries(reqProps) as [keyof typeof reqProps, string][]) {
-            if (validate(value) && !['id', 'createdBy', 'modifiedBy'].includes(key as string)) {
-                const reqExists = await solution.contains.loadCount({ where: { id: value } })
-                if (reqExists === 0)
-                    throw new Error(`Not Found: The referenced requirement with id ${value} does not exist in the solution.`)
-            }
-        }
+        if (!await this.isOrganizationAdmin())
+            throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const newRequirement = em.create(ReqClass, {
-            ...reqProps,
-            reqId,
-            lastModified: new Date(),
-            createdBy: appUser,
-            modifiedBy: appUser
-        }) as InstanceType<RCons>
+        const newSolutionId = await repo.addSolution({ name, description, effectiveDate, createdById: this._userId })
 
-        em.create(Belongs, { left: newRequirement, right: solution })
+        // create initial requirements for the solution
+        await this.addRequirement({
+            solutionId: newSolutionId,
+            ReqClass: req.Outcome,
+            reqProps: { name: 'G.1', description: 'Context and Objective', isSilence: false }
+        })
 
-        await em.flush()
+        await this.addRequirement({
+            solutionId: newSolutionId,
+            ReqClass: req.Obstacle,
+            reqProps: { name: 'G.2', description: 'Situation', isSilence: false }
+        })
 
-        return newRequirement
+        return newSolutionId
+    }
+
+    /**
+     * Delete an app user from the current organization
+     *
+     * @param id The id of the app user to delete
+     * @throws {Error} If the user is not an admin of the organization unless the user is deleting themselves
+     * @throws {Error} If the user is deleting the last admin of the organization
+     * @throws {Error} If the target app user does not exist
+     */
+    async deleteAppUser(id: AppUser['id']): Promise<unknown> {
+        if (!this.isOrganizationAdmin() && id !== this._userId)
+            throw new Error('Forbidden: You do not have permission to perform this action')
+
+        const targetUser = await this.getAppUserById(id),
+            orgAdminCount = (await this.repository.findAppUserOrganizationRoles({
+                role: AppRole.ORGANIZATION_ADMIN
+            })).length
+
+        if (targetUser.role === AppRole.ORGANIZATION_ADMIN && orgAdminCount === 1)
+            throw new Error('Forbidden: You cannot delete the last organization admin.')
+
+        return this.repository.deleteAppUserOrganizationRole({
+            appUserId: id,
+            deletedById: this._userId,
+            deletedDate: new Date(),
+            organizationId: (await this.getOrganization()).id
+        })
+    }
+
+    /**
+     * Delete the organization
+     *
+     * @throws {Error} If the user is not an admin of the organization or better
+     * @throws {Error} If the organization does not exist
+     */
+    async deleteOrganization(): Promise<void> {
+        if (!await this.isOrganizationAdmin())
+            throw new Error('Forbidden: You do not have permission to perform this action')
+
+        return this.repository.deleteOrganization({ deletedById: this._userId, deletedDate: new Date() })
     }
 
     /**
@@ -138,65 +192,43 @@ export class OrganizationInteractor {
      * @throws {Error} If the requirement does not exist
      * @throws {Error} If the requirement does not belong to the solution
      */
-    async deleteRequirement<RCons extends typeof Requirement>(props: {
+    async deleteRequirement<RCons extends typeof req.Requirement>(props: {
         id: InstanceType<RCons>['id'],
-        solutionId: Solution['id'],
+        solutionId: req.Solution['id'],
         ReqClass: RCons
     }): Promise<void> {
         if (!this.isOrganizationContributor())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const em = this.getEntityManager(),
-            solution = await this.getSolutionById(props.solutionId),
-            requirement = (await solution.contains.loadItems<Requirement>({
-                where: { id: props.id, req_type: props.ReqClass.req_type }
-            }))[0]
-
-        if (!requirement)
-            throw new Error('Not Found: The requirement does not exist.')
-
-        // remove all relationships to the requirement
-        const conn = this.getEntityManager().getConnection()
-        await conn.execute(`
-            DELETE
-            FROM requirement_relation
-            WHERE left_id = ? OR right_id = ?;
-        `, [requirement.id, requirement.id])
+        await this.repository.deleteSolutionRequirementById({
+            deletedById: this._userId,
+            deletedDate: new Date(),
+            ReqClass: props.ReqClass,
+            id: props.id,
+            solutionId: props.solutionId
+        })
 
         // TODO: decrement the reqId of all requirements that have a reqId greater than the deleted requirement
-
-        await em.removeAndFlush(requirement)
+        // see https://github.com/final-hill/cathedral/issues/475
     }
 
     /**
-     * Get a requirement by id from the specified solution
+     * Delete a solution by slug from an organization
      *
-     * @param props.solutionId The id of the solution that the requirement belongs to
-     * @param props.ReqClass The Constructor of the requirement to get
-     * @param props.id The id of the requirement to get
-     * @returns The requirement
+     * @param slug The id of the solution to delete
+     * @throws {Error} If the user is not an admin of the organization
      * @throws {Error} If the solution does not exist
-     * @throws {Error} If the user is not a reader of the organization or better
-     * @throws {Error} If the requirement does not exist
-     * @throws {Error} If the requirement does not belong to the solution
+     * @throws {Error} If the solution does not belong to the organization
      */
-    async getRequirementById<RCons extends typeof Requirement>(props: {
-        solutionId: Solution['id'],
-        ReqClass: RCons,
-        id: InstanceType<RCons>['id']
-    }): Promise<InstanceType<RCons>> {
-        if (!this.isOrganizationReader())
+    async deleteSolutionBySlug(slug: req.Solution['slug']): Promise<void> {
+        if (!await this.isOrganizationAdmin())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const solution = await this.getSolutionById(props.solutionId),
-            requirement = (await solution.contains.loadItems<Requirement>({
-                where: { id: props.id, req_type: props.ReqClass.req_type }
-            }))[0] as InstanceType<RCons>
-
-        if (!requirement)
-            throw new Error('Not Found: The requirement does not exist.')
-
-        return requirement
+        return this.repository.deleteSolutionBySlug({
+            deletedById: this._userId,
+            deletedDate: new Date(),
+            slug
+        })
     }
 
     /**
@@ -208,105 +240,30 @@ export class OrganizationInteractor {
      * @returns The requirements that match the query parameters
      * @throws {Error} If the user is not a reader of the organization or better
      */
-    async findRequirements<RCons extends typeof Requirement>(props: {
-        solutionId: Solution['id'],
+    async findSolutionRequirements<RCons extends typeof req.Requirement>(props: {
+        solutionId: req.Solution['id'],
         ReqClass: RCons,
         query: Partial<InstanceType<RCons>>
     }): Promise<InstanceType<RCons>[]> {
         if (!this.isOrganizationReader())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const solution = await this.getSolutionById(props.solutionId),
-            requirements = (await solution.contains.loadItems<InstanceType<RCons>>({
-                where: {
-                    req_type: props.ReqClass.req_type,
-                    ...props.query
-                }
-            })) as InstanceType<RCons>[]
-
-        return requirements
-    }
-
-    // TODO: allow the re-ordering of requirements in a solution (reqIds)
-
-    /**
-     * Update a requirement by id for a solution with the given properties
-     *
-     * @param props.id The id of the requirement to update
-     * @param props.solutionId The id of the solution that the requirement belongs to
-     * @param props.ReqClass The Constructor of the requirement to update
-     * @param props.reqProps The properties to update
-     * @throws {Error} If the user is not a contributor of the organization or better
-     * @throws {Error} If the requirement does not exist
-     * @throws {Error} If the solution does not exist
-     * @throws {Error} If the requirement is not owned by the solution
-     * @throws {Error} If a referenced requirement does not belong to the solution
-     */
-    async updateRequirement<RCons extends typeof Requirement>(props: {
-        id: InstanceType<RCons>['id'],
-        solutionId: Solution['id'],
-        ReqClass: RCons,
-        reqProps: Partial<Omit<InstanceType<RCons>, 'reqId' | 'lastModified' | 'modifiedBy' | 'createdBy'>>
-    }): Promise<void> {
-        if (!this.isOrganizationContributor())
-            throw new Error('Forbidden: You do not have permission to perform this action')
-
-        const em = this.getEntityManager(),
-            solution = await this.getSolutionById(props.solutionId),
-            requirement = (await solution.contains.loadItems<Requirement>({
-                where: { id: props.id, req_type: props.ReqClass.req_type }
-            }))[0] as InstanceType<RCons>
-
-        if (!requirement)
-            throw new Error('Not Found: The requirement does not exist.')
-
-        // if a property is a uuid, assert that it belongs to the solution
-        requirement.assign({
-            ...props.reqProps,
-            lastModified: new Date(),
-            modifiedBy: await this._user
-        } as any) // FIXME: TypeScript (v5.6.3) does not infer the proper type here
-
-        // If the entity is no longer silent and has no reqId, assume
-        // that it is a new requirement from the workbox and assign a new reqId
-        if (props.reqProps.isSilence !== undefined && props.reqProps.isSilence == false && !requirement.reqId)
-            requirement.reqId = await this._getNextReqId(solution, props.ReqClass.reqIdPrefix)
-
-        await em.persistAndFlush(requirement)
+        return this.repository.findSolutionRequirementsByType(props)
     }
 
     /**
-     * Invite an appuser to an organization with a role
+     * Find solutions that match the query parameters for an organization
      *
-     * @param props.email The email of the app user to invite
-     * @param props.role The role to assign to the app user
-     * @throws {Error} If the user is not an admin of the organization
+     * @param query The query parameters to filter solutions by
+     * @returns The solutions that match the query parameters
+     * @throws {Error} If the user is not a reader of the organization or better
      * @throws {Error} If the organization does not exist
-     * @throws {Error} If the target app user does not exist
-     * @throws {Error} If the target app user is already associated with the organization
      */
-    async addAppUserToOrganization({ email, role }: { email: string, role: AppRole }): Promise<void> {
-        if (!await this.isOrganizationAdmin())
+    async findSolutions(query: Partial<req.Solution> = {}): Promise<req.Solution[]> {
+        if (!await this.isOrganizationReader())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const em = this.getEntityManager(),
-            appUser = await em.findOne(AppUser, { email }),
-            organization = await this.getOrganization()
-
-        if (!appUser)
-            throw new Error('Not Found: The app user with the given email does not exist.')
-
-        const existingOrgAppUserRole = await em.findOne(AppUserOrganizationRole, {
-            appUser,
-            organization
-        })
-
-        if (existingOrgAppUserRole)
-            throw new Error('Conflict: The app user is already associated with the organization.')
-
-        em.create(AppUserOrganizationRole, { appUser, organization, role })
-
-        await em.flush()
+        return this.repository.findSolutions(query)
     }
 
     /**
@@ -319,139 +276,102 @@ export class OrganizationInteractor {
      * @throws {Error} If the user is trying to get an app user that is not in the same organization
      */
     async getAppUserById(id: AppUser['id']): Promise<AppUser> {
-        const organization = await this.getOrganization(),
-            em = this.getEntityManager(),
-            { appUser, role } = (await em.findOneOrFail(AppUserOrganizationRole, {
-                appUser: id,
-                organization
-            }, { populate: ['appUser'] }))
-
-        appUser.role = role
-
-        if (!appUser)
-            throw new Error('Not Found: AppUser not found for the given ID.')
-
         if (!this.isOrganizationReader())
             throw new Error('Forbidden: You do not have permission to perform this action')
-
-        return appUser
+        return this.repository.getOrganizationAppUserById(id)
     }
 
     /**
-     * Delete an app user from an organization
+     * Returns the organization that the user is associated with
      *
-     * @throws {Error} If the user is not an admin of the organization unless the user is deleting themselves
-     * @throws {Error} If the user is deleting the last admin of the organization
+     * @returns The organization
+     * @throws {Error} If the organization does not exist
      */
-    async deleteAppUser(id: AppUser['id']): Promise<unknown> {
-        const em = this.getEntityManager(),
-            organization = await this.getOrganization(),
-            appUser = await this._user,
-            [targetAppUserRole, orgAdminCount] = await Promise.all([
-                em.findOne(AppUserOrganizationRole, {
-                    appUser: id,
-                    organization
-                }, { populate: ['appUser'] }),
-                em.count(AppUserOrganizationRole, {
-                    organization,
-                    role: AppRole.ORGANIZATION_ADMIN
-                })
-            ])
-
-        if (!targetAppUserRole)
-            throw new Error('Not Found: AppUser not found for the given ID and organization.')
-
-        if (targetAppUserRole.role === AppRole.ORGANIZATION_ADMIN && orgAdminCount === 1)
-            throw new Error('Forbidden: You cannot delete the last organization admin.')
-
-        if (!this.isOrganizationAdmin() && targetAppUserRole.appUser.id !== appUser.id)
+    async getOrganization(): Promise<req.Organization> {
+        if (!this.isOrganizationReader())
             throw new Error('Forbidden: You do not have permission to perform this action')
-
-        return await em.removeAndFlush(targetAppUserRole)
+        return this.repository.getOrganization()
     }
 
     /**
-     * Update an app user by id in a given organization to have a new role
+     * Get all app users for the organization with their associated roles
      *
-     * @param id The id of the app user to update
-     * @param role The new role to assign to the app user
-     * @throws {Error} If the user is not an admin of the organization
-     * @throws {Error} If the app user does not exist
-     * @throws {Error} If the app user is not in the same organization
-     * @throws {Error} If the app user is the last admin of the organization and the new role is not an admin
-     * @throws {Error} If the app user is trying to update themselves to a role that is not an admin
+     * @returns The app users with their associated roles
+     * @throws {Error} If the user is not a reader of the organization or better
      */
-    async updateAppUserRole(id: AppUser['id'], role: AppRole): Promise<void> {
-        const em = this.getEntityManager(),
-            organization = await this.getOrganization(),
-            appUser = await this._user,
-            [targetAppUserRole, orgAdminCount] = await Promise.all([
-                em.findOne(AppUserOrganizationRole, {
-                    appUser: id,
-                    organization
-                }, { populate: ['appUser'] }),
-                em.count(AppUserOrganizationRole, {
-                    organization,
-                    role: AppRole.ORGANIZATION_ADMIN
-                })
-            ])
-
-        if (!targetAppUserRole)
-            throw new Error('Not Found: AppUser not found for the given ID and organization.')
+    async getOrganizationAppUsers(): Promise<AppUser[]> {
+        if (!this.isOrganizationReader())
+            throw new Error('Forbidden: You do not have permission to perform this action')
 
-        if (targetAppUserRole.role === AppRole.ORGANIZATION_ADMIN && orgAdminCount === 1
-            && role !== AppRole.ORGANIZATION_ADMIN)
-            throw new Error('Forbidden: You cannot remove the last organization admin.')
+        return this.repository.getOrganizationAppUsers()
+    }
 
-        if (!this.isOrganizationAdmin() && targetAppUserRole.appUser.id !== appUser.id)
+    /**
+     * Get a solution by id
+     *
+     * @param solutionId The id of the solution to get
+     * @returns The solution
+     * @throws {Error} If the user is not a reader of the organization or better
+     * @throws {Error} If the solution does not exist
+     * @throws {Error} If the solution does not belong to the organization
+     */
+    async getSolutionById(solutionId: req.Solution['id']): Promise<req.Solution> {
+        if (!await this.isOrganizationReader())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        if (targetAppUserRole.appUser.id === appUser.id && role !== AppRole.ORGANIZATION_ADMIN)
-            throw new Error('Forbidden: You cannot remove your own admin role.')
+        return this.repository.getSolutionById(solutionId)
+    }
 
-        targetAppUserRole.role = role
+    /**
+     * Get a solution by slug
+     *
+     * @param slug The slug of the solution to get
+     * @returns The solution
+     * @throws {Error} If the user is not a reader of the organization or better
+     * @throws {Error} If the solution does not exist
+     * @throws {Error} If the solution does not belong to the organization
+     */
+    async getSolutionBySlug(slug: req.Solution['slug']): Promise<req.Solution> {
+        if (!await this.isOrganizationReader())
+            throw new Error('Forbidden: You do not have permission to perform this action')
 
-        await em.persistAndFlush(targetAppUserRole)
+        return this.repository.getSolutionBySlug(slug)
     }
 
     /**
-     * Get all app users for the organization with their associated roles
+     * Get a requirement by id
      *
-     * @returns The app users with their associated roles
+     * @param props.ReqClass The Constructor of the requirement to get
+     * @param props.id The id of the requirement to get
+     * @param props.solutionId The id of the solution that the requirement belongs to
+     * @returns The requirement
      * @throws {Error} If the user is not a reader of the organization or better
+     * @throws {Error} If the requirement does not exist in the organization nor the solution
      */
-    async getOrganizationAppUsers(): Promise<AppUser[]> {
+    async getSolutionRequirementById<RCons extends typeof req.Requirement>(props: {
+        ReqClass: RCons,
+        solutionId: req.Solution['id'],
+        id: InstanceType<RCons>['id']
+    }): Promise<InstanceType<RCons>> {
         if (!this.isOrganizationReader())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const em = this.getEntityManager(),
-            organization = await this.getOrganization(),
-            appUserOrganizationRoles = await em.findAll(AppUserOrganizationRole, {
-                where: { organization },
-                populate: ['appUser']
-            })
-
-        // assign the roles to the appusers
-        const appUsersWithRoles: AppUser[] = appUserOrganizationRoles.map((aur) => {
-            const appUser = aur.appUser as AppUser
-            appUser.role = aur.role
-            return appUser
+        return await this.repository.getSolutionRequirementById({
+            ReqClass: props.ReqClass,
+            solutionId: props.solutionId,
+            id: props.id
         })
-
-        return appUsersWithRoles
     }
 
     /**
      * Check if the current user is an admin of the organization or a system admin
      */
     async isOrganizationAdmin(): Promise<boolean> {
-        const appUser = await this._user,
-            organization = await this.getOrganization()
+        const appUser = await this.repository.getOrganizationAppUserById(this._userId)
 
         if (appUser.isSystemAdmin) return true
 
-        const em = this.getEntityManager(),
-            auor = await em.findOne(AppUserOrganizationRole, { appUser, organization }),
+        const auor = await this.repository.getAppUserOrganizationRole(appUser.id),
             isOrgAdmin = auor?.role ?
                 [AppRole.ORGANIZATION_ADMIN].includes(auor.role)
                 : false
@@ -463,13 +383,11 @@ export class OrganizationInteractor {
      * Check if the current user is a contributor of the organization or a system admin
      */
     async isOrganizationContributor(): Promise<boolean> {
-        const appUser = await this._user,
-            organization = await this.getOrganization()
+        const appUser = await this.repository.getOrganizationAppUserById(this._userId)
 
         if (appUser.isSystemAdmin) return true
 
-        const em = this.getEntityManager(),
-            auor = await em.findOne(AppUserOrganizationRole, { appUser, organization }),
+        const auor = await this.repository.getAppUserOrganizationRole(appUser.id),
             isOrgContributor = auor?.role ?
                 [AppRole.ORGANIZATION_ADMIN, AppRole.ORGANIZATION_CONTRIBUTOR].includes(auor.role)
                 : false
@@ -481,13 +399,11 @@ export class OrganizationInteractor {
      * Check if the current user is a reader of the organization or a system admin
      */
     async isOrganizationReader(): Promise<boolean> {
-        const organization = await this.getOrganization(),
-            appUser = await this._user
+        const appUser = await this.repository.getOrganizationAppUserById(this._userId)
 
         if (appUser.isSystemAdmin) return true
 
-        const em = this.getEntityManager(),
-            auor = await em.findOne(AppUserOrganizationRole, { appUser, organization }),
+        const auor = await this.repository.getAppUserOrganizationRole(appUser.id),
             isOrgReader = auor?.role ?
                 [AppRole.ORGANIZATION_ADMIN, AppRole.ORGANIZATION_CONTRIBUTOR, AppRole.ORGANIZATION_READER].includes(auor.role)
                 : false
@@ -496,174 +412,108 @@ export class OrganizationInteractor {
     }
 
     /**
-     * Creates a new organization in the database and sets the creator as an admin
-     *
-     * @param props The properties of the organization
-     * @returns The new organization
-     */
-    async addOrganization(props: Pick<Organization, 'name' | 'description'>): Promise<Organization> {
-        const em = this.getEntityManager(),
-            appUser = await this._user,
-            newOrganization = em.create(Organization, {
-                name: props.name,
-                description: props.description,
-                createdBy: appUser,
-                modifiedBy: appUser,
-                lastModified: new Date(),
-                isSilence: false,
-                reqId: undefined
-            })
-
-        em.create(AppUserOrganizationRole, {
-            appUser: await this._user,
-            organization: newOrganization,
-            role: AppRole.ORGANIZATION_ADMIN
-        })
-
-        await em.flush()
-
-        return newOrganization
-    }
-
-    /**
-     * Add a solution to an organization
+     * Update a target user by id in a given organization to have a new role
      *
-     * @param props The properties of the solution
-     * @returns The new solution
-     * @throws {Error} If the user is not an admin of the organization
-     * @throws {Error} If the organization does not exist
+     * @param id The id of the target user to update
+     * @param role The new role to assign to the target user
+     * @throws {Error} If the current user is not an admin of the organization
+     * @throws {Error} If the target user does not exist
+     * @throws {Error} If the target user is not in the same organization
+     * @throws {Error} If the target user is the last admin of the organization and the new role is not an admin
+     * @throws {Error} If the target user is trying to update themselves
      */
-    async addSolution({ name, description }: Pick<Solution, 'name' | 'description'>): Promise<Solution> {
-        const organization = await this.getOrganization(),
-            createdBy = await this._user
-
-        if (!await this.isOrganizationAdmin())
+    async updateAppUserRole(id: AppUser['id'], role: AppRole): Promise<void> {
+        if (!this.isOrganizationAdmin())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const em = this.getEntityManager(),
-            newSolution = em.create(Solution, {
-                name,
-                description,
-                lastModified: new Date(),
-                createdBy,
-                modifiedBy: createdBy,
-                isSilence: false
-            });
+        const targetUser = await this.getAppUserById(id)
 
-        em.create(Belongs, { left: newSolution, right: organization })
+        if (targetUser.id === this._userId)
+            throw new Error('Forbidden: You cannot update your own role.')
 
-        await em.flush()
-
-        await this.addRequirement({
-            solutionId: newSolution.id,
-            ReqClass: Outcome,
-            reqProps: { name: 'G.1', description: 'Context and Objective', isSilence: false } as ConstructorParameters<typeof Outcome>[0]
-        })
+        if (targetUser.role === AppRole.ORGANIZATION_ADMIN && role !== AppRole.ORGANIZATION_ADMIN)
+            throw new Error('Forbidden: You cannot remove the last organization admin.')
 
-        await this.addRequirement({
-            solutionId: newSolution.id,
-            ReqClass: Obstacle,
-            reqProps: { name: 'G.2', description: 'Situation', isSilence: false } as ConstructorParameters<typeof Obstacle>[0]
+        await this.repository.updateAppUserRole({
+            appUserId: id,
+            role,
+            modifiedById: this._userId,
+            modifiedDate: new Date
         })
-
-        return newSolution
     }
 
     /**
-     * Find solutions that match the query parameters for an organization
+     * Update the organization with the given properties.
      *
-     * @param query The query parameters to filter solutions by
-     * @returns The solutions that match the query parameters
-     * @throws {Error} If the user is not a reader of the organization or better
+     * @param props The properties to update
+     * @throws {Error} If the user is not a contributor of the organization or better
      * @throws {Error} If the organization does not exist
      */
-    async findSolutions(query: Partial<Solution> = {}): Promise<Solution[]> {
-        const organization = await this.getOrganization()
-
-        if (!await this.isOrganizationReader())
+    async updateOrganization(props: Pick<Partial<req.Organization>, 'name' | 'description'>): Promise<void> {
+        if (!this.isOrganizationContributor())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const solutions = await organization.contains.loadItems<Solution>({
-            where: {
-                // remove null entries from the query
-                ...Object.entries(query).reduce((acc, [key, value]) => {
-                    if (value !== null && value !== undefined) acc[key] = value
-                    return acc
-                }, {} as Record<string, any>),
-                req_type: ReqType.SOLUTION
-            }
+        await this.repository.updateOrganization({
+            modifiedById: this._userId,
+            modifiedDate: new Date(),
+            ...props
         })
-
-        return solutions
     }
 
     /**
-     * Get a solution by id
-     *
-     * @param solutionId The id of the solution to get
-     * @returns The solution
-     * @throws {Error} If the user is not a reader of the organization or better
-     * @throws {Error} If the solution does not exist
-     * @throws {Error} If the solution does not belong to the organization
+     * Assert that all requirement references (uuid properties) belong to the same solution.
+     * This is to prevent a requirement from another solution being added to the current solution.
+     * This is a security measure to prevent unauthorized access to requirements
      */
-    async getSolutionById(solutionId: Solution['id']): Promise<Solution> {
-        if (!await this.isOrganizationReader())
-            throw new Error('Forbidden: You do not have permission to perform this action')
-
-        const organization = await this.getOrganization(),
-            solution = (await organization.contains.loadItems<Solution>({
-                where: { id: solutionId, req_type: ReqType.SOLUTION }
-            }))[0]
-
-        if (!solution)
-            throw new Error('Not Found: The solution does not exist.')
-
-        return solution
-    }
-
-    /**
-     * Get a solution by slug
-     *
-     * @param slug The slug of the solution to get
-     * @returns The solution
-     * @throws {Error} If the user is not a reader of the organization or better
-     * @throws {Error} If the solution does not exist
-     * @throws {Error} If the solution does not belong to the organization
-     */
-    async getSolutionBySlug(slug: Solution['slug']): Promise<Solution> {
-        if (!await this.isOrganizationReader())
-            throw new Error('Forbidden: You do not have permission to perform this action')
-
-        const organization = await this.getOrganization(),
-            solution = (await organization.contains.loadItems<Solution>({
-                where: { slug, req_type: ReqType.SOLUTION }
-            }))[0]
-
-        if (!solution)
-            throw new Error('Not Found: The solution does not exist.')
-
-        return solution
+    private async _assertReferenceRequirementsBelongToSolution(props: {
+        solutionId: req.Solution['id'],
+        reqProps: Partial<Omit<req.Requirement, 'reqId' | keyof AuditMetadata>>
+    }) {
+        for (const [_, value] of Object.entries(props.reqProps) as [keyof typeof props.reqProps, string][]) {
+            if (validateUuid(value)) {
+                const solHasReq = await this.repository.solutionHasRequirement({ id: value, solutionId: props.solutionId })
+
+                if (!solHasReq)
+                    throw new Error(`Requirement with id ${value} does not belong to the solution`)
+            }
+        }
     }
 
     /**
-     * Delete a solution by slug from an organization
+     * Update a requirement by id for a solution with the given properties
      *
-     * @param slug The id of the solution to delete
-     * @throws {Error} If the user is not an admin of the organization
+     * @param props.id The id of the requirement to update
+     * @param props.solutionId The id of the solution that the requirement belongs to
+     * @param props.ReqClass The Constructor of the requirement to update
+     * @param props.reqProps The properties to update
+     * @throws {Error} If the user is not a contributor of the organization or better
+     * @throws {Error} If the requirement does not exist
      * @throws {Error} If the solution does not exist
-     * @throws {Error} If the solution does not belong to the organization
+     * @throws {Error} If the requirement is not owned by the solution
+     * @throws {Error} If a referenced requirement does not belong to the solution
      */
-    async deleteSolutionBySlug(slug: Solution['slug']): Promise<void> {
-        if (!await this.isOrganizationAdmin())
+    async updateSolutionRequirement<RCons extends typeof req.Requirement>(props: {
+        id: InstanceType<RCons>['id'],
+        solutionId: req.Solution['id'],
+        ReqClass: RCons,
+        reqProps: Partial<Omit<InstanceType<RCons>, 'id' | 'reqId' | keyof AuditMetadata>>
+    }): Promise<void> {
+        if (!this.isOrganizationContributor())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const em = this.getEntityManager(),
-            solution = await this.getSolutionBySlug(slug)
-
-        if (!solution)
-            throw new Error('Not Found: The solution does not exist.')
+        await this._assertReferenceRequirementsBelongToSolution({
+            solutionId: props.solutionId,
+            reqProps: props.reqProps
+        })
 
-        await em.removeAndFlush(solution)
+        await this.repository.updateSolutionRequirement({
+            modifiedById: this._userId,
+            modifiedDate: new Date(),
+            ReqClass: props.ReqClass,
+            requirementId: props.id,
+            solutionId: props.solutionId,
+            reqProps: props.reqProps
+        })
     }
 
     /**
@@ -675,193 +525,17 @@ export class OrganizationInteractor {
      * @throws {Error} If the solution does not exist
      * @throws {Error} If the solution does not belong to the organization
      */
-    async updateSolutionBySlug(slug: Solution['slug'], props: Pick<Partial<Solution>, 'name' | 'description'>): Promise<void> {
-        if (!await this.isOrganizationContributor())
-            throw new Error('Forbidden: You do not have permission to perform this action')
-
-        const em = this.getEntityManager(),
-            solution = await this.getSolutionBySlug(slug)
-
-        if (!solution)
-            throw new Error('Not Found: The solution does not exist.')
-
-        solution.assign({
-            name: props.name ?? solution.name,
-            slug: props.name ? slugify(props.name) : solution.slug,
-            description: props.description ?? solution.description,
-            modifiedBy: await this._user,
-            lastModified: new Date()
-        })
-
-        await em.persistAndFlush(solution)
-    }
-
-    /**
-     * Get all organizations that the current user is associated with filtered by the query parameters
-     *
-     * @param query The query parameters to filter organizations by
-     */
-    async getUserOrganizations(query: Partial<Organization> = {}): Promise<Organization[]> {
-        const em = this.getEntityManager(),
-            appUser = await this._user
-
-        // If the user is a system admin, return all organizations
-        // filtered by the query parameters
-        if (appUser.isSystemAdmin) {
-            return em.findAll(Organization, {
-                where: Object.entries(query).reduce((acc, [key, value]) => {
-                    if (value) acc[key] = value
-                    return acc
-                }, {} as Record<string, any>)
-            })
-        }
-
-        // If the user is not a system admin, return only organizations
-        // that the user is associated with filtered by the query parameters
-        return (await em.findAll(AppUserOrganizationRole, {
-            where: {
-                appUser,
-                organization: Object.entries(query).reduce((acc, [key, value]) => {
-                    if (value) acc[key] = value
-                    return acc
-                }, {} as Record<string, any>)
-            },
-            populate: ['organization']
-        })).map((auor) => auor.organization)
-    }
-
-    /**
-     * Returns the organization that the user is associated with
-     *
-     * @returns The organization
-     * @throws {Error} If the organization does not exist
-     */
-    async getOrganization(): Promise<Organization> {
-        if (!this._organization)
-            throw new Error('Not Found: The organization does not exist.')
-        return await this._organization
-    }
-
-    /**
-     * Delete the organization
-     *
-     * @throws {Error} If the user is not an admin of the organization or better
-     * @throws {Error} If the organization does not exist
-     */
-    async deleteOrganization(): Promise<void> {
-        const em = this.getEntityManager(),
-            organization = await this.getOrganization()
-
-        if (!await this.isOrganizationAdmin())
-            throw new Error('Forbidden: You do not have permission to perform this action')
-
-        // Remove all roles associated with the organization
-        const appUserOrganizationRoles = await em.findAll(AppUserOrganizationRole, {
-            where: { organization }
-        })
-
-        for (const auor of appUserOrganizationRoles)
-            em.remove(auor)
-
-        await em.removeAndFlush(organization)
-
-        this._organization = undefined
-    }
-
-    /**
-     * Update the organization with the given properties.
-     *
-     * @param props The properties to update
-     * @throws {Error} If the user is not a contributor of the organization or better
-     * @throws {Error} If the organization does not exist
-     */
-    async updateOrganization(props: Pick<Partial<Organization>, 'name' | 'description'>): Promise<void> {
-        const em = this.getEntityManager(),
-            organization = await this.getOrganization()
-
+    async updateSolutionBySlug(slug: req.Solution['slug'], props: Pick<Partial<req.Solution>, 'name' | 'description'>): Promise<void> {
         if (!await this.isOrganizationContributor())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        organization.assign({
-            name: props.name ?? organization.name,
-            description: props.description ?? organization.description,
-            slug: props.name ? slugify(props.name) : organization.slug,
-            modifiedBy: await this._user,
-            lastModified: new Date()
-        })
-
-        await em.persistAndFlush(organization)
-    }
-
-    /**
-     * Get the audit log history for a specific entity
-     *
-     * @param entityId The id of the entity to get the audit log history for
-     * @returns The audit log history
-     * @throws {Error} If the user is not a reader of the organization or better
-     */
-    async getAuditLogHistory(entityId: Requirement['id']): Promise<AuditLog[]> {
-        if (!await this.isOrganizationReader())
-            throw new Error('Forbidden: You do not have permission to perform this action')
-
-        // FIXME: check the that the AuditLog entity belongs to the organization
-        // This is probably not necessary since the Audit Log is going away:
-        // https://github.com/final-hill/cathedral/issues/435
-
-        const em = this.getEntityManager()
-
-        return await em.findAll(AuditLog, {
-            where: { entityId },
-            orderBy: { createdAt: QueryOrder.DESC }
+        await this.repository.updateSolutionBySlug(slug, {
+            modifiedById: this._userId,
+            modifiedDate: new Date(),
+            ...props
         })
     }
 
-    /**
-     * Returns from the audit history all the deleted entities
-     * ordered by the date and time when they were deleted in descending order.
-     *
-     * @param entityName The name of the entity to get the audit log delete history for
-     * @returns The audit log delete history
-     * @throws {Error} If the user is not a reader of the organization or better
-     */
-    async getAuditLogDeleteHistory(entityName: string): Promise<unknown> {
-        type RowType = {
-            id: string,
-            type: ChangeSetType,
-            created_at: string,
-            entity_id: string,
-            entity_name: string,
-            entity: string
-        }
-
-        const conn = this.getEntityManager().getConnection(),
-            res: RowType[] = await conn.execute(`
-                SELECT d.id, d.type, d.created_at, a.entity_id, a.entity_name, a.entity
-                FROM audit_log AS d
-                JOIN audit_log AS a
-                    ON a.entity_id = d.entity_id
-                    AND a.created_at = (
-                        SELECT MAX(a2.created_at)
-                        FROM audit_log AS a2
-                        WHERE a2.entity_id = d.entity_id
-                        AND a2.type IN ('create', 'update')
-                        AND a2.created_at < d.created_at
-                    )
-                WHERE d.type = 'delete'
-                AND a.entity_name = ?;
-        `, [entityName]),
-            auditLogs = res.map((row) => new AuditLog({
-                id: row.id,
-                createdAt: new Date(row.created_at),
-                type: row.type,
-                entityId: row.entity_id,
-                entityName: row.entity_name,
-                entity: row.entity
-            }))
-
-        return auditLogs
-    }
-
     /**
      * Get all unapproved (isSilence) requirements that follow from the specified ParsedRequirement for a Solution
      * @param props.solutionId The id of the solution that the requirement belongs to
@@ -871,17 +545,18 @@ export class OrganizationInteractor {
      * @throws {Error} If the ParsedRequirement does not exist
      * @throws {Error} If the ParsedRequirement does not belong to the solution
      */
-    async getFollowingParsedSilenceRequirements({ solutionId, id }: { solutionId: Solution['id'], id: Requirement['id'] }): Promise<Partial<Record<ReqType, Requirement[]>>> {
+    // TODO: refactor to use the repository
+    async getFollowingParsedSilenceRequirements({ solutionId, id }: { solutionId: req.Solution['id'], id: req.Requirement['id'] }): Promise<Partial<Record<ReqType, Requirement[]>>> {
         if (!this.isOrganizationReader())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const parsedRequirement = await this.getRequirementById({ solutionId, ReqClass: ParsedRequirement, id })
+        const parsedRequirement = await this.getSolutionRequirementById({ solutionId, ReqClass: ParsedRequirement, id })
 
         if (!parsedRequirement)
             throw new Error('Not Found: The ParsedRequirement does not exist.')
 
         // Get all unapproved requirements that follow from the specified ParsedRequirement
-        const requirements = await parsedRequirement.followedBy.loadItems<Requirement>({
+        const requirements = await parsedRequirement.followedByIds.loadItems<Requirement>({
             where: { isSilence: true }
         })
 
@@ -899,8 +574,9 @@ export class OrganizationInteractor {
      * @throws {Error} If the user is not a contributor of the organization or better
      * @throws {Error} If the Solution does not belong to the organization
      */
+    // TODO: refactor to use the repository
     async parseRequirement({ solutionId, statement, parsingService }: {
-        solutionId: Solution['id'],
+        solutionId: req.Solution['id'],
         statement: string,
         // FIXME: This should no be the explicit service but a generic service
         parsingService: NaturalLanguageToRequirementService
@@ -908,13 +584,13 @@ export class OrganizationInteractor {
         if (!this.isOrganizationContributor())
             throw new Error('Forbidden: You do not have permission to perform this action')
 
-        const appUser = await this._user,
+        const appUser = await this._userId,
             em = this.getEntityManager(),
             solution = await this.getSolutionById(solutionId)
 
         const groupedResult = await parsingService.parse(statement)
 
-        const parsedRequirement = em.create(ParsedRequirement, {
+        const parsedRequirement = em.create(req.ParsedRequirement, {
             name: '{LLM Parsed Requirement}',
             description: statement,
             createdBy: appUser,
@@ -926,7 +602,7 @@ export class OrganizationInteractor {
         em.create(Belongs, { left: parsedRequirement, right: solution })
 
         // FIXME: need a better type than 'any'
-        const addSolReq = (ReqClass: typeof Requirement, props: any) => {
+        const addSolReq = (ReqClass: typeof req.Requirement, props: any) => {
             const req = em.create(ReqClass, {
                 ...props,
                 isSilence: true,
@@ -941,32 +617,32 @@ export class OrganizationInteractor {
         }
 
         // FIXME: need a better type than 'any'
-        const addParsedReq = (ReqClass: typeof Requirement, props: any) => {
+        const addParsedReq = (ReqClass: typeof req.Requirement, props: any) => {
             const req = addSolReq(ReqClass, props)
             em.create(Follows, { left: req, right: parsedRequirement })
 
             return req
         };
 
-        groupedResult.Assumption?.forEach((item) => addParsedReq(Assumption, item));
-        groupedResult.Constraint?.forEach((item) => addParsedReq(Constraint, item));
-        groupedResult.Effect?.forEach((item) => addParsedReq(Effect, item));
-        groupedResult.EnvironmentComponent?.forEach((item) => addParsedReq(EnvironmentComponent, item));
-        groupedResult.FunctionalBehavior?.forEach((item) => addParsedReq(FunctionalBehavior, item));
-        groupedResult.GlossaryTerm?.forEach((item) => addParsedReq(GlossaryTerm, item));
-        groupedResult.Invariant?.forEach((item) => addParsedReq(Invariant, item));
-        groupedResult.Justification?.forEach((item) => addParsedReq(Justification, item));
-        groupedResult.Limit?.forEach((item) => addParsedReq(Limit, item));
-        groupedResult.NonFunctionalBehavior?.forEach((item) => addParsedReq(NonFunctionalBehavior, item));
-        groupedResult.Obstacle?.forEach((item) => addParsedReq(Obstacle, item));
-        groupedResult.Outcome?.forEach((item) => addParsedReq(Outcome, item));
-        groupedResult.Person?.forEach((item) => addParsedReq(Person, item));
-        groupedResult.Stakeholder?.forEach((item) => addParsedReq(Stakeholder, item));
-        groupedResult.SystemComponent?.forEach((item) => addParsedReq(SystemComponent, item));
+        groupedResult.Assumption?.forEach((item) => addParsedReq(req.Assumption, item));
+        groupedResult.Constraint?.forEach((item) => addParsedReq(req.Constraint, item));
+        groupedResult.Effect?.forEach((item) => addParsedReq(req.Effect, item));
+        groupedResult.EnvironmentComponent?.forEach((item) => addParsedReq(req.EnvironmentComponent, item));
+        groupedResult.FunctionalBehavior?.forEach((item) => addParsedReq(req.FunctionalBehavior, item));
+        groupedResult.GlossaryTerm?.forEach((item) => addParsedReq(req.GlossaryTerm, item));
+        groupedResult.Invariant?.forEach((item) => addParsedReq(req.Invariant, item));
+        groupedResult.Justification?.forEach((item) => addParsedReq(req.Justification, item));
+        groupedResult.Limit?.forEach((item) => addParsedReq(req.Limit, item));
+        groupedResult.NonFunctionalBehavior?.forEach((item) => addParsedReq(req.NonFunctionalBehavior, item));
+        groupedResult.Obstacle?.forEach((item) => addParsedReq(req.Obstacle, item));
+        groupedResult.Outcome?.forEach((item) => addParsedReq(req.Outcome, item));
+        groupedResult.Person?.forEach((item) => addParsedReq(req.Person, item));
+        groupedResult.Stakeholder?.forEach((item) => addParsedReq(req.Stakeholder, item));
+        groupedResult.SystemComponent?.forEach((item) => addParsedReq(req.SystemComponent, item));
         groupedResult.UseCase?.forEach((item) => {
-            addParsedReq(UseCase, {
+            addParsedReq(req.UseCase, {
                 extensions: item.extensions,
-                outcome: addSolReq(Outcome, {
+                outcome: addSolReq(req.Outcome, {
                     name: item.name,
                     description: item.outcome
                 }),
@@ -975,47 +651,47 @@ export class OrganizationInteractor {
                 scope: item.scope,
                 name: item.name,
                 description: '',
-                priority: item.moscowPriority as MoscowPriority ?? MoscowPriority.MUST,
+                priority: item.moscowPriority as req.MoscowPriority ?? req.MoscowPriority.MUST,
                 // triggerId: undefined,
-                precondition: addSolReq(Assumption, {
+                precondition: addSolReq(req.Assumption, {
                     name: item.name,
                     description: item.precondition
                 }),
-                successGuarantee: addSolReq(Effect, {
+                successGuarantee: addSolReq(req.Effect, {
                     name: item.name,
                     description: item.successGuarantee
                 }),
-                primaryActor: addSolReq(Stakeholder, {
+                primaryActor: addSolReq(req.Stakeholder, {
                     name: item.primaryActor,
                     availability: 50,
                     influence: 50,
                     description: '',
-                    category: StakeholderCategory.KEY_STAKEHOLDER,
-                    segmentation: StakeholderSegmentation.VENDOR,
+                    category: req.StakeholderCategory.KEY_STAKEHOLDER,
+                    segmentation: req.StakeholderSegmentation.VENDOR,
                 })
             })
         });
         (groupedResult.UserStory ?? []).forEach((item) => {
-            addParsedReq(UserStory, {
-                priority: item.moscowPriority as MoscowPriority ?? MoscowPriority.MUST,
+            addParsedReq(req.UserStory, {
+                priority: item.moscowPriority as req.MoscowPriority ?? req.MoscowPriority.MUST,
                 name: item.name,
                 description: '',
-                functionalBehavior: addSolReq(FunctionalBehavior, {
-                    priority: item.moscowPriority as MoscowPriority ?? MoscowPriority.MUST,
+                functionalBehavior: addSolReq(req.FunctionalBehavior, {
+                    priority: item.moscowPriority as req.MoscowPriority ?? req.MoscowPriority.MUST,
                     name: item.functionalBehavior,
                     description: item.functionalBehavior
                 }),
-                outcome: addSolReq(Outcome, {
+                outcome: addSolReq(req.Outcome, {
                     name: item.outcome,
                     description: item.outcome
                 }),
-                primaryActor: addSolReq(Stakeholder, {
+                primaryActor: addSolReq(req.Stakeholder, {
                     name: item.role,
                     availability: 50,
                     influence: 50,
                     description: '',
-                    category: StakeholderCategory.KEY_STAKEHOLDER,
-                    segmentation: StakeholderSegmentation.VENDOR
+                    category: req.StakeholderCategory.KEY_STAKEHOLDER,
+                    segmentation: req.StakeholderSegmentation.VENDOR
                 })
             })
         });
diff --git a/components/XDataTable.vue b/components/XDataTable.vue
index 2d21571f..d7797ad0 100644
--- a/components/XDataTable.vue
+++ b/components/XDataTable.vue
@@ -3,7 +3,7 @@ import type Dialog from 'primevue/dialog'
 import type DataTable from 'primevue/datatable'
 import { FilterMatchMode } from 'primevue/api';
 import type { AuditLogViewModel } from '#shared/models';
-import { camelCaseToTitle } from '#shared/utils';
+import { camelCaseToTitleCase } from '#shared/utils';
 
 export type RequirementFieldType = { type: 'requirement', options: { id: string, name: string }[] }
 
@@ -186,7 +186,7 @@ const onEditDialogCancel = () => {
             :globalFilterFields="Object.keys(props.datasource?.[0] ?? {})" :loading="props.loading" stripedRows>
             <Column
                 v-for="key of Object.keys(props.viewModel).filter(k => props.viewModel[k as keyof RowType] !== 'hidden')"
-                :key="key" :field="key" :header="camelCaseToTitle(key)" sortable>
+                :key="key" :field="key" :header="camelCaseToTitleCase(key)" sortable>
                 <template #body="{ data, field }">
                     <span v-if="props.viewModel[field as keyof RowType] === 'text'">{{ data[field] }}</span>
                     <span v-else-if="
@@ -229,7 +229,7 @@ const onEditDialogCancel = () => {
             <div class="field grid"
                 v-for="key of Object.keys(props.createModel).filter(k => props.createModel[k as keyof RowType] !== 'hidden')"
                 :key="key" :field="key">
-                <label :for="key" class="col-4">{{ camelCaseToTitle(key) }}</label>
+                <label :for="key" class="col-4">{{ camelCaseToTitleCase(key) }}</label>
 
                 <InputText v-if="props.createModel[key as keyof RowType] === 'text'" :name="key"
                     v-model.trim="createDialogItem[key]" class="col-8" />
@@ -256,7 +256,7 @@ const onEditDialogCancel = () => {
                     (props.createModel[key as keyof RowType] as any).type === 'requirement'
                 " :name="key" class="p-inputtext p-component col-8"
                     v-model.trim="(createDialogItem[key] ?? { id: '' }).id">
-                    <option value="" disabled>Select a {{ camelCaseToTitle(key) }}</option>
+                    <option value="" disabled>Select a {{ camelCaseToTitleCase(key) }}</option>
                     <option v-for="option of (props.createModel[key as keyof RowType] as any).options" :key="option?.id"
                         :value="option?.id">
                         {{ option.name }}
@@ -279,7 +279,7 @@ const onEditDialogCancel = () => {
         <form id="editDialogForm" autocomplete="off" @submit.prevent="onEditDialogSave" @reset="onEditDialogCancel">
             <div class="field grid" v-for="key of Object.keys(props.editModel)" :key="key" :field="key">
                 <label v-if="props.editModel[key as keyof RowType] !== 'hidden'" :for="key" class="col-4">{{
-                    camelCaseToTitle(key) }}</label>
+                    camelCaseToTitleCase(key) }}</label>
 
                 <InputText v-if="props.editModel[key as keyof RowType] === 'text'" :name="key"
                     v-model.trim="editDialogItem[key]" class="col-8" />
@@ -308,7 +308,7 @@ const onEditDialogCancel = () => {
                     (props.editModel[key as keyof RowType] as any).type === 'requirement'
                 " :name="key" class="p-inputtext p-component col-8"
                     v-model.trim="(editDialogItem[key] ?? { id: '' }).id">
-                    <option value="" disabled>Select a {{ camelCaseToTitle(key) }}</option>
+                    <option value="" disabled>Select a {{ camelCaseToTitleCase(key) }}</option>
                     <option v-for="option of (props.editModel[key as keyof RowType] as any).options" :key="option.id"
                         :value="option.id">
                         {{ option.name }}
@@ -331,7 +331,7 @@ const onEditDialogCancel = () => {
             <DataTable ref="recycleBin" :value="recycleItems" dataKey="date" :loading="recycleDialogLoading">
                 <Column field="date" header="Date" sortable />
                 <Column v-for="key of Object.keys(recycleItems?.[0]?.entity ?? {})" :key="key" :field="key"
-                    :header="camelCaseToTitle(key)">
+                    :header="camelCaseToTitleCase(key)">
                     <template #body="{ data, field }">
                         <span v-if="data.entity[field] instanceof Date">{{ data.entity[field].toLocaleString() }}</span>
                         <span v-else-if="typeof data.entity[field] === 'object'">
@@ -363,7 +363,7 @@ const onEditDialogCancel = () => {
         </template>
         <section>
             <div class="field grid" v-for="key of Object.keys(selectedHistoryItem.entity)" :key="key">
-                <label :for="key" class="col-4">{{ camelCaseToTitle(key) }}:</label>
+                <label :for="key" class="col-4">{{ camelCaseToTitleCase(key) }}:</label>
                 <span class="col-8" v-if="selectedHistoryItem.entity[key] instanceof Date">
                     {{ selectedHistoryItem.entity[key].toLocaleString() }}
                 </span>
diff --git a/domain/AuditMetadata.ts b/domain/AuditMetadata.ts
new file mode 100644
index 00000000..03fb997b
--- /dev/null
+++ b/domain/AuditMetadata.ts
@@ -0,0 +1,38 @@
+/**
+ * Represents the metadata of an entity that is used to track the creation and modification of the entity
+ */
+export abstract class AuditMetadata {
+    constructor(props: Pick<AuditMetadata, keyof AuditMetadata>) {
+        this.createdById = props.createdById;
+        this.creationDate = props.creationDate;
+        this.isDeleted = props.isDeleted
+        this.lastModified = props.lastModified;
+        this.modifiedById = props.modifiedById;
+    }
+
+    /**
+     * The user who created the entity
+     */
+    readonly createdById: string;
+
+    /**
+     * The date and time when the entity was created
+     */
+    readonly creationDate: Date
+
+    /**
+     * Whether the entity is deleted
+     */
+    readonly isDeleted: boolean;
+
+    /**
+     * The date and time when the entity was last modified
+     */
+    readonly lastModified: Date;
+
+    /**
+     * The user who last modified the entity
+     */
+    readonly modifiedById: string;
+
+}
\ No newline at end of file
diff --git a/domain/application/AppUser.ts b/domain/application/AppUser.ts
index 74e71a8f..86ff0ab1 100644
--- a/domain/application/AppUser.ts
+++ b/domain/application/AppUser.ts
@@ -1,65 +1,63 @@
-import { BaseEntity, Entity, Enum, Property } from "@mikro-orm/core";
 import { AppRole } from "./AppRole.js";
-import { type Properties } from "../types/index.js";
 
 /**
  * An AppUser is a user of the application
  */
-@Entity()
-export class AppUser extends BaseEntity {
-    constructor(props: Properties<AppUser>) {
-        super()
-        this.id = props.id;
-        this.creationDate = props.creationDate;
-        this.isSystemAdmin = props.isSystemAdmin;
-        this.lastLoginDate = props.lastLoginDate;
-        this.name = props.name;
-        this.email = props.email;
-        this.role = props.role;
+export class AppUser {
+    constructor(props: Pick<AppUser, keyof AppUser>) {
+        Object.assign(this, props);
+
+        // email address: https://stackoverflow.com/a/574698
+        if (props.name.length > 254)
+            throw new Error('Name too long');
+        if (!props.email.match(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/))
+            throw new Error('Invalid email address');
+        if (props.email.length > 254)
+            throw new Error('Email address too long');
     }
 
     /**
      * The unique identifier of the AppUser (uuid)
      */
-    @Property({ type: 'uuid', primary: true })
-    id: string;
+    readonly id!: string;
 
     /**
      * The name of the AppUser
      */
-    @Property({ type: 'string', length: 254 })
-    name: string;
+    readonly name!: string;
+
+    /**
+     * The date and time when the user was last modified
+     */
+    readonly effectiveFrom!: Date;
+
+    /**
+     * Whether the user is deleted
+     */
+    readonly isDeleted!: boolean;
 
     /**
      * The email address of the AppUser
      */
-    // email address: https://stackoverflow.com/a/574698
-    @Property({ type: 'string', length: 254 })
-    email: string;
+    readonly email!: string;
 
     /**
      * The date the AppUser was created
      */
-    @Property({ type: 'datetime' })
-    creationDate: Date;
+    readonly creationDate!: Date;
 
     /**
      * The date the AppUser last logged in
      */
-    @Property({ type: 'datetime', nullable: true })
-    lastLoginDate?: Date;
+    readonly lastLoginDate?: Date;
 
     /**
      * Whether the AppUser is a system administrator
      */
-    @Property({ type: 'boolean' })
-    isSystemAdmin: boolean;
+    readonly isSystemAdmin!: boolean;
 
     /**
      * The role of the AppUser.
      */
-    // FIXME: this field is not mapped in the ORM. It is populated in the API layer.
-    // It's a design smell that needs to be addressed.
-    @Enum({ items: () => AppRole, persist: false })
-    role?: AppRole;
+    readonly role?: AppRole;
 }
\ No newline at end of file
diff --git a/domain/application/AppUserOrganizationRole.ts b/domain/application/AppUserOrganizationRole.ts
index ffa2f23d..4ec1d74a 100644
--- a/domain/application/AppUserOrganizationRole.ts
+++ b/domain/application/AppUserOrganizationRole.ts
@@ -1,36 +1,29 @@
-import { BaseEntity, Entity, Enum, ManyToOne } from "@mikro-orm/core";
+import { AuditMetadata } from "../AuditMetadata.js";
 import { AppRole } from "./AppRole.js";
-import { AppUser } from "./AppUser.js";
-import { type Properties } from "../types/index.js";
-import { Organization } from "../requirements/Organization.js";
 
 /**
  * An AppUserOrganizationRole is a mapping between an AppUser, an Organization, and a Role
  */
-@Entity()
-export class AppUserOrganizationRole extends BaseEntity {
-    constructor(props: Properties<AppUserOrganizationRole>) {
-        super()
-        this.appUser = props.appUser;
-        this.organization = props.organization;
-        this.role = props.role;
+export class AppUserOrganizationRole extends AuditMetadata {
+    constructor({ appUserId, organizationId, role, ...parentProps }: Pick<AppUserOrganizationRole, keyof AppUserOrganizationRole>) {
+        super(parentProps);
+        this.appUserId = appUserId;
+        this.organizationId = organizationId;
+        this.role = role;
     }
 
     /**
      * The user associated with the OrganizationRole
      */
-    @ManyToOne({ primary: true, entity: () => AppUser })
-    appUser: AppUser;
+    readonly appUserId!: string;
 
     /**
      * The Organization associated with the OrganizationRole
      */
-    @ManyToOne({ primary: true, entity: () => Organization })
-    organization: Organization;
+    readonly organizationId!: string;
 
     /**
      * The Role associated with the OrganizationRole
      */
-    @Enum({ items: () => AppRole, primary: true })
-    role: AppRole
+    readonly role!: AppRole
 }
\ No newline at end of file
diff --git a/domain/application/AuditLog.ts b/domain/application/AuditLog.ts
deleted file mode 100644
index cb090a6d..00000000
--- a/domain/application/AuditLog.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { v7 as uuidv7 } from 'uuid';
-import { BaseEntity, ChangeSetType, Entity, Enum, Property } from "@mikro-orm/core";
-import { type Properties } from '../types/index.js';
-
-/**
- * The AuditLog class is responsible for tracking changes to entities in the database.
- */
-@Entity()
-export class AuditLog extends BaseEntity {
-    constructor(props: Properties<Omit<AuditLog, 'id' | 'createdAt'>> & { id?: string, createdAt?: Date }) {
-        super()
-        this.type = props.type;
-        this.entity = props.entity;
-        this.entityId = props.entityId;
-        this.entityName = props.entityName;
-        this.createdAt = props.createdAt || new Date();
-        this.id = props.id || uuidv7();
-    }
-
-    /**
-     * The unique identifier of the AuditLog
-     */
-    @Property({ type: 'uuid', primary: true })
-    id: string
-
-    /**
-     * The unique identifier of the entity that was changed
-     */
-    @Property({ type: 'uuid' })
-    entityId: string
-
-    /**
-     * The name of the entity that was changed
-     */
-    @Property({ type: 'string' })
-    entityName: string
-
-    /**
-     * The type of change that was made
-     */
-    @Enum(() => ChangeSetType)
-    type: ChangeSetType
-
-    /**
-     * The entity that was changed
-     */
-    @Property({ type: 'json' })
-    entity: string
-
-    /**
-     * The date and time when the AuditLog was created
-     */
-    @Property({ type: 'datetime' })
-    createdAt: Date
-}
\ No newline at end of file
diff --git a/domain/application/index.ts b/domain/application/index.ts
index d7083bd9..fa210851 100644
--- a/domain/application/index.ts
+++ b/domain/application/index.ts
@@ -1,4 +1,3 @@
 export * from './AppRole.js';
 export * from './AppUser.js';
-export * from './AppUserOrganizationRole.js';
-export * from './AuditLog.js';
\ No newline at end of file
+export * from './AppUserOrganizationRole.js';
\ No newline at end of file
diff --git a/domain/relations/Belongs.ts b/domain/relations/Belongs.ts
index 6aaee37f..a84b8728 100644
--- a/domain/relations/Belongs.ts
+++ b/domain/relations/Belongs.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 
 /**
@@ -6,5 +5,4 @@ import { RequirementRelation } from "./RequirementRelation.js";
  *
  * X is a sub-requirement of Y; textually included
  */
-@Entity()
 export class Belongs extends RequirementRelation { }
\ No newline at end of file
diff --git a/domain/relations/Characterizes.ts b/domain/relations/Characterizes.ts
index bf0aad0f..40e73bf3 100644
--- a/domain/relations/Characterizes.ts
+++ b/domain/relations/Characterizes.ts
@@ -1,17 +1,13 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 import { MetaRequirement } from "../requirements/MetaRequirement.js";
-import { type Properties } from "../types/index.js";
 
 /**
  * X → Y
  *
  * Meta-requirement X applies to requirement Y
  */
-@Entity()
 export class Characterizes extends RequirementRelation {
-    constructor(props: Properties<Omit<Characterizes, 'id' | 'left'> & { left: MetaRequirement }>) {
+    constructor(props: Omit<Pick<Characterizes, keyof Characterizes>, 'id' | 'left'> & { left: MetaRequirement }) {
         super(props);
-        this.left = props.left;
     }
 }
\ No newline at end of file
diff --git a/domain/relations/Constrains.ts b/domain/relations/Constrains.ts
index 3d1502a6..4ebda8a3 100644
--- a/domain/relations/Constrains.ts
+++ b/domain/relations/Constrains.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 
 /**
@@ -6,5 +5,4 @@ import { RequirementRelation } from "./RequirementRelation.js";
  *
  * Constraint X applies to Y
  */
-@Entity()
 export class Constrains extends RequirementRelation { }
\ No newline at end of file
diff --git a/domain/relations/Contradicts.ts b/domain/relations/Contradicts.ts
index 6f84ebb5..2f7eb251 100644
--- a/domain/relations/Contradicts.ts
+++ b/domain/relations/Contradicts.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 
 /**
@@ -6,5 +5,4 @@ import { RequirementRelation } from "./RequirementRelation.js";
  *
  * Properties specified by X and Y cannot both hold
  */
-@Entity()
 export class Contradicts extends RequirementRelation { }
\ No newline at end of file
diff --git a/domain/relations/Details.ts b/domain/relations/Details.ts
index 06a22bb6..e1776751 100644
--- a/domain/relations/Details.ts
+++ b/domain/relations/Details.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { Extends } from "./Extends.js";
 
 /**
@@ -6,5 +5,4 @@ import { Extends } from "./Extends.js";
  *
  * X adds detail to properties of Y
  */
-@Entity()
 export class Details extends Extends { }
\ No newline at end of file
diff --git a/domain/relations/Disjoins.ts b/domain/relations/Disjoins.ts
index e55cd92f..743089ed 100644
--- a/domain/relations/Disjoins.ts
+++ b/domain/relations/Disjoins.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 
 /**
@@ -6,5 +5,4 @@ import { RequirementRelation } from "./RequirementRelation.js";
  *
  * X and Y are unrelated
  */
-@Entity()
 export class Disjoins extends RequirementRelation { }
\ No newline at end of file
diff --git a/domain/relations/Duplicates.ts b/domain/relations/Duplicates.ts
index 8a869ddb..da54b874 100644
--- a/domain/relations/Duplicates.ts
+++ b/domain/relations/Duplicates.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { Repeats } from "./Repeats.js";
 
 /**
@@ -8,5 +7,4 @@ import { Repeats } from "./Repeats.js";
  * In other words, X and Y are redundant.
  * Same properties, same type (notation-wise, X ≡ Y)
  */
-@Entity()
 export class Duplicates extends Repeats { }
\ No newline at end of file
diff --git a/domain/relations/Excepts.ts b/domain/relations/Excepts.ts
index c0d11fa4..9abc911d 100644
--- a/domain/relations/Excepts.ts
+++ b/domain/relations/Excepts.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 
 /**
@@ -6,5 +5,4 @@ import { RequirementRelation } from "./RequirementRelation.js";
  *
  * X specifies an exception to the property specified by Y.
  */
-@Entity()
 export class Excepts extends RequirementRelation { }
\ No newline at end of file
diff --git a/domain/relations/Explains.ts b/domain/relations/Explains.ts
index 5741111d..1652f09a 100644
--- a/domain/relations/Explains.ts
+++ b/domain/relations/Explains.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { Repeats } from "./Repeats.js";
 
 /**
@@ -8,5 +7,4 @@ import { Repeats } from "./Repeats.js";
  * In other words, Y introduces no new property but helps understand X better.
  * Same properties, different type (notation-wise)
  */
-@Entity()
 export class Explains extends Repeats { }
\ No newline at end of file
diff --git a/domain/relations/Extends.ts b/domain/relations/Extends.ts
index b63c3cbc..709b5449 100644
--- a/domain/relations/Extends.ts
+++ b/domain/relations/Extends.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 
 /**
@@ -8,5 +7,4 @@ import { RequirementRelation } from "./RequirementRelation.js";
  * X assumes Y and specifies a property that Y does not.
  * X adds to properties of Y
  */
-@Entity()
 export class Extends extends RequirementRelation { }
\ No newline at end of file
diff --git a/domain/relations/Follows.ts b/domain/relations/Follows.ts
index e58637e4..d2275ed5 100644
--- a/domain/relations/Follows.ts
+++ b/domain/relations/Follows.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 
 /**
@@ -6,5 +5,4 @@ import { RequirementRelation } from "./RequirementRelation.js";
  *
  * X is a consequence of the property specified by Y
  */
-@Entity()
 export class Follows extends RequirementRelation { }
\ No newline at end of file
diff --git a/domain/relations/Repeats.ts b/domain/relations/Repeats.ts
index f8ca60b8..ccf0a16b 100644
--- a/domain/relations/Repeats.ts
+++ b/domain/relations/Repeats.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { RequirementRelation } from "./RequirementRelation.js";
 
 /**
@@ -6,5 +5,4 @@ import { RequirementRelation } from "./RequirementRelation.js";
  *
  * X specifies the same property as Y
  */
-@Entity()
 export class Repeats extends RequirementRelation { }
\ No newline at end of file
diff --git a/domain/relations/RequirementRelation.ts b/domain/relations/RequirementRelation.ts
index 29a1b821..08b974b3 100644
--- a/domain/relations/RequirementRelation.ts
+++ b/domain/relations/RequirementRelation.ts
@@ -1,26 +1,22 @@
-import { BaseEntity, Entity, ManyToOne } from "@mikro-orm/core";
-import { Requirement } from '../requirements/Requirement.js'
+import { AuditMetadata } from "../AuditMetadata";
 
 /**
  * Relations between requirements
  */
-@Entity({ abstract: true, discriminatorColumn: 'rel_type' })
-export abstract class RequirementRelation extends BaseEntity {
-    constructor({ left, right }: { left: Requirement, right: Requirement }) {
-        super()
-        this.left = left;
-        this.right = right;
+export abstract class RequirementRelation extends AuditMetadata {
+    constructor(props: Pick<RequirementRelation, keyof RequirementRelation>) {
+        super(props)
+        this.leftId = props.leftId
+        this.rightId = props.rightId
     }
 
     /**
      * The left-hand side of the relation
      */
-    @ManyToOne({ primary: true, entity: () => Requirement })
-    left: Requirement
+    readonly leftId: string
 
     /**
      * The right-hand side of the relation
      */
-    @ManyToOne({ primary: true, entity: () => Requirement })
-    right: Requirement
+    readonly rightId: string
 }
\ No newline at end of file
diff --git a/domain/relations/Shares.ts b/domain/relations/Shares.ts
index 6138326b..c32d4e5b 100644
--- a/domain/relations/Shares.ts
+++ b/domain/relations/Shares.ts
@@ -1,4 +1,3 @@
-import { Entity } from "@mikro-orm/core";
 import { Repeats } from "./Repeats.js";
 
 /**
@@ -8,5 +7,4 @@ import { Repeats } from "./Repeats.js";
  * (Involve Repeats).
  * Some subrequirement is in common between X and Y.
  */
-@Entity()
 export class Shares extends Repeats { }
\ No newline at end of file
diff --git a/domain/requirements/Actor.ts b/domain/requirements/Actor.ts
index 51f19f4b..d3464d51 100644
--- a/domain/requirements/Actor.ts
+++ b/domain/requirements/Actor.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A part of a Project, Environment, System, or Goals that may affect or be affected by the associated entities
  */
-@Entity({ discriminatorValue: ReqType.ACTOR })
-export class Actor extends Requirement {
-    static override req_type: ReqType = ReqType.ACTOR;
-}
\ No newline at end of file
+export class Actor extends Requirement { }
\ No newline at end of file
diff --git a/domain/requirements/Assumption.ts b/domain/requirements/Assumption.ts
index bb4f1d1b..d8cdeb16 100644
--- a/domain/requirements/Assumption.ts
+++ b/domain/requirements/Assumption.ts
@@ -1,17 +1,14 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 export type AssumptionReqId = `${typeof Assumption.reqIdPrefix}${number}`;
 
 /**
  * Posited property of the environment
  */
-@Entity({ discriminatorValue: ReqType.ASSUMPTION })
 export class Assumption extends Requirement {
-    static override reqIdPrefix = 'E.4.' as const;
-    static override req_type = ReqType.ASSUMPTION;
+    static override readonly reqIdPrefix = 'E.4.' as const;
 
-    override get reqId() { return super.reqId as `${typeof Assumption.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
+    override get reqId() {
+        return super.reqId as `${typeof Assumption.reqIdPrefix}${number}` | undefined
+    }
 }
\ No newline at end of file
diff --git a/domain/requirements/Behavior.ts b/domain/requirements/Behavior.ts
index fd9feffa..34d83551 100644
--- a/domain/requirements/Behavior.ts
+++ b/domain/requirements/Behavior.ts
@@ -1,15 +1,10 @@
-import { Entity, Enum } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
 import { MoscowPriority } from "./MoscowPriority.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Property of the operation of the system
  */
-@Entity({ discriminatorValue: ReqType.BEHAVIOR })
 export class Behavior extends Requirement {
-    static override req_type: ReqType = ReqType.BEHAVIOR;
-
     constructor({ priority, ...rest }: ConstructorParameters<typeof Requirement>[0] & Pick<Behavior, 'priority'>) {
         super(rest);
         this.priority = priority;
@@ -18,6 +13,5 @@ export class Behavior extends Requirement {
     /**
      * The priority of the behavior.
      */
-    @Enum({ items: () => MoscowPriority })
-    priority: MoscowPriority;
+    readonly priority: MoscowPriority;
 }
\ No newline at end of file
diff --git a/domain/requirements/Component.ts b/domain/requirements/Component.ts
index 0fb24a72..262614ab 100644
--- a/domain/requirements/Component.ts
+++ b/domain/requirements/Component.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Actor } from "./Actor.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Idenfitication of a part (of the Project, Environment, Goals, or System)
  */
-@Entity({ discriminatorValue: ReqType.COMPONENT })
-export class Component extends Actor {
-    static override req_type: ReqType = ReqType.COMPONENT;
-}
+export class Component extends Actor { }
diff --git a/domain/requirements/Constraint.ts b/domain/requirements/Constraint.ts
index 6294d5bc..63dd0796 100644
--- a/domain/requirements/Constraint.ts
+++ b/domain/requirements/Constraint.ts
@@ -1,15 +1,11 @@
-import { Entity, Enum } from '@mikro-orm/core';
 import { Requirement } from './Requirement.js';
 import { ConstraintCategory } from './ConstraintCategory.js';
-import { ReqType } from './ReqType.js';
 
 /**
  * A Constraint is a property imposed by the environment
  */
-@Entity({ discriminatorValue: ReqType.CONSTRAINT })
 export class Constraint extends Requirement {
-    static override reqIdPrefix = 'E.3.' as const;
-    static override req_type = ReqType.CONSTRAINT;
+    static override readonly reqIdPrefix = 'E.3.' as const;
 
     constructor({ category, ...rest }: ConstructorParameters<typeof Requirement>[0] & Pick<Constraint, 'category'>) {
         super(rest);
@@ -17,11 +13,9 @@ export class Constraint extends Requirement {
     }
 
     override get reqId() { return super.reqId as `${typeof Constraint.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 
     /**
      * Category of the constraint
      */
-    @Enum({ items: () => ConstraintCategory })
-    category?: ConstraintCategory;
+    readonly category: ConstraintCategory;
 }
\ No newline at end of file
diff --git a/domain/requirements/Effect.ts b/domain/requirements/Effect.ts
index fb70f640..8b2a676b 100644
--- a/domain/requirements/Effect.ts
+++ b/domain/requirements/Effect.ts
@@ -1,15 +1,10 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Environment property affected by the system
  */
-@Entity({ discriminatorValue: ReqType.EFFECT })
 export class Effect extends Requirement {
-    static override reqIdPrefix = 'E.5.' as const;
-    static override req_type = ReqType.EFFECT;
+    static override readonly reqIdPrefix = 'E.5.' as const;
 
     override get reqId() { return super.reqId as `${typeof Effect.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/EnvironmentComponent.ts b/domain/requirements/EnvironmentComponent.ts
index d4f0d958..3c1730d5 100644
--- a/domain/requirements/EnvironmentComponent.ts
+++ b/domain/requirements/EnvironmentComponent.ts
@@ -1,15 +1,10 @@
-import { Entity } from "@mikro-orm/core";
 import { Component } from "./Component.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Represents a component that is part of an environment.
  */
-@Entity({ discriminatorValue: ReqType.ENVIRONMENT_COMPONENT })
 export class EnvironmentComponent extends Component {
-    static override reqIdPrefix = 'E.2.' as const;
-    static override req_type = ReqType.ENVIRONMENT_COMPONENT;
+    static override readonly reqIdPrefix = 'E.2.' as const;
 
     override get reqId() { return super.reqId as `${typeof EnvironmentComponent.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/Epic.ts b/domain/requirements/Epic.ts
index 31db5665..ff52a2d4 100644
--- a/domain/requirements/Epic.ts
+++ b/domain/requirements/Epic.ts
@@ -1,31 +1,21 @@
-import { Entity, ManyToOne } from "@mikro-orm/core";
 import { Scenario } from "./Scenario.js";
-import { ReqType } from "./ReqType.js";
-import { FunctionalBehavior } from "./FunctionalBehavior.js";
 
 /**
  * An Epic is a collection of Use Cases and User Stories all directed towards a common goal.
  * Ex: "decrease the percentage of of fraudulent sellers by 20%"
  */
-@Entity({ discriminatorValue: ReqType.EPIC })
 export class Epic extends Scenario {
-    static override reqIdPrefix = 'G.5.' as const;
-    static override req_type = ReqType.EPIC;
+    static override readonly reqIdPrefix = 'G.5.' as const;
 
-    constructor(props: ConstructorParameters<typeof Scenario>[0] & Pick<Epic, 'functionalBehavior'>) {
+    constructor(props: ConstructorParameters<typeof Scenario>[0] & Pick<Epic, 'functionalBehaviorId'>) {
         super(props);
-        this.functionalBehavior = props.functionalBehavior;
+        this.functionalBehaviorId = props.functionalBehaviorId;
     }
 
     override get reqId() { return super.reqId as `${typeof Epic.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
-
-    private _functionalBehavior?: FunctionalBehavior;
 
     /**
      * The action that the user wants to perform.
-     */
-    @ManyToOne({ entity: () => FunctionalBehavior })
-    get functionalBehavior(): FunctionalBehavior | undefined { return this._functionalBehavior; }
-    set functionalBehavior(value: FunctionalBehavior | undefined) { this._functionalBehavior = value; }
+    */
+    readonly functionalBehaviorId!: string;
 }
\ No newline at end of file
diff --git a/domain/requirements/Example.ts b/domain/requirements/Example.ts
index 98d95d80..70e4c154 100644
--- a/domain/requirements/Example.ts
+++ b/domain/requirements/Example.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Behavior } from "./Behavior.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Illustration of behavior through a usage scenario
  */
-@Entity({ discriminatorValue: ReqType.EXAMPLE })
-export class Example extends Behavior {
-    static override req_type: ReqType = ReqType.EXAMPLE;
-}
\ No newline at end of file
+export class Example extends Behavior { }
\ No newline at end of file
diff --git a/domain/requirements/FunctionalBehavior.ts b/domain/requirements/FunctionalBehavior.ts
index b9e1dfdf..b6f40706 100644
--- a/domain/requirements/FunctionalBehavior.ts
+++ b/domain/requirements/FunctionalBehavior.ts
@@ -1,17 +1,12 @@
-import { Entity } from "@mikro-orm/core";
 import { Functionality } from "./Functionality.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * FunctionalBehavior specifies **what** behavior the system should exhibit, i.e.,
  * the results or effects of the system's operation.
  * Generally expressed in the form "system must do <requirement>"
  */
-@Entity({ discriminatorValue: ReqType.FUNCTIONAL_BEHAVIOR })
 export class FunctionalBehavior extends Functionality {
-    static override reqIdPrefix = 'S.2.' as const;
-    static override req_type = ReqType.FUNCTIONAL_BEHAVIOR;
+    static override readonly reqIdPrefix = 'S.2.' as const;
 
     override get reqId() { return super.reqId as `${typeof FunctionalBehavior.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/Functionality.ts b/domain/requirements/Functionality.ts
index 50a006f0..72329a80 100644
--- a/domain/requirements/Functionality.ts
+++ b/domain/requirements/Functionality.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Behavior } from "./Behavior.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Functionality describes what system will do and how it will do it.
  */
-@Entity({ discriminatorValue: ReqType.FUNCTIONALITY })
-export class Functionality extends Behavior {
-    static override req_type: ReqType = ReqType.FUNCTIONALITY;
-}
\ No newline at end of file
+export class Functionality extends Behavior { }
\ No newline at end of file
diff --git a/domain/requirements/GlossaryTerm.ts b/domain/requirements/GlossaryTerm.ts
index 3d074229..1e6f718b 100644
--- a/domain/requirements/GlossaryTerm.ts
+++ b/domain/requirements/GlossaryTerm.ts
@@ -1,15 +1,10 @@
-import { Entity } from "@mikro-orm/core";
 import { Component } from "./Component.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A word or phrase that is part of a glossary. Provides a definition for the term
  */
-@Entity({ discriminatorValue: ReqType.GLOSSARY_TERM })
 export class GlossaryTerm extends Component {
-    static override reqIdPrefix = 'E.1.' as const;
-    static override req_type = ReqType.GLOSSARY_TERM;
+    static override readonly reqIdPrefix = 'E.1.' as const;
 
     override get reqId() { return super.reqId as `${typeof GlossaryTerm.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/Goal.ts b/domain/requirements/Goal.ts
index 803f6c54..5b6407c8 100644
--- a/domain/requirements/Goal.ts
+++ b/domain/requirements/Goal.ts
@@ -1,13 +1,8 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A result desired by an organization.
  * an objective of the project or system, in terms
  * of their desired effect on the environment
  */
-@Entity({ discriminatorValue: ReqType.GOAL })
-export class Goal extends Requirement {
-    static override req_type: ReqType = ReqType.GOAL;
-}
\ No newline at end of file
+export class Goal extends Requirement { }
\ No newline at end of file
diff --git a/domain/requirements/Hint.ts b/domain/requirements/Hint.ts
index 81e62c38..3e6102e8 100644
--- a/domain/requirements/Hint.ts
+++ b/domain/requirements/Hint.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Noise } from "./Noise.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Design or implementation suggestion
  */
-@Entity({ discriminatorValue: ReqType.HINT })
-export class Hint extends Noise {
-    static override req_type: ReqType = ReqType.HINT;
-}
\ No newline at end of file
+export class Hint extends Noise { }
\ No newline at end of file
diff --git a/domain/requirements/Invariant.ts b/domain/requirements/Invariant.ts
index e872ade1..068b8feb 100644
--- a/domain/requirements/Invariant.ts
+++ b/domain/requirements/Invariant.ts
@@ -1,22 +1,12 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Environment property that must be maintained.
  * It exists as both an assumption and an effect.
  * (precondition and postcondition)
  */
-@Entity({ discriminatorValue: ReqType.INVARIANT })
 export class Invariant extends Requirement {
-    static override reqIdPrefix = 'E.6.' as const;
-    static override req_type: ReqType = ReqType.INVARIANT;
-
-    constructor(props: ConstructorParameters<typeof Requirement>[0]) {
-        super(props);
-        this.req_type = ReqType.INVARIANT;
-    }
+    static override readonly reqIdPrefix = 'E.6.' as const;
 
     override get reqId() { return super.reqId as `${typeof Invariant.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/Justification.ts b/domain/requirements/Justification.ts
index 436dada6..07db782e 100644
--- a/domain/requirements/Justification.ts
+++ b/domain/requirements/Justification.ts
@@ -1,12 +1,7 @@
-import { Entity } from "@mikro-orm/core";
 import { MetaRequirement } from "./MetaRequirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Explanation of a project or system property in reference to a goal or environment property.
  * A requirement is justified if it helps to achieve a goal or to satisfy an environment property (constraint).
  */
-@Entity({ discriminatorValue: ReqType.JUSTIFICATION })
-export class Justification extends MetaRequirement {
-    static override req_type: ReqType = ReqType.JUSTIFICATION;
-}
\ No newline at end of file
+export class Justification extends MetaRequirement { }
\ No newline at end of file
diff --git a/domain/requirements/Limit.ts b/domain/requirements/Limit.ts
index ff2cc25a..d243691b 100644
--- a/domain/requirements/Limit.ts
+++ b/domain/requirements/Limit.ts
@@ -1,15 +1,10 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * An Exclusion from the scope of requirements
  */
-@Entity({ discriminatorValue: ReqType.LIMIT })
 export class Limit extends Requirement {
-    static override reqIdPrefix = 'G.6.' as const;
-    static override req_type = ReqType.LIMIT;
+    static override readonly reqIdPrefix = 'G.6.' as const;
 
     override get reqId() { return super.reqId as `${typeof Limit.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/MetaRequirement.ts b/domain/requirements/MetaRequirement.ts
index 3e189344..89e40e47 100644
--- a/domain/requirements/MetaRequirement.ts
+++ b/domain/requirements/MetaRequirement.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Property of requirements themselves (not of the Project, Environment, Goals, or System)
  */
-@Entity({ discriminatorValue: ReqType.META_REQUIREMENT })
-export class MetaRequirement extends Requirement {
-    static override req_type: ReqType = ReqType.META_REQUIREMENT;
-}
\ No newline at end of file
+export class MetaRequirement extends Requirement { }
\ No newline at end of file
diff --git a/domain/requirements/Noise.ts b/domain/requirements/Noise.ts
index 333f6df9..ab5c4f47 100644
--- a/domain/requirements/Noise.ts
+++ b/domain/requirements/Noise.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Property that is in requirements but should not be
  */
-@Entity({ discriminatorValue: ReqType.NOISE })
-export class Noise extends Requirement {
-    static override req_type: ReqType = ReqType.NOISE;
-}
\ No newline at end of file
+export class Noise extends Requirement { }
\ No newline at end of file
diff --git a/domain/requirements/NonFunctionalBehavior.ts b/domain/requirements/NonFunctionalBehavior.ts
index 14801293..67c6ed3d 100644
--- a/domain/requirements/NonFunctionalBehavior.ts
+++ b/domain/requirements/NonFunctionalBehavior.ts
@@ -1,17 +1,12 @@
-import { Entity } from "@mikro-orm/core";
 import { Functionality } from "./Functionality.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * NonFunctionalBehavior is a type of Behavior that is not directly related to the functionality of a system.
  * It specifies **how** the system should behave, i.e., the qualities that the system must exhibit.
  * Generally expressed in the form "system shall be <requirement>."
  */
-@Entity({ discriminatorValue: ReqType.NON_FUNCTIONAL_BEHAVIOR })
 export class NonFunctionalBehavior extends Functionality {
-    static override reqIdPrefix = 'S.2.' as const;
-    static override req_type = ReqType.NON_FUNCTIONAL_BEHAVIOR;
+    static override readonly reqIdPrefix = 'S.2.' as const;
 
     override get reqId() { return super.reqId as `${typeof NonFunctionalBehavior.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/Obstacle.ts b/domain/requirements/Obstacle.ts
index 42b7d95f..61207c80 100644
--- a/domain/requirements/Obstacle.ts
+++ b/domain/requirements/Obstacle.ts
@@ -1,15 +1,10 @@
-import { Entity } from "@mikro-orm/core";
 import { Goal } from "./Goal.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Obstacles are the challenges that prevent the goals from being achieved.
  */
-@Entity({ discriminatorValue: ReqType.OBSTACLE })
 export class Obstacle extends Goal {
-    static override reqIdPrefix = 'G.2.' as const;
-    static override req_type: ReqType = ReqType.OBSTACLE;
+    static override readonly reqIdPrefix = 'G.2.' as const;
 
     override get reqId() { return super.reqId as `${typeof Obstacle.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/Organization.ts b/domain/requirements/Organization.ts
index cc330a52..d3d0050f 100644
--- a/domain/requirements/Organization.ts
+++ b/domain/requirements/Organization.ts
@@ -1,35 +1,17 @@
-import { Entity, Property } from "@mikro-orm/core";
 import { slugify } from "../../shared/utils/slugify.js";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * An Organization is a collection of users and solutions
  */
-@Entity({ discriminatorValue: ReqType.ORGANIZATION })
 export class Organization extends Requirement {
-    static override req_type: ReqType = ReqType.ORGANIZATION
-
     constructor(props: ConstructorParameters<typeof Requirement>[0]) {
         super(props)
-        this._slug = slugify(props.name);
-    }
-
-    override set name(value: string) {
-        super.name = value;
-        this._slug = slugify(value);
+        this.slug = slugify(props.name);
     }
 
-    private _slug!: string;
-
     /**
      * A slugified version of the name
      */
-    @Property({ type: 'string', unique: true })
-    get slug(): string { return this._slug; }
-    set slug(value: string) {
-        if (value !== slugify(this.name))
-            throw new Error('Slug must be a slugified version of the name');
-        this._slug = value;
-    }
+    readonly slug!: string;
 }
\ No newline at end of file
diff --git a/domain/requirements/Outcome.ts b/domain/requirements/Outcome.ts
index 1b51d195..289cbd9e 100644
--- a/domain/requirements/Outcome.ts
+++ b/domain/requirements/Outcome.ts
@@ -1,16 +1,11 @@
-import { Entity } from "@mikro-orm/core";
 import { Goal } from "./Goal.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A result desired by an organization
  */
-@Entity({ discriminatorValue: ReqType.OUTCOME })
 export class Outcome extends Goal {
-    static override req_type: ReqType = ReqType.OUTCOME;
     // FIXME: The Context and overall objective entry is an Outcome, but the req_id is G.1.0
-    static override reqIdPrefix = 'G.3.' as const;
+    static override readonly reqIdPrefix = 'G.3.' as const;
 
     override get reqId() { return super.reqId as `${typeof Outcome.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/ParsedRequirement.ts b/domain/requirements/ParsedRequirement.ts
index 3f5e40b3..5dc8c6f2 100644
--- a/domain/requirements/ParsedRequirement.ts
+++ b/domain/requirements/ParsedRequirement.ts
@@ -1,11 +1,6 @@
-import { Entity } from '@mikro-orm/core';
 import { MetaRequirement } from './MetaRequirement.js';
-import { ReqType } from './ReqType.js';
 
 /**
  * A requirement that has been parsed from natural language text
  */
-@Entity({ discriminatorValue: ReqType.PARSED_REQUIREMENT })
-export class ParsedRequirement extends MetaRequirement {
-    static override req_type: ReqType = ReqType.PARSED_REQUIREMENT;
-}
\ No newline at end of file
+export class ParsedRequirement extends MetaRequirement { }
\ No newline at end of file
diff --git a/domain/requirements/Person.ts b/domain/requirements/Person.ts
index 57332dc0..0160af52 100644
--- a/domain/requirements/Person.ts
+++ b/domain/requirements/Person.ts
@@ -1,27 +1,25 @@
-import { Entity, Property } from "@mikro-orm/core";
 import { Actor } from "./Actor.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A person is a member of the Project staff
  */
-@Entity({ discriminatorValue: ReqType.PERSON })
 export class Person extends Actor {
-    static override req_type: ReqType = ReqType.PERSON;
-    static override reqIdPrefix = 'P.1.' as const;
+    static override readonly reqIdPrefix = 'P.1.' as const;
 
     constructor({ email, ...rest }: ConstructorParameters<typeof Actor>[0] & Pick<Person, 'email'>) {
         super(rest);
+        // email address: https://stackoverflow.com/a/574698
+        if (email && !email.match(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/))
+            throw new Error('Invalid email address');
+        if (email && email.length > 254)
+            throw new Error('Email address too long');
         this.email = email;
     }
 
     override get reqId() { return super.reqId as `${typeof Person.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 
     /**
      * Email address of the person
      */
-    // email address: https://stackoverflow.com/a/574698
-    @Property({ type: 'string', length: 254 })
-    email?: string;
+    readonly email?: string;
 }
\ No newline at end of file
diff --git a/domain/requirements/Product.ts b/domain/requirements/Product.ts
index 881e9ea3..7cd85f76 100644
--- a/domain/requirements/Product.ts
+++ b/domain/requirements/Product.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Artifact needed or produced by a task
  */
-@Entity({ discriminatorValue: ReqType.PRODUCT })
-export class Product extends Requirement {
-    static override req_type: ReqType = ReqType.PRODUCT;
-}
\ No newline at end of file
+export class Product extends Requirement { }
\ No newline at end of file
diff --git a/domain/requirements/Requirement.ts b/domain/requirements/Requirement.ts
index f85af6db..146525c2 100644
--- a/domain/requirements/Requirement.ts
+++ b/domain/requirements/Requirement.ts
@@ -1,310 +1,58 @@
-import { v7 as uuidv7 } from 'uuid';
-import { BaseEntity, Cascade, Collection, Entity, Enum, ManyToMany, ManyToOne, OptionalProps, Property } from '@mikro-orm/core';
-import { type Properties } from '../types/index.js';
-import { ReqType } from './ReqType.js';
-import { AppUser } from '../application/AppUser.js';
+import { AuditMetadata } from "../AuditMetadata.js";
 
 /**
  * A Requirement is a statement that specifies a property.
  */
-@Entity({ abstract: true, discriminatorColumn: 'req_type' })
-export abstract class Requirement extends BaseEntity {
-    static req_type: ReqType = ReqType.REQUIREMENT;
-    static reqIdPrefix: `${'P' | 'E' | 'G' | 'S' | '0'}.${number}.` = '0.0.';
-
-    constructor(props: Properties<Omit<Requirement, 'id' | 'req_type'>>) {
-        super()
-        this.id = uuidv7();
-        this.req_type = (this.constructor as typeof Requirement).req_type;
+export class Requirement extends AuditMetadata {
+    static readonly reqIdPrefix: `${'P' | 'E' | 'G' | 'S' | '0'}.${number}.` = '0.0.';
+
+    constructor({ reqId, ...props }: Omit<Pick<Requirement, keyof Requirement>, 'reqId'> & { reqId?: Requirement['_reqId'] }) {
+        super(props)
+        if (props.name.length > 100)
+            throw new Error('Name must be less than 100 characters')
+        if (props.description.length > 1000)
+            throw new Error('Description must be less than 1000 characters')
+
+        this._reqId = reqId;
+        this.id = props.id;
         this.name = props.name;
         this.description = props.description;
-        this.lastModified = props.lastModified;
-        this.modifiedBy = props.modifiedBy;
         this.isSilence = props.isSilence;
-        this.createdBy = props.createdBy;
-        this._reqId = props.reqId;
-
-        // The ORM can pass extra properties to the constructor
-        if (Object.values(props).some((value) => (value as any) instanceof Collection))
-            throw new Error('Collections cannot be passed to the Requirement constructor')
     }
 
-    // This fixes the issue with em.create not honoring the constructor signature
-    // see: https://mikro-orm.io/docs/property-validation#properties-with-default-value
-    [OptionalProps]?: 'req_type' | 'slug'
-
-    private _req_type!: ReqType;
-    @Enum(() => ReqType)
-    get req_type(): ReqType { return this._req_type }
-    set req_type(value: ReqType) { this._req_type = value }
-
     /**
      * The unique identifier of the Requirement
      */
-    @Property({ type: 'uuid', primary: true })
-    id: string;
+    readonly id: string;
 
-    // This is nullable because MetaRequirements, Silence, and Noise do not have a reqId
-    // It may also be undefined if the requirement has not been added to a solution
-    private _reqId?: `${typeof Requirement['reqIdPrefix']}${number}`
+    private readonly _reqId?: `${typeof Requirement['reqIdPrefix']}${number}`
 
     /**
      * The user-friendly identifier of the requirement that is unique within its parent
      */
-    @Property({ type: 'text', nullable: true })
+    // This is nullable because MetaRequirements, Silence, and Noise do not have a reqId
+    // It may also be undefined if the requirement has not been added to a solution
     get reqId() { return this._reqId }
-    set reqId(value) { this._reqId = value }
 
     // A property is a Predicate formalizing its associated statement.
     // see: https://github.com/final-hill/cathedral/issues/368
     // property!: string
 
-    private _name!: string;
     /**
      * A short name for the requirement
      * @throws {Error} if the name is longer than 100 characters
-     */
-    @Property({ type: 'string', length: 100 })
-    get name(): string { return this._name }
-    set name(value: string) {
-        if (value.length > 100) throw new Error('Name must be less than 100 characters')
-        this._name = value
-    }
+    */
+    readonly name: string;
 
-    private _description!: string;
     /**
      * A human-readable explanation of a property
      * @throws {Error} if the description is longer than 1000 characters
-     */
-    @Property({ type: 'string', length: 1000 })
-    get description(): string { return this._description }
-    set description(value: string) {
-        if (value.length > 1000) throw new Error('Description must be less than 1000 characters')
-        this._description = value
-    }
-
-    /**
-     * The date and time when the requirement was last modified
-     */
-    @Property({ type: 'datetime', onCreate: () => new Date(), onUpdate: () => new Date(), defaultRaw: 'now()' })
-    lastModified: Date;
-
-    /**
-     * The user who last modified the requirement
-     */
-    @ManyToOne({ entity: () => AppUser })
-    modifiedBy: AppUser;
-
-    /**
-     * The user who created the requirement
-     */
-    @ManyToOne({ entity: () => AppUser })
-    createdBy: AppUser;
+    */
+    readonly description: string;
 
     /**
      * Whether the requirement is a silence requirement.
      * (i.e. a requirement that is not included in the solution)
      */
-    @Property({ type: 'boolean', default: false })
-    isSilence: boolean;
-
-    ///////////////////////////////////////////////////////////////////////////
-    ////////////////////// Relations /////////////////////////////////////////
-    ///////////////////////////////////////////////////////////////////////////
-
-    /**
-     * this ⊆ other
-     *
-     * this is a sub-requirement of other; textually included
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Belongs', inversedBy: (r) => r.contains })
-    belongs = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link belongs}
-     *
-     * This is the set of requirements that are sub-requirements of this requirement
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Belongs', mappedBy: (r) => r.belongs })
-    contains = new Collection<Requirement>(this);
-
-    /**
-     * this → other
-     *
-     * Meta-requirement this applies to other
-     */
-    // TODO: need to enforce that this is a MetaRequirement
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Characterizes', inversedBy: (r) => r.characterizedBy })
-    characterizes = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link characterizes}
-     */
-    // TODO: need to enforce that other is a MetaRequirement
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Characterizes', mappedBy: (r) => r.characterizes })
-    characterizedBy = new Collection<Requirement>(this);
-
-    /**
-     * this ▸ other
-     *
-     * Constraint this applies to other
-     */
-    // TODO: need to enforce that this is a Constraint
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Constrains', inversedBy: (r) => r.constrainedBy })
-    constrains = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link constrains}
-     */
-    // TODO: need to enforce that other is a Constraint
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Constrains', mappedBy: (r) => r.constrains })
-    constrainedBy = new Collection<Requirement>(this);
-
-    /**
-     * this ⊕ other
-     *
-     * Properties specified by this and other cannot both hold
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Contradicts', inversedBy: (r) => r.contradictedBy })
-    contradicts = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link contradicts}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Contradicts', mappedBy: (r) => r.contradicts })
-    contradictedBy = new Collection<Requirement>(this);
-
-    /**
-     * this » other
-     *
-     * this adds detail to properties of other
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Details', inversedBy: (r) => r.detailedBy })
-    details = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link details}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Details', mappedBy: (r) => r.details })
-    detailedBy = new Collection<Requirement>(this);
-
-    /**
-     * this || other
-     *
-     * this and other are unrelated
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Disjoins', inversedBy: (r) => r.disjoinedBy })
-    disjoins = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link disjoins}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Disjoins', mappedBy: (r) => r.disjoins })
-    disjoinedBy = new Collection<Requirement>(this);
-
-    /**
-     * this ≡ other
-     *
-     * this ⇔ other, and this has the same type as other.
-     * In other words, this and other are redundant.
-     * Same properties, same type (notation-wise, this ≡ other)
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Duplicates', inversedBy: (r) => r.duplicatedBy })
-    duplicates = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link duplicates}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Duplicates', mappedBy: (r) => r.duplicates })
-    duplicatedBy = new Collection<Requirement>(this);
-
-    /**
-     * this \\ other
-     *
-     * this specifies an exception to the property specified by other.
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Excepts', inversedBy: (r) => r.exceptedBy })
-    excepts = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link excepts}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Excepts', mappedBy: (r) => r.excepts })
-    exceptedBy = new Collection<Requirement>(this);
-
-    /**
-     * this ≅ other
-     *
-     * this ⇔ other, and this has a different type from other.
-     * In other words, other introduces no new property but helps understand this better.
-     * Same properties, different type (notation-wise)
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Explains', inversedBy: (r) => r.explainedBy })
-    explains = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link explains}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Explains', mappedBy: (r) => r.explains })
-    explainedBy = new Collection<Requirement>(this);
-
-    /**
-     * this > other
-     *
-     * aka "refines".
-     * this assumes other and specifies a property that other does not.
-     * this adds to properties of other
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Extends', inversedBy: (r) => r.extendedBy })
-    extends = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link extends}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Extends', mappedBy: (r) => r.extends })
-    extendedBy = new Collection<Requirement>(this);
-
-    /**
-     * this ⊣ other
-     *
-     * this is a consequence of the property specified by other
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Follows', inversedBy: (r) => r.followedBy })
-    follows = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link follows}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Follows', mappedBy: (r) => r.follows })
-    followedBy = new Collection<Requirement>(this);
-
-    /**
-     * this ⇔ other
-     *
-     * this specifies the same property as other
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Repeats', inversedBy: (r) => r.repeatedBy })
-    repeats = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link repeats}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Repeats', mappedBy: (r) => r.repeats })
-    repeatedBy = new Collection<Requirement>(this);
-
-    /**
-     * this ∩ other
-     *
-     * this' ⇔ other' for some sub-requirements this' and other' of this and other.
-     * (Involve Repeats).
-     * Some subrequirement is in common between this and other.
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Shares', inversedBy: (r) => r.sharedBy })
-    shares = new Collection<Requirement>(this);
-
-    /**
-     * The inverse of {@link shares}
-     */
-    @ManyToMany({ entity: () => Requirement, pivotEntity: 'Shares', mappedBy: (r) => r.shares })
-    sharedBy = new Collection<Requirement>(this);
+    readonly isSilence: boolean;
 }
\ No newline at end of file
diff --git a/domain/requirements/Responsibility.ts b/domain/requirements/Responsibility.ts
index 18621420..24985fce 100644
--- a/domain/requirements/Responsibility.ts
+++ b/domain/requirements/Responsibility.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Assignment of behavior or task to a component
  */
-@Entity({ discriminatorValue: ReqType.RESPONSIBILITY })
-export class Responsibility extends Requirement {
-    static override req_type: ReqType = ReqType.RESPONSIBILITY;
-}
+export class Responsibility extends Requirement { }
diff --git a/domain/requirements/Role.ts b/domain/requirements/Role.ts
index 18847af1..895523a0 100644
--- a/domain/requirements/Role.ts
+++ b/domain/requirements/Role.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Responsibility } from "./Responsibility.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Human responsibility
  */
-@Entity({ discriminatorValue: ReqType.ROLE })
-export class Role extends Responsibility {
-    static override req_type: ReqType = ReqType.ROLE;
-}
+export class Role extends Responsibility { }
diff --git a/domain/requirements/Scenario.ts b/domain/requirements/Scenario.ts
index d3577e55..7b333c32 100644
--- a/domain/requirements/Scenario.ts
+++ b/domain/requirements/Scenario.ts
@@ -1,32 +1,23 @@
-import { Entity, ManyToOne } from "@mikro-orm/core";
 import { Example } from "./Example.js";
-import { Stakeholder } from "./Stakeholder.js";
-import { ReqType } from "./ReqType.js";
-import { Outcome } from "./Outcome.js";
 
 /**
  * A Scenario specifies system behavior by describing paths
  * of interaction between actors and the system.
  */
-@Entity({ abstract: true, discriminatorValue: ReqType.SCENARIO })
 export abstract class Scenario extends Example {
-    static override req_type: ReqType = ReqType.SCENARIO;
-
-    constructor({ primaryActor, outcome, ...rest }: ConstructorParameters<typeof Example>[0] & Pick<Scenario, 'primaryActor' | 'outcome'>) {
+    constructor({ primaryActorId, outcomeId, ...rest }: ConstructorParameters<typeof Example>[0] & Pick<Scenario, 'primaryActorId' | 'outcomeId'>) {
         super(rest);
-        this.primaryActor = primaryActor;
-        this.outcome = outcome;
+        this.primaryActorId = primaryActorId;
+        this.outcomeId = outcomeId;
     }
 
     /**
      * Primary actor involved in the scenario
      */
-    @ManyToOne({ entity: () => Stakeholder })
-    primaryActor?: Stakeholder;
+    readonly primaryActorId: string;
 
     /**
      * The outcome (goal) that the scenario is aiming to achieve.
      */
-    @ManyToOne({ entity: () => Outcome })
-    outcome?: Outcome;
+    readonly outcomeId: string;
 }
\ No newline at end of file
diff --git a/domain/requirements/Silence.ts b/domain/requirements/Silence.ts
index 1ccb7d91..2c8502df 100644
--- a/domain/requirements/Silence.ts
+++ b/domain/requirements/Silence.ts
@@ -1,14 +1,9 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Property that is not in requirements but should be
  */
-@Entity({ discriminatorValue: ReqType.SILENCE })
 export class Silence extends Requirement {
-    static override req_type: ReqType = ReqType.SILENCE;
-
     constructor(props: Omit<ConstructorParameters<typeof Requirement>[0], 'isSilence'>) {
         super({ ...props, isSilence: true });
     }
diff --git a/domain/requirements/Solution.ts b/domain/requirements/Solution.ts
index f8d9a699..0353e0c8 100644
--- a/domain/requirements/Solution.ts
+++ b/domain/requirements/Solution.ts
@@ -1,35 +1,17 @@
-import { Entity, Property } from '@mikro-orm/core';
 import { slugify } from '../../shared/utils/slugify.js';
 import { Requirement } from './Requirement.js';
-import { ReqType } from './ReqType.js';
 
 /**
  * A Solution is the aggregation of a Project, Environment, Goals, and a System
  */
-@Entity({ discriminatorValue: ReqType.SOLUTION })
 export class Solution extends Requirement {
-    static override req_type: ReqType = ReqType.SOLUTION;
-
     constructor(props: ConstructorParameters<typeof Requirement>[0]) {
         super(props);
-        this._slug = slugify(props.name);
-    }
-
-    private _slug: string;
-
-    override set name(value: string) {
-        super.name = value;
-        this._slug = slugify(value);
+        this.slug = slugify(props.name);
     }
 
     /**
      * A slugified version of the name
      */
-    @Property({ type: 'string', unique: true })
-    get slug(): string { return this._slug; }
-    set slug(value: string) {
-        if (value !== slugify(this.name))
-            throw new Error('Slug must be a slugified version of the name');
-        this._slug = value;
-    }
+    readonly slug: string;
 }
\ No newline at end of file
diff --git a/domain/requirements/Stakeholder.ts b/domain/requirements/Stakeholder.ts
index cbd39a02..8cb1e30f 100644
--- a/domain/requirements/Stakeholder.ts
+++ b/domain/requirements/Stakeholder.ts
@@ -1,16 +1,12 @@
-import { Entity, Enum, Property } from "@mikro-orm/core";
 import { Component } from "./Component.js";
 import { StakeholderCategory } from "./StakeholderCategory.js";
 import { StakeholderSegmentation } from "./StakeholderSegmentation.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A human actor who may affect or be affected by a project or its associated system
  */
-@Entity({ discriminatorValue: ReqType.STAKEHOLDER })
 export class Stakeholder extends Component {
-    static override reqIdPrefix = 'G.7.' as const;
-    static override req_type: ReqType = ReqType.STAKEHOLDER;
+    static override readonly reqIdPrefix = 'G.7.' as const;
 
     constructor(props: ConstructorParameters<typeof Component>[0] & Pick<Stakeholder, 'influence' | 'availability' | 'segmentation' | 'category'>) {
         super(props);
@@ -21,29 +17,24 @@ export class Stakeholder extends Component {
     }
 
     override get reqId() { return super.reqId as `${typeof Stakeholder.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 
     /**
      * The segmentation of the stakeholder.
      */
-    @Enum({ items: () => StakeholderSegmentation })
-    segmentation?: StakeholderSegmentation;
+    readonly segmentation?: StakeholderSegmentation;
 
     /**
      * The category of the stakeholder.
      */
-    @Enum({ items: () => StakeholderCategory })
-    category?: StakeholderCategory;
+    readonly category?: StakeholderCategory;
 
     /**
      * The availability of the stakeholder.
      */
-    @Property({ type: 'number', check: 'availability >= 0 AND availability <= 100' })
-    availability: number;
+    readonly availability: number;
 
     /**
      * The influence of the stakeholder.
      */
-    @Property({ type: 'number', check: 'influence >= 0 AND influence <= 100' })
-    influence: number;
+    readonly influence: number;
 }
\ No newline at end of file
diff --git a/domain/requirements/SystemComponent.ts b/domain/requirements/SystemComponent.ts
index 019b9bce..b7e6ba1a 100644
--- a/domain/requirements/SystemComponent.ts
+++ b/domain/requirements/SystemComponent.ts
@@ -1,15 +1,10 @@
-import { Entity } from "@mikro-orm/core";
 import { Component } from "./Component.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A component of a system
  */
-@Entity({ discriminatorValue: ReqType.SYSTEM_COMPONENT })
 export class SystemComponent extends Component {
-    static override reqIdPrefix = 'S.1.' as const;
-    static override req_type = ReqType.SYSTEM_COMPONENT;
+    static override readonly reqIdPrefix = 'S.1.' as const;
 
     override get reqId() { return super.reqId as `${typeof SystemComponent.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 }
\ No newline at end of file
diff --git a/domain/requirements/Task.ts b/domain/requirements/Task.ts
index b3264d9e..568a9700 100644
--- a/domain/requirements/Task.ts
+++ b/domain/requirements/Task.ts
@@ -1,11 +1,6 @@
-import { Entity } from "@mikro-orm/core";
 import { Requirement } from "./Requirement.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * Activity included in the project
  */
-@Entity({ discriminatorValue: ReqType.TASK })
-export class Task extends Requirement {
-    static override req_type: ReqType = ReqType.TASK;
-}
+export class Task extends Requirement { }
diff --git a/domain/requirements/TestCase.ts b/domain/requirements/TestCase.ts
index a0aa6094..a742af66 100644
--- a/domain/requirements/TestCase.ts
+++ b/domain/requirements/TestCase.ts
@@ -1,13 +1,8 @@
-import { Entity } from "@mikro-orm/core";
 import { Example } from "./Example.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A TestCase is a specification of the inputs, execution conditions,
  * testing procedure, and expected results that define a single test to
  * be executed to achieve a particular goal.
  */
-@Entity({ discriminatorValue: ReqType.TEST_CASE })
-export class TestCase extends Example {
-    static override req_type: ReqType = ReqType.TEST_CASE;
-}
\ No newline at end of file
+export class TestCase extends Example { }
\ No newline at end of file
diff --git a/domain/requirements/UseCase.ts b/domain/requirements/UseCase.ts
index 4ba73bdf..499b49dc 100644
--- a/domain/requirements/UseCase.ts
+++ b/domain/requirements/UseCase.ts
@@ -1,58 +1,47 @@
-import { Entity, ManyToOne, Property } from "@mikro-orm/core";
-import { Assumption } from "./Assumption.js";
-import { Effect } from "./Effect.js";
 import { Scenario } from "./Scenario.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A Use Case specifies the scenario of a complete
  * interaction of a user through a system.
  */
-@Entity({ discriminatorValue: ReqType.USE_CASE })
 export class UseCase extends Scenario {
-    static override reqIdPrefix = 'S.4.' as const;
-    static override req_type = ReqType.USE_CASE;
+    static override readonly reqIdPrefix = 'S.4.' as const;
 
-    constructor(props: ConstructorParameters<typeof Scenario>[0] & Pick<UseCase, 'scope' | 'level' | 'precondition' | 'triggerId' | 'mainSuccessScenario' | 'successGuarantee' | 'extensions'>) {
+    constructor(props: ConstructorParameters<typeof Scenario>[0] & Pick<UseCase, 'scope' | 'level' | 'preconditionId' | 'triggerId' | 'mainSuccessScenario' | 'successGuaranteeId' | 'extensions'>) {
         super(props);
         this.scope = props.scope;
         this.level = props.level;
-        this.precondition = props.precondition;
+        this.preconditionId = props.preconditionId;
         this.triggerId = props.triggerId;
         this.mainSuccessScenario = props.mainSuccessScenario;
-        this.successGuarantee = props.successGuarantee;
+        this.successGuaranteeId = props.successGuaranteeId;
         this.extensions = props.extensions;
         // this.stakeHoldersAndInterests = props.stakeHoldersAndInterests;
     }
 
     override get reqId() { return super.reqId as `${typeof UseCase.reqIdPrefix}${number}` | undefined }
-    override set reqId(value) { super.reqId = value }
 
     /**
      * The scope of the use case.
      */
     // TODO: <https://github.com/final-hill/cathedral/issues/154>
-    @Property({ type: 'string' })
-    scope: string;
+    readonly scope: string;
 
     /**
      * The level of the use case.
      */
     // TODO: <https://github.com/final-hill/cathedral/issues/154>
-    @Property({ type: 'string' })
-    level: string;
+    readonly level: string;
 
     /**
      * The precondition is an Assumption that must be true before the use case can start.
      */
-    @ManyToOne({ entity: () => Assumption })
-    precondition?: Assumption;
+    readonly preconditionId: string;
 
     /**
      * The action upon the system that starts the use case.
      */
-    @Property({ type: 'uuid' })
-    triggerId?: string;
+    readonly triggerId: string;
 
     /**
      * The main success scenario is the most common path through the system.
@@ -63,21 +52,18 @@ export class UseCase extends Scenario {
      * ...
      */
     //mainSuccessScenario: [FunctionalRequirement | Constraint | Role | Responsibility][]
-    @Property({ type: 'string' })
-    mainSuccessScenario: string
+    readonly mainSuccessScenario: string
 
     /**
      * An Effect that is guaranteed to be true after the use case is completed.
      */
-    @ManyToOne({ entity: () => Effect })
-    successGuarantee?: Effect;
+    readonly successGuaranteeId: string;
 
     /**
      * Extensions of the use case.
      */
     // extensions: [FunctionalRequirement | Constraint | Role | Responsibility][]
-    @Property({ type: 'string' })
-    extensions: string
+    readonly extensions: string
 
     // TODO: <https://github.com/final-hill/cathedral/issues/154>
     // stakeHoldersAndInterests: string[] // Actor[]
diff --git a/domain/requirements/UserStory.ts b/domain/requirements/UserStory.ts
index e4b1e20e..555f6684 100644
--- a/domain/requirements/UserStory.ts
+++ b/domain/requirements/UserStory.ts
@@ -1,7 +1,4 @@
-import { Entity, ManyToOne } from "@mikro-orm/core";
-import { FunctionalBehavior } from "./FunctionalBehavior.js";
 import { Scenario } from "./Scenario.js";
-import { ReqType } from "./ReqType.js";
 
 /**
  * A User Story specifies the handling of a specific user need.
@@ -12,25 +9,18 @@ import { ReqType } from "./ReqType.js";
  * [behavior] - behaviorId (Functional Behavior)
  * [goal] - outcomeId
  */
-@Entity({ discriminatorValue: ReqType.USER_STORY })
 export class UserStory extends Scenario {
-    static override reqIdPrefix = 'S.4.' as const;
-    static override req_type = ReqType.USER_STORY;
+    static override readonly reqIdPrefix = 'S.4.' as const;
 
-    constructor({ functionalBehavior, ...rest }: ConstructorParameters<typeof Scenario>[0] & Pick<UserStory, 'functionalBehavior'>) {
+    constructor({ functionalBehaviorId, ...rest }: ConstructorParameters<typeof Scenario>[0] & Pick<UserStory, 'functionalBehaviorId'>) {
         super(rest);
-        this.functionalBehavior = functionalBehavior;
+        this.functionalBehaviorId = functionalBehaviorId;
     }
 
     override get reqId() { return super.reqId as `${typeof UserStory.reqIdPrefix}${number}` | undefined; }
-    override set reqId(value) { super.reqId = value; }
-
-    private _functionalBehavior?: FunctionalBehavior;
 
     /**
      * The action that the user wants to perform.
      */
-    @ManyToOne({ entity: () => FunctionalBehavior })
-    get functionalBehavior(): FunctionalBehavior | undefined { return this._functionalBehavior; }
-    set functionalBehavior(value: FunctionalBehavior | undefined) { this._functionalBehavior = value; }
+    readonly functionalBehaviorId: string
 }
\ No newline at end of file
diff --git a/domain/requirements/index.ts b/domain/requirements/index.ts
index 81b43d25..1456fa0d 100644
--- a/domain/requirements/index.ts
+++ b/domain/requirements/index.ts
@@ -31,7 +31,6 @@ export * from './Outcome.js';
 export * from './Person.js';
 export * from './Product.js';
 export * from './Responsibility.js';
-export * from './ReqType.js';
 export * from './Role.js';
 export * from './Scenario.js';
 export * from './Epic.js';
diff --git a/mikro-orm.config.ts b/mikro-orm.config.ts
index 2a826bdc..921ce1a6 100644
--- a/mikro-orm.config.ts
+++ b/mikro-orm.config.ts
@@ -5,10 +5,9 @@ import dotenv from "dotenv";
 import { type Options, PostgreSqlDriver } from '@mikro-orm/postgresql';
 import { TsMorphMetadataProvider } from '@mikro-orm/reflection';
 import { Migrator } from '@mikro-orm/migrations';
-import * as entities from "./domain/requirements/index.js";
-import * as relations from "./domain/relations/index.js";
-import * as appEntities from "./domain/application/index.js";
-import AuditSubscriber from "./server/data/subscribers/AuditSubscriber.js";
+import * as entities from "./server/data/models/requirements/index.js";
+import * as relations from "./server/data/models/relations/index.js"
+import * as appEntities from "./server/data/models/application/index.js";
 
 dotenv.config();
 const config: Options = {
@@ -27,10 +26,9 @@ const config: Options = {
         ...Object.values(entities),
         ...Object.values(relations),
         ...Object.values(appEntities)
-    ].filter((entity) => typeof entity === 'function'),
+    ],
     discovery: { disableDynamicFileAccess: true },
     seeder: {},
-    subscribers: [new AuditSubscriber()],
     forceUtcTimezone: true,
     metadataProvider: TsMorphMetadataProvider,
     debug: process.env.NODE_ENV !== 'production',
diff --git a/pages/o/[organization-slug]/[solution-slug]/workbox.client.vue b/pages/o/[organization-slug]/[solution-slug]/workbox.client.vue
index 8ed08a70..0884899a 100644
--- a/pages/o/[organization-slug]/[solution-slug]/workbox.client.vue
+++ b/pages/o/[organization-slug]/[solution-slug]/workbox.client.vue
@@ -1,8 +1,8 @@
 <script lang="ts" setup>
 import type { DataTableRowExpandEvent, DataTableRowCollapseEvent, DataTableExpandedRows } from 'primevue/datatable';
 import type { ParsedRequirementViewModel, RequirementViewModel, SolutionViewModel } from '#shared/models';
-import type { ReqType } from '~/domain/requirements/ReqType';
-import { camelCaseToTitle, snakeCaseToSlug, snakeCaseToTitle } from '~/shared/utils';
+import type { ReqType } from '~/server/data/models/requirements/ReqType';
+import { camelCaseToTitleCase, snakeCaseToSlug, snakeCaseToTitleCase } from '~/shared/utils';
 
 useHead({ title: 'Workbox' });
 definePageMeta({ name: 'Workbox' });
@@ -103,10 +103,10 @@ const reqKeys = (req: object = {}) => Object.keys(req)
                     :value="dataRows[data.id].data[reqType as ReqType]" :loading="dataRows[data.id].isLoading"
                     stripedRows>
                     <template #header>
-                        <h4>{{ snakeCaseToTitle(reqType) }}</h4>
+                        <h4>{{ snakeCaseToTitleCase(reqType) }}</h4>
                     </template>
                     <Column v-for="col of reqKeys(dataRows[data.id]?.data[reqType as ReqType]?.[0])" :key="col"
-                        :field="col" :header="camelCaseToTitle(col)" sortable />
+                        :field="col" :header="camelCaseToTitleCase(col)" sortable />
                     <Column header="Actions" frozen align-frozen="right">
                         <template #body="{ data }">
                             <Button icon="pi pi-check" text rounded class="mr-2" severity="success" title="Approve"
diff --git a/seeders/AppUserSeeder.ts b/seeders/AppUserSeeder.ts
index 07cd18ac..cfac009a 100644
--- a/seeders/AppUserSeeder.ts
+++ b/seeders/AppUserSeeder.ts
@@ -1,6 +1,6 @@
 import type { EntityManager } from '@mikro-orm/core';
 import { Seeder } from '@mikro-orm/seeder';
-import { AppUser } from '../domain/application/index.js';
+import { AppUserModel, AppUserVersionsModel } from '~/server/data/models/index.js';
 
 export class AppUserSeeder extends Seeder {
 
@@ -10,13 +10,24 @@ export class AppUserSeeder extends Seeder {
         if (isDev) {
             const mlHaufeId = 'a6e97f11-725b-439d-b8dc-06ca77c08dd7'
 
-            const sysAdminUser = await em.findOne(AppUser, {
-                id: mlHaufeId
-            })
+            const sysAdminUserStatic = await em.findOne(AppUserModel, {
+                id: mlHaufeId,
+                latestVersion: { isDeleted: false }
+            }, {
+                populate: ['latestVersion']
+            }),
+                latestVersion = sysAdminUserStatic?.latestVersion?.get(),
+                effectiveDate = new Date()
 
-            if (sysAdminUser) {
-                sysAdminUser.isSystemAdmin = true
-                await em.persistAndFlush(sysAdminUser)
+            if (latestVersion && !latestVersion.isSystemAdmin) {
+                em.create(AppUserVersionsModel, {
+                    ...latestVersion,
+                    isSystemAdmin: true,
+                    effectiveFrom: effectiveDate,
+                    modifiedBy: mlHaufeId
+                })
+
+                await em.flush()
             }
         }
     }
diff --git a/server/api/appusers/index.post.ts b/server/api/appusers/index.post.ts
index edd37577..31f1ecd6 100644
--- a/server/api/appusers/index.post.ts
+++ b/server/api/appusers/index.post.ts
@@ -26,5 +26,5 @@ export default defineEventHandler(async (event) => {
             organizationSlug
         })
 
-    return await organizationInteractor.addAppUserToOrganization({ email, role })
+    return await organizationInteractor.addAppUserOrganizationRole({ email, role })
 })
\ No newline at end of file
diff --git a/server/api/audit-log/deleted.get.ts b/server/api/audit-log/deleted.get.ts
deleted file mode 100644
index 03ab9b96..00000000
--- a/server/api/audit-log/deleted.get.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { z } from "zod"
-import { getServerSession } from '#auth'
-import { fork } from "~/server/data/orm.js"
-import { OrganizationInteractor } from "~/application"
-
-const querySchema = z.object({
-    entityName: z.string(),
-    organizationSlug: z.string()
-})
-
-/**
- * Returns from the audit history all the deleted entities
- * ordered by the date and time when they were deleted in descending order.
- */
-export default defineEventHandler(async (event) => {
-    const { entityName, organizationSlug } = await validateEventQuery(event, querySchema),
-        session = (await getServerSession(event))!,
-        organizationInteractor = new OrganizationInteractor({
-            userId: session.id,
-            entityManager: fork(),
-            organizationSlug
-        })
-
-    return organizationInteractor.getAuditLogDeleteHistory(entityName)
-})
\ No newline at end of file
diff --git a/server/api/audit-log/index.get.ts b/server/api/audit-log/index.get.ts
deleted file mode 100644
index 4b4c82b7..00000000
--- a/server/api/audit-log/index.get.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { z } from "zod"
-import { fork } from "~/server/data/orm.js"
-import { getServerSession } from '#auth'
-import { OrganizationInteractor } from "~/application"
-
-const querySchema = z.object({
-    entityId: z.string().uuid(),
-    organizationSlug: z.string()
-})
-
-/**
- * Returns the audit history of a specific entity
- */
-export default defineEventHandler(async (event) => {
-    const { entityId, organizationSlug } = await validateEventQuery(event, querySchema),
-        session = (await getServerSession(event))!,
-        organizationInteractor = new OrganizationInteractor({
-            userId: session.id,
-            entityManager: fork(),
-            organizationSlug
-        })
-
-    return await organizationInteractor.getAuditLogHistory(entityId)
-})
\ No newline at end of file
diff --git a/server/api/auth/[...].ts b/server/api/auth/[...].ts
index 37bddc75..47c8e364 100644
--- a/server/api/auth/[...].ts
+++ b/server/api/auth/[...].ts
@@ -1,7 +1,9 @@
 import { NuxtAuthHandler } from '#auth'
 import AzureADB2CProvider, { type AzureB2CProfile } from "next-auth/providers/azure-ad-b2c";
-import { fork } from '~/server/data/orm.js'
+import ormConfig from "~/mikro-orm.config"
 import { AppUser } from '~/domain/application/index.js';
+import { AppUserInteractor } from '~/application/AppUserInteractor';
+import { AppUserRepository } from '~/server/data/repositories/AppUserRepository';
 
 const config = useRuntimeConfig()
 
@@ -29,11 +31,14 @@ export default NuxtAuthHandler({
 
             if (account) {
                 const p = profile as AzureB2CProfile,
-                    em = fork()
+                    appUserInteractor = new AppUserInteractor({
+                        userId: p.oid,
+                        repository: new AppUserRepository({
+                            config: ormConfig
+                        })
+                    })
 
-                let appUser = await em.findOne(AppUser, {
-                    id: p.oid
-                })
+                let appUser = await appUserInteractor.getAppUserById(p.oid)
 
                 if (!appUser) {
                     appUser = em.create(AppUser, {
diff --git a/server/api/organization/[slug].delete.ts b/server/api/organization/[slug].delete.ts
index be323032..3792becd 100644
--- a/server/api/organization/[slug].delete.ts
+++ b/server/api/organization/[slug].delete.ts
@@ -1,7 +1,8 @@
 import { z } from "zod"
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
 import { getServerSession } from '#auth'
 import { OrganizationInteractor } from "~/application"
+import { OrganizationRepository } from "~/server/data/repositories/OrganizationRepository"
 
 const paramSchema = z.object({
     slug: z.string().max(100)
@@ -15,8 +16,7 @@ export default defineEventHandler(async (event) => {
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
             userId: session.id,
-            entityManager: fork(),
-            organizationSlug: slug
+            repository: new OrganizationRepository({ config, organizationSlug: slug })
         })
 
     return await organizationInteractor.deleteOrganization()
diff --git a/server/api/organization/[slug].get.ts b/server/api/organization/[slug].get.ts
index 51a75d8f..88189c5e 100644
--- a/server/api/organization/[slug].get.ts
+++ b/server/api/organization/[slug].get.ts
@@ -1,7 +1,8 @@
 import { z } from "zod"
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
 import { getServerSession } from '#auth'
 import { OrganizationInteractor } from "~/application"
+import { OrganizationRepository } from "~/server/data/repositories/OrganizationRepository"
 
 const paramSchema = z.object({
     slug: z.string().max(100)
@@ -14,9 +15,8 @@ export default defineEventHandler(async (event) => {
     const { slug } = await validateEventParams(event, paramSchema),
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
-            entityManager: fork(),
-            userId: session.id,
-            organizationSlug: slug
+            repository: new OrganizationRepository({ config, organizationSlug: slug }),
+            userId: session.id
         })
 
     return await organizationInteractor.getOrganization()
diff --git a/server/api/organization/[slug].put.ts b/server/api/organization/[slug].put.ts
index d2019d7a..c726aaed 100644
--- a/server/api/organization/[slug].put.ts
+++ b/server/api/organization/[slug].put.ts
@@ -1,7 +1,8 @@
 import { z } from "zod"
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
 import { getServerSession } from '#auth'
 import { OrganizationInteractor } from "~/application"
+import { OrganizationRepository } from "~/server/data/repositories/OrganizationRepository"
 
 const paramSchema = z.object({
     slug: z.string().max(100)
@@ -20,9 +21,8 @@ export default defineEventHandler(async (event) => {
         body = await validateEventBody(event, bodySchema),
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
-            entityManager: fork(),
-            userId: session.id,
-            organizationSlug: slug
+            repository: new OrganizationRepository({ config, organizationSlug: slug }),
+            userId: session.id
         })
 
     return await organizationInteractor.updateOrganization(body)
diff --git a/server/api/organization/index.get.ts b/server/api/organization/index.get.ts
index cf6ab202..f923a2d1 100644
--- a/server/api/organization/index.get.ts
+++ b/server/api/organization/index.get.ts
@@ -1,7 +1,8 @@
 import { z } from "zod"
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
 import { OrganizationInteractor } from '~/application/index.js'
 import { getServerSession } from '#auth'
+import { OrganizationRepository } from "~/server/data/repositories/OrganizationRepository"
 
 const querySchema = z.object({
     name: z.string().optional(),
@@ -15,9 +16,9 @@ export default defineEventHandler(async (event) => {
     const query = await validateEventParams(event, querySchema),
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
-            entityManager: fork(),
+            repository: new OrganizationRepository({ config }),
             userId: session.id
         })
 
-    return organizationInteractor.getUserOrganizations(query)
+    return organizationInteractor.getAppUserOrganizations(query)
 })
diff --git a/server/api/organization/index.post.ts b/server/api/organization/index.post.ts
index a054916f..baf630b1 100644
--- a/server/api/organization/index.post.ts
+++ b/server/api/organization/index.post.ts
@@ -1,7 +1,8 @@
 import { z } from "zod"
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
 import { getServerSession } from '#auth'
 import { OrganizationInteractor } from "~/application/index"
+import { OrganizationRepository } from "~/server/data/repositories/OrganizationRepository"
 
 const bodySchema = z.object({
     name: z.string(),
@@ -15,11 +16,15 @@ export default defineEventHandler(async (event) => {
     const { name, description } = await validateEventBody(event, bodySchema),
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
-            entityManager: fork(),
+            repository: new OrganizationRepository({ config }),
             userId: session.id
-        })
+        }),
+        newOrgId = await organizationInteractor.addOrganization({ name, description })
 
-    const newOrg = await organizationInteractor.addOrganization({ name, description })
+    const newOrgInteractor = new OrganizationInteractor({
+        repository: new OrganizationRepository({ config, organizationId: newOrgId }),
+        userId: session.id
+    })
 
-    return newOrg.slug
+    return newOrgInteractor.getOrganization()
 })
\ No newline at end of file
diff --git a/server/api/parse-requirement/follows.get.ts b/server/api/parse-requirement/follows.get.ts
index 50ce2494..54cab64f 100644
--- a/server/api/parse-requirement/follows.get.ts
+++ b/server/api/parse-requirement/follows.get.ts
@@ -1,7 +1,8 @@
 import { z } from "zod"
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
 import { getServerSession } from '#auth'
 import { OrganizationInteractor } from "~/application"
+import { OrganizationRepository } from "~/server/data/repositories/OrganizationRepository"
 
 const querySchema = z.object({
     organizationSlug: z.string(),
@@ -17,8 +18,7 @@ export default defineEventHandler(async (event) => {
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
             userId: session.id,
-            organizationSlug,
-            entityManager: fork()
+            repository: new OrganizationRepository({ config, organizationSlug })
         })
 
     return organizationInteractor.getFollowingParsedSilenceRequirements({ solutionId, id })
diff --git a/server/api/parse-requirement/index.post.ts b/server/api/parse-requirement/index.post.ts
index 94b47343..8ba6c8c2 100644
--- a/server/api/parse-requirement/index.post.ts
+++ b/server/api/parse-requirement/index.post.ts
@@ -1,8 +1,9 @@
 import { z } from "zod"
 import { getServerSession } from '#auth'
-import { fork } from "~/server/data/orm.js";
+import ormConfig from "~/mikro-orm.config";
 import { OrganizationInteractor } from "~/application/OrganizationInteractor.js";
 import NaturalLanguageToRequirementService from "~/server/data/services/NaturalLanguageToRequirementService.js";
+import { OrganizationRepository } from "~/server/data/repositories/OrganizationRepository";
 
 const bodySchema = z.object({
     solutionId: z.string().uuid(),
@@ -10,7 +11,7 @@ const bodySchema = z.object({
     statement: z.string().max(1000, 'Requirement must be less than or equal to 1000 characters')
 })
 
-const config = useRuntimeConfig()
+const appConfig = useRuntimeConfig()
 
 /**
  * Parse requirements from a statement, save the parsed requirements to the database,
@@ -21,14 +22,13 @@ export default defineEventHandler(async (event) => {
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
             userId: session.id,
-            organizationSlug,
-            entityManager: fork()
+            repository: new OrganizationRepository({ config: ormConfig, organizationSlug })
         }),
         naturalLanguageToRequirementService = new NaturalLanguageToRequirementService({
-            apiKey: config.azureOpenaiApiKey,
-            apiVersion: config.azureOpenaiApiVersion,
-            endpoint: config.azureOpenaiEndpoint,
-            modelId: config.azureOpenaiDeploymentId
+            apiKey: appConfig.azureOpenaiApiKey,
+            apiVersion: appConfig.azureOpenaiApiVersion,
+            endpoint: appConfig.azureOpenaiEndpoint,
+            modelId: appConfig.azureOpenaiDeploymentId
         })
 
     return organizationInteractor.parseRequirement({
diff --git a/server/api/solution/[slug].delete.ts b/server/api/solution/[slug].delete.ts
index b672dc5e..e1760aef 100644
--- a/server/api/solution/[slug].delete.ts
+++ b/server/api/solution/[slug].delete.ts
@@ -1,7 +1,8 @@
 import { getServerSession } from '#auth'
-import { fork } from "~/server/data/orm.js"
+import config from '~/mikro-orm.config'
 import { z } from "zod"
 import { OrganizationInteractor } from '~/application'
+import { OrganizationRepository } from '~/server/data/repositories/OrganizationRepository'
 
 const paramSchema = z.object({
     slug: z.string().max(100)
@@ -23,9 +24,7 @@ export default defineEventHandler(async (event) => {
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
             userId: session.id,
-            entityManager: fork(),
-            organizationId,
-            organizationSlug
+            repository: new OrganizationRepository({ config, organizationId, organizationSlug })
         })
 
     await organizationInteractor.deleteSolutionBySlug(slug)
diff --git a/server/api/solution/[slug].get.ts b/server/api/solution/[slug].get.ts
index 0369e271..c3e22829 100644
--- a/server/api/solution/[slug].get.ts
+++ b/server/api/solution/[slug].get.ts
@@ -1,7 +1,8 @@
 import { getServerSession } from '#auth'
 import { z } from "zod"
-import { fork } from "~/server/data/orm.js"
+import config from '~/mikro-orm.config'
 import { OrganizationInteractor } from '~/application'
+import { OrganizationRepository } from '~/server/data/repositories/OrganizationRepository'
 
 const paramSchema = z.object({
     slug: z.string().max(100)
@@ -23,9 +24,7 @@ export default defineEventHandler(async (event) => {
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
             userId: session.id,
-            entityManager: fork(),
-            organizationId,
-            organizationSlug
+            repository: new OrganizationRepository({ config, organizationId, organizationSlug })
         })
 
     return await organizationInteractor.getSolutionBySlug(slug)
diff --git a/server/api/solution/[slug].put.ts b/server/api/solution/[slug].put.ts
index 0cdd3d33..a7a2623c 100644
--- a/server/api/solution/[slug].put.ts
+++ b/server/api/solution/[slug].put.ts
@@ -1,7 +1,8 @@
 import { getServerSession } from '#auth'
 import { z } from "zod"
 import { OrganizationInteractor } from "~/application"
-import { fork } from "~/server/data/orm.js"
+import config from '~/mikro-orm.config'
+import { OrganizationRepository } from '~/server/data/repositories/OrganizationRepository'
 
 const paramSchema = z.object({
     slug: z.string().max(100)
@@ -25,9 +26,7 @@ export default defineEventHandler(async (event) => {
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
             userId: session.id,
-            entityManager: fork(),
-            organizationId,
-            organizationSlug
+            repository: new OrganizationRepository({ config, organizationId, organizationSlug })
         })
 
     await organizationInteractor.updateSolutionBySlug(slug, body)
diff --git a/server/api/solution/index.get.ts b/server/api/solution/index.get.ts
index 61f6b54d..30023bb1 100644
--- a/server/api/solution/index.get.ts
+++ b/server/api/solution/index.get.ts
@@ -1,7 +1,8 @@
 import { getServerSession } from '#auth'
-import { fork } from "~/server/data/orm.js"
+import config from '~/mikro-orm.config';
 import { z } from "zod"
 import { OrganizationInteractor } from "~/application"
+import { OrganizationRepository } from '~/server/data/repositories/OrganizationRepository';
 
 const querySchema = z.object({
     name: z.string().max(100).optional(),
@@ -21,9 +22,7 @@ export default defineEventHandler(async (event) => {
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
             userId: session.id,
-            entityManager: fork(),
-            organizationId,
-            organizationSlug
+            repository: new OrganizationRepository({ config, organizationId, organizationSlug })
         })
 
     return await organizationInteractor.findSolutions({ description, name, slug })
diff --git a/server/api/solution/index.post.ts b/server/api/solution/index.post.ts
index d75fe448..356dafae 100644
--- a/server/api/solution/index.post.ts
+++ b/server/api/solution/index.post.ts
@@ -1,7 +1,8 @@
 import { getServerSession } from '#auth'
-import { fork } from "~/server/data/orm.js"
+import config from '~/mikro-orm.config';
 import { z } from "zod"
 import { OrganizationInteractor } from "~/application"
+import { OrganizationRepository } from '~/server/data/repositories/OrganizationRepository';
 
 const bodySchema = z.object({
     name: z.string().min(1).max(100),
@@ -20,9 +21,7 @@ export default defineEventHandler(async (event) => {
         session = (await getServerSession(event))!,
         organizationInteractor = new OrganizationInteractor({
             userId: session.id,
-            entityManager: fork(),
-            organizationId,
-            organizationSlug
+            repository: new OrganizationRepository({ config, organizationId, organizationSlug })
         }),
         newSolution = await organizationInteractor.addSolution({ name, description })
 
diff --git a/server/data/mappers/DataModelToDomainModel.ts b/server/data/mappers/DataModelToDomainModel.ts
new file mode 100644
index 00000000..b3a0b985
--- /dev/null
+++ b/server/data/mappers/DataModelToDomainModel.ts
@@ -0,0 +1,37 @@
+import { Requirement } from "~/domain/requirements"
+import { RequirementModel } from "../models"
+import { Mapper } from "./Mapper"
+import { Collection } from "@mikro-orm/core"
+
+/**
+ * Converts a data model to a domain model
+ */
+export class DataModelToDomainModel implements Mapper<RequirementModel, Requirement> {
+    map<M extends RequirementModel, R extends Requirement>(model: M): R {
+        const staticProps = Object.entries(model).reduce((acc, [key, value]) => {
+            if (typeof value === 'object' && value !== null && 'id' in value)
+                return { ...acc, [`${key}Id`]: value.id }
+            else if (key === 'versions' || key === 'latestVersion')
+                return acc // skip
+            else
+                return { ...acc, [key]: value }
+        }, {})
+
+        const version = model.latestVersion!.getEntity()
+
+        const versionProps = Object.entries(version).reduce((acc, [key, value]) => {
+            if (key === 'requirement')
+                return acc // skip
+            else if (typeof value === 'object' && value !== null && 'id' in value)
+                return { ...acc, [`${key}Id`]: value.id }
+            else if (key === 'effectiveFrom')
+                return { ...acc, lastModified: value }
+            else if (value instanceof Collection)
+                return { ...acc, [`${key}Ids`]: value.getItems().map(item => item.id) }
+            else
+                return { ...acc, [key]: value }
+        }, {})
+
+        return { ...staticProps, ...versionProps } as R
+    }
+}
\ No newline at end of file
diff --git a/server/data/mappers/Mapper.ts b/server/data/mappers/Mapper.ts
new file mode 100644
index 00000000..8aceda0c
--- /dev/null
+++ b/server/data/mappers/Mapper.ts
@@ -0,0 +1,3 @@
+export interface Mapper<From, To> {
+    map(from: From): To
+}
\ No newline at end of file
diff --git a/server/data/mappers/ReqQueryToModelQuery.ts b/server/data/mappers/ReqQueryToModelQuery.ts
new file mode 100644
index 00000000..b2f29b1f
--- /dev/null
+++ b/server/data/mappers/ReqQueryToModelQuery.ts
@@ -0,0 +1,19 @@
+import { Requirement } from "~/domain/requirements"
+import { Mapper } from "./Mapper"
+
+/**
+ * Converts a Requirement query to a model query
+ */
+export class ReqQueryToModelQuery implements Mapper<Partial<Requirement>, Record<string, any>> {
+    map(query: Partial<Requirement>) {
+        return Object.entries(query).reduce((acc, [key, value]) => {
+            if (['createdById', 'creationDate', 'id'].includes(key))
+                return acc
+            if (key.endsWith('Id'))
+                key = key.slice(0, -2)
+            else if (key === 'lastModified')
+                key = 'effectiveFrom'
+            return { ...acc, [key]: value }
+        }, {})
+    }
+}
\ No newline at end of file
diff --git a/server/data/models/AuditSchema.ts b/server/data/models/AuditSchema.ts
new file mode 100644
index 00000000..31a8e243
--- /dev/null
+++ b/server/data/models/AuditSchema.ts
@@ -0,0 +1,21 @@
+import { ManyToOne, Property } from "@mikro-orm/core"
+import { AppUserModel } from "./index.js"
+
+export abstract class StaticAuditModel {
+    @ManyToOne({ entity: () => AppUserModel })
+    readonly createdBy!: AppUserModel;
+
+    @Property()
+    readonly creationDate!: Date;
+}
+
+export abstract class VolatileAuditModel {
+    @Property({ primary: true })
+    readonly effectiveFrom!: Date
+
+    @Property()
+    readonly isDeleted!: boolean
+
+    @ManyToOne({ entity: () => AppUserModel })
+    readonly modifiedBy!: AppUserModel;
+}
\ No newline at end of file
diff --git a/server/data/models/application/AppUserOrganizationRoleSchema.ts b/server/data/models/application/AppUserOrganizationRoleSchema.ts
new file mode 100644
index 00000000..db512dac
--- /dev/null
+++ b/server/data/models/application/AppUserOrganizationRoleSchema.ts
@@ -0,0 +1,44 @@
+import { Collection, Entity, Enum, ManyToOne, OneToMany, OneToOne, OptionalProps, Ref } from "@mikro-orm/core";
+import { AppRole } from "../../../../domain/application/index.js";
+import { StaticAuditModel, VolatileAuditModel } from "../AuditSchema.js";
+import { AppUserModel, } from "./index.js"
+import { OrganizationModel } from "../requirements/index.js";
+
+// static properties
+@Entity({ tableName: 'app_user_organization_role' })
+export class AppUserOrganizationRoleModel extends StaticAuditModel {
+    [OptionalProps]?: 'latestVersion'
+
+    @ManyToOne({ primary: true, entity: 'AppUserModel' })
+    readonly appUser!: AppUserModel;
+
+    @ManyToOne({ primary: true, entity: 'OrganizationModel' })
+    readonly organization!: OrganizationModel;
+
+    @OneToMany({ entity: 'AppUserOrganizationRoleVersionsModel', mappedBy: 'appUserOrganizationRole' })
+    readonly versions = new Collection<AppUserOrganizationRoleVersionsModel>(this);
+
+    @OneToOne({
+        entity: () => AppUserOrganizationRoleVersionsModel,
+        ref: true,
+        formula: alias =>
+            `select id
+            from app_user_organization_role_versions
+            where app_user_organization_role_id = ${alias}.id
+            and effective_from <= now()
+            and is_deleted = false
+            order by effective_from
+            desc limit 1`
+    })
+    readonly latestVersion?: Ref<AppUserOrganizationRoleVersionsModel>;
+}
+
+// volatile properties
+@Entity({ tableName: 'app_user_organization_role_versions' })
+export class AppUserOrganizationRoleVersionsModel extends VolatileAuditModel {
+    @ManyToOne({ primary: true, entity: 'AppUserOrganizationRoleModel' })
+    readonly appUserOrganizationRole!: AppUserOrganizationRoleModel;
+
+    @Enum({ items: () => AppRole })
+    readonly role!: AppRole
+}
\ No newline at end of file
diff --git a/server/data/models/application/AppUserSchema.ts b/server/data/models/application/AppUserSchema.ts
new file mode 100644
index 00000000..a766593b
--- /dev/null
+++ b/server/data/models/application/AppUserSchema.ts
@@ -0,0 +1,47 @@
+import { Collection, Entity, ManyToOne, OneToMany, OneToOne, OptionalProps, Property, Ref } from "@mikro-orm/core";
+import { StaticAuditModel, VolatileAuditModel } from "../index.js";
+
+// static properties
+@Entity({ tableName: 'app_user' })
+export class AppUserModel extends StaticAuditModel {
+    [OptionalProps]?: 'latestVersion'
+
+    @Property({ type: 'uuid', primary: true })
+    readonly id!: string
+
+    @OneToMany({ entity: () => AppUserVersionsModel, mappedBy: 'appUser' })
+    readonly versions = new Collection<AppUserVersionsModel>(this);
+
+    @OneToOne({
+        entity: () => AppUserVersionsModel,
+        ref: true,
+        formula: alias =>
+            `select id
+            from app_user_versions
+            where app_user_id = ${alias}.id
+            and effective_from <= now()
+            and is_deleted = false
+            order by effective_from
+            desc limit 1`
+    })
+    readonly latestVersion?: Ref<AppUserVersionsModel>
+}
+
+// volatile properties
+@Entity({ tableName: 'app_user_versions' })
+export class AppUserVersionsModel extends VolatileAuditModel {
+    @ManyToOne({ entity: () => AppUserModel, primary: true })
+    readonly appUser!: AppUserModel;
+
+    @Property({ length: 254 })
+    readonly name!: string;
+
+    @Property({ length: 254 })
+    readonly email!: string;
+
+    @Property({ nullable: true })
+    readonly lastLoginDate?: Date
+
+    @Property()
+    readonly isSystemAdmin!: boolean
+}
\ No newline at end of file
diff --git a/server/data/models/application/index.ts b/server/data/models/application/index.ts
new file mode 100644
index 00000000..441c1f2b
--- /dev/null
+++ b/server/data/models/application/index.ts
@@ -0,0 +1,2 @@
+export * from './AppUserSchema.js';
+export * from './AppUserOrganizationRoleSchema.js';
\ No newline at end of file
diff --git a/server/data/models/index.ts b/server/data/models/index.ts
new file mode 100644
index 00000000..287a32cd
--- /dev/null
+++ b/server/data/models/index.ts
@@ -0,0 +1,4 @@
+export * from './AuditSchema.js';
+export * from './application/index.js';
+export * from './requirements/index.js';
+export * from './relations/index.js';
\ No newline at end of file
diff --git a/server/data/models/relations/BelongsSchema.ts b/server/data/models/relations/BelongsSchema.ts
new file mode 100644
index 00000000..10fc10e4
--- /dev/null
+++ b/server/data/models/relations/BelongsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.BELONGS })
+export class BelongsModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.BELONGS })
+export class BelongsVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: BelongsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/CharacterizesSchema.ts b/server/data/models/relations/CharacterizesSchema.ts
new file mode 100644
index 00000000..c9340f98
--- /dev/null
+++ b/server/data/models/relations/CharacterizesSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.CHARACTERIZES })
+export class CharacterizesModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.CHARACTERIZES })
+export class CharacterizesVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: CharacterizesModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/ConstrainsSchema.ts b/server/data/models/relations/ConstrainsSchema.ts
new file mode 100644
index 00000000..1ae90da8
--- /dev/null
+++ b/server/data/models/relations/ConstrainsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.CONSTRAINS })
+export class ConstrainsModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.CONSTRAINS })
+export class ConstrainsVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: ConstrainsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/ContradictsSchema.ts b/server/data/models/relations/ContradictsSchema.ts
new file mode 100644
index 00000000..e3c3ed88
--- /dev/null
+++ b/server/data/models/relations/ContradictsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.CONTRADICTS })
+export class ContradictsModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.CONTRADICTS })
+export class ContradictsVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: ContradictsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/DetailsSchema.ts b/server/data/models/relations/DetailsSchema.ts
new file mode 100644
index 00000000..4d0afbab
--- /dev/null
+++ b/server/data/models/relations/DetailsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RelType } from "./RelType.js";
+import { ExtendsModel, ExtendsVersionsModel } from "./ExtendsSchema.js";
+
+@Entity({ discriminatorValue: RelType.DETAILS })
+export class DetailsModel extends ExtendsModel { }
+
+@Entity({ discriminatorValue: RelType.DETAILS })
+export class DetailsVersionsModel extends ExtendsVersionsModel {
+    declare readonly requirementRelation: DetailsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/DisjoinsSchema.ts b/server/data/models/relations/DisjoinsSchema.ts
new file mode 100644
index 00000000..89cb113e
--- /dev/null
+++ b/server/data/models/relations/DisjoinsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.DISJOINS })
+export class DisjoinsModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.DISJOINS })
+export class DisjoinsVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: DisjoinsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/DuplicatesSchema.ts b/server/data/models/relations/DuplicatesSchema.ts
new file mode 100644
index 00000000..f0467725
--- /dev/null
+++ b/server/data/models/relations/DuplicatesSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RelType } from "./RelType.js";
+import { RepeatsModel, RepeatsVersionsModel } from "./RepeatsSchema.js";
+
+@Entity({ discriminatorValue: RelType.DUPLICATES })
+export class DuplicatesModel extends RepeatsModel { }
+
+@Entity({ discriminatorValue: RelType.DUPLICATES })
+export class DuplicatesVersionsModel extends RepeatsVersionsModel {
+    declare readonly requirementRelation: DuplicatesModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/ExceptsSchema.ts b/server/data/models/relations/ExceptsSchema.ts
new file mode 100644
index 00000000..eaa07807
--- /dev/null
+++ b/server/data/models/relations/ExceptsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.EXCEPTS })
+export class ExceptsModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.EXCEPTS })
+export class ExceptsVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: ExceptsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/ExplainsSchema.ts b/server/data/models/relations/ExplainsSchema.ts
new file mode 100644
index 00000000..abf8e4f6
--- /dev/null
+++ b/server/data/models/relations/ExplainsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RelType } from "./RelType.js";
+import { RepeatsModel, RepeatsVersionsModel } from "./RepeatsSchema.js";
+
+@Entity({ discriminatorValue: RelType.EXPLAINS })
+export class ExplainsModel extends RepeatsModel { }
+
+@Entity({ discriminatorValue: RelType.EXPLAINS })
+export class ExplainsVersionsModel extends RepeatsVersionsModel {
+    declare readonly requirementRelation: ExplainsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/ExtendsSchema.ts b/server/data/models/relations/ExtendsSchema.ts
new file mode 100644
index 00000000..b70786f5
--- /dev/null
+++ b/server/data/models/relations/ExtendsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.EXTENDS })
+export class ExtendsModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.EXTENDS })
+export class ExtendsVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: ExtendsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/FollowsSchema.ts b/server/data/models/relations/FollowsSchema.ts
new file mode 100644
index 00000000..1ca62074
--- /dev/null
+++ b/server/data/models/relations/FollowsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.FOLLOWS })
+export class FollowsModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.FOLLOWS })
+export class FollowsVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: FollowsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/RelType.ts b/server/data/models/relations/RelType.ts
new file mode 100644
index 00000000..cf84051d
--- /dev/null
+++ b/server/data/models/relations/RelType.ts
@@ -0,0 +1,16 @@
+export enum RelType {
+    BELONGS = 'belongs',
+    CHARACTERIZES = 'characterizes',
+    CONSTRAINS = 'constrains',
+    CONTRADICTS = 'contradicts',
+    DETAILS = 'details',
+    DISJOINS = 'disjoins',
+    DUPLICATES = 'duplicates',
+    EXCEPTS = 'excepts',
+    EXPLAINS = 'explains',
+    EXTENDS = 'extends',
+    FOLLOWS = 'follows',
+    RELATION = 'relation',
+    REPEATS = 'repeats',
+    SHARES = 'shares'
+}
\ No newline at end of file
diff --git a/server/data/models/relations/RepeatsSchema.ts b/server/data/models/relations/RepeatsSchema.ts
new file mode 100644
index 00000000..b6b2fc16
--- /dev/null
+++ b/server/data/models/relations/RepeatsSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RequirementRelationModel, RequirementRelationVersionsModel } from "./RequirementRelationSchema.js";
+import { RelType } from "./RelType.js";
+
+@Entity({ discriminatorValue: RelType.REPEATS })
+export class RepeatsModel extends RequirementRelationModel { }
+
+@Entity({ discriminatorValue: RelType.REPEATS })
+export class RepeatsVersionsModel extends RequirementRelationVersionsModel {
+    declare readonly requirementRelation: RepeatsModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/RequirementRelationSchema.ts b/server/data/models/relations/RequirementRelationSchema.ts
new file mode 100644
index 00000000..15c977ae
--- /dev/null
+++ b/server/data/models/relations/RequirementRelationSchema.ts
@@ -0,0 +1,51 @@
+import { Collection, Entity, Enum, ManyToOne, OneToMany, OneToOne, OptionalProps, Ref } from '@mikro-orm/core';
+import { RelType } from './RelType.js';
+import { StaticAuditModel, VolatileAuditModel } from '../index.js';
+import { RequirementModel } from '../requirements/index.js';
+
+// Static properties
+@Entity({ abstract: true, tableName: 'requirement_relation', discriminatorColumn: 'rel_type', discriminatorValue: RelType.RELATION })
+export abstract class RequirementRelationModel extends StaticAuditModel {
+    [OptionalProps]?: 'rel_type' | 'latestVersion'
+
+    @Enum({ items: () => RelType, primary: true })
+    readonly rel_type!: RelType
+
+    @ManyToOne({ entity: 'RequirementModel', primary: true })
+    readonly left!: RequirementModel
+
+    @ManyToOne({ entity: 'RequirementModel', primary: true })
+    readonly right!: RequirementModel
+
+    @OneToMany({ entity: 'RequirementRelationVersionsModel', mappedBy: 'requirementRelation' })
+    readonly versions = new Collection<RequirementRelationVersionsModel>(this)
+
+    @OneToOne({
+        entity: () => RequirementRelationVersionsModel,
+        ref: true,
+        // Select the latest version id of the requirement (effective_from <= now())
+        formula: alias =>
+            `select id
+            from requirement_relation_versions
+            where requirement_relation_id = ${alias}.id
+            and effective_from <= now()
+            and is_deleted = false
+            order by effective_from
+            desc limit 1`
+    })
+    readonly latestVersion?: Ref<RequirementRelationVersionsModel>
+}
+
+// Volatile properties
+@Entity({
+    abstract: true, tableName: 'requirement_relation_versions', discriminatorColumn: 'rel_type', discriminatorValue: RelType.RELATION
+})
+export abstract class RequirementRelationVersionsModel extends VolatileAuditModel {
+    [OptionalProps]?: 'rel_type'
+
+    @Enum({ items: () => RelType, primary: true })
+    readonly rel_type!: RelType
+
+    @ManyToOne({ entity: 'RequirementRelationModel', primary: true })
+    readonly requirementRelation!: RequirementRelationModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/SharesSchema.ts b/server/data/models/relations/SharesSchema.ts
new file mode 100644
index 00000000..6ffca0dd
--- /dev/null
+++ b/server/data/models/relations/SharesSchema.ts
@@ -0,0 +1,11 @@
+import { Entity } from "@mikro-orm/core";
+import { RelType } from "./RelType.js";
+import { RepeatsModel, RepeatsVersionsModel } from "./RepeatsSchema.js";
+
+@Entity({ discriminatorValue: RelType.SHARES })
+export class SharesModel extends RepeatsModel { }
+
+@Entity({ discriminatorValue: RelType.SHARES })
+export class SharesVersionsModel extends RepeatsVersionsModel {
+    declare readonly requirementRelation: SharesModel
+}
\ No newline at end of file
diff --git a/server/data/models/relations/index.ts b/server/data/models/relations/index.ts
new file mode 100644
index 00000000..5c6dc9b5
--- /dev/null
+++ b/server/data/models/relations/index.ts
@@ -0,0 +1,14 @@
+export * from './RequirementRelationSchema.js'
+export * from './BelongsSchema.js'
+export * from './CharacterizesSchema.js'
+export * from './ConstrainsSchema.js'
+export * from './ContradictsSchema.js'
+export * from './DetailsSchema.js'
+export * from './DisjoinsSchema.js'
+export * from './DuplicatesSchema.js'
+export * from './ExceptsSchema.js'
+export * from './ExplainsSchema.js'
+export * from './ExtendsSchema.js'
+export * from './FollowsSchema.js'
+export * from './RepeatsSchema.js'
+export * from './SharesSchema.js'
\ No newline at end of file
diff --git a/server/data/models/requirements/ActorSchema.ts b/server/data/models/requirements/ActorSchema.ts
new file mode 100644
index 00000000..67395cff
--- /dev/null
+++ b/server/data/models/requirements/ActorSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+import { ReqType } from "./ReqType.js";
+
+@Entity({ discriminatorValue: ReqType.ACTOR })
+export class ActorModel extends RequirementModel {
+    declare readonly versions: Collection<ActorVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.ACTOR })
+export class ActorVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/AssumptionSchema.ts b/server/data/models/requirements/AssumptionSchema.ts
new file mode 100644
index 00000000..786274f0
--- /dev/null
+++ b/server/data/models/requirements/AssumptionSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.ASSUMPTION })
+export class AssumptionModel extends RequirementModel {
+    declare readonly versions: Collection<AssumptionVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.ASSUMPTION })
+export class AssumptionVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/BehaviorSchema.ts b/server/data/models/requirements/BehaviorSchema.ts
new file mode 100644
index 00000000..5dae37a6
--- /dev/null
+++ b/server/data/models/requirements/BehaviorSchema.ts
@@ -0,0 +1,15 @@
+import { Collection, Entity, Enum } from "@mikro-orm/core";
+import { MoscowPriority } from '../../../../domain/requirements/index.js';
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+import { ReqType } from "./ReqType.js";
+
+@Entity({ discriminatorValue: ReqType.BEHAVIOR })
+export class BehaviorModel extends RequirementModel {
+    declare readonly versions: Collection<BehaviorVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.BEHAVIOR })
+export class BehaviorVersionsModel extends RequirementVersionsModel {
+    @Enum({ items: () => MoscowPriority })
+    readonly priority!: MoscowPriority;
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/ComponentSchema.ts b/server/data/models/requirements/ComponentSchema.ts
new file mode 100644
index 00000000..682b4385
--- /dev/null
+++ b/server/data/models/requirements/ComponentSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { ActorModel, ActorVersionsModel } from "./ActorSchema.js";
+
+@Entity({ discriminatorValue: ReqType.COMPONENT })
+export class ComponentModel extends ActorModel {
+    declare readonly versions: Collection<ComponentVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.COMPONENT })
+export class ComponentVersionsModel extends ActorVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/ConstraintSchema.ts b/server/data/models/requirements/ConstraintSchema.ts
new file mode 100644
index 00000000..03f59665
--- /dev/null
+++ b/server/data/models/requirements/ConstraintSchema.ts
@@ -0,0 +1,15 @@
+import { Collection, Entity, Enum } from "@mikro-orm/core";
+import { ConstraintCategory } from '../../../../domain/requirements/index.js';
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+import { ReqType } from "./ReqType.js";
+
+@Entity({ discriminatorValue: ReqType.CONSTRAINT })
+export class ConstraintModel extends RequirementModel {
+    declare readonly versions: Collection<ConstraintVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.CONSTRAINT })
+export class ConstraintVersionsModel extends RequirementVersionsModel {
+    @Enum({ items: () => ConstraintCategory })
+    readonly category?: ConstraintCategory;
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/EffectSchema.ts b/server/data/models/requirements/EffectSchema.ts
new file mode 100644
index 00000000..0d554536
--- /dev/null
+++ b/server/data/models/requirements/EffectSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.EFFECT })
+export class EffectModel extends RequirementModel {
+    declare readonly versions: Collection<EffectVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.EFFECT })
+export class EffectVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/EnvironmentComponentSchema.ts b/server/data/models/requirements/EnvironmentComponentSchema.ts
new file mode 100644
index 00000000..cae97839
--- /dev/null
+++ b/server/data/models/requirements/EnvironmentComponentSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { ComponentModel, ComponentVersionsModel } from "./ComponentSchema.js";
+
+@Entity({ discriminatorValue: ReqType.ENVIRONMENT_COMPONENT })
+export class EnvironmentComponentModel extends ComponentModel {
+    declare readonly versions: Collection<EnvironmentComponentVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.ENVIRONMENT_COMPONENT })
+export class EnvironmentComponentVersionsModel extends ComponentVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/EpicSchema.ts b/server/data/models/requirements/EpicSchema.ts
new file mode 100644
index 00000000..7fcbd396
--- /dev/null
+++ b/server/data/models/requirements/EpicSchema.ts
@@ -0,0 +1,15 @@
+import { Collection, Entity, ManyToOne } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { ScenarioModel, ScenarioVersionsModel } from "./ScenarioSchema.js";
+import { FunctionalBehaviorModel } from "./FunctionalBehaviorSchema.js";
+
+@Entity({ discriminatorValue: ReqType.EPIC })
+export class EpicModel extends ScenarioModel {
+    declare readonly versions: Collection<EpicVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.EPIC })
+export class EpicVersionsModel extends ScenarioVersionsModel {
+    @ManyToOne({ entity: () => FunctionalBehaviorModel })
+    readonly functionalBehavior!: FunctionalBehaviorModel
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/ExampleSchema.ts b/server/data/models/requirements/ExampleSchema.ts
new file mode 100644
index 00000000..ab5a24cf
--- /dev/null
+++ b/server/data/models/requirements/ExampleSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { BehaviorModel, BehaviorVersionsModel } from "./BehaviorSchema.js";
+
+@Entity({ discriminatorValue: ReqType.EXAMPLE })
+export class ExampleModel extends BehaviorModel {
+    declare readonly versions: Collection<ExampleVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.EXAMPLE })
+export class ExampleVersionsModel extends BehaviorVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/FunctionalBehaviorSchema.ts b/server/data/models/requirements/FunctionalBehaviorSchema.ts
new file mode 100644
index 00000000..e2e8bf13
--- /dev/null
+++ b/server/data/models/requirements/FunctionalBehaviorSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { FunctionalityModel, FunctionalityVersionsModel } from "./FunctionalitySchema.js";
+
+@Entity({ discriminatorValue: ReqType.FUNCTIONAL_BEHAVIOR })
+export class FunctionalBehaviorModel extends FunctionalityModel {
+    declare readonly versions: Collection<FunctionalBehaviorVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.FUNCTIONAL_BEHAVIOR })
+export class FunctionalBehaviorVersionsModel extends FunctionalityVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/FunctionalitySchema.ts b/server/data/models/requirements/FunctionalitySchema.ts
new file mode 100644
index 00000000..23ac6fd2
--- /dev/null
+++ b/server/data/models/requirements/FunctionalitySchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { BehaviorModel, BehaviorVersionsModel } from "./BehaviorSchema.js";
+
+@Entity({ discriminatorValue: ReqType.FUNCTIONALITY })
+export class FunctionalityModel extends BehaviorModel {
+    declare readonly versions: Collection<FunctionalityVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.FUNCTIONALITY })
+export class FunctionalityVersionsModel extends BehaviorVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/GlossaryTermSchema.ts b/server/data/models/requirements/GlossaryTermSchema.ts
new file mode 100644
index 00000000..371f2c80
--- /dev/null
+++ b/server/data/models/requirements/GlossaryTermSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { ComponentModel, ComponentVersionsModel } from "./ComponentSchema.js";
+
+@Entity({ discriminatorValue: ReqType.GLOSSARY_TERM })
+export class GlossaryTermModel extends ComponentModel {
+    declare readonly versions: Collection<GlossaryTermVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.GLOSSARY_TERM })
+export class GlossaryTermVersionsModel extends ComponentVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/GoalSchema.ts b/server/data/models/requirements/GoalSchema.ts
new file mode 100644
index 00000000..5d81c4b0
--- /dev/null
+++ b/server/data/models/requirements/GoalSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.GOAL })
+export class GoalModel extends RequirementModel {
+    declare readonly versions: Collection<GoalVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.GOAL })
+export class GoalVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/HintSchema.ts b/server/data/models/requirements/HintSchema.ts
new file mode 100644
index 00000000..da2281ba
--- /dev/null
+++ b/server/data/models/requirements/HintSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { NoiseModel, NoiseVersionsModel } from "./NoiseSchema.js";
+
+@Entity({ discriminatorValue: ReqType.HINT })
+export class HintModel extends NoiseModel {
+    declare readonly versions: Collection<HintVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.HINT })
+export class HintVersionsModel extends NoiseVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/InvariantSchema.ts b/server/data/models/requirements/InvariantSchema.ts
new file mode 100644
index 00000000..950b99bc
--- /dev/null
+++ b/server/data/models/requirements/InvariantSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.INVARIANT })
+export class InvariantModel extends RequirementModel {
+    declare readonly versions: Collection<InvariantVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.INVARIANT })
+export class InvariantVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/JustificationSchema.ts b/server/data/models/requirements/JustificationSchema.ts
new file mode 100644
index 00000000..561aa3a7
--- /dev/null
+++ b/server/data/models/requirements/JustificationSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { MetaRequirementModel, MetaRequirementVersionsModel } from "./MetaRequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.JUSTIFICATION })
+export class JustificationModel extends MetaRequirementModel {
+    declare readonly versions: Collection<JustificationVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.JUSTIFICATION })
+export class JustificationVersionsModel extends MetaRequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/LimitSchema.ts b/server/data/models/requirements/LimitSchema.ts
new file mode 100644
index 00000000..1fba99ad
--- /dev/null
+++ b/server/data/models/requirements/LimitSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.LIMIT })
+export class LimitModel extends RequirementModel {
+    declare readonly versions: Collection<LimitVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.LIMIT })
+export class LimitVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/MetaRequirementSchema.ts b/server/data/models/requirements/MetaRequirementSchema.ts
new file mode 100644
index 00000000..f9a05191
--- /dev/null
+++ b/server/data/models/requirements/MetaRequirementSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.META_REQUIREMENT })
+export class MetaRequirementModel extends RequirementModel {
+    declare readonly versions: Collection<MetaRequirementVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.META_REQUIREMENT })
+export class MetaRequirementVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/NoiseSchema.ts b/server/data/models/requirements/NoiseSchema.ts
new file mode 100644
index 00000000..2d4591b8
--- /dev/null
+++ b/server/data/models/requirements/NoiseSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.NOISE })
+export class NoiseModel extends RequirementModel {
+    declare readonly versions: Collection<NoiseVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.NOISE })
+export class NoiseVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/NonFunctionalBehaviorSchema.ts b/server/data/models/requirements/NonFunctionalBehaviorSchema.ts
new file mode 100644
index 00000000..af429437
--- /dev/null
+++ b/server/data/models/requirements/NonFunctionalBehaviorSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { FunctionalityModel, FunctionalityVersionsModel } from "./FunctionalitySchema.js";
+
+@Entity({ discriminatorValue: ReqType.NON_FUNCTIONAL_BEHAVIOR })
+export class NonFunctionalBehaviorModel extends FunctionalityModel {
+    declare readonly versions: Collection<NonFunctionalBehaviorVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.NON_FUNCTIONAL_BEHAVIOR })
+export class NonFunctionalBehaviorVersionsModel extends FunctionalityVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/ObstacleSchema.ts b/server/data/models/requirements/ObstacleSchema.ts
new file mode 100644
index 00000000..eb6c118c
--- /dev/null
+++ b/server/data/models/requirements/ObstacleSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { GoalModel, GoalVersionsModel } from "./GoalSchema.js";
+
+@Entity({ discriminatorValue: ReqType.OBSTACLE })
+export class ObstacleModel extends GoalModel {
+    declare readonly versions: Collection<ObstacleVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.OBSTACLE })
+export class ObstacleVersionsModel extends GoalVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/OrganizationSchema.ts b/server/data/models/requirements/OrganizationSchema.ts
new file mode 100644
index 00000000..1c9d3a40
--- /dev/null
+++ b/server/data/models/requirements/OrganizationSchema.ts
@@ -0,0 +1,16 @@
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+import { Collection, Entity, Property } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+
+@Entity({ discriminatorValue: ReqType.ORGANIZATION })
+export class OrganizationModel extends RequirementModel {
+    declare readonly versions: Collection<OrganizationVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.ORGANIZATION })
+export class OrganizationVersionsModel extends RequirementVersionsModel {
+    declare readonly requirement: OrganizationModel
+
+    @Property()
+    readonly slug!: string
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/OutcomeSchema.ts b/server/data/models/requirements/OutcomeSchema.ts
new file mode 100644
index 00000000..625cb9c9
--- /dev/null
+++ b/server/data/models/requirements/OutcomeSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { GoalModel, GoalVersionsModel } from "./GoalSchema.js";
+
+@Entity({ discriminatorValue: ReqType.OUTCOME })
+export class OutcomeModel extends GoalModel {
+    declare readonly versions: Collection<OutcomeVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.OUTCOME })
+export class OutcomeVersionsModel extends GoalVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/ParsedRequirementSchema.ts b/server/data/models/requirements/ParsedRequirementSchema.ts
new file mode 100644
index 00000000..18e95de7
--- /dev/null
+++ b/server/data/models/requirements/ParsedRequirementSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { MetaRequirementModel, MetaRequirementVersionsModel } from './MetaRequirementSchema.js';
+
+@Entity({ discriminatorValue: ReqType.PARSED_REQUIREMENT })
+export class ParsedRequirementModel extends MetaRequirementModel {
+    declare readonly versions: Collection<ParsedRequirementVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.PARSED_REQUIREMENT })
+export class ParsedRequirementVersionsModel extends MetaRequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/PersonSchema.ts b/server/data/models/requirements/PersonSchema.ts
new file mode 100644
index 00000000..e5b41b44
--- /dev/null
+++ b/server/data/models/requirements/PersonSchema.ts
@@ -0,0 +1,14 @@
+import { Collection, Entity, Property } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { ActorModel, ActorVersionsModel } from './ActorSchema.js';
+
+@Entity({ discriminatorValue: ReqType.PERSON })
+export class PersonModel extends ActorModel {
+    declare readonly versions: Collection<PersonVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.PERSON })
+export class PersonVersionsModel extends ActorVersionsModel {
+    @Property({ length: 254 })
+    readonly email!: string
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/ProductSchema.ts b/server/data/models/requirements/ProductSchema.ts
new file mode 100644
index 00000000..bd8b39c9
--- /dev/null
+++ b/server/data/models/requirements/ProductSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.PRODUCT })
+export class ProductModel extends RequirementModel {
+    declare readonly versions: Collection<ProductVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.PRODUCT })
+export class ProductVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/domain/requirements/ReqType.ts b/server/data/models/requirements/ReqType.ts
similarity index 100%
rename from domain/requirements/ReqType.ts
rename to server/data/models/requirements/ReqType.ts
diff --git a/server/data/models/requirements/RequirementSchema.ts b/server/data/models/requirements/RequirementSchema.ts
new file mode 100644
index 00000000..3d470a89
--- /dev/null
+++ b/server/data/models/requirements/RequirementSchema.ts
@@ -0,0 +1,56 @@
+import { Collection, Entity, Enum, ManyToOne, OneToMany, OneToOne, OptionalProps, Property, Ref } from '@mikro-orm/core';
+import { StaticAuditModel, VolatileAuditModel } from '../index.js';
+import { ReqType } from './ReqType.js';
+
+// static properties
+@Entity({ abstract: true, tableName: 'requirement', discriminatorColumn: 'req_type', discriminatorValue: ReqType.REQUIREMENT })
+export abstract class RequirementModel extends StaticAuditModel {
+    [OptionalProps]?: 'req_type' | 'latestVersion'
+
+    @Enum({ items: () => ReqType, primary: true })
+    readonly req_type!: ReqType;
+
+    @Property({ type: 'uuid', primary: true })
+    readonly id!: string;
+
+    @OneToMany({ entity: () => RequirementVersionsModel, mappedBy: 'requirement' })
+    readonly versions = new Collection<RequirementVersionsModel>(this);
+
+    @OneToOne({
+        entity: () => RequirementVersionsModel,
+        ref: true,
+        formula: alias =>
+            `select id
+            from requirement_versions
+            where requirement_id = ${alias}.id
+            and effective_from <= now()
+            and is_deleted = false
+            order by effective_from
+            desc limit 1`
+    })
+    readonly latestVersion?: Ref<RequirementVersionsModel>;
+}
+
+//volatile properties
+@Entity({ abstract: true, tableName: 'requirement_versions', discriminatorColumn: 'req_type', discriminatorValue: ReqType.REQUIREMENT })
+export abstract class RequirementVersionsModel extends VolatileAuditModel {
+    [OptionalProps]?: 'req_type'
+
+    @Enum({ items: () => ReqType, primary: true })
+    readonly req_type!: ReqType;
+
+    @ManyToOne({ entity: () => RequirementModel, primary: true })
+    readonly requirement!: RequirementModel;
+
+    @Property({ length: 100 })
+    readonly name!: string
+
+    @Property({ length: 1000 })
+    readonly description!: string
+
+    @Property({ type: 'string', nullable: true })
+    readonly reqId?: `P.${number}.${number}` | `E.${number}.${number}` | `G.${number}.${number}` | `S.${number}.${number}` | `0.${number}.${number}` | undefined
+
+    @Property({ default: false })
+    readonly isSilence!: boolean
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/ResponsibilitySchema.ts b/server/data/models/requirements/ResponsibilitySchema.ts
new file mode 100644
index 00000000..19f5f306
--- /dev/null
+++ b/server/data/models/requirements/ResponsibilitySchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from './RequirementSchema.js';
+
+@Entity({ discriminatorValue: ReqType.RESPONSIBILITY })
+export class ResponsibilityModel extends RequirementModel {
+    declare readonly versions: Collection<ResponsibilityVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.RESPONSIBILITY })
+export class ResponsibilityVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/RoleSchema.ts b/server/data/models/requirements/RoleSchema.ts
new file mode 100644
index 00000000..e7a4eaf9
--- /dev/null
+++ b/server/data/models/requirements/RoleSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { ResponsibilityModel, ResponsibilityVersionsModel } from './ResponsibilitySchema.js';
+
+@Entity({ discriminatorValue: ReqType.ROLE })
+export class Role extends ResponsibilityModel {
+    declare readonly versions: Collection<RoleVersions, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.ROLE })
+export class RoleVersions extends ResponsibilityVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/ScenarioSchema.ts b/server/data/models/requirements/ScenarioSchema.ts
new file mode 100644
index 00000000..f64320f4
--- /dev/null
+++ b/server/data/models/requirements/ScenarioSchema.ts
@@ -0,0 +1,19 @@
+import { Collection, Entity, ManyToOne } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { ExampleModel, ExampleVersionsModel } from "./ExampleSchema.js";
+import { StakeholderModel } from "./StakeholderSchema.js";
+import { OutcomeModel } from "./OutcomeSchema.js";
+
+@Entity({ discriminatorValue: ReqType.SCENARIO })
+export class ScenarioModel extends ExampleModel {
+    declare readonly versions: Collection<ScenarioVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.SCENARIO })
+export class ScenarioVersionsModel extends ExampleVersionsModel {
+    @ManyToOne({ entity: () => StakeholderModel })
+    readonly primaryActor!: StakeholderModel;
+
+    @ManyToOne({ entity: () => OutcomeModel })
+    readonly outcome!: OutcomeModel;
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/SilenceSchema.ts b/server/data/models/requirements/SilenceSchema.ts
new file mode 100644
index 00000000..06940533
--- /dev/null
+++ b/server/data/models/requirements/SilenceSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from "./RequirementSchema.js";
+
+@Entity({ discriminatorValue: ReqType.SILENCE })
+export class SilenceModel extends RequirementModel {
+    declare readonly versions: Collection<SilenceVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.SILENCE })
+export class SilenceVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/SolutionSchema.ts b/server/data/models/requirements/SolutionSchema.ts
new file mode 100644
index 00000000..aeaca558
--- /dev/null
+++ b/server/data/models/requirements/SolutionSchema.ts
@@ -0,0 +1,14 @@
+import { Collection, Entity, Property } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from './RequirementSchema.js';
+
+@Entity({ discriminatorValue: ReqType.SOLUTION })
+export class SolutionModel extends RequirementModel {
+    declare readonly versions: Collection<SolutionVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.SOLUTION })
+export class SolutionVersionsModel extends RequirementVersionsModel {
+    @Property()
+    readonly slug!: string
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/StakeholderSchema.ts b/server/data/models/requirements/StakeholderSchema.ts
new file mode 100644
index 00000000..6e73d2b4
--- /dev/null
+++ b/server/data/models/requirements/StakeholderSchema.ts
@@ -0,0 +1,24 @@
+import { Collection, Entity, Enum, Property } from '@mikro-orm/core';
+import { StakeholderCategory, StakeholderSegmentation } from '../../../../domain/requirements/index.js';
+import { ComponentModel, ComponentVersionsModel } from './ComponentSchema.js';
+import { ReqType } from "./ReqType.js";
+
+@Entity({ discriminatorValue: ReqType.STAKEHOLDER })
+export class StakeholderModel extends ComponentModel {
+    declare readonly versions: Collection<StakeholderVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.STAKEHOLDER })
+export class StakeholderVersionsModel extends ComponentVersionsModel {
+    @Enum({ items: () => StakeholderSegmentation })
+    readonly segmentation!: StakeholderSegmentation
+
+    @Enum({ items: () => StakeholderCategory })
+    readonly category!: StakeholderCategory
+
+    @Property({ check: 'availability >= 0 AND availability <= 100' })
+    readonly availability!: number
+
+    @Property({ check: 'influence >= 0 AND influence <= 100' })
+    readonly influence!: number
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/SystemComponentSchema.ts b/server/data/models/requirements/SystemComponentSchema.ts
new file mode 100644
index 00000000..7e60f1c2
--- /dev/null
+++ b/server/data/models/requirements/SystemComponentSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from "@mikro-orm/core";
+import { ReqType } from "./ReqType.js";
+import { ComponentModel, ComponentVersionsModel } from "./ComponentSchema.js";
+
+@Entity({ discriminatorValue: ReqType.SYSTEM_COMPONENT })
+export class SystemComponentModel extends ComponentModel {
+    declare readonly versions: Collection<SystemComponentVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.SYSTEM_COMPONENT })
+export class SystemComponentVersionsModel extends ComponentVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/TaskSchema.ts b/server/data/models/requirements/TaskSchema.ts
new file mode 100644
index 00000000..0114ae18
--- /dev/null
+++ b/server/data/models/requirements/TaskSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from './RequirementSchema.js';
+
+@Entity({ discriminatorValue: ReqType.TASK })
+export class TaskModel extends RequirementModel {
+    declare readonly versions: Collection<TaskVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.TASK })
+export class TaskVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/TestCaseSchema.ts b/server/data/models/requirements/TestCaseSchema.ts
new file mode 100644
index 00000000..936cbc89
--- /dev/null
+++ b/server/data/models/requirements/TestCaseSchema.ts
@@ -0,0 +1,11 @@
+import { Collection, Entity } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { RequirementModel, RequirementVersionsModel } from './RequirementSchema.js';
+
+@Entity({ discriminatorValue: ReqType.TEST_CASE })
+export class TestCaseModel extends RequirementModel {
+    declare readonly versions: Collection<TestCaseVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.TEST_CASE })
+export class TestCaseVersionsModel extends RequirementVersionsModel { }
\ No newline at end of file
diff --git a/server/data/models/requirements/UseCaseSchema.ts b/server/data/models/requirements/UseCaseSchema.ts
new file mode 100644
index 00000000..fc302ade
--- /dev/null
+++ b/server/data/models/requirements/UseCaseSchema.ts
@@ -0,0 +1,34 @@
+import { Collection, Entity, ManyToOne, Property } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { ScenarioModel, ScenarioVersionsModel } from './ScenarioSchema.js';
+import { AssumptionModel } from './AssumptionSchema.js';
+import { EffectModel } from './EffectSchema.js';
+
+@Entity({ discriminatorValue: ReqType.USE_CASE })
+export class UseCaseModel extends ScenarioModel {
+    declare readonly versions: Collection<UseCaseVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.USE_CASE })
+export class UseCaseVersionsModel extends ScenarioVersionsModel {
+    @Property()
+    readonly scope!: string
+
+    @Property()
+    readonly level!: string
+
+    @ManyToOne({ entity: () => AssumptionModel })
+    readonly precondition!: AssumptionModel
+
+    @Property({ type: 'uuid' })
+    readonly triggerId!: string
+
+    @Property()
+    readonly mainSuccessScenario!: string
+
+    @ManyToOne({ entity: () => EffectModel })
+    readonly successGuarantee!: EffectModel
+
+    @Property({ type: 'string' })
+    readonly extensions!: string
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/UserStorySchema.ts b/server/data/models/requirements/UserStorySchema.ts
new file mode 100644
index 00000000..cac48874
--- /dev/null
+++ b/server/data/models/requirements/UserStorySchema.ts
@@ -0,0 +1,15 @@
+import { Collection, Entity, ManyToOne } from '@mikro-orm/core';
+import { ReqType } from "./ReqType.js";
+import { ScenarioModel, ScenarioVersionsModel } from './ScenarioSchema.js';
+import { FunctionalBehaviorModel } from './FunctionalBehaviorSchema.js';
+
+@Entity({ discriminatorValue: ReqType.USER_STORY })
+export class UserStoryModel extends ScenarioModel {
+    declare readonly versions: Collection<UserStoryVersionsModel, object>;
+}
+
+@Entity({ discriminatorValue: ReqType.USER_STORY })
+export class UserStoryVersionsModel extends ScenarioVersionsModel {
+    @ManyToOne({ entity: () => FunctionalBehaviorModel })
+    readonly functionalBehavior!: FunctionalBehaviorModel
+}
\ No newline at end of file
diff --git a/server/data/models/requirements/index.ts b/server/data/models/requirements/index.ts
new file mode 100644
index 00000000..2787f61e
--- /dev/null
+++ b/server/data/models/requirements/index.ts
@@ -0,0 +1,38 @@
+export * from './RequirementSchema.js';
+export * from './AssumptionSchema.js';
+export * from './ConstraintSchema.js';
+export * from './OrganizationSchema.js';
+export * from './SolutionSchema.js';
+export * from './ParsedRequirementSchema.js';
+export * from './MetaRequirementSchema.js';
+export * from './ActorSchema.js';
+export * from './ComponentSchema.js';
+export * from './StakeholderSchema.js';
+export * from './BehaviorSchema.js';
+export * from './EffectSchema.js';
+export * from './EnvironmentComponentSchema.js';
+export * from './ExampleSchema.js';
+export * from './FunctionalitySchema.js';
+export * from './FunctionalBehaviorSchema.js';
+export * from './GlossaryTermSchema.js';
+export * from './GoalSchema.js';
+export * from './InvariantSchema.js';
+export * from './LimitSchema.js';
+export * from './JustificationSchema.js';
+export * from './NoiseSchema.js';
+export * from './HintSchema.js';
+export * from './NonFunctionalBehaviorSchema.js';
+export * from './ObstacleSchema.js';
+export * from './OutcomeSchema.js';
+export * from './PersonSchema.js';
+export * from './ProductSchema.js';
+export * from './ResponsibilitySchema.js';
+export * from './RoleSchema.js';
+export * from './ScenarioSchema.js';
+export * from './EpicSchema.js';
+export * from './SilenceSchema.js';
+export * from './SystemComponentSchema.js';
+export * from './TaskSchema.js';
+export * from './TestCaseSchema.js';
+export * from './UseCaseSchema.js';
+export * from './UserStorySchema.js';
\ No newline at end of file
diff --git a/server/data/orm.ts b/server/data/orm.ts
deleted file mode 100644
index 70c73e8c..00000000
--- a/server/data/orm.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { MikroORM } from '@mikro-orm/postgresql'
-import config from '../../mikro-orm.config.js'
-
-const orm = await MikroORM.init(config),
-    fork = () => orm.em.fork()
-
-export { orm, fork }
\ No newline at end of file
diff --git a/server/data/repositories/AppUserRepository.ts b/server/data/repositories/AppUserRepository.ts
new file mode 100644
index 00000000..a20fe0c0
--- /dev/null
+++ b/server/data/repositories/AppUserRepository.ts
@@ -0,0 +1,80 @@
+import { AppUser } from "~/domain/application";
+import { Repository } from "./Repository";
+import { AppUserModel, AppUserOrganizationRoleModel, OrganizationModel } from "../models";
+import { Organization } from "~/domain/requirements";
+
+export class AppUserRepository extends Repository<AppUser> {
+    /**
+     * Get the app user by id.
+     * Note: The 'role' will not be populated. Use the OrganizationInteractor methods if you need the associated role.
+     * @param id - The id of the app user
+     * @returns The app user
+     * @throws {Error} If the user does not exist
+     */
+    async getUserById(id: AppUser['id']): Promise<AppUser> {
+        const em = this._fork()
+
+        const user = await em.findOneOrFail(AppUserModel, {
+            id,
+            latestVersion: { isDeleted: false }
+        })
+
+        const latestVersion = user.latestVersion?.getEntity()
+
+        if (latestVersion == undefined)
+            throw new Error(`User with id ${id} does not exist`)
+
+        return new AppUser({
+            id: user.id,
+            creationDate: user.creationDate,
+            lastLoginDate: latestVersion.lastLoginDate,
+            effectiveFrom: latestVersion.effectiveFrom,
+            email: latestVersion.email,
+            isDeleted: latestVersion.isDeleted,
+            isSystemAdmin: latestVersion.isSystemAdmin,
+            name: latestVersion.name,
+            // Roles are associated with organizations, not users
+            role: undefined
+        })
+    }
+
+    /**
+     * Returns all organization ids associated with the app user
+     * @param appUserId - The id of the app user
+     * @returns The organizations associated with the app user
+     */
+    async getUserOrganizationIds(appUserId: AppUser['id']): Promise<Organization['id'][]> {
+        const em = this._fork()
+
+        const auors = (await em.find(AppUserOrganizationRoleModel, {
+            appUser: appUserId,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(auor => auor.latestVersion != undefined)
+
+        const organizationIds = auors.map(auor => auor.organization.id)
+
+        const organizations = (await em.find(OrganizationModel, {
+            id: { $in: organizationIds },
+            latestVersion: { isDeleted: false }
+        }))
+            .filter(org => org.latestVersion != undefined)
+
+        return organizations.map(org => org.id)
+    }
+
+    /**
+     * Checks if the specified app user exists
+     */
+    async hasUser(id: AppUser['id']): Promise<boolean> {
+        const em = this._fork(),
+            user = await em.findOne(AppUserModel, {
+                id,
+                latestVersion: { isDeleted: false }
+            })
+
+        return user != undefined && user.latestVersion?.getEntity() != undefined
+    }
+}
\ No newline at end of file
diff --git a/server/data/repositories/OrganizationRepository.test.ts b/server/data/repositories/OrganizationRepository.test.ts
new file mode 100644
index 00000000..f1225ac0
--- /dev/null
+++ b/server/data/repositories/OrganizationRepository.test.ts
@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import { OrganizationRepository } from './OrganizationRepository';
+
+// TODO: pglite wanted for testing
+// https://github.com/mikro-orm/mikro-orm/discussions/5945
+
+describe('OrganizationRepository', () => {
+
+})
\ No newline at end of file
diff --git a/server/data/repositories/OrganizationRepository.ts b/server/data/repositories/OrganizationRepository.ts
new file mode 100644
index 00000000..0ca7e621
--- /dev/null
+++ b/server/data/repositories/OrganizationRepository.ts
@@ -0,0 +1,983 @@
+import { raw } from "@mikro-orm/postgresql";
+import { AppUser, AppUserOrganizationRole } from "~/domain/application";
+import * as req from "~/domain/requirements";
+import * as reqModels from "../models/requirements";
+import { AppUserModel, AppUserOrganizationRoleModel, AppUserOrganizationRoleVersionsModel } from "../models/application";
+import { BelongsModel, BelongsVersionsModel } from "../models/relations";
+import { pascalCaseToSnakeCase, slugify, snakeCaseToCamelCase } from "#shared/utils";
+import { ReqType } from "../models/requirements/ReqType";
+import { v7 as uuid7 } from 'uuid'
+import { AuditMetadata } from "~/domain/AuditMetadata";
+import { Repository } from "./Repository";
+import { ReqQueryToModelQuery } from "../mappers/ReqQueryToModelQuery";
+import { DataModelToDomainModel } from "../mappers/DataModelToDomainModel";
+
+export type CreationInfo = {
+    createdById: AppUser['id']
+    effectiveDate: Date
+}
+
+export type UpdationInfo = {
+    modifiedById: AppUser['id']
+    modifiedDate: Date
+}
+
+export type DeletionInfo = {
+    deletedById: AppUser['id']
+    deletedDate: Date
+}
+
+// TODO: parameterize the repository type
+export class OrganizationRepository extends Repository<req.Organization> {
+    private _organizationId?: req.Organization['id']
+    private _organizationSlug?: req.Organization['slug']
+    /** This is not readonly because it can be reassigned in {@link #deleteOrganization} */
+    private _organization: Promise<req.Organization>
+
+    /**
+     * Constructs a new OrganizationRepository instance
+     *
+     * @param props - The properties to utilize
+     * @param props.config - The MikroORM configuration to utilize
+     * @param [props.organizationId] - The id of the organization to utilize
+     * @param [props.organizationSlug] - The slug of the organization to utilize
+     */
+    constructor(options: ConstructorParameters<typeof Repository>[0] & {
+        organizationId?: req.Organization['id'],
+        organizationSlug?: req.Organization['slug']
+    }) {
+        super({ config: options.config })
+
+        const { organizationId, organizationSlug } = options
+
+        this._organizationId = organizationId
+        this._organizationSlug = organizationSlug
+        this._organization = this._getOrganization()
+    }
+
+    /**
+     * Associates an app user with the organization with the specified role
+     * @param auor.appUserId - The id of the app user
+     * @param auor.organizationId - The id of the organization
+     * @param auor.role - The role of the app user in the organization
+     * @throws {Error} If the app user organization role already exists
+     */
+    async addAppUserOrganizationRole(auor: Pick<AppUserOrganizationRole, 'appUserId' | 'role' | 'organizationId'> & CreationInfo): Promise<void> {
+        const em = this._fork(),
+            existingAuor = await em.findOne(AppUserOrganizationRoleModel, {
+                appUser: auor.appUserId,
+                organization: auor.organizationId,
+                latestVersion: { isDeleted: false }
+            }, { populate: ['latestVersion'] }),
+            existingRole = (await existingAuor?.latestVersion?.load())?.role
+
+        if (existingRole === auor.role)
+            throw new Error('App user organization role already exists with the same role')
+
+        em.create(AppUserOrganizationRoleVersionsModel, {
+            appUserOrganizationRole: existingAuor ?? em.create(AppUserOrganizationRoleModel, {
+                appUser: auor.appUserId,
+                organization: auor.organizationId,
+                createdBy: auor.createdById,
+                creationDate: auor.effectiveDate
+            }),
+            role: auor.role,
+            isDeleted: false,
+            effectiveFrom: auor.effectiveDate,
+            modifiedBy: auor.appUserId
+        })
+
+        await em.flush()
+    }
+
+    /**
+     * Adds a new organization
+     * @param props.name - The name of the organization
+     * @param props.description - The description of the organization
+     * @param props.userId - The id of the user creating the organization
+     * @param props.effectiveDate - The effective date of the organization
+     * @returns The id of the organization
+     * @throws {Error} If the organization already exists
+     */
+    async addOrganization(props: Pick<req.Organization, 'name' | 'description'> & CreationInfo): Promise<req.Organization['id']> {
+        const em = this._fork(),
+            existingOrgStatic = await em.findOne(reqModels.OrganizationModel, {
+                latestVersion: {
+                    slug: slugify(name),
+                    isDeleted: false
+                } as reqModels.OrganizationVersionsModel
+            }, {
+                populate: ['latestVersion']
+            }),
+            latestVersion = existingOrgStatic?.latestVersion as reqModels.OrganizationVersionsModel | undefined
+
+        if (latestVersion)
+            throw new Error('Organization already exists with the same name')
+
+        const newId = uuid7()
+
+        em.create(reqModels.OrganizationVersionsModel, {
+            isDeleted: false,
+            effectiveFrom: props.effectiveDate,
+            isSilence: false,
+            slug: slugify(name),
+            name,
+            description: props.description,
+            modifiedBy: props.createdById,
+            requirement: existingOrgStatic ?? em.create(reqModels.OrganizationModel, {
+                id: newId,
+                createdBy: props.createdById,
+                creationDate: props.effectiveDate
+            })
+        })
+
+        await em.flush()
+
+        return newId
+    }
+
+    /**
+     * Adds a new requirement to the organization
+     * @param props.solutionId - The id of the solution to add the requirement to
+     * @param props.ReqClass - The Constructor of the requirement to add
+     * @param props.reqProps - The properties of the requirement to add
+     * @param props.effectiveDate - The effective date of the requirement
+     * @param props.createdById - The id of the user creating the requirement
+     */
+    async addRequirement<RCons extends typeof req.Requirement>(props: CreationInfo & {
+        solutionId: req.Solution['id'],
+        ReqClass: RCons,
+        reqProps: Omit<InstanceType<RCons>, 'reqId' | 'id' | keyof AuditMetadata>
+    }): Promise<InstanceType<RCons>['id']> {
+        const em = this._fork(),
+            newId = uuid7()
+
+        const solution = await this.getSolutionById(props.solutionId)
+
+        if (!solution)
+            throw new Error('Solution does not exist')
+
+        em.create<reqModels.RequirementVersionsModel>((reqModels as any)[`${props.ReqClass.name}VersionsModel`], {
+            id: newId,
+            isDeleted: false,
+            effectiveFrom: props.effectiveDate,
+            modifiedBy: props.createdById,
+            // Silent requirements do not have a reqId as they are not approved to be part of the solution
+            reqId: props.reqProps.isSilence ? undefined : await this.getNextReqId(props.solutionId, props.ReqClass.reqIdPrefix),
+            ...props.reqProps,
+            requirement: em.create<reqModels.RequirementModel>((reqModels as any)[props.ReqClass.name], {
+                id: newId,
+                createdBy: props.createdById,
+                creationDate: props.effectiveDate
+            })
+        })
+
+        // add the relation between the requirement and the solution (Belongs relation)
+        em.create(BelongsVersionsModel, {
+            isDeleted: false,
+            effectiveFrom: props.effectiveDate,
+            modifiedBy: props.createdById,
+            requirementRelation: em.create(BelongsModel, {
+                left: newId,
+                right: props.solutionId,
+                createdBy: props.createdById,
+                creationDate: props.effectiveDate
+            })
+        })
+
+        await em.flush()
+
+        return newId
+    }
+
+    /**
+     * Adds a new solution to the organization
+     * @param props.name - The name of the solution
+     * @param props.description - The description of the solution
+     * @param props.modifiedById - The id of the user creating the solution
+     * @param props.effectiveDate - The effective date of the solution
+     */
+    async addSolution({ name, description, createdById, effectiveDate }: Pick<req.Solution, 'name' | 'description'> & CreationInfo): Promise<req.Solution['id']> {
+        const em = this._fork(),
+            organization = await this.getOrganization(),
+            newId = uuid7()
+
+        em.create(reqModels.SolutionVersionsModel, {
+            isDeleted: false,
+            effectiveFrom: effectiveDate,
+            isSilence: false,
+            slug: slugify(name),
+            name,
+            description,
+            modifiedBy: createdById,
+            requirement: em.create(reqModels.SolutionModel, {
+                id: newId,
+                createdBy: createdById,
+                creationDate: effectiveDate
+            })
+        })
+
+        // add the relation between the solution and the organization
+        em.create(BelongsVersionsModel, {
+            isDeleted: false,
+            effectiveFrom: effectiveDate,
+            modifiedBy: createdById,
+            requirementRelation: em.create(BelongsModel, {
+                left: newId,
+                right: organization.id,
+                createdBy: createdById,
+                creationDate: effectiveDate
+            })
+        })
+
+        await em.flush()
+
+        return newId
+    }
+
+    /**
+     * Deletes an app user organization role
+     * @param auor.appUserId - The id of the app user
+     * @param auor.organizationId - The id of the organization
+     * @param auor.deletedById - The id of the user deleting the app user organization role
+     * @param auor.effectiveDate - The effective date of the deletion
+     * @throws {Error} If the app user organization role does not exist
+     */
+    async deleteAppUserOrganizationRole(auor: Pick<AppUserOrganizationRole, 'appUserId' | 'organizationId'> & DeletionInfo): Promise<void> {
+        const em = this._fork(),
+            existingAuor = await em.findOne(AppUserOrganizationRoleModel, {
+                appUser: auor.appUserId,
+                organization: await this.getOrganization(),
+                latestVersion: { isDeleted: false }
+            }, { populate: ['latestVersion'] })
+
+        if (!existingAuor || !existingAuor.latestVersion)
+            throw new Error('App user organization role does not exist')
+
+        em.create(AppUserOrganizationRoleVersionsModel, {
+            ...existingAuor.latestVersion.get(),
+            isDeleted: true,
+            effectiveFrom: auor.deletedDate,
+            modifiedBy: auor.deletedById
+        })
+
+        await em.flush()
+    }
+
+    /**
+     * Deletes the organization
+     * @param props.deletedById - The id of the user deleting the organization
+     * @throws {Error} If the organization does not exist
+     */
+    async deleteOrganization(props: DeletionInfo): Promise<void> {
+        const em = this._fork(),
+            { id, slug, name, description } = await this.getOrganization()
+
+        em.create(reqModels.OrganizationVersionsModel, {
+            isDeleted: true,
+            effectiveFrom: props.deletedDate,
+            isSilence: false,
+            slug,
+            name,
+            description,
+            modifiedBy: props.deletedById,
+            requirement: await em.findOneOrFail(reqModels.OrganizationModel, { id })
+        })
+
+        // delete all AppUserOrganizationRoles associated with the organization
+        const orgUsers = await this.getOrganizationAppUsers()
+
+        await Promise.all(orgUsers.map(user => this.deleteAppUserOrganizationRole({
+            appUserId: user.id,
+            organizationId: id,
+            deletedById: props.deletedById,
+            deletedDate: props.deletedDate
+        })))
+
+        // delete all solutions associated with the organization
+        const orgSolutions = await this.findSolutions({})
+
+        await Promise.all(orgSolutions.map(sol => this.deleteSolutionBySlug({
+            deletedById: props.deletedById,
+            slug: sol.slug,
+            deletedDate: props.deletedDate
+        })))
+
+        await em.flush()
+
+        this._organization = this._getOrganization()
+    }
+
+    /**
+     * Deletes a solution by slug
+     * @param props.deletedById - The id of the user deleting the solution
+     * @param props.slug - The slug of the solution to delete
+     * @throws {Error} If the solution does not exist
+     * @throws {Error} If the solution does not belong to the organization
+     */
+    async deleteSolutionBySlug(props: DeletionInfo & Pick<req.Solution, 'slug'>): Promise<void> {
+        const em = this._fork(),
+            solution = await this.getSolutionBySlug(props.slug)
+
+        em.create(reqModels.SolutionVersionsModel, {
+            isDeleted: true,
+            effectiveFrom: props.deletedDate,
+            isSilence: false,
+            slug: solution.slug,
+            name: solution.name,
+            description: solution.description,
+            modifiedBy: props.deletedById,
+            requirement: await em.findOneOrFail(reqModels.SolutionModel, { id: solution.id })
+        })
+
+        // delete all requirements associated with the solution
+
+        const reqIdTypesInSolution = (await em.find(BelongsModel, {
+            right: solution.id,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(rel => rel.latestVersion != undefined)
+            .map(rel => ({
+                id: rel.latestVersion!.get().requirementRelation.left.id,
+                req_type: rel.latestVersion!.get().requirementRelation.left.req_type
+            }))
+
+        // The keys representing the requirement classes in the req module
+        type RCons = keyof { [K in keyof typeof req]: typeof req[K] extends typeof req.Requirement ? K : never }
+
+        await Promise.all(reqIdTypesInSolution.map(reqIdType => this.deleteSolutionRequirementById({
+            id: reqIdType.id,
+            deletedById: props.deletedById,
+            deletedDate: props.deletedDate,
+            solutionId: solution.id,
+            ReqClass: req[snakeCaseToCamelCase(reqIdType.req_type) as RCons] as typeof req.Requirement
+        })))
+
+        await em.flush()
+    }
+
+    /**
+     * Deletes a requirement belonging to a solution by id
+     * @param props.deletedById - The id of the user deleting the requirement
+     * @param props.effectiveDate - The effective date of the deletion
+     * @param props.id - The id of the requirement to delete
+     * @param props.solutionId - The id of the solution the requirement belongs to
+     * @param props.ReqClass - The Constructor of the requirement to delete
+     * @throws {Error} If the requirement does not exist
+     * @throws {Error} If the requirement does not belong to the solution
+     * @throws {Error} If the solution does not exist
+     */
+    async deleteSolutionRequirementById<RCons extends typeof req.Requirement>(
+        props: DeletionInfo & {
+            id: string,
+            solutionId: string,
+            ReqClass: RCons
+        }
+    ): Promise<void> {
+        // delete the requirement associated with the solution by creating a new version with isDeleted set to true
+        const em = this._fork()
+
+        const existingReq = await em.findOneOrFail<reqModels.RequirementModel, 'latestVersion'>(
+            reqModels[`${props.ReqClass.name}Model` as keyof typeof reqModels], {
+            id: props.id,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        })
+
+        if (!existingReq.latestVersion)
+            throw new Error(`Requirement does not exist with id ${props.id}`)
+
+        // "delete" the requirement by creating a new version with isDeleted set to true
+        em.create<reqModels.RequirementVersionsModel>(
+            reqModels[`${props.ReqClass.name}VersionsModel` as keyof typeof reqModels], {
+            ...existingReq.latestVersion.get(),
+            isDeleted: true
+        })
+
+        // "delete" the relation between the requirement and the solution (Belongs relation)
+        const rel = await em.findOneOrFail(BelongsModel, {
+            left: props.id,
+            right: props.solutionId,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        })
+
+        if (!rel.latestVersion)
+            throw new Error(`Requirement does not belong to solution with id ${props.solutionId}`)
+
+        em.create(BelongsVersionsModel, {
+            ...rel.latestVersion.get(),
+            isDeleted: true
+        })
+
+        await em.flush()
+    }
+
+    /**
+     * Find solutions that match the query parameters for an organization
+     *
+     * @param query The query parameters to filter solutions by
+     * @returns The solutions that match the query parameters
+     */
+    async findSolutions(query: Partial<req.Solution>): Promise<req.Solution[]> {
+        const em = this._fork(),
+            organizationId = (await this.getOrganization()).id
+
+        const belongsModels = (await em.find(BelongsModel, {
+            left: {
+                ...(query.id ? { id: query.id } : {}),
+                req_type: ReqType.SOLUTION
+            },
+            right: { id: organizationId, req_type: ReqType.ORGANIZATION },
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(belongs => belongs.latestVersion != undefined)
+            .map(belongs => belongs.latestVersion!.get().requirementRelation.left.id)
+
+        if (belongsModels.length === 0 && query.id !== undefined)
+            throw new Error('Solution does not exist in the organization')
+
+        const solutionModels = (await em.find(reqModels.SolutionModel, {
+            id: { $in: belongsModels },
+            ...(query.createdById ? { createdBy: query.createdById } : {}),
+            ...(query.creationDate ? { creationDate: query.creationDate } : {}),
+            latestVersion: {
+                isDeleted: false,
+                ...new ReqQueryToModelQuery().map(query)
+            }
+        }, {
+            populate: ['latestVersion']
+        })).filter(sol => sol.latestVersion != undefined)
+
+        return solutionModels.map(sol => new req.Solution(new DataModelToDomainModel().map(sol)))
+    }
+
+    /**
+     * Find app user organization roles that match the query parameters for an organization
+     * @param query - The query parameters to filter app user organization roles by
+     * @returns The app user organization roles that match the query parameters
+     */
+    async findAppUserOrganizationRoles(query: Partial<Omit<AppUserOrganizationRole, 'organizationId'>>): Promise<AppUserOrganizationRole[]> {
+        const em = this._fork(),
+            organizationId = (await this.getOrganization()).id
+
+        const auors = (await em.find(AppUserOrganizationRoleModel, {
+            organization: organizationId,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(auor => auor.latestVersion != undefined)
+
+        return auors.map(auor => {
+            const auorv = auor.latestVersion!.get()
+
+            return new AppUserOrganizationRole({
+                appUserId: auor.appUser.id,
+                organizationId,
+                role: auorv.role,
+                isDeleted: auorv.isDeleted,
+                createdById: auor.createdBy.id,
+                modifiedById: auorv.modifiedBy.id,
+                creationDate: auor.creationDate,
+                lastModified: auorv.effectiveFrom
+            })
+        })
+    }
+
+    /**
+     * Find requirements that match the query parameters for a solution
+     *
+     * @param props.solutionId - The id of the solution to find the requirements for
+     * @param props.ReqClass - The Constructor of the requirement to find
+     * @param props.query - The query parameters to filter requirements by
+     * @returns The requirements that match the query parameters
+     * @throws {Error} If the solution does not exist in the organization
+     */
+    async findSolutionRequirementsByType<RCons extends typeof req.Requirement>(props: {
+        solutionId: req.Solution['id'],
+        ReqClass: RCons,
+        query: Partial<InstanceType<RCons>>
+    }): Promise<InstanceType<RCons>[]> {
+        const em = this._fork()
+
+        const reqsInSolution = (await em.find(BelongsModel, {
+            left: {
+                req_type: pascalCaseToSnakeCase(props.ReqClass.name) as ReqType,
+                ...(props.query.id ? { id: props.query.id } : {})
+            },
+            right: { id: props.solutionId, req_type: ReqType.SOLUTION },
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(rel => rel.latestVersion != undefined)
+            .map(rel => rel.latestVersion!.get().requirementRelation.left.id)
+
+        if (reqsInSolution.length === 0 && props.query.id !== undefined)
+            throw new Error('Requirement does not exist in the solution')
+
+        const requirementModels = (await em.find<reqModels.RequirementModel, 'latestVersion'>((reqModels as any)[`${props.ReqClass.name}Model`], {
+            id: { $in: reqsInSolution },
+            ...(props.query.createdById ? { createdBy: props.query.createdById } : {}),
+            ...(props.query.creationDate ? { creationDate: props.query.creationDate } : {}),
+            latestVersion: {
+                isDeleted: false,
+                ...new ReqQueryToModelQuery().map(props.query)
+            }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(req => req.latestVersion != undefined)
+
+        return requirementModels.map(req => new props.ReqClass(new DataModelToDomainModel().map(req))) as InstanceType<RCons>[]
+    }
+
+    /**
+     * Returns the AppUserOrganizationRole for the given app user and organization
+     * @param props.appUserId - The id of the app user
+     * @returns The AppUserOrganizationRole
+     * @throws {Error} If the app user organization role does not exist
+     */
+    async getAppUserOrganizationRole(appUserId: AppUser['id']): Promise<AppUserOrganizationRole> {
+        const organizationId = (await this.getOrganization()).id,
+            em = this._fork()
+
+        const auor = await em.findOne(AppUserOrganizationRoleModel, {
+            appUser: appUserId,
+            organization: organizationId
+        }, {
+            populate: ['versions'],
+            populateFilter: {
+                versions: {
+                    effectiveFrom: {
+                        $eq: raw(`(SELECT MAX(effective_from)
+                            FROM app_user_organization_role_versions
+                            WHERE app_user_organization_role_id = app_user_organization_role.id AND effective_from <= now())`)
+                    },
+                    isDeleted: false
+                }
+            }
+        })
+
+        if (!auor || !auor.versions[0])
+            throw new Error('App user organization role does not exist')
+
+        const auorv = auor.versions[0]
+
+        return new AppUserOrganizationRole({
+            appUserId,
+            organizationId,
+            role: auorv.role,
+            isDeleted: auorv.isDeleted,
+            createdById: auor.createdBy.id,
+            modifiedById: auorv.modifiedBy.id,
+            creationDate: auor.creationDate,
+            lastModified: auorv.effectiveFrom
+        })
+    }
+
+    /**
+     * Gets the organization
+     * @returns The organization
+     * @throws {Error} If the organization does not exist
+     */
+    async getOrganization(): Promise<req.Organization> {
+        return this._organization
+    }
+
+    /**
+     * Gets all organizations
+     * @returns The organizations
+     */
+    async getAllOrganizations(): Promise<req.Organization[]> {
+        const em = this._fork()
+
+        const organizations = (await em.find(reqModels.OrganizationModel, {
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(org => org.latestVersion != undefined)
+
+        return organizations.map(org => new req.Organization(new DataModelToDomainModel().map(org)))
+    }
+
+    /**
+     * Gets an organization by id or slug
+     * @returns The organization
+     * @throws {Error} If the organization does not exist
+     */
+    private async _getOrganization(): Promise<req.Organization> {
+        const em = this._fork();
+
+        const organizationId = this._organizationId,
+            organizationSlug = this._organizationSlug
+
+        if (!organizationId && !organizationSlug)
+            throw new Error('Organization id or slug must be provided')
+
+        const result = await em.findOne(reqModels.OrganizationModel, {
+            ...(organizationId ? { id: organizationId } : {}),
+            latestVersion: {
+                ...(organizationSlug ? { slug: organizationSlug } : {}),
+                isDeleted: false
+            }
+        }, {
+            populate: ['latestVersion']
+        })
+
+        if (!result || !result.latestVersion)
+            throw new Error('Organization does not exist')
+
+        return new req.Organization(new DataModelToDomainModel().map(result))
+    }
+
+    /**
+     * Get an organization user by id
+     *
+     * @param props.id The id of the app user to get
+     * @returns The app user
+     * @throws {Error} If the organization does not exist
+     * @throws {Error} If the app user does not exist in the organization
+     */
+    async getOrganizationAppUserById(id: AppUser['id']): Promise<AppUser> {
+        const em = this._fork(),
+            organizationId = (await this.getOrganization()).id
+
+        const auor = await em.findOne(AppUserOrganizationRoleModel, {
+            appUser: id,
+            organization: organizationId,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        })
+
+        if (!auor || !auor.latestVersion)
+            throw new Error('App user does not exist in the organization')
+
+        const auorv = auor.latestVersion.get()
+
+        const user = await em.findOne(AppUserModel, {
+            id,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        })
+
+        if (!user || !user.latestVersion)
+            throw new Error('App user does not exist')
+
+        const userv = user.latestVersion.get()
+
+        return new AppUser({
+            id,
+            name: userv.name,
+            email: userv.email,
+            isSystemAdmin: userv.isSystemAdmin,
+            lastLoginDate: userv.lastLoginDate,
+            creationDate: user.creationDate,
+            effectiveFrom: auorv.effectiveFrom,
+            isDeleted: auorv.isDeleted,
+            role: auorv.role
+        })
+    }
+
+    /**
+     * Gets the next requirement id for the given solution and prefix
+     *
+     * @param solutionId - The id of the solution
+     * @param prefix - The prefix for the requirement id. Ex: 'P.1.'
+     * @returns The next requirement id
+     * @throws {Error} If the solution does not exist
+     */
+    async getNextReqId<R extends typeof req.Requirement>(solutionId: req.Solution['id'], prefix: R['reqIdPrefix']): Promise<InstanceType<R>['reqId']> {
+        const em = this._fork()
+
+        const reqsBelongingToSolution = (await em.find(BelongsModel, {
+            right: solutionId,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(rel => rel.latestVersion != undefined)
+            .map(rel => rel.latestVersion!.get().requirementRelation.left.id)
+
+        if (reqsBelongingToSolution.length === 0)
+            return `${prefix}1`
+
+        const reqs = (await em.find(reqModels.RequirementModel, {
+            id: { $in: reqsBelongingToSolution },
+            latestVersion: {
+                isDeleted: false,
+                reqId: { $like: `${prefix}%` }
+            }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(req => req.latestVersion != undefined)
+            .map(req => req.latestVersion!.get().reqId)
+
+        const count = reqs.length
+
+        if (count === 0)
+            return `${prefix}1`
+
+        return `${prefix}${count + 1}`
+    }
+
+    /**
+     * Gets all AppUsers for the organization
+     * @throws {Error} If the organization does not exist
+     * @returns The AppUsers for the organization
+     */
+    async getOrganizationAppUsers(): Promise<AppUser[]> {
+        const em = this._fork(),
+            organizationId = (await this.getOrganization()).id
+
+        const auors = (await em.find(AppUserOrganizationRoleModel, {
+            organization: organizationId,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(auor => auor.latestVersion != undefined)
+
+        const appUserIds = auors.map(auor => auor.appUser.id)
+
+        const appUsers = (await em.find(AppUserModel, {
+            id: { $in: appUserIds },
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+            .filter(user => user.latestVersion != undefined)
+
+        return appUsers.map(user => {
+            const userv = user.latestVersion!.get(),
+                auor = auors.find(auor => auor.appUser.id === user.id),
+                auorv = auor!.latestVersion!.get()
+
+            return new AppUser({
+                id: user.id,
+                name: userv.name,
+                email: userv.email,
+                isSystemAdmin: userv.isSystemAdmin,
+                lastLoginDate: userv.lastLoginDate,
+                creationDate: user.creationDate,
+                effectiveFrom: auorv.effectiveFrom,
+                isDeleted: auorv.isDeleted,
+                role: auorv.role
+            })
+        })
+    }
+
+    /**
+     * Gets a solution by id belonging to the organization
+     * @param solutionId - The id of the solution to get
+     * @returns The solution
+     * @throws {Error} If the solution does not exist in the organization
+     */
+    async getSolutionById(solutionId: req.Solution['id']): Promise<req.Solution> {
+        return (await this.findSolutions({ id: solutionId }))[0]
+    }
+
+    /**
+     * Gets a solution by slug belonging to the organization
+     * @param solutionSlug - The slug of the solution to get
+     * @returns The solution
+     * @throws {Error} If the solution does not exist in the organization
+     * @throws {Error} If the solution does not exist
+     */
+    async getSolutionBySlug(solutionSlug: req.Solution['slug']): Promise<req.Solution> {
+        return (await this.findSolutions({ slug: solutionSlug }))[0]
+    }
+
+    /**
+     * Gets a requirement by id belonging to the organization solution
+     * @param props.id - The id of the requirement to get
+     * @param props.ReqClass - The class of the requirement to get
+     * @param props.solutionId - The id of the solution to get the requirement from
+     * @returns The requirement
+     * @throws {Error} If the requirement does not exist in the organization nor the solution
+     */
+    async getSolutionRequirementById<RCons extends typeof req.Requirement>(props: {
+        id: req.Requirement['id'],
+        solutionId: req.Solution['id'],
+        ReqClass: RCons,
+    }): Promise<InstanceType<RCons>> {
+        const requirement = (await this.findSolutionRequirementsByType({
+            solutionId: props.solutionId,
+            ReqClass: props.ReqClass,
+            query: { id: props.id } as Partial<InstanceType<RCons>>
+        }))[0]
+
+        if (!requirement)
+            throw new Error('Requirement does not exist in the organization nor the solution')
+
+        return requirement
+    }
+
+    /**
+     * Checks if the solution has the specified requirement
+     * @param props.solutionId - The id of the solution
+     * @param props.id - The id of the requirement
+     * @returns Whether the organization has the requirement
+     */
+    async solutionHasRequirement(props: {
+        solutionId: req.Solution['id'],
+        id: req.Requirement['id']
+    }): Promise<boolean> {
+        const em = this._fork()
+
+        const reqInSolution = (await em.findOne(BelongsModel, {
+            left: { id: props.id },
+            right: props.solutionId,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        }))
+
+        return reqInSolution != undefined && reqInSolution.latestVersion != undefined
+    }
+
+    /**
+     * Updates the role of an app user in the organization
+     * @param props - The properties of the app user organization role to update
+     * @throws {Error} If the app user organization role does not exist
+     */
+    async updateAppUserRole(props: Pick<AppUserOrganizationRole, 'appUserId' | 'role'> & UpdationInfo): Promise<void> {
+        const existingAuor = await this.getAppUserOrganizationRole(props.appUserId)
+
+        if (existingAuor.role === props.role)
+            return
+
+        const em = this._fork()
+
+        em.create(AppUserOrganizationRoleVersionsModel, {
+            isDeleted: false,
+            effectiveFrom: props.modifiedDate,
+            modifiedBy: props.modifiedById,
+            role: props.role,
+            appUserOrganizationRole: await em.findOneOrFail(AppUserOrganizationRoleModel, {
+                appUser: props.appUserId,
+                organization: await this.getOrganization()
+            })
+        })
+
+        await em.flush()
+    }
+
+    /**
+     * Updates a requirement by id
+     * @param props.solutionId - The id of the solution the requirement belongs to
+     * @param props.requirementId - The id of the requirement to update
+     * @param props.ReqClass - The Constructor of the requirement to update
+     * @param props.reqProps - The properties of the requirement to update
+     * @param props.modifiedById - The id of the user updating the requirement
+     * @param props.modifiedDate - The effective date of the update
+     * @throws {Error} If the requirement does not exist
+     * @throws {Error} If the requirement does not belong to the solution
+     * @throws {Error} If the solution does not exist
+     */
+    async updateSolutionRequirement<RCons extends typeof req.Requirement>(props: UpdationInfo & {
+        solutionId: req.Solution['id'],
+        requirementId: req.Requirement['id'],
+        ReqClass: RCons,
+        reqProps: Omit<Partial<InstanceType<RCons>>, 'id' | 'reqId' | keyof AuditMetadata>
+    }): Promise<void> {
+        const em = this._fork()
+
+        const existingSolution = await this.getSolutionById(props.solutionId)
+
+        const existingReq = await em.findOneOrFail<reqModels.RequirementModel, 'latestVersion'>(
+            reqModels[`${props.ReqClass.name}Model` as keyof typeof reqModels], {
+            id: props.requirementId,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        })
+
+        if (!existingReq.latestVersion)
+            throw new Error(`Requirement does not exist with id ${props.requirementId}`)
+
+        const rel = await em.findOneOrFail(BelongsModel, {
+            left: props.requirementId,
+            right: existingSolution.id,
+            latestVersion: { isDeleted: false }
+        }, {
+            populate: ['latestVersion']
+        })
+
+        if (!rel.latestVersion)
+            throw new Error(`Requirement does not belong to solution with id ${props.solutionId}`)
+
+        const existingReqv = existingReq.latestVersion.get()
+
+        em.create<reqModels.RequirementVersionsModel>(
+            reqModels[`${props.ReqClass.name}VersionsModel` as keyof typeof reqModels], {
+            ...existingReqv,
+            ...props.reqProps,
+            effectiveFrom: props.modifiedDate,
+            modifiedBy: props.modifiedById,
+            isDeleted: false
+        })
+
+        await em.flush()
+    }
+
+
+    /**
+     * Updates a solution by slug
+     * @param props.slug - The slug of the solution to update
+     * @param props - The properties to update
+     * @throws {Error} If the solution does not exist
+     * @throws {Error} If the solution does not belong to the organization
+     */
+    async updateSolutionBySlug(slug: req.Solution['slug'], props: Pick<Partial<req.Solution>, 'name' | 'description'> & UpdationInfo): Promise<void> {
+        const em = this._fork(),
+            solution = await this.getSolutionBySlug(slug)
+
+        em.create(reqModels.SolutionVersionsModel, {
+            isDeleted: false,
+            effectiveFrom: props.modifiedDate,
+            isSilence: false,
+            slug: props.name ? slugify(props.name) : solution.slug,
+            name: props.name ?? solution.name,
+            description: props.description ?? solution.description,
+            modifiedBy: props.modifiedById,
+            requirement: await em.findOneOrFail(reqModels.SolutionModel, { id: solution.id })
+        })
+
+        await em.flush()
+    }
+
+    /**
+     * Updates an organization
+     * @param props - The properties to update
+     * @throws {Error} If the organization does not exist
+     */
+    async updateOrganization(props: Pick<Partial<req.Organization>, 'name' | 'description'> & UpdationInfo): Promise<void> {
+        const em = this._fork(),
+            organization = await this.getOrganization()
+
+        em.create(reqModels.OrganizationVersionsModel, {
+            isDeleted: false,
+            effectiveFrom: props.modifiedDate,
+            isSilence: false,
+            slug: props.name ? slugify(props.name) : organization.slug,
+            name: props.name ?? organization.name,
+            description: props.description ?? organization.description,
+            modifiedBy: props.modifiedById,
+            requirement: await em.findOneOrFail(reqModels.OrganizationModel, { id: organization.id })
+        })
+
+        await em.flush()
+    }
+}
\ No newline at end of file
diff --git a/server/data/repositories/Repository.ts b/server/data/repositories/Repository.ts
new file mode 100644
index 00000000..0008b5a1
--- /dev/null
+++ b/server/data/repositories/Repository.ts
@@ -0,0 +1,19 @@
+import { MikroORM, type Options } from "@mikro-orm/postgresql"
+
+/**
+ * A Repository is a class that contains the data access logic for a particular entity
+ */
+// TODO: E should be a type that extends Entity | ValueObject
+// Though more accurately, should be a type that implements Equatable
+export abstract class Repository<E> {
+    private _orm
+
+    constructor(options: { config: Options }) {
+        this._orm = MikroORM.initSync(options.config)
+    }
+
+    /**
+     * Returns new EntityManager instance with its own identity map
+     */
+    protected _fork() { return this._orm.em.fork() }
+}
\ No newline at end of file
diff --git a/server/data/subscribers/AuditSubscriber.ts b/server/data/subscribers/AuditSubscriber.ts
deleted file mode 100644
index 96c1bbfb..00000000
--- a/server/data/subscribers/AuditSubscriber.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { type EventSubscriber, type FlushEventArgs } from "@mikro-orm/core";
-import { AuditLog } from "../../../domain/application/AuditLog.js";
-
-/**
- * The AuditSubscriber class is responsible for
- * tracking changes to entities in the database.
- * @see https://github.com/mikro-orm/mikro-orm/issues/637
- * @see https://mikro-orm.io/docs/events#eventsubscriber
- */
-export default class AuditSubscriber implements EventSubscriber {
-    async onFlush(args: FlushEventArgs): Promise<void> {
-        await Promise.all(
-            args.uow.getChangeSets()
-                // Don't log the log...
-                .filter(cs => !(cs.entity instanceof AuditLog))
-                // Ignore entities that don't have an id
-                // This is not a perfect solution, but it's good enough for now since
-                //   the AuditLog concept is going away soon.
-                .filter(cs => cs.entity.id)
-                .map(async (changeSet) => {
-                    const auditLog = new AuditLog({
-                        type: changeSet.type,
-                        entityId: changeSet.entity.id,
-                        entityName: changeSet.name,
-                        entity: JSON.stringify(changeSet.entity)
-                    });
-
-                    args.uow.computeChangeSet(auditLog)
-                })
-        )
-    }
-}
\ No newline at end of file
diff --git a/server/utils/deleteRequirementHttpHandler.ts b/server/utils/deleteRequirementHttpHandler.ts
index 199b910b..73c19860 100644
--- a/server/utils/deleteRequirementHttpHandler.ts
+++ b/server/utils/deleteRequirementHttpHandler.ts
@@ -1,8 +1,9 @@
 import { z } from "zod"
 import { getServerSession } from '#auth'
 import { OrganizationInteractor } from '~/application'
-import { fork } from "~/server/data/orm.js"
 import { Requirement } from '~/domain/requirements'
+import config from '~/mikro-orm.config'
+import { OrganizationRepository } from "../data/repositories/OrganizationRepository"
 
 const paramSchema = z.object({
     id: z.string().uuid()
@@ -28,10 +29,8 @@ export default function deleteRequirementHttpHandler<RCons extends typeof Requir
             { solutionId, organizationId, organizationSlug } = await validateEventBody(event, bodySchema),
             session = (await getServerSession(event))!,
             organizationInteractor = new OrganizationInteractor({
-                organizationId,
-                organizationSlug,
-                userId: session.id,
-                entityManager: fork()
+                repository: new OrganizationRepository({ config, organizationId, organizationSlug }),
+                userId: session.id
             })
 
         await organizationInteractor.deleteRequirement({ ReqClass, id, solutionId })
diff --git a/server/utils/findRequirementsHttpHandler.ts b/server/utils/findRequirementsHttpHandler.ts
index b9a70682..dfeefe04 100644
--- a/server/utils/findRequirementsHttpHandler.ts
+++ b/server/utils/findRequirementsHttpHandler.ts
@@ -1,8 +1,9 @@
-import { fork } from "~/server/data/orm.js"
+import config from '~/mikro-orm.config'
 import { getServerSession } from '#auth'
 import { OrganizationInteractor } from "~/application"
 import { type ZodObject, z } from "zod"
 import { Requirement } from "~/domain/requirements"
+import { OrganizationRepository } from '../data/repositories/OrganizationRepository'
 
 export default function findRequirementsHttpHandler<
     RCons extends typeof Requirement,
@@ -21,12 +22,10 @@ export default function findRequirementsHttpHandler<
         const { solutionId, organizationId, organizationSlug, ...query } = await validateEventQuery(event, validatedQuerySchema) as any,
             session = (await getServerSession(event))!,
             organizationInteractor = new OrganizationInteractor({
-                userId: session.id,
-                organizationId,
-                organizationSlug,
-                entityManager: fork()
+                repository: new OrganizationRepository({ config, organizationId, organizationSlug }),
+                userId: session.id
             })
 
-        return await organizationInteractor.findRequirements({ solutionId, ReqClass, query })
+        return await organizationInteractor.findSolutionRequirements({ solutionId, ReqClass, query })
     })
 }
\ No newline at end of file
diff --git a/server/utils/getRequirementHttpHandler.ts b/server/utils/getRequirementHttpHandler.ts
index 4e9d4391..89aae2cf 100644
--- a/server/utils/getRequirementHttpHandler.ts
+++ b/server/utils/getRequirementHttpHandler.ts
@@ -2,7 +2,8 @@ import { z } from "zod"
 import { getServerSession } from '#auth'
 import { Requirement } from "~/domain/requirements"
 import { OrganizationInteractor } from '~/application'
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
+import { OrganizationRepository } from "../data/repositories/OrganizationRepository"
 
 const paramSchema = z.object({
     id: z.string().uuid()
@@ -28,12 +29,10 @@ export default function getRequirementHttpHandler<RCons extends typeof Requireme
             { solutionId, organizationId, organizationSlug } = await validateEventQuery(event, querySchema),
             session = (await getServerSession(event))!,
             organizationInteractor = new OrganizationInteractor({
-                userId: session.id,
-                organizationId,
-                organizationSlug,
-                entityManager: fork()
+                repository: new OrganizationRepository({ config, organizationId, organizationSlug }),
+                userId: session.id
             })
 
-        return (await organizationInteractor.getRequirementById({ solutionId, ReqClass, id }))
+        return (await organizationInteractor.getSolutionRequirementById({ solutionId, ReqClass, id }))
     })
 }
\ No newline at end of file
diff --git a/server/utils/postRequirementHttpHandler.ts b/server/utils/postRequirementHttpHandler.ts
index 2eb011e6..21079dcb 100644
--- a/server/utils/postRequirementHttpHandler.ts
+++ b/server/utils/postRequirementHttpHandler.ts
@@ -1,8 +1,9 @@
 import { getServerSession } from '#auth'
 import { Requirement } from "~/domain/requirements"
 import { OrganizationInteractor } from '~/application'
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
 import { z, type ZodObject } from "zod"
+import { OrganizationRepository } from '../data/repositories/OrganizationRepository';
 
 /**
  * Creates an event handler for POST requests that create a new requirement
@@ -28,10 +29,8 @@ export default function postRequirementHttpHandler<
         const { solutionId, organizationId, organizationSlug, ...reqProps } = await validateEventBody(event, validatedBodySchema) as any,
             session = (await getServerSession(event))!,
             organizationInteractor = new OrganizationInteractor({
-                userId: session.id,
-                organizationId,
-                organizationSlug,
-                entityManager: fork()
+                repository: new OrganizationRepository({ config, organizationId, organizationSlug }),
+                userId: session.id
             })
 
         const newRequirement = await organizationInteractor.addRequirement({ ReqClass, solutionId, reqProps })
diff --git a/server/utils/putRequirementHttpHandler.ts b/server/utils/putRequirementHttpHandler.ts
index efca96a2..9bcdb361 100644
--- a/server/utils/putRequirementHttpHandler.ts
+++ b/server/utils/putRequirementHttpHandler.ts
@@ -1,8 +1,9 @@
 import { getServerSession } from '#auth'
 import { Requirement } from "~/domain/requirements"
 import { OrganizationInteractor } from '~/application'
-import { fork } from "~/server/data/orm.js"
+import config from "~/mikro-orm.config"
 import { z, type ZodObject } from "zod"
+import { OrganizationRepository } from '../data/repositories/OrganizationRepository'
 
 /**
  * Creates an event handler for PUT requests that update an existing requirement
@@ -37,12 +38,10 @@ export default function putRequirementHttpHandler<
             { solutionId, organizationId, organizationSlug, ...reqProps } = await validateEventBody(event, validatedBodySchema) as any,
             session = (await getServerSession(event))!,
             organizationInteractor = new OrganizationInteractor({
-                userId: session.id,
-                organizationId,
-                organizationSlug,
-                entityManager: fork()
+                repository: new OrganizationRepository({ config, organizationId, organizationSlug }),
+                userId: session.id
             })
 
-        await organizationInteractor.updateRequirement({ ReqClass, id, solutionId, reqProps })
+        await organizationInteractor.updateSolutionRequirement({ ReqClass, id, solutionId, reqProps })
     })
 }
\ No newline at end of file
diff --git a/shared/models/RequirementViewModel.ts b/shared/models/RequirementViewModel.ts
index cd9d499c..06b8d8a5 100644
--- a/shared/models/RequirementViewModel.ts
+++ b/shared/models/RequirementViewModel.ts
@@ -1,4 +1,4 @@
-import type { ReqType } from '~/domain/requirements/ReqType.js';
+import type { ReqType } from '~/server/data/models/requirements/ReqType.js';
 
 export interface RequirementViewModel {
     id: number;
diff --git a/shared/utils/camelCaseToSnakeCase.test.ts b/shared/utils/camelCaseToSnakeCase.test.ts
new file mode 100644
index 00000000..c4cbc7a6
--- /dev/null
+++ b/shared/utils/camelCaseToSnakeCase.test.ts
@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { camelCaseToSnakeCase } from './camelCaseToSnakeCase';
+
+describe('camelCaseToSnakeCase', () => {
+    it('should convert camelCase to snake_case', () => {
+        expect(camelCaseToSnakeCase('camelCase')).toBe('camel_case');
+    });
+
+    it('should handle single word', () => {
+        expect(camelCaseToSnakeCase('word')).toBe('word');
+    });
+
+    it('should handle empty string', () => {
+        expect(camelCaseToSnakeCase('')).toBe('');
+    });
+
+    it('should handle multiple camelCase words', () => {
+        expect(camelCaseToSnakeCase('thisIsATestString')).toBe('this_is_a_test_string');
+    });
+
+    it('should handle strings with numbers', () => {
+        expect(camelCaseToSnakeCase('testString123')).toBe('test_string123');
+    });
+
+    // trim leading and trailing whitespace
+    it('should trim leading and trailing whitespace', () => {
+        expect(camelCaseToSnakeCase('  test  ')).toBe('test');
+    });
+});
\ No newline at end of file
diff --git a/shared/utils/camelCaseToSnakeCase.ts b/shared/utils/camelCaseToSnakeCase.ts
new file mode 100644
index 00000000..b127a0be
--- /dev/null
+++ b/shared/utils/camelCaseToSnakeCase.ts
@@ -0,0 +1,14 @@
+/**
+ * Convert camelCase to snake_case
+ * @example
+ * camelCaseToSnakeCase('camelCase') // 'camel_case'
+ */
+const camelCaseToSnakeCase = (str: string): string =>
+    str.trim()                                     // Remove leading and trailing whitespace
+        .replace(/[^a-zA-Z0-9]+/g, '_')            // Replace non-alphanumeric characters with underscores
+        .replace(/([a-z][^A-Z]*?)([A-Z])/g, '$1_$2') // Insert underscore between lowercase and uppercase letters
+        .replace(/([A-Z])([A-Z][^A-Z]*?)/g, '$1_$2') // Insert underscore between two uppercase letters
+        .replace(/_+/g, '_')                         // replace multiple underscores with a single underscore
+        .toLowerCase();                              // Convert the entire string to lowercase
+
+export { camelCaseToSnakeCase }
\ No newline at end of file
diff --git a/shared/utils/camelCaseToTitle.test.ts b/shared/utils/camelCaseToTitle.test.ts
deleted file mode 100644
index ccda9e75..00000000
--- a/shared/utils/camelCaseToTitle.test.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { camelCaseToTitle } from './camelCaseToTitle';
-
-describe('camelCaseToTitle', () => {
-    it('should convert camelCase to Title Case', () => {
-        expect(camelCaseToTitle('camelCaseString')).toBe('Camel Case String');
-    });
-
-    it('should handle single word', () => {
-        expect(camelCaseToTitle('word')).toBe('Word');
-    });
-
-    it('should handle empty string', () => {
-        expect(camelCaseToTitle('')).toBe('');
-    });
-
-    it('should handle multiple camelCase words', () => {
-        expect(camelCaseToTitle('thisIsATestString')).toBe('This Is A Test String');
-    });
-
-    it('should handle strings with numbers', () => {
-        expect(camelCaseToTitle('testString123')).toBe('Test String123');
-    });
-
-    // trim leading and trailing whitespace
-    it('should trim leading and trailing whitespace', () => {
-        expect(camelCaseToTitle('  test  ')).toBe('Test');
-    });
-});
\ No newline at end of file
diff --git a/shared/utils/camelCaseToTitleCase.test.ts b/shared/utils/camelCaseToTitleCase.test.ts
new file mode 100644
index 00000000..f5da5e8c
--- /dev/null
+++ b/shared/utils/camelCaseToTitleCase.test.ts
@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { camelCaseToTitleCase } from './camelCaseToTitleCase';
+
+describe('camelCaseToTitleCase', () => {
+    it('should convert camelCase to Title Case', () => {
+        expect(camelCaseToTitleCase('camelCaseString')).toBe('Camel Case String');
+    });
+
+    it('should handle single word', () => {
+        expect(camelCaseToTitleCase('word')).toBe('Word');
+    });
+
+    it('should handle empty string', () => {
+        expect(camelCaseToTitleCase('')).toBe('');
+    });
+
+    it('should handle multiple camelCase words', () => {
+        expect(camelCaseToTitleCase('thisIsATestString')).toBe('This Is A Test String');
+    });
+
+    it('should handle strings with numbers', () => {
+        expect(camelCaseToTitleCase('testString123')).toBe('Test String123');
+    });
+
+    // trim leading and trailing whitespace
+    it('should trim leading and trailing whitespace', () => {
+        expect(camelCaseToTitleCase('  test  ')).toBe('Test');
+    });
+});
\ No newline at end of file
diff --git a/shared/utils/camelCaseToTitle.ts b/shared/utils/camelCaseToTitleCase.ts
similarity index 65%
rename from shared/utils/camelCaseToTitle.ts
rename to shared/utils/camelCaseToTitleCase.ts
index 5ac8e7b7..da90f8ec 100644
--- a/shared/utils/camelCaseToTitle.ts
+++ b/shared/utils/camelCaseToTitleCase.ts
@@ -1,11 +1,11 @@
-/*
+/**
  * Convert a camelCase string to a Title Case string.
  * @example
- * camelCaseToTitle('camelCaseString'); // 'Camel Case String'
+ * camelCaseToTitleCase('camelCaseString'); // 'Camel Case String'
  */
-const camelCaseToTitle = (str: string) =>
+const camelCaseToTitleCase = (str: string) =>
     str.trim() // Remove leading and trailing whitespace
         .replace(/([A-Z])/g, ' $1') // Add space before uppercase letters
         .replace(/^./, str => str.toUpperCase()) // Capitalize the first letter
 
-export { camelCaseToTitle }
\ No newline at end of file
+export { camelCaseToTitleCase }
\ No newline at end of file
diff --git a/shared/utils/index.ts b/shared/utils/index.ts
index 59f5fa09..4f654c22 100644
--- a/shared/utils/index.ts
+++ b/shared/utils/index.ts
@@ -1,9 +1,12 @@
 export * from './camelCaseToSlug';
-export * from './camelCaseToTitle';
+export * from './camelCaseToSnakeCase';
+export * from './camelCaseToTitleCase';
 export * from './debounce';
 export * from './dedent';
 export * from './deSlugify';
 export * from './groupBy';
+export * from './pascalCaseToSnakeCase'
 export * from './slugify';
+export * from './snakeCaseToCamelCase';
 export * from './snakeCaseToSlug';
-export * from './snakeCaseToTitle';
\ No newline at end of file
+export * from './snakeCaseToTitleCase';
\ No newline at end of file
diff --git a/shared/utils/pascalCaseToSnakeCase.test.ts b/shared/utils/pascalCaseToSnakeCase.test.ts
new file mode 100644
index 00000000..c5c81ff2
--- /dev/null
+++ b/shared/utils/pascalCaseToSnakeCase.test.ts
@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { pascalCaseToSnakeCase } from './pascalCaseToSnakeCase';
+
+describe('pascalCaseToSnakeCase', () => {
+    it('should convert PascalCase to snake_case', () => {
+        expect(pascalCaseToSnakeCase('PascalCase')).toBe('pascal_case');
+    });
+
+    it('should handle single word', () => {
+        expect(pascalCaseToSnakeCase('Word')).toBe('word');
+    });
+
+    it('should handle empty string', () => {
+        expect(pascalCaseToSnakeCase('')).toBe('');
+    });
+
+    it('should handle multiple PascalCase words', () => {
+        expect(pascalCaseToSnakeCase('ThisIsATestString')).toBe('this_is_a_test_string');
+    });
+
+    it('should handle strings with numbers', () => {
+        expect(pascalCaseToSnakeCase('TestString123')).toBe('test_string123');
+    });
+
+    it('should trim leading and trailing whitespace', () => {
+        expect(pascalCaseToSnakeCase('  Test  ')).toBe('test');
+    });
+});
\ No newline at end of file
diff --git a/shared/utils/pascalCaseToSnakeCase.ts b/shared/utils/pascalCaseToSnakeCase.ts
new file mode 100644
index 00000000..4da1be31
--- /dev/null
+++ b/shared/utils/pascalCaseToSnakeCase.ts
@@ -0,0 +1,14 @@
+/**
+ * Convert PascalCase to snake_case
+ * @example
+ * pascalCaseToSnakeCase('PascalCase') // 'pascal_case'
+ */
+const pascalCaseToSnakeCase = (str: string): string =>
+    str.trim()                                     // Remove leading and trailing whitespace
+        .replace(/[^a-zA-Z0-9]+/g, '_')            // Replace non-alphanumeric characters with underscores
+        .replace(/([a-z][^A-Z]*?)([A-Z])/g, '$1_$2') // Insert underscore between lowercase and uppercase letters
+        .replace(/([A-Z])([A-Z][^A-Z]*?)/g, '$1_$2') // Insert underscore between two uppercase letters
+        .replace(/_+/g, '_')                         // replace multiple underscores with a single underscore
+        .toLowerCase();                              // Convert the entire string to lowercase
+
+export { pascalCaseToSnakeCase }
\ No newline at end of file
diff --git a/shared/utils/snakeCaseToCamelCase.test.ts b/shared/utils/snakeCaseToCamelCase.test.ts
new file mode 100644
index 00000000..ccee01ca
--- /dev/null
+++ b/shared/utils/snakeCaseToCamelCase.test.ts
@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { snakeCaseToCamelCase } from './snakeCaseToCamelCase';
+
+describe('snakeCaseToCamelCase', () => {
+    it('should convert snake_case to camelCase', () => {
+        expect(snakeCaseToCamelCase('snake_case_string')).toBe('snakeCaseString');
+    });
+
+    it('should handle empty strings', () => {
+        expect(snakeCaseToCamelCase('')).toBe('');
+    });
+
+    it('should handle strings without underscores', () => {
+        expect(snakeCaseToCamelCase('noUnderscores')).toBe('noUnderscores');
+    });
+
+    it('should handle strings with multiple underscores', () => {
+        expect(snakeCaseToCamelCase('multiple__underscores')).toBe('multipleUnderscores');
+    });
+
+    it('should handle strings with leading and trailing underscores', () => {
+        expect(snakeCaseToCamelCase('_leading_and_trailing_')).toBe('LeadingAndTrailing');
+    });
+
+    it('should handle strings with only underscores', () => {
+        expect(snakeCaseToCamelCase('_____')).toBe('');
+    });
+});
\ No newline at end of file
diff --git a/shared/utils/snakeCaseToCamelCase.ts b/shared/utils/snakeCaseToCamelCase.ts
new file mode 100644
index 00000000..02536b46
--- /dev/null
+++ b/shared/utils/snakeCaseToCamelCase.ts
@@ -0,0 +1,10 @@
+/**
+ * Convert snake_case to camelCase
+ * @example
+ * snakeCaseToCamelCase('snake_case_string'); // 'snakeCaseString'
+ * @param str - The snake_case string to convert
+ * @returns The camelCase string
+ */
+const snakeCaseToCamelCase = (str: string) => str.replace(/_./g, char => char[1].toUpperCase());
+
+export { snakeCaseToCamelCase }
\ No newline at end of file
diff --git a/shared/utils/snakeCaseToTitle.test.ts b/shared/utils/snakeCaseToTitle.test.ts
deleted file mode 100644
index 1800c952..00000000
--- a/shared/utils/snakeCaseToTitle.test.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { snakeCaseToTitle } from './snakeCaseToTitle';
-
-describe('snakeCaseToTitle', () => {
-    it('should convert snake_case to Title Case', () => {
-        expect(snakeCaseToTitle('snake_case_string')).toBe('Snake Case String');
-    });
-
-    it('should handle single word', () => {
-        expect(snakeCaseToTitle('word')).toBe('Word');
-    });
-
-    it('should handle empty string', () => {
-        expect(snakeCaseToTitle('')).toBe('');
-    });
-
-    it('should handle multiple underscores', () => {
-        expect(snakeCaseToTitle('multiple__underscores')).toBe('Multiple  Underscores');
-    });
-
-    it('should handle leading and trailing underscores', () => {
-        expect(snakeCaseToTitle('_leading_trailing_')).toBe(' Leading Trailing ');
-    });
-
-    it('should handle numbers in the string', () => {
-        expect(snakeCaseToTitle('snake_case_123')).toBe('Snake Case 123');
-    });
-
-    it('should handle mixed case input', () => {
-        expect(snakeCaseToTitle('sNaKe_CaSe')).toBe('SNaKe CaSe');
-    });
-});
\ No newline at end of file
diff --git a/shared/utils/snakeCaseToTitle.ts b/shared/utils/snakeCaseToTitle.ts
deleted file mode 100644
index 3e6c3cac..00000000
--- a/shared/utils/snakeCaseToTitle.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-/**
- * Convert snake_case to Title Case
- * @example
- * snakeCaseToTitle('snake_case_string'); // 'Snake Case String'
- */
-const snakeCaseToTitle = (str: string) =>
-    str.replace(/_/g, ' ')
-        .replace(/\b\w/g, char => char.toUpperCase());
-
-export { snakeCaseToTitle }
\ No newline at end of file
diff --git a/shared/utils/snakeCaseToTitleCase.test.ts b/shared/utils/snakeCaseToTitleCase.test.ts
new file mode 100644
index 00000000..5f7f38ad
--- /dev/null
+++ b/shared/utils/snakeCaseToTitleCase.test.ts
@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { snakeCaseToTitleCase } from './snakeCaseToTitleCase';
+
+describe('snakeCaseToTitleCase', () => {
+    it('should convert snake_case to Title Case', () => {
+        expect(snakeCaseToTitleCase('snake_case_string')).toBe('Snake Case String');
+    });
+
+    it('should handle single word', () => {
+        expect(snakeCaseToTitleCase('word')).toBe('Word');
+    });
+
+    it('should handle empty string', () => {
+        expect(snakeCaseToTitleCase('')).toBe('');
+    });
+
+    it('should handle multiple underscores', () => {
+        expect(snakeCaseToTitleCase('multiple__underscores')).toBe('Multiple  Underscores');
+    });
+
+    it('should handle leading and trailing underscores', () => {
+        expect(snakeCaseToTitleCase('_leading_trailing_')).toBe(' Leading Trailing ');
+    });
+
+    it('should handle numbers in the string', () => {
+        expect(snakeCaseToTitleCase('snake_case_123')).toBe('Snake Case 123');
+    });
+
+    it('should handle mixed case input', () => {
+        expect(snakeCaseToTitleCase('sNaKe_CaSe')).toBe('SNaKe CaSe');
+    });
+});
\ No newline at end of file
diff --git a/shared/utils/snakeCaseToTitleCase.ts b/shared/utils/snakeCaseToTitleCase.ts
new file mode 100644
index 00000000..88872148
--- /dev/null
+++ b/shared/utils/snakeCaseToTitleCase.ts
@@ -0,0 +1,10 @@
+/**
+ * Convert snake_case to Title Case
+ * @example
+ * snakeCaseToTitleCase('snake_case_string'); // 'Snake Case String'
+ */
+const snakeCaseToTitleCase = (str: string) =>
+    str.replace(/_/g, ' ')
+        .replace(/\b\w/g, char => char.toUpperCase());
+
+export { snakeCaseToTitleCase }
\ No newline at end of file