diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell.ts
index 21e5cb3ce2..ba194b6687 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell.ts
@@ -6,7 +6,8 @@ import { v4 } from 'uuid';
 import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
 import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
 import { getObjectTypename } from '@/object-record/cache/utils/getObjectTypename';
-import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
+import { getRecordFromRecordNode } from '@/object-record/cache/utils/getRecordFromRecordNode';
+import { useCreateManyRecords } from '@/object-record/hooks/useCreateManyRecords';
 import { useDeleteOneRecord } from '@/object-record/hooks/useDeleteOneRecord';
 import { type FieldDefinition } from '@/object-record/record-field/ui/types/FieldDefinition';
 import {
@@ -56,11 +57,8 @@ export const useUpdateJunctionRelationFromCell = ({
     junctionObjectMetadata?.nameSingular ??
     fieldDefinition.metadata.relationObjectMetadataNameSingular;
 
-  // Skip the post-optimistic effect since we handle optimistic updates manually
-  // Otherwise Apollo would also add the record, resulting in duplicates
-  const { createOneRecord: createJunctionRecord } = useCreateOneRecord({
+  const { createManyRecords: createJunctionRecords } = useCreateManyRecords({
     objectNameSingular: junctionObjectNameSingular,
-    skipPostOptimisticEffect: true,
   });
 
   const { deleteOneRecord: deleteJunctionRecord } = useDeleteOneRecord({
@@ -175,11 +173,11 @@ export const useUpdateJunctionRelationFromCell = ({
         }
 
         const targetRecord = searchRecord.record;
-        const newJunctionId = v4();
+        const optimisticJunctionId = v4();
         const now = new Date().toISOString();
 
         const junctionRecordForStore = {
-          id: newJunctionId,
+          id: optimisticJunctionId,
           createdAt: now,
           updatedAt: now,
           __typename: getObjectTypename(junctionObjectName),
@@ -188,12 +186,6 @@ export const useUpdateJunctionRelationFromCell = ({
           [targetFieldName]: targetRecord,
         };
 
-        const newJunctionRecordForApi = {
-          id: newJunctionId,
-          [sourceJoinColumnName]: recordId,
-          [targetJoinColumnName]: morphItem.recordId,
-        };
-
         store.set(
           recordStoreFamilyState.atomFamily(recordId),
           (currentRecord: Record<string, unknown> | null | undefined) => {
@@ -213,12 +205,93 @@ export const useUpdateJunctionRelationFromCell = ({
           },
         );
 
-        await createJunctionRecord(newJunctionRecordForApi);
+        const removeOptimisticJunctionRecord = () =>
+          store.set(
+            recordStoreFamilyState.atomFamily(recordId),
+            (currentRecord: Record<string, unknown> | null | undefined) => {
+              if (!isDefined(currentRecord)) {
+                return currentRecord;
+              }
+
+              const currentFieldValue = currentRecord[fieldName];
+
+              return {
+                ...currentRecord,
+                [fieldName]: Array.isArray(currentFieldValue)
+                  ? currentFieldValue.filter(
+                      (junctionRecord) =>
+                        junctionRecord.id !== optimisticJunctionId,
+                    )
+                  : currentFieldValue,
+              } as ObjectRecord;
+            },
+          );
+
+        const persistedJunctionRecordNode = await createJunctionRecords({
+          recordsToCreate: [
+            {
+              [sourceJoinColumnName]: recordId,
+              [targetJoinColumnName]: morphItem.recordId,
+            },
+          ],
+          upsert: true,
+        })
+          .then(([createdJunctionRecordNode]) => createdJunctionRecordNode)
+          .catch((error: Error) => {
+            removeOptimisticJunctionRecord();
+
+            throw error;
+          });
+
+        if (!isDefined(persistedJunctionRecordNode)) {
+          removeOptimisticJunctionRecord();
+
+          return;
+        }
+
+        const persistedJunctionRecord = getRecordFromRecordNode({
+          recordNode: persistedJunctionRecordNode,
+        });
+
+        store.set(
+          recordStoreFamilyState.atomFamily(recordId),
+          (currentRecord: Record<string, unknown> | null | undefined) => {
+            if (!isDefined(currentRecord)) {
+              return currentRecord;
+            }
+
+            const currentFieldValue = currentRecord[fieldName];
+
+            if (!Array.isArray(currentFieldValue)) {
+              return currentRecord as ObjectRecord;
+            }
+
+            const junctionRecordsWithoutOptimistic = currentFieldValue.filter(
+              (junctionRecord) => junctionRecord.id !== optimisticJunctionId,
+            );
+
+            const isPersistedJunctionRecordAlreadyInStore =
+              junctionRecordsWithoutOptimistic.some(
+                (junctionRecord) =>
+                  junctionRecord.id === persistedJunctionRecord.id,
+              );
+
+            return {
+              ...currentRecord,
+              [fieldName]: isPersistedJunctionRecordAlreadyInStore
+                ? junctionRecordsWithoutOptimistic
+                : [
+                    ...junctionRecordsWithoutOptimistic,
+                    { ...junctionRecordForStore, ...persistedJunctionRecord },
+                  ],
+            } as ObjectRecord;
+          },
+        );
       }
     },
     [
       store,
-      createJunctionRecord,
+      createJunctionRecords,
       deleteJunctionRecord,
       fieldDefinition.metadata.fieldName,
       junctionConfig,
diff --git a/packages/twenty-server/test/integration/graphql/suites/upsert/upsert.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/upsert/upsert.integration-spec.ts
index 64c10acc2e..88d91d293d 100644
--- a/packages/twenty-server/test/integration/graphql/suites/upsert/upsert.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/upsert/upsert.integration-spec.ts
@@ -228,6 +228,50 @@ describe('upsert (createMany with upsert:true)', () => {
     );
   });
 
+  it('should restore a soft-deleted record matched on its unique fields only', async () => {
+    const createResponse = await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'softDeletedByUniqueFields',
+            secondUniqueTestField: 'softDeletedByUniqueFieldsSecond',
+            name: 'originalRecord',
+          },
+        ],
+        upsert: false,
+      },
+    });
+
+    const createdRecord = createResponse.body.data.createTestRecordObjects[0];
+
+    await makeGraphqlAPIRequest({
+      query: deleteRecordsQuery,
+      variables: {
+        filter: { id: { eq: createdRecord.id } },
+      },
+    });
+
+    const upsertResponse = await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'softDeletedByUniqueFields',
+            secondUniqueTestField: 'softDeletedByUniqueFieldsSecond',
+          },
+        ],
+        upsert: true,
+      },
+    });
+
+    const upsertedRecord = upsertResponse.body.data.createTestRecordObjects[0];
+
+    expect(upsertedRecord.id).toEqual(createdRecord.id);
+    expect(upsertedRecord.deletedAt).toBeNull();
+    expect(upsertedRecord.name).toEqual('originalRecord');
+  });
+
   it('should update and restore updated soft-deleted record', async () => {
     const createResponse = await makeGraphqlAPIRequest({
       query: createRecordsQuery,