diff --git a/package-lock.json b/package-lock.json
index 1ca32a85..3756c2ff 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -73,7 +73,6 @@
         "react-router-dom": "^5.1.2",
         "react-slick": "^0.28.1",
         "react-twitter-embed": "^3.0.3",
-        "reflect-metadata": "^0.1.13",
         "replacestream": "^4.0.3",
         "request-received": "0.0.3",
         "restful-react": "^15.2.0",
diff --git a/package.json b/package.json
index 0c9de53b..0db0b198 100644
--- a/package.json
+++ b/package.json
@@ -43,7 +43,8 @@
     "backend": {
       "context": "node",
       "distDir": "dist/backend",
-      "optimize": false
+      "optimize": false,
+      "scopeHoist": false
     },
     "frontend": {
       "context": "browser",
@@ -53,12 +54,14 @@
     "migrations-script": {
       "context": "node",
       "distDir": "dist/scripts",
-      "optimize": false
+      "optimize": false,
+      "scopeHoist": false
     },
     "init-script": {
       "context": "node",
       "distDir": "dist/scripts",
-      "optimize": false
+      "optimize": false,
+      "scopeHoist": false
     }
   },
   "engines": {
@@ -143,7 +146,6 @@
     "react-router-dom": "^5.1.2",
     "react-slick": "^0.28.1",
     "react-twitter-embed": "^3.0.3",
-    "reflect-metadata": "^0.1.13",
     "replacestream": "^4.0.3",
     "request-received": "0.0.3",
     "restful-react": "^15.2.0",
diff --git a/src/backend/controllers/preprint.js b/src/backend/controllers/preprint.js
index 0efbe812..6e560951 100644
--- a/src/backend/controllers/preprint.js
+++ b/src/backend/controllers/preprint.js
@@ -1,5 +1,4 @@
 import router from 'koa-joi-router';
-import 'reflect-metadata';
 import { QueryOrder } from '@mikro-orm/core';
 import { getLogger } from '../log.ts';
 import { resolvePreprint } from '../utils/resolve.ts';
diff --git a/src/backend/mikro-orm.config.ts b/src/backend/mikro-orm.config.ts
index f786d0d0..e54e17c4 100644
--- a/src/backend/mikro-orm.config.ts
+++ b/src/backend/mikro-orm.config.ts
@@ -1,26 +1,26 @@
 import { Options } from '@mikro-orm/core';
 import {
-  Badge,
-  BaseEntity,
-  Comment,
-  Community,
-  Contact,
-  Event,
-  Expertise,
-  FullReview,
-  FullReviewDraft,
-  Group,
-  Key,
-  Persona,
-  Preprint,
-  RapidReview,
-  Report,
-  Request,
-  Statement,
-  Tag,
-  Template,
-  User,
-  Work,
+  badgeSchema,
+  baseEntitySchema,
+  commentSchema,
+  communitySchema,
+  contactSchema,
+  eventSchema,
+  expertiseSchema,
+  fullReviewSchema,
+  fullReviewDraftSchema,
+  groupSchema,
+  keySchema,
+  personaSchema,
+  preprintSchema,
+  rapidReviewSchema,
+  reportSchema,
+  requestSchema,
+  statementSchema,
+  tagSchema,
+  templateSchema,
+  userSchema,
+  workSchema,
 } from './models/entities';
 import config from './config';
 
@@ -30,27 +30,27 @@ const portString = config.dbPort ? `:${config.dbPort}` : '';
 
 const options: Options = {
   entities: [
-    Badge,
-    BaseEntity,
-    Comment,
-    Community,
-    Contact,
-    Event,
-    Expertise,
-    FullReview,
-    FullReviewDraft,
-    Group,
-    Key,
-    Persona,
-    Preprint,
-    RapidReview,
-    Report,
-    Request,
-    Statement,
-    Tag,
-    Template,
-    User,
-    Work,
+    badgeSchema,
+    baseEntitySchema,
+    commentSchema,
+    communitySchema,
+    contactSchema,
+    eventSchema,
+    expertiseSchema,
+    fullReviewSchema,
+    fullReviewDraftSchema,
+    groupSchema,
+    keySchema,
+    personaSchema,
+    preprintSchema,
+    rapidReviewSchema,
+    reportSchema,
+    requestSchema,
+    statementSchema,
+    tagSchema,
+    templateSchema,
+    userSchema,
+    workSchema,
   ],
   type: 'postgresql',
   debug: config.logLevel === 'trace',
diff --git a/src/backend/models/badges.ts b/src/backend/models/badges.ts
index 19c8acbe..b25aa2e4 100644
--- a/src/backend/models/badges.ts
+++ b/src/backend/models/badges.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Badge } from './entities';
 
-@Repository(Badge)
 export class BadgeModel extends EntityRepository<Badge> {}
 
 export function badgeModelWrapper(db: MikroORM): BadgeModel {
diff --git a/src/backend/models/comments.ts b/src/backend/models/comments.ts
index fd1bd078..08e8b3d0 100644
--- a/src/backend/models/comments.ts
+++ b/src/backend/models/comments.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Comment } from './entities';
 
-@Repository(Comment)
 export class CommentModel extends EntityRepository<Comment> {}
 
 export function commentModelWrapper(db: MikroORM): CommentModel {
diff --git a/src/backend/models/communities.ts b/src/backend/models/communities.ts
index c4949c00..03b3507f 100644
--- a/src/backend/models/communities.ts
+++ b/src/backend/models/communities.ts
@@ -1,4 +1,4 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { ORCID as orcidUtils } from 'orcid-utils';
 import { validate as uuidValidate } from 'uuid';
 import { Community, User } from './entities';
@@ -6,7 +6,6 @@ import { getLogger } from '../log';
 
 const log = getLogger('backend:models:communities');
 
-@Repository(Community)
 export class CommunityModel extends EntityRepository<Community> {
   async isMemberOf(communityId: string, userId: string): Promise<boolean> {
     let user: User | null = null;
diff --git a/src/backend/models/contacts.ts b/src/backend/models/contacts.ts
index d6bcfeb7..c554a78d 100644
--- a/src/backend/models/contacts.ts
+++ b/src/backend/models/contacts.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Contact } from './entities';
 
-@Repository(Contact)
 export class ContactModel extends EntityRepository<Contact> {}
 
 export function contactModelWrapper(db: MikroORM): ContactModel {
diff --git a/src/backend/models/entities/Badge.ts b/src/backend/models/entities/Badge.ts
index 25bc47f1..17fc194d 100644
--- a/src/backend/models/entities/Badge.ts
+++ b/src/backend/models/entities/Badge.ts
@@ -1,27 +1,11 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  ManyToMany,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { BadgeModel } from '../badges';
 import { BaseEntity } from './BaseEntity';
 import { Persona } from './Persona';
 
-@Entity()
 export class Badge extends BaseEntity {
-  [EntityRepositoryType]?: BadgeModel;
-
-  @Property()
-  @Unique()
   name!: string;
-
-  @Property()
   color?: string;
-
-  @ManyToMany({ entity: () => Persona, inversedBy: 'badges' })
   personas: Collection<Persona> = new Collection<Persona>(this);
 
   constructor(name: string, color = '#FF0000') {
@@ -30,3 +14,18 @@ export class Badge extends BaseEntity {
     this.color = color;
   }
 }
+
+export const badgeSchema = new EntitySchema<Badge, BaseEntity>({
+  class: Badge,
+
+  customRepository: () => BadgeModel,
+  properties: {
+    name: { type: 'string', unique: true },
+    color: { type: 'string' },
+    personas: {
+      reference: 'm:n',
+      entity: () => Persona,
+      inversedBy: (persona) => persona.badges,
+    },
+  },
+});
diff --git a/src/backend/models/entities/BaseEntity.ts b/src/backend/models/entities/BaseEntity.ts
index 5bcdbca2..8d6f4e34 100644
--- a/src/backend/models/entities/BaseEntity.ts
+++ b/src/backend/models/entities/BaseEntity.ts
@@ -1,17 +1,20 @@
+import { EntitySchema } from '@mikro-orm/core';
 import { v4 as uuidv4 } from 'uuid';
-import { PrimaryKey, Property, Unique } from '@mikro-orm/core';
 
 export abstract class BaseEntity {
-  @PrimaryKey({ hidden: true })
   id!: number;
-
-  @Property({ type: 'string' })
-  @Unique()
   uuid = uuidv4();
-
-  @Property()
   createdAt: Date = new Date();
-
-  @Property({ onUpdate: () => new Date() })
   updatedAt: Date = new Date();
 }
+
+export const baseEntitySchema = new EntitySchema<BaseEntity>({
+  name: 'BaseEntity',
+  abstract: true,
+  properties: {
+    id: { type: 'number', hidden: true, primary: true },
+    uuid: { type: 'string', unique: true },
+    createdAt: { type: 'Date' },
+    updatedAt: { type: 'Date', onUpdate: () => new Date() },
+  },
+});
diff --git a/src/backend/models/entities/Comment.ts b/src/backend/models/entities/Comment.ts
index 38ef756b..4b817dc2 100644
--- a/src/backend/models/entities/Comment.ts
+++ b/src/backend/models/entities/Comment.ts
@@ -1,34 +1,14 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { CommentModel } from '../comments';
 import { BaseEntity } from './BaseEntity';
 import { FullReview } from './FullReview';
 import { Persona } from './Persona';
 
-@Entity()
-@Index({ properties: ['author'] })
-@Index({ properties: ['parent'] })
 export class Comment extends BaseEntity {
-  [EntityRepositoryType]?: CommentModel;
-
-  @Property({ columnType: 'text' })
   contents!: string;
-
-  @Property()
   isPublished: boolean = false;
-
-  @Property()
   isFlagged: boolean = false;
-
-  @ManyToOne({ entity: () => Persona })
   author!: Persona;
-
-  @ManyToOne({ entity: () => FullReview })
   parent!: FullReview;
 
   constructor(contents: string, author: Persona, parent: FullReview) {
@@ -38,3 +18,16 @@ export class Comment extends BaseEntity {
     this.parent = parent;
   }
 }
+
+export const commentSchema = new EntitySchema<Comment, BaseEntity>({
+  class: Comment,
+  customRepository: () => CommentModel,
+  indexes: [{ properties: 'author' }, { properties: 'parent' }],
+  properties: {
+    contents: { type: 'string', columnType: 'text' },
+    isPublished: { type: 'boolean' },
+    isFlagged: { type: 'boolean' },
+    author: { reference: 'm:1', entity: () => Persona },
+    parent: { reference: 'm:1', entity: () => FullReview },
+  },
+});
diff --git a/src/backend/models/entities/Community.ts b/src/backend/models/entities/Community.ts
index 737d0266..c45e7dd3 100644
--- a/src/backend/models/entities/Community.ts
+++ b/src/backend/models/entities/Community.ts
@@ -1,12 +1,4 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  ManyToMany,
-  OneToMany,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { CommunityModel } from '../communities';
 import { BaseEntity } from './BaseEntity';
 import { Event } from './Event';
@@ -16,46 +8,18 @@ import { Tag } from './Tag';
 import { Template } from './Template';
 import { User } from './User';
 
-@Entity()
 export class Community extends BaseEntity {
-  [EntityRepositoryType]?: CommunityModel;
-
-  @Property()
-  @Unique()
   name!: string;
-
-  @Property()
-  @Unique()
   slug!: string;
-
-  @Property({ columnType: 'text', nullable: true })
   description?: string;
-
-  @Property({ nullable: true })
   banner?: Buffer;
-
-  @Property({ nullable: true })
   logo?: Buffer;
-
-  @Property({ nullable: true })
   twitter?: string;
-
-  @ManyToMany({ entity: () => Persona, inversedBy: 'communities' })
   members: Collection<Persona> = new Collection<Persona>(this);
-
-  @ManyToMany({ entity: () => User, inversedBy: 'owned' })
   owners: Collection<User> = new Collection<User>(this);
-
-  @ManyToMany({ entity: () => Preprint, inversedBy: 'communities' })
   preprints: Collection<Preprint> = new Collection<Preprint>(this);
-
-  @OneToMany({ entity: () => Event, mappedBy: 'community' })
   events: Collection<Event> = new Collection<Event>(this);
-
-  @ManyToMany({ entity: () => Tag, inversedBy: 'communities' })
   tags: Collection<Tag> = new Collection<Tag>(this);
-
-  @OneToMany({ entity: () => Template, mappedBy: 'community' })
   templates: Collection<Template> = new Collection<Template>(this);
 
   constructor(
@@ -71,3 +35,46 @@ export class Community extends BaseEntity {
     this.twitter = twitter;
   }
 }
+
+export const communitySchema = new EntitySchema<Community, BaseEntity>({
+  class: Community,
+  customRepository: () => CommunityModel,
+  properties: {
+    name: { type: 'string', unique: true },
+    slug: { type: 'string', unique: true },
+    description: { type: 'string', columnType: 'text', nullable: true },
+    banner: { type: 'Buffer', nullable: true },
+    logo: { type: 'Buffer', nullable: true },
+    twitter: { type: 'string', nullable: true },
+    members: {
+      reference: 'm:n',
+      entity: () => Persona,
+      inversedBy: (persona) => persona.communities,
+    },
+    owners: {
+      reference: 'm:n',
+      entity: () => User,
+      inversedBy: (user) => user.owned,
+    },
+    preprints: {
+      reference: 'm:n',
+      entity: () => Preprint,
+      inversedBy: (preprint) => preprint.communities,
+    },
+    events: {
+      reference: '1:m',
+      entity: () => Event,
+      mappedBy: (event) => event.community,
+    },
+    tags: {
+      reference: 'm:n',
+      entity: () => Tag,
+      inversedBy: (tag) => tag.communities,
+    },
+    templates: {
+      reference: '1:m',
+      entity: () => Template,
+      mappedBy: (template) => template.community,
+    },
+  },
+});
diff --git a/src/backend/models/entities/Contact.ts b/src/backend/models/entities/Contact.ts
index abba4ac4..8b160e28 100644
--- a/src/backend/models/entities/Contact.ts
+++ b/src/backend/models/entities/Contact.ts
@@ -1,38 +1,15 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { ContactModel } from '../contacts';
 import { BaseEntity } from './BaseEntity';
 import { User } from './User';
 
-@Entity()
-@Index({ properties: ['identity'] })
 export class Contact extends BaseEntity {
-  [EntityRepositoryType]?: ContactModel;
-
-  @Property()
   schema!: string;
-
-  @Property()
   value!: string;
-
-  @ManyToOne({ entity: () => User })
   identity!: User;
-
-  @Property()
   isVerified: boolean;
-
-  @Property()
   isNotified: boolean;
-
-  @Property()
   isPublic: boolean;
-
-  @Property({ nullable: true })
   token?: string;
 
   constructor(
@@ -52,3 +29,18 @@ export class Contact extends BaseEntity {
     this.isPublic = isPublic;
   }
 }
+
+export const contactSchema = new EntitySchema<Contact, BaseEntity>({
+  class: Contact,
+  customRepository: () => ContactModel,
+  indexes: [{ properties: 'identity' }],
+  properties: {
+    schema: { type: 'string' },
+    value: { type: 'string' },
+    identity: { reference: 'm:1', entity: () => User },
+    isVerified: { type: 'boolean' },
+    isNotified: { type: 'boolean' },
+    isPublic: { type: 'boolean' },
+    token: { type: 'string', nullable: true },
+  },
+});
diff --git a/src/backend/models/entities/Event.ts b/src/backend/models/entities/Event.ts
index f06130e5..89d49ea1 100644
--- a/src/backend/models/entities/Event.ts
+++ b/src/backend/models/entities/Event.ts
@@ -1,36 +1,15 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { EventModel } from '../events';
 import { BaseEntity } from './BaseEntity';
 import { Community } from './Community';
 
-@Entity()
 export class Event extends BaseEntity {
-  [EntityRepositoryType]?: EventModel;
-
-  @Property()
   title!: string;
-
-  @Property()
   start!: Date;
-
-  @Property({ nullable: true })
   end?: Date;
-
-  @Property()
   isPrivate: boolean = false;
-
-  @Property({ columnType: 'text', nullable: true })
   description?: string;
-
-  @Property({ columnType: 'text', nullable: true })
   url?: string;
-
-  @ManyToOne({ entity: () => Community, nullable: true })
   community?: Community;
 
   constructor(
@@ -50,3 +29,17 @@ export class Event extends BaseEntity {
     this.community = community;
   }
 }
+
+export const eventSchema = new EntitySchema<Event, BaseEntity>({
+  class: Event,
+  customRepository: () => EventModel,
+  properties: {
+    title: { type: 'string' },
+    start: { type: 'Date' },
+    end: { type: 'Date', nullable: true },
+    isPrivate: { type: 'boolean' },
+    description: { type: 'string', nullable: true },
+    url: { type: 'string', columnType: 'text', nullable: true },
+    community: { reference: 'm:1', entity: () => Community, nullable: true },
+  },
+});
diff --git a/src/backend/models/entities/Expertise.ts b/src/backend/models/entities/Expertise.ts
index 27f05629..5af2f1b2 100644
--- a/src/backend/models/entities/Expertise.ts
+++ b/src/backend/models/entities/Expertise.ts
@@ -1,24 +1,10 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  ManyToMany,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { ExpertiseModel } from '../expertises';
 import { BaseEntity } from './BaseEntity';
 import { Persona } from './Persona';
 
-@Entity()
 export class Expertise extends BaseEntity {
-  [EntityRepositoryType]?: ExpertiseModel;
-
-  @Property()
-  @Unique()
   name!: string;
-
-  @ManyToMany({ entity: () => Persona, inversedBy: 'expertises' })
   personas: Collection<Persona> = new Collection<Persona>(this);
 
   constructor(name: string) {
@@ -26,3 +12,16 @@ export class Expertise extends BaseEntity {
     this.name = name;
   }
 }
+
+export const expertiseSchema = new EntitySchema<Expertise, BaseEntity>({
+  class: Expertise,
+  customRepository: () => ExpertiseModel,
+  properties: {
+    name: { type: 'string', unique: true },
+    personas: {
+      reference: 'm:n',
+      entity: () => Persona,
+      inversedBy: (persona) => persona.expertises,
+    },
+  },
+});
diff --git a/src/backend/models/entities/FullReview.ts b/src/backend/models/entities/FullReview.ts
index e8642f09..d6cf96f2 100644
--- a/src/backend/models/entities/FullReview.ts
+++ b/src/backend/models/entities/FullReview.ts
@@ -1,13 +1,4 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  ManyToMany,
-  ManyToOne,
-  OneToMany,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { FullReviewModel } from '../fullReviews';
 import { BaseEntity } from './BaseEntity';
 import { Comment } from './Comment';
@@ -16,42 +7,17 @@ import { Persona } from './Persona';
 import { Preprint } from './Preprint';
 import { Statement } from './Statement';
 
-@Entity()
 export class FullReview extends BaseEntity {
-  [EntityRepositoryType]?: FullReviewModel;
-
-  @Property()
   isPublished: boolean = false;
-
-  @Property()
   isFlagged: boolean = false;
-
-  @Property({ nullable: true })
-  @Unique()
   doi?: string;
-
-  @OneToMany({ entity: () => FullReviewDraft, mappedBy: 'parent' })
   drafts: Collection<FullReviewDraft> = new Collection<FullReviewDraft>(this);
-
-  @ManyToMany({ entity: () => Persona, inversedBy: 'invitedToMentor' })
   mentorInvites: Collection<Persona> = new Collection<Persona>(this);
-
-  @ManyToMany({ entity: () => Persona, inversedBy: 'mentoring' })
   mentors: Collection<Persona> = new Collection<Persona>(this);
-
-  @ManyToMany({ entity: () => Persona, inversedBy: 'invitedToAuthor' })
   authorInvites: Collection<Persona> = new Collection<Persona>(this);
-
-  @ManyToMany({ entity: () => Persona, inversedBy: 'fullReviews' })
   authors: Collection<Persona> = new Collection<Persona>(this);
-
-  @ManyToOne({ entity: () => Preprint })
   preprint!: Preprint;
-
-  @OneToMany({ entity: () => Comment, mappedBy: 'parent' })
   comments: Collection<Comment> = new Collection<Comment>(this);
-
-  @OneToMany({ entity: () => Comment, mappedBy: 'parent' })
   statements: Collection<Statement> = new Collection<Statement>(this);
 
   constructor(preprint: Preprint, isPublished = false, doi?: string) {
@@ -61,3 +27,49 @@ export class FullReview extends BaseEntity {
     this.doi = doi;
   }
 }
+
+export const fullReviewSchema = new EntitySchema<FullReview, BaseEntity>({
+  class: FullReview,
+  customRepository: () => FullReviewModel,
+  properties: {
+    isPublished: { type: 'boolean' },
+    isFlagged: { type: 'boolean' },
+    doi: { type: 'string', nullable: true, unique: true },
+    drafts: {
+      reference: '1:m',
+      entity: () => FullReviewDraft,
+      mappedBy: (draft) => draft.parent,
+    },
+    mentorInvites: {
+      reference: 'm:n',
+      entity: () => Persona,
+      inversedBy: (persona) => persona.invitedToMentor,
+    },
+    mentors: {
+      reference: 'm:n',
+      entity: () => Persona,
+      inversedBy: (persona) => persona.mentoring,
+    },
+    authorInvites: {
+      reference: 'm:n',
+      entity: () => Persona,
+      inversedBy: (persona) => persona.invitedToAuthor,
+    },
+    authors: {
+      reference: 'm:n',
+      entity: () => Persona,
+      inversedBy: (persona) => persona.fullReviews,
+    },
+    preprint: { reference: 'm:1', entity: () => Preprint },
+    comments: {
+      reference: '1:m',
+      entity: () => Comment,
+      mappedBy: (comment) => comment.parent,
+    },
+    statements: {
+      reference: '1:m',
+      entity: () => Statement,
+      mappedBy: (statement) => statement.parent,
+    },
+  },
+});
diff --git a/src/backend/models/entities/FullReviewDraft.ts b/src/backend/models/entities/FullReviewDraft.ts
index 37257eb8..481ed528 100644
--- a/src/backend/models/entities/FullReviewDraft.ts
+++ b/src/backend/models/entities/FullReviewDraft.ts
@@ -1,23 +1,10 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { FullReviewDraftModel } from '../fullReviewDrafts';
 import { BaseEntity } from './BaseEntity';
 import { FullReview } from './FullReview';
 
-@Entity()
-@Index({ properties: ['parent'] })
 export class FullReviewDraft extends BaseEntity {
-  [EntityRepositoryType]: FullReviewDraftModel;
-
-  @ManyToOne({ entity: () => FullReview })
   parent!: FullReview;
-
-  @Property({ columnType: 'text' })
   contents!: string;
 
   constructor(parent: FullReview, contents: string) {
@@ -26,3 +13,16 @@ export class FullReviewDraft extends BaseEntity {
     this.contents = contents;
   }
 }
+
+export const fullReviewDraftSchema = new EntitySchema<
+  FullReviewDraft,
+  BaseEntity
+>({
+  class: FullReviewDraft,
+  customRepository: () => FullReviewDraftModel,
+  indexes: [{ properties: ['parent'] }],
+  properties: {
+    parent: { reference: 'm:1', entity: () => FullReview },
+    contents: { type: 'string', columnType: 'text' },
+  },
+});
diff --git a/src/backend/models/entities/Group.ts b/src/backend/models/entities/Group.ts
index 972fec73..c00df63a 100644
--- a/src/backend/models/entities/Group.ts
+++ b/src/backend/models/entities/Group.ts
@@ -1,24 +1,10 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  ManyToMany,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { GroupModel } from '../groups';
 import { BaseEntity } from './BaseEntity';
 import { User } from './User';
 
-@Entity()
 export class Group extends BaseEntity {
-  [EntityRepositoryType]?: GroupModel;
-
-  @Property()
-  @Unique()
   name!: string;
-
-  @ManyToMany({ entity: () => User, inversedBy: 'groups' })
   members: Collection<User> = new Collection<User>(this);
 
   constructor(name: string) {
@@ -26,3 +12,16 @@ export class Group extends BaseEntity {
     this.name = name;
   }
 }
+
+export const groupSchema = new EntitySchema<Group, BaseEntity>({
+  class: Group,
+  customRepository: () => GroupModel,
+  properties: {
+    name: { type: 'string', unique: true },
+    members: {
+      reference: 'm:n',
+      entity: () => User,
+      inversedBy: (user) => user.groups,
+    },
+  },
+});
diff --git a/src/backend/models/entities/Key.ts b/src/backend/models/entities/Key.ts
index aabd8403..99042698 100644
--- a/src/backend/models/entities/Key.ts
+++ b/src/backend/models/entities/Key.ts
@@ -1,25 +1,12 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import uuidApiKey from 'uuid-apikey';
 import { KeyModel } from '../keys';
 import { BaseEntity } from './BaseEntity';
 import { User } from './User';
 
-@Entity()
 export class Key extends BaseEntity {
-  [EntityRepositoryType]?: KeyModel;
-
-  @ManyToOne({ entity: () => User })
   owner!: User;
-
-  @Property()
   app!: string;
-
-  @Property()
   secret!: string;
 
   constructor(owner: User, app: string) {
@@ -29,3 +16,13 @@ export class Key extends BaseEntity {
     this.secret = uuidApiKey.create().apiKey;
   }
 }
+
+export const keySchema = new EntitySchema<Key, BaseEntity>({
+  class: Key,
+  customRepository: () => KeyModel,
+  properties: {
+    owner: { reference: 'm:1', entity: () => User },
+    app: { type: 'string' },
+    secret: { type: 'string' },
+  },
+});
diff --git a/src/backend/models/entities/Persona.ts b/src/backend/models/entities/Persona.ts
index 6675ae6c..84a432de 100644
--- a/src/backend/models/entities/Persona.ts
+++ b/src/backend/models/entities/Persona.ts
@@ -1,13 +1,4 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToMany,
-  ManyToOne,
-  OneToMany,
-  Property,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { PersonaModel } from '../personas';
 import { BaseEntity } from './BaseEntity';
 import { Badge } from './Badge';
@@ -18,60 +9,23 @@ import { RapidReview } from './RapidReview';
 import { Request } from './Request';
 import { User } from './User';
 
-@Entity()
-@Index({ name: 'persona_trgm', properties: ['name', 'bio'] })
 export class Persona extends BaseEntity {
-  [EntityRepositoryType]?: PersonaModel;
-
-  @Property()
   name!: string;
-
-  @ManyToOne({ entity: () => User, nullable: true, hidden: true })
   identity?: User;
-
-  @Property()
   isAnonymous!: boolean;
-
-  @Property()
   isLocked: boolean = false;
-
-  @Property()
   isFlagged: boolean = false;
-
-  @Property({ columnType: 'text', nullable: true })
   bio?: string;
-
-  @Property({ nullable: true })
   avatar?: Buffer;
-
-  @Property({ nullable: true })
   avatar_encoding?: string;
-
-  @ManyToMany({ entity: () => Community, mappedBy: 'members' })
   communities: Collection<Community> = new Collection<Community>(this);
-
-  @OneToMany({ entity: () => RapidReview, mappedBy: 'author' })
   rapidReviews: Collection<RapidReview> = new Collection<RapidReview>(this);
-
-  @ManyToMany({ entity: () => FullReview, mappedBy: 'authors' })
   fullReviews: Collection<FullReview> = new Collection<FullReview>(this);
-
-  @ManyToMany({ entity: () => FullReview, mappedBy: 'authorInvites' })
   invitedToAuthor: Collection<FullReview> = new Collection<FullReview>(this);
-
-  @ManyToMany({ entity: () => FullReview, mappedBy: 'mentors' })
   mentoring: Collection<FullReview> = new Collection<FullReview>(this);
-
-  @ManyToMany({ entity: () => FullReview, mappedBy: 'mentorInvites' })
   invitedToMentor: Collection<FullReview> = new Collection<FullReview>(this);
-
-  @OneToMany({ entity: () => Request, mappedBy: 'author' })
   requests: Collection<Request> = new Collection<Request>(this);
-
-  @ManyToMany({ entity: () => Badge, mappedBy: 'personas' })
   badges: Collection<Badge> = new Collection<Badge>(this);
-
-  @ManyToMany({ entity: () => Expertise, mappedBy: 'personas' })
   expertises: Collection<Expertise> = new Collection<Expertise>(this);
 
   constructor(
@@ -95,3 +49,69 @@ export class Persona extends BaseEntity {
     this.avatar_encoding = avatar_encoding;
   }
 }
+
+export const personaSchema = new EntitySchema<Persona, BaseEntity>({
+  class: Persona,
+  customRepository: () => PersonaModel,
+  indexes: [{ name: 'persona_trgm', properties: ['name', 'bio'] }],
+  properties: {
+    name: { type: 'string' },
+    identity: {
+      reference: 'm:1',
+      entity: () => User,
+      nullable: true,
+      hidden: true,
+    },
+    isAnonymous: { type: 'boolean' },
+    isLocked: { type: 'boolean' },
+    isFlagged: { type: 'boolean' },
+    bio: { type: 'string', columnType: 'text', nullable: true },
+    avatar: { type: 'Buffer', nullable: true },
+    avatar_encoding: { type: 'string', nullable: true },
+    communities: {
+      reference: 'm:n',
+      entity: () => Community,
+      mappedBy: (community) => community.members,
+    },
+    rapidReviews: {
+      reference: '1:m',
+      entity: () => RapidReview,
+      mappedBy: (rapidReview) => rapidReview.author,
+    },
+    fullReviews: {
+      reference: 'm:n',
+      entity: () => FullReview,
+      mappedBy: (fullReview) => fullReview.authors,
+    },
+    invitedToAuthor: {
+      reference: 'm:n',
+      entity: () => FullReview,
+      mappedBy: (fullReview) => fullReview.authorInvites,
+    },
+    mentoring: {
+      reference: 'm:n',
+      entity: () => FullReview,
+      mappedBy: (fullReview) => fullReview.mentors,
+    },
+    invitedToMentor: {
+      reference: 'm:n',
+      entity: () => FullReview,
+      mappedBy: (fullReview) => fullReview.mentorInvites,
+    },
+    requests: {
+      reference: '1:m',
+      entity: () => Request,
+      mappedBy: (request) => request.author,
+    },
+    badges: {
+      reference: 'm:n',
+      entity: () => Badge,
+      mappedBy: (badge) => badge.personas,
+    },
+    expertises: {
+      reference: 'm:n',
+      entity: () => Expertise,
+      mappedBy: (expertise) => expertise.personas,
+    },
+  },
+});
diff --git a/src/backend/models/entities/Preprint.ts b/src/backend/models/entities/Preprint.ts
index a142dd58..ad1a5abb 100644
--- a/src/backend/models/entities/Preprint.ts
+++ b/src/backend/models/entities/Preprint.ts
@@ -1,13 +1,4 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToMany,
-  OneToMany,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { PreprintModel } from '../preprints';
 import { BaseEntity } from './BaseEntity';
 import { Community } from './Community';
@@ -16,79 +7,23 @@ import { RapidReview } from './RapidReview';
 import { Request } from './Request';
 import { Tag } from './Tag';
 
-@Entity()
-@Index({
-  name: 'preprint_trgm',
-  properties: ['title', 'handle', 'abstractText', 'authors'],
-})
 export class Preprint extends BaseEntity {
-  [EntityRepositoryType]?: PreprintModel;
-
-  @Property()
-  @Unique()
   handle!: string;
-
-  @Property({ columnType: 'text' })
   title!: string;
-
-  @Property({ columnType: 'text', nullable: true })
   authors?: string;
-
-  @Property()
   isPublished!: boolean;
-
-  @Property({ columnType: 'text', nullable: true })
   abstractText?: string;
-
-  @Property({ nullable: true })
   preprintServer?: string;
-
-  @Property({ nullable: true })
   datePosted?: Date;
-
-  @Property({ nullable: true })
   license?: string;
-
-  @Property({ nullable: true })
   publication?: string;
-
-  @Property({ nullable: true })
   url?: string;
-
-  @Property({ nullable: true })
   contentEncoding?: string;
-
-  @Property({ nullable: true })
   contentUrl?: string;
-
-  //@Property({ persist: false })
-  //get fullReviewCount(): number {
-  //  return this.fullReviews.count();
-  //}
-
-  //@Property({ persist: false })
-  //get rapidReviewCount(): number {
-  //  return this.rapidReviews.count();
-  //}
-
-  //@Property({ persist: false })
-  //get requestCount(): number {
-  //  return this.requests.count();
-  //}
-
-  @OneToMany({ entity: () => RapidReview, mappedBy: 'preprint' })
   rapidReviews: Collection<RapidReview> = new Collection<RapidReview>(this);
-
-  @OneToMany({ entity: () => FullReview, mappedBy: 'preprint' })
   fullReviews: Collection<FullReview> = new Collection<FullReview>(this);
-
-  @OneToMany({ entity: () => Request, mappedBy: 'preprint' })
   requests: Collection<Request> = new Collection<Request>(this);
-
-  @ManyToMany({ entity: () => Community, mappedBy: 'preprints' })
   communities: Collection<Community> = new Collection<Community>(this);
-
-  @ManyToMany({ entity: () => Tag, mappedBy: 'preprints' })
   tags: Collection<Tag> = new Collection<Tag>(this);
 
   constructor(
@@ -118,3 +53,53 @@ export class Preprint extends BaseEntity {
     this.contentUrl = contentUrl;
   }
 }
+
+export const preprintSchema = new EntitySchema<Preprint, BaseEntity>({
+  class: Preprint,
+  customRepository: () => PreprintModel,
+  indexes: [
+    {
+      name: 'preprint_trgm',
+      properties: ['title', 'handle', 'abstractText', 'authors'],
+    },
+  ],
+  properties: {
+    handle: { type: 'string', unique: true },
+    title: { type: 'string', columnType: 'text' },
+    authors: { type: 'string', columnType: 'text', nullable: true },
+    isPublished: { type: 'boolean' },
+    abstractText: { type: 'string', columnType: 'text', nullable: true },
+    preprintServer: { type: 'string', nullable: true },
+    datePosted: { type: 'Date', nullable: true },
+    license: { type: 'string', nullable: true },
+    publication: { type: 'string', nullable: true },
+    url: { type: 'string', nullable: true },
+    contentEncoding: { type: 'string', nullable: true },
+    contentUrl: { type: 'string', nullable: true },
+    rapidReviews: {
+      reference: '1:m',
+      entity: () => RapidReview,
+      mappedBy: (rapidReview) => rapidReview.preprint,
+    },
+    fullReviews: {
+      reference: '1:m',
+      entity: () => FullReview,
+      mappedBy: (fullReview) => fullReview.preprint,
+    },
+    requests: {
+      reference: '1:m',
+      entity: () => Request,
+      mappedBy: (request) => request.preprint,
+    },
+    communities: {
+      reference: 'm:n',
+      entity: () => Community,
+      mappedBy: (community) => community.preprints,
+    },
+    tags: {
+      reference: 'm:n',
+      entity: () => Tag,
+      mappedBy: (tag) => tag.preprints,
+    },
+  },
+});
diff --git a/src/backend/models/entities/RapidReview.ts b/src/backend/models/entities/RapidReview.ts
index fc6f49e2..b2c78c2a 100644
--- a/src/backend/models/entities/RapidReview.ts
+++ b/src/backend/models/entities/RapidReview.ts
@@ -1,11 +1,4 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Enum,
-  Index,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { RapidReviewModel } from '../rapidReviews';
 import { BaseEntity } from './BaseEntity';
 import { Persona } from './Persona';
@@ -18,64 +11,24 @@ enum Checkboxes {
   unsure = 'unsure',
 }
 
-@Entity()
-@Index({ properties: ['author'] })
-@Index({ properties: ['preprint'] })
 export class RapidReview extends BaseEntity {
-  [EntityRepositoryType]?: RapidReviewModel;
-
-  @ManyToOne({ entity: () => Persona })
   author!: Persona;
-
-  @ManyToOne({ entity: () => Preprint })
   preprint!: Preprint;
-
-  @Property()
   isPublished: boolean = false;
-
-  @Property()
   isFlagged: boolean = false;
-
-  @Enum(() => Checkboxes)
   ynNovel = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynFuture = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynReproducibility = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynMethods = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynCoherent = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynLimitations = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynEthics = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynNewData = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynRecommend = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynPeerReview = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynAvailableCode = Checkboxes.na;
-
-  @Enum(() => Checkboxes)
   ynAvailableData = Checkboxes.na;
-
-  @Property({ columnType: 'text', nullable: true })
   linkToData?: string;
-
-  @Property({ columnType: 'text', nullable: true })
   coi?: string;
 
   constructor(author: Persona, preprint: Preprint) {
@@ -84,3 +37,29 @@ export class RapidReview extends BaseEntity {
     this.preprint = preprint;
   }
 }
+
+export const rapidReviewSchema = new EntitySchema<RapidReview, BaseEntity>({
+  class: RapidReview,
+  customRepository: () => RapidReviewModel,
+  indexes: [{ properties: ['author'] }, { properties: ['preprint'] }],
+  properties: {
+    author: { reference: 'm:1', entity: () => Persona },
+    preprint: { reference: 'm:1', entity: () => Preprint },
+    isPublished: { type: 'boolean' },
+    isFlagged: { type: 'boolean' },
+    ynNovel: { enum: true, items: () => Checkboxes },
+    ynFuture: { enum: true, items: () => Checkboxes },
+    ynReproducibility: { enum: true, items: () => Checkboxes },
+    ynMethods: { enum: true, items: () => Checkboxes },
+    ynCoherent: { enum: true, items: () => Checkboxes },
+    ynLimitations: { enum: true, items: () => Checkboxes },
+    ynEthics: { enum: true, items: () => Checkboxes },
+    ynNewData: { enum: true, items: () => Checkboxes },
+    ynRecommend: { enum: true, items: () => Checkboxes },
+    ynPeerReview: { enum: true, items: () => Checkboxes },
+    ynAvailableCode: { enum: true, items: () => Checkboxes },
+    ynAvailableData: { enum: true, items: () => Checkboxes },
+    linkToData: { type: 'string', columnType: 'text', nullable: true },
+    coi: { type: 'string', columnType: 'text', nullable: true },
+  },
+});
diff --git a/src/backend/models/entities/Report.ts b/src/backend/models/entities/Report.ts
index 1fa27f9e..2dd9aa7c 100644
--- a/src/backend/models/entities/Report.ts
+++ b/src/backend/models/entities/Report.ts
@@ -1,32 +1,13 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { ReportModel } from '../reports';
 import { BaseEntity } from './BaseEntity';
 import { Persona } from './Persona';
 
-@Entity()
-@Index({ properties: ['author'] })
 export class Report extends BaseEntity {
-  [EntityRepositoryType]?: ReportModel;
-
-  @Property({ columnType: 'text', nullable: true })
   reason?: string;
-
-  @Property({ columnType: 'text', nullable: true })
   title?: string;
-
-  @ManyToOne({ entity: () => Persona })
   author!: Persona;
-
-  @Property()
   subject!: string;
-
-  @Property()
   subjectType!: string;
 
   constructor(
@@ -44,3 +25,16 @@ export class Report extends BaseEntity {
     this.title = title;
   }
 }
+
+export const reportSchema = new EntitySchema<Report, BaseEntity>({
+  class: Report,
+  customRepository: () => ReportModel,
+  indexes: [{ properties: ['author'] }],
+  properties: {
+    reason: { type: 'string', columnType: 'text', nullable: true },
+    title: { type: 'string', columnType: 'text', nullable: true },
+    author: { reference: 'm:1', entity: () => Persona },
+    subject: { type: 'string' },
+    subjectType: { type: 'string' },
+  },
+});
diff --git a/src/backend/models/entities/Request.ts b/src/backend/models/entities/Request.ts
index 366d8ee7..73741abe 100644
--- a/src/backend/models/entities/Request.ts
+++ b/src/backend/models/entities/Request.ts
@@ -1,28 +1,12 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { RequestModel } from '../requests';
 import { BaseEntity } from './BaseEntity';
 import { Persona } from './Persona';
 import { Preprint } from './Preprint';
 
-@Entity()
-@Index({ properties: ['author'] })
-@Index({ properties: ['preprint'] })
 export class Request extends BaseEntity {
-  [EntityRepositoryType]?: RequestModel;
-
-  @ManyToOne({ entity: () => Persona })
   author!: Persona;
-
-  @ManyToOne({ entity: () => Preprint })
   preprint!: Preprint;
-
-  @Property()
   isPreprintAuthor: boolean = false;
 
   constructor(author: Persona, preprint: Preprint, isPreprintAuthor = false) {
@@ -32,3 +16,14 @@ export class Request extends BaseEntity {
     this.isPreprintAuthor = isPreprintAuthor;
   }
 }
+
+export const requestSchema = new EntitySchema<Request, BaseEntity>({
+  class: Request,
+  customRepository: () => RequestModel,
+  indexes: [{ properties: ['author'] }, { properties: ['preprint'] }],
+  properties: {
+    author: { reference: 'm:1', entity: () => Persona },
+    preprint: { reference: 'm:1', entity: () => Preprint },
+    isPreprintAuthor: { type: 'boolean' },
+  },
+});
diff --git a/src/backend/models/entities/Statement.ts b/src/backend/models/entities/Statement.ts
index 556622d5..436b26b2 100644
--- a/src/backend/models/entities/Statement.ts
+++ b/src/backend/models/entities/Statement.ts
@@ -1,31 +1,13 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { StatementModel } from '../statements';
 import { BaseEntity } from './BaseEntity';
 import { FullReview } from './FullReview';
 import { Persona } from './Persona';
 
-@Entity()
-@Index({ properties: ['author'] })
-@Index({ properties: ['parent'] })
 export class Statement extends BaseEntity {
-  [EntityRepositoryType]?: StatementModel;
-
-  @Property({ columnType: 'text' })
   contents!: string;
-
-  @Property()
   isFlagged: boolean = false;
-
-  @ManyToOne({ entity: () => Persona })
   author!: Persona;
-
-  @ManyToOne({ entity: () => FullReview })
   parent!: FullReview;
 
   constructor(contents: string, author: Persona, parent: FullReview) {
@@ -35,3 +17,15 @@ export class Statement extends BaseEntity {
     this.parent = parent;
   }
 }
+
+export const statementSchema = new EntitySchema<Statement, BaseEntity>({
+  class: Statement,
+  customRepository: () => StatementModel,
+  indexes: [{ properties: ['author'] }, { properties: ['parent'] }],
+  properties: {
+    contents: { type: 'string', columnType: 'text' },
+    isFlagged: { type: 'boolean' },
+    author: { reference: 'm:1', entity: () => Persona },
+    parent: { reference: 'm:1', entity: () => FullReview },
+  },
+});
diff --git a/src/backend/models/entities/Tag.ts b/src/backend/models/entities/Tag.ts
index b3f34f26..fb851fe4 100644
--- a/src/backend/models/entities/Tag.ts
+++ b/src/backend/models/entities/Tag.ts
@@ -1,31 +1,13 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  ManyToMany,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { TagModel } from '../tags';
 import { BaseEntity } from './BaseEntity';
 import { Community } from './Community';
 import { Preprint } from './Preprint';
 
-@Entity()
 export class Tag extends BaseEntity {
-  [EntityRepositoryType]?: TagModel;
-
-  @Property()
-  @Unique()
   name!: string;
-
-  @Property()
   color?: string;
-
-  @ManyToMany({ entity: () => Preprint, inversedBy: 'tags' })
   preprints: Collection<Preprint> = new Collection<Preprint>(this);
-
-  @ManyToMany({ entity: () => Community, mappedBy: 'tags' })
   communities: Collection<Community> = new Collection<Community>(this);
 
   constructor(name: string, color = '#FF0000') {
@@ -34,3 +16,22 @@ export class Tag extends BaseEntity {
     this.color = color;
   }
 }
+
+export const tagSchema = new EntitySchema<Tag, BaseEntity>({
+  class: Tag,
+  customRepository: () => TagModel,
+  properties: {
+    name: { type: 'string', unique: true },
+    color: { type: 'string' },
+    preprints: {
+      reference: 'm:n',
+      entity: () => Preprint,
+      inversedBy: (preprint) => preprint.tags,
+    },
+    communities: {
+      reference: 'm:n',
+      entity: () => Community,
+      mappedBy: (community) => community.tags,
+    },
+  },
+});
diff --git a/src/backend/models/entities/Template.ts b/src/backend/models/entities/Template.ts
index 50208cc5..e2bb4350 100644
--- a/src/backend/models/entities/Template.ts
+++ b/src/backend/models/entities/Template.ts
@@ -1,28 +1,11 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToOne,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { TemplateModel } from '../templates';
 import { BaseEntity } from './BaseEntity';
 import { Community } from './Community';
 
-@Entity()
-@Index({ properties: ['community'] })
 export class Template extends BaseEntity {
-  [EntityRepositoryType]?: TemplateModel;
-
-  @Property()
-  @Unique()
   title!: string;
-
-  @Property({ columnType: 'text' })
   contents!: string;
-
-  @ManyToOne({ entity: () => Community, nullable: true })
   community?: Community;
 
   constructor(title: string, contents: string, community?: Community) {
@@ -32,3 +15,14 @@ export class Template extends BaseEntity {
     this.community = community;
   }
 }
+
+export const templateSchema = new EntitySchema<Template, BaseEntity>({
+  class: Template,
+  customRepository: () => TemplateModel,
+  indexes: [{ properties: ['community'] }],
+  properties: {
+    title: { type: 'string', unique: true },
+    contents: { type: 'string', columnType: 'text' },
+    community: { reference: 'm:1', entity: () => Community, nullable: true },
+  },
+});
diff --git a/src/backend/models/entities/User.ts b/src/backend/models/entities/User.ts
index 4febb908..83c16532 100644
--- a/src/backend/models/entities/User.ts
+++ b/src/backend/models/entities/User.ts
@@ -1,13 +1,4 @@
-import {
-  Collection,
-  Entity,
-  EntityRepositoryType,
-  ManyToMany,
-  OneToMany,
-  OneToOne,
-  Property,
-  Unique,
-} from '@mikro-orm/core';
+import { Collection, EntitySchema } from '@mikro-orm/core';
 import { UserModel } from '../users';
 import { BaseEntity } from './BaseEntity';
 import { Community } from './Community';
@@ -17,36 +8,15 @@ import { Persona } from './Persona';
 import { Work } from './Work';
 import { Key } from './Key';
 
-@Entity()
 export class User extends BaseEntity {
-  [EntityRepositoryType]?: UserModel;
-
-  @Unique()
-  @Property()
   orcid!: string;
-
-  @OneToOne({ entity: () => Persona, nullable: true })
   defaultPersona?: Persona;
-
-  @Property()
   isPrivate?: boolean;
-
-  @ManyToMany({ entity: () => Group, mappedBy: 'members' })
   groups: Collection<Group> = new Collection<Group>(this);
-
-  @ManyToMany({ entity: () => Community, mappedBy: 'owners' })
   owned: Collection<Community> = new Collection<Community>(this);
-
-  @OneToMany({ entity: () => Persona, mappedBy: 'identity' })
   personas: Collection<Persona> = new Collection<Persona>(this);
-
-  @OneToMany({ entity: () => Contact, mappedBy: 'identity' })
   contacts: Collection<Contact> = new Collection<Contact>(this);
-
-  @OneToMany({ entity: () => Work, mappedBy: 'author' })
   works: Collection<Work> = new Collection<Work>(this);
-
-  @OneToMany({ entity: () => Key, mappedBy: 'owner' })
   keys: Collection<Key> = new Collection<Key>(this);
 
   constructor(orcid: string, isPrivate = false, defaultPersona?: Persona) {
@@ -58,3 +28,39 @@ export class User extends BaseEntity {
     }
   }
 }
+
+export const userSchema = new EntitySchema<User, BaseEntity>({
+  class: User,
+  customRepository: () => UserModel,
+  properties: {
+    orcid: { type: 'string', unique: true },
+    defaultPersona: { reference: '1:1', entity: () => Persona, nullable: true },
+    isPrivate: { type: 'boolean' },
+    groups: {
+      reference: 'm:n',
+      entity: () => Group,
+      mappedBy: (group) => group.members,
+    },
+    owned: {
+      reference: 'm:n',
+      entity: () => Community,
+      mappedBy: (community) => community.owners,
+    },
+    personas: {
+      reference: '1:m',
+      entity: () => Persona,
+      mappedBy: (persona) => persona.identity,
+    },
+    contacts: {
+      reference: '1:m',
+      entity: () => Contact,
+      mappedBy: (contact) => contact.identity,
+    },
+    works: {
+      reference: '1:m',
+      entity: () => Work,
+      mappedBy: (work) => work.author,
+    },
+    keys: { reference: '1:m', entity: () => Key, mappedBy: (key) => key.owner },
+  },
+});
diff --git a/src/backend/models/entities/Work.ts b/src/backend/models/entities/Work.ts
index 873562c6..e5084ced 100644
--- a/src/backend/models/entities/Work.ts
+++ b/src/backend/models/entities/Work.ts
@@ -1,38 +1,15 @@
-import {
-  Entity,
-  EntityRepositoryType,
-  Index,
-  ManyToOne,
-  Property,
-} from '@mikro-orm/core';
+import { EntitySchema } from '@mikro-orm/core';
 import { WorkModel } from '../works';
 import { BaseEntity } from './BaseEntity';
 import { User } from './User';
 
-@Entity()
-@Index({ properties: ['author'] })
 export class Work extends BaseEntity {
-  [EntityRepositoryType]?: WorkModel;
-
-  @Property({ columnType: 'text', nullable: true })
   title?: string;
-
-  @ManyToOne({ entity: () => User })
   author!: User;
-
-  @Property({ columnType: 'text', nullable: true })
   url?: string;
-
-  @Property({ nullable: true })
   type?: string;
-
-  @Property({ nullable: true })
   handle?: string;
-
-  @Property({ nullable: true })
   publicationDate?: Date;
-
-  @Property({ columnType: 'text', nullable: true })
   publisher?: string;
 
   constructor(
@@ -54,3 +31,18 @@ export class Work extends BaseEntity {
     this.publisher = publisher;
   }
 }
+
+export const workSchema = new EntitySchema<Work, BaseEntity>({
+  class: Work,
+  customRepository: () => WorkModel,
+  indexes: [{ properties: ['author'] }],
+  properties: {
+    title: { type: 'string', columnType: 'text', nullable: true },
+    author: { reference: 'm:1', entity: () => User },
+    url: { type: 'string', columnType: 'text', nullable: true },
+    type: { type: 'string', nullable: true },
+    handle: { type: 'string', nullable: true },
+    publicationDate: { type: 'Date', nullable: true },
+    publisher: { type: 'string', columnType: 'text', nullable: true },
+  },
+});
diff --git a/src/backend/models/events.ts b/src/backend/models/events.ts
index 18895a78..598a49a1 100644
--- a/src/backend/models/events.ts
+++ b/src/backend/models/events.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Event } from './entities';
 
-@Repository(Event)
 export class EventModel extends EntityRepository<Event> {}
 
 export function eventModelWrapper(db: MikroORM): EventModel {
diff --git a/src/backend/models/expertises.ts b/src/backend/models/expertises.ts
index e5825d11..9f341bce 100644
--- a/src/backend/models/expertises.ts
+++ b/src/backend/models/expertises.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Expertise } from './entities';
 
-@Repository(Expertise)
 export class ExpertiseModel extends EntityRepository<Expertise> {}
 
 export function expertiseModelWrapper(db: MikroORM): ExpertiseModel {
diff --git a/src/backend/models/fullReviewDrafts.ts b/src/backend/models/fullReviewDrafts.ts
index 8b00af97..db014d15 100644
--- a/src/backend/models/fullReviewDrafts.ts
+++ b/src/backend/models/fullReviewDrafts.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { FullReviewDraft } from './entities';
 
-@Repository(FullReviewDraft)
 export class FullReviewDraftModel extends EntityRepository<FullReviewDraft> {
   async search(query: string): Promise<unknown> {
     const connection = this.em.getConnection();
diff --git a/src/backend/models/fullReviews.ts b/src/backend/models/fullReviews.ts
index adae91d3..a170cc2e 100644
--- a/src/backend/models/fullReviews.ts
+++ b/src/backend/models/fullReviews.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { FullReview } from './entities';
 
-@Repository(FullReview)
 export class FullReviewModel extends EntityRepository<FullReview> {}
 
 export function fullReviewModelWrapper(db: MikroORM): FullReviewModel {
diff --git a/src/backend/models/groups.ts b/src/backend/models/groups.ts
index e4bf0995..14f2a04b 100644
--- a/src/backend/models/groups.ts
+++ b/src/backend/models/groups.ts
@@ -1,4 +1,4 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { ORCID as orcidUtils } from 'orcid-utils';
 import { validate as uuidValidate } from 'uuid';
 import { Group, User } from './entities';
@@ -6,7 +6,6 @@ import { getLogger } from '../log';
 
 const log = getLogger('backend:models:groups');
 
-@Repository(Group)
 export class GroupModel extends EntityRepository<Group> {
   async isMemberOf(groupName: string, userId: string): Promise<boolean> {
     const group = await this.findOne({ name: groupName }, ['members']);
diff --git a/src/backend/models/keys.ts b/src/backend/models/keys.ts
index 180ad9de..760b60ce 100644
--- a/src/backend/models/keys.ts
+++ b/src/backend/models/keys.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Key } from './entities';
 
-@Repository(Key)
 export class KeyModel extends EntityRepository<Key> {}
 
 export function keyModelWrapper(db: MikroORM): KeyModel {
diff --git a/src/backend/models/personas.ts b/src/backend/models/personas.ts
index 675a21d5..dad98c8f 100644
--- a/src/backend/models/personas.ts
+++ b/src/backend/models/personas.ts
@@ -1,4 +1,4 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { ORCID as orcidUtils } from 'orcid-utils';
 import { validate as uuidValidate } from 'uuid';
 import { Persona, User } from './entities';
@@ -6,7 +6,6 @@ import { getLogger } from '../log';
 
 const log = getLogger('backend:models:personas');
 
-@Repository(Persona)
 export class PersonaModel extends EntityRepository<Persona> {
   async isIdentityOf(personaId: string, userId: string): Promise<boolean> {
     let persona: Persona | null = null;
diff --git a/src/backend/models/preprints.ts b/src/backend/models/preprints.ts
index fe1208c6..3dc0dc50 100644
--- a/src/backend/models/preprints.ts
+++ b/src/backend/models/preprints.ts
@@ -1,4 +1,4 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Preprint } from './entities';
 import { decodePreprintId } from '../../common/utils/ids';
 import ChainedError from 'typescript-chained-error';
@@ -6,7 +6,6 @@ import { getLogger } from '../log';
 
 const log = getLogger('backend:model:preprints');
 
-@Repository(Preprint)
 export class PreprintModel extends EntityRepository<Preprint> {
   async findOneByUuidOrHandle(value: string, params: string[]): Promise<Preprint> {
     try {
diff --git a/src/backend/models/rapidReviews.ts b/src/backend/models/rapidReviews.ts
index 55cf10ae..431f49c0 100644
--- a/src/backend/models/rapidReviews.ts
+++ b/src/backend/models/rapidReviews.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { RapidReview } from './entities';
 
-@Repository(RapidReview)
 export class RapidReviewModel extends EntityRepository<RapidReview> {}
 
 export function rapidReviewModelWrapper(db: MikroORM): RapidReviewModel {
diff --git a/src/backend/models/reports.ts b/src/backend/models/reports.ts
index 15009858..1be6819a 100644
--- a/src/backend/models/reports.ts
+++ b/src/backend/models/reports.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Report } from './entities';
 
-@Repository(Report)
 export class ReportModel extends EntityRepository<Report> {}
 
 export function reportModelWrapper(db: MikroORM): ReportModel {
diff --git a/src/backend/models/requests.ts b/src/backend/models/requests.ts
index 9c82b65a..cf453700 100644
--- a/src/backend/models/requests.ts
+++ b/src/backend/models/requests.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Request } from './entities';
 
-@Repository(Request)
 export class RequestModel extends EntityRepository<Request> {}
 
 export function requestModelWrapper(db: MikroORM): RequestModel {
diff --git a/src/backend/models/statements.ts b/src/backend/models/statements.ts
index 4d0cdc27..ee0f3bc3 100644
--- a/src/backend/models/statements.ts
+++ b/src/backend/models/statements.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Statement } from './entities';
 
-@Repository(Statement)
 export class StatementModel extends EntityRepository<Statement> {}
 
 export function statementModelWrapper(db: MikroORM): StatementModel {
diff --git a/src/backend/models/tags.ts b/src/backend/models/tags.ts
index 12c46954..a0728d86 100644
--- a/src/backend/models/tags.ts
+++ b/src/backend/models/tags.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Tag } from './entities';
 
-@Repository(Tag)
 export class TagModel extends EntityRepository<Tag> {}
 
 export function tagModelWrapper(db: MikroORM): TagModel {
diff --git a/src/backend/models/templates.ts b/src/backend/models/templates.ts
index e3bf3986..2581bf38 100644
--- a/src/backend/models/templates.ts
+++ b/src/backend/models/templates.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Template } from './entities';
 
-@Repository(Template)
 export class TemplateModel extends EntityRepository<Template> {}
 
 export function templateModelWrapper(db: MikroORM): TemplateModel {
diff --git a/src/backend/models/users.ts b/src/backend/models/users.ts
index 65f593ad..85c66891 100644
--- a/src/backend/models/users.ts
+++ b/src/backend/models/users.ts
@@ -1,10 +1,9 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { ORCID as orcidUtils } from 'orcid-utils';
 import { validate as uuidValidate } from 'uuid';
 import { User } from './entities';
 import ChainedError from 'typescript-chained-error';
 
-@Repository(User)
 export class UserModel extends EntityRepository<User> {
   findOneByUuidOrOrcid(value: string, params: string[]): Promise<User | null> {
     try {
diff --git a/src/backend/models/works.ts b/src/backend/models/works.ts
index 007e74c2..7abb1f80 100644
--- a/src/backend/models/works.ts
+++ b/src/backend/models/works.ts
@@ -1,7 +1,6 @@
-import { EntityRepository, MikroORM, Repository } from '@mikro-orm/core';
+import { EntityRepository, MikroORM } from '@mikro-orm/core';
 import { Work } from './entities';
 
-@Repository(Work)
 export class WorkModel extends EntityRepository<Work> {}
 
 export function workModelWrapper(db: MikroORM): WorkModel {
diff --git a/src/backend/utils/getFields.ts b/src/backend/utils/getFields.ts
index d46f85d3..846c237b 100644
--- a/src/backend/utils/getFields.ts
+++ b/src/backend/utils/getFields.ts
@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 import { FindOptions, MetadataStorage } from '@mikro-orm/core';
 import * as entities from '../models/entities';
 
diff --git a/tsconfig.json b/tsconfig.json
index a27474d4..3bf253bf 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -9,8 +9,6 @@
     "allowSyntheticDefaultImports": true,
     "noLib": false,
     "lib": ["es2017", "dom"],
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
     "target": "es6",
     "sourceMap": true,
     "allowJs": true,