diff --git a/ghost/tiers/.eslintrc.js b/ghost/tiers/.eslintrc.js
new file mode 100644
index 0000000000..c9c1bcb522
--- /dev/null
+++ b/ghost/tiers/.eslintrc.js
@@ -0,0 +1,6 @@
+module.exports = {
+    plugins: ['ghost'],
+    extends: [
+        'plugin:ghost/node'
+    ]
+};
diff --git a/ghost/tiers/README.md b/ghost/tiers/README.md
new file mode 100644
index 0000000000..c3eb735197
--- /dev/null
+++ b/ghost/tiers/README.md
@@ -0,0 +1,23 @@
+# Tiers
+
+'
+
+
+## Usage
+
+
+## Develop
+
+This is a monorepo package.
+
+Follow the instructions for the top-level repo.
+1. `git clone` this repo & `cd` into it as usual
+2. Run `yarn` to install top-level dependencies.
+
+
+
+## Test
+
+- `yarn lint` run just eslint
+- `yarn test` run lint and tests
+
diff --git a/ghost/tiers/index.js b/ghost/tiers/index.js
new file mode 100644
index 0000000000..4f7da35e65
--- /dev/null
+++ b/ghost/tiers/index.js
@@ -0,0 +1,5 @@
+module.exports = {
+    Tier: require('./lib/Tier'),
+    TiersAPI: require('./lib/TiersAPI'),
+    InMemoryTierRepository: require('./lib/InMemoryTierRepository')
+};
diff --git a/ghost/tiers/lib/InMemoryTierRepository.js b/ghost/tiers/lib/InMemoryTierRepository.js
new file mode 100644
index 0000000000..4f6f16e9eb
--- /dev/null
+++ b/ghost/tiers/lib/InMemoryTierRepository.js
@@ -0,0 +1,73 @@
+const nql = require('@tryghost/nql');
+
+/**
+ * @typedef {import('./Tier')} Tier
+ */
+
+class InMemoryTierRepository {
+    /** @type {Tier[]} */
+    #store = [];
+    /** @type {Object.<string, true>} */
+    #ids = {};
+
+    /**
+     * @param {Tier} tier
+     * @returns {any}
+     */
+    toPrimitive(tier) {
+        return {
+            ...tier,
+            id: tier.id.toHexString()
+        };
+    }
+
+    /**
+     * @param {Tier} linkClick
+     * @returns {Promise<void>}
+     */
+    async save(tier) {
+        if (this.#ids[tier.id.toHexString()]) {
+            const existing = this.#store.findIndex((item) => {
+                return item.id.equals(tier.id);
+            });
+            this.#store.splice(existing, 1, tier);
+        } else {
+            this.#store.push(tier);
+            this.#ids[tier.id.toHexString()] = true;
+        }
+    }
+
+    /**
+     * @param {import('bson-objectid').default} id
+     * @returns {Promise<Tier>}
+     */
+    async getById(id) {
+        return this.#store.find((item) => {
+            return item.id.equals(id);
+        });
+    }
+
+    /**
+     * @param {string} slug
+     * @returns {Promise<Tier>}
+     */
+    async getBySlug(slug) {
+        return this.#store.find((item) => {
+            return item.slug === slug;
+        });
+    }
+
+    /**
+     * @param {object} [options]
+     * @param {string} [options.filter]
+     * @returns {Promise<Tier[]>}
+     */
+    async getAll(options = {}) {
+        const filter = nql(options.filter, {});
+        return this.#store.slice().filter((item) => {
+            return filter.queryJSON(this.toPrimitive(item));
+        });
+    }
+}
+
+module.exports = InMemoryTierRepository;
diff --git a/ghost/tiers/lib/Tier.js b/ghost/tiers/lib/Tier.js
new file mode 100644
index 0000000000..0f365ad740
--- /dev/null
+++ b/ghost/tiers/lib/Tier.js
@@ -0,0 +1,430 @@
+const ObjectID = require('bson-objectid').default;
+const {ValidationError} = require('@tryghost/errors');
+
+module.exports = class Tier {
+    /** @type {ObjectID} */
+    #id;
+    get id() {
+        return this.#id;
+    }
+
+    /** @type {string} */
+    #slug;
+    get slug() {
+        return this.#slug;
+    }
+
+    /** @type {string} */
+    #name;
+    get name() {
+        return this.#name;
+    }
+    set name(value) {
+        this.#name = validateName(value);
+    }
+
+    /** @type {string[]} */
+    #benefits;
+    get benefits() {
+        return this.#benefits;
+    }
+    set benefits(value) {
+        this.#benefits = validateBenefits(value);
+    }
+
+    /** @type {string} */
+    #description;
+    get description() {
+        return this.#description;
+    }
+    set description(value) {
+        this.#description = validateDescription(value);
+    }
+
+    /** @type {URL} */
+    #welcomePageURL;
+    get welcomePageURL() {
+        return this.#welcomePageURL;
+    }
+    set welcomePageURL(value) {
+        this.#welcomePageURL = validateWelcomePageURL(value);
+    }
+
+    /** @type {'active'|'archived'} */
+    #status;
+    get status() {
+        return this.#status;
+    }
+    set status(value) {
+        this.#status = validateStatus(value);
+    }
+
+    /** @type {'public'} */
+    #visibility;
+    get visibility() {
+        return this.#visibility;
+    }
+
+    /** @type {'paid'|'free'} */
+    #type;
+    get type() {
+        return this.#type;
+    }
+
+    /** @type {number|null} */
+    #trialDays;
+    get trialDays() {
+        return this.#trialDays;
+    }
+    set trialDays(value) {
+        this.#trialDays = validateTrialDays(value, this.#type);
+    }
+
+    /** @type {string|null} */
+    #currency;
+    get currency() {
+        return this.#currency;
+    }
+    set currency(value) {
+        this.#currency = validateCurrency(value, this.#type);
+    }
+
+    /** @type {number|null} */
+    #monthlyPrice;
+    get monthlyPrice() {
+        return this.#monthlyPrice;
+    }
+    set monthlyPrice(value) {
+        this.#monthlyPrice = validateMonthlyPrice(value, this.#type);
+    }
+
+    /** @type {number|null} */
+    #yearlyPrice;
+    get yearlyPrice() {
+        return this.#yearlyPrice;
+    }
+    set yearlyPrice(value) {
+        this.#yearlyPrice = validateYearlyPrice(value, this.#type);
+    }
+
+    /** @type {Date} */
+    #createdAt;
+    get createdAt() {
+        return this.#createdAt;
+    }
+
+    /** @type {Date|null} */
+    #updatedAt;
+    get updatedAt() {
+        return this.#updatedAt;
+    }
+
+    toJSON() {
+        return {
+            id: this.#id,
+            slug: this.#slug,
+            name: this.#name,
+            description: this.#description,
+            welcomePageURL: this.#welcomePageURL,
+            status: this.#status,
+            visibility: this.#visibility,
+            type: this.#type,
+            trialDays: this.#trialDays,
+            currency: this.#currency,
+            monthlyPrice: this.#monthlyPrice,
+            yearlyPrice: this.#yearlyPrice,
+            createdAt: this.#createdAt,
+            updatedAt: this.#updatedAt,
+            benefits: this.#benefits
+        };
+    }
+
+    /**
+     * @private
+     */
+    constructor(data) {
+        this.#id = data.id;
+        this.#slug = data.slug;
+        this.#name = data.name;
+        this.#description = data.description;
+        this.#welcomePageURL = data.welcome_page_url;
+        this.#status = data.status;
+        this.#visibility = data.visibility;
+        this.#type = data.type;
+        this.#trialDays = data.trial_days;
+        this.#currency = data.currency;
+        this.#monthlyPrice = data.monthly_price;
+        this.#yearlyPrice = data.yearly_price;
+        this.#createdAt = data.created_at;
+        this.#updatedAt = data.updated_at;
+        this.#benefits = data.benefits;
+    }
+
+    /**
+     * @param {any} data
+     * @param {ISlugService} slugService
+     * @returns {Promise<Tier>}
+     */
+    static async create(data, slugService) {
+        let id;
+        if (!data.id) {
+            id = new ObjectID();
+        } else if (typeof data.id === 'string') {
+            id = ObjectID.createFromHexString(data.id);
+        } else if (data.id instanceof ObjectID) {
+            id = data.id;
+        } else {
+            throw new ValidationError({
+                message: 'Invalid ID provided for Tier'
+            });
+        }
+
+        let name = validateName(data.name);
+
+        let slug;
+        if (data.slug) {
+            slug = await slugService.validate(data.slug);
+        } else {
+            slug = await slugService.generate(name);
+        }
+
+        let description = validateDescription(data.description);
+        let welcomePageURL = validateWelcomePageURL(data.welcome_page_url);
+        let status = validateStatus(data.status || 'active');
+        let visibility = validateVisibility(data.visibility || 'public');
+        let type = validateType(data.type || 'paid');
+        let currency = validateCurrency(data.currency || null, type);
+        let trialDays = validateTrialDays(data.trial_days || null, type);
+        let monthlyPrice = validateMonthlyPrice(data.monthly_price || null, type);
+        let yearlyPrice = validateYearlyPrice(data.yearly_price || null , type);
+        let createdAt = validateCreatedAt(data.created_at);
+        let updatedAt = validateUpdatedAt(data.updated_at);
+        let benefits = validateBenefits(data.benefits);
+
+        return new Tier({
+            id,
+            slug,
+            name,
+            description,
+            welcome_page_url: welcomePageURL,
+            status,
+            visibility,
+            type,
+            trial_days: trialDays,
+            currency,
+            monthly_price: monthlyPrice,
+            yearly_price: yearlyPrice,
+            created_at: createdAt,
+            updated_at: updatedAt,
+            benefits
+        });
+    }
+};
+
+function validateName(value) {
+    if (typeof value !== 'string') {
+        throw new ValidationError({
+            message: 'Tier name must be a string with a maximum of 191 characters'
+        });
+    }
+
+    if (value.length > 191) {
+        throw new ValidationError({
+            message: 'Tier name must be a string with a maximum of 191 characters'
+        });
+    }
+
+    return value;
+}
+
+function validateWelcomePageURL(value) {
+    if (value instanceof URL) {
+        return value;
+    }
+    if (!value) {
+        return null;
+    }
+    try {
+        return new URL(value);
+    } catch (err) {
+        throw new ValidationError({
+            err,
+            message: 'Tier Welcome Page URL must be a URL'
+        });
+    }
+}
+
+function validateDescription(value) {
+    if (!value) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        throw new ValidationError({
+            message: 'Tier description must be a string with a maximum of 191 characters'
+        });
+    }
+    if (value.length > 191) {
+        throw new ValidationError({
+            message: 'Tier description must be a string with a maximum of 191 characters'
+        });
+    }
+}
+
+function validateStatus(value) {
+    if (value !== 'active' && value !== 'archived') {
+        throw new ValidationError({
+            message: 'Tier status must be either "active" or "archived"'
+        });
+    }
+    return value;
+}
+
+function validateVisibility(value) {
+    if (value !== 'public' && value !== 'none') {
+        throw new ValidationError({
+            message: 'Tier visibility must be either "public" or "none"'
+        });
+    }
+    return value;
+}
+
+function validateType(value) {
+    if (value !== 'paid' && value !== 'free') {
+        throw new ValidationError({
+            message: 'Tier type must be either "paid" or "free"'
+        });
+    }
+    return value;
+}
+
+function validateTrialDays(value, type) {
+    if (type === 'free') {
+        if (value !== null) {
+            throw new ValidationError({
+                message: 'Free Tiers cannot have a trial'
+            });
+        }
+        return null;
+    }
+    if (!value) {
+        return null;
+    }
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new ValidationError({
+            message: 'Tier trials must be an integer greater than 0'
+        });
+    }
+    return value;
+}
+
+function validateCurrency(value, type) {
+    if (type === 'free') {
+        if (value !== null) {
+            throw new ValidationError({
+                message: 'Free Tiers cannot have a currency'
+            });
+        }
+        return null;
+    }
+    if (typeof value !== 'string') {
+        throw new ValidationError({
+            message: 'Tier currency must be a 3 letter ISO currency code'
+        });
+    }
+    if (value.length !== 3) {
+        throw new ValidationError({
+            message: 'Tier currency must be a 3 letter ISO currency code'
+        });
+    }
+    return value.toUpperCase();
+}
+
+function validateMonthlyPrice(value, type) {
+    if (type === 'free') {
+        if (value !== null) {
+            throw new ValidationError({
+                message: 'Free Tiers cannot have a monthly price'
+            });
+        }
+        return null;
+    }
+    if (!Number.isSafeInteger(value)) {
+        throw new ValidationError({
+            message: ''
+        });
+    }
+    if (value < 0) {
+        throw new ValidationError({
+            message: ''
+        });
+    }
+    if (value > 9999999999) {
+        throw new ValidationError({
+            message: ''
+        });
+    }
+    return value;
+}
+
+function validateYearlyPrice(value, type) {
+    if (type === 'free') {
+        if (value !== null) {
+            throw new ValidationError({
+                message: 'Free Tiers cannot have a yearly price'
+            });
+        }
+        return null;
+    }
+    if (!Number.isSafeInteger(value)) {
+        throw new ValidationError({
+            message: ''
+        });
+    }
+    if (value < 0) {
+        throw new ValidationError({
+            message: ''
+        });
+    }
+    if (value > 9999999999) {
+        throw new ValidationError({
+            message: ''
+        });
+    }
+    return value;
+}
+
+function validateCreatedAt(value) {
+    if (!value) {
+        return new Date();
+    }
+    if (value instanceof Date) {
+        return value;
+    }
+    throw new ValidationError({
+        message: 'Tier created_at must be a date'
+    });
+}
+
+function validateUpdatedAt(value) {
+    if (!value) {
+        return null;
+    }
+    if (value instanceof Date) {
+        return value;
+    }
+    throw new ValidationError({
+        message: 'Tier created_at must be a date'
+    });
+}
+
+function validateBenefits(value) {
+    if (!value) {
+        return [];
+    }
+    if (!Array.isArray(value) || !value.every(item => typeof item === 'string')) {
+        throw new ValidationError({
+            message: 'Tier benefits must be a list of strings'
+        });
+    }
+    return value;
+}
diff --git a/ghost/tiers/lib/TierSlugService.js b/ghost/tiers/lib/TierSlugService.js
new file mode 100644
index 0000000000..b874b9b5f9
--- /dev/null
+++ b/ghost/tiers/lib/TierSlugService.js
@@ -0,0 +1,33 @@
+const {ValidationError} = require('@tryghost/errors');
+const {slugify} = require('@tryghost/string');
+
+module.exports = class TierSlugService {
+    /** @type {import('./TiersAPI').ITierRepository} */
+    #repository;
+
+    constructor(deps) {
+        this.#repository = deps.repository;
+    }
+
+    async validate(slug) {
+        const exists = !!(await this.#repository.getBySlug(slug));
+
+        if (!exists) {
+            return slug;
+        }
+
+        throw new ValidationError({
+            message: 'Slug already exists'
+        });
+    }
+
+    async generate(input, n = 0) {
+        const slug = slugify(input + (n ? n : ''));
+
+        try {
+            return await this.validate(slug);
+        } catch (err) {
+            return this.generate(input, n + 1);
+        }
+    }
+};
diff --git a/ghost/tiers/lib/TiersAPI.js b/ghost/tiers/lib/TiersAPI.js
new file mode 100644
index 0000000000..e9d2f3f46e
--- /dev/null
+++ b/ghost/tiers/lib/TiersAPI.js
@@ -0,0 +1,137 @@
+const ObjectID = require('bson-objectid').default;
+const {BadRequestError} = require('@tryghost/errors');
+const Tier = require('./Tier');
+const TierSlugService = require('./TierSlugService');
+
+/**
+ * @typedef {object} ITierRepository
+ * @prop {(id: ObjectID) => Promise<Tier>} getById
+ * @prop {(slug: string) => Promise<Tier>} getBySlug
+ * @prop {(tier: Tier) => Promise<void>} save
+ * @prop {(options?: {filter?: string}) => Promise<Tier[]>} getAll
+ */
+
+/**
+ * @template {Model}
+ * @typedef {object} Page<Model>
+ * @prop {Model[]} data
+ * @prop {object} meta
+ * @prop {object} meta.pagination
+ * @prop {number} meta.pagination.page - The current page
+ * @prop {number} meta.pagination.pages - The total number of pages
+ * @prop {number} meta.pagination.limit - The limit of models per page
+ * @prop {number} meta.pagination.total - The totaL number of models across all pages
+ * @prop {number|null} meta.pagination.prev - The number of the previous page, or null if there isn't one
+ * @prop {number|null} meta.pagination.next - The number of the next page, or null if there isn't one
+ */
+
+module.exports = class TiersAPI {
+    /** @type {ITierRepository} */
+    #repository;
+
+    /** @type {TierSlugService} */
+    #slugService;
+
+    constructor(deps) {
+        this.#repository = deps.repository;
+        this.#slugService = new TierSlugService({
+            repository: deps.repository
+        });
+    }
+
+    /**
+     * @param {object} [options]
+     * @param {string} [options.filter] - An NQL filter string
+     *
+     * @returns {Promise<Page<Tier>>}
+     */
+    async browse(options = {}) {
+        const tiers = await this.#repository.getAll(options);
+
+        return {
+            data: tiers,
+            meta: {
+                pagination: {
+                    page: 1,
+                    pages: 1,
+                    limit: tiers.length,
+                    total: tiers.length,
+                    prev: null,
+                    next: null
+                }
+            }
+        };
+    }
+
+    /**
+     * @param {string} idString
+     *
+     * @returns {Promise<Tier>}
+     */
+    async read(idString) {
+        const id = ObjectID.createFromHexString(idString);
+        const tier = await this.#repository.getById(id);
+
+        return tier;
+    }
+
+    /**
+     * @param {string} id
+     * @param {object} data
+     * @returns {Promise<Tier>}
+     */
+    async edit(id, data) {
+        const tier = await this.#repository.getById(id);
+
+        const editableProperties = [
+            'name',
+            'benefits',
+            'description',
+            'visibility',
+            'active',
+            'trial_days',
+            'currency',
+            'monthly_price',
+            'yearly_price'
+        ];
+
+        for (const editableProperty of editableProperties) {
+            if (Reflect.has(data, editableProperty)) {
+                tier[editableProperty] = data[editableProperty];
+            }
+        }
+
+        await this.#repository.save(tier);
+
+        return tier;
+    }
+
+    /**
+     * @param {object} data
+     * @returns {Promise<Tier>}
+     */
+    async add(data) {
+        if (data.type !== 'paid') {
+            throw new BadRequestError({
+                message: 'Cannot create free Tier'
+            });
+        }
+        const tier = await Tier.create({
+            type: 'paid',
+            status: 'active',
+            visibility: data.visibility,
+            name: data.name,
+            description: data.description,
+            benefits: data.benefits,
+            welcome_page_url: data.welcome_page_url,
+            monthly_price: data.monthly_price,
+            yearly_price: data.yearly_price,
+            currency: data.currency,
+            trial_days: data.trial_days
+        }, this.#slugService);
+
+        await this.#repository.save(tier);
+
+        return tier;
+    }
+};
diff --git a/ghost/tiers/package.json b/ghost/tiers/package.json
new file mode 100644
index 0000000000..55a126c3cb
--- /dev/null
+++ b/ghost/tiers/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "@tryghost/tiers",
+  "version": "0.0.0",
+  "repository": "https://github.com/TryGhost/Ghost/tree/main/packages/tiers",
+  "author": "Ghost Foundation",
+  "private": true,
+  "main": "index.js",
+  "scripts": {
+    "dev": "echo \"Implement me!\"",
+    "test:unit": "NODE_ENV=testing c8 --all --check-coverage --reporter text --reporter cobertura mocha './test/**/*.test.js'",
+    "test": "yarn test:unit",
+    "lint:code": "eslint *.js lib/ --ext .js --cache",
+    "lint": "yarn lint:code && yarn lint:test",
+    "lint:test": "eslint -c test/.eslintrc.js test/ --ext .js --cache"
+  },
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "devDependencies": {
+    "c8": "7.12.0",
+    "mocha": "10.0.0"
+  },
+  "dependencies": {
+    "@tryghost/errors": "1.2.18",
+    "@tryghost/string": "0.2.1",
+    "@tryghost/tpl": "0.1.19",
+    "bson-objectid": "2.0.3"
+  }
+}
diff --git a/ghost/tiers/test/.eslintrc.js b/ghost/tiers/test/.eslintrc.js
new file mode 100644
index 0000000000..829b601eb0
--- /dev/null
+++ b/ghost/tiers/test/.eslintrc.js
@@ -0,0 +1,6 @@
+module.exports = {
+    plugins: ['ghost'],
+    extends: [
+        'plugin:ghost/test'
+    ]
+};
diff --git a/ghost/tiers/test/Tier.test.js b/ghost/tiers/test/Tier.test.js
new file mode 100644
index 0000000000..1665b8f8fb
--- /dev/null
+++ b/ghost/tiers/test/Tier.test.js
@@ -0,0 +1,163 @@
+const assert = require('assert');
+const ObjectID = require('bson-objectid');
+const Tier = require('../lib/Tier');
+
+async function assertError(fn, checkError) {
+    let error;
+    try {
+        await fn();
+        error = false;
+    } catch (err) {
+        error = err;
+    } finally {
+        assert(error);
+        if (checkError) {
+            checkError(error);
+        }
+    }
+}
+const validInput = {
+    name: 'Tier Name',
+    slug: 'tier-name',
+    description: 'My First Tier',
+    welcome_page_url: null,
+    status: 'active',
+    visibility: 'public',
+    type: 'paid',
+    trial_days: 10,
+    currency: 'usd',
+    monthly_price: 5000,
+    yearly_price: 50000,
+    benefits: []
+};
+
+const invalidInputs = [
+    {id: [100]},
+    {name: 100},
+    {name: ('a').repeat(200)},
+    {description: ['whatever?']},
+    {description: ('b').repeat(200)},
+    {welcome_page_url: 'hello world'},
+    {status: 'something random'},
+    {visibility: 'highly visible'},
+    {type: 'comped'},
+    {trial_days: -10},
+    {trial_days: 10, type: 'free', currency: null, monthly_price: null, yearly_price: null},
+    {currency: 'dollar bills'},
+    {currency: 25},
+    {currency: 'USD', type: 'free'},
+    {monthly_price: 2000, type: 'free', trial_days: null, currency: null, yearly_price: null},
+    {monthly_price: null},
+    {monthly_price: -20},
+    {monthly_price: 10000000000},
+    {yearly_price: 2000, type: 'free', trial_days: null, monthly_price: null, currency: null},
+    {yearly_price: null},
+    {yearly_price: -20},
+    {yearly_price: 10000000000},
+    {created_at: 'Today'},
+    {updated_at: 'Tomorrow'}
+];
+
+const validInputs = [
+    {welcome_page_url: new URL('https://google.com')},
+    {id: (new ObjectID()).toHexString()},
+    {id: new ObjectID()},
+    {type: 'free', currency: null, monthly_price: null, yearly_price: null, trial_days: null},
+    {created_at: new Date()},
+    {updated_at: new Date()},
+    {status: undefined},
+    {type: undefined},
+    {visibility: undefined}
+];
+
+describe('Tier', function () {
+    describe('create', function () {
+        it('Errors if passed an invalid input', async function () {
+            for (const invalidInput of invalidInputs) {
+                let input = {};
+                Object.assign(input, validInput, invalidInput);
+                await assertError(async function () {
+                    await Tier.create(input, {validate: x => x, generate: x => x});
+                });
+            }
+        });
+
+        it('Does not error for valid inputs', async function () {
+            for (const validInputItem of validInputs) {
+                let input = {};
+                Object.assign(input, validInput, validInputItem);
+                await Tier.create(input, {validate: x => x, generate: x => x});
+            }
+        });
+
+        it('Can create a Tier with valid input', async function () {
+            const tier = await Tier.create(validInput, {validate: x => x, generate: x => x});
+
+            const expectedProps = [
+                'id',
+                'slug',
+                'name',
+                'description',
+                'welcome_page_url',
+                'status',
+                'visibility',
+                'type',
+                'trial_days',
+                'currency',
+                'monthly_price',
+                'yearly_price',
+                'created_at',
+                'updated_at',
+                'benefits'
+            ];
+
+            for (const prop of expectedProps) {
+                assert(tier[prop] === tier.toJSON()[prop]);
+            }
+        });
+
+        it('Errors when attempting to set invalid properties', async function () {
+            const tier = await Tier.create(validInput, {validate: x => x, generate: x => x});
+
+            assertError(() => {
+                tier.name = 20;
+            });
+
+            assertError(() => {
+                tier.benefits = 20;
+            });
+
+            assertError(() => {
+                tier.description = 20;
+            });
+
+            assertError(() => {
+                tier.welcome_page_url = 20;
+            });
+
+            assertError(() => {
+                tier.status = 20;
+            });
+
+            assertError(() => {
+                tier.visibility = 20;
+            });
+
+            assertError(() => {
+                tier.trial_days = 'one hundred';
+            });
+
+            assertError(() => {
+                tier.currency = 'one hundred';
+            });
+
+            assertError(() => {
+                tier.monthly_price = 'one hundred';
+            });
+
+            assertError(() => {
+                tier.yearly_price = 'one hundred';
+            });
+        });
+    });
+});
diff --git a/ghost/tiers/test/TiersAPI.test.js b/ghost/tiers/test/TiersAPI.test.js
new file mode 100644
index 0000000000..2895cb7ec3
--- /dev/null
+++ b/ghost/tiers/test/TiersAPI.test.js
@@ -0,0 +1,70 @@
+const assert = require('assert');
+const TiersAPI = require('../lib/TiersAPI');
+const InMemoryTierRepository = require('../lib/InMemoryTierRepository');
+
+describe('TiersAPI', function () {
+    /** @type {TiersAPI.ITierRepository} */
+    let repository;
+
+    /** @type {TiersAPI} */
+    let api;
+
+    before(function () {
+        repository = new InMemoryTierRepository();
+        api = new TiersAPI({
+            repository
+        });
+    });
+
+    it('Can not create new free Tiers', async function () {
+        let error;
+        try {
+            await api.add({
+                name: 'My testing Tier',
+                type: 'free'
+            });
+            error = null;
+        } catch (err) {
+            error = err;
+        } finally {
+            assert(error, 'An error should have been thrown');
+        }
+    });
+
+    it('Can create new paid Tiers and find them again', async function () {
+        const tier = await api.add({
+            name: 'My testing Tier',
+            type: 'paid',
+            monthly_price: 5000,
+            yearly_price: 50000,
+            currency: 'usd'
+        });
+
+        const found = await api.read(tier.id.toHexString());
+
+        assert(found);
+    });
+
+    it('Can edit a tier', async function () {
+        const tier = await api.add({
+            name: 'My testing Tier',
+            type: 'paid',
+            monthly_price: 5000,
+            yearly_price: 50000,
+            currency: 'usd'
+        });
+
+        const updated = await api.edit(tier.id.toHexString(), {
+            name: 'Updated'
+        });
+
+        assert(updated.name === 'Updated');
+    });
+
+    it('Can browse tiers', async function () {
+        const page = await api.browse();
+
+        assert(page.data.length === 2);
+        assert(page.meta.pagination.total === 2);
+    });
+});
diff --git a/ghost/tiers/test/index.test.js b/ghost/tiers/test/index.test.js
new file mode 100644
index 0000000000..5db3270ddf
--- /dev/null
+++ b/ghost/tiers/test/index.test.js
@@ -0,0 +1,18 @@
+const assert = require('assert');
+const {
+    Tier,
+    TiersAPI,
+    InMemoryTierRepository
+} = require('../index');
+
+describe('index.js', function () {
+    it('Exports Tier', function () {
+        assert(Tier === require('../lib/Tier'));
+    });
+    it('Exports TiersAPI', function () {
+        assert(TiersAPI === require('../lib/TiersAPI'));
+    });
+    it('Exports InMemoryTierRepository', function () {
+        assert(InMemoryTierRepository === require('../lib/InMemoryTierRepository'));
+    });
+});
diff --git a/yarn.lock b/yarn.lock
index 2cf0272c57..90d6da1f39 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4653,7 +4653,7 @@
   dependencies:
     lodash.template "^4.5.0"
 
-"@tryghost/tpl@^0.1.18", "@tryghost/tpl@^0.1.19":
+"@tryghost/tpl@0.1.19", "@tryghost/tpl@^0.1.18", "@tryghost/tpl@^0.1.19":
   version "0.1.19"
   resolved "https://registry.yarnpkg.com/@tryghost/tpl/-/tpl-0.1.19.tgz#2f3883554d23d83e31631625c67c91a7eb9d03fb"
   integrity sha512-0ZOSDx/L75Sai/pea6k9TKnDz8GyyorGR/dtCIKlwd8qJ7oP90XbmTN4PBN+i4oGcZFchf8il9PbzVCoLnG0zA==
@@ -5363,6 +5363,11 @@
     "@typescript-eslint/types" "5.39.0"
     eslint-visitor-keys "^3.3.0"
 
+"@ungap/promise-all-settled@1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz#aa58042711d6e3275dd37dc597e5d31e8c290a44"
+  integrity sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==
+
 "@webassemblyjs/ast@1.11.1":
   version "1.11.1"
   resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.1.tgz#2bfd767eae1a6996f432ff7e8d7fc75679c0b6a7"
@@ -19306,6 +19311,34 @@ mocha-slow-test-reporter@0.1.2:
     text-table "^0.2.0"
     wordwrap "^1.0.0"
 
+mocha@10.0.0:
+  version "10.0.0"
+  resolved "https://registry.yarnpkg.com/mocha/-/mocha-10.0.0.tgz#205447d8993ec755335c4b13deba3d3a13c4def9"
+  integrity sha512-0Wl+elVUD43Y0BqPZBzZt8Tnkw9CMUdNYnUsTfOM1vuhJVZL+kiesFYsqwBkEEuEixaiPe5ZQdqDgX2jddhmoA==
+  dependencies:
+    "@ungap/promise-all-settled" "1.1.2"
+    ansi-colors "4.1.1"
+    browser-stdout "1.3.1"
+    chokidar "3.5.3"
+    debug "4.3.4"
+    diff "5.0.0"
+    escape-string-regexp "4.0.0"
+    find-up "5.0.0"
+    glob "7.2.0"
+    he "1.2.0"
+    js-yaml "4.1.0"
+    log-symbols "4.1.0"
+    minimatch "5.0.1"
+    ms "2.1.3"
+    nanoid "3.3.3"
+    serialize-javascript "6.0.0"
+    strip-json-comments "3.1.1"
+    supports-color "8.1.1"
+    workerpool "6.2.1"
+    yargs "16.2.0"
+    yargs-parser "20.2.4"
+    yargs-unparser "2.0.0"
+
 mocha@10.1.0:
   version "10.1.0"
   resolved "https://registry.yarnpkg.com/mocha/-/mocha-10.1.0.tgz#dbf1114b7c3f9d0ca5de3133906aea3dfc89ef7a"