diff --git a/adminSiteClient/GdocsBreadcrumbsInput.tsx b/adminSiteClient/GdocsBreadcrumbsInput.tsx
index 1e650b3f1fa..bed28d02554 100644
--- a/adminSiteClient/GdocsBreadcrumbsInput.tsx
+++ b/adminSiteClient/GdocsBreadcrumbsInput.tsx
@@ -86,7 +86,7 @@ export const GdocsBreadcrumbsInput = ({
             breadcrumbs[breadcrumbs.length - 1].href = undefined
         } else breadcrumbs = undefined
 
-        setCurrentGdoc({ ...gdoc, breadcrumbs })
+        setCurrentGdoc({ ...gdoc, breadcrumbs: breadcrumbs ?? null })
     }
 
     const setItemAtIndex = (item: BreadcrumbItem, i: number) => {
diff --git a/adminSiteClient/GdocsIndexPage.tsx b/adminSiteClient/GdocsIndexPage.tsx
index 4770350830a..76176819997 100644
--- a/adminSiteClient/GdocsIndexPage.tsx
+++ b/adminSiteClient/GdocsIndexPage.tsx
@@ -16,14 +16,14 @@ import {
 } from "@fortawesome/free-solid-svg-icons"
 import { FontAwesomeIcon } from "@fortawesome/react-fontawesome/index.js"
 import {
-    Tag,
+    DbChartTagJoin,
     OwidGdocType,
     SearchWord,
     buildSearchWordsFromSearchString,
     filterFunctionForSearchWords,
     spansToUnformattedPlainText,
-    OwidGdoc,
     checkIsGdocPost,
+    OwidGdocIndexItem,
 } from "@ourworldindata/utils"
 import { Route, RouteComponentProps } from "react-router-dom"
 import { Link } from "./Link.js"
@@ -139,11 +139,11 @@ export class GdocsIndexPage extends React.Component<GdocsMatchProps> {
     }
 
     @computed
-    get tags(): Tag[] {
+    get tags(): DbChartTagJoin[] {
         return this.context?.availableTags || []
     }
 
-    @computed get allGdocsToShow(): OwidGdoc[] {
+    @computed get allGdocsToShow(): OwidGdocIndexItem[] {
         const { searchWords, context } = this
         if (!context) return []
 
@@ -156,18 +156,18 @@ export class GdocsIndexPage extends React.Component<GdocsMatchProps> {
             ? context.gdocs.filter(
                   (gdoc) =>
                       // don't filter docs with no type set
-                      !gdoc.content.type || !!this.filters[gdoc.content.type]
+                      !gdoc.type || !!this.filters[gdoc.type]
               )
             : context.gdocs
 
         if (searchWords.length > 0) {
             const filterFn = filterFunctionForSearchWords(
                 searchWords,
-                (gdoc: OwidGdoc) => {
+                (gdoc: OwidGdocIndexItem) => {
                     const properties = [
-                        gdoc.content.title,
+                        gdoc.title,
                         gdoc.slug,
-                        gdoc.content.authors?.join(" "),
+                        gdoc.authors?.join(" "),
                         gdoc.tags?.map(({ name }) => name).join(" "),
                         gdoc.id,
                     ]
@@ -232,17 +232,16 @@ export class GdocsIndexPage extends React.Component<GdocsMatchProps> {
                         <div
                             key={gdoc.id}
                             className={cx(`gdoc-index-item`, {
-                                [`gdoc-index-item__${gdoc.content.type}`]:
-                                    gdoc.content.type,
+                                [`gdoc-index-item__${gdoc.type}`]: gdoc.type,
                             })}
                         >
                             <div className="gdoc-index-item__content">
-                                {gdoc.content.type ? (
+                                {gdoc.type ? (
                                     <span
                                         className="gdoc-index-item__type-icon"
-                                        title={gdoc.content.type}
+                                        title={gdoc.type}
                                     >
-                                        {iconGdocTypeMap[gdoc.content.type]}
+                                        {iconGdocTypeMap[gdoc.type]}
                                     </span>
                                 ) : null}
                                 <Link
@@ -252,19 +251,19 @@ export class GdocsIndexPage extends React.Component<GdocsMatchProps> {
                                         className="gdoc-index-item__title"
                                         title="Preview article"
                                     >
-                                        {gdoc.content.title || "Untitled"}
+                                        {gdoc.title || "Untitled"}
                                     </h5>
                                 </Link>
                                 <GdocsEditLink gdocId={gdoc.id} />
                                 <p className="gdoc-index-item__byline">
-                                    {gdoc.content.authors?.join(", ")}
+                                    {gdoc.authors?.join(", ")}
                                 </p>
                                 <span className="gdoc-index-item__tags">
-                                    {gdoc.content.type &&
+                                    {gdoc.type &&
                                     ![
                                         OwidGdocType.Fragment,
                                         OwidGdocType.AboutPage,
-                                    ].includes(gdoc.content.type) &&
+                                    ].includes(gdoc.type) &&
                                     gdoc.tags ? (
                                         <EditableTags
                                             tags={gdoc.tags}
@@ -290,8 +289,7 @@ export class GdocsIndexPage extends React.Component<GdocsMatchProps> {
                                                 : undefined
                                         }
                                         href={
-                                            gdoc.content.type !==
-                                            OwidGdocType.Fragment
+                                            gdoc.type !== OwidGdocType.Fragment
                                                 ? `${BAKED_BASE_URL}/${gdoc.slug}`
                                                 : undefined
                                         }
diff --git a/adminSiteClient/GdocsStore.tsx b/adminSiteClient/GdocsStore.tsx
index 2e34c9eefb9..9f90ac04b54 100644
--- a/adminSiteClient/GdocsStore.tsx
+++ b/adminSiteClient/GdocsStore.tsx
@@ -3,11 +3,14 @@ import { action, observable } from "mobx"
 import {
     getOwidGdocFromJSON,
     OwidGdocJSON,
-    Tag,
+    DbChartTagJoin,
     OwidGdoc,
+    DbPlainTag,
+    OwidGdocIndexItem,
 } from "@ourworldindata/utils"
 import { AdminAppContext } from "./AdminAppContext.js"
 import { Admin } from "./Admin.js"
+import { extractGdocIndexItem } from "@ourworldindata/types"
 
 /**
  * This was originally a MobX data domain store (see
@@ -17,8 +20,8 @@ import { Admin } from "./Admin.js"
  * Today, this store acts as CRUD proxy for requests to API endpoints.
  */
 export class GdocsStore {
-    @observable gdocs: OwidGdoc[] = []
-    @observable availableTags: Tag[] = []
+    @observable gdocs: OwidGdocIndexItem[] = []
+    @observable availableTags: DbChartTagJoin[] = []
     admin: Admin
 
     constructor(admin: Admin) {
@@ -32,9 +35,13 @@ export class GdocsStore {
 
     @action
     async update(gdoc: OwidGdoc): Promise<OwidGdoc> {
-        return this.admin
+        const item: OwidGdoc = await this.admin
             .requestJSON<OwidGdocJSON>(`/api/gdocs/${gdoc.id}`, gdoc, "PUT")
             .then(getOwidGdocFromJSON)
+        const indexItem = extractGdocIndexItem(gdoc)
+        const gdocToUpdateIndex = this.gdocs.findIndex((g) => g.id === gdoc.id)
+        if (gdocToUpdateIndex >= 0) this.gdocs[gdocToUpdateIndex] = indexItem
+        return item
     }
 
     @action
@@ -61,7 +68,9 @@ export class GdocsStore {
 
     @action
     async fetchGdocs() {
-        const gdocs = (await this.admin.getJSON("/api/gdocs")) as OwidGdoc[]
+        const gdocs = (await this.admin.getJSON(
+            "/api/gdocs"
+        )) as OwidGdocIndexItem[]
         this.gdocs = gdocs
     }
 
@@ -72,7 +81,7 @@ export class GdocsStore {
     }
 
     @action
-    async updateTags(gdoc: OwidGdoc, tags: Tag[]) {
+    async updateTags(gdoc: OwidGdocIndexItem, tags: DbPlainTag[]) {
         const json = await this.admin.requestJSON(
             `/api/gdocs/${gdoc.id}/setTags`,
             { tagIds: tags.map((t) => t.id) },
diff --git a/adminSiteClient/PostsIndexPage.tsx b/adminSiteClient/PostsIndexPage.tsx
index e15ae4f09cb..21bd2aacb7e 100644
--- a/adminSiteClient/PostsIndexPage.tsx
+++ b/adminSiteClient/PostsIndexPage.tsx
@@ -3,12 +3,11 @@ import { observer } from "mobx-react"
 import { observable, computed, action, runInAction } from "mobx"
 
 import {
-    DbChartTagJoin,
-    Tag,
     buildSearchWordsFromSearchString,
     filterFunctionForSearchWords,
     SearchWord,
     uniq,
+    DbChartTagJoin,
 } from "@ourworldindata/utils"
 import { AdminLayout } from "./AdminLayout.js"
 import { SearchField, FieldsRow, Timeago } from "./Forms.js"
@@ -52,7 +51,7 @@ enum GdocStatus {
 
 interface PostRowProps {
     post: PostIndexMeta
-    availableTags: Tag[]
+    availableTags: DbChartTagJoin[]
 }
 
 @observer
@@ -257,7 +256,7 @@ export class PostsIndexPage extends React.Component {
     @observable posts: PostIndexMeta[] = []
     @observable maxVisibleRows = 50
     @observable searchInput?: string
-    @observable availableTags: Tag[] = []
+    @observable availableTags: DbChartTagJoin[] = []
 
     @computed get searchWords(): SearchWord[] {
         const { searchInput } = this
diff --git a/adminSiteClient/TagsIndexPage.tsx b/adminSiteClient/TagsIndexPage.tsx
index e24a9dc3729..b5f8a0e42a7 100644
--- a/adminSiteClient/TagsIndexPage.tsx
+++ b/adminSiteClient/TagsIndexPage.tsx
@@ -5,7 +5,7 @@ import * as lodash from "lodash"
 import { Redirect } from "react-router-dom"
 import { AdminLayout } from "./AdminLayout.js"
 import { FieldsRow, Modal, TextField } from "./Forms.js"
-import { Tag, DbChartTagJoin } from "@ourworldindata/utils"
+import { DbChartTagJoin } from "@ourworldindata/utils"
 import { TagBadge } from "./TagBadge.js"
 import { AdminAppContext, AdminAppContextType } from "./AdminAppContext.js"
 
@@ -166,7 +166,10 @@ export class TagsIndexPage extends React.Component {
                                     </p>
                                 )}
                                 {parent.children.map((tag) => (
-                                    <TagBadge key={tag.id} tag={tag as Tag} />
+                                    <TagBadge
+                                        key={tag.id}
+                                        tag={tag as DbChartTagJoin}
+                                    />
                                 ))}
                                 <button
                                     className="btn btn-default"
diff --git a/adminSiteClient/gdocsDeploy.ts b/adminSiteClient/gdocsDeploy.ts
index f883a17a23f..cfb4a34dc82 100644
--- a/adminSiteClient/gdocsDeploy.ts
+++ b/adminSiteClient/gdocsDeploy.ts
@@ -6,14 +6,15 @@ import {
     OwidGdocDataInsightContent,
     OwidGdocType,
     OwidGdocHomepageContent,
+    DbEnrichedPostGdoc,
     OwidGdocAuthorContent,
 } from "@ourworldindata/types"
 import { GDOC_DIFF_OMITTABLE_PROPERTIES } from "./GdocsDiff.js"
 import { GDOCS_DETAILS_ON_DEMAND_ID } from "../settings/clientSettings.js"
 
 export const checkFullDeployFallback = (
-    prevGdoc: OwidGdoc,
-    nextGdoc: OwidGdoc,
+    prevGdoc: DbEnrichedPostGdoc,
+    nextGdoc: DbEnrichedPostGdoc,
     hasChanges: boolean
 ) => {
     return hasChanges && (prevGdoc.published || nextGdoc.published)
@@ -27,8 +28,8 @@ export const checkFullDeployFallback = (
  *
  */
 export const checkIsLightningUpdate = (
-    prevGdoc: OwidGdoc,
-    nextGdoc: OwidGdoc,
+    prevGdoc: DbEnrichedPostGdoc,
+    nextGdoc: DbEnrichedPostGdoc,
     hasChanges: boolean
 ) => {
     if (
@@ -66,6 +67,7 @@ export const checkIsLightningUpdate = (
         published: false, // requires an update of the blog roll
         publishedAt: false, // could require an update of the blog roll
         slug: false, // requires updating any articles that link to it
+        markdown: true,
     }
 
     const postlightningPropContentConfigMap: Record<
diff --git a/adminSiteServer/apiRouter.ts b/adminSiteServer/apiRouter.ts
index 6aa278b48bc..31c3dbb706c 100644
--- a/adminSiteServer/apiRouter.ts
+++ b/adminSiteServer/apiRouter.ts
@@ -3,7 +3,6 @@
 import * as lodash from "lodash"
 import * as db from "../db/db.js"
 import { imageStore } from "../db/model/Image.js"
-import { GdocXImage } from "../db/model/GdocXImage.js"
 import { DEPRECATEDgetTopics } from "../db/DEPRECATEDwpdb.js"
 import {
     UNCATEGORIZED_TAG_ID,
@@ -23,7 +22,7 @@ import {
     oldChartFieldList,
     setChartTags,
 } from "../db/model/Chart.js"
-import { Request, CurrentUser } from "./authentication.js"
+import { Request } from "./authentication.js"
 import {
     getMergedGrapherConfigForVariable,
     fetchS3MetadataByPath,
@@ -54,7 +53,6 @@ import {
     DimensionProperty,
     TaggableType,
     DbChartTagJoin,
-    OwidGdoc,
     pick,
 } from "@ourworldindata/utils"
 import {
@@ -76,6 +74,11 @@ import {
     serializeChartConfig,
     DbRawOrigin,
     DbRawPostGdoc,
+    PostsGdocsXImagesTableName,
+    DbInsertPostGdocXImage,
+    PostsGdocsLinksTableName,
+    PostsGdocsTableName,
+    PostsGdocsXTagsTableName,
     DbPlainDataset,
 } from "@ourworldindata/types"
 import {
@@ -85,7 +88,6 @@ import {
 import { getDatasetById, setTagsForDataset } from "../db/model/Dataset.js"
 import { getUserById, insertUser, updateUser } from "../db/model/User.js"
 import { GdocPost } from "../db/model/Gdoc/GdocPost.js"
-import { GdocBase, Tag as TagEntity } from "../db/model/Gdoc/GdocBase.js"
 import {
     syncDatasetToGitRepo,
     removeDatasetFromGitRepo,
@@ -111,22 +113,33 @@ import {
 } from "../adminSiteClient/gdocsDeploy.js"
 import { dataSource } from "../db/dataSource.js"
 import { createGdocAndInsertOwidGdocPostContent } from "../db/model/Gdoc/archieToGdoc.js"
-import { Link } from "../db/model/Link.js"
-import { In } from "typeorm"
 import { logErrorAndMaybeSendToBugsnag } from "../serverUtils/errorLog.js"
-import { GdocFactory } from "../db/model/Gdoc/GdocFactory.js"
 import {
     getRouteWithROTransaction,
     deleteRouteWithRWTransaction,
     putRouteWithRWTransaction,
     postRouteWithRWTransaction,
     patchRouteWithRWTransaction,
+    getRouteNonIdempotentWithRWTransaction,
 } from "./routerHelpers.js"
+import { getPublishedLinksTo } from "../db/model/Link.js"
+import {
+    createGdocAndInsertIntoDb,
+    gdocFromJSON,
+    getAllGdocIndexItemsOrderedByUpdatedAt,
+    getAndLoadGdocById,
+    getDbEnrichedGdocFromOwidGdoc,
+    getGdocBaseObjectById,
+    loadGdocFromGdocBase,
+    setTagsForGdoc,
+    updateGdocContentOnly,
+    upsertGdoc,
+} from "../db/model/Gdoc/GdocFactory.js"
 
 const apiRouter = new FunctionalRouter()
 
 // Call this to trigger build and deployment of static charts on change
-const triggerStaticBuild = async (user: CurrentUser, commitMessage: string) => {
+const triggerStaticBuild = async (user: DbPlainUser, commitMessage: string) => {
     if (!BAKE_ON_CHANGE) {
         console.log(
             "Not triggering static build because BAKE_ON_CHANGE is false"
@@ -143,7 +156,7 @@ const triggerStaticBuild = async (user: CurrentUser, commitMessage: string) => {
 }
 
 const enqueueLightningChange = async (
-    user: CurrentUser,
+    user: DbPlainUser,
     commitMessage: string,
     slug: string
 ) => {
@@ -232,7 +245,7 @@ const expectChartById = async (
 
 const saveGrapher = async (
     knex: db.KnexReadWriteTransaction,
-    user: CurrentUser,
+    user: DbPlainUser,
     newConfig: GrapherInterface,
     existingConfig?: GrapherInterface,
     referencedVariablesMightChange = true // if the variables a chart uses can change then we need
@@ -690,9 +703,9 @@ deleteRouteWithRWTransaction(
     "/charts/:chartId",
     async (req, res, trx) => {
         const chart = await expectChartById(trx, req.params.chartId)
-        const links = await Link.getPublishedLinksTo([chart.slug!])
+        const links = await getPublishedLinksTo(trx, [chart.slug!])
         if (links.length) {
-            const sources = links.map((link) => link.source.slug).join(", ")
+            const sources = links.map((link) => link.sourceSlug).join(", ")
             throw new Error(
                 `Cannot delete chart in-use in the following published documents: ${sources}`
             )
@@ -2434,10 +2447,7 @@ postRouteWithRWTransaction(
                 500
             )
         const tagsByPostId = await getTagsByPostId(trx)
-        const tags =
-            tagsByPostId
-                .get(postId)
-                ?.map(({ id }) => TagEntity.create({ id })) || []
+        const tags = tagsByPostId.get(postId) || []
         const archieMl = JSON.parse(
             // Google Docs interprets &region in grapher URLS as ®ion
             // So we escape them here
@@ -2462,15 +2472,14 @@ postRouteWithRWTransaction(
 
             const gdoc = new GdocPost(gdocId)
             gdoc.slug = post.slug
-            gdoc.tags = tags
             gdoc.content.title = post.title
             gdoc.content.type = archieMl.content.type || OwidGdocType.Article
             gdoc.published = false
             gdoc.createdAt = new Date()
             gdoc.publishedAt = post.published_at
-            await dataSource.getRepository(GdocPost).save(gdoc)
+            await upsertGdoc(trx, gdoc)
+            await setTagsForGdoc(trx, gdocId, tags)
         }
-
         return { googleDocsId: gdocId }
     }
 )
@@ -2544,65 +2553,73 @@ apiRouter.put("/deploy", async (req, res) => {
     triggerStaticBuild(res.locals.user, "Manually triggered deploy")
 })
 
-apiRouter.get("/gdocs", async () => {
-    // orderBy was leading to a sort buffer overflow (ER_OUT_OF_SORTMEMORY) with MySQL's default sort_buffer_size
-    // when the posts_gdocs table got larger than 9MB, so we sort in memory
-    return GdocPost.find({ relations: ["tags"] }).then((gdocs) =>
-        gdocs.sort((a, b) => {
-            if (!a.updatedAt || !b.updatedAt) return 0
-            return b.updatedAt.getTime() - a.updatedAt.getTime()
-        })
-    )
+getRouteWithROTransaction(apiRouter, "/gdocs", async (req, res, trx) => {
+    return getAllGdocIndexItemsOrderedByUpdatedAt(trx)
 })
 
-apiRouter.get("/gdocs/:id", async (req, res) => {
-    const id = req.params.id
-    const contentSource = req.query.contentSource as
-        | GdocsContentSource
-        | undefined
+getRouteNonIdempotentWithRWTransaction(
+    apiRouter,
+    "/gdocs/:id",
+    async (req, res, trx) => {
+        const id = req.params.id
+        const contentSource = req.query.contentSource as
+            | GdocsContentSource
+            | undefined
 
-    try {
-        const gdoc = await GdocFactory.load(id, contentSource)
+        try {
+            const gdoc = await getAndLoadGdocById(trx, id, contentSource)
 
-        if (!gdoc.published) {
-            await gdoc.save()
-        }
+            if (!gdoc.published) {
+                await updateGdocContentOnly(
+                    trx,
+                    id,
+                    gdoc,
+                    gdoc.enrichedBlockSources.flat()
+                )
+            }
 
-        res.set("Cache-Control", "no-store")
-        res.send(gdoc)
-    } catch (error) {
-        console.error("Error fetching gdoc", error)
-        res.status(500).json({ error: { message: String(error), status: 500 } })
+            res.set("Cache-Control", "no-store")
+            res.send(gdoc)
+        } catch (error) {
+            console.error("Error fetching gdoc", error)
+            res.status(500).json({
+                error: { message: String(error), status: 500 },
+            })
+        }
     }
-})
+)
 
 /**
  * Only supports creating a new empty Gdoc or updating an existing one. Does not
  * support creating a new Gdoc from an existing one. Relevant updates will
  * trigger a deploy.
  */
-apiRouter.put("/gdocs/:id", async (req, res) => {
+putRouteWithRWTransaction(apiRouter, "/gdocs/:id", async (req, res, trx) => {
     const { id } = req.params
     const nextGdocJSON: OwidGdocJSON = req.body
 
     if (isEmpty(nextGdocJSON)) {
         // Check to see if the gdoc already exists in the database
-        const existingGdoc = await GdocBase.findOneBy({ id })
+        const existingGdoc = await getGdocBaseObjectById(trx, id, false)
         if (existingGdoc) {
-            return GdocFactory.load(id, GdocsContentSource.Gdocs)
+            return loadGdocFromGdocBase(
+                trx,
+                existingGdoc,
+                GdocsContentSource.Gdocs
+            )
         } else {
-            return GdocFactory.create(id)
+            return createGdocAndInsertIntoDb(trx, id)
         }
     }
 
-    const prevGdoc = await GdocFactory.load(id)
+    const prevGdoc = await getAndLoadGdocById(trx, id)
     if (!prevGdoc) throw new JsonError(`No Google Doc with id ${id} found`)
 
-    const nextGdoc = GdocFactory.fromJSON(nextGdocJSON)
-    await nextGdoc.loadState()
+    const nextGdoc = gdocFromJSON(nextGdocJSON)
+    await nextGdoc.loadState(trx)
 
     // Deleting and recreating these is simpler than tracking orphans over the next code block
-    await GdocXImage.delete({ gdocId: id })
+    await trx.table(PostsGdocsXImagesTableName).where({ gdocId: id }).delete()
     const filenames = nextGdoc.filenames
 
     // The concept of a "published gdoc" is looser here than in
@@ -2612,31 +2629,36 @@ apiRouter.put("/gdocs/:id", async (req, res) => {
     // synced to S3 and ultimately baked in bakeDriveImages().
     if (filenames.length && nextGdoc.published) {
         await imageStore.fetchImageMetadata(filenames)
-        const images = await imageStore.syncImagesToS3()
+        const images = await imageStore.syncImagesToS3(trx)
+        const gdocXImagesToInsert: DbInsertPostGdocXImage[] = []
         for (const image of images) {
             if (image) {
-                try {
-                    await GdocXImage.save({
-                        gdocId: nextGdoc.id,
-                        imageId: image.id,
-                    })
-                } catch (e) {
-                    console.error(
-                        `Error tracking image reference ${image.filename} with Google ID ${nextGdoc.id}`,
-                        e
-                    )
-                }
+                gdocXImagesToInsert.push({
+                    gdocId: nextGdoc.id,
+                    imageId: image.id,
+                })
             }
         }
+        try {
+            await trx
+                .table(PostsGdocsXImagesTableName)
+                .insert(gdocXImagesToInsert)
+        } catch (e) {
+            console.error(
+                `Error tracking image references with Google ID ${nextGdoc.id}`,
+                e
+            )
+        }
     }
 
-    await Link.delete({
-        source: {
-            id: id,
-        },
-    })
-    if (nextGdoc.published) {
-        await dataSource.getRepository(Link).save(nextGdoc.links)
+    await trx.table(PostsGdocsLinksTableName).where({ sourceId: id }).delete()
+
+    if (
+        nextGdoc.published &&
+        nextGdoc.links !== undefined &&
+        nextGdoc.links.length > 0
+    ) {
+        await trx.table(PostsGdocsLinksTableName).insert(nextGdoc.links)
     }
 
     //todo #gdocsvalidationserver: run validation before saving published
@@ -2656,11 +2678,11 @@ apiRouter.put("/gdocs/:id", async (req, res) => {
     // enqueue), so I opted for the version that matches the closest the current
     // baking model, which is "bake what is persisted in the DB". Ultimately, a
     // full sucessful deploy would resolve the state discrepancy either way.
-    await nextGdoc.save()
+    await upsertGdoc(trx, nextGdoc)
 
     const hasChanges = checkHasChanges(prevGdoc, nextGdoc)
-    const prevJson = prevGdoc.toJSON<OwidGdoc>()
-    const nextJson = nextGdoc.toJSON<OwidGdoc>()
+    const prevJson = getDbEnrichedGdocFromOwidGdoc(prevGdoc)
+    const nextJson = getDbEnrichedGdocFromOwidGdoc(nextGdoc)
     if (checkIsLightningUpdate(prevJson, nextJson, hasChanges)) {
         await enqueueLightningChange(
             res.locals.user,
@@ -2683,7 +2705,7 @@ apiRouter.put("/gdocs/:id", async (req, res) => {
 deleteRouteWithRWTransaction(apiRouter, "/gdocs/:id", async (req, res, trx) => {
     const { id } = req.params
 
-    const gdoc = await GdocPost.findOneBy({ id })
+    const gdoc = await getGdocBaseObjectById(trx, id, false)
     if (!gdoc) throw new JsonError(`No Google Doc with id ${id} found`)
 
     await trx
@@ -2691,30 +2713,30 @@ deleteRouteWithRWTransaction(apiRouter, "/gdocs/:id", async (req, res, trx) => {
         .where({ gdocSuccessorId: gdoc.id })
         .update({ gdocSuccessorId: null })
 
-    await Link.delete({
-        source: {
-            id,
-        },
-    })
-    await GdocXImage.delete({ gdocId: id })
-    await GdocPost.delete({ id })
+    trx.table(PostsGdocsLinksTableName).where({ sourceId: id }).delete()
+    trx.table(PostsGdocsXImagesTableName).where({ gdocId: id }).delete()
+    trx.table(PostsGdocsTableName).where({ id }).delete()
     await triggerStaticBuild(res.locals.user, `Deleting ${gdoc.slug}`)
     return {}
 })
 
-apiRouter.post("/gdocs/:gdocId/setTags", async (req, res) => {
-    const { gdocId } = req.params
-    const { tagIds } = req.body
-
-    const gdoc = await GdocPost.findOneBy({ id: gdocId })
-    if (!gdoc) return Error(`Unable to find Gdoc with ID: ${gdocId}`)
-    const tags = await dataSource
-        .getRepository(TagEntity)
-        .findBy({ id: In(tagIds) })
-    gdoc.tags = tags
-    await gdoc.save()
-    return { success: true }
-})
+postRouteWithRWTransaction(
+    apiRouter,
+    "/gdocs/:gdocId/setTags",
+    async (req, res, trx) => {
+        const { gdocId } = req.params
+        const { tagIds } = req.body
+
+        await trx.table(PostsGdocsXTagsTableName).where({ gdocId }).delete()
+        if (tagIds.length) {
+            await trx
+                .table(PostsGdocsXTagsTableName)
+                .insert(tagIds.map((tagId: number) => ({ gdocId, tagId })))
+        }
+
+        return { success: true }
+    }
+)
 
 getRouteWithROTransaction(
     apiRouter,
diff --git a/adminSiteServer/app.tsx b/adminSiteServer/app.tsx
index 21e00b4c7b8..78ad792d944 100644
--- a/adminSiteServer/app.tsx
+++ b/adminSiteServer/app.tsx
@@ -31,7 +31,7 @@ import { mockSiteRouter } from "./mockSiteRouter.js"
 import { GIT_CMS_DIR } from "../gitCms/GitCmsConstants.js"
 import { GdocsContentSource } from "@ourworldindata/utils"
 import OwidGdocPage from "../site/gdocs/OwidGdocPage.js"
-import { GdocFactory } from "../db/model/Gdoc/GdocFactory.js"
+import { getAndLoadGdocById } from "../db/model/Gdoc/GdocFactory.js"
 
 interface OwidAdminAppOptions {
     gitCmsDir: string
@@ -126,22 +126,25 @@ export class OwidAdminApp {
         // Public preview of a Gdoc document
         app.get("/gdocs/:id/preview", async (req, res) => {
             try {
-                const gdoc = await GdocFactory.load(
-                    req.params.id,
-                    GdocsContentSource.Gdocs
-                )
+                await db.knexReadonlyTransaction(async (knex) => {
+                    const gdoc = await getAndLoadGdocById(
+                        knex,
+                        req.params.id,
+                        GdocsContentSource.Gdocs
+                    )
 
-                res.set("X-Robots-Tag", "noindex")
-                res.send(
-                    renderToHtmlPage(
-                        <OwidGdocPage
-                            baseUrl={BAKED_BASE_URL}
-                            gdoc={gdoc}
-                            debug
-                            isPreviewing
-                        />
+                    res.set("X-Robots-Tag", "noindex")
+                    res.send(
+                        renderToHtmlPage(
+                            <OwidGdocPage
+                                baseUrl={BAKED_BASE_URL}
+                                gdoc={gdoc}
+                                debug
+                                isPreviewing
+                            />
+                        )
                     )
-                )
+                })
             } catch (error) {
                 console.error("Error fetching gdoc preview", error)
                 res.status(500).json({
diff --git a/adminSiteServer/authentication.tsx b/adminSiteServer/authentication.tsx
index 6ad1bc9c592..285750176d1 100644
--- a/adminSiteServer/authentication.tsx
+++ b/adminSiteServer/authentication.tsx
@@ -1,7 +1,6 @@
 import express from "express"
 import crypto from "crypto"
 import randomstring from "randomstring"
-import { User } from "../db/model/User.js"
 import * as db from "../db/db.js"
 import {
     CLOUDFLARE_AUD,
@@ -12,14 +11,12 @@ import {
 } from "../settings/serverSettings.js"
 import { BCryptHasher } from "../db/hashers.js"
 import { Secret, verify } from "jsonwebtoken"
-import { JsonError } from "@ourworldindata/utils"
-
-export type CurrentUser = User
+import { DbPlainSession, DbPlainUser, JsonError } from "@ourworldindata/utils"
 
 export type Request = express.Request
 
 export interface Response extends express.Response {
-    locals: { user: CurrentUser; session: Session }
+    locals: { user: DbPlainUser; session: Session }
 }
 
 interface Session {
@@ -84,7 +81,12 @@ export async function authCloudflareSSOMiddleware(
         return next()
     }
 
-    const user = await User.findOneBy({ email: payload.email })
+    // Here in the middleware we don't have access to the transaction yet so we get a knexinstance manually
+    const user = await db
+        .knexInstance()
+        .table("users")
+        .where({ email: payload.email })
+        .first()
     if (!user) return next("User not found. Please contact an administrator.")
 
     // Authenticate as the user stored in the token
@@ -124,36 +126,58 @@ export async function authMiddleware(
     res: express.Response,
     next: express.NextFunction
 ) {
-    let user: CurrentUser | null = null
+    let user: DbPlainUser | null = null
     let session: Session | undefined
 
     const sessionid = req.cookies["sessionid"]
     if (sessionid) {
-        // Expire old sessions
-        await db.execute("DELETE FROM sessions WHERE expire_date < NOW()")
-
-        const rows = await db.queryMysql(
-            `SELECT * FROM sessions WHERE session_key = ?`,
-            [sessionid]
+        const userAndSession = await db.knexReadWriteTransaction(
+            async (trx) => {
+                // Expire old sessions
+                await db.knexRaw(
+                    trx,
+                    "DELETE FROM sessions WHERE expire_date < NOW()"
+                )
+
+                const rows = await db.knexRaw<DbPlainSession>(
+                    trx,
+                    `SELECT * FROM sessions WHERE session_key = ?`,
+                    [sessionid]
+                )
+                if (rows.length) {
+                    const sessionData = Buffer.from(
+                        rows[0].session_data,
+                        "base64"
+                    ).toString("utf8")
+                    const sessionJson = JSON.parse(
+                        sessionData.split(":").slice(1).join(":")
+                    )
+
+                    const user = await trx
+                        .table("users")
+                        .where({ email: sessionJson.user_email })
+                        .first<DbPlainUser>()
+                    if (!user)
+                        throw new JsonError(
+                            "Invalid session (no such user)",
+                            500
+                        )
+                    const session = {
+                        id: sessionid,
+                        expiryDate: rows[0].expire_date,
+                    }
+
+                    await trx
+                        .table("users")
+                        .where({ id: user.id })
+                        .update({ lastSeen: new Date() })
+                    return { user, session }
+                }
+                return null
+            }
         )
-        if (rows.length) {
-            const sessionData = Buffer.from(
-                rows[0].session_data,
-                "base64"
-            ).toString("utf8")
-            const sessionJson = JSON.parse(
-                sessionData.split(":").slice(1).join(":")
-            )
-
-            user = await User.findOneBy({ email: sessionJson.user_email })
-            if (!user)
-                throw new JsonError("Invalid session (no such user)", 500)
-            session = { id: sessionid, expiryDate: rows[0].expiry_date }
-
-            // Don't await this
-            user.lastSeen = new Date()
-            user.save()
-        }
+        user = userAndSession?.user ?? null
+        session = userAndSession?.session
     }
 
     // Authed urls shouldn't be cached
@@ -175,7 +199,7 @@ function saltedHmac(salt: string, value: string): string {
     return hmac.digest("hex")
 }
 
-async function logInAsUser(user: User) {
+async function logInAsUser(user: DbPlainUser) {
     const sessionId = randomstring.generate()
 
     const sessionJson = JSON.stringify({
@@ -197,8 +221,11 @@ async function logInAsUser(user: User) {
         [sessionId, sessionData, expiryDate]
     )
 
-    user.lastLogin = now
-    await user.save()
+    await db
+        .knexInstance()
+        .table("users")
+        .where({ id: user.id })
+        .update({ lastLogin: now })
 
     return { id: sessionId, expiryDate: expiryDate }
 }
@@ -207,7 +234,9 @@ export async function logInWithCredentials(
     email: string,
     password: string
 ): Promise<Session> {
-    const user = await User.findOneBy({ email: email })
+    // Here in the middleware we don't have access to the transaction yet so we get a knexinstance manually
+    const user = await db.knexInstance().table("users").where({ email }).first()
+
     if (!user) throw new Error("No such user")
 
     const hasher = new BCryptHasher()
diff --git a/adminSiteServer/mockSiteRouter.tsx b/adminSiteServer/mockSiteRouter.tsx
index afb75c55067..c8ba6140331 100644
--- a/adminSiteServer/mockSiteRouter.tsx
+++ b/adminSiteServer/mockSiteRouter.tsx
@@ -192,8 +192,12 @@ mockSiteRouter.get("/", async (req, res) => {
     res.send(frontPage)
 })
 
-mockSiteRouter.get("/donate", async (req, res) =>
-    res.send(await renderDonatePage())
+mockSiteRouter.get(
+    "/donate",
+    async (req, res) =>
+        await db.knexReadonlyTransaction(async (knex) =>
+            res.send(await renderDonatePage(knex))
+        )
 )
 
 mockSiteRouter.get("/thank-you", async (req, res) =>
@@ -201,47 +205,51 @@ mockSiteRouter.get("/thank-you", async (req, res) =>
 )
 
 mockSiteRouter.get("/data-insights/:pageNumberOrSlug?", async (req, res) => {
-    const totalPageCount = calculateDataInsightIndexPageCount(
-        await db
-            .getPublishedDataInsights(
-                db.knexInstance() as db.KnexReadonlyTransaction
-            )
-            .then((insights) => insights.length)
-    )
-    async function renderIndexPage(pageNumber: number) {
-        const dataInsights =
-            await GdocDataInsight.getPublishedDataInsights(pageNumber)
-        // calling fetchImageMetadata 20 times makes me sad, would be nice if we could cache this
-        await Promise.all(dataInsights.map((insight) => insight.loadState()))
-        return renderDataInsightsIndexPage(
-            dataInsights,
-            pageNumber,
-            totalPageCount,
-            true
+    return await db.knexReadonlyTransaction(async (knex) => {
+        const totalPageCount = calculateDataInsightIndexPageCount(
+            await db
+                .getPublishedDataInsights(knex)
+                .then((insights) => insights.length)
         )
-    }
-    const pageNumberOrSlug = req.params.pageNumberOrSlug
-    if (!pageNumberOrSlug) {
-        return res.send(await renderIndexPage(0))
-    }
+        async function renderIndexPage(pageNumber: number) {
+            const dataInsights = await GdocDataInsight.getPublishedDataInsights(
+                knex,
+                pageNumber
+            )
+            // calling fetchImageMetadata 20 times makes me sad, would be nice if we could cache this
+            await Promise.all(
+                dataInsights.map((insight) => insight.loadState(knex))
+            )
+            return renderDataInsightsIndexPage(
+                dataInsights,
+                pageNumber,
+                totalPageCount,
+                true
+            )
+        }
+        const pageNumberOrSlug = req.params.pageNumberOrSlug
+        if (!pageNumberOrSlug) {
+            return res.send(await renderIndexPage(0))
+        }
 
-    // pageNumber is 1-indexed, but DB operations are 0-indexed
-    const pageNumber = parseInt(pageNumberOrSlug) - 1
-    if (!isNaN(pageNumber)) {
-        if (pageNumber <= 0 || pageNumber >= totalPageCount) {
-            return res.redirect("/data-insights")
+        // pageNumber is 1-indexed, but DB operations are 0-indexed
+        const pageNumber = parseInt(pageNumberOrSlug) - 1
+        if (!isNaN(pageNumber)) {
+            if (pageNumber <= 0 || pageNumber >= totalPageCount) {
+                return res.redirect("/data-insights")
+            }
+            return res.send(await renderIndexPage(pageNumber))
         }
-        return res.send(await renderIndexPage(pageNumber))
-    }
 
-    const slug = pageNumberOrSlug
-    try {
-        return res.send(await renderGdocsPageBySlug(slug, true))
-    } catch (e) {
-        console.error(e)
-    }
+        const slug = pageNumberOrSlug
+        try {
+            return res.send(await renderGdocsPageBySlug(knex, slug, true))
+        } catch (e) {
+            console.error(e)
+        }
 
-    return new JsonError(`Data insight with slug "${slug}" not found`, 404)
+        return new JsonError(`Data insight with slug "${slug}" not found`, 404)
+    })
 })
 
 mockSiteRouter.get("/charts", async (req, res) => {
@@ -366,7 +374,9 @@ mockSiteRouter.get("/multiEmbedderTest", async (req, res) =>
 
 mockSiteRouter.get("/dods.json", async (_, res) => {
     res.set("Access-Control-Allow-Origin", "*")
-    const { details, parseErrors } = await GdocPost.getDetailsOnDemandGdoc()
+    const { details, parseErrors } = await db.knexReadonlyTransaction((trx) =>
+        GdocPost.getDetailsOnDemandGdoc(trx)
+    )
     if (parseErrors.length) {
         console.error(
             `Error(s) parsing details: ${parseErrors
@@ -380,21 +390,22 @@ mockSiteRouter.get("/dods.json", async (_, res) => {
 mockSiteRouter.get("/*", async (req, res) => {
     const slug = req.path.replace(/^\//, "")
 
-    try {
-        res.send(await renderGdocsPageBySlug(slug))
-    } catch (e) {
-        console.error(e)
-    }
+    await db.knexReadonlyTransaction(async (knex) => {
+        try {
+            const page = await renderGdocsPageBySlug(knex, slug)
+            res.send(page)
+        } catch (e) {
+            console.error(e)
+        }
 
-    try {
-        const page = await db.knexReadonlyTransaction(async (knex) =>
-            renderPageBySlug(slug, knex)
-        )
-        res.send(page)
-    } catch (e) {
-        console.error(e)
-        res.status(404).send(await renderNotFoundPage())
-    }
+        try {
+            const page = await renderPageBySlug(slug, knex)
+            res.send(page)
+        } catch (e) {
+            console.error(e)
+            res.status(404).send(await renderNotFoundPage())
+        }
+    })
 })
 
 export { mockSiteRouter }
diff --git a/adminSiteServer/routerHelpers.tsx b/adminSiteServer/routerHelpers.tsx
index 65537eac6f0..e9ae007d2bc 100644
--- a/adminSiteServer/routerHelpers.tsx
+++ b/adminSiteServer/routerHelpers.tsx
@@ -17,21 +17,25 @@ export function getRouteWithROTransaction<T>(
     })
 }
 
-// Might be needed in the future if we have get requests that e.g. write analytics data or stats to the DB
-// function getRouteWithRWTransaction<T>(
-//     targetPath: string,
-//     handler: (
-//         req: Request,
-//         res: Response,
-//         trx: db.KnexReadWriteTransaction
-//     ) => Promise<T>
-// ) {
-//     return apiRouter.get(targetPath, (req: Request, res: Response) => {
-//         return db.knexReadWriteTransaction((transaction) =>
-//             handler(req, res, transaction)
-//         )
-//     })
-// }
+/** Usually get routes should be idempotent (caching and retry reasons among others),
+    but for example the gdoc preview route is not because it updates the gdoc in the DB after
+    fetching it from the google API.
+ */
+export function getRouteNonIdempotentWithRWTransaction<T>(
+    router: FunctionalRouter,
+    targetPath: string,
+    handler: (
+        req: Request,
+        res: Response,
+        trx: db.KnexReadWriteTransaction
+    ) => Promise<T>
+) {
+    return router.get(targetPath, (req: Request, res: Response) => {
+        return db.knexReadWriteTransaction((transaction) =>
+            handler(req, res, transaction)
+        )
+    })
+}
 
 export function postRouteWithRWTransaction<T>(
     router: FunctionalRouter,
diff --git a/baker/DatapageHelpers.ts b/baker/DatapageHelpers.ts
index 5470e246fcc..ba6213c42d9 100644
--- a/baker/DatapageHelpers.ts
+++ b/baker/DatapageHelpers.ts
@@ -11,10 +11,13 @@ import {
     getNextUpdateFromVariable,
     omitUndefinedValues,
 } from "@ourworldindata/utils"
-import { GdocPost } from "../db/model/Gdoc/GdocPost.js"
-import { GdocFactory } from "../db/model/Gdoc/GdocFactory.js"
+import {
+    getAndLoadGdocById,
+    getGdocBaseObjectById,
+} from "../db/model/Gdoc/GdocFactory.js"
 import { OwidGoogleAuth } from "../db/OwidGoogleAuth.js"
 import { GrapherInterface } from "@ourworldindata/types"
+import { KnexReadonlyTransaction } from "../db/db.js"
 
 export const getDatapageDataV2 = async (
     variableMetadata: OwidVariableWithSource,
@@ -76,6 +79,7 @@ export const getDatapageDataV2 = async (
  * see https://github.com/owid/owid-grapher/issues/2121#issue-1676097164
  */
 export const getDatapageGdoc = async (
+    knex: KnexReadonlyTransaction,
     googleDocEditLinkOrId: string,
     isPreviewing: boolean
 ): Promise<OwidGdocPostInterface | null> => {
@@ -99,11 +103,16 @@ export const getDatapageGdoc = async (
 
     const datapageGdoc =
         isPreviewing && OwidGoogleAuth.areGdocAuthKeysSet()
-            ? ((await GdocFactory.load(
+            ? ((await getAndLoadGdocById(
+                  knex,
                   googleDocId,
                   GdocsContentSource.Gdocs
-              )) as GdocPost)
-            : await GdocPost.findOneBy({ id: googleDocId })
+              )) as OwidGdocPostInterface)
+            : ((await getGdocBaseObjectById(
+                  knex,
+                  googleDocId,
+                  true
+              )) as OwidGdocPostInterface)
 
     return datapageGdoc
 }
diff --git a/baker/GDriveImagesBaker.tsx b/baker/GDriveImagesBaker.tsx
index c60006ce769..28fd048870f 100644
--- a/baker/GDriveImagesBaker.tsx
+++ b/baker/GDriveImagesBaker.tsx
@@ -7,8 +7,9 @@ import {
 } from "../settings/serverSettings.js"
 
 import {
-    ImageMetadata,
+    DbRawImage,
     getFilenameAsPng,
+    parseImageRow,
     retryPromise,
 } from "@ourworldindata/utils"
 import { Image } from "../db/model/Image.js"
@@ -16,14 +17,18 @@ import sharp from "sharp"
 import pMap from "p-map"
 import { BAKED_BASE_URL } from "../settings/clientSettings.js"
 
-export const bakeDriveImages = async (bakedSiteDir: string) => {
+export const bakeDriveImages = async (
+    knex: db.KnexReadonlyTransaction,
+    bakedSiteDir: string
+) => {
     // Get all GDocs images, download locally and resize them
     const images: Image[] = await db
-        .queryMysql(
+        .knexRaw<DbRawImage>(
+            knex,
             `SELECT * FROM images WHERE id IN (SELECT DISTINCT imageId FROM posts_gdocs_x_images)`
         )
-        .then((results: ImageMetadata[]) =>
-            results.map((result) => Image.create<Image>(result))
+        .then((results) =>
+            results.map((result) => new Image(parseImageRow(result)))
         )
 
     const imagesDirectory = path.join(bakedSiteDir, "images", "published")
diff --git a/baker/GrapherBaker.tsx b/baker/GrapherBaker.tsx
index 0f1400a0ed7..4049259dbf9 100644
--- a/baker/GrapherBaker.tsx
+++ b/baker/GrapherBaker.tsx
@@ -43,6 +43,7 @@ import {
     FaqEntryData,
     FaqDictionary,
     ImageMetadata,
+    OwidGdocBaseInterface,
 } from "@ourworldindata/types"
 import ProgressBar from "progress"
 import {
@@ -51,16 +52,16 @@ import {
     getVariableOfDatapageIfApplicable,
 } from "../db/model/Variable.js"
 import { getDatapageDataV2, getDatapageGdoc } from "./DatapageHelpers.js"
-import { Image } from "../db/model/Image.js"
+import { Image, getAllImages } from "../db/model/Image.js"
 import { logErrorAndMaybeSendToBugsnag } from "../serverUtils/errorLog.js"
 
 import { parseFaqs } from "../db/model/Gdoc/rawToEnriched.js"
-import { GdocPost } from "../db/model/Gdoc/GdocPost.js"
 import { getShortPageCitation } from "../site/gdocs/utils.js"
 import { getSlugForTopicTag, getTagToSlugMap } from "./GrapherBakingUtils.js"
 import { knexRaw } from "../db/db.js"
 import { getRelatedChartsForVariable } from "../db/model/Chart.js"
 import pMap from "p-map"
+import { getGdocBaseObjectBySlug } from "../db/model/Gdoc/GdocFactory.js"
 
 const renderDatapageIfApplicable = async (
     grapher: GrapherInterface,
@@ -150,7 +151,7 @@ export async function renderDataPageV2(
         uniq(variableMetadata.presentation?.faqs?.map((faq) => faq.gdocId))
     )
     const gdocFetchPromises = faqDocs.map((gdocId) =>
-        getDatapageGdoc(gdocId, isPreviewing)
+        getDatapageGdoc(knex, gdocId, isPreviewing)
     )
     const gdocs = await Promise.all(gdocFetchPromises)
     const gdocIdToFragmentIdToBlock: Record<string, FaqDictionary> = {}
@@ -250,14 +251,9 @@ export async function renderDataPageV2(
                 `Datapage with variableId "${variableId}" and title "${datapageData.title.title}" is using "${firstTopicTag}" as its primary tag, which we are unable to resolve to a tag in the grapher DB`
             )
         }
-        let gdoc: GdocPost | null = null
+        let gdoc: OwidGdocBaseInterface | undefined = undefined
         if (slug) {
-            gdoc = await GdocPost.findOne({
-                where: {
-                    slug,
-                },
-                relations: ["tags"],
-            })
+            gdoc = await getGdocBaseObjectBySlug(knex, slug, true)
         }
         if (gdoc) {
             const citation = getShortPageCitation(
@@ -495,8 +491,8 @@ export const bakeAllChangedGrapherPagesVariablesPngSvgAndDeleteRemovedGraphers =
         // Prefetch imageMetadata instead of each grapher page fetching
         // individually. imageMetadata is used by the google docs powering rich
         // text (including images) in data pages.
-        const imageMetadataDictionary = await Image.find().then((images) =>
-            keyBy(images, "filename")
+        const imageMetadataDictionary = await getAllImages(knex).then(
+            (images) => keyBy(images, "filename")
         )
 
         const jobs: BakeSingleGrapherChartArguments[] = chartsToBake.map(
diff --git a/baker/GrapherBakingUtils.ts b/baker/GrapherBakingUtils.ts
index bd1079eef4b..68061371abb 100644
--- a/baker/GrapherBakingUtils.ts
+++ b/baker/GrapherBakingUtils.ts
@@ -12,7 +12,7 @@ import { bakeGraphersToSvgs } from "../baker/GrapherImageBaker.js"
 import { warn } from "../serverUtils/errorLog.js"
 import { mapSlugsToIds } from "../db/model/Chart.js"
 import md5 from "md5"
-import { Url, Tag } from "@ourworldindata/utils"
+import { DbPlainTag, Url } from "@ourworldindata/utils"
 
 interface ChartExportMeta {
     key: string
@@ -146,7 +146,7 @@ export async function getTagToSlugMap(): Promise<
 > {
     const tags = (await db.queryMysql(
         `SELECT slug, name, id FROM tags WHERE slug IS NOT NULL`
-    )) as Pick<Tag, "name" | "id" | "slug">[]
+    )) as Pick<DbPlainTag, "name" | "id" | "slug">[]
     const tagsByIdAndName: Record<string | number, string> = {}
     for (const tag of tags) {
         if (tag.slug) {
diff --git a/baker/SiteBaker.tsx b/baker/SiteBaker.tsx
index 203495c14e8..421e33b7073 100644
--- a/baker/SiteBaker.tsx
+++ b/baker/SiteBaker.tsx
@@ -81,7 +81,7 @@ import {
     postsTable,
 } from "../db/model/Post.js"
 import { GdocPost } from "../db/model/Gdoc/GdocPost.js"
-import { Image } from "../db/model/Image.js"
+import { Image, getAllImages } from "../db/model/Image.js"
 import { generateEmbedSnippet } from "../site/viteUtils.js"
 import { logErrorAndMaybeSendToBugsnag } from "../serverUtils/errorLog.js"
 import {
@@ -94,14 +94,12 @@ import {
 } from "../settings/clientSettings.js"
 import pMap from "p-map"
 import { GdocDataInsight } from "../db/model/Gdoc/GdocDataInsight.js"
-import {
-    calculateDataInsightIndexPageCount,
-    fullGdocToMinimalGdoc,
-} from "../db/model/Gdoc/gdocUtils.js"
+import { calculateDataInsightIndexPageCount } from "../db/model/Gdoc/gdocUtils.js"
 import {
     getVariableMetadata,
     getVariableOfDatapageIfApplicable,
 } from "../db/model/Variable.js"
+import { getAllMinimalGdocBaseObjects } from "../db/model/Gdoc/GdocFactory.js"
 import { getBakePath } from "@ourworldindata/components"
 import { GdocAuthor } from "../db/model/Gdoc/GdocAuthor.js"
 
@@ -304,13 +302,13 @@ export class SiteBaker {
         picks?: [string[], string[], string[], string[]]
     ): Promise<PrefetchedAttachments> {
         if (!this._prefetchedAttachmentsCache) {
-            const publishedGdocs = await GdocPost.getPublishedGdocPosts().then(
-                (fullGdocs) => fullGdocs.map(fullGdocToMinimalGdoc)
-            )
+            const publishedGdocs = await getAllMinimalGdocBaseObjects(knex)
             const publishedGdocsDictionary = keyBy(publishedGdocs, "id")
 
             const imageMetadataDictionary: Record<string, Image> =
-                await Image.find().then((images) => keyBy(images, "filename"))
+                await getAllImages(knex).then((images) =>
+                    keyBy(images, "filename")
+                )
             const publishedExplorersBySlug = await this.explorerAdminServer
                 .getAllPublishedExplorersBySlugCached()
                 .then((results) =>
@@ -443,7 +441,7 @@ export class SiteBaker {
             postSlugs.push(post.slug)
         }
 
-        const gdocPosts = await GdocPost.getPublishedGdocPosts()
+        const gdocPosts = await getAllMinimalGdocBaseObjects(knex)
 
         for (const post of gdocPosts) {
             postSlugs.push(post.slug)
@@ -485,9 +483,8 @@ export class SiteBaker {
 
     // Bake all GDoc posts, or a subset of them if slugs are provided
     async bakeGDocPosts(knex: db.KnexReadonlyTransaction, slugs?: string[]) {
-        await db.getConnection()
         if (!this.bakeSteps.has("gdocPosts")) return
-        const publishedGdocs = await GdocPost.getPublishedGdocPosts()
+        const publishedGdocs = await GdocPost.getPublishedGdocPosts(knex)
 
         const gdocsToBake =
             slugs !== undefined
@@ -520,9 +517,9 @@ export class SiteBaker {
             publishedGdoc.linkedIndicators = attachments.linkedIndicators
 
             // this is a no-op if the gdoc doesn't have an all-chart block
-            await publishedGdoc.loadRelatedCharts()
+            await publishedGdoc.loadRelatedCharts(knex)
 
-            await publishedGdoc.validate()
+            await publishedGdoc.validate(knex)
             if (
                 publishedGdoc.errors.filter(
                     (e) => e.type === OwidGdocErrorMessageType.Error
@@ -557,7 +554,7 @@ export class SiteBaker {
         )
         await this.stageWrite(
             `${this.bakedSiteDir}/donate.html`,
-            await renderDonatePage()
+            await renderDonatePage(knex)
         )
         await this.stageWrite(
             `${this.bakedSiteDir}/thank-you.html`,
@@ -618,7 +615,9 @@ export class SiteBaker {
         this.progressBar.tick({ name: "✅ baked explorers" })
     }
 
-    private async validateGrapherDodReferences() {
+    private async validateGrapherDodReferences(
+        knex: db.KnexReadonlyTransaction
+    ) {
         if (!this.bakeSteps.has("dods") || !this.bakeSteps.has("charts")) return
         if (!GDOCS_DETAILS_ON_DEMAND_ID) {
             console.error(
@@ -627,7 +626,7 @@ export class SiteBaker {
             return
         }
 
-        const { details } = await GdocPost.getDetailsOnDemandGdoc()
+        const { details } = await GdocPost.getDetailsOnDemandGdoc(knex)
 
         if (!details) {
             this.progressBar.tick({
@@ -637,7 +636,9 @@ export class SiteBaker {
         }
 
         const charts: { slug: string; subtitle: string; note: string }[] =
-            await db.queryMysql(`
+            await db.knexRaw<{ slug: string; subtitle: string; note: string }>(
+                knex,
+                `-- sql
                 SELECT
                     config ->> '$.slug' as slug,
                     config ->> '$.subtitle' as subtitle,
@@ -652,7 +653,8 @@ export class SiteBaker {
                 )
                 ORDER BY
                     JSON_EXTRACT(config, "$.slug") ASC
-            `)
+            `
+            )
 
         for (const chart of charts) {
             const detailIds = new Set(
@@ -670,7 +672,7 @@ export class SiteBaker {
         this.progressBar.tick({ name: "✅ validated grapher dods" })
     }
 
-    private async bakeDetailsOnDemand() {
+    private async bakeDetailsOnDemand(knex: db.KnexReadonlyTransaction) {
         if (!this.bakeSteps.has("dods")) return
         if (!GDOCS_DETAILS_ON_DEMAND_ID) {
             console.error(
@@ -679,7 +681,8 @@ export class SiteBaker {
             return
         }
 
-        const { details, parseErrors } = await GdocPost.getDetailsOnDemandGdoc()
+        const { details, parseErrors } =
+            await GdocPost.getDetailsOnDemandGdoc(knex)
         if (parseErrors.length) {
             logErrorAndMaybeSendToBugsnag(
                 `Error(s) baking details: ${parseErrors
@@ -703,7 +706,7 @@ export class SiteBaker {
         if (!this.bakeSteps.has("dataInsights")) return
         const latestDataInsights = await db.getPublishedDataInsights(knex, 5)
         const publishedDataInsights =
-            await GdocDataInsight.getPublishedDataInsights()
+            await GdocDataInsight.getPublishedDataInsights(knex)
 
         for (const dataInsight of publishedDataInsights) {
             const attachments = await this.getPrefetchedGdocAttachments(knex, [
@@ -720,7 +723,7 @@ export class SiteBaker {
             }
             dataInsight.latestDataInsights = latestDataInsights
 
-            await dataInsight.validate()
+            await dataInsight.validate(knex)
             if (
                 dataInsight.errors.filter(
                     (e) => e.type === OwidGdocErrorMessageType.Error
@@ -770,7 +773,7 @@ export class SiteBaker {
     private async bakeAuthors(knex: db.KnexReadonlyTransaction) {
         if (!this.bakeSteps.has("authors")) return
 
-        const publishedAuthors = await GdocAuthor.getPublishedAuthors()
+        const publishedAuthors = await GdocAuthor.getPublishedAuthors(knex)
 
         for (const publishedAuthor of publishedAuthors) {
             const attachments = await this.getPrefetchedGdocAttachments(knex, [
@@ -795,9 +798,9 @@ export class SiteBaker {
             publishedAuthor.imageMetadata = attachments.imageMetadata
 
             // Attach image metadata for the “latest work" images
-            await publishedAuthor.loadLatestWorkImages()
+            await publishedAuthor.loadLatestWorkImages(knex)
 
-            await publishedAuthor.validate()
+            await publishedAuthor.validate(knex)
             if (
                 publishedAuthor.errors.filter(
                     (e) => e.type === OwidGdocErrorMessageType.Error
@@ -881,10 +884,10 @@ export class SiteBaker {
         this.progressBar.tick({ name: "✅ baked rss" })
     }
 
-    private async bakeDriveImages() {
+    private async bakeDriveImages(knex: db.KnexReadonlyTransaction) {
         if (!this.bakeSteps.has("gdriveImages")) return
         await this.ensureDir("images/published")
-        await bakeDriveImages(this.bakedSiteDir)
+        await bakeDriveImages(knex, this.bakedSiteDir)
         this.progressBar.tick({ name: "✅ baked google drive images" })
     }
 
@@ -979,12 +982,12 @@ export class SiteBaker {
                 name: "✅ bakeAllChangedGrapherPagesVariablesPngSvgAndDeleteRemovedGraphers",
             })
         }
-        await this.bakeDetailsOnDemand()
-        await this.validateGrapherDodReferences()
+        await this.bakeDetailsOnDemand(knex)
+        await this.validateGrapherDodReferences(knex)
         await this.bakeGDocPosts(knex)
         await this.bakeDataInsights(knex)
         await this.bakeAuthors(knex)
-        await this.bakeDriveImages()
+        await this.bakeDriveImages(knex)
     }
 
     async bakeNonWordpressPages(knex: db.KnexReadonlyTransaction) {
diff --git a/baker/algolia/indexChartsToAlgolia.ts b/baker/algolia/indexChartsToAlgolia.ts
index a9e8582d36b..b8bbd72cb29 100644
--- a/baker/algolia/indexChartsToAlgolia.ts
+++ b/baker/algolia/indexChartsToAlgolia.ts
@@ -6,8 +6,8 @@ import { ChartRecord, SearchIndexName } from "../../site/search/searchTypes.js"
 import { KeyChartLevel, OwidGdocLinkType, isNil } from "@ourworldindata/utils"
 import { MarkdownTextWrap } from "@ourworldindata/components"
 import { getAnalyticsPageviewsByUrlObj } from "../../db/model/Pageview.js"
-import { Link } from "../../db/model/Link.js"
 import { getRelatedArticles } from "../../db/model/Post.js"
+import { getPublishedLinksTo } from "../../db/model/Link.js"
 
 const computeScore = (record: Omit<ChartRecord, "score">): number => {
     const { numRelatedArticles, views_7d } = record
@@ -82,7 +82,8 @@ const getChartsRecords = async (
         if (isPathRedirectedToExplorer(`/grapher/${c.slug}`)) continue
 
         const relatedArticles = (await getRelatedArticles(knex, c.id)) ?? []
-        const linksFromGdocs = await Link.getPublishedLinksTo(
+        const linksFromGdocs = await getPublishedLinksTo(
+            knex,
             [c.slug],
             OwidGdocLinkType.Grapher
         )
diff --git a/baker/algolia/indexToAlgolia.tsx b/baker/algolia/indexToAlgolia.tsx
index 519690446e3..62f641d4a48 100644
--- a/baker/algolia/indexToAlgolia.tsx
+++ b/baker/algolia/indexToAlgolia.tsx
@@ -10,8 +10,8 @@ import {
     keyBy,
     OwidGdocType,
     type RawPageview,
-    Tag,
     PostRestApi,
+    DbPlainTag,
 } from "@ourworldindata/utils"
 import { formatPost } from "../formatWordpressPost.js"
 import ReactDOMServer from "react-dom/server.js"
@@ -83,7 +83,7 @@ async function generateWordpressRecords(
 ): Promise<PageRecord[]> {
     const getPostTypeAndImportance = (
         post: FormattedPost,
-        tags: Pick<Tag, "name">[]
+        tags: Pick<DbPlainTag, "name">[]
     ): TypeAndImportance => {
         if (post.slug.startsWith("about/") || post.slug === "about")
             return { type: "about", importance: 1 }
@@ -181,7 +181,7 @@ function generateGdocRecords(
                 excerpt: gdoc.content.excerpt,
                 date: gdoc.publishedAt!.toISOString(),
                 modifiedDate: gdoc.updatedAt!.toISOString(),
-                tags: gdoc.tags.map((t) => t.name),
+                tags: gdoc?.tags?.map((t) => t.name),
                 documentType: "gdoc" as const,
                 // authors: gdoc.content.byline, // different format
             }
@@ -196,7 +196,7 @@ function generateGdocRecords(
 // Generate records for countries, WP posts (not including posts that have been succeeded by Gdocs equivalents), and Gdocs
 const getPagesRecords = async (knex: db.KnexReadonlyTransaction) => {
     const pageviews = await getAnalyticsPageviewsByUrlObj(knex)
-    const gdocs = await GdocPost.getPublishedGdocPosts()
+    const gdocs = await GdocPost.getPublishedGdocPosts(knex)
     const publishedGdocsBySlug = keyBy(gdocs, "slug")
     // TODO: the knex instance should be handed down as a parameter
     const slugsWithPublishedGdocsSuccessors =
diff --git a/baker/siteRenderers.tsx b/baker/siteRenderers.tsx
index a930500aff9..bc52cb74581 100644
--- a/baker/siteRenderers.tsx
+++ b/baker/siteRenderers.tsx
@@ -91,7 +91,10 @@ import {
 } from "../db/model/Post.js"
 import { GdocPost } from "../db/model/Gdoc/GdocPost.js"
 import { logErrorAndMaybeSendToBugsnag } from "../serverUtils/errorLog.js"
-import { GdocFactory } from "../db/model/Gdoc/GdocFactory.js"
+import {
+    getAndLoadGdocBySlug,
+    getAndLoadGdocById,
+} from "../db/model/Gdoc/GdocFactory.js"
 import { SiteNavigationStatic } from "../site/SiteNavigation.js"
 
 export const renderToHtmlPage = (element: any) =>
@@ -167,15 +170,16 @@ export function renderDynamicCollectionPage() {
 }
 
 export const renderGdocsPageBySlug = async (
+    knex: KnexReadonlyTransaction,
     slug: string,
     isPreviewing: boolean = false
 ): Promise<string | undefined> => {
-    const gdoc = await GdocFactory.loadBySlug(slug)
+    const gdoc = await getAndLoadGdocBySlug(knex, slug)
     if (!gdoc) {
         throw new Error(`Failed to render an unknown GDocs post: ${slug}.`)
     }
 
-    await gdoc.loadState()
+    await gdoc.loadState(knex)
 
     return renderGdoc(gdoc, isPreviewing)
 }
@@ -259,8 +263,8 @@ export const renderFrontPage = async (knex: KnexReadonlyTransaction) => {
     const gdocHomepageId = await getHomepageId(knex)
 
     if (gdocHomepageId) {
-        const gdocHomepage = await GdocFactory.load(gdocHomepageId)
-        await gdocHomepage.loadState()
+        const gdocHomepage = await getAndLoadGdocById(knex, gdocHomepageId)
+        await gdocHomepage.loadState(knex)
         return renderGdoc(gdocHomepage)
     } else {
         logErrorAndMaybeSendToBugsnag(
@@ -272,8 +276,9 @@ export const renderFrontPage = async (knex: KnexReadonlyTransaction) => {
     }
 }
 
-export const renderDonatePage = async () => {
-    const faqsGdoc = (await GdocFactory.load(
+export const renderDonatePage = async (knex: KnexReadonlyTransaction) => {
+    const faqsGdoc = (await getAndLoadGdocById(
+        knex,
         GDOCS_DONATE_FAQS_DOCUMENT_ID
     )) as GdocPost
     if (!faqsGdoc)
diff --git a/baker/sitemap.ts b/baker/sitemap.ts
index 3d8f4c120a5..67766140e40 100644
--- a/baker/sitemap.ts
+++ b/baker/sitemap.ts
@@ -73,7 +73,7 @@ export const makeSitemap = async (
         undefined,
         (postrow) => !alreadyPublishedViaGdocsSlugsSet.has(postrow.slug)
     )
-    const gdocPosts = await GdocPost.getPublishedGdocPosts()
+    const gdocPosts = await GdocPost.getPublishedGdocPosts(knex)
 
     const publishedDataInsights = await db.getPublishedDataInsights(knex)
     const dataInsightFeedPageCount = calculateDataInsightIndexPageCount(
diff --git a/db/db.ts b/db/db.ts
index a08afaa7ed4..cb28560df5e 100644
--- a/db/db.ts
+++ b/db/db.ts
@@ -143,13 +143,25 @@ export async function knexReadWriteTransaction<T>(
 export const knexRaw = async <TRow = unknown>(
     knex: Knex<any, any[]>,
     str: string,
-    params?: any[]
-): Promise<TRow[]> => (await knex.raw(str, params ?? []))[0]
+    params?: any[] | Record<string, any>
+): Promise<TRow[]> => {
+    try {
+        const rawReturnConstruct = await knex.raw(str, params ?? [])
+        return rawReturnConstruct[0]
+    } catch (e) {
+        console.error("Exception when executing SQL statement!", {
+            sql: str,
+            params,
+            error: e,
+        })
+        throw e
+    }
+}
 
 export const knexRawFirst = async <TRow = unknown>(
     knex: KnexReadonlyTransaction,
     str: string,
-    params?: any[]
+    params?: any[] | Record<string, any>
 ): Promise<TRow | undefined> => {
     const results = await knexRaw<TRow>(knex, str, params)
     if (results.length === 0) return undefined
@@ -274,7 +286,7 @@ export const getPublishedDataInsightCount = (
 ): Promise<number> => {
     return knexRawFirst<{ count: number }>(
         knex,
-        `-- sql
+        `
         SELECT COUNT(*) AS count
         FROM posts_gdocs
         WHERE content->>'$.type' = '${OwidGdocType.DataInsight}'
@@ -288,7 +300,7 @@ export const getTotalNumberOfCharts = (
 ): Promise<number> => {
     return knexRawFirst<{ count: number }>(
         knex,
-        `-- sql
+        `
         SELECT COUNT(*) AS count
         FROM charts
         WHERE config->"$.isPublished" = TRUE`
diff --git a/db/migrateWpPostsToArchieMl.ts b/db/migrateWpPostsToArchieMl.ts
index f34dcd034fa..259a1dafece 100644
--- a/db/migrateWpPostsToArchieMl.ts
+++ b/db/migrateWpPostsToArchieMl.ts
@@ -258,6 +258,8 @@ const migrate = async (trx: db.KnexReadWriteTransaction): Promise<void> => {
                 updatedAt: post.updated_at_in_wordpress,
                 publicationContext: OwidGdocPublicationContext.listed, // TODO: not all articles are listed, take this from the DB
                 revisionId: null,
+                breadcrumbs: null,
+                markdown: null,
             }
             const archieMlStatsContent = {
                 errors,
diff --git a/db/model/Chart.ts b/db/model/Chart.ts
index 985d6b6ab7e..b1a6619c9eb 100644
--- a/db/model/Chart.ts
+++ b/db/model/Chart.ts
@@ -1,22 +1,21 @@
-import {
-    Entity,
-    PrimaryGeneratedColumn,
-    Column,
-    BaseEntity,
-    ManyToOne,
-    OneToMany,
-    type Relation,
-} from "typeorm"
+// import {
+//     Entity,
+//     PrimaryGeneratedColumn,
+//     Column,
+//     BaseEntity,
+//     ManyToOne,
+//     OneToMany,
+//     type Relation,
+// } from "typeorm"
 import * as lodash from "lodash"
 import * as db from "../db.js"
 import { getDataForMultipleVariables } from "./Variable.js"
-import { User } from "./User.js"
-import { ChartRevision } from "./ChartRevision.js"
+// import { User } from "./User.js"
+// import { ChartRevision } from "./ChartRevision.js"
 import {
     JsonError,
     KeyChartLevel,
     MultipleOwidVariableDataDimensionsMap,
-    Tag,
     DbChartTagJoin,
 } from "@ourworldindata/utils"
 import {
@@ -29,6 +28,7 @@ import {
     parseChartsRow,
     parseChartConfig,
     ChartRedirect,
+    DbPlainTag,
 } from "@ourworldindata/types"
 import { OpenAI } from "openai"
 import {
@@ -42,24 +42,25 @@ export const PUBLIC_TAG_PARENT_IDS = [
     1505, 1508, 1512, 1510, 1834, 1835,
 ]
 
-@Entity("charts")
-export class Chart extends BaseEntity {
-    @PrimaryGeneratedColumn() id!: number
-    @Column({ type: "json" }) config!: GrapherInterface
-    @Column() lastEditedAt!: Date
-    @Column() lastEditedByUserId!: number
-    @Column({ nullable: true }) publishedAt!: Date
-    @Column({ nullable: true }) publishedByUserId!: number
-    @Column() createdAt!: Date
-    @Column() updatedAt!: Date
-
-    @ManyToOne(() => User, (user) => user.lastEditedCharts)
-    lastEditedByUser!: Relation<User>
-    @ManyToOne(() => User, (user) => user.publishedCharts)
-    publishedByUser!: Relation<User>
-    @OneToMany(() => ChartRevision, (rev) => rev.chart)
-    logs!: Relation<ChartRevision[]>
-}
+// @Entity("charts")
+// export class Chart extends BaseEntity {
+//     @PrimaryGeneratedColumn() id!: number
+//     @Column({ type: "json" }) config!: GrapherInterface
+//     @Column() lastEditedAt!: Date
+//     @Column() lastEditedByUserId!: number
+//     @Column({ nullable: true }) publishedAt!: Date
+//     @Column({ nullable: true }) publishedByUserId!: number
+//     @Column() createdAt!: Date
+//     @Column() updatedAt!: Date
+//     @Column() isExplorable!: boolean
+
+//     @ManyToOne(() => User, (user) => user.lastEditedCharts)
+//     lastEditedByUser!: Relation<User>
+//     @ManyToOne(() => User, (user) => user.publishedCharts)
+//     publishedByUser!: Relation<User>
+//     @OneToMany(() => ChartRevision, (rev) => rev.chart)
+//     logs!: Relation<ChartRevision[]>
+// }
 // Only considers published charts, because only in that case the mapping slug -> id is unique
 export async function mapSlugsToIds(
     knex: db.KnexReadonlyTransaction
@@ -303,7 +304,7 @@ export async function assignTagsForCharts(
 export async function getGptTopicSuggestions(
     knex: db.KnexReadonlyTransaction,
     chartId: number
-): Promise<Pick<Tag, "id" | "name">[]> {
+): Promise<Pick<DbPlainTag, "id" | "name">[]> {
     if (!OPENAI_API_KEY) throw new JsonError("No OPENAI_API_KEY env found", 500)
 
     const chartConfigOnly: Pick<DbRawChart, "config"> | undefined = await knex
@@ -315,7 +316,7 @@ export async function getGptTopicSuggestions(
         throw new JsonError(`No chart found for id ${chartId}`, 404)
     const enrichedChartConfig = parseChartConfig(chartConfigOnly.config)
 
-    const topics: Pick<Tag, "id" | "name">[] = await db.knexRaw(
+    const topics: Pick<DbPlainTag, "id" | "name">[] = await db.knexRaw(
         knex,
         `-- sql
         SELECT t.id, t.name
diff --git a/db/model/ChartRevision.ts b/db/model/ChartRevision.ts
index 0125b14b420..4f9bd840ceb 100644
--- a/db/model/ChartRevision.ts
+++ b/db/model/ChartRevision.ts
@@ -1,27 +1,27 @@
-import {
-    Entity,
-    PrimaryGeneratedColumn,
-    Column,
-    BaseEntity,
-    ManyToOne,
-    type Relation,
-} from "typeorm"
-import { Chart } from "./Chart.js"
-import { User } from "./User.js"
+// import {
+//     Entity,
+//     PrimaryGeneratedColumn,
+//     Column,
+//     BaseEntity,
+//     ManyToOne,
+//     type Relation,
+// } from "typeorm"
+// // import { Chart } from "./Chart.js"
+// import { User } from "./User.js"
 
-@Entity("chart_revisions")
-export class ChartRevision extends BaseEntity {
-    @PrimaryGeneratedColumn() id!: number
-    @Column() chartId!: number
-    @Column({ type: "json" }) config: any
-    @Column() userId!: number
+// @Entity("chart_revisions")
+// export class ChartRevision extends BaseEntity {
+//     @PrimaryGeneratedColumn() id!: number
+//     @Column() chartId!: number
+//     @Column({ type: "json" }) config: any
+//     @Column() userId!: number
 
-    @Column() createdAt!: Date
-    @Column() updatedAt!: Date
+//     @Column() createdAt!: Date
+//     @Column() updatedAt!: Date
 
-    @ManyToOne(() => User, (user) => user.editedCharts)
-    user!: Relation<User>
+//     @ManyToOne(() => User, (user) => user.editedCharts)
+//     user!: Relation<User>
 
-    @ManyToOne(() => Chart, (chart) => chart.logs)
-    chart!: Relation<Chart>
-}
+//     @ManyToOne(() => Chart, (chart) => chart.logs)
+//     chart!: Relation<Chart>
+// }
diff --git a/db/model/Dataset.ts b/db/model/Dataset.ts
index 68110afcab6..d47bd47c55d 100644
--- a/db/model/Dataset.ts
+++ b/db/model/Dataset.ts
@@ -1,15 +1,5 @@
-import {
-    Entity,
-    PrimaryGeneratedColumn,
-    Column,
-    BaseEntity,
-    ManyToOne,
-    Unique,
-    type Relation,
-} from "typeorm"
 import { Writable } from "stream"
 
-import { User } from "./User.js"
 import { getSourcesForDataset, sourceToDatapackage } from "./Source.js"
 
 import * as db from "../db.js"
@@ -23,25 +13,25 @@ import {
     DbRawVariable,
 } from "@ourworldindata/types"
 
-@Entity("datasets")
-@Unique(["name", "namespace"])
-export class Dataset extends BaseEntity {
-    @PrimaryGeneratedColumn() id!: number
-    @Column() name!: string
-    @Column({ default: "owid" }) namespace!: string
-    @Column({ default: "" }) description!: string
-    @Column() createdAt!: Date
-    @Column() updatedAt!: Date
-    @Column() metadataEditedAt!: Date
-    @Column() metadataEditedByUserId!: number
-    @Column() dataEditedAt!: Date
-    @Column() dataEditedByUserId!: number
-    @Column({ default: false }) isPrivate!: boolean
-    @Column({ default: false }) nonRedistributable!: boolean
+// @Entity("datasets")
+// @Unique(["name", "namespace"])
+// export class Dataset extends BaseEntity {
+//     @PrimaryGeneratedColumn() id!: number
+//     @Column() name!: string
+//     @Column({ default: "owid" }) namespace!: string
+//     @Column({ default: "" }) description!: string
+//     @Column() createdAt!: Date
+//     @Column() updatedAt!: Date
+//     @Column() metadataEditedAt!: Date
+//     @Column() metadataEditedByUserId!: number
+//     @Column() dataEditedAt!: Date
+//     @Column() dataEditedByUserId!: number
+//     @Column({ default: false }) isPrivate!: boolean
+//     @Column({ default: false }) nonRedistributable!: boolean
 
-    @ManyToOne(() => User, (user) => user.createdDatasets)
-    createdByUser!: Relation<User>
-}
+//     @ManyToOne(() => User, (user) => user.createdDatasets)
+//     createdByUser!: Relation<User>
+// }
 
 export async function getDatasetById(
     knex: db.KnexReadonlyTransaction,
diff --git a/db/model/Gdoc/GdocAuthor.ts b/db/model/Gdoc/GdocAuthor.ts
index eb22ec33395..4a8af87c073 100644
--- a/db/model/Gdoc/GdocAuthor.ts
+++ b/db/model/Gdoc/GdocAuthor.ts
@@ -1,4 +1,3 @@
-import { Entity, Column, Raw } from "typeorm"
 import {
     OwidGdocErrorMessage,
     OwidGdocAuthorInterface,
@@ -8,23 +7,28 @@ import {
     OwidGdocErrorMessageType,
     DbEnrichedLatestWork,
     DEFAULT_GDOC_FEATURED_IMAGE,
-    OwidGdocType,
+    OwidGdocBaseInterface,
 } from "@ourworldindata/utils"
 import { GdocBase } from "./GdocBase.js"
 import { htmlToEnrichedTextBlock } from "./htmlToEnriched.js"
 import { parseSocials } from "./rawToEnriched.js"
 import { getLatestWorkByAuthor } from "../Post.js"
 import * as db from "../../../db/db.js"
+import { loadPublishedGdocAuthors } from "./GdocFactory.js"
 
-@Entity("posts_gdocs")
 export class GdocAuthor extends GdocBase implements OwidGdocAuthorInterface {
-    @Column({ default: "{}", type: "json" })
     content!: OwidGdocAuthorContent
     latestWorkLinks?: DbEnrichedLatestWork[]
 
     constructor(id?: string) {
         super(id)
     }
+
+    static create(obj: OwidGdocBaseInterface): GdocAuthor {
+        const gdoc = new GdocAuthor()
+        Object.assign(gdoc, obj)
+        return gdoc
+    }
     _filenameProperties: string[] = ["featured-image"]
 
     _getSubclassEnrichedBlocks = (gdoc: this): OwidEnrichedGdocBlock[] => {
@@ -36,13 +40,16 @@ export class GdocAuthor extends GdocBase implements OwidGdocAuthorInterface {
         return blocks
     }
 
-    _loadSubclassAttachments = (): Promise<void> => {
-        return this.loadLatestWorkImages()
+    _loadSubclassAttachments = (
+        knex: db.KnexReadonlyTransaction
+    ): Promise<void> => {
+        return this.loadLatestWorkImages(knex)
     }
 
-    loadLatestWorkImages = async (): Promise<void> => {
+    loadLatestWorkImages = async (
+        knex: db.KnexReadonlyTransaction
+    ): Promise<void> => {
         if (!this.content.title) return
-        const knex = db.knexInstance()
 
         this.latestWorkLinks = await getLatestWorkByAuthor(
             knex,
@@ -65,7 +72,7 @@ export class GdocAuthor extends GdocBase implements OwidGdocAuthorInterface {
         // Load the image metadata for the latest work images, including the
         // default featured image which is used as a fallback in the entire
         // research and writing block
-        return super.loadImageMetadata([
+        return super.loadImageMetadata(knex, [
             ...latestWorkImageFilenames,
             DEFAULT_GDOC_FEATURED_IMAGE,
         ])
@@ -115,15 +122,9 @@ export class GdocAuthor extends GdocBase implements OwidGdocAuthorInterface {
         return errors
     }
 
-    static async getPublishedAuthors(): Promise<GdocAuthor[]> {
-        return GdocAuthor.find({
-            where: {
-                published: true,
-                content: Raw(
-                    (content) =>
-                        `${content}->"$.type" = '${OwidGdocType.Author}'`
-                ),
-            },
-        })
+    static async getPublishedAuthors(
+        knex: db.KnexReadonlyTransaction
+    ): Promise<GdocAuthor[]> {
+        return loadPublishedGdocAuthors(knex)
     }
 }
diff --git a/db/model/Gdoc/GdocBase.ts b/db/model/Gdoc/GdocBase.ts
index 8b4c0797302..cb5c5405f65 100644
--- a/db/model/Gdoc/GdocBase.ts
+++ b/db/model/Gdoc/GdocBase.ts
@@ -1,21 +1,9 @@
-import {
-    Entity,
-    Column,
-    BaseEntity,
-    UpdateDateColumn,
-    PrimaryColumn,
-    BeforeUpdate,
-    BeforeInsert,
-    ManyToMany,
-    JoinTable,
-} from "typeorm"
 import * as db from "../../db"
 import { getUrlTarget } from "@ourworldindata/components"
 import {
     LinkedChart,
     LinkedIndicator,
     keyBy,
-    excludeNull,
     ImageMetadata,
     excludeUndefined,
     OwidGdocErrorMessage,
@@ -27,10 +15,8 @@ import {
     EnrichedBlockResearchAndWritingLink,
     traverseEnrichedSpan,
     uniq,
-    omit,
     identity,
     OwidGdocBaseInterface,
-    Tag as TagInterface,
     OwidGdocPublicationContext,
     BreadcrumbItem,
     MinimalDataInsightInterface,
@@ -38,12 +24,14 @@ import {
     urlToSlug,
     grabMetadataForGdocLinkedIndicator,
     GrapherTabOption,
+    DbInsertPostGdocLink,
+    DbPlainTag,
+    formatDate,
 } from "@ourworldindata/utils"
 import { BAKED_GRAPHER_URL } from "../../../settings/serverSettings.js"
 import { google } from "googleapis"
 import { gdocToArchie } from "./gdocToArchie.js"
 import { archieToEnriched } from "./archieToEnriched.js"
-import { Link } from "../Link.js"
 import { imageStore } from "../Image.js"
 import { getChartConfigById, mapSlugsToIds } from "../Chart.js"
 import {
@@ -54,7 +42,6 @@ import { EXPLORERS_ROUTE_FOLDER } from "../../../explorer/ExplorerConstants.js"
 import { match, P } from "ts-pattern"
 import {
     extractUrl,
-    fullGdocToMinimalGdoc,
     getAllLinksFromResearchAndWritingBlock,
     spansToSimpleString,
 } from "./gdocUtils.js"
@@ -64,46 +51,24 @@ import {
     getVariableMetadata,
     getVariableOfDatapageIfApplicable,
 } from "../Variable.js"
-
-@Entity("tags")
-export class Tag extends BaseEntity implements TagInterface {
-    static table = "tags"
-    @PrimaryColumn() id!: number
-    @Column() name!: string
-    @Column() createdAt!: Date
-    @Column({ nullable: true }) updatedAt!: Date
-    @Column({ nullable: true }) parentId!: number
-    @Column() isBulkImport!: boolean
-    @Column({ type: "varchar", nullable: true }) slug!: string | null
-    @Column() specialType!: string
-    @ManyToMany(() => GdocBase, (gdoc) => gdoc.tags)
-    gdocs!: GdocBase[]
-}
-
-@Entity("posts_gdocs")
-export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
-    @PrimaryColumn() id!: string
-    @Column() slug: string = ""
-    @Column({ default: "{}", type: "json" }) content!: Record<string, any>
-    @Column() published: boolean = false
-    @Column() createdAt: Date = new Date()
-    @Column({ type: Date, nullable: true }) publishedAt: Date | null = null
-    @UpdateDateColumn({ nullable: true }) updatedAt: Date | null = null
-    @Column({ type: String, nullable: true }) revisionId: string | null = null
-    @Column({ type: String, nullable: true }) markdown: string | null = null
-    @Column() publicationContext: OwidGdocPublicationContext =
+import { createLinkFromUrl } from "../Link.js"
+import { OwidGdocContent, OwidGdocType } from "@ourworldindata/types"
+import { KnexReadonlyTransaction } from "../../db"
+
+export class GdocBase implements OwidGdocBaseInterface {
+    id!: string
+    slug: string = ""
+    content!: OwidGdocContent
+    published: boolean = false
+    createdAt: Date = new Date()
+    publishedAt: Date | null = null
+    updatedAt: Date | null = null
+    revisionId: string | null = null
+    markdown: string | null = null
+    publicationContext: OwidGdocPublicationContext =
         OwidGdocPublicationContext.unlisted
-    @Column({ type: "json", nullable: true }) breadcrumbs:
-        | BreadcrumbItem[]
-        | null = null
-    @ManyToMany(() => Tag, { cascade: true })
-    @JoinTable({
-        name: "posts_gdocs_x_tags",
-        joinColumn: { name: "gdocId", referencedColumnName: "id" },
-        inverseJoinColumn: { name: "tagId", referencedColumnName: "id" },
-    })
-    tags!: Tag[]
-
+    breadcrumbs: BreadcrumbItem[] | null = null
+    tags: DbPlainTag[] | null = null
     errors: OwidGdocErrorMessage[] = []
     imageMetadata: Record<string, ImageMetadata> = {}
     linkedCharts: Record<string, LinkedChart> = {}
@@ -114,22 +79,34 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
     _getSubclassEnrichedBlocks: (gdoc: typeof this) => OwidEnrichedGdocBlock[] =
         () => []
     _enrichSubclassContent: (content: Record<string, any>) => void = identity
-    _validateSubclass: (gdoc: typeof this) => Promise<OwidGdocErrorMessage[]> =
-        async () => []
-    // Some subclasses have filenames/urls in the front-matter that we want to track
-    _filenameProperties: string[] = []
-    _urlProperties: string[] = []
+    _validateSubclass: (
+        knex: db.KnexReadonlyTransaction,
+        gdoc: typeof this
+    ) => Promise<OwidGdocErrorMessage[]> = async () => []
     _omittableFields: string[] = []
-    _loadSubclassAttachments: () => Promise<void> = async () => undefined
+    _loadSubclassAttachments: (
+        knex: db.KnexReadonlyTransaction
+    ) => Promise<void> = async () => undefined
 
     constructor(id?: string) {
-        super()
         if (id) {
             this.id = id
         }
-        this.content = {}
     }
 
+    protected typeSpecificFilenames(): string[] {
+        return []
+    }
+
+    protected typeSpecificUrls(): string[] {
+        return []
+    }
+    // static create(obj: OwidGdocBaseInterface): GdocBase {
+    //     const gdoc = new GdocBase()
+    //     Object.assign(gdoc, obj)
+    //     return gdoc
+    // }
+
     get enrichedBlockSources(): OwidEnrichedGdocBlock[][] {
         const enrichedBlockSources: OwidEnrichedGdocBlock[][] = excludeNullish([
             this.content.body,
@@ -139,8 +116,6 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         return enrichedBlockSources
     }
 
-    @BeforeUpdate()
-    @BeforeInsert()
     updateMarkdown(): void {
         try {
             this.markdown =
@@ -156,8 +131,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
     get filenames(): string[] {
         const filenames: Set<string> = new Set()
 
-        for (const filenameProperty of this._filenameProperties) {
-            const filename = this.content[filenameProperty]
+        for (const filename of this.typeSpecificFilenames()) {
             if (filename) {
                 filenames.add(filename)
             }
@@ -230,14 +204,14 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         return [...details]
     }
 
-    get links(): Link[] {
-        const links: Link[] = []
+    get links(): DbInsertPostGdocLink[] {
+        const links: DbInsertPostGdocLink[] = []
 
-        for (const urlProperty of this._urlProperties) {
-            const url = extractUrl(this.content[urlProperty])
+        for (const urlCandidate of this.typeSpecificUrls()) {
+            const url = extractUrl(urlCandidate)
             if (url) {
                 links.push(
-                    Link.createFromUrl({
+                    createLinkFromUrl({
                         url,
                         source: this,
                         componentType: "front-matter",
@@ -334,10 +308,12 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         return hasAllChartsBlock
     }
 
-    extractLinksFromBlock(block: OwidEnrichedGdocBlock): Link[] | void {
-        const links: Link[] = match(block)
+    extractLinksFromBlock(
+        block: OwidEnrichedGdocBlock
+    ): DbInsertPostGdocLink[] | void {
+        const links: DbInsertPostGdocLink[] = match(block)
             .with({ type: "prominent-link" }, (block) => [
-                Link.createFromUrl({
+                createLinkFromUrl({
                     url: block.url,
                     source: this,
                     componentType: block.type,
@@ -345,7 +321,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 }),
             ])
             .with({ type: "chart" }, (block) => [
-                Link.createFromUrl({
+                createLinkFromUrl({
                     url: block.url,
                     source: this,
                     componentType: block.type,
@@ -353,7 +329,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
             ])
             .with({ type: "all-charts" }, (block) =>
                 block.top.map((item) =>
-                    Link.createFromUrl({
+                    createLinkFromUrl({
                         url: item.url,
                         source: this,
                         componentType: block.type,
@@ -361,11 +337,11 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 )
             )
             .with({ type: "recirc" }, (block) => {
-                const links: Link[] = []
+                const links: DbInsertPostGdocLink[] = []
 
                 block.links.forEach(({ url }, i) => {
                     links.push(
-                        Link.createFromUrl({
+                        createLinkFromUrl({
                             url,
                             source: this,
                             componentType: block.type,
@@ -377,10 +353,10 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 return links
             })
             .with({ type: "scroller" }, (block) => {
-                const links: Link[] = []
+                const links: DbInsertPostGdocLink[] = []
 
                 block.blocks.forEach(({ url, text }, i) => {
-                    const chartLink = Link.createFromUrl({
+                    const chartLink = createLinkFromUrl({
                         url,
                         source: this,
                         componentType: block.type,
@@ -398,10 +374,10 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 return links
             })
             .with({ type: "chart-story" }, (block) => {
-                const links: Link[] = []
+                const links: DbInsertPostGdocLink[] = []
 
                 block.items.forEach((storyItem, i) => {
-                    const chartLink = Link.createFromUrl({
+                    const chartLink = createLinkFromUrl({
                         url: storyItem.chart.url,
                         source: this,
                         componentType: block.type,
@@ -427,10 +403,10 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 return links
             })
             .with({ type: "topic-page-intro" }, (block) => {
-                const links: Link[] = []
+                const links: DbInsertPostGdocLink[] = []
 
                 if (block.downloadButton) {
-                    const downloadButtonLink = Link.createFromUrl({
+                    const downloadButtonLink = createLinkFromUrl({
                         url: block.downloadButton.url,
                         source: this,
                         componentType: block.type,
@@ -440,7 +416,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 }
                 if (block.relatedTopics) {
                     block.relatedTopics.forEach((relatedTopic) => {
-                        const relatedTopicLink = Link.createFromUrl({
+                        const relatedTopicLink = createLinkFromUrl({
                             url: relatedTopic.url,
                             source: this,
                             componentType: block.type,
@@ -462,12 +438,12 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 return links
             })
             .with({ type: "key-insights" }, (block) => {
-                const links: Link[] = []
+                const links: DbInsertPostGdocLink[] = []
 
                 // insights content is traversed by traverseEnrichedBlocks
                 block.insights.forEach((insight) => {
                     if (insight.url) {
-                        const insightLink = Link.createFromUrl({
+                        const insightLink = createLinkFromUrl({
                             url: insight.url,
                             source: this,
                             componentType: block.type,
@@ -485,7 +461,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 },
                 (explorerTiles) =>
                     explorerTiles.explorers.map(({ url }) =>
-                        Link.createFromUrl({
+                        createLinkFromUrl({
                             url,
                             source: this,
                             componentType: "explorer-tiles",
@@ -505,20 +481,20 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                     return allLinks.reduce(
                         (links, link) => [
                             ...links,
-                            Link.createFromUrl({
+                            createLinkFromUrl({
                                 source: this,
                                 url: link.value.url,
                                 componentType: researchAndWriting.type,
                                 text: link.value.title,
                             }),
                         ],
-                        [] as Link[]
+                        [] as DbInsertPostGdocLink[]
                     )
                 }
             )
             .with({ type: "video" }, (video) => {
                 return [
-                    Link.createFromUrl({
+                    createLinkFromUrl({
                         url: video.url,
                         source: this,
                         componentType: video.type,
@@ -528,7 +504,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
             })
             .with({ type: "key-indicator" }, (block) => {
                 return [
-                    Link.createFromUrl({
+                    createLinkFromUrl({
                         url: block.datapageUrl,
                         source: this,
                         componentType: block.type,
@@ -537,7 +513,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
             })
             .with({ type: "pill-row" }, (pillRow) => {
                 return pillRow.pills.map((pill) =>
-                    Link.createFromUrl({
+                    createLinkFromUrl({
                         url: pill.url,
                         source: this,
                         componentType: pillRow.type,
@@ -547,7 +523,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
             })
             .with({ type: "homepage-intro" }, (homepageIntro) => {
                 return homepageIntro.featuredWork.map((featuredWork) =>
-                    Link.createFromUrl({
+                    createLinkFromUrl({
                         url: featuredWork.url,
                         source: this,
                         componentType: homepageIntro.type,
@@ -600,7 +576,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         return links
     }
 
-    extractLinkFromSpan(span: Span): Link | void {
+    extractLinkFromSpan(span: Span): DbInsertPostGdocLink | void {
         // Don't track the ref links e.g. "#note-1"
         function checkIsRefAnchor(link: string): boolean {
             return new RegExp(/^#note-\d+$/).test(link)
@@ -608,7 +584,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         if (span.spanType === "span-link") {
             const url = span.url
             if (!checkIsRefAnchor(url)) {
-                return Link.createFromUrl({
+                return createLinkFromUrl({
                     url,
                     source: this,
                     componentType: span.spanType,
@@ -618,45 +594,39 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         }
     }
 
-    async loadLinkedCharts(): Promise<void> {
-        const { linkedGrapherCharts, publishedExplorersBySlug } =
-            await db.knexReadonlyTransaction(async (trx) => {
-                const slugToIdMap = await mapSlugsToIds(trx)
-                const linkedGrapherCharts = await Promise.all(
-                    [...this.linkedChartSlugs.grapher.values()].map(
-                        async (originalSlug) => {
-                            const chartId = slugToIdMap[originalSlug]
-                            if (!chartId) return
-                            const chart = await getChartConfigById(trx, chartId)
-                            if (!chart) return
-                            const resolvedSlug = chart.config.slug ?? ""
-                            const resolvedTitle = chart.config.title ?? ""
-                            const tab =
-                                chart.config.tab ?? GrapherTabOption.chart
-                            const datapageIndicator =
-                                await getVariableOfDatapageIfApplicable(
-                                    chart.config
-                                )
-                            const linkedChart: LinkedChart = {
-                                originalSlug,
-                                title: resolvedTitle,
-                                tab,
-                                resolvedUrl: `${BAKED_GRAPHER_URL}/${resolvedSlug}`,
-                                thumbnail: `${BAKED_GRAPHER_EXPORTS_BASE_URL}/${resolvedSlug}.svg`,
-                                tags: [],
-                                indicatorId: datapageIndicator?.id,
-                            }
-                            return linkedChart
-                        }
-                    )
-                ).then(excludeNullish)
+    async loadLinkedCharts(knex: db.KnexReadonlyTransaction): Promise<void> {
+        const slugToIdMap = await mapSlugsToIds(knex)
+        // TODO: rewrite this as a single query instead of N queries
+        const linkedGrapherCharts = await Promise.all(
+            [...this.linkedChartSlugs.grapher.values()].map(
+                async (originalSlug) => {
+                    const chartId = slugToIdMap[originalSlug]
+                    if (!chartId) return
+                    const chart = await getChartConfigById(knex, chartId)
+                    if (!chart) return
+                    const resolvedSlug = chart.config.slug ?? ""
+                    const resolvedTitle = chart.config.title ?? ""
+                    const tab = chart.config.tab ?? GrapherTabOption.chart
+                    const datapageIndicator =
+                        await getVariableOfDatapageIfApplicable(chart.config)
+                    const linkedChart: LinkedChart = {
+                        originalSlug,
+                        title: resolvedTitle,
+                        tab,
+                        resolvedUrl: `${BAKED_GRAPHER_URL}/${resolvedSlug}`,
+                        thumbnail: `${BAKED_GRAPHER_EXPORTS_BASE_URL}/${resolvedSlug}.svg`,
+                        tags: [],
+                        indicatorId: datapageIndicator?.id,
+                    }
+                    return linkedChart
+                }
+            )
+        ).then(excludeNullish)
 
-                const publishedExplorersBySlug =
-                    await db.getPublishedExplorersBySlug(trx)
-                return { linkedGrapherCharts, publishedExplorersBySlug }
-            })
+        const publishedExplorersBySlug =
+            await db.getPublishedExplorersBySlug(knex)
 
-        const linkedExplorerCharts = await Promise.all(
+        const linkedExplorerCharts = excludeNullish(
             this.linkedChartSlugs.explorer.map((originalSlug) => {
                 const explorer = publishedExplorersBySlug[originalSlug]
                 if (!explorer) return
@@ -671,7 +641,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
                 }
                 return linkedChart
             })
-        ).then(excludeNullish)
+        )
 
         this.linkedCharts = keyBy(
             [...linkedGrapherCharts, ...linkedExplorerCharts],
@@ -700,29 +670,25 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         this.linkedIndicators = keyBy(linkedIndicators, "id")
     }
 
-    async loadLinkedDocuments(): Promise<void> {
+    async loadLinkedDocuments(knex: db.KnexReadonlyTransaction): Promise<void> {
         const linkedDocuments: OwidGdocMinimalPostInterface[] =
-            await Promise.all(
-                this.linkedDocumentIds.map(async (target) => {
-                    const linkedDocument = await GdocBase.findOneBy({
-                        id: target,
-                    })
-                    return linkedDocument
-                })
-            )
-                .then(excludeNull)
-                .then((fullGdocs) => fullGdocs.map(fullGdocToMinimalGdoc))
+            await getMinimalGdocBaseObjectsByIds(knex, this.linkedDocumentIds)
 
         this.linkedDocuments = keyBy(linkedDocuments, "id")
     }
 
-    async loadImageMetadata(filenames?: string[]): Promise<void> {
+    async loadImageMetadata(
+        knex: db.KnexReadonlyTransaction,
+        filenames?: string[]
+    ): Promise<void> {
         const imagesFilenames = filenames ?? this.linkedImageFilenames
 
         if (!imagesFilenames.length) return
 
         await imageStore.fetchImageMetadata(imagesFilenames)
-        const images = await imageStore.syncImagesToS3().then(excludeUndefined)
+        const images = await imageStore
+            .syncImagesToS3(knex)
+            .then(excludeUndefined)
 
         // Merge the new image metadata with the existing image metadata. This
         // is used by GdocAuthor to load additional image metadata from the
@@ -754,7 +720,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         this.content = archieToEnriched(text, this._enrichSubclassContent)
     }
 
-    async validate(): Promise<void> {
+    async validate(knex: db.KnexReadonlyTransaction): Promise<void> {
         const filenameErrors: OwidGdocErrorMessage[] = this.filenames.reduce(
             (
                 errors: OwidGdocErrorMessage[],
@@ -848,7 +814,7 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
             )
         }
 
-        const subclassErrors = await this._validateSubclass(this)
+        const subclassErrors = await this._validateSubclass(knex, this)
         this.errors = [
             ...filenameErrors,
             ...linkErrors,
@@ -857,23 +823,63 @@ export class GdocBase extends BaseEntity implements OwidGdocBaseInterface {
         ]
     }
 
-    async loadState(): Promise<void> {
-        await this.loadLinkedDocuments()
-        await this.loadImageMetadata()
-        await this.loadLinkedCharts()
+    async loadState(knex: db.KnexReadonlyTransaction): Promise<void> {
+        await this.loadLinkedDocuments(knex)
+        await this.loadImageMetadata(knex)
+        await this.loadLinkedCharts(knex)
         await this.loadLinkedIndicators() // depends on linked charts
-        await this._loadSubclassAttachments()
-        await this.validate()
+        await this._loadSubclassAttachments(knex)
+        await this.validate(knex)
     }
+}
 
-    toJSON<T extends OwidGdocBaseInterface>(): T {
-        return omit(this, [
-            "_enrichSubclassContent",
-            "_filenameProperties",
-            "_getSubclassEnrichedBlocks",
-            "_omittableFields",
-            "_validateSubclass",
-            ...this._omittableFields,
-        ]) as any as T
-    }
+// This function would naturally live in GdocFactory but that would create a circular dependency
+export async function getMinimalGdocBaseObjectsByIds(
+    knex: KnexReadonlyTransaction,
+    ids: string[]
+): Promise<OwidGdocMinimalPostInterface[]> {
+    if (ids.length === 0) return []
+    const rows = await db.knexRaw<{
+        id: string
+        title: string
+        slug: string
+        authors: string
+        publishedAt: Date
+        published: number
+        subtitle: string
+        excerpt: string
+        type: string
+        "featured-image": string
+    }>(
+        knex,
+        `-- sql
+            SELECT
+                id,
+                content ->> '$.title' as title,
+                slug,
+                content ->> '$.authors' as authors,
+                publishedAt,
+                published,
+                content ->> '$.subtitle' as subtitle,
+                content ->> '$.excerpt' as excerpt,
+                content ->> '$.type' as type,
+                content ->> '$."featured-image"' as "featured-image"
+            FROM posts_gdocs
+            WHERE id in (:ids)`,
+        { ids }
+    )
+    return rows.map((row) => {
+        return {
+            id: row.id,
+            title: row.title,
+            slug: row.slug,
+            authors: JSON.parse(row.authors) as string[],
+            publishedAt: formatDate(row.publishedAt),
+            published: !!row.published,
+            subtitle: row.subtitle,
+            excerpt: row.excerpt,
+            type: row.type as OwidGdocType,
+            "featured-image": row["featured-image"],
+        } satisfies OwidGdocMinimalPostInterface
+    })
 }
diff --git a/db/model/Gdoc/GdocDataInsight.ts b/db/model/Gdoc/GdocDataInsight.ts
index c57049e2996..4756131b52d 100644
--- a/db/model/Gdoc/GdocDataInsight.ts
+++ b/db/model/Gdoc/GdocDataInsight.ts
@@ -1,23 +1,21 @@
-import { Entity, Column, LessThanOrEqual, Raw } from "typeorm"
 import {
     OwidGdocErrorMessage,
     OwidGdocErrorMessageType,
     OwidGdocDataInsightContent,
     OwidGdocDataInsightInterface,
     MinimalDataInsightInterface,
-    OwidGdocType,
-    DATA_INSIGHTS_INDEX_PAGE_SIZE,
     OwidGdocMinimalPostInterface,
+    OwidGdocBaseInterface,
+    excludeNullish,
 } from "@ourworldindata/utils"
 import { GdocBase } from "./GdocBase.js"
 import * as db from "../../../db/db.js"
+import { getAndLoadPublishedDataInsights } from "./GdocFactory.js"
 
-@Entity("posts_gdocs")
 export class GdocDataInsight
     extends GdocBase
     implements OwidGdocDataInsightInterface
 {
-    @Column({ default: "{}", type: "json" })
     content!: OwidGdocDataInsightContent
 
     constructor(id?: string) {
@@ -27,10 +25,19 @@ export class GdocDataInsight
         }
     }
 
+    static create(obj: OwidGdocBaseInterface): GdocDataInsight {
+        const gdoc = new GdocDataInsight()
+        Object.assign(gdoc, obj)
+        return gdoc
+    }
+
     linkedDocuments: Record<string, OwidGdocMinimalPostInterface> = {}
     latestDataInsights: MinimalDataInsightInterface[] = []
     // TODO: support query parameters in grapher urls so we can track country selections
-    _urlProperties: string[] = ["grapher-url"]
+
+    protected typeSpecificUrls(): string[] {
+        return excludeNullish([this.content["grapher-url"]])
+    }
 
     _validateSubclass = async (): Promise<OwidGdocErrorMessage[]> => {
         const errors: OwidGdocErrorMessage[] = []
@@ -44,33 +51,17 @@ export class GdocDataInsight
         return errors
     }
 
-    _loadSubclassAttachments = async (): Promise<void> => {
+    _loadSubclassAttachments = async (
+        knex: db.KnexReadonlyTransaction
+    ): Promise<void> => {
         // TODO: refactor these classes to properly use knex - not going to start it now
-        this.latestDataInsights = await db.getPublishedDataInsights(
-            db.knexInstance() as db.KnexReadonlyTransaction, // TODO: replace this with a transaction that is passed in
-            5
-        )
+        this.latestDataInsights = await db.getPublishedDataInsights(knex, 5)
     }
 
     static async getPublishedDataInsights(
+        knex: db.KnexReadonlyTransaction,
         page?: number
     ): Promise<GdocDataInsight[]> {
-        const isPaging = page !== undefined
-        return GdocDataInsight.find({
-            where: {
-                published: true,
-                publishedAt: LessThanOrEqual(new Date()),
-                content: Raw(
-                    (content) =>
-                        `${content}->"$.type" = '${OwidGdocType.DataInsight}'`
-                ),
-            },
-            order: {
-                publishedAt: "DESC",
-            },
-            take: isPaging ? DATA_INSIGHTS_INDEX_PAGE_SIZE : undefined,
-            skip: isPaging ? page * DATA_INSIGHTS_INDEX_PAGE_SIZE : undefined,
-            relations: ["tags"],
-        })
+        return getAndLoadPublishedDataInsights(knex, page)
     }
 }
diff --git a/db/model/Gdoc/GdocFactory.ts b/db/model/Gdoc/GdocFactory.ts
index 09ba18b3da9..0af29a5d6d3 100644
--- a/db/model/Gdoc/GdocFactory.ts
+++ b/db/model/Gdoc/GdocFactory.ts
@@ -1,154 +1,556 @@
-import { get } from "lodash"
+import { get, groupBy } from "lodash"
 import { match, P } from "ts-pattern"
 import {
+    DATA_INSIGHTS_INDEX_PAGE_SIZE,
+    DbEnrichedPostGdoc,
+    DbPlainTag,
+    DbRawPostGdoc,
     GdocsContentSource,
+    OwidEnrichedGdocBlock,
     OwidGdoc,
+    OwidGdocBaseInterface,
+    OwidGdocIndexItem,
+    OwidGdocMinimalPostInterface,
+    OwidGdocPublicationContext,
     OwidGdocType,
+    PostsGdocsTableName,
+    PostsGdocsXTagsTableName,
     checkIsOwidGdocType,
+    extractGdocIndexItem,
+    formatDate,
+    parsePostsGdocsRow,
+    serializePostsGdocsRow,
 } from "@ourworldindata/utils"
 
-import { GdocBase, Tag } from "./GdocBase.js"
+import { GdocBase } from "./GdocBase.js"
 import { GdocPost } from "./GdocPost.js"
 import { GdocDataInsight } from "./GdocDataInsight.js"
 import { GdocHomepage } from "./GdocHomepage.js"
+import {
+    knexRawFirst,
+    KnexReadonlyTransaction,
+    knexRaw,
+    KnexReadWriteTransaction,
+} from "../../db.js"
+import { enrichedBlocksToMarkdown } from "./enrichedToMarkdown.js"
 import { GdocAuthor } from "./GdocAuthor.js"
 
-// Handles the registration and loading of Gdocs
-// Couldn't put this in GdocBase because of circular dependency issues
-export class GdocFactory {
-    static fromJSON(
-        json: Record<string, any>
-    ): GdocPost | GdocDataInsight | GdocHomepage | GdocAuthor {
-        if (typeof json.content === "string") {
-            json.content = JSON.parse(json.content)
-        }
-        const type = json.content.type as OwidGdocType | undefined
-        const id = json.id as string
-        if (!type) {
-            throw new Error(
-                `Database record for Google Doc with id "${id}" has no type`
-            )
-        }
-
-        json.createdAt = new Date(json.createdAt)
-        json.publishedAt = json.publishedAt ? new Date(json.publishedAt) : null
-        json.updatedAt = new Date(json.updatedAt)
-
-        // `tags` ordinarily gets populated via a join table in .load(), for our purposes we don't need it here
-        // except for the fact that loadRelatedCharts() assumes the array exists
-        const tags = Tag.create(json.tags)
-        json.tags = tags
-
-        return match(type)
-            .with(
-                P.union(
-                    OwidGdocType.Article,
-                    OwidGdocType.LinearTopicPage,
-                    OwidGdocType.TopicPage,
-                    OwidGdocType.Fragment,
-                    OwidGdocType.AboutPage
-                ),
-                // TODO: better validation here?
-                () => GdocPost.create({ ...(json as any) })
-            )
-            .with(
-                OwidGdocType.DataInsight,
-                // TODO: better validation here?
-                () => GdocDataInsight.create({ ...(json as any) })
-            )
-            .with(
-                OwidGdocType.Homepage,
-                // TODO: better validation here?
-                () => GdocHomepage.create({ ...(json as any) })
-            )
-            .with(
-                OwidGdocType.Author,
-                // TODO: better validation here?
-                () => GdocAuthor.create({ ...(json as any) })
-            )
-            .exhaustive()
+export function gdocFromJSON(
+    json: Record<string, any>
+): GdocPost | GdocDataInsight | GdocHomepage | GdocAuthor {
+    if (typeof json.content === "string") {
+        json.content = JSON.parse(json.content)
+    }
+    const type = json.content.type as OwidGdocType | undefined
+    const id = json.id as string
+    if (!type) {
+        throw new Error(
+            `Database record for Google Doc with id "${id}" has no type`
+        )
     }
 
-    static async create(id: string): Promise<OwidGdoc> {
-        // Fetch the data from Google Docs and save it to the database
-        // We have to fetch it here because we need to know the type of the Gdoc in this.load()
-        const base = new GdocBase(id)
-        await base.fetchAndEnrichGdoc()
-        await base.save()
+    json.createdAt = new Date(json.createdAt)
+    json.publishedAt = json.publishedAt ? new Date(json.publishedAt) : null
+    json.updatedAt = new Date(json.updatedAt)
 
-        // Load its metadata and state so that subclass parsing & validation is also done.
-        // This involves a second call to the DB and Google, which makes me sad, but it'll do for now.
-        const gdoc = await this.load(id, GdocsContentSource.Gdocs)
+    // `tags` ordinarily gets populated via a join table in .load(), for our purposes we don't need it here
+    // except for the fact that loadRelatedCharts() assumes the array exists
+    json.tags = json.tags
 
-        await gdoc.save()
+    return match(type)
+        .with(
+            P.union(
+                OwidGdocType.Article,
+                OwidGdocType.LinearTopicPage,
+                OwidGdocType.TopicPage,
+                OwidGdocType.Fragment,
+                OwidGdocType.AboutPage
+            ),
+            // TODO: better validation here?
+            () => GdocPost.create({ ...(json as any) })
+        )
+        .with(
+            OwidGdocType.DataInsight,
+            // TODO: better validation here?
+            () => GdocDataInsight.create({ ...(json as any) })
+        )
+        .with(
+            OwidGdocType.Homepage,
+            // TODO: better validation here?
+            () => GdocHomepage.create({ ...(json as any) })
+        )
+        .with(
+            OwidGdocType.Author,
+            // TODO: better validation here?
+            () => GdocAuthor.create({ ...(json as any) })
+        )
+        .exhaustive()
+}
 
-        return gdoc
-    }
+export async function createGdocAndInsertIntoDb(
+    knex: KnexReadWriteTransaction,
+    id: string
+): Promise<OwidGdoc> {
+    // Fetch the data from Google Docs and save it to the database
+    // We have to fetch it here because we need to know the type of the Gdoc in load()
+    const base = new GdocBase(id)
+    await base.fetchAndEnrichGdoc()
+    await upsertGdoc(knex, base)
 
-    static async loadBySlug(
-        slug: string
-    ): Promise<GdocPost | GdocDataInsight | GdocHomepage | GdocAuthor> {
-        const base = await GdocBase.findOne({
-            where: { slug, published: true },
+    // Load its metadata and state so that subclass parsing & validation is also done.
+    // This involves a second call to the DB and Google, which makes me sad, but it'll do for now.
+    const gdoc = await loadGdocFromGdocBase(
+        knex,
+        base,
+        GdocsContentSource.Gdocs
+    )
+
+    // 2024-03-12 Daniel: We used to save here before the knex refactor but I think that was redundant?
+    // await gdoc.save()
+
+    return gdoc
+}
+
+export async function updateGdocContentOnly(
+    knex: KnexReadonlyTransaction,
+    id: string,
+    gdoc: OwidGdoc,
+    markdownContentSource: OwidEnrichedGdocBlock[]
+): Promise<void> {
+    let markdown: string | null = gdoc.markdown
+    try {
+        markdown = enrichedBlocksToMarkdown(markdownContentSource, true) ?? null
+    } catch (e) {
+        console.error("Error when converting content to markdown", e)
+    }
+    return knex
+        .table(PostsGdocsTableName)
+        .where({ id })
+        .andWhere("revisionId", "<>", gdoc.revisionId)
+        .update({
+            content: JSON.stringify(gdoc.content),
+            revisionId: gdoc.revisionId,
+            markdown,
         })
-        if (!base) {
-            throw new Error(
-                `No published Google Doc with slug "${slug}" found in the database`
-            )
-        }
-        return this.load(base.id)
+}
+
+export async function getGdocBaseObjectById(
+    knex: KnexReadonlyTransaction,
+    id: string,
+    fetchLinkedTags: boolean,
+    onlyPublished: boolean = false
+): Promise<OwidGdocBaseInterface | undefined> {
+    const filters: {
+        id: string
+        published?: number
+    } = {
+        id,
+    }
+    if (onlyPublished) {
+        filters["published"] = 1
     }
+    const row = await knex.table(PostsGdocsTableName).where(filters).first()
+    if (!row) return undefined
+    const enrichedRow = parsePostsGdocsRow(row)
+    const gdoc: OwidGdocBaseInterface = {
+        ...enrichedRow,
+        tags: null,
+    } satisfies OwidGdocBaseInterface
+    if (fetchLinkedTags) {
+        const tags = await knexRaw<DbPlainTag>(
+            knex,
+            `-- sql
+                SELECT tags.*
+                FROM tags
+                JOIN posts_gdocs_x_tags gt ON gt.tagId = tags.id
+                WHERE gt.gdocId = ?`,
+            [id]
+        )
+        gdoc.tags = tags
+    }
+    return gdoc
+}
 
-    // From an ID, get a Gdoc object with all its metadata and state loaded, in its correct subclass.
-    // If contentSource is Gdocs, use live data from Google, otherwise use the data in the DB.
-    static async load(
-        id: string,
-        contentSource?: GdocsContentSource
-    ): Promise<GdocPost | GdocDataInsight | GdocHomepage | GdocAuthor> {
-        const base = await GdocBase.findOne({
-            where: {
+export async function getAllMinimalGdocBaseObjects(
+    knex: KnexReadonlyTransaction
+): Promise<OwidGdocMinimalPostInterface[]> {
+    const rows = await knexRaw<{
+        id: string
+        title: string
+        slug: string
+        authors: string
+        publishedAt: Date
+        published: number
+        subtitle: string
+        excerpt: string
+        type: string
+        "featured-image": string
+    }>(
+        knex,
+        `-- sql
+            SELECT
                 id,
-            },
-            relations: ["tags"],
-        })
-        if (!base)
-            throw new Error(
-                `No Google Doc with id "${id}" found in the database`
-            )
-
-        const type = get(base, "content.type") as unknown
-        if (!type)
-            throw new Error(
-                `Database record for Google Doc with id "${id}" has no type`
-            )
-        if (!checkIsOwidGdocType(type)) {
-            throw new Error(
-                `Database record for Google Doc with id "${id}" has invalid type "${type}"`
-            )
+                content ->> '$.title' as title,
+                slug,
+                content ->> '$.authors' as authors,
+                publishedAt,
+                published,
+                content ->> '$.subtitle' as subtitle,
+                content ->> '$.excerpt' as excerpt,
+                content ->> '$.type' as type,
+                content ->> '$."featured-image"' as "featured-image"
+            FROM posts_gdocs
+            WHERE published = 1
+            AND publishedAt <= NOW()`,
+        {}
+    )
+    return rows.map((row) => {
+        return {
+            id: row.id,
+            title: row.title,
+            slug: row.slug,
+            authors: JSON.parse(row.authors) as string[],
+            publishedAt: formatDate(row.publishedAt),
+            published: !!row.published,
+            subtitle: row.subtitle,
+            excerpt: row.excerpt,
+            type: row.type as OwidGdocType,
+            "featured-image": row["featured-image"],
+        } satisfies OwidGdocMinimalPostInterface
+    })
+}
+
+export async function getGdocBaseObjectBySlug(
+    knex: KnexReadonlyTransaction,
+    slug: string,
+    fetchLinkedTags: boolean
+): Promise<OwidGdocBaseInterface | undefined> {
+    const row = await knexRawFirst<DbRawPostGdoc>(
+        knex,
+        `-- sql
+            SELECT *
+            FROM posts_gdocs
+            WHERE slug = ?
+            AND published = 1`,
+        [slug]
+    )
+    if (!row) return undefined
+    const enrichedRow = parsePostsGdocsRow(row)
+    const gdoc: OwidGdocBaseInterface = {
+        ...enrichedRow,
+        tags: null,
+    } satisfies OwidGdocBaseInterface
+    if (fetchLinkedTags) {
+        const tags = await knexRaw<DbPlainTag>(
+            knex,
+            `-- sql
+                SELECT tags.*
+                FROM tags
+                JOIN posts_gdocs_x_tags gt ON gt.tagId = tags.id
+                WHERE gt.gdocId = ?`,
+            [gdoc.id]
+        )
+        gdoc.tags = tags
+    }
+    return gdoc
+}
+
+export async function getAndLoadGdocBySlug(
+    knex: KnexReadonlyTransaction,
+    slug: string
+): Promise<GdocPost | GdocDataInsight | GdocHomepage | GdocAuthor> {
+    const base = await getGdocBaseObjectBySlug(knex, slug, true)
+    if (!base) {
+        throw new Error(
+            `No published Google Doc with slug "${slug}" found in the database`
+        )
+    }
+    return loadGdocFromGdocBase(knex, base)
+}
+
+export async function getAndLoadGdocById(
+    knex: KnexReadonlyTransaction,
+    id: string,
+    contentSource?: GdocsContentSource
+): Promise<GdocPost | GdocDataInsight | GdocHomepage | GdocAuthor> {
+    const base = await getGdocBaseObjectById(knex, id, true)
+    if (!base)
+        throw new Error(`No Google Doc with id "${id}" found in the database`)
+    return loadGdocFromGdocBase(knex, base, contentSource)
+}
+
+// From an ID, get a Gdoc object with all its metadata and state loaded, in its correct subclass.
+// If contentSource is Gdocs, use live data from Google, otherwise use the data in the DB.
+export async function loadGdocFromGdocBase(
+    knex: KnexReadonlyTransaction,
+    base: OwidGdocBaseInterface,
+    contentSource?: GdocsContentSource
+): Promise<GdocPost | GdocDataInsight | GdocHomepage | GdocAuthor> {
+    const type = get(base, "content.type") as unknown
+    if (!type)
+        throw new Error(
+            `Database record for Google Doc with id "${base.id}" has no type`
+        )
+    if (!checkIsOwidGdocType(type)) {
+        throw new Error(
+            `Database record for Google Doc with id "${base.id}" has invalid type "${type}"`
+        )
+    }
+
+    const gdoc = match(type)
+        .with(
+            P.union(
+                OwidGdocType.Article,
+                OwidGdocType.LinearTopicPage,
+                OwidGdocType.TopicPage,
+                OwidGdocType.Fragment,
+                OwidGdocType.AboutPage
+            ),
+            () => GdocPost.create(base)
+        )
+        .with(OwidGdocType.DataInsight, () => GdocDataInsight.create(base))
+        .with(OwidGdocType.Homepage, () => GdocHomepage.create(base))
+        .with(OwidGdocType.Author, () => GdocAuthor.create(base))
+        .exhaustive()
+
+    if (contentSource === GdocsContentSource.Gdocs) {
+        // TODO: if we get here via fromJSON then we have already done this - optimize that?
+        await gdoc.fetchAndEnrichGdoc()
+    }
+
+    await gdoc.loadState(knex)
+
+    return gdoc
+}
+
+export async function getAndLoadPublishedDataInsights(
+    knex: KnexReadonlyTransaction,
+    page?: number
+): Promise<GdocDataInsight[]> {
+    const limitOffsetClause =
+        page !== undefined
+            ? `LIMIT ${DATA_INSIGHTS_INDEX_PAGE_SIZE} OFFSET ${
+                  page * DATA_INSIGHTS_INDEX_PAGE_SIZE
+              }`
+            : ""
+    const rows = await knexRaw<DbRawPostGdoc>(
+        knex,
+        `-- sql
+            SELECT *
+            FROM posts_gdocs
+            WHERE published = 1
+            AND content ->> '$.type' = ?
+            AND publishedAt <= NOW()
+            ORDER BY publishedAt DESC
+            ${limitOffsetClause}`,
+        [OwidGdocType.DataInsight]
+    )
+    const ids = rows.map((row) => row.id)
+    const tags = await knexRaw<DbPlainTag>(
+        knex,
+        `-- sql
+                SELECT gt.gdocId as gdocId, tags.*
+                FROM tags
+                JOIN posts_gdocs_x_tags gt ON gt.tagId = tags.id
+                WHERE gt.gdocId in (:ids)`,
+        { ids: ids }
+    )
+    const groupedTags = groupBy(tags, "gdocId")
+    const enrichedRows = rows.map((row) => {
+        return {
+            ...parsePostsGdocsRow(row),
+            tags: groupedTags[row.id] ? groupedTags[row.id] : null,
+        } satisfies OwidGdocBaseInterface
+    })
+    const gdocs = await Promise.all(
+        enrichedRows.map(async (row) => loadGdocFromGdocBase(knex, row))
+    )
+    return gdocs as GdocDataInsight[]
+}
+
+export async function getAndLoadPublishedGdocPosts(
+    knex: KnexReadonlyTransaction
+): Promise<GdocPost[]> {
+    const rows = await knexRaw<DbRawPostGdoc>(
+        knex,
+        `-- sql
+            SELECT *
+            FROM posts_gdocs
+            WHERE published = 1
+            AND content ->> '$.type' IN (:types)
+            AND publishedAt <= NOW()
+            ORDER BY publishedAt DESC`,
+        {
+            types: [
+                OwidGdocType.Article,
+                OwidGdocType.LinearTopicPage,
+                OwidGdocType.TopicPage,
+                OwidGdocType.Fragment,
+                OwidGdocType.AboutPage,
+            ],
         }
+    )
+    const ids = rows.map((row) => row.id)
+    const tags = await knexRaw<DbPlainTag>(
+        knex,
+        `-- sql
+                SELECT gt.gdocId as gdocId, tags.*
+                FROM tags
+                JOIN posts_gdocs_x_tags gt ON gt.tagId = tags.id
+                WHERE gt.gdocId in (:ids)`,
+        { ids: ids }
+    )
+    const groupedTags = groupBy(tags, "gdocId")
+    const enrichedRows = rows.map((row) => {
+        return {
+            ...parsePostsGdocsRow(row),
+            tags: groupedTags[row.id] ? groupedTags[row.id] : null,
+        } satisfies OwidGdocBaseInterface
+    })
+    const gdocs = await Promise.all(
+        enrichedRows.map(async (row) => loadGdocFromGdocBase(knex, row))
+    )
+    return gdocs as GdocPost[]
+}
 
-        const gdoc = match(type)
-            .with(
-                P.union(
-                    OwidGdocType.Article,
-                    OwidGdocType.LinearTopicPage,
-                    OwidGdocType.TopicPage,
-                    OwidGdocType.Fragment,
-                    OwidGdocType.AboutPage
-                ),
-                () => GdocPost.create(base)
-            )
-            .with(OwidGdocType.DataInsight, () => GdocDataInsight.create(base))
-            .with(OwidGdocType.Homepage, () => GdocHomepage.create(base))
-            .with(OwidGdocType.Author, () => GdocAuthor.create(base))
-            .exhaustive()
-
-        if (contentSource === GdocsContentSource.Gdocs) {
-            await gdoc.fetchAndEnrichGdoc()
+export async function loadPublishedGdocAuthors(
+    knex: KnexReadonlyTransaction
+): Promise<GdocAuthor[]> {
+    const rows = await knexRaw<DbRawPostGdoc>(
+        knex,
+        `-- sql
+            SELECT *
+            FROM posts_gdocs
+            WHERE published = 1
+            AND content ->> '$.type' IN (:types)`,
+        {
+            types: [OwidGdocType.Author],
         }
+    )
+
+    const enrichedRows = rows.map((row) => {
+        return {
+            ...parsePostsGdocsRow(row),
+        } satisfies OwidGdocBaseInterface
+    })
+    const gdocs = await Promise.all(
+        enrichedRows.map(async (row) => loadGdocFromGdocBase(knex, row))
+    )
+    return gdocs as GdocAuthor[]
+}
+
+export async function getAndLoadListedGdocPosts(
+    knex: KnexReadonlyTransaction
+): Promise<GdocPost[]> {
+    // TODO: Check if we shouldn't also restrict the types of gdocs here
+    const rows = await knexRaw<DbRawPostGdoc>(
+        knex,
+        `-- sql
+            SELECT *
+            FROM posts_gdocs
+            WHERE published = 1
+            publicationContext: ${OwidGdocPublicationContext.listed}
+            publishedAt <= NOW()
+            ORDER BY publishedAt DESC`,
+        {}
+    )
+    const ids = rows.map((row) => row.id)
+    const tags = await knexRaw<DbPlainTag>(
+        knex,
+        `-- sql
+                SELECT gt.gdocId as gdocId, tags.*
+                FROM tags
+                JOIN posts_gdocs_x_tags gt ON gt.tagId = tags.id
+                WHERE gt.gdocId in (:ids)`,
+        { ids: ids }
+    )
+    const groupedTags = groupBy(tags, "gdocId")
+    const enrichedRows = rows.map((row) => {
+        return {
+            ...parsePostsGdocsRow(row),
+            tags: groupedTags[row.id] ? groupedTags[row.id] : null,
+        } satisfies OwidGdocBaseInterface
+    })
+    const gdocs = await Promise.all(
+        enrichedRows.map(async (row) => loadGdocFromGdocBase(knex, row))
+    )
+    return gdocs as GdocPost[]
+}
 
-        await gdoc.loadState()
+export async function setTagsForGdoc(
+    knex: KnexReadWriteTransaction,
+    gdocId: string,
+    tagIds: Pick<DbPlainTag, "id">[]
+): Promise<void> {
+    await knex.table(PostsGdocsXTagsTableName).where("gdocId", gdocId).delete()
+    await knex
+        .table(PostsGdocsXTagsTableName)
+        .insert(tagIds.map(({ id: tagId }) => ({ gdocId, tagId })))
+}
 
-        return gdoc
+export function getDbEnrichedGdocFromOwidGdoc(
+    gdoc: OwidGdoc | GdocBase
+): DbEnrichedPostGdoc {
+    const enrichedGdoc = {
+        breadcrumbs: gdoc.breadcrumbs,
+        content: gdoc.content,
+        createdAt: gdoc.createdAt,
+        id: gdoc.id,
+        markdown: gdoc.markdown,
+        publicationContext: gdoc.publicationContext,
+        published: gdoc.published,
+        publishedAt: gdoc.publishedAt,
+        revisionId: gdoc.revisionId,
+        slug: gdoc.slug,
+        updatedAt: gdoc.updatedAt,
+    } satisfies DbEnrichedPostGdoc
+    return enrichedGdoc
+}
+export async function upsertGdoc(
+    knex: KnexReadWriteTransaction,
+    gdoc: OwidGdoc | GdocBase
+): Promise<number[]> {
+    let sql = undefined
+    try {
+        const enrichedGdoc = getDbEnrichedGdocFromOwidGdoc(gdoc)
+        const rawPost = serializePostsGdocsRow(enrichedGdoc)
+        const query = knex
+            .table(PostsGdocsTableName)
+            .insert(rawPost)
+            .onConflict("id")
+            .merge()
+        sql = query.toSQL()
+        return query
+    } catch (e) {
+        console.error(`Error occured in sql: ${sql}`, e)
+        throw e
     }
 }
+
+// TODO:
+export async function getAllGdocIndexItemsOrderedByUpdatedAt(
+    knex: KnexReadonlyTransaction
+): Promise<OwidGdocIndexItem[]> {
+    // Old note from Ike for somewhat different code that might still be relevant:
+    // orderBy was leading to a sort buffer overflow (ER_OUT_OF_SORTMEMORY) with MySQL's default sort_buffer_size
+    // when the posts_gdocs table got larger than 9MB, so we sort in memory
+    const gdocs: DbRawPostGdoc[] = await knex
+        .table<DbRawPostGdoc>(PostsGdocsTableName)
+        .orderBy("updatedAt", "desc")
+    const tagsForGdocs = await knexRaw<DbPlainTag & Pick<DbRawPostGdoc, "id">>(
+        knex,
+        `-- sql
+        SELECT gt.gdocId as gdocId, tags.*
+        FROM tags
+        JOIN posts_gdocs_x_tags gt ON gt.tagId = tags.id
+        WHERE gt.gdocId in (:ids)`,
+        { ids: gdocs.map((gdoc) => gdoc.id) }
+    )
+    const groupedTags = groupBy(tagsForGdocs, "gdocId")
+    return gdocs.map((gdoc) =>
+        extractGdocIndexItem({
+            ...parsePostsGdocsRow(gdoc),
+            tags: groupedTags[gdoc.id] ? groupedTags[gdoc.id] : null,
+        })
+    )
+}
diff --git a/db/model/Gdoc/GdocFaq.ts b/db/model/Gdoc/GdocFaq.ts
index dec1800af41..1f93df50674 100644
--- a/db/model/Gdoc/GdocFaq.ts
+++ b/db/model/Gdoc/GdocFaq.ts
@@ -1,19 +1,10 @@
-import { Entity, Column } from "typeorm"
-import {
-    OwidGdocErrorMessage,
-    OwidGdocErrorMessageType,
-    OwidEnrichedGdocBlock,
-    FaqDictionary,
-    ParseError,
-} from "@ourworldindata/utils"
-import { parseFaqs } from "./rawToEnriched.js"
-import { GdocBase } from "./GdocBase.js"
+// import { FaqDictionary, ParseError } from "@ourworldindata/utils"
 
-interface InterfaceGdocFaq {
-    parsedFaqs: FaqDictionary
-    parseErrors: ParseError[]
-    faqs: unknown // unparsed
-}
+// interface InterfaceGdocFaq {
+//     parsedFaqs: FaqDictionary
+//     parseErrors: ParseError[]
+//     faqs: unknown // unparsed
+// }
 
 /**
  * This is an unused mock prototype, I think *something* like this could work,
@@ -21,48 +12,53 @@ interface InterfaceGdocFaq {
  * instead of using the same endpoint for both posts and faqs.
  * For now, we'll just use the GdocPost class.
  */
-@Entity("posts_gdocs")
-export class GdocFaq extends GdocBase {
-    static table = "posts_gdocs"
-    @Column({ default: "{}", type: "json" }) content!: InterfaceGdocFaq
+// export class GdocFaq extends GdocBase {
+//     static table = "posts_gdocs"
+//     content!: InterfaceGdocFaq
 
-    constructor(id?: string) {
-        super()
-        if (id) {
-            this.id = id
-        }
-    }
-    _omittableFields: string[] = ["content.parseErrors, content.faqs"]
+//     constructor(id?: string) {
+//         super()
+//         if (id) {
+//             this.id = id
+//         }
+//     }
 
-    _enrichSubclassContent = (content: Record<string, any>): void => {
-        if (content.faqs) {
-            const faqResults = parseFaqs(content.faqs, this.id)
-            content.parsedFaqs = faqResults.faqs
-            content.parseErrors = faqResults.parseErrors
-        }
-    }
+//     static create(obj: OwidGdocBaseInterface): GdocFaq {
+//         const gdoc = new GdocFaq()
+//         Object.assign(gdoc, obj)
+//         return gdoc
+//     }
+//     _omittableFields: string[] = ["content.parseErrors, content.faqs"]
 
-    _validateSubclass = async (): Promise<OwidGdocErrorMessage[]> => {
-        const errors: OwidGdocErrorMessage[] = []
+//     _enrichSubclassContent = (content: Record<string, any>): void => {
+//         if (content.faqs) {
+//             const faqResults = parseFaqs(content.faqs, this.id)
+//             content.parsedFaqs = faqResults.faqs
+//             content.parseErrors = faqResults.parseErrors
+//         }
+//     }
 
-        for (const parseError of this.content.parseErrors) {
-            errors.push({
-                ...parseError,
-                property: "faqs",
-                type: OwidGdocErrorMessageType.Error,
-            })
-        }
+//     _validateSubclass = async (): Promise<OwidGdocErrorMessage[]> => {
+//         const errors: OwidGdocErrorMessage[] = []
 
-        return errors
-    }
+//         for (const parseError of this.content.parseErrors) {
+//             errors.push({
+//                 ...parseError,
+//                 property: "faqs",
+//                 type: OwidGdocErrorMessageType.Error,
+//             })
+//         }
 
-    _getSubclassEnrichedBlocks = (gdoc: this): OwidEnrichedGdocBlock[] => {
-        const enrichedBlocks: OwidEnrichedGdocBlock[] = []
+//         return errors
+//     }
 
-        for (const faq of Object.values(gdoc.content.parsedFaqs)) {
-            enrichedBlocks.push(...faq.content)
-        }
+//     _getSubclassEnrichedBlocks = (gdoc: this): OwidEnrichedGdocBlock[] => {
+//         const enrichedBlocks: OwidEnrichedGdocBlock[] = []
 
-        return enrichedBlocks
-    }
-}
+//         for (const faq of Object.values(gdoc.content.parsedFaqs)) {
+//             enrichedBlocks.push(...faq.content)
+//         }
+
+//         return enrichedBlocks
+//     }
+// }
diff --git a/db/model/Gdoc/GdocHomepage.ts b/db/model/Gdoc/GdocHomepage.ts
index 7295ce72df6..caa4553a425 100644
--- a/db/model/Gdoc/GdocHomepage.ts
+++ b/db/model/Gdoc/GdocHomepage.ts
@@ -1,4 +1,3 @@
-import { Entity, Column } from "typeorm"
 import {
     OwidGdocErrorMessage,
     OwidGdocErrorMessageType,
@@ -9,15 +8,15 @@ import {
 } from "@ourworldindata/utils"
 import { GdocBase } from "./GdocBase.js"
 import * as db from "../../db.js"
-import { OwidGdocHomepageMetadata } from "@ourworldindata/types"
+import {
+    OwidGdocBaseInterface,
+    OwidGdocHomepageMetadata,
+} from "@ourworldindata/types"
 import { UNIQUE_TOPIC_COUNT } from "../../../site/SiteNavigation.js"
-
-@Entity("posts_gdocs")
 export class GdocHomepage
     extends GdocBase
     implements OwidGdocHomepageInterface
 {
-    @Column({ default: "{}", type: "json" })
     content!: OwidGdocHomepageContent
 
     constructor(id?: string) {
@@ -27,9 +26,14 @@ export class GdocHomepage
         }
     }
 
+    static create(obj: OwidGdocBaseInterface): GdocHomepage {
+        const gdoc = new GdocHomepage()
+        Object.assign(gdoc, obj)
+        return gdoc
+    }
+
     linkedDocuments: Record<string, OwidGdocMinimalPostInterface> = {}
     homepageMetadata: OwidGdocHomepageMetadata = {}
-    _urlProperties: string[] = []
 
     _validateSubclass = async (): Promise<OwidGdocErrorMessage[]> => {
         const errors: OwidGdocErrorMessage[] = []
@@ -54,10 +58,11 @@ export class GdocHomepage
         return errors
     }
 
-    _loadSubclassAttachments = async (): Promise<void> => {
-        const knex = db.knexInstance() as db.KnexReadonlyTransaction
+    _loadSubclassAttachments = async (
+        knex: db.KnexReadonlyTransaction
+    ): Promise<void> => {
         this.homepageMetadata = {
-            chartCount: await db.getTotalNumberOfCharts(knex), // TODO: replace this with a transaction that is passed in
+            chartCount: await db.getTotalNumberOfCharts(knex),
             topicCount: UNIQUE_TOPIC_COUNT,
         }
 
diff --git a/db/model/Gdoc/GdocPost.ts b/db/model/Gdoc/GdocPost.ts
index 2dcea9ce152..788a06f5b49 100644
--- a/db/model/Gdoc/GdocPost.ts
+++ b/db/model/Gdoc/GdocPost.ts
@@ -1,8 +1,6 @@
-import { Entity, Column, LessThanOrEqual } from "typeorm"
 import {
     type OwidGdocPostContent,
     OwidGdocPostInterface,
-    OwidGdocPublicationContext,
     OwidGdocErrorMessage,
     OwidGdocErrorMessageType,
     DetailDictionary,
@@ -12,6 +10,8 @@ import {
     RawBlockText,
     RelatedChart,
     OwidGdocMinimalPostInterface,
+    OwidGdocBaseInterface,
+    excludeNullish,
 } from "@ourworldindata/utils"
 import { GDOCS_DETAILS_ON_DEMAND_ID } from "../../../settings/serverSettings.js"
 import {
@@ -23,11 +23,15 @@ import { ADMIN_BASE_URL } from "../../../settings/clientSettings.js"
 import { parseDetails, parseFaqs } from "./rawToEnriched.js"
 import { htmlToEnrichedTextBlock } from "./htmlToEnriched.js"
 import { GdocBase } from "./GdocBase.js"
-import { getConnection } from "../../db.js"
+import { KnexReadonlyTransaction, knexRaw } from "../../db.js"
+import {
+    getGdocBaseObjectById,
+    getAndLoadListedGdocPosts,
+    getAndLoadPublishedGdocPosts,
+} from "./GdocFactory.js"
 
-@Entity("posts_gdocs")
 export class GdocPost extends GdocBase implements OwidGdocPostInterface {
-    @Column({ default: "{}", type: "json" }) content!: OwidGdocPostContent
+    content!: OwidGdocPostContent
 
     constructor(id?: string) {
         super(id)
@@ -35,10 +39,20 @@ export class GdocPost extends GdocBase implements OwidGdocPostInterface {
             authors: ["Our World in Data team"],
         }
     }
-
+    static create(obj: OwidGdocBaseInterface): GdocPost {
+        const gdoc = new GdocPost()
+        Object.assign(gdoc, obj)
+        return gdoc
+    }
     linkedDocuments: Record<string, OwidGdocMinimalPostInterface> = {}
     relatedCharts: RelatedChart[] = []
-    _filenameProperties = ["cover-image", "featured-image"]
+
+    protected typeSpecificFilenames(): string[] {
+        return excludeNullish([
+            this.content["cover-image"],
+            this.content["featured-image"],
+        ])
+    }
 
     _getSubclassEnrichedBlocks = (gdoc: this): OwidEnrichedGdocBlock[] => {
         const enrichedBlocks: OwidEnrichedGdocBlock[] = []
@@ -81,7 +95,9 @@ export class GdocPost extends GdocBase implements OwidGdocPostInterface {
         }
     }
 
-    _validateSubclass = async (): Promise<OwidGdocErrorMessage[]> => {
+    _validateSubclass = async (
+        knex: KnexReadonlyTransaction
+    ): Promise<OwidGdocErrorMessage[]> => {
         const errors: OwidGdocErrorMessage[] = []
 
         if (!this.tags?.length) {
@@ -124,7 +140,7 @@ export class GdocPost extends GdocBase implements OwidGdocPostInterface {
 
         // Unless this is the DoD document, validate that all referenced dods exist
         if (this.id !== GDOCS_DETAILS_ON_DEMAND_ID) {
-            const { details } = await GdocPost.getDetailsOnDemandGdoc()
+            const { details } = await GdocPost.getDetailsOnDemandGdoc(knex)
             for (const detailId of this.details) {
                 if (details && !details[detailId]) {
                     errors.push({
@@ -152,16 +168,21 @@ export class GdocPost extends GdocBase implements OwidGdocPostInterface {
         return errors
     }
 
-    _loadSubclassAttachments: () => Promise<void> = async () => {
-        await this.loadRelatedCharts()
-    }
+    _loadSubclassAttachments: (knex: KnexReadonlyTransaction) => Promise<void> =
+        (knex: KnexReadonlyTransaction): Promise<void> =>
+            this.loadRelatedCharts(knex)
 
-    async loadRelatedCharts(): Promise<void> {
+    async loadRelatedCharts(knex: KnexReadonlyTransaction): Promise<void> {
         if (!this.tags?.length || !this.hasAllChartsBlock) return
 
-        const connection = await getConnection()
-        const relatedCharts = await connection.query(
-            `
+        const relatedCharts = await knexRaw<{
+            slug: string
+            title: string
+            variantName: string
+            keyChartLevel: number
+        }>(
+            knex,
+            `-- sql
         SELECT DISTINCT
         charts.config->>"$.slug" AS slug,
         charts.config->>"$.title" AS title,
@@ -179,7 +200,9 @@ export class GdocPost extends GdocBase implements OwidGdocPostInterface {
         this.relatedCharts = relatedCharts
     }
 
-    static async getDetailsOnDemandGdoc(): Promise<{
+    static async getDetailsOnDemandGdoc(
+        knex: KnexReadonlyTransaction
+    ): Promise<{
         details: DetailDictionary
         parseErrors: ParseError[]
     }> {
@@ -189,14 +212,14 @@ export class GdocPost extends GdocBase implements OwidGdocPostInterface {
             )
             return { details: {}, parseErrors: [] }
         }
-        const gdoc = await GdocPost.findOne({
-            where: {
-                id: GDOCS_DETAILS_ON_DEMAND_ID,
-                published: true,
-            },
-        })
+        const gdoc = await getGdocBaseObjectById(
+            knex,
+            GDOCS_DETAILS_ON_DEMAND_ID,
+            false,
+            true
+        )
 
-        if (!gdoc) {
+        if (!gdoc || !("details" in gdoc.content)) {
             return {
                 details: {},
                 parseErrors: [
@@ -210,7 +233,9 @@ export class GdocPost extends GdocBase implements OwidGdocPostInterface {
         return parseDetails(gdoc.content.details)
     }
 
-    static async getPublishedGdocPosts(): Promise<GdocPost[]> {
+    static async getPublishedGdocPosts(
+        knex: KnexReadonlyTransaction
+    ): Promise<GdocPost[]> {
         // #gdocsvalidation this cast means that we trust the admin code and
         // workflow to provide published articles that have all the required content
         // fields (see #gdocsvalidationclient and pending #gdocsvalidationserver).
@@ -223,34 +248,15 @@ export class GdocPost extends GdocBase implements OwidGdocPostInterface {
         // mapGdocsToWordpressPosts(). This would make the Gdoc entity coming from
         // the database dependent on the mapping function, which is more practical
         // but also makes it less of a source of truth when considered in isolation.
-        return GdocPost.find({
-            where: {
-                published: true,
-                publishedAt: LessThanOrEqual(new Date()),
-            },
-            relations: ["tags"],
-        }).then((gdocs) =>
-            gdocs.filter(
-                ({ content: { type } }) =>
-                    type &&
-                    [
-                        OwidGdocType.Article,
-                        OwidGdocType.TopicPage,
-                        OwidGdocType.LinearTopicPage,
-                        OwidGdocType.AboutPage,
-                    ].includes(type)
-            )
-        )
+        return getAndLoadPublishedGdocPosts(knex)
     }
 
     /**
      * Excludes published listed Gdocs with a publication date in the future
      */
-    static async getListedGdocPosts(): Promise<GdocPost[]> {
-        return GdocPost.findBy({
-            published: true,
-            publicationContext: OwidGdocPublicationContext.listed,
-            publishedAt: LessThanOrEqual(new Date()),
-        })
+    static async getListedGdocPosts(
+        knex: KnexReadonlyTransaction
+    ): Promise<GdocPost[]> {
+        return getAndLoadListedGdocPosts(knex)
     }
 }
diff --git a/db/model/Gdoc/gdocUtils.ts b/db/model/Gdoc/gdocUtils.ts
index 8b641eb0559..f35bf2b2c07 100644
--- a/db/model/Gdoc/gdocUtils.ts
+++ b/db/model/Gdoc/gdocUtils.ts
@@ -3,10 +3,6 @@ import {
     Span,
     excludeNullish,
     EnrichedBlockResearchAndWritingLink,
-    OwidGdocMinimalPostInterface,
-    OwidGdocType,
-    formatDate,
-    OwidGdocBaseInterface,
     DATA_INSIGHTS_INDEX_PAGE_SIZE,
 } from "@ourworldindata/utils"
 import { match, P } from "ts-pattern"
@@ -157,23 +153,6 @@ export function parseAuthors(authors?: string): string[] {
         .map((author: string) => author.trim())
 }
 
-export function fullGdocToMinimalGdoc(
-    gdoc: OwidGdocBaseInterface
-): OwidGdocMinimalPostInterface {
-    return {
-        id: gdoc.id,
-        title: gdoc.content.title || "",
-        slug: gdoc.slug,
-        authors: gdoc.content.authors,
-        publishedAt: gdoc.publishedAt ? formatDate(gdoc.publishedAt) : "",
-        published: gdoc.published,
-        subtitle: gdoc.content.subtitle || "",
-        excerpt: gdoc.content.excerpt || "",
-        type: gdoc.content.type || OwidGdocType.Article,
-        "featured-image": gdoc.content["featured-image"],
-    }
-}
-
 /**
  * Calculate the number of pages needed to display all data insights
  * e.g. if there are 61 data insights and we want to display 20 per page, we need 4 pages
diff --git a/db/model/GdocXImage.ts b/db/model/GdocXImage.ts
index d8cd2b961ad..8a1a28c46e4 100644
--- a/db/model/GdocXImage.ts
+++ b/db/model/GdocXImage.ts
@@ -1,8 +1,8 @@
-import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm"
+// import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm"
 
-@Entity("posts_gdocs_x_images")
-export class GdocXImage extends BaseEntity {
-    @PrimaryGeneratedColumn() id!: number
-    @Column() gdocId!: string
-    @Column() imageId!: number
-}
+// @Entity("posts_gdocs_x_images")
+// export class GdocXImage extends BaseEntity {
+//     @PrimaryGeneratedColumn() id!: number
+//     @Column() gdocId!: string
+//     @Column() imageId!: number
+// }
diff --git a/db/model/GdocXTag.ts b/db/model/GdocXTag.ts
index c9682eaeb4d..d1c09dac128 100644
--- a/db/model/GdocXTag.ts
+++ b/db/model/GdocXTag.ts
@@ -1,8 +1,8 @@
-import { Entity, BaseEntity, PrimaryColumn } from "typeorm"
+// import { Entity, BaseEntity, PrimaryColumn } from "typeorm"
 
-@Entity("posts_gdocs_x_tags")
-export class GdocXTag extends BaseEntity {
-    static table = "posts_gdocs_x_tags"
-    @PrimaryColumn() gdocId!: string
-    @PrimaryColumn() tagId!: number
-}
+// @Entity("posts_gdocs_x_tags")
+// export class GdocXTag extends BaseEntity {
+//     static table = "posts_gdocs_x_tags"
+//     @PrimaryColumn() gdocId!: string
+//     @PrimaryColumn() tagId!: number
+// }
diff --git a/db/model/Image.ts b/db/model/Image.ts
index 0049a27894a..325fc935694 100644
--- a/db/model/Image.ts
+++ b/db/model/Image.ts
@@ -1,10 +1,3 @@
-import {
-    Entity,
-    Column,
-    BaseEntity,
-    PrimaryGeneratedColumn,
-    ValueTransformer,
-} from "typeorm"
 import { drive_v3, google } from "googleapis"
 import {
     PutObjectCommand,
@@ -19,6 +12,11 @@ import {
     ImageMetadata,
     findDuplicates,
     getFilenameMIMEType,
+    DbRawImage,
+    DbEnrichedImage,
+    parseImageRow,
+    DbInsertImage,
+    serializeImageRow,
 } from "@ourworldindata/utils"
 import { OwidGoogleAuth } from "../OwidGoogleAuth.js"
 import {
@@ -29,6 +27,7 @@ import {
     GDOCS_CLIENT_EMAIL,
     GDOCS_SHARED_DRIVE_ID,
 } from "../../settings/serverSettings.js"
+import { KnexReadonlyTransaction } from "../db.js"
 
 class ImageStore {
     images: Record<string, ImageMetadata> | undefined
@@ -112,12 +111,14 @@ class ImageStore {
         this.images = keyBy(images, "filename")
     }
 
-    async syncImagesToS3(): Promise<(Image | undefined)[]> {
+    async syncImagesToS3(
+        knex: KnexReadonlyTransaction
+    ): Promise<(Image | undefined)[]> {
         const images = this.images
         if (!images) return []
         return Promise.all(
             Object.keys(images).map((filename) =>
-                Image.syncImage(images[filename])
+                Image.syncImage(knex, images[filename])
             )
         )
     }
@@ -134,38 +135,14 @@ const s3Client = new S3Client({
         secretAccessKey: IMAGE_HOSTING_SPACE_SECRET_ACCESS_KEY,
     },
 })
-
-// https://github.com/typeorm/typeorm/issues/873#issuecomment-424643086
-// otherwise epochs are retrieved as string instead of number
-export class ColumnNumericTransformer implements ValueTransformer {
-    to(data: number): number {
-        return data
-    }
-    from(data: string): number {
-        return parseFloat(data)
-    }
-}
-
-@Entity("images")
-export class Image extends BaseEntity implements ImageMetadata {
-    @PrimaryGeneratedColumn() id!: number
-    @Column() googleId!: string
-    @Column() filename!: string
-    @Column() defaultAlt!: string
-    @Column({
-        transformer: new ColumnNumericTransformer(),
-    })
-    updatedAt!: number
-    @Column({
-        transformer: new ColumnNumericTransformer(),
-        nullable: true,
-    })
-    originalWidth?: number
-    @Column({
-        transformer: new ColumnNumericTransformer(),
-        nullable: true,
-    })
-    originalHeight?: number
+export class Image implements ImageMetadata {
+    id!: number
+    googleId!: string
+    filename!: string
+    defaultAlt!: string
+    updatedAt!: number | null
+    originalWidth!: number | null
+    originalHeight!: number | null
 
     get isSvg(): boolean {
         return this.fileExtension === "svg"
@@ -184,15 +161,20 @@ export class Image extends BaseEntity implements ImageMetadata {
         return this.filename.slice(this.filename.indexOf(".") + 1)
     }
 
+    constructor(metadata: ImageMetadata) {
+        Object.assign(this, metadata)
+    }
+
     // Given a record from Drive, see if we're already aware of it
     // If we are, see if Drive's version is different from the one we have stored
     // If it is, upload it and update our record
     // If we're not aware of it, upload and record it
     static async syncImage(
+        knex: KnexReadonlyTransaction,
         metadata: ImageMetadata
     ): Promise<Image | undefined> {
-        const fresh = Image.create<Image>(metadata)
-        const stored = await Image.findOneBy({ filename: metadata.filename })
+        const fresh = new Image(metadata)
+        const stored = await getImageByFilename(knex, metadata.filename)
 
         try {
             if (stored) {
@@ -205,13 +187,19 @@ export class Image extends BaseEntity implements ImageMetadata {
                     stored.updatedAt = fresh.updatedAt
                     stored.defaultAlt = fresh.defaultAlt
                     stored.originalWidth = fresh.originalWidth
-                    stored.originalHeight = fresh.originalHeight
-                    await stored.save()
+                    await updateImage(knex, stored.id, {
+                        updatedAt: fresh.updatedAt,
+                        defaultAlt: fresh.defaultAlt,
+                        originalWidth: fresh.originalWidth,
+                        originalHeight: fresh.originalHeight,
+                    })
                 }
                 return stored
             } else {
                 await fresh.fetchFromDriveAndUploadToS3()
-                return fresh.save()
+                const id = await insertImageClass(knex, fresh)
+                fresh.id = id
+                return fresh
             }
         } catch (e) {
             console.error(`Error syncing ${fresh.filename}`, e)
@@ -262,3 +250,46 @@ export class Image extends BaseEntity implements ImageMetadata {
         )
     }
 }
+
+export async function getImageByFilename(
+    knex: KnexReadonlyTransaction,
+    filename: string
+): Promise<Image | undefined> {
+    const image = await knex
+        .table("images")
+        .where({ filename })
+        .first<DbRawImage | undefined>()
+    if (!image) return undefined
+    const enrichedImage = parseImageRow(image)
+    return new Image(enrichedImage)
+}
+
+export async function getAllImages(
+    knex: KnexReadonlyTransaction
+): Promise<Image[]> {
+    const images = await knex.table("images").select<DbRawImage[]>()
+    return images.map(parseImageRow).map((row) => new Image(row))
+}
+
+export async function updateImage(
+    knex: KnexReadonlyTransaction,
+    id: number,
+    updates: Partial<DbEnrichedImage>
+): Promise<void> {
+    await knex.table("images").where({ id }).update(updates)
+}
+
+export async function insertImageClass(
+    knex: KnexReadonlyTransaction,
+    image: Image
+): Promise<number> {
+    return insertImageObject(knex, serializeImageRow({ ...image }))
+}
+
+export async function insertImageObject(
+    knex: KnexReadonlyTransaction,
+    image: DbInsertImage
+): Promise<number> {
+    const [id] = await knex.table("images").insert(image)
+    return id
+}
diff --git a/db/model/Link.ts b/db/model/Link.ts
index da5085a20d9..e91407ce1ac 100644
--- a/db/model/Link.ts
+++ b/db/model/Link.ts
@@ -1,64 +1,57 @@
-import {
-    Entity,
-    PrimaryGeneratedColumn,
-    Column,
-    BaseEntity,
-    ManyToOne,
-    type Relation,
-    In,
-} from "typeorm"
 import { getLinkType, getUrlTarget } from "@ourworldindata/components"
-import { OwidGdocLinkJSON, Url } from "@ourworldindata/utils"
+import { Url } from "@ourworldindata/utils"
 import { GdocBase } from "./Gdoc/GdocBase.js"
 import { formatUrls } from "../../site/formatting.js"
-import { OwidGdocLinkType } from "@ourworldindata/types"
-
-@Entity("posts_gdocs_links")
-export class Link extends BaseEntity implements OwidGdocLinkJSON {
-    @PrimaryGeneratedColumn() id!: number
-    @ManyToOne(() => GdocBase, (gdoc) => gdoc.id) source!: Relation<GdocBase>
-    @Column() linkType!: OwidGdocLinkType
-    @Column() target!: string
-    @Column() queryString!: string
-    @Column() hash!: string
-    @Column() componentType!: string
-    @Column() text!: string
+import {
+    DbInsertPostGdocLink,
+    DbPlainPostGdocLink,
+    OwidGdocLinkType,
+} from "@ourworldindata/types"
+import { KnexReadonlyTransaction, knexRaw } from "../db.js"
 
-    static async getPublishedLinksTo(
-        ids: string[],
-        linkType?: Link["linkType"]
-    ): Promise<Link[]> {
-        return Link.find({
-            where: { target: In(ids), linkType },
-            relations: ["source"],
-        }).then((links) => links.filter((link) => link.source.published))
-    }
+export async function getPublishedLinksTo(
+    knex: KnexReadonlyTransaction,
+    ids: string[],
+    linkType?: OwidGdocLinkType
+): Promise<(DbPlainPostGdocLink & { sourceSlug: string })[]> {
+    const rows = await knexRaw<DbPlainPostGdocLink & { sourceSlug: string }>(
+        knex,
+        `-- sql
+        select posts_gdocs_links.*, posts_gdocs.slug as sourceSlug
+        from posts_gdocs_links
+        join posts_gdocs on posts_gdocs_links.source = posts_gdocs.id
+        where target in (?) and linkType = ?
+        and published = true
+    `,
+        [ids, linkType]
+    )
+    return rows
+}
 
-    static createFromUrl({
-        url,
-        source,
-        text = "",
-        componentType = "",
-    }: {
-        url: string
-        source: GdocBase
-        text?: string
-        componentType?: string
-    }): Link {
-        const formattedUrl = formatUrls(url)
-        const urlObject = Url.fromURL(formattedUrl)
-        const linkType = getLinkType(formattedUrl)
-        const target = getUrlTarget(formattedUrl)
-        const queryString = urlObject.queryStr
-        const hash = urlObject.hash
-        return Link.create({
-            target,
-            linkType,
-            queryString,
-            hash,
-            source,
-            text,
-            componentType,
-        })
-    }
+export function createLinkFromUrl({
+    url,
+    source,
+    text = "",
+    componentType = "",
+}: {
+    url: string
+    source: GdocBase
+    text?: string
+    componentType?: string
+}): DbInsertPostGdocLink {
+    const formattedUrl = formatUrls(url)
+    const urlObject = Url.fromURL(formattedUrl)
+    const linkType = getLinkType(formattedUrl)
+    const target = getUrlTarget(formattedUrl)
+    const queryString = urlObject.queryStr
+    const hash = urlObject.hash
+    return {
+        target,
+        linkType,
+        queryString,
+        hash,
+        text,
+        componentType,
+        sourceId: source.id,
+    } satisfies DbInsertPostGdocLink
 }
diff --git a/db/model/Post.ts b/db/model/Post.ts
index cbb317f8d6b..bd21c3ff60e 100644
--- a/db/model/Post.ts
+++ b/db/model/Post.ts
@@ -17,12 +17,12 @@ import {
     snapshotIsPostRestApi,
     snapshotIsBlockGraphQlApi,
     PostReference,
-    Tag,
     DataPageRelatedResearch,
     OwidGdocType,
     DbRawLatestWork,
     DbEnrichedLatestWork,
     parseLatestWork,
+    DbPlainTag,
 } from "@ourworldindata/types"
 import { uniqBy, sortBy, memoize, orderBy } from "@ourworldindata/utils"
 import { Knex } from "knex"
@@ -265,7 +265,7 @@ const selectHomepagePosts: FilterFnPostRestApi = (post) =>
 export const getBlogIndex = memoize(
     async (knex: db.KnexReadonlyTransaction): Promise<IndexPost[]> => {
         await db.getConnection() // side effect: ensure connection is established
-        const gdocPosts = await GdocPost.getListedGdocPosts()
+        const gdocPosts = await GdocPost.getListedGdocPosts(knex)
         const wpPosts = await Promise.all(
             await getPostsFromSnapshots(
                 knex,
@@ -437,7 +437,7 @@ export const getRelatedArticles = async (
 export const getPostTags = async (
     trx: db.KnexReadonlyTransaction,
     postId: number
-): Promise<Pick<Tag, "id" | "name">[]> => {
+): Promise<Pick<DbPlainTag, "id" | "name">[]> => {
     return await trx
         .table("post_tags")
         .select("tags.id", "tags.name")
diff --git a/db/model/User.ts b/db/model/User.ts
index 8901c31d2f0..ede8a7cca07 100644
--- a/db/model/User.ts
+++ b/db/model/User.ts
@@ -1,14 +1,3 @@
-import {
-    Entity,
-    PrimaryGeneratedColumn,
-    Column,
-    BaseEntity,
-    OneToMany,
-    type Relation,
-} from "typeorm"
-import { Chart } from "./Chart.js"
-import { Dataset } from "./Dataset.js"
-import { ChartRevision } from "./ChartRevision.js"
 import { BCryptHasher } from "../hashers.js"
 import {
     DbPlainUser,
@@ -16,33 +5,6 @@ import {
     UsersTableName,
 } from "@ourworldindata/types"
 import { KnexReadWriteTransaction, KnexReadonlyTransaction } from "../db.js"
-
-@Entity("users")
-export class User extends BaseEntity {
-    @PrimaryGeneratedColumn() id!: number
-    @Column({ unique: true }) email!: string
-    @Column({ length: 128 }) password!: string
-    @Column({ default: "" }) fullName!: string
-    @Column({ default: true }) isActive!: boolean
-    @Column({ default: false }) isSuperuser!: boolean
-    @Column() createdAt!: Date
-    @Column() updatedAt!: Date
-    @Column() lastLogin!: Date
-    @Column() lastSeen!: Date
-
-    @OneToMany(() => Chart, (chart) => chart.lastEditedByUser)
-    lastEditedCharts!: Relation<Chart[]>
-
-    @OneToMany(() => Chart, (chart) => chart.publishedByUser)
-    publishedCharts!: Relation<Chart[]>
-
-    @OneToMany(() => ChartRevision, (rev) => rev.user)
-    editedCharts!: Relation<ChartRevision[]>
-
-    @OneToMany(() => Dataset, (dataset) => dataset.createdByUser)
-    createdDatasets!: Relation<Dataset[]>
-}
-
 export async function setPassword(
     knex: KnexReadWriteTransaction,
     id: number,
@@ -60,6 +22,13 @@ export async function getUserById(
     return knex<DbPlainUser>(UsersTableName).where({ id }).first()
 }
 
+export async function getUserByEmail(
+    knex: KnexReadonlyTransaction,
+    email: string
+): Promise<DbPlainUser | undefined> {
+    return knex<DbPlainUser>(UsersTableName).where({ email }).first()
+}
+
 export async function insertUser(
     knex: KnexReadWriteTransaction,
     user: DbInsertUser
diff --git a/db/tests/basic.test.ts b/db/tests/basic.test.ts
index 29b208569df..e89bb96f676 100644
--- a/db/tests/basic.test.ts
+++ b/db/tests/basic.test.ts
@@ -13,7 +13,7 @@ import {
     knexReadonlyTransaction,
 } from "../db.js"
 import { DataSource } from "typeorm"
-import { deleteUser, insertUser, updateUser, User } from "../model/User.js"
+import { deleteUser, insertUser, updateUser } from "../model/User.js"
 import {
     ChartsTableName,
     DbInsertChart,
@@ -58,11 +58,13 @@ afterAll((done: any) => {
 })
 
 test("it can query a user created in fixture via TypeORM", async () => {
-    if (!typeOrmConnection)
-        throw new Error("TypeOrm connection not initialized")
-    const user = await User.findOne({ where: { email: "admin@example.com" } })
-    expect(user!.id).toBe(1)
-    expect(user!.email).toBe("admin@example.com")
+    expect(knexInstance).toBeDefined()
+    const user = await knexInstance!
+        .table(UsersTableName)
+        .where({ email: "admin@example.com" })
+        .first<DbPlainUser>()
+    expect(user.id).toBe(1)
+    expect(user.email).toBe("admin@example.com")
 })
 
 function sleep(time: number, value: any): Promise<any> {
@@ -155,7 +157,6 @@ test("knex interface", async () => {
         expect(afterUpdate.length).toBe(2)
         expect(afterUpdate[1].isSuperuser).toBe(1)
 
-        // Use raw queries, using ?? to specify the table name using the shared const value
         // The pick type is used to type the result row
         const usersFromRawQuery: Pick<DbPlainUser, "email">[] = await knexRaw(
             trx,
@@ -163,6 +164,17 @@ test("knex interface", async () => {
             []
         )
         expect(usersFromRawQuery.length).toBe(2)
+
+        // Check if in queries work as expected
+        const usersFromRawQueryWithInClause: Pick<DbPlainUser, "email">[] =
+            await knexRaw(trx, "select * from users where email in (:emails)", {
+                emails: [
+                    usersFromRawQuery[0].email,
+                    usersFromRawQuery[1].email,
+                ],
+            })
+        expect(usersFromRawQueryWithInClause.length).toBe(2)
+
         await deleteUser(trx, 2)
     }, knexInstance)
 })
diff --git a/devTools/markdownTest/markdown.ts b/devTools/markdownTest/markdown.ts
index 28139c9cd61..ba3658f8f13 100644
--- a/devTools/markdownTest/markdown.ts
+++ b/devTools/markdownTest/markdown.ts
@@ -13,11 +13,12 @@ import fs from "fs-extra"
 import parseArgs from "minimist"
 import { OwidEnrichedGdocBlock } from "@ourworldindata/utils"
 import { parsePostArchieml } from "@ourworldindata/utils"
+import { getAndLoadGdocBySlug } from "../../db/model/Gdoc/GdocFactory.js"
 
 async function main(parsedArgs: parseArgs.ParsedArgs) {
     try {
         await knexReadonlyTransaction(async (trx) => {
-            const gdoc = await GdocBase.findOneBy({ slug: parsedArgs._[0] })
+            const gdoc = await getAndLoadGdocBySlug(trx, parsedArgs._[0])
             let archieMlContent: OwidEnrichedGdocBlock[] | null
             let contentToShowOnError: any
             if (!gdoc) {
diff --git a/packages/@ourworldindata/types/src/dbTypes/Images.ts b/packages/@ourworldindata/types/src/dbTypes/Images.ts
index 8f0c8b26038..1efddb86d2a 100644
--- a/packages/@ourworldindata/types/src/dbTypes/Images.ts
+++ b/packages/@ourworldindata/types/src/dbTypes/Images.ts
@@ -5,6 +5,31 @@ export interface DbInsertImage {
     googleId: string
     id?: number
     originalWidth?: number | null
-    updatedAt?: string | null
+    originalHeight?: number | null
+    updatedAt?: string | null // MySQL Date objects round to the nearest second, whereas Google includes milliseconds so we store as an epoch of type bigint to avoid any conversion issues
+}
+export type DbRawImage = Required<DbInsertImage>
+export type DbEnrichedImage = Omit<DbRawImage, "updatedAt"> & {
+    updatedAt: number | null
+}
+
+export function parseImageRow(row: DbRawImage): DbEnrichedImage {
+    return { ...row, updatedAt: parseImageUpdatedAt(row.updatedAt) }
+}
+
+export function parseImageUpdatedAt(updatedAt: string | null): number | null {
+    return updatedAt ? parseFloat(updatedAt) : null
+}
+
+export function serializeImageRow(row: DbEnrichedImage): DbRawImage {
+    return {
+        ...row,
+        updatedAt: serializeImageUpdatedAt(row.updatedAt),
+    }
+}
+
+export function serializeImageUpdatedAt(
+    updatedAt: number | null
+): string | null {
+    return updatedAt ? updatedAt.toString() : null
 }
-export type DbPlainImage = Required<DbInsertImage>
diff --git a/packages/@ourworldindata/types/src/dbTypes/PostsGdocs.ts b/packages/@ourworldindata/types/src/dbTypes/PostsGdocs.ts
index 47e2601fe7a..a37a1ec9def 100644
--- a/packages/@ourworldindata/types/src/dbTypes/PostsGdocs.ts
+++ b/packages/@ourworldindata/types/src/dbTypes/PostsGdocs.ts
@@ -22,10 +22,11 @@ export interface DbInsertPostGdoc {
 export type DbRawPostGdoc = Required<DbInsertPostGdoc>
 export type DbEnrichedPostGdoc = Omit<
     DbRawPostGdoc,
-    "content" | "breadcrumbs"
+    "content" | "breadcrumbs" | "published"
 > & {
     content: OwidGdocContent
     breadcrumbs: BreadcrumbItem[] | null
+    published: boolean
 }
 
 export function parsePostGdocContent(content: JsonString): OwidGdocContent {
@@ -53,6 +54,7 @@ export function parsePostsGdocsRow(row: DbRawPostGdoc): DbEnrichedPostGdoc {
         ...row,
         content: parsePostGdocContent(row.content),
         breadcrumbs: parsePostsGdocsBreadcrumbs(row.breadcrumbs),
+        published: !!row.published,
     }
 }
 
@@ -61,5 +63,6 @@ export function serializePostsGdocsRow(row: DbEnrichedPostGdoc): DbRawPostGdoc {
         ...row,
         content: serializePostGdocContent(row.content),
         breadcrumbs: serializePostsGdocsBreadcrumbs(row.breadcrumbs),
+        published: row.published ? 1 : 0,
     }
 }
diff --git a/packages/@ourworldindata/types/src/domainTypes/Tag.ts b/packages/@ourworldindata/types/src/domainTypes/Tag.ts
deleted file mode 100644
index d7f8776c28d..00000000000
--- a/packages/@ourworldindata/types/src/domainTypes/Tag.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-export interface Tag {
-    id: number
-    name: string
-    createdAt: Date
-    updatedAt: Date
-    parentId: number
-    isBulkImport: boolean
-    specialType: string
-    slug: string | null
-}
diff --git a/packages/@ourworldindata/types/src/gdocTypes/Gdoc.ts b/packages/@ourworldindata/types/src/gdocTypes/Gdoc.ts
index 413c2bc0d3d..91a58a721ea 100644
--- a/packages/@ourworldindata/types/src/gdocTypes/Gdoc.ts
+++ b/packages/@ourworldindata/types/src/gdocTypes/Gdoc.ts
@@ -1,4 +1,3 @@
-import { Tag } from "../domainTypes/Tag.js"
 import { GrapherTabOption, RelatedChart } from "../grapherTypes/GrapherTypes.js"
 import { BreadcrumbItem } from "../domainTypes/Site.js"
 import { TocHeadingWithTitleSupertitle } from "../domainTypes/Toc.js"
@@ -13,6 +12,7 @@ import {
     RefDictionary,
 } from "./ArchieMlComponents.js"
 import { DbChartTagJoin } from "../dbTypes/ChartTags.js"
+import { DbPlainTag } from "../dbTypes/Tags.js"
 import { DbEnrichedLatestWork } from "../domainTypes/Author.js"
 
 export enum OwidGdocPublicationContext {
@@ -58,21 +58,23 @@ export enum OwidGdocType {
 export interface OwidGdocBaseInterface {
     id: string
     slug: string
-    content: Record<string, any>
+    // TODO: should we type this as a union of the possible content types instead?
+    content: OwidGdocContent
     published: boolean
     createdAt: Date
     publishedAt: Date | null
     updatedAt: Date | null
     revisionId: string | null
     publicationContext: OwidGdocPublicationContext
-    breadcrumbs?: BreadcrumbItem[] | null
+    breadcrumbs: BreadcrumbItem[] | null
     linkedDocuments?: Record<string, OwidGdocMinimalPostInterface>
     linkedCharts?: Record<string, LinkedChart>
     linkedIndicators?: Record<number, LinkedIndicator>
     imageMetadata?: Record<string, ImageMetadata>
     relatedCharts?: RelatedChart[]
-    tags?: Tag[]
+    tags?: DbPlainTag[] | null
     errors?: OwidGdocErrorMessage[]
+    markdown: string | null
 }
 
 export interface OwidGdocPostInterface extends OwidGdocBaseInterface {
@@ -93,6 +95,27 @@ export interface OwidGdocMinimalPostInterface {
     "featured-image"?: string // used in prominent links and research & writing block
 }
 
+export type OwidGdocIndexItem = Pick<
+    OwidGdocBaseInterface,
+    "id" | "slug" | "tags" | "published" | "publishedAt"
+> &
+    Pick<OwidGdocContent, "title" | "authors" | "type">
+
+export function extractGdocIndexItem(
+    gdoc: OwidGdocBaseInterface
+): OwidGdocIndexItem {
+    return {
+        id: gdoc.id,
+        slug: gdoc.slug,
+        tags: gdoc.tags ?? [],
+        published: gdoc.published,
+        publishedAt: gdoc.publishedAt,
+        title: gdoc.content.title ?? "",
+        authors: gdoc.content.authors,
+        type: gdoc.content.type,
+    }
+}
+
 export interface OwidGdocDataInsightContent {
     title: string
     authors: string[]
@@ -107,7 +130,6 @@ export const DATA_INSIGHTS_INDEX_PAGE_SIZE = 20
 export interface OwidGdocDataInsightInterface extends OwidGdocBaseInterface {
     content: OwidGdocDataInsightContent
     latestDataInsights?: MinimalDataInsightInterface[]
-    tags?: Tag[]
 }
 
 export type MinimalDataInsightInterface = Pick<
@@ -138,7 +160,6 @@ export interface OwidGdocHomepageInterface extends OwidGdocBaseInterface {
     content: OwidGdocHomepageContent
     linkedDocuments?: Record<string, OwidGdocMinimalPostInterface>
     homepageMetadata?: OwidGdocHomepageMetadata
-    tags?: Tag[] // won't be used, but necessary in various validation steps
 }
 
 export interface OwidGdocAuthorContent {
@@ -210,7 +231,7 @@ export enum OwidGdocLinkType {
 }
 
 export interface OwidGdocLinkJSON {
-    source: Record<string, any>
+    // source: Record<string, any>
     linkType: OwidGdocLinkType
     target: string
     componentType: string
diff --git a/packages/@ourworldindata/types/src/gdocTypes/Image.ts b/packages/@ourworldindata/types/src/gdocTypes/Image.ts
index e39117f0028..4c56fc9e9fd 100644
--- a/packages/@ourworldindata/types/src/gdocTypes/Image.ts
+++ b/packages/@ourworldindata/types/src/gdocTypes/Image.ts
@@ -16,7 +16,7 @@ export interface ImageMetadata {
     defaultAlt: string
     // MySQL Date objects round to the nearest second, whereas Google includes milliseconds
     // so we store as an epoch to avoid any conversion issues
-    updatedAt: number
-    originalWidth?: number
-    originalHeight?: number
+    updatedAt: number | null
+    originalWidth?: number | null
+    originalHeight?: number | null
 }
diff --git a/packages/@ourworldindata/types/src/index.ts b/packages/@ourworldindata/types/src/index.ts
index f4800c3255a..543dae7d134 100644
--- a/packages/@ourworldindata/types/src/index.ts
+++ b/packages/@ourworldindata/types/src/index.ts
@@ -49,7 +49,6 @@ export {
     DeployStatus,
     type DeployMetadata,
 } from "./domainTypes/DeployStatus.js"
-export { type Tag } from "./domainTypes/Tag.js"
 
 export {
     IDEAL_PLOT_ASPECT_RATIO,
@@ -303,6 +302,9 @@ export {
     OwidGdocLinkType,
     type LinkedIndicator,
     DYNAMIC_COLLECTION_PAGE_CONTAINER_ID,
+    type OwidGdocContent,
+    type OwidGdocIndexItem,
+    extractGdocIndexItem,
 } from "./gdocTypes/Gdoc.js"
 
 export {
@@ -488,8 +490,13 @@ export {
     ExplorerVariablesTableName,
 } from "./dbTypes/ExplorerVariables.js"
 export {
-    type DbPlainImage,
+    type DbRawImage,
+    type DbEnrichedImage,
     type DbInsertImage,
+    parseImageRow,
+    parseImageUpdatedAt,
+    serializeImageRow,
+    serializeImageUpdatedAt,
     ImagesTableName,
 } from "./dbTypes/Images.js"
 export {
diff --git a/site/gdocs/components/Image.tsx b/site/gdocs/components/Image.tsx
index 528ed0b4b35..e32bca6dfdc 100644
--- a/site/gdocs/components/Image.tsx
+++ b/site/gdocs/components/Image.tsx
@@ -122,8 +122,8 @@ export default function Image(props: {
                     src={makePreviewUrl(image.filename)}
                     alt={alt}
                     className={maybeLightboxClassName}
-                    width={image.originalWidth}
-                    height={image.originalHeight}
+                    width={image.originalWidth ?? undefined}
+                    height={image.originalHeight ?? undefined}
                 />
             </picture>
         )
@@ -138,8 +138,8 @@ export default function Image(props: {
                     src={imgSrc}
                     alt={alt}
                     className={maybeLightboxClassName}
-                    width={image.originalWidth}
-                    height={image.originalHeight}
+                    width={image.originalWidth ?? undefined}
+                    height={image.originalHeight ?? undefined}
                 />
                 {containerType !== "thumbnail" ? (
                     <a
@@ -176,8 +176,8 @@ export default function Image(props: {
                 loading="lazy"
                 // There's no way of knowing in advance whether we'll be showing the image or smallImage - we just have to choose one
                 // I went with image, as we currently only use smallImage for data insights
-                width={image.originalWidth}
-                height={image.originalHeight}
+                width={image.originalWidth ?? undefined}
+                height={image.originalHeight ?? undefined}
             />
         </picture>
     )
diff --git a/site/gdocs/pages/DataInsight.tsx b/site/gdocs/pages/DataInsight.tsx
index 4e79c5cb654..866fe87b2e6 100644
--- a/site/gdocs/pages/DataInsight.tsx
+++ b/site/gdocs/pages/DataInsight.tsx
@@ -11,8 +11,8 @@ import {
     formatAuthors,
     MinimalDataInsightInterface,
     formatDate,
-    Tag,
     copyToClipboard,
+    DbPlainTag,
 } from "@ourworldindata/utils"
 import React, { useContext } from "react"
 import { ArticleBlocks } from "../components/ArticleBlocks.js"
@@ -79,7 +79,7 @@ const RelatedTopicsList = ({
     tags,
     className,
 }: {
-    tags?: Tag[]
+    tags?: DbPlainTag[]
     className?: string
 }) => {
     if (!tags?.length) return null
@@ -171,7 +171,7 @@ export const DataInsightBody = (
                 <div className="data-insight-blocks">
                     <ArticleBlocks blocks={props.content.body} />
                 </div>
-                <RelatedTopicsList tags={props.tags} />
+                <RelatedTopicsList tags={props.tags ?? undefined} />
             </div>
         </div>
     )