diff --git a/ts/sql/Server.ts b/ts/sql/Server.ts
index 48e35177340d..8d4b87da6345 100644
--- a/ts/sql/Server.ts
+++ b/ts/sql/Server.ts
@@ -498,12 +498,18 @@ function migrateSchemaVersion(db: Database): void {
   setUserVersion(db, newUserVersion);
 }
 
-function openAndMigrateDatabase(filePath: string, key: string) {
+function openAndMigrateDatabase(
+  filePath: string,
+  key: string,
+  readonly: boolean
+) {
   let db: Database | undefined;
 
   // First, we try to open the database without any cipher changes
   try {
-    db = new SQL(filePath);
+    db = new SQL(filePath, {
+      readonly,
+    });
     keyDatabase(db, key);
     switchToWAL(db);
     migrateSchemaVersion(db);
@@ -538,13 +544,16 @@ function openAndMigrateDatabase(filePath: string, key: string) {
 }
 
 const INVALID_KEY = /[^0-9A-Fa-f]/;
-function openAndSetUpSQLCipher(filePath: string, { key }: { key: string }) {
+function openAndSetUpSQLCipher(
+  filePath: string,
+  { key, readonly }: { key: string; readonly: boolean }
+) {
   const match = INVALID_KEY.exec(key);
   if (match) {
     throw new Error(`setupSQLCipher: key '${key}' is not valid`);
   }
 
-  const db = openAndMigrateDatabase(filePath, key);
+  const db = openAndMigrateDatabase(filePath, key, readonly);
 
   // Because foreign key support is not enabled by default!
   db.pragma('foreign_keys = ON');
@@ -552,7 +561,8 @@ function openAndSetUpSQLCipher(filePath: string, { key }: { key: string }) {
   return db;
 }
 
-let globalInstance: Database | undefined;
+let globalWritableInstance: Database | undefined;
+let globalReadonlyInstance: Database | undefined;
 let logger = consoleLogger;
 let databaseFilePath: string | undefined;
 let indexedDBPath: string | undefined;
@@ -570,7 +580,7 @@ async function initialize({
   key: string;
   logger: LoggerType;
 }): Promise<void> {
-  if (globalInstance) {
+  if (globalWritableInstance || globalReadonlyInstance) {
     throw new Error('Cannot initialize more than once!');
   }
 
@@ -590,26 +600,32 @@ async function initialize({
 
   databaseFilePath = join(dbDir, 'db.sqlite');
 
-  let db: Database | undefined;
+  let writable: Database | undefined;
+  let readonly: Database | undefined;
 
   try {
-    db = openAndSetUpSQLCipher(databaseFilePath, { key });
+    writable = openAndSetUpSQLCipher(databaseFilePath, {
+      key,
+      readonly: false,
+    });
 
     // For profiling use:
     // db.pragma('cipher_profile=\'sqlcipher.log\'');
 
-    updateSchema(db, logger);
+    updateSchema(writable, logger);
+
+    readonly = openAndSetUpSQLCipher(databaseFilePath, { key, readonly: true });
 
     // At this point we can allow general access to the database
-    globalInstance = db;
+    globalWritableInstance = writable;
+    globalReadonlyInstance = readonly;
 
     // test database
     getMessageCountSync();
   } catch (error) {
     logger.error('Database startup error:', error.stack);
-    if (db) {
-      db.close();
-    }
+    readonly?.close();
+    writable?.close();
     throw error;
   }
 }
@@ -617,20 +633,30 @@ async function initialize({
 async function close(): Promise<void> {
   // SQLLite documentation suggests that we run `PRAGMA optimize` right
   // before closing the database connection.
-  globalInstance?.pragma('optimize');
+  globalWritableInstance?.pragma('optimize');
 
-  globalInstance?.close();
-  globalInstance = undefined;
+  globalWritableInstance?.close();
+  globalWritableInstance = undefined;
+  globalReadonlyInstance?.close();
+  globalReadonlyInstance = undefined;
 }
 
 async function removeDB(): Promise<void> {
-  if (globalInstance) {
+  if (globalWritableInstance) {
     try {
-      globalInstance.close();
+      globalWritableInstance.close();
     } catch (error) {
       logger.error('removeDB: Failed to close database:', error.stack);
     }
-    globalInstance = undefined;
+    globalWritableInstance = undefined;
+  }
+  if (globalReadonlyInstance) {
+    try {
+      globalReadonlyInstance.close();
+    } catch (error) {
+      logger.error('removeDB: Failed to close readonly database:', error.stack);
+    }
+    globalReadonlyInstance = undefined;
   }
   if (!databaseFilePath) {
     throw new Error(
@@ -656,65 +682,77 @@ async function removeIndexedDBFiles(): Promise<void> {
   indexedDBPath = undefined;
 }
 
-function getInstance(): Database {
-  if (!globalInstance) {
-    throw new Error('getInstance: globalInstance not set!');
+function getReadonlyInstance(): Database {
+  if (!globalReadonlyInstance) {
+    throw new Error('getReadonlyInstance: globalReadonlyInstance not set!');
   }
 
-  return globalInstance;
+  return globalReadonlyInstance;
+}
+
+async function getWritableInstance(): Promise<Database> {
+  if (!globalWritableInstance) {
+    throw new Error('getWritableInstance: globalWritableInstance not set!');
+  }
+
+  return globalWritableInstance;
 }
 
 const IDENTITY_KEYS_TABLE = 'identityKeys';
 async function createOrUpdateIdentityKey(
   data: StoredIdentityKeyType
 ): Promise<void> {
-  return createOrUpdate(getInstance(), IDENTITY_KEYS_TABLE, data);
+  return createOrUpdate(await getWritableInstance(), IDENTITY_KEYS_TABLE, data);
 }
 async function getIdentityKeyById(
   id: IdentityKeyIdType
 ): Promise<StoredIdentityKeyType | undefined> {
-  return getById(getInstance(), IDENTITY_KEYS_TABLE, id);
+  return getById(getReadonlyInstance(), IDENTITY_KEYS_TABLE, id);
 }
 async function bulkAddIdentityKeys(
   array: Array<StoredIdentityKeyType>
 ): Promise<void> {
-  return bulkAdd(getInstance(), IDENTITY_KEYS_TABLE, array);
+  return bulkAdd(await getWritableInstance(), IDENTITY_KEYS_TABLE, array);
 }
 async function removeIdentityKeyById(id: IdentityKeyIdType): Promise<void> {
-  return removeById(getInstance(), IDENTITY_KEYS_TABLE, id);
+  return removeById(await getWritableInstance(), IDENTITY_KEYS_TABLE, id);
 }
 async function removeAllIdentityKeys(): Promise<void> {
-  return removeAllFromTable(getInstance(), IDENTITY_KEYS_TABLE);
+  return removeAllFromTable(await getWritableInstance(), IDENTITY_KEYS_TABLE);
 }
 async function getAllIdentityKeys(): Promise<Array<StoredIdentityKeyType>> {
-  return getAllFromTable(getInstance(), IDENTITY_KEYS_TABLE);
+  return getAllFromTable(getReadonlyInstance(), IDENTITY_KEYS_TABLE);
 }
 
 const KYBER_PRE_KEYS_TABLE = 'kyberPreKeys';
 async function createOrUpdateKyberPreKey(
   data: StoredKyberPreKeyType
 ): Promise<void> {
-  return createOrUpdate(getInstance(), KYBER_PRE_KEYS_TABLE, data);
+  return createOrUpdate(
+    await getWritableInstance(),
+    KYBER_PRE_KEYS_TABLE,
+    data
+  );
 }
 async function getKyberPreKeyById(
   id: PreKeyIdType
 ): Promise<StoredKyberPreKeyType | undefined> {
-  return getById(getInstance(), KYBER_PRE_KEYS_TABLE, id);
+  return getById(getReadonlyInstance(), KYBER_PRE_KEYS_TABLE, id);
 }
 async function bulkAddKyberPreKeys(
   array: Array<StoredKyberPreKeyType>
 ): Promise<void> {
-  return bulkAdd(getInstance(), KYBER_PRE_KEYS_TABLE, array);
+  return bulkAdd(await getWritableInstance(), KYBER_PRE_KEYS_TABLE, array);
 }
 async function removeKyberPreKeyById(
   id: PreKeyIdType | Array<PreKeyIdType>
 ): Promise<void> {
-  return removeById(getInstance(), KYBER_PRE_KEYS_TABLE, id);
+  return removeById(await getWritableInstance(), KYBER_PRE_KEYS_TABLE, id);
 }
 async function removeKyberPreKeysByServiceId(
   serviceId: ServiceIdString
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<Query>(
     'DELETE FROM kyberPreKeys WHERE ourServiceId IS $serviceId;'
   ).run({
@@ -722,33 +760,33 @@ async function removeKyberPreKeysByServiceId(
   });
 }
 async function removeAllKyberPreKeys(): Promise<void> {
-  return removeAllFromTable(getInstance(), KYBER_PRE_KEYS_TABLE);
+  return removeAllFromTable(await getWritableInstance(), KYBER_PRE_KEYS_TABLE);
 }
 async function getAllKyberPreKeys(): Promise<Array<StoredKyberPreKeyType>> {
-  return getAllFromTable(getInstance(), KYBER_PRE_KEYS_TABLE);
+  return getAllFromTable(getReadonlyInstance(), KYBER_PRE_KEYS_TABLE);
 }
 
 const PRE_KEYS_TABLE = 'preKeys';
 async function createOrUpdatePreKey(data: StoredPreKeyType): Promise<void> {
-  return createOrUpdate(getInstance(), PRE_KEYS_TABLE, data);
+  return createOrUpdate(await getWritableInstance(), PRE_KEYS_TABLE, data);
 }
 async function getPreKeyById(
   id: PreKeyIdType
 ): Promise<StoredPreKeyType | undefined> {
-  return getById(getInstance(), PRE_KEYS_TABLE, id);
+  return getById(getReadonlyInstance(), PRE_KEYS_TABLE, id);
 }
 async function bulkAddPreKeys(array: Array<StoredPreKeyType>): Promise<void> {
-  return bulkAdd(getInstance(), PRE_KEYS_TABLE, array);
+  return bulkAdd(await getWritableInstance(), PRE_KEYS_TABLE, array);
 }
 async function removePreKeyById(
   id: PreKeyIdType | Array<PreKeyIdType>
 ): Promise<void> {
-  return removeById(getInstance(), PRE_KEYS_TABLE, id);
+  return removeById(await getWritableInstance(), PRE_KEYS_TABLE, id);
 }
 async function removePreKeysByServiceId(
   serviceId: ServiceIdString
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<Query>(
     'DELETE FROM preKeys WHERE ourServiceId IS $serviceId;'
   ).run({
@@ -756,37 +794,41 @@ async function removePreKeysByServiceId(
   });
 }
 async function removeAllPreKeys(): Promise<void> {
-  return removeAllFromTable(getInstance(), PRE_KEYS_TABLE);
+  return removeAllFromTable(await getWritableInstance(), PRE_KEYS_TABLE);
 }
 async function getAllPreKeys(): Promise<Array<StoredPreKeyType>> {
-  return getAllFromTable(getInstance(), PRE_KEYS_TABLE);
+  return getAllFromTable(getReadonlyInstance(), PRE_KEYS_TABLE);
 }
 
 const SIGNED_PRE_KEYS_TABLE = 'signedPreKeys';
 async function createOrUpdateSignedPreKey(
   data: StoredSignedPreKeyType
 ): Promise<void> {
-  return createOrUpdate(getInstance(), SIGNED_PRE_KEYS_TABLE, data);
+  return createOrUpdate(
+    await getWritableInstance(),
+    SIGNED_PRE_KEYS_TABLE,
+    data
+  );
 }
 async function getSignedPreKeyById(
   id: SignedPreKeyIdType
 ): Promise<StoredSignedPreKeyType | undefined> {
-  return getById(getInstance(), SIGNED_PRE_KEYS_TABLE, id);
+  return getById(getReadonlyInstance(), SIGNED_PRE_KEYS_TABLE, id);
 }
 async function bulkAddSignedPreKeys(
   array: Array<StoredSignedPreKeyType>
 ): Promise<void> {
-  return bulkAdd(getInstance(), SIGNED_PRE_KEYS_TABLE, array);
+  return bulkAdd(await getWritableInstance(), SIGNED_PRE_KEYS_TABLE, array);
 }
 async function removeSignedPreKeyById(
   id: SignedPreKeyIdType | Array<SignedPreKeyIdType>
 ): Promise<void> {
-  return removeById(getInstance(), SIGNED_PRE_KEYS_TABLE, id);
+  return removeById(await getWritableInstance(), SIGNED_PRE_KEYS_TABLE, id);
 }
 async function removeSignedPreKeysByServiceId(
   serviceId: ServiceIdString
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<Query>(
     'DELETE FROM signedPreKeys WHERE ourServiceId IS $serviceId;'
   ).run({
@@ -794,10 +836,10 @@ async function removeSignedPreKeysByServiceId(
   });
 }
 async function removeAllSignedPreKeys(): Promise<void> {
-  return removeAllFromTable(getInstance(), SIGNED_PRE_KEYS_TABLE);
+  return removeAllFromTable(await getWritableInstance(), SIGNED_PRE_KEYS_TABLE);
 }
 async function getAllSignedPreKeys(): Promise<Array<StoredSignedPreKeyType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: JSONRows = db
     .prepare<EmptyQuery>(
       `
@@ -815,15 +857,15 @@ const ITEMS_TABLE = 'items';
 async function createOrUpdateItem<K extends ItemKeyType>(
   data: StoredItemType<K>
 ): Promise<void> {
-  return createOrUpdate(getInstance(), ITEMS_TABLE, data);
+  return createOrUpdate(await getWritableInstance(), ITEMS_TABLE, data);
 }
 async function getItemById<K extends ItemKeyType>(
   id: K
 ): Promise<StoredItemType<K> | undefined> {
-  return getById(getInstance(), ITEMS_TABLE, id);
+  return getById(getReadonlyInstance(), ITEMS_TABLE, id);
 }
 async function getAllItems(): Promise<StoredAllItemsType> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: JSONRows = db
     .prepare<EmptyQuery>('SELECT json FROM items ORDER BY id ASC;')
     .all();
@@ -843,19 +885,18 @@ async function getAllItems(): Promise<StoredAllItemsType> {
 async function removeItemById(
   id: ItemKeyType | Array<ItemKeyType>
 ): Promise<void> {
-  return removeById(getInstance(), ITEMS_TABLE, id);
+  return removeById(await getWritableInstance(), ITEMS_TABLE, id);
 }
 async function removeAllItems(): Promise<void> {
-  return removeAllFromTable(getInstance(), ITEMS_TABLE);
+  return removeAllFromTable(await getWritableInstance(), ITEMS_TABLE);
 }
 
 async function createOrUpdateSenderKey(key: SenderKeyType): Promise<void> {
-  createOrUpdateSenderKeySync(key);
+  const db = await getWritableInstance();
+  createOrUpdateSenderKeySync(db, key);
 }
 
-function createOrUpdateSenderKeySync(key: SenderKeyType): void {
-  const db = getInstance();
-
+function createOrUpdateSenderKeySync(db: Database, key: SenderKeyType): void {
   prepare(
     db,
     `
@@ -878,7 +919,7 @@ function createOrUpdateSenderKeySync(key: SenderKeyType): void {
 async function getSenderKeyById(
   id: SenderKeyIdType
 ): Promise<SenderKeyType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const row = prepare(db, 'SELECT * FROM senderKeys WHERE id = $id').get({
     id,
   });
@@ -886,17 +927,17 @@ async function getSenderKeyById(
   return row;
 }
 async function removeAllSenderKeys(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   prepare<EmptyQuery>(db, 'DELETE FROM senderKeys').run();
 }
 async function getAllSenderKeys(): Promise<Array<SenderKeyType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows = prepare<EmptyQuery>(db, 'SELECT * FROM senderKeys').all();
 
   return rows;
 }
 async function removeSenderKeyById(id: SenderKeyIdType): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   prepare(db, 'DELETE FROM senderKeys WHERE id = $id').run({ id });
 }
 
@@ -907,7 +948,7 @@ async function insertSentProto(
     messageIds: SentMessagesType;
   }
 ): Promise<number> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const { recipients, messageIds } = options;
 
   // Note: we use `pluck` in this function to fetch only the first column of returned row.
@@ -1000,7 +1041,7 @@ async function insertSentProto(
 }
 
 async function deleteSentProtosOlderThan(timestamp: number): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   prepare(
     db,
@@ -1016,7 +1057,7 @@ async function deleteSentProtosOlderThan(timestamp: number): Promise<void> {
 }
 
 async function deleteSentProtoByMessageId(messageId: string): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   prepare(
     db,
@@ -1040,7 +1081,7 @@ async function insertProtoRecipients({
   recipientServiceId: ServiceIdString;
   deviceIds: Array<number>;
 }): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     const statement = prepare(
@@ -1073,7 +1114,7 @@ async function deleteSentProtoRecipient(
     | DeleteSentProtoRecipientOptionsType
     | ReadonlyArray<DeleteSentProtoRecipientOptionsType>
 ): Promise<DeleteSentProtoRecipientResultType> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   const items = Array.isArray(options) ? options : [options];
 
@@ -1190,13 +1231,13 @@ async function getSentProtoByRecipient({
   recipientServiceId: ServiceIdString;
   timestamp: number;
 }): Promise<SentProtoWithMessageIdsType | undefined> {
-  const db = getInstance();
-
   const HOUR = 1000 * 60 * 60;
   const oneDayAgo = now - HOUR * 24;
 
   await deleteSentProtosOlderThan(oneDayAgo);
 
+  const db = getReadonlyInstance();
+
   const row = prepare(
     db,
     `
@@ -1231,11 +1272,11 @@ async function getSentProtoByRecipient({
   };
 }
 async function removeAllSentProtos(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   prepare<EmptyQuery>(db, 'DELETE FROM sendLogPayloads;').run();
 }
 async function getAllSentProtos(): Promise<Array<SentProtoType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows = prepare<EmptyQuery>(db, 'SELECT * FROM sendLogPayloads;').all();
 
   return rows.map(row => ({
@@ -1249,7 +1290,7 @@ async function getAllSentProtos(): Promise<Array<SentProtoType>> {
 async function _getAllSentProtoRecipients(): Promise<
   Array<SentRecipientsDBType>
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows = prepare<EmptyQuery>(
     db,
     'SELECT * FROM sendLogRecipients;'
@@ -1258,7 +1299,7 @@ async function _getAllSentProtoRecipients(): Promise<
   return rows;
 }
 async function _getAllSentProtoMessageIds(): Promise<Array<SentMessageDBType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows = prepare<EmptyQuery>(
     db,
     'SELECT * FROM sendLogMessageIds;'
@@ -1268,8 +1309,7 @@ async function _getAllSentProtoMessageIds(): Promise<Array<SentMessageDBType>> {
 }
 
 const SESSIONS_TABLE = 'sessions';
-function createOrUpdateSessionSync(data: SessionType): void {
-  const db = getInstance();
+function createOrUpdateSessionSync(db: Database, data: SessionType): void {
   const { id, conversationId, ourServiceId, serviceId } = data;
   if (!id) {
     throw new Error(
@@ -1308,17 +1348,18 @@ function createOrUpdateSessionSync(data: SessionType): void {
   });
 }
 async function createOrUpdateSession(data: SessionType): Promise<void> {
-  return createOrUpdateSessionSync(data);
+  const db = await getWritableInstance();
+  return createOrUpdateSessionSync(db, data);
 }
 
 async function createOrUpdateSessions(
   array: Array<SessionType>
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     for (const item of array) {
-      assertSync(createOrUpdateSessionSync(item));
+      assertSync(createOrUpdateSessionSync(db, item));
     }
   })();
 }
@@ -1332,33 +1373,33 @@ async function commitDecryptResult({
   sessions: Array<SessionType>;
   unprocessed: Array<UnprocessedType>;
 }): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     for (const item of senderKeys) {
-      assertSync(createOrUpdateSenderKeySync(item));
+      assertSync(createOrUpdateSenderKeySync(db, item));
     }
 
     for (const item of sessions) {
-      assertSync(createOrUpdateSessionSync(item));
+      assertSync(createOrUpdateSessionSync(db, item));
     }
 
     for (const item of unprocessed) {
-      assertSync(saveUnprocessedSync(item));
+      assertSync(saveUnprocessedSync(db, item));
     }
   })();
 }
 
 async function bulkAddSessions(array: Array<SessionType>): Promise<void> {
-  return bulkAdd(getInstance(), SESSIONS_TABLE, array);
+  return bulkAdd(await getWritableInstance(), SESSIONS_TABLE, array);
 }
 async function removeSessionById(id: SessionIdType): Promise<void> {
-  return removeById(getInstance(), SESSIONS_TABLE, id);
+  return removeById(await getWritableInstance(), SESSIONS_TABLE, id);
 }
 async function removeSessionsByConversation(
   conversationId: string
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<Query>(
     `
     DELETE FROM sessions
@@ -1371,7 +1412,7 @@ async function removeSessionsByConversation(
 async function removeSessionsByServiceId(
   serviceId: ServiceIdString
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<Query>(
     `
     DELETE FROM sessions
@@ -1382,15 +1423,15 @@ async function removeSessionsByServiceId(
   });
 }
 async function removeAllSessions(): Promise<void> {
-  return removeAllFromTable(getInstance(), SESSIONS_TABLE);
+  return removeAllFromTable(await getWritableInstance(), SESSIONS_TABLE);
 }
 async function getAllSessions(): Promise<Array<SessionType>> {
-  return getAllFromTable(getInstance(), SESSIONS_TABLE);
+  return getAllFromTable(getReadonlyInstance(), SESSIONS_TABLE);
 }
 // Conversations
 
 async function getConversationCount(): Promise<number> {
-  return getCountFromTable(getInstance(), 'conversations');
+  return getCountFromTable(getReadonlyInstance(), 'conversations');
 }
 
 function getConversationMembersList({ members, membersV2 }: ConversationType) {
@@ -1403,10 +1444,7 @@ function getConversationMembersList({ members, membersV2 }: ConversationType) {
   return null;
 }
 
-function saveConversationSync(
-  data: ConversationType,
-  db = getInstance()
-): void {
+function saveConversationSync(db: Database, data: ConversationType): void {
   const {
     active_at,
     e164,
@@ -1479,29 +1517,24 @@ function saveConversationSync(
   });
 }
 
-async function saveConversation(
-  data: ConversationType,
-  db = getInstance()
-): Promise<void> {
-  return saveConversationSync(data, db);
+async function saveConversation(data: ConversationType): Promise<void> {
+  const db = await getWritableInstance();
+  return saveConversationSync(db, data);
 }
 
 async function saveConversations(
   arrayOfConversations: Array<ConversationType>
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     for (const conversation of arrayOfConversations) {
-      assertSync(saveConversationSync(conversation));
+      assertSync(saveConversationSync(db, conversation));
     }
   })();
 }
 
-function updateConversationSync(
-  data: ConversationType,
-  db = getInstance()
-): void {
+function updateConversationSync(db: Database, data: ConversationType): void {
   const {
     id,
     active_at,
@@ -1555,24 +1588,26 @@ function updateConversationSync(
 }
 
 async function updateConversation(data: ConversationType): Promise<void> {
-  return updateConversationSync(data);
+  const db = await getWritableInstance();
+  return updateConversationSync(db, data);
 }
 
 async function updateConversations(
   array: Array<ConversationType>
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     for (const item of array) {
-      assertSync(updateConversationSync(item));
+      assertSync(updateConversationSync(db, item));
     }
   })();
 }
 
-function removeConversationsSync(ids: ReadonlyArray<string>): void {
-  const db = getInstance();
-
+function removeConversationsSync(
+  db: Database,
+  ids: ReadonlyArray<string>
+): void {
   // Our node interface doesn't seem to allow you to replace one single ? with an array
   db.prepare<ArrayQuery>(
     `
@@ -1583,7 +1618,7 @@ function removeConversationsSync(ids: ReadonlyArray<string>): void {
 }
 
 async function removeConversation(id: Array<string> | string): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   if (!Array.isArray(id)) {
     db.prepare<Query>('DELETE FROM conversations WHERE id = $id;').run({
@@ -1597,18 +1632,18 @@ async function removeConversation(id: Array<string> | string): Promise<void> {
     throw new Error('removeConversation: No ids to delete!');
   }
 
-  batchMultiVarQuery(db, id, removeConversationsSync);
+  batchMultiVarQuery(db, id, ids => removeConversationsSync(db, ids));
 }
 
 async function _removeAllConversations(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<EmptyQuery>('DELETE from conversations;').run();
 }
 
 async function getConversationById(
   id: string
 ): Promise<ConversationType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const row: { json: string } = db
     .prepare<Query>('SELECT json FROM conversations WHERE id = $id;')
     .get({ id });
@@ -1620,7 +1655,9 @@ async function getConversationById(
   return jsonToObject(row.json);
 }
 
-function getAllConversationsSync(db = getInstance()): Array<ConversationType> {
+function getAllConversationsSync(
+  db = getReadonlyInstance()
+): Array<ConversationType> {
   const rows: ConversationRows = db
     .prepare<EmptyQuery>(
       `
@@ -1639,7 +1676,7 @@ async function getAllConversations(): Promise<Array<ConversationType>> {
 }
 
 async function getAllConversationIds(): Promise<Array<string>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: Array<{ id: string }> = db
     .prepare<EmptyQuery>(
       `
@@ -1654,7 +1691,7 @@ async function getAllConversationIds(): Promise<Array<string>> {
 async function getAllGroupsInvolvingServiceId(
   serviceId: ServiceIdString
 ): Promise<Array<ConversationType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: ConversationRows = db
     .prepare<Query>(
       `
@@ -1685,7 +1722,9 @@ async function searchMessages({
 }): Promise<Array<ServerSearchResultMessageType>> {
   const { limit = conversationId ? 100 : 500 } = options ?? {};
 
-  const db = getInstance();
+  // We don't actually write to the database, but temporary tables below
+  // require write access.
+  const db = await getWritableInstance();
 
   // sqlite queries with a join on a virtual table (like FTS5) are de-optimized
   // and can't use indices for ordering results. Instead an in-memory index of
@@ -1831,7 +1870,7 @@ async function searchMessages({
 
 function getMessageCountSync(
   conversationId?: string,
-  db = getInstance()
+  db = getReadonlyInstance()
 ): number {
   if (conversationId === undefined) {
     return getCountFromTable(db, 'messages');
@@ -1852,7 +1891,7 @@ function getMessageCountSync(
 }
 
 async function getStoryCount(conversationId: string): Promise<number> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   return db
     .prepare<Query>(
       `
@@ -1872,7 +1911,7 @@ async function getMessageCount(conversationId?: string): Promise<number> {
 // Note: we really only use this in 1:1 conversations, where story replies are always
 //   shown, so this has no need to be story-aware.
 function hasUserInitiatedMessages(conversationId: string): boolean {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const exists: number = db
     .prepare<Query>(
@@ -1893,27 +1932,21 @@ function hasUserInitiatedMessages(conversationId: string): boolean {
 }
 
 function saveMessageSync(
+  db: Database,
   data: MessageType,
   options: {
     alreadyInTransaction?: boolean;
-    db?: Database;
     forceSave?: boolean;
     jobToInsert?: StoredJob;
     ourAci: AciString;
   }
 ): string {
-  const {
-    alreadyInTransaction,
-    db = getInstance(),
-    forceSave,
-    jobToInsert,
-    ourAci,
-  } = options;
+  const { alreadyInTransaction, forceSave, jobToInsert, ourAci } = options;
 
   if (!alreadyInTransaction) {
     return db.transaction(() => {
       return assertSync(
-        saveMessageSync(data, {
+        saveMessageSync(db, data, {
           ...options,
           alreadyInTransaction: true,
         })
@@ -2127,33 +2160,32 @@ async function saveMessage(
     ourAci: AciString;
   }
 ): Promise<string> {
-  return saveMessageSync(data, options);
+  const db = await getWritableInstance();
+  return saveMessageSync(db, data, options);
 }
 
 async function saveMessages(
   arrayOfMessages: ReadonlyArray<MessageType>,
   options: { forceSave?: boolean; ourAci: AciString }
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     for (const message of arrayOfMessages) {
       assertSync(
-        saveMessageSync(message, { ...options, alreadyInTransaction: true })
+        saveMessageSync(db, message, { ...options, alreadyInTransaction: true })
       );
     }
   })();
 }
 
 async function removeMessage(id: string): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.prepare<Query>('DELETE FROM messages WHERE id = $id;').run({ id });
 }
 
-function removeMessagesSync(ids: ReadonlyArray<string>): void {
-  const db = getInstance();
-
+function removeMessagesSync(db: Database, ids: ReadonlyArray<string>): void {
   db.prepare<ArrayQuery>(
     `
     DELETE FROM messages
@@ -2163,11 +2195,12 @@ function removeMessagesSync(ids: ReadonlyArray<string>): void {
 }
 
 async function removeMessages(ids: ReadonlyArray<string>): Promise<void> {
-  batchMultiVarQuery(getInstance(), ids, removeMessagesSync);
+  const db = await getWritableInstance();
+  batchMultiVarQuery(db, ids, batch => removeMessagesSync(db, batch));
 }
 
 async function getMessageById(id: string): Promise<MessageType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   return getMessageByIdSync(db, id);
 }
 
@@ -2191,7 +2224,7 @@ export function getMessageByIdSync(
 async function getMessagesById(
   messageIds: ReadonlyArray<string>
 ): Promise<Array<MessageType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   return batchMultiVarQuery(
     db,
@@ -2209,7 +2242,7 @@ async function getMessagesById(
 }
 
 async function _getAllMessages(): Promise<Array<MessageType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: JSONRows = db
     .prepare<EmptyQuery>('SELECT json FROM messages ORDER BY id ASC;')
     .all();
@@ -2217,14 +2250,14 @@ async function _getAllMessages(): Promise<Array<MessageType>> {
   return rows.map(row => jsonToObject(row.json));
 }
 async function _removeAllMessages(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.exec(`
     DELETE FROM messages;
   `);
 }
 
 async function getAllMessageIds(): Promise<Array<string>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: Array<{ id: string }> = db
     .prepare<EmptyQuery>('SELECT id FROM messages ORDER BY id ASC;')
     .all();
@@ -2243,7 +2276,7 @@ async function getMessageBySender({
   sourceDevice?: number;
   sent_at: number;
 }): Promise<MessageType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: JSONRows = prepare(
     db,
     `
@@ -2307,7 +2340,7 @@ async function getUnreadByConversationAndMarkRead({
   readAt?: number;
   now?: number;
 }): Promise<GetUnreadByConversationAndMarkReadResultType> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   return db.transaction(() => {
     const expirationStartTimestamp = Math.min(now, readAt ?? Infinity);
 
@@ -2396,7 +2429,7 @@ async function getUnreadReactionsAndMarkRead({
   newestUnreadAt: number;
   storyId?: string;
 }): Promise<Array<ReactionResultType>> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   return db.transaction(() => {
     const unreadMessages: Array<ReactionResultType> = db
@@ -2439,7 +2472,7 @@ async function markReactionAsRead(
   targetAuthorServiceId: ServiceIdString,
   targetTimestamp: number
 ): Promise<ReactionType | undefined> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   return db.transaction(() => {
     const readReaction = db
       .prepare(
@@ -2484,7 +2517,7 @@ async function addReaction({
   targetAuthorAci,
   targetTimestamp,
 }: ReactionType): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   await db
     .prepare(
       `INSERT INTO reactions (
@@ -2530,7 +2563,7 @@ async function removeReactionFromConversation({
   targetAuthorServiceId: ServiceIdString;
   targetTimestamp: number;
 }): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   await db
     .prepare(
       `DELETE FROM reactions WHERE
@@ -2548,11 +2581,11 @@ async function removeReactionFromConversation({
 }
 
 async function _getAllReactions(): Promise<Array<ReactionType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   return db.prepare<EmptyQuery>('SELECT * from reactions;').all();
 }
 async function _removeAllReactions(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<EmptyQuery>('DELETE from reactions;').run();
 }
 
@@ -2580,7 +2613,7 @@ function getRecentStoryRepliesSync(
     sentAt = Number.MAX_VALUE,
   }: GetRecentStoryRepliesOptionsType = {}
 ): Array<MessageTypeUnhydrated> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const timeFilters = {
     first: sqlFragment`received_at = ${receivedAt} AND sent_at < ${sentAt}`,
     second: sqlFragment`received_at < ${receivedAt}`,
@@ -2621,7 +2654,7 @@ function getAdjacentMessagesByConversationSync(
     storyId,
   }: AdjacentMessagesByConversationOptionsType
 ): Array<MessageTypeUnhydrated> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   let timeFilters: { first: QueryFragment; second: QueryFragment };
   let timeOrder: QueryFragment;
@@ -2717,7 +2750,7 @@ async function getAllStories({
   conversationId?: string;
   sourceServiceId?: ServiceIdString;
 }): Promise<GetAllStoriesResultType> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: ReadonlyArray<{
     json: string;
     hasReplies: number;
@@ -2777,7 +2810,7 @@ function getOldestMessageForConversation(
     includeStoryReplies: boolean;
   }
 ): MessageMetricsType | undefined {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query, params] = sql`
     SELECT received_at, sent_at, id FROM messages WHERE
         conversationId = ${conversationId} AND
@@ -2805,7 +2838,7 @@ function getNewestMessageForConversation(
     includeStoryReplies: boolean;
   }
 ): MessageMetricsType | undefined {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query, params] = sql`
     SELECT received_at, sent_at, id FROM messages WHERE
         conversationId = ${conversationId} AND
@@ -2833,7 +2866,7 @@ async function getMessagesBetween(
   conversationId: string,
   options: GetMessagesBetweenOptions
 ): Promise<Array<string>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   // In the future we could accept this as an option, but for now we just
   // use it for the story predicate.
@@ -2875,7 +2908,7 @@ async function getNearbyMessageFromDeletedSet({
   storyId,
   includeStoryReplies,
 }: GetNearbyMessageFromDeletedSetOptionsType): Promise<string | null> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   function runQuery(after: boolean) {
     const dir = after ? sqlFragment`ASC` : sqlFragment`DESC`;
@@ -2920,7 +2953,7 @@ function getLastConversationActivity({
   conversationId: string;
   includeStoryReplies: boolean;
 }): MessageType | undefined {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const row = prepare(
     db,
     `
@@ -2956,7 +2989,7 @@ function getLastConversationPreview({
     json: string;
   }>;
 
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const index = includeStoryReplies
     ? 'messages_preview'
@@ -2993,7 +3026,7 @@ async function getConversationMessageStats({
   conversationId: string;
   includeStoryReplies: boolean;
 }): Promise<ConversationMessageStatsType> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   return db.transaction(() => {
     return {
@@ -3015,7 +3048,7 @@ async function getLastConversationMessage({
 }: {
   conversationId: string;
 }): Promise<MessageType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const row = db
     .prepare<Query>(
       `
@@ -3046,7 +3079,7 @@ function getOldestUnseenMessageForConversation(
     includeStoryReplies: boolean;
   }
 ): MessageMetricsType | undefined {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const [query, params] = sql`
     SELECT received_at, sent_at, id FROM messages WHERE
@@ -3084,7 +3117,7 @@ export function getOldestUnreadMentionOfMeForConversationSync(
     includeStoryReplies: boolean;
   }
 ): MessageMetricsType | undefined {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query, params] = sql`
       SELECT received_at, sent_at, id FROM messages WHERE
         conversationId = ${conversationId} AND
@@ -3118,7 +3151,7 @@ function getTotalUnreadForConversationSync(
     includeStoryReplies: boolean;
   }
 ): number {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query, params] = sql`
     SELECT count(1)
     FROM messages
@@ -3151,7 +3184,7 @@ function getTotalUnreadMentionsOfMeForConversationSync(
     includeStoryReplies: boolean;
   }
 ): number {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query, params] = sql`
     SELECT count(1)
     FROM messages
@@ -3176,7 +3209,7 @@ function getTotalUnseenForConversationSync(
     includeStoryReplies: boolean;
   }
 ): number {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query, params] = sql`
     SELECT count(1)
       FROM messages
@@ -3230,7 +3263,7 @@ async function getConversationRangeCenteredOnMessage(
 ): Promise<
   GetConversationRangeCenteredOnMessageResultType<MessageTypeUnhydrated>
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   return db.transaction(() => {
     return {
@@ -3248,7 +3281,7 @@ async function getConversationRangeCenteredOnMessage(
 }
 
 async function getAllCallHistory(): Promise<ReadonlyArray<CallHistoryDetails>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query] = sql`
     SELECT * FROM callsHistory;
   `;
@@ -3258,7 +3291,7 @@ async function getAllCallHistory(): Promise<ReadonlyArray<CallHistoryDetails>> {
 async function clearCallHistory(
   beforeTimestamp: number
 ): Promise<Array<string>> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   return db.transaction(() => {
     const whereMessages = sqlFragment`
       WHERE messages.type IS 'call-history'
@@ -3296,7 +3329,7 @@ async function clearCallHistory(
 }
 
 async function cleanupCallHistoryMessages(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   return db
     .transaction(() => {
       const [query, params] = sql`
@@ -3317,7 +3350,7 @@ async function getCallHistoryMessageByCallId(options: {
   conversationId: string;
   callId: string;
 }): Promise<MessageType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query, params] = sql`
     SELECT json
     FROM messages
@@ -3336,7 +3369,7 @@ async function getCallHistory(
   callId: string,
   peerId: ServiceIdString | string
 ): Promise<CallHistoryDetails | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const [query, params] = sql`
     SELECT * FROM callsHistory
@@ -3361,7 +3394,7 @@ const CALL_STATUS_INCOMING = sqlConstant(CallDirection.Incoming);
 const FOUR_HOURS_IN_MS = sqlConstant(4 * 60 * 60 * 1000);
 
 async function getCallHistoryUnreadCount(): Promise<number> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const [query, params] = sql`
     SELECT count(*) FROM messages
     LEFT JOIN callsHistory ON callsHistory.callId = messages.callId
@@ -3375,7 +3408,7 @@ async function getCallHistoryUnreadCount(): Promise<number> {
 }
 
 async function markCallHistoryRead(callId: string): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const [query, params] = sql`
     UPDATE messages
     SET readStatus = ${READ_STATUS_READ}
@@ -3386,7 +3419,7 @@ async function markCallHistoryRead(callId: string): Promise<void> {
 }
 
 async function markAllCallHistoryRead(): Promise<ReadonlyArray<string>> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   return db.transaction(() => {
     const where = sqlFragment`
@@ -3602,7 +3635,9 @@ const countSchema = z.number().int().nonnegative();
 async function getCallHistoryGroupsCount(
   filter: CallHistoryFilter
 ): Promise<number> {
-  const db = getInstance();
+  // getCallHistoryGroupDataSync creates a temporary table and thus requires
+  // write access.
+  const db = await getWritableInstance();
   const result = getCallHistoryGroupDataSync(db, true, filter, {
     limit: 0,
     offset: 0,
@@ -3628,7 +3663,9 @@ async function getCallHistoryGroups(
   filter: CallHistoryFilter,
   pagination: CallHistoryPagination
 ): Promise<Array<CallHistoryGroup>> {
-  const db = getInstance();
+  // getCallHistoryGroupDataSync creates a temporary table and thus requires
+  // write access.
+  const db = await getWritableInstance();
   const groupsData = groupsDataSchema.parse(
     getCallHistoryGroupDataSync(db, false, filter, pagination)
   );
@@ -3663,7 +3700,7 @@ async function getCallHistoryGroups(
 }
 
 async function saveCallHistory(callHistory: CallHistoryDetails): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   const [insertQuery, insertParams] = sql`
     INSERT OR REPLACE INTO callsHistory (
@@ -3694,7 +3731,7 @@ async function hasGroupCallHistoryMessage(
   conversationId: string,
   eraId: string
 ): Promise<boolean> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const exists: number = db
     .prepare<Query>(
@@ -3721,7 +3758,7 @@ async function migrateConversationMessages(
   obsoleteId: string,
   currentId: string
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.prepare<Query>(
     `
@@ -3739,7 +3776,7 @@ async function migrateConversationMessages(
 async function getMessagesBySentAt(
   sentAt: number
 ): Promise<Array<MessageType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const [query, params] = sql`
       SELECT messages.json, received_at, sent_at FROM edited_messages
@@ -3758,7 +3795,7 @@ async function getMessagesBySentAt(
 }
 
 async function getExpiredMessages(): Promise<Array<MessageType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const now = Date.now();
 
   const rows: JSONRows = db
@@ -3777,7 +3814,7 @@ async function getExpiredMessages(): Promise<Array<MessageType>> {
 async function getMessagesUnexpectedlyMissingExpirationStartTimestamp(): Promise<
   Array<MessageType>
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: JSONRows = db
     .prepare<EmptyQuery>(
       `
@@ -3802,7 +3839,7 @@ async function getMessagesUnexpectedlyMissingExpirationStartTimestamp(): Promise
 }
 
 async function getSoonestMessageExpiry(): Promise<undefined | number> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   // Note: we use `pluck` to only get the first column.
   const result: null | number = db
@@ -3825,7 +3862,7 @@ async function getSoonestMessageExpiry(): Promise<undefined | number> {
 async function getNextTapToViewMessageTimestampToAgeOut(): Promise<
   undefined | number
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const row = db
     .prepare<EmptyQuery>(
       `
@@ -3849,7 +3886,7 @@ async function getNextTapToViewMessageTimestampToAgeOut(): Promise<
 }
 
 async function getTapToViewMessagesNeedingErase(): Promise<Array<MessageType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const THIRTY_DAYS_AGO = Date.now() - 30 * 24 * 60 * 60 * 1000;
 
   const rows: JSONRows = db
@@ -3873,8 +3910,7 @@ async function getTapToViewMessagesNeedingErase(): Promise<Array<MessageType>> {
 
 const MAX_UNPROCESSED_ATTEMPTS = 10;
 
-function saveUnprocessedSync(data: UnprocessedType): string {
-  const db = getInstance();
+function saveUnprocessedSync(db: Database, data: UnprocessedType): string {
   const {
     id,
     timestamp,
@@ -3951,10 +3987,10 @@ function saveUnprocessedSync(data: UnprocessedType): string {
 }
 
 function updateUnprocessedWithDataSync(
+  db: Database,
   id: string,
   data: UnprocessedUpdateType
 ): void {
-  const db = getInstance();
   const {
     source,
     sourceServiceId,
@@ -3991,17 +4027,18 @@ async function updateUnprocessedWithData(
   id: string,
   data: UnprocessedUpdateType
 ): Promise<void> {
-  return updateUnprocessedWithDataSync(id, data);
+  const db = await getWritableInstance();
+  return updateUnprocessedWithDataSync(db, id, data);
 }
 
 async function updateUnprocessedsWithData(
   arrayOfUnprocessed: Array<{ id: string; data: UnprocessedUpdateType }>
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     for (const { id, data } of arrayOfUnprocessed) {
-      assertSync(updateUnprocessedWithDataSync(id, data));
+      assertSync(updateUnprocessedWithDataSync(db, id, data));
     }
   })();
 }
@@ -4009,7 +4046,7 @@ async function updateUnprocessedsWithData(
 async function getUnprocessedById(
   id: string
 ): Promise<UnprocessedType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const row = db
     .prepare<Query>('SELECT * FROM unprocessed WHERE id = $id;')
     .get({
@@ -4024,12 +4061,12 @@ async function getUnprocessedById(
 }
 
 async function getUnprocessedCount(): Promise<number> {
-  return getCountFromTable(getInstance(), 'unprocessed');
+  return getCountFromTable(getReadonlyInstance(), 'unprocessed');
 }
 
 async function getAllUnprocessedIds(): Promise<Array<string>> {
   log.info('getAllUnprocessedIds');
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   return db.transaction(() => {
     // cleanup first
@@ -4080,7 +4117,7 @@ async function getUnprocessedByIdsAndIncrementAttempts(
 ): Promise<Array<UnprocessedType>> {
   log.info('getUnprocessedByIdsAndIncrementAttempts', { totalIds: ids.length });
 
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   batchMultiVarQuery(db, ids, batch => {
     return db
@@ -4113,10 +4150,11 @@ async function getUnprocessedByIdsAndIncrementAttempts(
   });
 }
 
-function removeUnprocessedsSync(ids: ReadonlyArray<string>): void {
+function removeUnprocessedsSync(
+  db: Database,
+  ids: ReadonlyArray<string>
+): void {
   log.info('removeUnprocessedsSync', { totalIds: ids.length });
-  const db = getInstance();
-
   db.prepare<ArrayQuery>(
     `
     DELETE FROM unprocessed
@@ -4125,10 +4163,8 @@ function removeUnprocessedsSync(ids: ReadonlyArray<string>): void {
   ).run(ids);
 }
 
-function removeUnprocessedSync(id: string | Array<string>): void {
+function removeUnprocessedSync(db: Database, id: string | Array<string>): void {
   log.info('removeUnprocessedSync', { id });
-  const db = getInstance();
-
   if (!Array.isArray(id)) {
     prepare(db, 'DELETE FROM unprocessed WHERE id = $id;').run({ id });
 
@@ -4141,15 +4177,19 @@ function removeUnprocessedSync(id: string | Array<string>): void {
     return;
   }
 
-  assertSync(batchMultiVarQuery(db, id, removeUnprocessedsSync));
+  assertSync(
+    batchMultiVarQuery(db, id, batch => removeUnprocessedsSync(db, batch))
+  );
 }
 
 async function removeUnprocessed(id: string | Array<string>): Promise<void> {
-  removeUnprocessedSync(id);
+  const db = await getWritableInstance();
+
+  removeUnprocessedSync(db, id);
 }
 
 async function removeAllUnprocessed(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<EmptyQuery>('DELETE FROM unprocessed;').run();
 }
 
@@ -4159,13 +4199,13 @@ const ATTACHMENT_DOWNLOADS_TABLE = 'attachment_downloads';
 async function getAttachmentDownloadJobById(
   id: string
 ): Promise<AttachmentDownloadJobType | undefined> {
-  return getById(getInstance(), ATTACHMENT_DOWNLOADS_TABLE, id);
+  return getById(getReadonlyInstance(), ATTACHMENT_DOWNLOADS_TABLE, id);
 }
 async function getNextAttachmentDownloadJobs(
   limit?: number,
   options: { timestamp?: number } = {}
 ): Promise<Array<AttachmentDownloadJobType>> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const timestamp =
     options && options.timestamp ? options.timestamp : Date.now();
 
@@ -4195,7 +4235,7 @@ async function getNextAttachmentDownloadJobs(
             `JSON: '${row.json}' ` +
             `Error: ${Errors.toLogFormat(error)}`
         );
-        removeAttachmentDownloadJobSync(row.id);
+        removeAttachmentDownloadJobSync(db, row.id);
         throw new Error(INNER_ERROR);
       }
     });
@@ -4209,7 +4249,7 @@ async function getNextAttachmentDownloadJobs(
 async function saveAttachmentDownloadJob(
   job: AttachmentDownloadJobType
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const { id, pending, timestamp } = job;
   if (!id) {
     throw new Error(
@@ -4242,7 +4282,7 @@ async function setAttachmentDownloadJobPending(
   id: string,
   pending: boolean
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<Query>(
     `
     UPDATE attachment_downloads
@@ -4255,7 +4295,7 @@ async function setAttachmentDownloadJobPending(
   });
 }
 async function resetAttachmentDownloadPending(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<EmptyQuery>(
     `
     UPDATE attachment_downloads
@@ -4264,20 +4304,24 @@ async function resetAttachmentDownloadPending(): Promise<void> {
     `
   ).run();
 }
-function removeAttachmentDownloadJobSync(id: string): void {
-  return removeById(getInstance(), ATTACHMENT_DOWNLOADS_TABLE, id);
+function removeAttachmentDownloadJobSync(db: Database, id: string): void {
+  return removeById(db, ATTACHMENT_DOWNLOADS_TABLE, id);
 }
 async function removeAttachmentDownloadJob(id: string): Promise<void> {
-  return removeAttachmentDownloadJobSync(id);
+  const db = await getWritableInstance();
+  return removeAttachmentDownloadJobSync(db, id);
 }
 async function removeAllAttachmentDownloadJobs(): Promise<void> {
-  return removeAllFromTable(getInstance(), ATTACHMENT_DOWNLOADS_TABLE);
+  return removeAllFromTable(
+    await getWritableInstance(),
+    ATTACHMENT_DOWNLOADS_TABLE
+  );
 }
 
 // Stickers
 
 async function createOrUpdateStickerPack(pack: StickerPackType): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const {
     attemptedStatus,
     author,
@@ -4416,11 +4460,11 @@ async function createOrUpdateStickerPack(pack: StickerPackType): Promise<void> {
   ).run(payload);
 }
 function updateStickerPackStatusSync(
+  db: Database,
   id: string,
   status: StickerPackStatusType,
   options?: { timestamp: number }
 ): void {
-  const db = getInstance();
   const timestamp = options ? options.timestamp || Date.now() : Date.now();
   const installedAt = status === 'installed' ? timestamp : null;
 
@@ -4441,7 +4485,8 @@ async function updateStickerPackStatus(
   status: StickerPackStatusType,
   options?: { timestamp: number }
 ): Promise<void> {
-  return updateStickerPackStatusSync(id, status, options);
+  const db = await getWritableInstance();
+  return updateStickerPackStatusSync(db, id, status, options);
 }
 async function updateStickerPackInfo({
   id,
@@ -4451,7 +4496,7 @@ async function updateStickerPackInfo({
   storageNeedsSync,
   uninstalledAt,
 }: StickerPackInfoType): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   if (uninstalledAt) {
     db.prepare<Query>(
@@ -4492,7 +4537,7 @@ async function updateStickerPackInfo({
   }
 }
 async function clearAllErrorStickerPackAttempts(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.prepare<EmptyQuery>(
     `
@@ -4503,7 +4548,7 @@ async function clearAllErrorStickerPackAttempts(): Promise<void> {
   ).run();
 }
 async function createOrUpdateSticker(sticker: StickerType): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const { emoji, height, id, isCoverOnly, lastUsed, packId, path, width } =
     sticker;
 
@@ -4556,7 +4601,7 @@ async function updateStickerLastUsed(
   stickerId: number,
   lastUsed: number
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<Query>(
     `
     UPDATE stickers
@@ -4583,7 +4628,7 @@ async function addStickerPackReference(
   messageId: string,
   packId: string
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   if (!messageId) {
     throw new Error(
@@ -4615,7 +4660,7 @@ async function deleteStickerPackReference(
   messageId: string,
   packId: string
 ): Promise<ReadonlyArray<string> | undefined> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   if (!messageId) {
     throw new Error(
@@ -4707,7 +4752,7 @@ async function deleteStickerPackReference(
 }
 
 async function deleteStickerPack(packId: string): Promise<Array<string>> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   if (!packId) {
     throw new Error(
@@ -4748,10 +4793,10 @@ async function deleteStickerPack(packId: string): Promise<Array<string>> {
 }
 
 async function getStickerCount(): Promise<number> {
-  return getCountFromTable(getInstance(), 'stickers');
+  return getCountFromTable(getReadonlyInstance(), 'stickers');
 }
 async function getAllStickerPacks(): Promise<Array<StickerPackType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const rows = db
     .prepare<EmptyQuery>(
@@ -4772,9 +4817,10 @@ async function getAllStickerPacks(): Promise<Array<StickerPackType>> {
     };
   });
 }
-function addUninstalledStickerPackSync(pack: UninstalledStickerPackType): void {
-  const db = getInstance();
-
+function addUninstalledStickerPackSync(
+  db: Database,
+  pack: UninstalledStickerPackType
+): void {
   db.prepare<Query>(
     `
         INSERT OR REPLACE INTO uninstalled_sticker_packs
@@ -4800,22 +4846,22 @@ function addUninstalledStickerPackSync(pack: UninstalledStickerPackType): void {
 async function addUninstalledStickerPack(
   pack: UninstalledStickerPackType
 ): Promise<void> {
-  return addUninstalledStickerPackSync(pack);
+  const db = await getWritableInstance();
+  return addUninstalledStickerPackSync(db, pack);
 }
-function removeUninstalledStickerPackSync(packId: string): void {
-  const db = getInstance();
-
+function removeUninstalledStickerPackSync(db: Database, packId: string): void {
   db.prepare<Query>(
     'DELETE FROM uninstalled_sticker_packs WHERE id IS $id'
   ).run({ id: packId });
 }
 async function removeUninstalledStickerPack(packId: string): Promise<void> {
-  return removeUninstalledStickerPackSync(packId);
+  const db = await getWritableInstance();
+  return removeUninstalledStickerPackSync(db, packId);
 }
 async function getUninstalledStickerPacks(): Promise<
   Array<UninstalledStickerPackType>
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const rows = db
     .prepare<EmptyQuery>(
@@ -4826,7 +4872,7 @@ async function getUninstalledStickerPacks(): Promise<
   return rows || [];
 }
 async function getInstalledStickerPacks(): Promise<Array<StickerPackType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   // If sticker pack has a storageID - it is being downloaded and about to be
   // installed so we better sync it back to storage service if asked.
@@ -4848,7 +4894,7 @@ async function getInstalledStickerPacks(): Promise<Array<StickerPackType>> {
 async function getStickerPackInfo(
   packId: string
 ): Promise<StickerPackInfoType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   return db.transaction(() => {
     const uninstalled = db
@@ -4884,22 +4930,22 @@ async function installStickerPack(
   packId: string,
   timestamp: number
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   return db.transaction(() => {
     const status = 'installed';
-    updateStickerPackStatusSync(packId, status, { timestamp });
+    updateStickerPackStatusSync(db, packId, status, { timestamp });
 
-    removeUninstalledStickerPackSync(packId);
+    removeUninstalledStickerPackSync(db, packId);
   })();
 }
 async function uninstallStickerPack(
   packId: string,
   timestamp: number
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   return db.transaction(() => {
     const status = 'downloaded';
-    updateStickerPackStatusSync(packId, status);
+    updateStickerPackStatusSync(db, packId, status);
 
     db.prepare<Query>(
       `
@@ -4912,7 +4958,7 @@ async function uninstallStickerPack(
       `
     ).run({ packId });
 
-    addUninstalledStickerPackSync({
+    addUninstalledStickerPackSync(db, {
       id: packId,
       uninstalledAt: timestamp,
       storageNeedsSync: true,
@@ -4920,7 +4966,7 @@ async function uninstallStickerPack(
   })();
 }
 async function getAllStickers(): Promise<Array<StickerType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const rows = db
     .prepare<EmptyQuery>(
@@ -4936,7 +4982,7 @@ async function getAllStickers(): Promise<Array<StickerType>> {
 async function getRecentStickers({ limit }: { limit?: number } = {}): Promise<
   Array<StickerType>
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   // Note: we avoid 'IS NOT NULL' here because it does seem to bypass our index
   const rows = db
@@ -4961,7 +5007,7 @@ async function updateEmojiUsage(
   shortName: string,
   timeUsed: number = Date.now()
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     const rows = db
@@ -4995,7 +5041,7 @@ async function updateEmojiUsage(
 }
 
 async function getRecentEmojis(limit = 32): Promise<Array<EmojiType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows = db
     .prepare<Query>(
       `
@@ -5011,7 +5057,7 @@ async function getRecentEmojis(limit = 32): Promise<Array<EmojiType>> {
 }
 
 async function getAllBadges(): Promise<Array<BadgeType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const [badgeRows, badgeImageFileRows] = db.transaction(() => [
     db.prepare<EmptyQuery>('SELECT * FROM badges').all(),
@@ -5048,7 +5094,7 @@ async function getAllBadges(): Promise<Array<BadgeType>> {
 async function updateOrCreateBadges(
   badges: ReadonlyArray<BadgeType>
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   const insertBadge = prepare<Query>(
     db,
@@ -5127,7 +5173,7 @@ async function badgeImageFileDownloaded(
   url: string,
   localPath: string
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   prepare<Query>(
     db,
     'UPDATE badgeImageFiles SET localPath = $localPath WHERE url = $url'
@@ -5135,7 +5181,7 @@ async function badgeImageFileDownloaded(
 }
 
 async function getAllBadgeImageFileLocalPaths(): Promise<Set<string>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const localPaths = db
     .prepare<EmptyQuery>(
       'SELECT localPath FROM badgeImageFiles WHERE localPath IS NOT NULL'
@@ -5204,7 +5250,7 @@ function freezeStoryDistribution(
 async function _getAllStoryDistributions(): Promise<
   Array<StoryDistributionType>
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const storyDistributions = db
     .prepare<EmptyQuery>('SELECT * FROM storyDistributions;')
     .all();
@@ -5214,13 +5260,13 @@ async function _getAllStoryDistributions(): Promise<
 async function _getAllStoryDistributionMembers(): Promise<
   Array<StoryDistributionMemberType>
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   return db
     .prepare<EmptyQuery>('SELECT * FROM storyDistributionMembers;')
     .all();
 }
 async function _deleteAllStoryDistributions(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<EmptyQuery>('DELETE FROM storyDistributions;').run();
 }
 async function createNewStoryDistribution(
@@ -5231,7 +5277,7 @@ async function createNewStoryDistribution(
     'Distribution list does not have a valid name'
   );
 
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     const payload = freezeStoryDistribution(distribution);
@@ -5304,7 +5350,7 @@ async function getAllStoryDistributionsWithMembers(): Promise<
 async function getStoryDistributionWithMembers(
   id: string
 ): Promise<StoryDistributionWithMembersType | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const storyDistribution: StoryDistributionForDatabase | undefined = prepare(
     db,
     'SELECT * FROM storyDistributions WHERE id = $id;'
@@ -5411,7 +5457,7 @@ async function modifyStoryDistributionWithMembers(
   }: { toAdd: Array<ServiceIdString>; toRemove: Array<ServiceIdString> }
 ): Promise<void> {
   const payload = freezeStoryDistribution(distribution);
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   if (toAdd.length || toRemove.length) {
     db.transaction(() => {
@@ -5426,7 +5472,7 @@ async function modifyStoryDistribution(
   distribution: StoryDistributionType
 ): Promise<void> {
   const payload = freezeStoryDistribution(distribution);
-  const db = getInstance();
+  const db = await getWritableInstance();
   modifyStoryDistributionSync(db, payload);
 }
 async function modifyStoryDistributionMembers(
@@ -5436,7 +5482,7 @@ async function modifyStoryDistributionMembers(
     toRemove,
   }: { toAdd: Array<ServiceIdString>; toRemove: Array<ServiceIdString> }
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     modifyStoryDistributionMembersSync(db, listId, { toAdd, toRemove });
@@ -5445,22 +5491,22 @@ async function modifyStoryDistributionMembers(
 async function deleteStoryDistribution(
   id: StoryDistributionIdString
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<Query>('DELETE FROM storyDistributions WHERE id = $id;').run({
     id,
   });
 }
 
 async function _getAllStoryReads(): Promise<Array<StoryReadType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   return db.prepare<EmptyQuery>('SELECT * FROM storyReads;').all();
 }
 async function _deleteAllStoryReads(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   db.prepare<EmptyQuery>('DELETE FROM storyReads;').run();
 }
 async function addNewStoryRead(read: StoryReadType): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   prepare(
     db,
@@ -5490,7 +5536,7 @@ async function getLastStoryReadsForAuthor({
 }): Promise<Array<StoryReadType>> {
   const limit = initialLimit || 5;
 
-  const db = getInstance();
+  const db = getReadonlyInstance();
   return db
     .prepare<Query>(
       `
@@ -5512,7 +5558,7 @@ async function getLastStoryReadsForAuthor({
 async function countStoryReadsByConversation(
   conversationId: string
 ): Promise<number> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   return db
     .prepare<Query>(
       `
@@ -5526,7 +5572,7 @@ async function countStoryReadsByConversation(
 
 // All data in database
 async function removeAll(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     db.exec(`
@@ -5585,7 +5631,7 @@ async function removeAll(): Promise<void> {
 async function removeAllConfiguration(
   mode = RemoveAllConfiguration.Full
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     db.exec(
@@ -5633,7 +5679,7 @@ async function removeAllConfiguration(
 }
 
 async function eraseStorageServiceState(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.exec(`
     -- Conversations
@@ -5672,7 +5718,7 @@ async function getMessagesNeedingUpgrade(
   limit: number,
   { maxVersion }: { maxVersion: number }
 ): Promise<Array<MessageType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   const rows: JSONRows = db
     .prepare<Query>(
@@ -5701,7 +5747,7 @@ async function getMessagesWithVisualMediaAttachments(
   conversationId: string,
   { limit }: { limit: number }
 ): Promise<Array<MessageType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows: JSONRows = db
     .prepare<Query>(
       `
@@ -5730,7 +5776,7 @@ async function getMessagesWithFileAttachments(
   conversationId: string,
   { limit }: { limit: number }
 ): Promise<Array<MessageType>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const rows = db
     .prepare<Query>(
       `
@@ -5754,7 +5800,7 @@ async function getMessagesWithFileAttachments(
 async function getMessageServerGuidsForSpam(
   conversationId: string
 ): Promise<Array<string>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   // The server's maximum is 3, which is why you see `LIMIT 3` in this query. Note that we
   //   use `pluck` here to only get the first column!
@@ -5878,7 +5924,7 @@ function getExternalDraftFilesForConversation(
 async function getKnownMessageAttachments(
   cursor?: MessageAttachmentsCursorType
 ): Promise<GetKnownMessageAttachmentsResultType> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const result = new Set<string>();
   const chunkSize = 1000;
 
@@ -5971,7 +6017,7 @@ async function finishGetKnownMessageAttachments({
   count,
   done,
 }: MessageAttachmentsCursorType): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   const logId = `finishGetKnownMessageAttachments(${runId})`;
   if (!done) {
@@ -5987,7 +6033,7 @@ async function finishGetKnownMessageAttachments({
 }
 
 async function getKnownConversationAttachments(): Promise<Array<string>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const result = new Set<string>();
   const chunkSize = 500;
 
@@ -6038,7 +6084,7 @@ async function getKnownConversationAttachments(): Promise<Array<string>> {
 async function removeKnownStickers(
   allStickers: ReadonlyArray<string>
 ): Promise<Array<string>> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const lookup: Dictionary<boolean> = fromPairs(
     map(allStickers, file => [file, true])
   );
@@ -6089,7 +6135,7 @@ async function removeKnownStickers(
 async function removeKnownDraftAttachments(
   allStickers: ReadonlyArray<string>
 ): Promise<Array<string>> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   const lookup: Dictionary<boolean> = fromPairs(
     map(allStickers, file => [file, true])
   );
@@ -6147,7 +6193,7 @@ async function removeKnownDraftAttachments(
 }
 
 async function getJobsInQueue(queueType: string): Promise<Array<StoredJob>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   return getJobsInQueueSync(db, queueType);
 }
 
@@ -6190,12 +6236,12 @@ export function insertJobSync(db: Database, job: Readonly<StoredJob>): void {
 }
 
 async function insertJob(job: Readonly<StoredJob>): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
   return insertJobSync(db, job);
 }
 
 async function deleteJob(id: string): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.prepare<Query>('DELETE FROM jobs WHERE id = $id').run({ id });
 }
@@ -6203,7 +6249,7 @@ async function deleteJob(id: string): Promise<void> {
 async function wasGroupCallRingPreviouslyCanceled(
   ringId: bigint
 ): Promise<boolean> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   return db
     .prepare<Query>(
@@ -6223,7 +6269,7 @@ async function wasGroupCallRingPreviouslyCanceled(
 }
 
 async function processGroupCallRingCancellation(ringId: bigint): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.prepare<Query>(
     `
@@ -6239,7 +6285,7 @@ async function processGroupCallRingCancellation(ringId: bigint): Promise<void> {
 const MAX_GROUP_CALL_RING_AGE = 30 * durations.MINUTE;
 
 async function cleanExpiredGroupCallRingCancellations(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.prepare<Query>(
     `
@@ -6252,7 +6298,7 @@ async function cleanExpiredGroupCallRingCancellations(): Promise<void> {
 }
 
 async function getMaxMessageCounter(): Promise<number | undefined> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   return db
     .prepare<EmptyQuery>(
@@ -6271,7 +6317,7 @@ async function getMaxMessageCounter(): Promise<number | undefined> {
 }
 
 async function getStatisticsForLogging(): Promise<Record<string, string>> {
-  const db = getInstance();
+  const db = getReadonlyInstance();
   const counts = await pProps({
     messageCount: getMessageCount(),
     conversationCount: getConversationCount(),
@@ -6288,7 +6334,7 @@ async function updateAllConversationColors(
     value: CustomColorType;
   }
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.prepare<Query>(
     `
@@ -6305,7 +6351,7 @@ async function updateAllConversationColors(
 }
 
 async function removeAllProfileKeyCredentials(): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.exec(
     `
@@ -6321,11 +6367,11 @@ async function saveEditedMessage(
   ourAci: AciString,
   { conversationId, messageId, readStatus, sentAt }: EditedMessageType
 ): Promise<void> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   db.transaction(() => {
     assertSync(
-      saveMessageSync(mainMessage, {
+      saveMessageSync(db, mainMessage, {
         ourAci,
         alreadyInTransaction: true,
       })
@@ -6352,7 +6398,7 @@ async function saveEditedMessage(
 async function _getAllEditedMessages(): Promise<
   Array<{ messageId: string; sentAt: number }>
 > {
-  const db = getInstance();
+  const db = getReadonlyInstance();
 
   return db
     .prepare<Query>(
@@ -6370,7 +6416,7 @@ async function getUnreadEditedMessagesAndMarkRead({
   conversationId: string;
   newestUnreadAt: number;
 }): Promise<GetUnreadByConversationAndMarkReadResultType> {
-  const db = getInstance();
+  const db = await getWritableInstance();
 
   return db.transaction(() => {
     const [selectQuery, selectParams] = sql`