diff --git a/lib/handlers/db-ops-handler.react.js b/lib/handlers/db-ops-handler.react.js
index d78985f00..504ea4bc6 100644
--- a/lib/handlers/db-ops-handler.react.js
+++ b/lib/handlers/db-ops-handler.react.js
@@ -1,41 +1,61 @@
 // @flow
 
 import * as React from 'react';
 
 import { opsProcessingFinishedActionType } from '../actions/db-ops-actions.js';
+import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js';
 import type { DBOpsEntry } from '../types/db-ops-types.js';
 import type { StoreOperations } from '../types/store-ops-types.js';
+import {
+  type MessageProcessed,
+  peerToPeerMessageTypes,
+} from '../types/tunnelbroker/peer-to-peer-message-types.js';
+import { getConfig } from '../utils/config.js';
 import { useDispatch, useSelector } from '../utils/redux-utils.js';
 
 type Props = {
   +processDBStoreOperations: StoreOperations => Promise<mixed>,
 };
 
 function DBOpsHandler(props: Props): React.Node {
+  const { sqliteAPI } = getConfig();
   const { processDBStoreOperations } = props;
   const queueFront = useSelector(state => state.dbOpsStore.queuedOps[0]);
   const prevQueueFront = React.useRef<?DBOpsEntry>(null);
+  const { sendMessage } = useTunnelbroker();
 
   const dispatch = useDispatch();
 
   React.useEffect(() => {
     if (!queueFront || prevQueueFront.current === queueFront) {
       return;
     }
     prevQueueFront.current = queueFront;
 
-    const ops = queueFront.ops;
+    const { ops, messageSourceMetadata } = queueFront;
     void (async () => {
       if (ops) {
         await processDBStoreOperations(ops);
       }
       dispatch({
         type: opsProcessingFinishedActionType,
       });
+      if (messageSourceMetadata) {
+        const { messageID, senderDeviceID } = messageSourceMetadata;
+        const message: MessageProcessed = {
+          type: peerToPeerMessageTypes.MESSAGE_PROCESSED,
+          messageID,
+        };
+        await sendMessage({
+          deviceID: senderDeviceID,
+          payload: JSON.stringify(message),
+        });
+        await sqliteAPI.removeReceivedMessagesToDevice([messageID]);
+      }
     })();
-  }, [queueFront, dispatch, processDBStoreOperations]);
+  }, [queueFront, dispatch, processDBStoreOperations, sendMessage, sqliteAPI]);
 
   return null;
 }
 
 export { DBOpsHandler };
diff --git a/lib/types/tunnelbroker/peer-to-peer-message-types.js b/lib/types/tunnelbroker/peer-to-peer-message-types.js
index abe44dd90..9833f2d96 100644
--- a/lib/types/tunnelbroker/peer-to-peer-message-types.js
+++ b/lib/types/tunnelbroker/peer-to-peer-message-types.js
@@ -1,103 +1,116 @@
 // @flow
 
 import type { TInterface, TUnion } from 'tcomb';
 import t from 'tcomb';
 
 import { tShape, tString } from '../../utils/validation-utils.js';
 import { type EncryptedData, encryptedDataValidator } from '../crypto-types.js';
 import {
   signedDeviceListValidator,
   type SignedDeviceList,
 } from '../identity-service-types.js';
 
 export type SenderInfo = {
   +userID: string,
   +deviceID: string,
 };
 const senderInfoValidator: TInterface<SenderInfo> = tShape<SenderInfo>({
   userID: t.String,
   deviceID: t.String,
 });
 
 export const peerToPeerMessageTypes = Object.freeze({
   OUTBOUND_SESSION_CREATION: 'OutboundSessionCreation',
   ENCRYPTED_MESSAGE: 'EncryptedMessage',
   REFRESH_KEY_REQUEST: 'RefreshKeyRequest',
   QR_CODE_AUTH_MESSAGE: 'QRCodeAuthMessage',
   DEVICE_LIST_UPDATED: 'DeviceListUpdated',
+  MESSAGE_PROCESSED: 'MessageProcessed',
 });
 
 export type OutboundSessionCreation = {
   +type: 'OutboundSessionCreation',
   +senderInfo: SenderInfo,
   +encryptedData: EncryptedData,
   +sessionVersion: number,
 };
 export const outboundSessionCreationValidator: TInterface<OutboundSessionCreation> =
   tShape<OutboundSessionCreation>({
     type: tString(peerToPeerMessageTypes.OUTBOUND_SESSION_CREATION),
     senderInfo: senderInfoValidator,
     encryptedData: encryptedDataValidator,
     sessionVersion: t.Number,
   });
 
 export type EncryptedMessage = {
   +type: 'EncryptedMessage',
   +senderInfo: SenderInfo,
   +encryptedData: EncryptedData,
 };
 export const encryptedMessageValidator: TInterface<EncryptedMessage> =
   tShape<EncryptedMessage>({
     type: tString(peerToPeerMessageTypes.ENCRYPTED_MESSAGE),
     senderInfo: senderInfoValidator,
     encryptedData: encryptedDataValidator,
   });
 
 export type RefreshKeyRequest = {
   +type: 'RefreshKeyRequest',
   +deviceID: string,
   +numberOfKeys: number,
 };
 export const refreshKeysRequestValidator: TInterface<RefreshKeyRequest> =
   tShape<RefreshKeyRequest>({
     type: tString(peerToPeerMessageTypes.REFRESH_KEY_REQUEST),
     deviceID: t.String,
     numberOfKeys: t.Number,
   });
 
 export type QRCodeAuthMessage = {
   +type: 'QRCodeAuthMessage',
   +encryptedContent: string,
 };
 export const qrCodeAuthMessageValidator: TInterface<QRCodeAuthMessage> =
   tShape<QRCodeAuthMessage>({
     type: tString(peerToPeerMessageTypes.QR_CODE_AUTH_MESSAGE),
     encryptedContent: t.String,
   });
 
 export type DeviceListUpdated = {
   +type: 'DeviceListUpdated',
   +userID: string,
   +signedDeviceList: SignedDeviceList,
 };
 export const deviceListUpdatedValidator: TInterface<DeviceListUpdated> =
   tShape<DeviceListUpdated>({
     type: tString(peerToPeerMessageTypes.DEVICE_LIST_UPDATED),
     userID: t.String,
     signedDeviceList: signedDeviceListValidator,
   });
 
+export type MessageProcessed = {
+  +type: 'MessageProcessed',
+  +messageID: string,
+};
+export const messageProcessedValidator: TInterface<MessageProcessed> =
+  tShape<MessageProcessed>({
+    type: tString(peerToPeerMessageTypes.MESSAGE_PROCESSED),
+    messageID: t.String,
+  });
+
 export type PeerToPeerMessage =
   | OutboundSessionCreation
   | EncryptedMessage
   | RefreshKeyRequest
   | QRCodeAuthMessage
-  | DeviceListUpdated;
+  | DeviceListUpdated
+  | MessageProcessed;
 
 export const peerToPeerMessageValidator: TUnion<PeerToPeerMessage> = t.union([
   outboundSessionCreationValidator,
   encryptedMessageValidator,
   refreshKeysRequestValidator,
   qrCodeAuthMessageValidator,
   deviceListUpdatedValidator,
+  messageProcessedValidator,
 ]);