diff --git a/.changeset/little-pets-cross.md b/.changeset/little-pets-cross.md
new file mode 100644
index 0000000000..0f4e2605cd
--- /dev/null
+++ b/.changeset/little-pets-cross.md
@@ -0,0 +1,5 @@
+---
+'@backstage/catalog-model': patch
+---
+
+Replace `yup` with `ajv`, for validation of catalog entities.
diff --git a/.changeset/metal-pans-leave.md b/.changeset/metal-pans-leave.md
new file mode 100644
index 0000000000..16d5478e43
--- /dev/null
+++ b/.changeset/metal-pans-leave.md
@@ -0,0 +1,5 @@
+---
+'@backstage/config-loader': patch
+---
+
+Bump `config-loader` to `ajv` 7, to enable v7 feature use elsewhere
diff --git a/.changeset/six-ravens-heal.md b/.changeset/six-ravens-heal.md
new file mode 100644
index 0000000000..960c482be9
--- /dev/null
+++ b/.changeset/six-ravens-heal.md
@@ -0,0 +1,5 @@
+---
+'@backstage/catalog-model': patch
+---
+
+Introduce json schema variants of the `yup` validation schemas
diff --git a/packages/catalog-model/package.json b/packages/catalog-model/package.json
index 0b05f489a1..e81bc3a9b6 100644
--- a/packages/catalog-model/package.json
+++ b/packages/catalog-model/package.json
@@ -32,6 +32,7 @@
     "@backstage/config": "^0.1.2",
     "@types/json-schema": "^7.0.5",
     "@types/yup": "^0.29.8",
+    "ajv": "^7.0.3",
     "json-schema": "^0.2.5",
     "lodash": "^4.17.15",
     "uuid": "^8.0.0",
diff --git a/packages/catalog-model/src/EntityPolicies.test.ts b/packages/catalog-model/src/EntityPolicies.test.ts
index cd869f798c..b67180241e 100644
--- a/packages/catalog-model/src/EntityPolicies.test.ts
+++ b/packages/catalog-model/src/EntityPolicies.test.ts
@@ -1,4 +1,3 @@
-import { Entity } from './entity';
 /*
  * Copyright 2020 Spotify AB
  *
@@ -15,8 +14,8 @@ import { Entity } from './entity';
  * limitations under the License.
  */
 
+import { Entity, EntityPolicy } from './entity';
 import { EntityPolicies } from './EntityPolicies';
-import { EntityPolicy } from './types';
 
 describe('EntityPolicies', () => {
   const p1: jest.Mocked<EntityPolicy> = { enforce: jest.fn() };
diff --git a/packages/catalog-model/src/EntityPolicies.ts b/packages/catalog-model/src/EntityPolicies.ts
index 1f304f8f27..2d576b1670 100644
--- a/packages/catalog-model/src/EntityPolicies.ts
+++ b/packages/catalog-model/src/EntityPolicies.ts
@@ -14,8 +14,7 @@
  * limitations under the License.
  */
 
-import { Entity } from './entity';
-import { EntityPolicy } from './types';
+import { Entity, EntityPolicy } from './entity';
 
 // Helper that requires that all of a set of policies can be successfully
 // applied
diff --git a/packages/catalog-model/src/entity/policies/DefaultNamespaceEntityPolicy.ts b/packages/catalog-model/src/entity/policies/DefaultNamespaceEntityPolicy.ts
index 3119164454..4f5bbe04f4 100644
--- a/packages/catalog-model/src/entity/policies/DefaultNamespaceEntityPolicy.ts
+++ b/packages/catalog-model/src/entity/policies/DefaultNamespaceEntityPolicy.ts
@@ -15,7 +15,7 @@
  */
 
 import lodash from 'lodash';
-import { EntityPolicy } from '../../types';
+import { EntityPolicy } from './types';
 import { ENTITY_DEFAULT_NAMESPACE } from '../constants';
 import { Entity } from '../Entity';
 
diff --git a/packages/catalog-model/src/entity/policies/FieldFormatEntityPolicy.ts b/packages/catalog-model/src/entity/policies/FieldFormatEntityPolicy.ts
index 00add2f63c..1ed13c972c 100644
--- a/packages/catalog-model/src/entity/policies/FieldFormatEntityPolicy.ts
+++ b/packages/catalog-model/src/entity/policies/FieldFormatEntityPolicy.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { EntityPolicy } from '../../types';
+import { EntityPolicy } from './types';
 import {
   CommonValidatorFunctions,
   KubernetesValidatorFunctions,
diff --git a/packages/catalog-model/src/entity/policies/NoForeignRootFieldsEntityPolicy.ts b/packages/catalog-model/src/entity/policies/NoForeignRootFieldsEntityPolicy.ts
index 9d1851bc02..7d401542ba 100644
--- a/packages/catalog-model/src/entity/policies/NoForeignRootFieldsEntityPolicy.ts
+++ b/packages/catalog-model/src/entity/policies/NoForeignRootFieldsEntityPolicy.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { EntityPolicy } from '../../types';
+import { EntityPolicy } from './types';
 import { Entity } from '../Entity';
 
 const defaultKnownFields = ['apiVersion', 'kind', 'metadata', 'spec'];
diff --git a/packages/catalog-model/src/entity/policies/SchemaValidEntityPolicy.ts b/packages/catalog-model/src/entity/policies/SchemaValidEntityPolicy.ts
index ed49bea526..7e0a8df268 100644
--- a/packages/catalog-model/src/entity/policies/SchemaValidEntityPolicy.ts
+++ b/packages/catalog-model/src/entity/policies/SchemaValidEntityPolicy.ts
@@ -14,31 +14,12 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
-import { EntityPolicy } from '../../types';
-import { Entity, EntityLink } from '../Entity';
-
-const DEFAULT_ENTITY_SCHEMA = yup
-  .object({
-    apiVersion: yup.string().required(),
-    kind: yup.string().required(),
-    metadata: yup
-      .object({
-        uid: yup.string().notRequired().min(1),
-        etag: yup.string().notRequired().min(1),
-        generation: yup.number().notRequired().integer().min(1),
-        name: yup.string().required(),
-        namespace: yup.string().notRequired(),
-        description: yup.string().notRequired(),
-        labels: yup.object<Record<string, string>>().notRequired(),
-        annotations: yup.object<Record<string, string>>().notRequired(),
-        tags: yup.array<string>().notRequired(),
-        links: yup.array<EntityLink>().notRequired(),
-      })
-      .required(),
-    spec: yup.object({}).notRequired(),
-  })
-  .required();
+import Ajv, { ValidateFunction } from 'ajv';
+import entitySchema from '../../schema/Entity.schema.json';
+import entityMetaSchema from '../../schema/EntityMeta.schema.json';
+import commonSchema from '../../schema/shared/common.schema.json';
+import { Entity } from '../Entity';
+import { EntityPolicy } from './types';
 
 /**
  * Ensures that the entity spec is valid according to a schema.
@@ -48,17 +29,28 @@ const DEFAULT_ENTITY_SCHEMA = yup
  * typescript type.
  */
 export class SchemaValidEntityPolicy implements EntityPolicy {
-  private readonly schema: yup.Schema<Entity>;
-
-  constructor(schema: yup.Schema<Entity> = DEFAULT_ENTITY_SCHEMA) {
-    this.schema = schema;
-  }
+  private validate: ValidateFunction<Entity> | undefined;
 
   async enforce(entity: Entity): Promise<Entity> {
-    try {
-      return await this.schema.validate(entity, { strict: true });
-    } catch (e) {
-      throw new Error(`Malformed envelope, ${e}`);
+    if (!this.validate) {
+      const ajv = new Ajv({ allowUnionTypes: true });
+      this.validate = ajv
+        .addSchema([commonSchema, entityMetaSchema], undefined, undefined, true)
+        .compile<Entity>(entitySchema);
     }
+
+    const result = this.validate(entity);
+    if (result === true) {
+      return entity;
+    }
+
+    const [error] = this.validate.errors || [];
+    if (!error) {
+      throw new Error(`Malformed envelope, Unknown error`);
+    }
+
+    throw new Error(
+      `Malformed envelope, ${error.dataPath || '<root>'} ${error.message}`,
+    );
   }
 }
diff --git a/packages/catalog-model/src/entity/policies/index.ts b/packages/catalog-model/src/entity/policies/index.ts
index c381d29a23..5d75ef4d84 100644
--- a/packages/catalog-model/src/entity/policies/index.ts
+++ b/packages/catalog-model/src/entity/policies/index.ts
@@ -18,3 +18,4 @@ export { DefaultNamespaceEntityPolicy } from './DefaultNamespaceEntityPolicy';
 export { FieldFormatEntityPolicy } from './FieldFormatEntityPolicy';
 export { NoForeignRootFieldsEntityPolicy } from './NoForeignRootFieldsEntityPolicy';
 export { SchemaValidEntityPolicy } from './SchemaValidEntityPolicy';
+export type { EntityPolicy } from './types';
diff --git a/packages/catalog-model/src/entity/policies/types.ts b/packages/catalog-model/src/entity/policies/types.ts
new file mode 100644
index 0000000000..415c98bbd2
--- /dev/null
+++ b/packages/catalog-model/src/entity/policies/types.ts
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2021 Spotify AB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { Entity } from '../Entity';
+
+/**
+ * A policy for validation or mutation to be applied to entities as they are
+ * entering the system.
+ */
+export type EntityPolicy = {
+  /**
+   * Applies validation or mutation on an entity.
+   *
+   * @param entity The entity, as validated/mutated so far in the policy tree
+   * @returns The incoming entity, or a mutated version of the same, or
+   *          undefined if this processor could not handle the entity
+   * @throws An error if the entity should be rejected
+   */
+  enforce(entity: Entity): Promise<Entity | undefined>;
+};
diff --git a/packages/catalog-model/src/index.ts b/packages/catalog-model/src/index.ts
index f93a4001a5..976b5f6148 100644
--- a/packages/catalog-model/src/index.ts
+++ b/packages/catalog-model/src/index.ts
@@ -18,5 +18,5 @@ export * from './entity';
 export { EntityPolicies } from './EntityPolicies';
 export * from './kinds';
 export * from './location';
-export type { EntityName, EntityPolicy, EntityRef, JSONSchema } from './types';
+export type { EntityName, EntityRef, JSONSchema } from './types';
 export * from './validation';
diff --git a/packages/catalog-model/src/kinds/ApiEntityV1alpha1.ts b/packages/catalog-model/src/kinds/ApiEntityV1alpha1.ts
index 2c634ff091..5432cafdeb 100644
--- a/packages/catalog-model/src/kinds/ApiEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/ApiEntityV1alpha1.ts
@@ -14,27 +14,16 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
-import { schemaValidator } from './util';
+import schema from '../schema/kinds/API.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'API' as const;
 
-const schema = yup.object<Partial<ApiEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      type: yup.string().required().min(1),
-      lifecycle: yup.string().required().min(1),
-      owner: yup.string().required().min(1),
-      definition: yup.string().required().min(1),
-      system: yup.string().notRequired().min(1),
-    })
-    .required(),
-});
-
 export interface ApiEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -47,8 +36,9 @@ export interface ApiEntityV1alpha1 extends Entity {
   };
 }
 
-export const apiEntityV1alpha1Validator = schemaValidator(
+export const apiEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/ComponentEntityV1alpha1.ts b/packages/catalog-model/src/kinds/ComponentEntityV1alpha1.ts
index c55c48055a..3006a4288c 100644
--- a/packages/catalog-model/src/kinds/ComponentEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/ComponentEntityV1alpha1.ts
@@ -14,29 +14,16 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
-import { schemaValidator } from './util';
+import schema from '../schema/kinds/Component.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'Component' as const;
 
-const schema = yup.object<Partial<ComponentEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      type: yup.string().required().min(1),
-      lifecycle: yup.string().required().min(1),
-      owner: yup.string().required().min(1),
-      subcomponentOf: yup.string().notRequired().min(1),
-      providesApis: yup.array(yup.string().required()).notRequired(),
-      consumesApis: yup.array(yup.string().required()).notRequired(),
-      system: yup.string().notRequired().min(1),
-    })
-    .required(),
-});
-
 export interface ComponentEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -51,8 +38,9 @@ export interface ComponentEntityV1alpha1 extends Entity {
   };
 }
 
-export const componentEntityV1alpha1Validator = schemaValidator(
+export const componentEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/DomainEntityV1alpha1.ts b/packages/catalog-model/src/kinds/DomainEntityV1alpha1.ts
index 60b11aa124..7aab35e367 100644
--- a/packages/catalog-model/src/kinds/DomainEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/DomainEntityV1alpha1.ts
@@ -14,23 +14,16 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
-import { schemaValidator } from './util';
+import schema from '../schema/kinds/Domain.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'Domain' as const;
 
-const schema = yup.object<Partial<DomainEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      owner: yup.string().required().min(1),
-    })
-    .required(),
-});
-
 export interface DomainEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -39,8 +32,9 @@ export interface DomainEntityV1alpha1 extends Entity {
   };
 }
 
-export const domainEntityV1alpha1Validator = schemaValidator(
+export const domainEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/GroupEntityV1alpha1.ts b/packages/catalog-model/src/kinds/GroupEntityV1alpha1.ts
index 6f2664af77..d039fdaba8 100644
--- a/packages/catalog-model/src/kinds/GroupEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/GroupEntityV1alpha1.ts
@@ -14,40 +14,16 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
-import { schemaValidator } from './util';
+import schema from '../schema/kinds/Group.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'Group' as const;
 
-const schema = yup.object<Partial<GroupEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      type: yup.string().required().min(1),
-      profile: yup
-        .object({
-          displayName: yup.string().min(1).notRequired(),
-          email: yup.string().min(1).notRequired(),
-          picture: yup.string().min(1).notRequired(),
-        })
-        .notRequired(),
-      parent: yup.string().notRequired().min(1),
-      // Use these manual tests because yup .required() requires at least
-      // one element and there is no simple workaround -_-
-      // the cast is there to convince typescript that the array itself is
-      // required without using .required()
-      children: yup.array(yup.string().required()).test({
-        name: 'isDefined',
-        message: 'children must be defined',
-        test: v => Boolean(v),
-      }) as yup.ArraySchema<string, object>,
-    })
-    .required(),
-});
-
 export interface GroupEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -63,8 +39,9 @@ export interface GroupEntityV1alpha1 extends Entity {
   };
 }
 
-export const groupEntityV1alpha1Validator = schemaValidator(
+export const groupEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/LocationEntityV1alpha1.ts b/packages/catalog-model/src/kinds/LocationEntityV1alpha1.ts
index 9cd767de94..fb452b6ac7 100644
--- a/packages/catalog-model/src/kinds/LocationEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/LocationEntityV1alpha1.ts
@@ -14,25 +14,16 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
-import { schemaValidator } from './util';
+import schema from '../schema/kinds/Location.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'Location' as const;
 
-const schema = yup.object<Partial<LocationEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      type: yup.string().notRequired().min(1),
-      target: yup.string().notRequired().min(1),
-      targets: yup.array(yup.string().required()).notRequired(),
-    })
-    .required(),
-});
-
 export interface LocationEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -43,8 +34,9 @@ export interface LocationEntityV1alpha1 extends Entity {
   };
 }
 
-export const locationEntityV1alpha1Validator = schemaValidator(
+export const locationEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/ResourceEntityV1alpha1.ts b/packages/catalog-model/src/kinds/ResourceEntityV1alpha1.ts
index 12df7f6664..520a39f02c 100644
--- a/packages/catalog-model/src/kinds/ResourceEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/ResourceEntityV1alpha1.ts
@@ -14,25 +14,16 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
-import { schemaValidator } from './util';
+import schema from '../schema/kinds/Resource.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'Resource' as const;
 
-const schema = yup.object<Partial<ResourceEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      type: yup.string().required().min(1),
-      owner: yup.string().required().min(1),
-      system: yup.string().notRequired().min(1),
-    })
-    .required(),
-});
-
 export interface ResourceEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -43,8 +34,9 @@ export interface ResourceEntityV1alpha1 extends Entity {
   };
 }
 
-export const resourceEntityV1alpha1Validator = schemaValidator(
+export const resourceEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/SystemEntityV1alpha1.ts b/packages/catalog-model/src/kinds/SystemEntityV1alpha1.ts
index 764514efdd..1ee19466f0 100644
--- a/packages/catalog-model/src/kinds/SystemEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/SystemEntityV1alpha1.ts
@@ -14,24 +14,16 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
-import { schemaValidator } from './util';
+import schema from '../schema/kinds/System.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'System' as const;
 
-const schema = yup.object<Partial<SystemEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      owner: yup.string().required().min(1),
-      domain: yup.string().notRequired().min(1),
-    })
-    .required(),
-});
-
 export interface SystemEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -41,8 +33,9 @@ export interface SystemEntityV1alpha1 extends Entity {
   };
 }
 
-export const systemEntityV1alpha1Validator = schemaValidator(
+export const systemEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/TemplateEntityV1alpha1.ts b/packages/catalog-model/src/kinds/TemplateEntityV1alpha1.ts
index b16fcdc7e4..72479c7efa 100644
--- a/packages/catalog-model/src/kinds/TemplateEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/TemplateEntityV1alpha1.ts
@@ -14,27 +14,17 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
+import schema from '../schema/kinds/Template.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
 import type { JSONSchema } from '../types';
-import { schemaValidator } from './util';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'Template' as const;
 
-const schema = yup.object<Partial<TemplateEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      type: yup.string().required().min(1),
-      path: yup.string(),
-      schema: yup.object().required(),
-      templater: yup.string().required(),
-    })
-    .required(),
-});
-
 export interface TemplateEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -46,8 +36,9 @@ export interface TemplateEntityV1alpha1 extends Entity {
   };
 }
 
-export const templateEntityV1alpha1Validator = schemaValidator(
+export const templateEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/UserEntityV1alpha1.ts b/packages/catalog-model/src/kinds/UserEntityV1alpha1.ts
index 16a5a86e05..a8700a496e 100644
--- a/packages/catalog-model/src/kinds/UserEntityV1alpha1.ts
+++ b/packages/catalog-model/src/kinds/UserEntityV1alpha1.ts
@@ -14,38 +14,16 @@
  * limitations under the License.
  */
 
-import * as yup from 'yup';
 import type { Entity } from '../entity/Entity';
-import { schemaValidator } from './util';
+import schema from '../schema/kinds/User.v1alpha1.schema.json';
+import entitySchema from '../schema/Entity.schema.json';
+import entityMetaSchema from '../schema/EntityMeta.schema.json';
+import commonSchema from '../schema/shared/common.schema.json';
+import { ajvCompiledJsonSchemaValidator } from './util';
 
 const API_VERSION = ['backstage.io/v1alpha1', 'backstage.io/v1beta1'] as const;
 const KIND = 'User' as const;
 
-const schema = yup.object<Partial<UserEntityV1alpha1>>({
-  apiVersion: yup.string().required().oneOf(API_VERSION),
-  kind: yup.string().required().equals([KIND]),
-  spec: yup
-    .object({
-      profile: yup
-        .object({
-          displayName: yup.string().min(1).notRequired(),
-          email: yup.string().min(1).notRequired(),
-          picture: yup.string().min(1).notRequired(),
-        })
-        .notRequired(),
-      // Use this manual test because yup .required() requires at least one
-      // element and there is no simple workaround -_-
-      // the cast is there to convince typescript that the array itself is
-      // required without using .required()
-      memberOf: yup.array(yup.string().required()).test({
-        name: 'isDefined',
-        message: 'memberOf must be defined',
-        test: v => Boolean(v),
-      }) as yup.ArraySchema<string, object>,
-    })
-    .required(),
-});
-
 export interface UserEntityV1alpha1 extends Entity {
   apiVersion: typeof API_VERSION[number];
   kind: typeof KIND;
@@ -59,8 +37,9 @@ export interface UserEntityV1alpha1 extends Entity {
   };
 }
 
-export const userEntityV1alpha1Validator = schemaValidator(
+export const userEntityV1alpha1Validator = ajvCompiledJsonSchemaValidator(
   KIND,
   API_VERSION,
   schema,
+  [commonSchema, entityMetaSchema, entitySchema],
 );
diff --git a/packages/catalog-model/src/kinds/util.ts b/packages/catalog-model/src/kinds/util.ts
index f1b02cfba1..4002f2806c 100644
--- a/packages/catalog-model/src/kinds/util.ts
+++ b/packages/catalog-model/src/kinds/util.ts
@@ -14,9 +14,13 @@
  * limitations under the License.
  */
 
+import Ajv, { AnySchema } from 'ajv';
 import * as yup from 'yup';
 import { KindValidator } from './types';
 
+/**
+ * @deprecated We no longer use yup for the catalog model. This utility method will be removed.
+ */
 export function schemaValidator(
   kind: string,
   apiVersion: readonly string[],
@@ -24,10 +28,7 @@ export function schemaValidator(
 ): KindValidator {
   return {
     async check(envelope) {
-      if (
-        kind !== envelope.kind ||
-        !apiVersion.includes(envelope.apiVersion as any)
-      ) {
+      if (kind !== envelope.kind || !apiVersion.includes(envelope.apiVersion)) {
         return false;
       }
       await schema.validate(envelope, { strict: true });
@@ -35,3 +36,38 @@ export function schemaValidator(
     },
   };
 }
+
+export function ajvCompiledJsonSchemaValidator(
+  kind: string,
+  apiVersion: readonly string[],
+  schema: AnySchema,
+  extraSchemas?: AnySchema[],
+): KindValidator {
+  const ajv = new Ajv({ allowUnionTypes: true });
+  if (extraSchemas) {
+    ajv.addSchema(extraSchemas, undefined, undefined, true);
+  }
+  const validate = ajv.compile(schema);
+
+  return {
+    async check(envelope) {
+      if (kind !== envelope.kind || !apiVersion.includes(envelope.apiVersion)) {
+        return false;
+      }
+
+      const result = validate(envelope);
+      if (result === true) {
+        return true;
+      }
+
+      const [error] = validate.errors || [];
+      if (!error) {
+        throw new TypeError(`Malformed ${kind}, Unknown error`);
+      }
+
+      throw new TypeError(
+        `Malformed ${kind}, ${error.dataPath || '<root>'} ${error.message}`,
+      );
+    },
+  };
+}
diff --git a/packages/catalog-model/src/schema/Entity.schema.json b/packages/catalog-model/src/schema/Entity.schema.json
new file mode 100644
index 0000000000..803e025796
--- /dev/null
+++ b/packages/catalog-model/src/schema/Entity.schema.json
@@ -0,0 +1,67 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "Entity",
+  "description": "The format envelope that's common to all versions/kinds of entity.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "Component",
+      "metadata": {
+        "name": "LoremService",
+        "description": "Creates Lorems like a pro.",
+        "labels": {
+          "product_name": "Random value Generator"
+        },
+        "annotations": {
+          "docs": "https://github.com/..../tree/develop/doc"
+        }
+      },
+      "spec": {
+        "type": "service",
+        "lifecycle": "production",
+        "owner": "tools"
+      }
+    }
+  ],
+  "type": "object",
+  "required": ["apiVersion", "kind", "metadata"],
+  "additionalProperties": false,
+  "properties": {
+    "apiVersion": {
+      "type": "string",
+      "description": "The version of specification format for this particular entity that this is written against.",
+      "minLength": 1,
+      "examples": ["backstage.io/v1alpha1", "my-company.net/v1", "1.0"]
+    },
+    "kind": {
+      "type": "string",
+      "description": "The high level entity type being described.",
+      "minLength": 1,
+      "examples": [
+        "API",
+        "Component",
+        "Domain",
+        "Group",
+        "Location",
+        "Resource",
+        "System",
+        "Template",
+        "User"
+      ]
+    },
+    "metadata": {
+      "$ref": "EntityMeta"
+    },
+    "spec": {
+      "type": "object",
+      "description": "The specification data describing the entity itself."
+    },
+    "relations": {
+      "type": "array",
+      "description": "The relations that this entity has with other entities.",
+      "items": {
+        "$ref": "common#relation"
+      }
+    }
+  }
+}
diff --git a/packages/catalog-model/src/schema/EntityMeta.schema.json b/packages/catalog-model/src/schema/EntityMeta.schema.json
new file mode 100644
index 0000000000..ff0f9c84a8
--- /dev/null
+++ b/packages/catalog-model/src/schema/EntityMeta.schema.json
@@ -0,0 +1,117 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "EntityMeta",
+  "description": "Metadata fields common to all versions/kinds of entity.",
+  "examples": [
+    {
+      "uid": "e01199ab-08cc-44c2-8e19-5c29ded82521",
+      "etag": "lsndfkjsndfkjnsdfkjnsd==",
+      "generation": 13,
+      "name": "my-component-yay",
+      "namespace": "the-namespace",
+      "labels": {
+        "backstage.io/custom": "ValueStuff"
+      },
+      "annotations": {
+        "example.com/bindings": "are-secret"
+      },
+      "tags": ["java", "data"]
+    }
+  ],
+  "type": "object",
+  "required": ["name"],
+  "additionalProperties": true,
+  "properties": {
+    "uid": {
+      "type": "string",
+      "description": "A globally unique ID for the entity. This field can not be set by the user at creation time, and the server will reject an attempt to do so. The field will be populated in read operations. The field can (optionally) be specified when performing update or delete operations, but the server is free to reject requests that do so in such a way that it breaks semantics.",
+      "examples": ["e01199ab-08cc-44c2-8e19-5c29ded82521"],
+      "minLength": 1
+    },
+    "etag": {
+      "type": "string",
+      "description": "An opaque string that changes for each update operation to any part of the entity, including metadata. This field can not be set by the user at creation time, and the server will reject an attempt to do so. The field will be populated in read operations. The field can (optionally) be specified when performing update or delete operations, and the server will then reject the operation if it does not match the current stored value.",
+      "examples": ["lsndfkjsndfkjnsdfkjnsd=="],
+      "minLength": 1
+    },
+    "generation": {
+      "type": "integer",
+      "description": "A positive nonzero number that indicates the current generation of data for this entity; the value is incremented each time the spec changes. This field can not be set by the user at creation time, and the server will reject an attempt to do so. The field will be populated in read operations.",
+      "examples": [1],
+      "minimum": 1
+    },
+    "name": {
+      "type": "string",
+      "description": "The name of the entity. Must be unique within the catalog at any given point in time, for any given namespace + kind pair.",
+      "examples": ["metadata-proxy"],
+      "minLength": 1
+    },
+    "namespace": {
+      "type": "string",
+      "description": "The namespace that the entity belongs to.",
+      "default": "default",
+      "examples": ["default", "admin"],
+      "minLength": 1
+    },
+    "description": {
+      "type": "string",
+      "description": "A short (typically relatively few words, on one line) description of the entity."
+    },
+    "labels": {
+      "type": "object",
+      "description": "Key/value pairs of identifying information attached to the entity.",
+      "additionalProperties": true,
+      "patternProperties": {
+        "^.+$": {
+          "type": "string"
+        }
+      }
+    },
+    "annotations": {
+      "type": "object",
+      "description": "Key/value pairs of non-identifying auxiliary information attached to the entity.",
+      "additionalProperties": true,
+      "patternProperties": {
+        "^.+$": {
+          "type": "string"
+        }
+      }
+    },
+    "tags": {
+      "type": "array",
+      "description": "A list of single-valued strings, to for example classify catalog entities in various ways.",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    },
+    "links": {
+      "type": "array",
+      "description": "A list of external hyperlinks related to the entity. Links can provide additional contextual information that may be located outside of Backstage itself. For example, an admin dashboard or external CMS page.",
+      "items": {
+        "type": "object",
+        "required": ["url"],
+        "properties": {
+          "url": {
+            "type": "string",
+            "description": "A url in a standard uri format.",
+            "examples": ["https://admin.example-org.com"],
+            "minLength": 1
+          },
+          "title": {
+            "type": "string",
+            "description": "A user friendly display name for the link.",
+            "examples": ["Admin Dashboard"],
+            "minLength": 1
+          },
+          "icon": {
+            "type": "string",
+            "description": "A key representing a visual icon to be displayed in the UI.",
+            "examples": ["dashboard"],
+            "minLength": 1
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/packages/catalog-model/src/schema/kinds/API.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/API.v1alpha1.schema.json
new file mode 100644
index 0000000000..fae1225764
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/API.v1alpha1.schema.json
@@ -0,0 +1,79 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ApiV1alpha1",
+  "description": "An API describes an interface that can be exposed by a component. The API can be defined in different formats, like OpenAPI, AsyncAPI, GraphQL, gRPC, or other formats.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "API",
+      "metadata": {
+        "name": "artist-api",
+        "description": "Retrieve artist details",
+        "labels": {
+          "product_name": "Random value Generator"
+        },
+        "annotations": {
+          "docs": "https://github.com/..../tree/develop/doc"
+        }
+      },
+      "spec": {
+        "type": "openapi",
+        "lifecycle": "production",
+        "owner": "artist-relations-team",
+        "system": "artist-engagement-portal",
+        "definition": "openapi: \"3.0.0\"\ninfo:..."
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["API"]
+        },
+        "spec": {
+          "type": "object",
+          "required": ["type", "lifecycle", "owner", "definition"],
+          "properties": {
+            "type": {
+              "type": "string",
+              "description": "The type of the API definition.",
+              "examples": ["openapi", "asyncapi", "graphql", "grpc"],
+              "minLength": 1
+            },
+            "lifecycle": {
+              "type": "string",
+              "description": "The lifecycle state of the API.",
+              "examples": ["experimental", "production", "deprecated"],
+              "minLength": 1
+            },
+            "owner": {
+              "type": "string",
+              "description": "An entity reference to the owner of the API.",
+              "examples": ["artist-relations-team", "user:john.johnson"],
+              "minLength": 1
+            },
+            "system": {
+              "type": "string",
+              "description": "An entity reference to the system that the API belongs to.",
+              "minLength": 1
+            },
+            "definition": {
+              "type": "string",
+              "description": "The definition of the API, based on the format defined by the type.",
+              "minLength": 1
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/kinds/Component.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/Component.v1alpha1.schema.json
new file mode 100644
index 0000000000..822059a0ea
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/Component.v1alpha1.schema.json
@@ -0,0 +1,93 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ComponentV1alpha1",
+  "description": "A Component describes a software component. It is typically intimately linked to the source code that constitutes the component, and should be what a developer may regard a \"unit of software\", usually with a distinct deployable or linkable artifact.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "Component",
+      "metadata": {
+        "name": "LoremService",
+        "description": "Creates Lorems like a pro.",
+        "labels": {
+          "product_name": "Random value Generator"
+        },
+        "annotations": {
+          "docs": "https://github.com/..../tree/develop/doc"
+        }
+      },
+      "spec": {
+        "type": "service",
+        "lifecycle": "production",
+        "owner": "tools"
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["Component"]
+        },
+        "spec": {
+          "type": "object",
+          "required": ["type", "lifecycle", "owner"],
+          "properties": {
+            "type": {
+              "type": "string",
+              "description": "The type of component.",
+              "examples": ["service", "website", "library"],
+              "minLength": 1
+            },
+            "lifecycle": {
+              "type": "string",
+              "description": "The lifecycle state of the component.",
+              "examples": ["experimental", "production", "deprecated"],
+              "minLength": 1
+            },
+            "owner": {
+              "type": "string",
+              "description": "An entity reference to the owner of the component.",
+              "examples": ["artist-relations-team", "user:john.johnson"],
+              "minLength": 1
+            },
+            "system": {
+              "type": "string",
+              "description": "An entity reference to the system that the component belongs to.",
+              "minLength": 1
+            },
+            "subcomponentOf": {
+              "type": "string",
+              "description": "An entity reference to another component of which the component is a part.",
+              "minLength": 1
+            },
+            "providesApis": {
+              "type": "array",
+              "description": "An array of entity references to the APIs that are provided by the component.",
+              "items": {
+                "type": "string",
+                "minLength": 1
+              }
+            },
+            "consumesApis": {
+              "type": "array",
+              "description": "An array of entity references to the APIs that are consumed by the component.",
+              "items": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/kinds/Domain.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/Domain.v1alpha1.schema.json
new file mode 100644
index 0000000000..a1a09b1213
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/Domain.v1alpha1.schema.json
@@ -0,0 +1,47 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "DomainV1alpha1",
+  "description": "A Domain groups a collection of systems that share terminology, domain models, business purpose, or documentation, i.e. form a bounded context.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "Domain",
+      "metadata": {
+        "name": "artists",
+        "description": "Everything about artists"
+      },
+      "spec": {
+        "owner": "artist-relations-team"
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["Domain"]
+        },
+        "spec": {
+          "type": "object",
+          "required": ["owner"],
+          "properties": {
+            "owner": {
+              "type": "string",
+              "description": "An entity reference to the owner of the component.",
+              "examples": ["artist-relations-team", "user:john.johnson"],
+              "minLength": 1
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/kinds/Group.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/Group.v1alpha1.schema.json
new file mode 100644
index 0000000000..fc19d98301
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/Group.v1alpha1.schema.json
@@ -0,0 +1,95 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "GroupV1alpha1",
+  "description": "A group describes an organizational entity, such as for example a team, a business unit, or a loose collection of people in an interest group. Members of these groups are modeled in the catalog as kind User.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "Group",
+      "metadata": {
+        "name": "infrastructure",
+        "description": "The infra business unit"
+      },
+      "spec": {
+        "type": "business-unit",
+        "profile": {
+          "displayName": "Infrastructure",
+          "email": "infrastructure@example.com",
+          "picture": "https://example.com/groups/bu-infrastructure.jpeg"
+        },
+        "parent": "ops",
+        "children": ["backstage", "other"]
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["Group"]
+        },
+        "spec": {
+          "type": "object",
+          "required": ["type", "children"],
+          "properties": {
+            "type": {
+              "type": "string",
+              "description": "The type of group. There is currently no enforced set of values for this field, so it is left up to the adopting organization to choose a nomenclature that matches their org hierarchy.",
+              "examples": ["team", "business-unit", "product-area", "root"],
+              "minLength": 1
+            },
+            "profile": {
+              "type": "object",
+              "description": "Optional profile information about the group, mainly for display purposes. All fields of this structure are also optional. The email would be a group email of some form, that the group may wish to be used for contacting them. The picture is expected to be a URL pointing to an image that's representative of the group, and that a browser could fetch and render on a group page or similar.",
+              "properties": {
+                "displayName": {
+                  "type": "string",
+                  "description": "A simple display name to present to users.",
+                  "examples": ["Infrastructure"],
+                  "minLength": 1
+                },
+                "email": {
+                  "type": "string",
+                  "description": "An email where this entity can be reached.",
+                  "examples": ["infrastructure@example.com"],
+                  "minLength": 1
+                },
+                "picture": {
+                  "type": "string",
+                  "description": "The URL of an image that represents this entity.",
+                  "examples": [
+                    "https://example.com/groups/bu-infrastructure.jpeg"
+                  ],
+                  "minLength": 1
+                }
+              }
+            },
+            "parent": {
+              "type": "string",
+              "description": "The immediate parent group in the hierarchy, if any. Not all groups must have a parent; the catalog supports multi-root hierarchies. Groups may however not have more than one parent. This field is an entity reference.",
+              "examples": ["ops"],
+              "minLength": 1
+            },
+            "children": {
+              "type": "array",
+              "description": "The immediate child groups of this group in the hierarchy (whose parent field points to this group). The list must be present, but may be empty if there are no child groups. The items are not guaranteed to be ordered in any particular way. The entries of this array are entity references.",
+              "items": {
+                "type": "string",
+                "examples": ["backstage", "other"],
+                "minLength": 1
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/kinds/Location.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/Location.v1alpha1.schema.json
new file mode 100644
index 0000000000..d633d30229
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/Location.v1alpha1.schema.json
@@ -0,0 +1,68 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "LocationV1alpha1",
+  "description": "A location is a marker that references other places to look for catalog data.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "Location",
+      "metadata": {
+        "name": "org-data"
+      },
+      "spec": {
+        "type": "url",
+        "targets": [
+          "http://github.com/myorg/myproject/org-data-dump/catalog-info-staff.yaml",
+          "http://github.com/myorg/myproject/org-data-dump/catalog-info-consultants.yaml"
+        ]
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["Location"]
+        },
+        "spec": {
+          "type": "object",
+          "required": [],
+          "properties": {
+            "type": {
+              "type": "string",
+              "description": "The single location type, that's common to the targets specified in the spec. If it is left out, it is inherited from the location type that originally read the entity data.",
+              "examples": ["url"],
+              "minLength": 1
+            },
+            "target": {
+              "type": "string",
+              "description": "A single target as a string. Can be either an absolute path/URL (depending on the type), or a relative path such as ./details/catalog-info.yaml which is resolved relative to the location of this Location entity itself.",
+              "examples": ["./details/catalog-info.yaml"],
+              "minLength": 1
+            },
+            "targets": {
+              "type": "array",
+              "description": "A list of targets as strings. They can all be either absolute paths/URLs (depending on the type), or relative paths such as ./details/catalog-info.yaml which are resolved relative to the location of this Location entity itself.",
+              "items": {
+                "type": "string",
+                "examples": [
+                  "./details/catalog-info.yaml",
+                  "http://github.com/myorg/myproject/org-data-dump/catalog-info-staff.yaml"
+                ],
+                "minLength": 1
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/kinds/Resource.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/Resource.v1alpha1.schema.json
new file mode 100644
index 0000000000..b426dd7f94
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/Resource.v1alpha1.schema.json
@@ -0,0 +1,60 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ResourceV1alpha1",
+  "description": "A resource describes the infrastructure a system needs to operate, like BigTable databases, Pub/Sub topics, S3 buckets or CDNs. Modelling them together with components and systems allows to visualize resource footprint, and create tooling around them.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "Resource",
+      "metadata": {
+        "name": "artists-db",
+        "description": "Stores artist details"
+      },
+      "spec": {
+        "type": "database",
+        "owner": "artist-relations-team",
+        "system": "artist-engagement-portal"
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["Resource"]
+        },
+        "spec": {
+          "type": "object",
+          "required": ["type", "owner"],
+          "properties": {
+            "type": {
+              "type": "string",
+              "description": "The type of resource.",
+              "examples": ["database", "s3-bucket", "cluster"],
+              "minLength": 1
+            },
+            "owner": {
+              "type": "string",
+              "description": "An entity reference to the owner of the resource.",
+              "examples": ["artist-relations-team", "user:john.johnson"],
+              "minLength": 1
+            },
+            "system": {
+              "type": "string",
+              "description": "An entity reference to the system that the resource belongs to.",
+              "minLength": 1
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/kinds/System.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/System.v1alpha1.schema.json
new file mode 100644
index 0000000000..2cdbc37076
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/System.v1alpha1.schema.json
@@ -0,0 +1,54 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SystemV1alpha1",
+  "description": "A system is a collection of resources and components. The system may expose or consume one or several APIs. It is viewed as abstraction level that provides potential consumers insights into exposed features without needing a too detailed view into the details of all components. This also gives the owning team the possibility to decide about published artifacts and APIs.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "System",
+      "metadata": {
+        "name": "artist-engagement-portal",
+        "description": "Handy tools to keep artists in the loop"
+      },
+      "spec": {
+        "owner": "artist-relations-team",
+        "domain": "artists"
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["System"]
+        },
+        "spec": {
+          "type": "object",
+          "required": ["owner"],
+          "properties": {
+            "owner": {
+              "type": "string",
+              "description": "An entity reference to the owner of the component.",
+              "examples": ["artist-relations-team", "user:john.johnson"],
+              "minLength": 1
+            },
+            "domain": {
+              "type": "string",
+              "description": "An entity reference to the domain that the system belongs to.",
+              "examples": ["artists"],
+              "minLength": 1
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/kinds/Template.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/Template.v1alpha1.schema.json
new file mode 100644
index 0000000000..5bb83d116b
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/Template.v1alpha1.schema.json
@@ -0,0 +1,94 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "TemplateV1alpha1",
+  "description": "A Template describes a skeleton for use with the Scaffolder. It is used for describing what templating library is supported, and also for documenting the variables that the template requires using JSON Forms Schema.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "Template",
+      "metadata": {
+        "name": "react-ssr-template",
+        "title": "React SSR Template",
+        "description": "Next.js application skeleton for creating isomorphic web applications.",
+        "tags": ["recommended", "react"]
+      },
+      "spec": {
+        "owner": "artist-relations-team",
+        "templater": "cookiecutter",
+        "type": "website",
+        "path": ".",
+        "schema": {
+          "required": ["component-id", "description"],
+          "properties": {
+            "component_id": {
+              "title": "Name",
+              "type": "string",
+              "description": "Unique name of the component"
+            },
+            "description": {
+              "title": "Description",
+              "type": "string",
+              "description": "Description of the component"
+            }
+          }
+        }
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["Template"]
+        },
+        "metadata": {
+          "type": "object",
+          "properties": {
+            "title": {
+              "type": "string",
+              "description": "The nice display name for the template. This field is required as is used to reference the template to the user instead of the metadata.name field.",
+              "examples": ["React SSR Template"],
+              "minLength": 1
+            }
+          }
+        },
+        "spec": {
+          "type": "object",
+          "required": ["type", "templater", "schema"],
+          "properties": {
+            "type": {
+              "type": "string",
+              "description": "The type of component. This field is optional but recommended. The software catalog accepts any type value, but an organization should take great care to establish a proper taxonomy for these. Tools including Backstage itself may read this field and behave differently depending on its value. For example, a website type component may present tooling in the Backstage interface that is specific to just websites.",
+              "examples": ["service", "website", "library"],
+              "minLength": 1
+            },
+            "templater": {
+              "type": "string",
+              "description": "The templating library that is supported by the template skeleton.",
+              "examples": ["cookiecutter"],
+              "minLength": 1
+            },
+            "path": {
+              "type": "string",
+              "description": "The string location where the templater should be run if it is not on the same level as the template.yaml definition.",
+              "examples": ["./cookiecutter/skeleton"],
+              "minLength": 1
+            },
+            "schema": {
+              "type": "object",
+              "description": "The JSONSchema describing the inputs for the template."
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/kinds/User.v1alpha1.schema.json b/packages/catalog-model/src/schema/kinds/User.v1alpha1.schema.json
new file mode 100644
index 0000000000..a71409d5ba
--- /dev/null
+++ b/packages/catalog-model/src/schema/kinds/User.v1alpha1.schema.json
@@ -0,0 +1,80 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "UserV1alpha1",
+  "description": "A user describes a person, such as an employee, a contractor, or similar. Users belong to Group entities in the catalog. These catalog user entries are connected to the way that authentication within the Backstage ecosystem works. See the auth section of the docs for a discussion of these concepts.",
+  "examples": [
+    {
+      "apiVersion": "backstage.io/v1alpha1",
+      "kind": "User",
+      "metadata": {
+        "name": "jdoe"
+      },
+      "spec": {
+        "profile": {
+          "displayName": "Jenny Doe",
+          "email": "jenny-doe@example.com",
+          "picture": "https://example.com/staff/jenny-with-party-hat.jpeg"
+        },
+        "memberOf": ["team-b", "employees"]
+      }
+    }
+  ],
+  "allOf": [
+    {
+      "$ref": "Entity"
+    },
+    {
+      "type": "object",
+      "required": ["spec"],
+      "properties": {
+        "apiVersion": {
+          "enum": ["backstage.io/v1alpha1", "backstage.io/v1beta1"]
+        },
+        "kind": {
+          "enum": ["User"]
+        },
+        "spec": {
+          "type": "object",
+          "required": ["memberOf"],
+          "properties": {
+            "profile": {
+              "type": "object",
+              "description": "Optional profile information about the user, mainly for display purposes. All fields of this structure are also optional. The email would be a primary email of some form, that the user may wish to be used for contacting them. The picture is expected to be a URL pointing to an image that's representative of the user, and that a browser could fetch and render on a profile page or similar.",
+              "properties": {
+                "displayName": {
+                  "type": "string",
+                  "description": "A simple display name to present to users.",
+                  "examples": ["Jenny Doe"],
+                  "minLength": 1
+                },
+                "email": {
+                  "type": "string",
+                  "description": "An email where this user can be reached.",
+                  "examples": ["jenny-doe@example.com"],
+                  "minLength": 1
+                },
+                "picture": {
+                  "type": "string",
+                  "description": "The URL of an image that represents this user.",
+                  "examples": [
+                    "https://example.com/staff/jenny-with-party-hat.jpeg"
+                  ],
+                  "minLength": 1
+                }
+              }
+            },
+            "memberOf": {
+              "type": "array",
+              "description": "The list of groups that the user is a direct member of (i.e., no transitive memberships are listed here). The list must be present, but may be empty if the user is not member of any groups. The items are not guaranteed to be ordered in any particular way. The entries of this array are entity references.",
+              "items": {
+                "type": "string",
+                "examples": ["team-b", "employees"],
+                "minLength": 1
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/catalog-model/src/schema/shared/common.schema.json b/packages/catalog-model/src/schema/shared/common.schema.json
new file mode 100644
index 0000000000..84ae8a4147
--- /dev/null
+++ b/packages/catalog-model/src/schema/shared/common.schema.json
@@ -0,0 +1,50 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "common",
+  "type": "object",
+  "description": "Common definitions to import from other schemas",
+  "definitions": {
+    "reference": {
+      "$id": "#reference",
+      "type": "object",
+      "description": "A reference by name to another entity.",
+      "required": ["kind", "namespace", "name"],
+      "additionalProperties": false,
+      "properties": {
+        "kind": {
+          "type": "string",
+          "description": "The kind field of the entity."
+        },
+        "namespace": {
+          "type": "string",
+          "description": "The metadata.namespace field of the entity."
+        },
+        "name": {
+          "type": "string",
+          "description": "The metadata.name field of the entity."
+        }
+      }
+    },
+    "relation": {
+      "$id": "#relation",
+      "type": "object",
+      "description": "A directed relation from one entity to another.",
+      "required": ["type", "source", "target"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "^\\w+$",
+          "description": "The type of relation."
+        },
+        "source": {
+          "$ref": "#reference"
+        },
+        "target": {
+          "$ref": "#reference"
+        }
+      }
+    }
+  }
+}
diff --git a/packages/catalog-model/src/types.ts b/packages/catalog-model/src/types.ts
index aa96e46102..edac03466d 100644
--- a/packages/catalog-model/src/types.ts
+++ b/packages/catalog-model/src/types.ts
@@ -16,23 +16,6 @@
 
 import { JsonValue } from '@backstage/config';
 import { JSONSchema7 } from 'json-schema';
-import type { Entity } from './entity/Entity';
-
-/**
- * A policy for validation or mutation to be applied to entities as they are
- * entering the system.
- */
-export type EntityPolicy = {
-  /**
-   * Applies validation or mutation on an entity.
-   *
-   * @param entity The entity, as validated/mutated so far in the policy tree
-   * @returns The incoming entity, or a mutated version of the same, or
-   *          undefined if this processor could not handle the entity
-   * @throws An error if the entity should be rejected
-   */
-  enforce(entity: Entity): Promise<Entity | undefined>;
-};
 
 export type JSONSchema = JSONSchema7 & { [key in string]?: JsonValue };
 
diff --git a/packages/cli/package.json b/packages/cli/package.json
index ad45a33d93..35ad049741 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -173,7 +173,9 @@
             "type": "string",
             "visibility": "frontend",
             "description": "Tracking ID for Google Analytics",
-            "example": "UA-000000-0"
+            "examples": [
+              "UA-000000-0"
+            ]
           },
           "listen": {
             "type": "object",
diff --git a/packages/config-loader/package.json b/packages/config-loader/package.json
index 45ceb36e19..3387477231 100644
--- a/packages/config-loader/package.json
+++ b/packages/config-loader/package.json
@@ -32,7 +32,7 @@
   "dependencies": {
     "@backstage/cli-common": "^0.1.1",
     "@backstage/config": "^0.1.1",
-    "ajv": "^6.12.5",
+    "ajv": "^7.0.3",
     "fs-extra": "^9.0.0",
     "json-schema": "^0.2.5",
     "json-schema-merge-allof": "^0.7.0",
diff --git a/packages/config-loader/src/lib/schema/compile.test.ts b/packages/config-loader/src/lib/schema/compile.test.ts
index f03d7e6d10..e1d8ee5999 100644
--- a/packages/config-loader/src/lib/schema/compile.test.ts
+++ b/packages/config-loader/src/lib/schema/compile.test.ts
@@ -29,11 +29,11 @@ describe('compileConfigSchemas', () => {
       },
     ]);
     expect(validate([{ data: { a: 1 }, context: 'test' }])).toEqual({
-      errors: ['Config should be string { type=string } at .a'],
+      errors: ['Config should be string { type=string } at /a'],
       visibilityByPath: new Map(),
     });
     expect(validate([{ data: { b: 'b' }, context: 'test' }])).toEqual({
-      errors: ['Config should be number { type=number } at .b'],
+      errors: ['Config should be number { type=number } at /b'],
       visibilityByPath: new Map(),
     });
   });
@@ -80,10 +80,10 @@ describe('compileConfigSchemas', () => {
     ).toEqual({
       visibilityByPath: new Map(
         Object.entries({
-          '.a': 'frontend',
-          '.b': 'secret',
-          '.d': 'secret',
-          '.d.0': 'frontend',
+          '/a': 'frontend',
+          '/b': 'secret',
+          '/d': 'secret',
+          '/d/0': 'frontend',
         }),
       ),
     });
diff --git a/packages/config-loader/src/lib/schema/compile.ts b/packages/config-loader/src/lib/schema/compile.ts
index f01a4f640a..2607d51f80 100644
--- a/packages/config-loader/src/lib/schema/compile.ts
+++ b/packages/config-loader/src/lib/schema/compile.ts
@@ -42,23 +42,25 @@ export function compileConfigSchemas(
 
   const ajv = new Ajv({
     allErrors: true,
+    allowUnionTypes: true,
     schemas: {
       'https://backstage.io/schema/config-v1': true,
     },
-  }).addKeyword('visibility', {
+  }).addKeyword({
+    keyword: 'visibility',
     metaSchema: {
       type: 'string',
       enum: CONFIG_VISIBILITIES,
     },
     compile(visibility: ConfigVisibility) {
-      return (_data, dataPath) => {
-        if (!dataPath) {
+      return (_data, context) => {
+        if (context?.dataPath === undefined) {
           return false;
         }
         if (visibility && visibility !== 'backend') {
-          const normalizedPath = dataPath.replace(
+          const normalizedPath = context.dataPath.replace(
             /\['?(.*?)'?\]/g,
-            (_, segment) => `.${segment}`,
+            (_, segment) => `/${segment}`,
           );
           visibilityByPath.set(normalizedPath, visibility);
         }
diff --git a/packages/config-loader/src/lib/schema/filtering.test.ts b/packages/config-loader/src/lib/schema/filtering.test.ts
index f6926e3560..feb31ebab0 100644
--- a/packages/config-loader/src/lib/schema/filtering.test.ts
+++ b/packages/config-loader/src/lib/schema/filtering.test.ts
@@ -40,24 +40,24 @@ const data = {
 
 const visibility = new Map<string, ConfigVisibility>(
   Object.entries({
-    '.arr.0': 'frontend',
-    '.arr.1': 'backend',
-    '.arr.2': 'secret',
-    '.obj.f': 'frontend',
-    '.obj.b': 'backend',
-    '.obj.b.s': 'secret',
-    '.objArr.0.f': 'frontend',
-    '.objArr.0.b': 'backend',
-    '.objArr.0.s': 'secret',
-    '.objArr.1.f': 'frontend',
-    '.objArr.1.b': 'backend',
-    '.objArr.1.s': 'secret',
-    '.arrF': 'frontend',
-    '.arrB': 'backend',
-    '.arrS': 'secret',
-    '.objF': 'frontend',
-    '.objB': 'backend',
-    '.objS': 'secret',
+    '/arr/0': 'frontend',
+    '/arr/1': 'backend',
+    '/arr/2': 'secret',
+    '/obj/f': 'frontend',
+    '/obj/b': 'backend',
+    '/obj/b/s': 'secret',
+    '/objArr/0/f': 'frontend',
+    '/objArr/0/b': 'backend',
+    '/objArr/0/s': 'secret',
+    '/objArr/1/f': 'frontend',
+    '/objArr/1/b': 'backend',
+    '/objArr/1/s': 'secret',
+    '/arrF': 'frontend',
+    '/arrB': 'backend',
+    '/arrS': 'secret',
+    '/objF': 'frontend',
+    '/objB': 'backend',
+    '/objS': 'secret',
   }),
 );
 
diff --git a/packages/config-loader/src/lib/schema/filtering.ts b/packages/config-loader/src/lib/schema/filtering.ts
index 10a97f9a7f..93e899c9d8 100644
--- a/packages/config-loader/src/lib/schema/filtering.ts
+++ b/packages/config-loader/src/lib/schema/filtering.ts
@@ -49,7 +49,7 @@ export function filterByVisibility(
       const arr = new Array<JsonValue>();
 
       for (const [index, value] of jsonVal.entries()) {
-        const out = transform(value, `${path}.${index}`);
+        const out = transform(value, `${path}/${index}`);
         if (out !== undefined) {
           arr.push(out);
         }
@@ -68,7 +68,7 @@ export function filterByVisibility(
       if (value === undefined) {
         continue;
       }
-      const out = transform(value, `${path}.${key}`);
+      const out = transform(value, `${path}/${key}`);
       if (out !== undefined) {
         outObj[key] = out;
         hasOutput = true;
diff --git a/packages/config-loader/src/lib/schema/load.test.ts b/packages/config-loader/src/lib/schema/load.test.ts
index baf63525bb..7d9f7cc803 100644
--- a/packages/config-loader/src/lib/schema/load.test.ts
+++ b/packages/config-loader/src/lib/schema/load.test.ts
@@ -85,7 +85,7 @@ describe('loadConfigSchema', () => {
     expect(() =>
       schema2.process([...configs, { data: { key1: 3 }, context: 'test2' }]),
     ).toThrow(
-      'Config validation failed, Config should be string { type=string } at .key1',
+      'Config validation failed, Config should be string { type=string } at /key1',
     );
 
     await expect(
diff --git a/yarn.lock b/yarn.lock
index 43bcf73364..f553207d23 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2478,6 +2478,7 @@
     "@backstage/config" "^0.1.2"
     "@types/json-schema" "^7.0.5"
     "@types/yup" "^0.29.8"
+    ajv "^7.0.3"
     json-schema "^0.2.5"
     lodash "^4.17.15"
     uuid "^8.0.0"
@@ -2489,6 +2490,7 @@
     "@backstage/config" "^0.1.2"
     "@types/json-schema" "^7.0.5"
     "@types/yup" "^0.29.8"
+    ajv "^7.0.3"
     json-schema "^0.2.5"
     lodash "^4.17.15"
     uuid "^8.0.0"
@@ -7970,6 +7972,16 @@ ajv@^6.1.0, ajv@^6.10.0, ajv@^6.10.1, ajv@^6.10.2, ajv@^6.12.4, ajv@^6.12.5, ajv
     json-schema-traverse "^0.4.1"
     uri-js "^4.2.2"
 
+ajv@^7.0.3:
+  version "7.0.3"
+  resolved "https://registry.npmjs.org/ajv/-/ajv-7.0.3.tgz#13ae747eff125cafb230ac504b2406cf371eece2"
+  integrity sha512-R50QRlXSxqXcQP5SvKUrw8VZeypvo12i2IX0EeR5PiZ7bEKeHWgzgo264LDadUsCU42lTJVhFikTqJwNeH34gQ==
+  dependencies:
+    fast-deep-equal "^3.1.1"
+    json-schema-traverse "^1.0.0"
+    require-from-string "^2.0.2"
+    uri-js "^4.2.2"
+
 alphanum-sort@^1.0.0:
   version "1.0.2"
   resolved "https://registry.npmjs.org/alphanum-sort/-/alphanum-sort-1.0.2.tgz#97a1119649b211ad33691d9f9f486a8ec9fbe0a3"
@@ -16954,6 +16966,11 @@ json-schema-traverse@^0.4.1:
   resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
 
+json-schema-traverse@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2"
+  integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==
+
 json-schema@0.2.3:
   version "0.2.3"
   resolved "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13"
@@ -22693,6 +22710,11 @@ require-directory@^2.1.1:
   resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
   integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
 
+require-from-string@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
+  integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
+
 require-main-filename@^1.0.1:
   version "1.0.1"
   resolved "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"