# What Database Technologies Are Used in OpenWork? MySQL and SQLite Explained

> OpenWork leverages MySQL for enterprise data and SQLite for local state, both powered by the Drizzle ORM. Discover how these database technologies drive the OpenWork platform.

- Repository: [Different AI/openwork](https://github.com/different-ai/openwork)
- Tags: internals
- Published: 2026-08-14

---

**OpenWork uses MySQL (with PlanetScale compatibility) for core enterprise data and SQLite for local runtime state, both accessed through the type-safe Drizzle ORM.**

If you are exploring the `different-ai/openwork` repository, understanding the database technologies used in OpenWork is essential to grasping its hybrid persistence architecture. The platform splits data storage between a robust relational engine for enterprise records and a lightweight file-based store for local workspace configuration. Both layers are managed through the modern, type-safe Drizzle ORM.

## Core Enterprise Data Layer: MySQL

MySQL serves as the main relational database for OpenWork's enterprise backend, powering organizations, users, policies, and plugins. The `@openwork-ee/den-db` package centralizes this layer, defining schemas with `mysqlTable` and `mysqlEnum` and connecting via Drizzle ORM.

### MySQL Schema Definitions

In `ee/packages/den-db/src/schema/*.ts`, the enterprise backend declares tables using Drizzle ORM's `mysql-core` primitives. These schema files export type-safe table definitions that enforce relational constraints across the Den services.

### MySQL Client and Connection Drivers

The [`ee/packages/den-db/src/client.ts`](https://github.com/different-ai/openwork/blob/main/ee/packages/den-db/src/client.ts) module creates the Drizzle client. It supports two driver configurations:

- **`drizzle-orm/mysql2`** for standard MySQL connections.
- **`drizzle-orm/planetscale-serverless`** for PlanetScale-compatible serverless deployments.

```ts
import { drizzle } from "drizzle-orm/mysql2";
import { mysqlTable, varchar } from "drizzle-orm/mysql-core";

// Create a typed DB client
const db = drizzle(mysqlConnection, { schema: {/* generated from schema files */} });

```

*(source: [`ee/packages/den-db/src/client.ts`](https://github.com/different-ai/openwork/blob/main/ee/packages/den-db/src/client.ts))*

## Local Runtime State: SQLite

SQLite provides fast, file-based persistence for workspace-specific configuration, temporary caches, and per-session data. This avoids the overhead of a networked database for local desktop sessions.

### Workspace KV Store

The `WorkspaceKvStore` class in [`apps/server/src/workspace-kv-store.ts`](https://github.com/different-ai/openwork/blob/main/apps/server/src/workspace-kv-store.ts) exposes a key-value API over a local SQLite file named `runtime.sqlite`. It builds on Drizzle's `sqliteTable` and native `bun:sqlite` or `node:sqlite` drivers.

### Runtime Database Abstraction

The [`apps/server/src/runtime-db.ts`](https://github.com/different-ai/openwork/blob/main/apps/server/src/runtime-db.ts) module handles SQLite database creation, migration, and access. It abstracts the native driver selection, allowing OpenWork to run under Bun or Node.js while keeping workspace data isolated.

```ts
import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
import { Database } from "bun:sqlite";
import { drizzle } from "drizzle-orm/bun-sqlite";

const dbPath = join(configDir, "runtime.sqlite");
const sqlite = new Database(dbPath, { create: true });
const kv = drizzle(sqlite);

// Define a table for key/value pairs
export const workspaceKv = sqliteTable("workspace_kv", {
  key: text("key").primaryKey(),
  value: text("value"),
});

```

*(source: [`apps/server/src/workspace-kv-store.ts`](https://github.com/different-ai/openwork/blob/main/apps/server/src/workspace-kv-store.ts) and [`apps/server/src/runtime-db.ts`](https://github.com/different-ai/openwork/blob/main/apps/server/src/runtime-db.ts))*

## Drizzle ORM as the Unified Database Layer

Drizzle ORM is the single abstraction used across both database technologies in OpenWork. The enterprise package relies on `drizzle-orm/mysql-core`, while the server runtime uses `drizzle-orm/sqlite-core`. Migration scripts for the MySQL layer are generated via Drizzle-Kit, configured in [`ee/packages/den-db/drizzle.config.ts`](https://github.com/different-ai/openwork/blob/main/ee/packages/den-db/drizzle.config.ts).

This dual-engine approach lets OpenWork maintain a full-featured relational model for shared enterprise data while keeping local state lightweight and portable.

## Summary

- **MySQL** powers the core enterprise backend for organizations, users, and policies through the `@openwork-ee/den-db` package.
- **SQLite** handles per-workspace configuration and temporary caches via a local `runtime.sqlite` file.
- Both engines are accessed through **Drizzle ORM**, ensuring type-safe queries and schema management.
- The codebase contains no PostgreSQL, MongoDB, or other database drivers, confirming a focused MySQL-plus-SQLite stack.

## Frequently Asked Questions

### Does OpenWork support PostgreSQL or MongoDB?

No. A full search of the `different-ai/openwork` codebase reveals no PostgreSQL or MongoDB clients, drivers, or schemas. The only database technologies used in OpenWork are MySQL and SQLite.

### Can OpenWork use PlanetScale instead of a self-hosted MySQL database?

Yes. The MySQL client in [`ee/packages/den-db/src/client.ts`](https://github.com/different-ai/openwork/blob/main/ee/packages/den-db/src/client.ts) can connect through `drizzle-orm/planetscale-serverless`, making PlanetScale a fully supported drop-in replacement for standard MySQL.

### Why does OpenWork use SQLite if MySQL is already available?

SQLite serves a different purpose: it stores local workspace state, session caches, and per-desktop configuration. Using a file-based engine eliminates network latency and server setup for individual user environments, while MySQL remains reserved for shared, persistent enterprise data.

### What ORM does OpenWork use for its database layers?

OpenWork uses **Drizzle ORM** exclusively. It leverages `mysql-core` and `sqlite-core` packages alongside Drizzle-Kit for type-safe schema definitions, query building, and migrations across both engines.