diff --git a/lib/Onyx.ts b/lib/Onyx.ts
index 98b9413c2..c41db3b0c 100644
--- a/lib/Onyx.ts
+++ b/lib/Onyx.ts
@@ -303,48 +303,43 @@ function merge<TKey extends OnyxKey>(key: TKey, changes: OnyxEntry<NullishDeep<K
 
         try {
             // We first only merge the changes, so we can provide these to the native implementation (SQLite uses only delta changes in "JSON_PATCH" to merge)
-            // We don't want to remove null values from the "batchedChanges", because SQLite uses them to remove keys from storage natively.
-            let batchedChanges = OnyxUtils.applyMerge(undefined, mergeQueue[key], false);
+            // We don't want to remove null values from the "batchedDeltaChanges", because SQLite uses them to remove keys from storage natively.
+            const batchedDeltaChanges = OnyxUtils.applyMerge(undefined, mergeQueue[key], false);
 
-            // The presence of a `null` in the merge queue instructs us to drop the existing value.
+            // Case (1): When there is no existing value in storage, we want to set the value instead of merge it.
+            // Case (2): The presence of a top-level `null` in the merge queue instructs us to drop the whole existing value.
             // In this case, we can't simply merge the batched changes with the existing value, because then the null in the merge queue would have no effect
-            const shouldOverwriteExistingValue = mergeQueue[key].includes(null);
+            const shouldSetValue = !existingValue || mergeQueue[key].includes(null);
 
             // Clean up the write queue, so we don't apply these changes again
             delete mergeQueue[key];
             delete mergeQueuePromise[key];
 
             // If the batched changes equal null, we want to remove the key from storage, to reduce storage size
-            const {wasRemoved} = OnyxUtils.removeNullValues(key, batchedChanges);
-
-            // After that we merge the batched changes with the existing value
-            // We can remove null values from the "modifiedData", because "null" implicates that the user wants to remove a value from storage.
-            // The "modifiedData" will be directly "set" in storage instead of being merged
-            const modifiedData = shouldOverwriteExistingValue ? batchedChanges : OnyxUtils.applyMerge(existingValue, [batchedChanges], true);
-
-            // On native platforms we use SQLite which utilises JSON_PATCH to merge changes.
-            // JSON_PATCH generally removes null values from the stored object.
-            // When there is no existing value though, SQLite will just insert the changes as a new value and thus the null values won't be removed.
-            // Therefore we need to remove null values from the `batchedChanges` which are sent to the SQLite, if no existing value is present.
-            if (!existingValue) {
-                batchedChanges = OnyxUtils.applyMerge(undefined, [batchedChanges], true);
-            }
+            const {wasRemoved} = OnyxUtils.removeNullValues(key, batchedDeltaChanges);
+
+            // For providers that can't handle delta changes, we need to merge the batched changes with the existing value beforehand.
+            // The "preMergedValue" will be directly "set" in storage instead of being merged
+            // Therefore we merge the batched changes with the existing value to get the final merged value that will be stored.
+            // We can remove null values from the "preMergedValue", because "null" implicates that the user wants to remove a value from storage.
+            const preMergedValue = OnyxUtils.applyMerge(shouldSetValue ? undefined : existingValue, [batchedDeltaChanges], true);
 
-            const hasChanged = cache.hasValueChanged(key, modifiedData);
+            // In cache, we don't want to remove the key if it's null to improve performance and speed up the next merge.
+            const hasChanged = cache.hasValueChanged(key, preMergedValue);
 
             // Logging properties only since values could be sensitive things we don't want to log
-            Logger.logInfo(`merge called for key: ${key}${_.isObject(batchedChanges) ? ` properties: ${_.keys(batchedChanges).join(',')}` : ''} hasChanged: ${hasChanged}`);
+            Logger.logInfo(`merge called for key: ${key}${_.isObject(batchedDeltaChanges) ? ` properties: ${_.keys(batchedDeltaChanges).join(',')}` : ''} hasChanged: ${hasChanged}`);
 
             // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-            const updatePromise = OnyxUtils.broadcastUpdate(key, modifiedData, hasChanged, wasRemoved);
+            const updatePromise = OnyxUtils.broadcastUpdate(key, preMergedValue, hasChanged, wasRemoved);
 
             // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
             if (!hasChanged || wasRemoved) {
                 return updatePromise;
             }
 
-            return Storage.mergeItem(key, batchedChanges, modifiedData).then(() => {
-                OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.MERGE, key, changes, modifiedData);
+            return Storage.mergeItem(key, batchedDeltaChanges, preMergedValue, shouldSetValue).then(() => {
+                OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.MERGE, key, changes, preMergedValue);
                 return updatePromise;
             });
         } catch (error) {
diff --git a/lib/storage/index.ts b/lib/storage/index.ts
index cf8c575bc..c9b797b10 100644
--- a/lib/storage/index.ts
+++ b/lib/storage/index.ts
@@ -114,9 +114,9 @@ const Storage: Storage = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem: (key, changes, modifiedData) =>
+    mergeItem: (key, deltaChanges, preMergedValue, shouldSetValue = false) =>
         tryOrDegradePerformance(() => {
-            const promise = provider.mergeItem(key, changes, modifiedData);
+            const promise = provider.mergeItem(key, deltaChanges, preMergedValue, shouldSetValue);
 
             if (shouldKeepInstancesSync) {
                 return promise.then(() => InstanceSync.mergeItem(key));
diff --git a/lib/storage/providers/IDBKeyValProvider.ts b/lib/storage/providers/IDBKeyValProvider.ts
index 3a385d228..f3539b500 100644
--- a/lib/storage/providers/IDBKeyValProvider.ts
+++ b/lib/storage/providers/IDBKeyValProvider.ts
@@ -40,9 +40,9 @@ const provider: StorageProvider = {
                 return Promise.all(upsertMany);
             });
         }),
-    mergeItem(key, _changes, modifiedData) {
+    mergeItem(key, _deltaChanges, preMergedValue) {
         // Since Onyx also merged the existing value with the changes, we can just set the value directly
-        return provider.setItem(key, modifiedData);
+        return provider.setItem(key, preMergedValue);
     },
     multiSet: (pairs) => setMany(pairs, idbKeyValStore),
     clear: () => clear(idbKeyValStore),
diff --git a/lib/storage/providers/MemoryOnlyProvider.ts b/lib/storage/providers/MemoryOnlyProvider.ts
index 74d9e3a84..00583a55a 100644
--- a/lib/storage/providers/MemoryOnlyProvider.ts
+++ b/lib/storage/providers/MemoryOnlyProvider.ts
@@ -78,9 +78,9 @@ const provider: StorageProvider = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem(key, _changes, modifiedData) {
+    mergeItem(key, _deltaChanges, preMergedValue) {
         // Since Onyx already merged the existing value with the changes, we can just set the value directly
-        return this.setItem(key, modifiedData);
+        return this.setItem(key, preMergedValue);
     },
 
     /**
diff --git a/lib/storage/providers/SQLiteProvider.ts b/lib/storage/providers/SQLiteProvider.ts
index ad5324ea9..461c4b8ca 100644
--- a/lib/storage/providers/SQLiteProvider.ts
+++ b/lib/storage/providers/SQLiteProvider.ts
@@ -76,8 +76,12 @@ const provider: StorageProvider = {
 
         return db.executeBatchAsync([[query, queryArguments]]);
     },
-    mergeItem(key, changes) {
-        return this.multiMerge([[key, changes]]) as Promise<BatchQueryResult>;
+    mergeItem(key, deltaChanges, preMergedValue, shouldSetValue) {
+        if (shouldSetValue) {
+            return this.setItem(key, preMergedValue) as Promise<BatchQueryResult>;
+        }
+
+        return this.multiMerge([[key, deltaChanges]]) as Promise<BatchQueryResult>;
     },
     getAllKeys: () =>
         db.executeAsync('SELECT record_key FROM keyvaluepairs;').then(({rows}) => {
diff --git a/lib/storage/providers/types.ts b/lib/storage/providers/types.ts
index 80cf88ba7..0161ecdae 100644
--- a/lib/storage/providers/types.ts
+++ b/lib/storage/providers/types.ts
@@ -43,10 +43,11 @@ type StorageProvider = {
 
     /**
      * Merges an existing value with a new one by leveraging JSON_PATCH
-     * @param changes - the delta for a specific key
-     * @param modifiedData - the pre-merged data from `Onyx.applyMerge`
+     * @param deltaChanges - the delta for a specific key
+     * @param preMergedValue - the pre-merged data from `Onyx.applyMerge`
+     * @param shouldSetValue - whether the data should be set instead of merged
      */
-    mergeItem: <TKey extends OnyxKey>(key: TKey, changes: OnyxValue<TKey>, modifiedData: OnyxValue<TKey>) => Promise<BatchQueryResult | void>;
+    mergeItem: <TKey extends OnyxKey>(key: TKey, deltaChanges: OnyxValue<TKey>, preMergedValue: OnyxValue<TKey>, shouldSetValue?: boolean) => Promise<BatchQueryResult | void>;
 
     /**
      * Returns all keys available in storage