diff --git a/hermes-console/json-server/db.json b/hermes-console/json-server/db.json
index 8c2720872d..23dab13ee0 100644
--- a/hermes-console/json-server/db.json
+++ b/hermes-console/json-server/db.json
@@ -91,6 +91,32 @@
       ]
     }
   ],
+  "inconsistentGroups3":[
+    {
+      "name": "pl.allegro.public.group",
+      "inconsistentMetadata": [],
+      "inconsistentTopics": [
+        {
+          "name": "pl.allegro.public.group.DummyEvent",
+          "inconsistentMetadata": [],
+          "inconsistentSubscriptions": [
+            {
+              "name": "pl.allegro.public.group.DummyEvent$foobar-service",
+              "inconsistentMetadata": [
+                {
+                  "datacenter": "DC1"
+                },
+                {
+                  "datacenter": "DC2",
+                  "content": "{\n  \"id\": \"foobar-service\",\n  \"topicName\": \"pl.allegro.public.group.DummyEvent\",\n  \"name\": \"foobar-service\",\n  \"endpoint\": \"service://foobar-service/events/dummy-event\",\n  \"state\": \"ACTIVE\",\n  \"description\": \"Test Hermes endpoint\",\n  \"subscriptionPolicy\": {\n    \"rate\": 10,\n    \"messageTtl\": 60,\n    \"messageBackoff\": 100,\n    \"requestTimeout\": 1000,\n    \"socketTimeout\": 0,\n    \"sendingDelay\": 0,\n    \"backoffMultiplier\": 1.0,\n    \"backoffMaxIntervalInSec\": 600,\n    \"retryClientErrors\": true,\n    \"backoffMaxIntervalMillis\": 600000\n  },\n  \"trackingEnabled\": false,\n  \"trackingMode\": \"trackingOff\",\n  \"owner\": {\n    \"source\": \"Service Catalog\",\n    \"id\": \"42\"\n  },\n  \"monitoringDetails\": {\n    \"severity\": \"NON_IMPORTANT\",\n    \"reaction\": \"\"\n  },\n  \"contentType\": \"JSON\",\n  \"deliveryType\": \"SERIAL\",\n  \"filters\": [\n    {\n      \"type\": \"avropath\",\n      \"path\": \"foobar\",\n      \"matcher\": \"^FOO_BAR$|^BAZ_BAR$\",\n      \"matchingStrategy\": \"any\"\n    },\n    {\n      \"type\": \"avropath\",\n      \"path\": \".foo.bar.baz\",\n      \"matcher\": \"true\",\n      \"matchingStrategy\": \"all\"\n    }\n  ],\n  \"mode\": \"ANYCAST\",\n  \"headers\": [\n    {\n      \"name\": \"X-My-Header\",\n      \"value\": \"boobar\"\n    },\n    {\n      \"name\": \"X-Another-Header\",\n      \"value\": \"foobar\"\n    }\n  ],\n  \"endpointAddressResolverMetadata\": {\n    \"additionalMetadata\": false,\n    \"nonSupportedProperty\": 2\n  },\n  \"http2Enabled\": false,\n  \"subscriptionIdentityHeadersEnabled\": false,\n  \"autoDeleteWithTopicEnabled\": false,\n  \"createdAt\": 1579507131.238,\n  \"modifiedAt\": 1672140855.813\n}"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ],
   "topicNames": [
     "pl.allegro.public.offer.product.ProductEventV1",
     "pl.allegro.public.offer.product.ProductEventV2",
diff --git a/hermes-console/json-server/routes.json b/hermes-console/json-server/routes.json
index eb0b5ae948..0a741b6490 100644
--- a/hermes-console/json-server/routes.json
+++ b/hermes-console/json-server/routes.json
@@ -3,6 +3,7 @@
   "/consistency/groups": "/consistencyGroups",
   "/consistency/inconsistencies/groups?groupNames=pl.allegro.public.offer*": "/inconsistentGroups",
   "/consistency/inconsistencies/groups?groupNames=pl.allegro.public.group2*": "/inconsistentGroups2",
+  "/consistency/inconsistencies/groups?groupNames=pl.allegro.public.group": "/inconsistentGroups3",
   "/groups": "/groups",
   "/owners/sources/Service%20Catalog/:id": "/topicsOwners/:id",
   "/readiness/datacenters": "/readinessDatacenters",
diff --git a/hermes-console/json-server/server.ts b/hermes-console/json-server/server.ts
index 6c1daab3d7..0a47cb6361 100644
--- a/hermes-console/json-server/server.ts
+++ b/hermes-console/json-server/server.ts
@@ -87,6 +87,22 @@ server.put(
   },
 );
 
+server.post(
+  '/consistency/sync/topics/pl.allegro.public.group.DummyEvent/subscriptions/barbaz-service*',
+  (req, res) => {
+    res.sendStatus(200);
+  },
+);
+
+server.post(
+  '/consistency/sync/topics/pl.allegro.public.group.DummyEvent*',
+  (req, res) => {
+    res.status(404).jsonp({
+      message: 'Group pl.allegro.public.group not found',
+    });
+  },
+);
+
 server.post('/filters/:topic', (req, res) => {
   res.jsonp(filterDebug);
 });
diff --git a/hermes-console/src/api/hermes-client/index.ts b/hermes-console/src/api/hermes-client/index.ts
index 4c4f6f89a4..23b7ca55ef 100644
--- a/hermes-console/src/api/hermes-client/index.ts
+++ b/hermes-console/src/api/hermes-client/index.ts
@@ -464,3 +464,45 @@ export function verifyFilters(
     },
   );
 }
+
+export function syncGroup(
+  groupName: string,
+  primaryDatacenter: string,
+): ResponsePromise<void> {
+  return axios.post<void>(`/consistency/sync/groups/${groupName}`, null, {
+    params: {
+      primaryDatacenter: primaryDatacenter,
+    },
+  });
+}
+
+export function syncTopic(
+  topicQualifiedName: string,
+  primaryDatacenter: string,
+): ResponsePromise<void> {
+  return axios.post<void>(
+    `/consistency/sync/topics/${topicQualifiedName}`,
+    null,
+    {
+      params: {
+        primaryDatacenter: primaryDatacenter,
+      },
+    },
+  );
+}
+
+export function syncSubscription(
+  topicQualifiedName: string,
+  subscriptionName: string,
+  primaryDatacenter: string,
+): ResponsePromise<void> {
+  return axios.post<void>(
+    `/consistency/sync/topics/${topicQualifiedName}/subscriptions/${subscriptionName}`,
+    null,
+    {
+      params: {
+        primaryDatacenter: primaryDatacenter,
+      },
+    },
+  );
+}
diff --git a/hermes-console/src/composables/sync/use-sync/useSync.spec.ts b/hermes-console/src/composables/sync/use-sync/useSync.spec.ts
new file mode 100644
index 0000000000..e9c57240e4
--- /dev/null
+++ b/hermes-console/src/composables/sync/use-sync/useSync.spec.ts
@@ -0,0 +1,175 @@
+import { afterEach, describe, expect } from 'vitest';
+import { createTestingPinia } from '@pinia/testing';
+import {
+  expectNotificationDispatched,
+  notificationStoreSpy,
+} from '@/utils/test-utils';
+import { setActivePinia } from 'pinia';
+import { setupServer } from 'msw/node';
+import {
+  syncGroupHandler,
+  syncSubscriptionHandler,
+  syncTopicHandler,
+} from '@/mocks/handlers';
+import { useSync } from '@/composables/sync/use-sync/useSync';
+import { waitFor } from '@testing-library/vue';
+
+describe('useSync', () => {
+  const server = setupServer();
+
+  const pinia = createTestingPinia({
+    fakeApp: true,
+  });
+
+  beforeEach(() => {
+    setActivePinia(pinia);
+  });
+
+  afterEach(() => {
+    server.resetHandlers();
+  });
+
+  it('should show error notification when group sync fails', async () => {
+    // given
+    const groupName = 'group';
+    server.use(syncGroupHandler({ groupName, statusCode: 500 }));
+    server.listen();
+
+    const notificationStore = notificationStoreSpy();
+
+    // when
+    const { syncGroup } = useSync();
+    const result = await syncGroup(groupName, 'DC1');
+
+    // then
+    expect(result).toBeFalsy();
+
+    await waitFor(() => {
+      expectNotificationDispatched(notificationStore, {
+        type: 'error',
+        title: 'notifications.consistency.sync.failure',
+      });
+    });
+  });
+
+  it('should show error notification when topic sync fails', async () => {
+    // given
+    const topicName = 'group.topic';
+    server.use(syncTopicHandler({ topicName, statusCode: 500 }));
+    server.listen();
+
+    const notificationStore = notificationStoreSpy();
+
+    // when
+    const { syncTopic } = useSync();
+    const result = await syncTopic(topicName, 'DC1');
+
+    // then
+    expect(result).toBeFalsy();
+
+    await waitFor(() => {
+      expectNotificationDispatched(notificationStore, {
+        type: 'error',
+        title: 'notifications.consistency.sync.failure',
+      });
+    });
+  });
+
+  it('should show error notification when subscription sync fails', async () => {
+    // given
+    const topicName = 'group.topic';
+    const subscriptionName = 'subscription';
+    server.use(
+      syncSubscriptionHandler({ topicName, subscriptionName, statusCode: 500 }),
+    );
+    server.listen();
+
+    const notificationStore = notificationStoreSpy();
+
+    // when
+    const { syncSubscription } = useSync();
+    const result = await syncSubscription(topicName, subscriptionName, 'DC1');
+
+    // then
+    expect(result).toBeFalsy();
+
+    await waitFor(() => {
+      expectNotificationDispatched(notificationStore, {
+        type: 'error',
+        title: 'notifications.consistency.sync.failure',
+      });
+    });
+  });
+
+  it('should show success notification when group sync is successful', async () => {
+    const groupName = 'group';
+
+    server.use(syncGroupHandler({ groupName, statusCode: 200 }));
+    server.listen();
+
+    const notificationStore = notificationStoreSpy();
+
+    // when
+    const { syncGroup } = useSync();
+    const result = await syncGroup(groupName, 'DC1');
+
+    // then
+    expect(result).toBeTruthy();
+
+    await waitFor(() => {
+      expectNotificationDispatched(notificationStore, {
+        type: 'success',
+        text: 'notifications.consistency.sync.success',
+      });
+    });
+  });
+
+  it('should show success notification when topic sync is successful', async () => {
+    // given
+    const topicName = 'group.topic';
+    server.use(syncTopicHandler({ topicName, statusCode: 200 }));
+    server.listen();
+
+    const notificationStore = notificationStoreSpy();
+
+    // when
+    const { syncTopic } = useSync();
+    const result = await syncTopic(topicName, 'DC1');
+
+    // then
+    expect(result).toBeTruthy();
+
+    await waitFor(() => {
+      expectNotificationDispatched(notificationStore, {
+        type: 'success',
+        text: 'notifications.consistency.sync.success',
+      });
+    });
+  });
+
+  it('should show success notification when subscription sync is successful', async () => {
+    // given
+    const topicName = 'group.topic';
+    const subscriptionName = 'subscription';
+    server.use(
+      syncSubscriptionHandler({ topicName, subscriptionName, statusCode: 200 }),
+    );
+    server.listen();
+
+    const notificationStore = notificationStoreSpy();
+
+    // when
+    const { syncSubscription } = useSync();
+    const result = await syncSubscription(topicName, subscriptionName, 'DC1');
+
+    // then
+    expect(result).toBeTruthy();
+
+    await waitFor(() => {
+      expectNotificationDispatched(notificationStore, {
+        type: 'success',
+        text: 'notifications.consistency.sync.success',
+      });
+    });
+  });
+});
diff --git a/hermes-console/src/composables/sync/use-sync/useSync.ts b/hermes-console/src/composables/sync/use-sync/useSync.ts
new file mode 100644
index 0000000000..ff6ed46f9e
--- /dev/null
+++ b/hermes-console/src/composables/sync/use-sync/useSync.ts
@@ -0,0 +1,116 @@
+import { dispatchErrorNotification } from '@/utils/notification-utils';
+import {
+  syncGroup as doSyncGroup,
+  syncSubscription as doSyncSubscription,
+  syncTopic as doSyncTopic,
+} from '@/api/hermes-client';
+import { groupName } from '@/utils/topic-utils/topic-utils';
+import { useConsistencyStore } from '@/store/consistency/useConsistencyStore';
+import { useGlobalI18n } from '@/i18n';
+import { useNotificationsStore } from '@/store/app-notifications/useAppNotifications';
+
+export interface UseSync {
+  syncGroup: (groupName: string, primaryDatacenter: string) => Promise<boolean>;
+  syncTopic: (
+    topicQualifiedName: string,
+    primaryDatacenter: string,
+  ) => Promise<boolean>;
+  syncSubscription: (
+    topicQualifiedName: string,
+    subscriptionName: string,
+    primaryDatacenter: string,
+  ) => Promise<boolean>;
+}
+
+export function useSync(): UseSync {
+  const notificationStore = useNotificationsStore();
+  const consistencyStore = useConsistencyStore();
+
+  const syncGroup = async (groupName: string, primaryDatacenter: string) => {
+    try {
+      await doSyncGroup(groupName, primaryDatacenter);
+      await notificationStore.dispatchNotification({
+        text: useGlobalI18n().t('notifications.consistency.sync.success', {
+          group: groupName,
+        }),
+        type: 'success',
+      });
+      await consistencyStore.refresh(groupName);
+      return true;
+    } catch (e: any) {
+      dispatchErrorNotification(
+        e,
+        notificationStore,
+        useGlobalI18n().t('notifications.consistency.sync.failure', {
+          group: groupName,
+        }),
+      );
+      return false;
+    }
+  };
+
+  const syncTopic = async (
+    topicQualifiedName: string,
+    primaryDatacenter: string,
+  ) => {
+    const group = groupName(topicQualifiedName);
+    try {
+      await doSyncTopic(topicQualifiedName, primaryDatacenter);
+      await notificationStore.dispatchNotification({
+        text: useGlobalI18n().t('notifications.consistency.sync.success', {
+          group,
+        }),
+        type: 'success',
+      });
+      await consistencyStore.refresh(group);
+      return true;
+    } catch (e: any) {
+      dispatchErrorNotification(
+        e,
+        notificationStore,
+        useGlobalI18n().t('notifications.consistency.sync.failure', {
+          group,
+        }),
+      );
+      return false;
+    }
+  };
+
+  const syncSubscription = async (
+    topicQualifiedName: string,
+    subscriptionName: string,
+    primaryDatacenter: string,
+  ) => {
+    const group = groupName(topicQualifiedName);
+    try {
+      await doSyncSubscription(
+        topicQualifiedName,
+        subscriptionName,
+        primaryDatacenter,
+      );
+      await notificationStore.dispatchNotification({
+        text: useGlobalI18n().t('notifications.consistency.sync.success', {
+          group,
+        }),
+        type: 'success',
+      });
+      await consistencyStore.refresh(group);
+      return true;
+    } catch (e: any) {
+      dispatchErrorNotification(
+        e,
+        notificationStore,
+        useGlobalI18n().t('notifications.consistency.sync.failure', {
+          group,
+        }),
+      );
+      return false;
+    }
+  };
+
+  return {
+    syncGroup,
+    syncSubscription,
+    syncTopic,
+  };
+}
diff --git a/hermes-console/src/dummy/groupInconsistency.ts b/hermes-console/src/dummy/groupInconsistency.ts
index ae114b1938..2e06da4fc7 100644
--- a/hermes-console/src/dummy/groupInconsistency.ts
+++ b/hermes-console/src/dummy/groupInconsistency.ts
@@ -58,3 +58,34 @@ export const dummyGroupInconsistency3: InconsistentGroup[] = [
     inconsistentTopics: [],
   },
 ];
+
+export const dummyGroupInconsistency4: InconsistentGroup[] = [
+  {
+    name: 'pl.allegro.public.group',
+    inconsistentMetadata: [
+      {
+        datacenter: 'DC1',
+        content: '{"lorem": "ipsum"}',
+      },
+      {
+        datacenter: 'DC2',
+        content: '{"lorem": "ipsum"}',
+      },
+    ],
+    inconsistentTopics: [],
+  },
+  {
+    name: 'pl.allegro.public.group2',
+    inconsistentMetadata: [
+      {
+        datacenter: 'DC1',
+        content: '{"lorem": "ipsum"}',
+      },
+      {
+        datacenter: 'DC2',
+        content: '{"lorem": "ipsum"}',
+      },
+    ],
+    inconsistentTopics: [],
+  },
+];
diff --git a/hermes-console/src/i18n/en-US/index.ts b/hermes-console/src/i18n/en-US/index.ts
index 37ce1b5b14..01ec3f08b8 100644
--- a/hermes-console/src/i18n/en-US/index.ts
+++ b/hermes-console/src/i18n/en-US/index.ts
@@ -47,6 +47,12 @@ const en_US = {
     confirmText: "Type 'prod' to confirm action.",
   },
   consistency: {
+    sync: {
+      header: 'Sync datacenters',
+      explanation:
+        'Pick DC which contains correct data. Data from that DC will be propagated to other DCs.',
+      cta: 'Correct data is in DC:',
+    },
     connectionError: {
       title: 'Connection error',
       text: 'Could not fetch information about consistency',
@@ -708,6 +714,12 @@ const en_US = {
         failure: "Couldn't delete topic {topic}",
       },
     },
+    consistency: {
+      sync: {
+        success: 'Synchronization of {group} succeeded',
+        failure: 'Synchronization of {group} failed',
+      },
+    },
     subscription: {
       create: {
         success: 'Subscription {subscriptionName} successfully created',
diff --git a/hermes-console/src/mocks/handlers.ts b/hermes-console/src/mocks/handlers.ts
index d2eceac040..ebcccbb847 100644
--- a/hermes-console/src/mocks/handlers.ts
+++ b/hermes-console/src/mocks/handlers.ts
@@ -975,3 +975,47 @@ export const subscriptionFilterVerificationErrorHandler = ({
       status: 500,
     });
   });
+
+export const syncGroupHandler = ({
+  groupName,
+  statusCode,
+}: {
+  groupName: string;
+  statusCode: number;
+}) =>
+  http.post(`${url}/consistency/sync/groups/${groupName}`, () => {
+    return new HttpResponse(undefined, {
+      status: statusCode,
+    });
+  });
+
+export const syncTopicHandler = ({
+  topicName,
+  statusCode,
+}: {
+  topicName: string;
+  statusCode: number;
+}) =>
+  http.post(`${url}/consistency/sync/topics/${topicName}`, () => {
+    return new HttpResponse(undefined, {
+      status: statusCode,
+    });
+  });
+
+export const syncSubscriptionHandler = ({
+  topicName,
+  statusCode,
+  subscriptionName,
+}: {
+  topicName: string;
+  subscriptionName: string;
+  statusCode: number;
+}) =>
+  http.post(
+    `${url}/consistency/sync/topics/${topicName}/subscriptions/${subscriptionName}`,
+    () => {
+      return new HttpResponse(undefined, {
+        status: statusCode,
+      });
+    },
+  );
diff --git a/hermes-console/src/store/consistency/useConsistencyStore.spec.ts b/hermes-console/src/store/consistency/useConsistencyStore.spec.ts
index bb5e1b73d1..52dd62e082 100644
--- a/hermes-console/src/store/consistency/useConsistencyStore.spec.ts
+++ b/hermes-console/src/store/consistency/useConsistencyStore.spec.ts
@@ -1,6 +1,10 @@
 import { beforeEach, describe, expect } from 'vitest';
 import { createPinia, setActivePinia } from 'pinia';
-import { dummyGroupInconsistency } from '@/dummy/groupInconsistency';
+import {
+  dummyGroupInconsistency,
+  dummyGroupInconsistency2,
+  dummyGroupInconsistency4,
+} from '@/dummy/groupInconsistency';
 import { dummyInconsistentGroups } from '@/dummy/inconsistentGroups';
 import {
   fetchConsistencyGroupsErrorHandler,
@@ -86,4 +90,41 @@ describe('useConsistencyStore', () => {
 
     expect(consistencyStore.error.fetchError).not.toBeNull();
   });
+
+  it('should remove group from store when refresh returns that it is consistent', async () => {
+    // given
+    server.use(fetchGroupInconsistenciesHandler({ groupsInconsistency: [] }));
+    server.listen();
+    const consistencyStore = useConsistencyStore();
+    consistencyStore.groups = dummyGroupInconsistency4;
+    // make a copy of initial state
+    const expected = JSON.parse(JSON.stringify(dummyGroupInconsistency4[1]));
+
+    // when
+    await consistencyStore.refresh(dummyGroupInconsistency4[0].name);
+
+    // then
+    expect(consistencyStore.groups.length).toEqual(1);
+    expect(consistencyStore.groups[0]).toEqual(expected);
+  });
+
+  it('should update group in store when refresh returns different value', async () => {
+    // given
+    server.use(
+      fetchGroupInconsistenciesHandler({
+        groupsInconsistency: dummyGroupInconsistency2,
+      }),
+    );
+    server.listen();
+    const consistencyStore = useConsistencyStore();
+    consistencyStore.groups = dummyGroupInconsistency;
+    // make a copy of initial state
+
+    // when
+    await consistencyStore.refresh(dummyGroupInconsistency[0].name);
+
+    // then
+    expect(consistencyStore.groups.length).toEqual(1);
+    expect(consistencyStore.groups).toEqual(dummyGroupInconsistency2);
+  });
 });
diff --git a/hermes-console/src/store/consistency/useConsistencyStore.ts b/hermes-console/src/store/consistency/useConsistencyStore.ts
index 1d18182c20..3a6bbf4a52 100644
--- a/hermes-console/src/store/consistency/useConsistencyStore.ts
+++ b/hermes-console/src/store/consistency/useConsistencyStore.ts
@@ -52,6 +52,29 @@ export const useConsistencyStore = defineStore('consistency', {
         this.fetchInProgress = false;
       }
     },
+    async refresh(group: string) {
+      this.fetchInProgress = true;
+      try {
+        const refreshedGroup = (await fetchInconsistentGroups([group])).data;
+        let groupIndex = -1;
+        for (let i = 0; i < this.groups.length; i++) {
+          if (this.groups[i].name == group) {
+            groupIndex = i;
+            break;
+          }
+        }
+        if (groupIndex == -1) return;
+        if (refreshedGroup.length == 0) {
+          this.groups.splice(groupIndex, 1);
+        } else {
+          this.groups[groupIndex] = refreshedGroup[0];
+        }
+      } catch (e) {
+        this.error.fetchError = e as Error;
+      } finally {
+        this.fetchInProgress = false;
+      }
+    },
   },
   getters: {
     group(
diff --git a/hermes-console/src/views/admin/consistency/inconsistent-group/InconsistentGroup.vue b/hermes-console/src/views/admin/consistency/inconsistent-group/InconsistentGroup.vue
index 8352004610..56c7b25696 100644
--- a/hermes-console/src/views/admin/consistency/inconsistent-group/InconsistentGroup.vue
+++ b/hermes-console/src/views/admin/consistency/inconsistent-group/InconsistentGroup.vue
@@ -2,6 +2,7 @@
   import { useConsistencyStore } from '@/store/consistency/useConsistencyStore';
   import { useI18n } from 'vue-i18n';
   import { useRouter } from 'vue-router';
+  import { useSync } from '@/composables/sync/use-sync/useSync';
   import InconsistentMetadata from '@/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.vue';
 
   const router = useRouter();
@@ -13,6 +14,7 @@
   >;
 
   const consistencyStore = useConsistencyStore();
+  const { syncGroup } = useSync();
 
   const group = consistencyStore.group(groupId);
 
@@ -33,6 +35,13 @@
       title: groupId,
     },
   ];
+
+  async function sync(datacenter: string) {
+    const succeeded = await syncGroup(groupId, datacenter);
+    if (succeeded) {
+      router.push('/ui/consistency');
+    }
+  }
 </script>
 
 <template>
@@ -52,6 +61,7 @@
     <InconsistentMetadata
       :metadata="group.inconsistentMetadata"
       v-if="group"
+      @sync="sync"
       class="mt-8"
     ></InconsistentMetadata>
     <v-card
diff --git a/hermes-console/src/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.spec.ts b/hermes-console/src/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.spec.ts
index 797360fc80..16a723fe1b 100644
--- a/hermes-console/src/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.spec.ts
+++ b/hermes-console/src/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.spec.ts
@@ -1,9 +1,16 @@
-import { describe, expect } from 'vitest';
+import { beforeEach, describe, expect } from 'vitest';
+import { createPinia, setActivePinia } from 'pinia';
 import { inconsistentMetadata } from '@/dummy/inconsistentMetadata';
-import { render } from '@/utils/test-utils';
+import { render, renderWithEmits } from '@/utils/test-utils';
+import { waitFor } from '@testing-library/vue';
 import InconsistentMetadata from '@/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.vue';
+import router from '@/router';
 
 describe('InconsistentMetadataView', () => {
+  beforeEach(async () => {
+    setActivePinia(createPinia());
+  });
+
   it('should render metadata inconsistencies', () => {
     // when
     const { getByText } = render(InconsistentMetadata, {
@@ -31,4 +38,24 @@ describe('InconsistentMetadataView', () => {
       getByText('consistency.inconsistentGroup.metadata.consistent'),
     ).toBeVisible();
   });
+
+  it('should emit event with selected datacenter when sync button is clicked', async () => {
+    const group = 'pl.allegro.public.group';
+    await router.push(`/ui/consistency/${group}`);
+
+    const wrapper = renderWithEmits(InconsistentMetadata, {
+      props: {
+        metadata: inconsistentMetadata,
+      },
+    });
+
+    const buttonId = `sync-datacenter-${inconsistentMetadata[0].datacenter}`;
+    await wrapper.find(`[data-testid="${buttonId}"]`).trigger('click');
+
+    await waitFor(() => {
+      const syncEvents = wrapper.emitted('sync')!!;
+      expect(syncEvents.length).toEqual(1);
+      expect(syncEvents[0]).toEqual([inconsistentMetadata[0].datacenter]);
+    });
+  });
 });
diff --git a/hermes-console/src/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.vue b/hermes-console/src/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.vue
index 99d6e721d3..66519c1b95 100644
--- a/hermes-console/src/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.vue
+++ b/hermes-console/src/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.vue
@@ -8,6 +8,10 @@
 
   const { t } = useI18n();
 
+  const emit = defineEmits<{
+    sync: [datacenter: string];
+  }>();
+
   const prettyJson = (jsonString: string | undefined): string => {
     if (jsonString === undefined) {
       return 'null';
@@ -15,6 +19,10 @@
       return JSON.parse(jsonString);
     }
   };
+
+  function sync(datacenter: string) {
+    emit('sync', datacenter);
+  }
 </script>
 
 <template>
@@ -40,6 +48,24 @@
         </tr>
       </tbody>
     </v-table>
+    <v-card-text>
+      <p class="text-h5">{{ $t('consistency.sync.header') }}</p>
+      <p class="text-subtitle-1 mt-2">
+        {{ $t('consistency.sync.explanation') }}
+      </p>
+    </v-card-text>
+    <v-card-actions>
+      <p class="text mt-2 mr-4 ml-2">{{ $t('consistency.sync.cta') }}</p>
+      <v-btn
+        class="bg-primary"
+        v-for="meta in metadata"
+        @click="sync(meta.datacenter)"
+        :key="meta.datacenter"
+        :data-testid="`sync-datacenter-${meta.datacenter}`"
+      >
+        {{ meta.datacenter }}
+      </v-btn>
+    </v-card-actions>
   </v-card>
   <v-banner
     v-else
diff --git a/hermes-console/src/views/admin/consistency/inconsistent-topic/InconsistentTopic.vue b/hermes-console/src/views/admin/consistency/inconsistent-topic/InconsistentTopic.vue
index c7da46468c..814cef6d4b 100644
--- a/hermes-console/src/views/admin/consistency/inconsistent-topic/InconsistentTopic.vue
+++ b/hermes-console/src/views/admin/consistency/inconsistent-topic/InconsistentTopic.vue
@@ -1,15 +1,19 @@
 <script setup lang="ts">
+  import { parseSubscriptionFqn } from '@/utils/subscription-utils/subscription-utils';
   import { useConsistencyStore } from '@/store/consistency/useConsistencyStore';
   import { useI18n } from 'vue-i18n';
-  import { useRoute } from 'vue-router';
+  import { useRoute, useRouter } from 'vue-router';
+  import { useSync } from '@/composables/sync/use-sync/useSync';
   import InconsistentMetadata from '@/views/admin/consistency/inconsistent-metadata/InconsistentMetadata.vue';
 
+  const router = useRouter();
   const route = useRoute();
   const { t } = useI18n();
 
   const { groupId, topicId } = route.params as Record<string, string>;
 
   const consistencyStore = useConsistencyStore();
+  const { syncTopic, syncSubscription } = useSync();
 
   const topic = consistencyStore.topic(groupId, topicId);
 
@@ -31,6 +35,28 @@
       href: `/ui/consistency/${groupId}/topics/${topicId}`,
     },
   ];
+
+  async function doSyncTopic(datacenter: string) {
+    const succeeded = await syncTopic(topicId, datacenter);
+    if (succeeded) {
+      router.push('/ui/consistency');
+    }
+  }
+
+  async function doSyncSubscription(
+    subscriptionQualifiedName: string,
+    datacenter: string,
+  ) {
+    const subscriptionName = parseSubscriptionFqn(subscriptionQualifiedName);
+    const succeeded = await syncSubscription(
+      subscriptionName.topicName,
+      subscriptionName.subscriptionName,
+      datacenter,
+    );
+    if (succeeded) {
+      router.push('/ui/consistency');
+    }
+  }
 </script>
 
 <template>
@@ -55,6 +81,7 @@
       :metadata="topic.inconsistentMetadata"
       v-if="topic"
       class="mt-8"
+      @sync="doSyncTopic"
     ></InconsistentMetadata>
 
     <v-card
@@ -77,6 +104,7 @@
           <v-expansion-panel-text>
             <InconsistentMetadata
               :metadata="subscription.inconsistentMetadata"
+              @sync="(dc) => doSyncSubscription(subscription.name, dc)"
             ></InconsistentMetadata>
           </v-expansion-panel-text>
         </v-expansion-panel>
diff --git a/hermes-management/src/main/java/pl/allegro/tech/hermes/management/api/ConsistencyEndpoint.java b/hermes-management/src/main/java/pl/allegro/tech/hermes/management/api/ConsistencyEndpoint.java
index bb835b5112..5da9a9593a 100644
--- a/hermes-management/src/main/java/pl/allegro/tech/hermes/management/api/ConsistencyEndpoint.java
+++ b/hermes-management/src/main/java/pl/allegro/tech/hermes/management/api/ConsistencyEndpoint.java
@@ -3,7 +3,9 @@
 import jakarta.annotation.security.RolesAllowed;
 import jakarta.ws.rs.DELETE;
 import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
 import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
 import jakarta.ws.rs.Produces;
 import jakarta.ws.rs.QueryParam;
 import jakarta.ws.rs.container.ContainerRequestContext;
@@ -12,6 +14,8 @@
 import jakarta.ws.rs.core.Response;
 import org.springframework.stereotype.Component;
 import pl.allegro.tech.hermes.api.InconsistentGroup;
+import pl.allegro.tech.hermes.api.SubscriptionName;
+import pl.allegro.tech.hermes.api.TopicName;
 import pl.allegro.tech.hermes.management.api.auth.HermesSecurityAwareRequestUser;
 import pl.allegro.tech.hermes.management.api.auth.Roles;
 import pl.allegro.tech.hermes.management.domain.consistency.DcConsistencyService;
@@ -47,6 +51,38 @@ public Response listInconsistentGroups(@QueryParam("groupNames") List<String> gr
                 .build();
     }
 
+    @POST
+    @Produces({APPLICATION_JSON})
+    @Path("/sync/groups/{groupName}")
+    public Response syncGroup(@PathParam("groupName") String groupName,
+                              @QueryParam("primaryDatacenter") String primaryDatacenter
+    ) {
+        dcConsistencyService.syncGroup(groupName, primaryDatacenter);
+        return Response.ok().build();
+    }
+
+    @POST
+    @Produces({APPLICATION_JSON})
+    @Path("/sync/topics/{topicName}")
+    public Response syncTopic(@PathParam("topicName") String topicName,
+                              @QueryParam("primaryDatacenter") String primaryDatacenter
+    ) {
+        dcConsistencyService.syncTopic(TopicName.fromQualifiedName(topicName), primaryDatacenter);
+        return Response.ok().build();
+    }
+
+    @POST
+    @Produces({APPLICATION_JSON})
+    @Path("/sync/topics/{topicName}/subscriptions/{subscriptionName}")
+    public Response syncSubscription(@PathParam("topicName") String topicName,
+                                     @PathParam("subscriptionName") String subscriptionName,
+                                     @QueryParam("primaryDatacenter") String primaryDatacenter
+    ) {
+        SubscriptionName name = new SubscriptionName(subscriptionName, TopicName.fromQualifiedName(topicName));
+        dcConsistencyService.syncSubscription(name, primaryDatacenter);
+        return Response.ok().build();
+    }
+
     @GET
     @Produces({APPLICATION_JSON})
     @Path("/inconsistencies/topics")
diff --git a/hermes-management/src/main/java/pl/allegro/tech/hermes/management/domain/consistency/DcConsistencyService.java b/hermes-management/src/main/java/pl/allegro/tech/hermes/management/domain/consistency/DcConsistencyService.java
index 9218362f0c..cb20828a4f 100644
--- a/hermes-management/src/main/java/pl/allegro/tech/hermes/management/domain/consistency/DcConsistencyService.java
+++ b/hermes-management/src/main/java/pl/allegro/tech/hermes/management/domain/consistency/DcConsistencyService.java
@@ -13,11 +13,13 @@
 import pl.allegro.tech.hermes.api.InconsistentSubscription;
 import pl.allegro.tech.hermes.api.InconsistentTopic;
 import pl.allegro.tech.hermes.api.Subscription;
+import pl.allegro.tech.hermes.api.SubscriptionName;
 import pl.allegro.tech.hermes.api.Topic;
 import pl.allegro.tech.hermes.api.TopicName;
 import pl.allegro.tech.hermes.common.metric.MetricsFacade;
 import pl.allegro.tech.hermes.domain.group.GroupNotExistsException;
 import pl.allegro.tech.hermes.domain.group.GroupRepository;
+import pl.allegro.tech.hermes.domain.subscription.SubscriptionNotExistsException;
 import pl.allegro.tech.hermes.domain.subscription.SubscriptionRepository;
 import pl.allegro.tech.hermes.domain.topic.TopicNotExistsException;
 import pl.allegro.tech.hermes.domain.topic.TopicRepository;
@@ -30,6 +32,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -37,6 +40,8 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import static java.util.Collections.emptyList;
@@ -110,6 +115,81 @@ public List<InconsistentGroup> listInconsistentGroups(Set<String> groupNames) {
         return inconsistentGroups;
     }
 
+    public void syncGroup(String groupName, String primaryDatacenter) {
+        sync(groupRepositories, primaryDatacenter,
+                repo -> repo.groupExists(groupName),
+                repo -> {
+                    try {
+                        return Optional.of(repo.getGroupDetails(groupName));
+                    } catch (GroupNotExistsException ignored) {
+                        return Optional.empty();
+                    }
+                },
+                GroupRepository::createGroup,
+                GroupRepository::updateGroup,
+                repo -> repo.removeGroup(groupName)
+        );
+    }
+
+    public void syncTopic(TopicName topicName, String primaryDatacenter) {
+        sync(topicRepositories, primaryDatacenter,
+                repo -> repo.topicExists(topicName),
+                repo -> {
+                    try {
+                        return Optional.of(repo.getTopicDetails(topicName));
+                    } catch (TopicNotExistsException ignored) {
+                        return Optional.empty();
+                    }
+                },
+                TopicRepository::createTopic,
+                TopicRepository::updateTopic,
+                repo -> repo.removeTopic(topicName)
+        );
+    }
+
+    public void syncSubscription(SubscriptionName subscriptionName, String primaryDatacenter) {
+        sync(subscriptionRepositories, primaryDatacenter,
+                repo -> repo.subscriptionExists(subscriptionName.getTopicName(), subscriptionName.getName()),
+                repo -> {
+                    try {
+                        return Optional.of(repo.getSubscriptionDetails(subscriptionName));
+                    } catch (SubscriptionNotExistsException ignored) {
+                        return Optional.empty();
+                    }
+                },
+                SubscriptionRepository::createSubscription,
+                SubscriptionRepository::updateSubscription,
+                repo -> repo.removeSubscription(subscriptionName.getTopicName(), subscriptionName.getName())
+        );
+    }
+
+    private <R, S> void sync(List<DatacenterBoundRepositoryHolder<R>> repositories,
+                             String sourceOfTruthDatacenter,
+                             Function<R, Boolean> exists,
+                             Function<R, Optional<S>> get,
+                             BiConsumer<R, S> create,
+                             BiConsumer<R, S> update,
+                             Consumer<R> delete
+    ) {
+        var request = partition(repositories, sourceOfTruthDatacenter);
+        var primaryRepository = request.primaryHolder.getRepository();
+        Optional<S> primary = get.apply(primaryRepository);
+        var primaryPresent = primary.isPresent();
+
+        for (var holder : request.replicaHolders) {
+            var repository = holder.getRepository();
+            var replicaPresent = exists.apply(repository);
+
+            if (primaryPresent && replicaPresent) {
+                update.accept(repository, primary.get());
+            } else if (primaryPresent) {
+                create.accept(repository, primary.get());
+            } else if (replicaPresent) {
+                delete.accept(repository);
+            }
+        }
+    }
+
     private List<MetadataCopies> listCopiesOfGroups(Set<String> groupNames) {
         Map<String, Future<List<Group>>> futuresPerDatacenter = new HashMap<>();
         for (DatacenterBoundRepositoryHolder<GroupRepository> repositoryHolder : groupRepositories) {
@@ -242,5 +322,25 @@ private <T> T resolveFuture(Future<T> future) {
         }
     }
 
+    private record DatacenterRepositoryHolderSyncRequest<R>(
+            DatacenterBoundRepositoryHolder<R> primaryHolder,
+            List<DatacenterBoundRepositoryHolder<R>> replicaHolders
+    ) {
+    }
 
+    private <R> DatacenterRepositoryHolderSyncRequest<R> partition(List<DatacenterBoundRepositoryHolder<R>> repositoryHolders, String primaryDatacenter) {
+        List<DatacenterBoundRepositoryHolder<R>> replicas = new ArrayList<>();
+        DatacenterBoundRepositoryHolder<R> primary = null;
+        for (DatacenterBoundRepositoryHolder<R> repositoryHolder : repositoryHolders) {
+            if (repositoryHolder.getDatacenterName().equals(primaryDatacenter)) {
+                primary = repositoryHolder;
+            } else {
+                replicas.add(repositoryHolder);
+            }
+        }
+        if (primary == null) {
+            throw new SynchronizationException("Source of truth datacenter not found: " + primaryDatacenter);
+        }
+        return new DatacenterRepositoryHolderSyncRequest<>(primary, replicas);
+    }
 }
diff --git a/hermes-management/src/main/java/pl/allegro/tech/hermes/management/domain/consistency/SynchronizationException.java b/hermes-management/src/main/java/pl/allegro/tech/hermes/management/domain/consistency/SynchronizationException.java
new file mode 100644
index 0000000000..fb7a461e2f
--- /dev/null
+++ b/hermes-management/src/main/java/pl/allegro/tech/hermes/management/domain/consistency/SynchronizationException.java
@@ -0,0 +1,7 @@
+package pl.allegro.tech.hermes.management.domain.consistency;
+
+public class SynchronizationException extends RuntimeException {
+    public SynchronizationException(String message) {
+        super(message);
+    }
+}
diff --git a/hermes-management/src/test/groovy/pl/allegro/tech/hermes/management/domain/consistency/StorageSyncSpec.groovy b/hermes-management/src/test/groovy/pl/allegro/tech/hermes/management/domain/consistency/StorageSyncSpec.groovy
new file mode 100644
index 0000000000..fb80782c19
--- /dev/null
+++ b/hermes-management/src/test/groovy/pl/allegro/tech/hermes/management/domain/consistency/StorageSyncSpec.groovy
@@ -0,0 +1,369 @@
+package pl.allegro.tech.hermes.management.domain.consistency
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry
+import pl.allegro.tech.hermes.api.Group
+import pl.allegro.tech.hermes.api.Subscription
+import pl.allegro.tech.hermes.api.Topic
+import pl.allegro.tech.hermes.common.metric.MetricsFacade
+import pl.allegro.tech.hermes.domain.group.GroupNotExistsException
+import pl.allegro.tech.hermes.domain.subscription.SubscriptionRepository
+import pl.allegro.tech.hermes.domain.topic.TopicNotExistsException
+import pl.allegro.tech.hermes.domain.topic.TopicRepository
+import pl.allegro.tech.hermes.infrastructure.zookeeper.ZookeeperPaths
+import pl.allegro.tech.hermes.management.config.ConsistencyCheckerProperties
+import pl.allegro.tech.hermes.management.config.storage.DefaultZookeeperGroupRepositoryFactory
+import pl.allegro.tech.hermes.management.domain.dc.MultiDatacenterRepositoryCommandExecutor
+import pl.allegro.tech.hermes.management.domain.group.commands.CreateGroupRepositoryCommand
+import pl.allegro.tech.hermes.management.domain.mode.ModeService
+import pl.allegro.tech.hermes.management.domain.subscription.commands.CreateSubscriptionRepositoryCommand
+import pl.allegro.tech.hermes.management.domain.topic.commands.CreateTopicRepositoryCommand
+import pl.allegro.tech.hermes.management.infrastructure.zookeeper.ZookeeperClient
+import pl.allegro.tech.hermes.management.infrastructure.zookeeper.ZookeeperClientManager
+import pl.allegro.tech.hermes.management.infrastructure.zookeeper.ZookeeperRepositoryManager
+import pl.allegro.tech.hermes.management.utils.MultiZookeeperIntegrationTest
+import pl.allegro.tech.hermes.test.helper.builder.SubscriptionBuilder
+import pl.allegro.tech.hermes.test.helper.builder.TopicBuilder
+
+import static pl.allegro.tech.hermes.test.helper.builder.GroupBuilder.groupWithRandomName
+import static pl.allegro.tech.hermes.test.helper.builder.SubscriptionBuilder.subscriptionWithRandomName
+import static pl.allegro.tech.hermes.test.helper.builder.TopicBuilder.randomTopic
+
+class StorageSyncSpec extends MultiZookeeperIntegrationTest {
+
+    static GROUPS_PATH = '/hermes/groups'
+    ZookeeperClientManager manager
+    ZookeeperRepositoryManager repositoryManager
+
+    ModeService modeService
+    MultiDatacenterRepositoryCommandExecutor executor
+    MetricsFacade metricsFacade = new MetricsFacade(new SimpleMeterRegistry())
+
+    def objectMapper = new ObjectMapper().registerModule(new JavaTimeModule())
+    def paths = new ZookeeperPaths('/hermes')
+
+    def setup() {
+        manager = buildZookeeperClientManager()
+        manager.start()
+        assertZookeeperClientsConnected(manager.clients)
+        manager.clients.each { client -> setupZookeeperPath(client, GROUPS_PATH) }
+        repositoryManager = new ZookeeperRepositoryManager(
+                manager, new TestDatacenterNameProvider(DC_1_NAME), objectMapper,
+                paths, new DefaultZookeeperGroupRepositoryFactory())
+        repositoryManager.start()
+
+        modeService = new ModeService()
+        executor = new MultiDatacenterRepositoryCommandExecutor(repositoryManager, true, modeService)
+    }
+
+    def cleanup() {
+        manager.stop()
+    }
+
+    def "should create group in all DCs if primary datacenter contains group"() {
+        given:
+        def (Group group, String groupPath) = setupGroup()
+
+        and:
+        removeNode(DC_1_NAME, groupPath)
+
+        and:
+        assertNodeDoesNotExist(DC_1_NAME, groupPath)
+        assertNodeContains(DC_2_NAME, groupPath, group)
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncGroup(group.groupName, DC_2_NAME)
+
+        then:
+        assertNodesContains(groupPath, group)
+    }
+
+    def "should delete group in all DCs if primary datacenter does not contain group"() {
+        given:
+        def (Group group, String groupPath) = setupGroup()
+
+        and:
+        removeNode(DC_1_NAME, groupPath)
+
+        and:
+        assertNodeDoesNotExist(DC_1_NAME, groupPath)
+        assertNodeContains(DC_2_NAME, groupPath, group)
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncGroup(group.groupName, DC_1_NAME)
+
+        then:
+        assertNodesDoNotExist(groupPath)
+    }
+
+    def "should create topic in all DCs if primary datacenter contains topic"() {
+        given:
+        def (Group _, Topic topic, String topicPath) = setupTopic()
+
+        and:
+        removeNode(DC_1_NAME, topicPath)
+
+        and:
+        assertNodeDoesNotExist(DC_1_NAME, topicPath)
+        assertNodeContains(DC_2_NAME, topicPath, topic)
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncTopic(topic.getName(), DC_2_NAME)
+
+        then:
+        assertNodesContains(topicPath, topic)
+    }
+
+    def "should delete topic in all DCs if primary datacenter contains topic"() {
+        given:
+        def (Group _, Topic topic, String topicPath) = setupTopic()
+
+        and:
+        removeNode(DC_1_NAME, topicPath)
+
+        and:
+        assertNodeDoesNotExist(DC_1_NAME, topicPath)
+        assertNodeContains(DC_2_NAME, topicPath, topic)
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncTopic(topic.getName(), DC_1_NAME)
+
+        then:
+        assertNodesDoNotExist(topicPath)
+    }
+
+    def "should sync topic in all DCs to primary datacenter value"() {
+        given:
+        def (Group _, Topic topic, String topicPath) = setupTopic()
+
+        and:
+        TopicRepository topicRepository = repositoryManager.getLocalRepository(TopicRepository.class).getRepository()
+        Topic updatedTopic = TopicBuilder.topic(topic.name.getGroupName(), topic.name.getName())
+                .withDescription("foo bar").build()
+        topicRepository.updateTopic(updatedTopic)
+
+        and:
+        assertNodesAreDifferent(topicPath, Topic.class)
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncTopic(topic.getName(), DC_1_NAME)
+
+        then:
+        assertNodesContains(topicPath, updatedTopic)
+    }
+
+    def "should create subscription in all DCs if primary datacenter contains subscription"() {
+        given:
+        def (Group _, Topic __, Subscription subscription, String subscriptionPath) = setupSubscription()
+
+        and:
+        removeNode(DC_1_NAME, subscriptionPath)
+
+        and:
+        assertNodeDoesNotExist(DC_1_NAME, subscriptionPath)
+        assertNodeContains(DC_2_NAME, subscriptionPath, subscription)
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncSubscription(subscription.getQualifiedName(), DC_2_NAME)
+
+        then:
+        assertNodesContains(subscriptionPath, subscription)
+    }
+
+    def "should delete subscription in all DCs if primary datacenter does not contain subscription"() {
+        given:
+        def (Group _, Topic __, Subscription subscription, String subscriptionPath) = setupSubscription()
+
+        and:
+        SubscriptionRepository subscriptionRepository = repositoryManager.getLocalRepository(SubscriptionRepository.class).getRepository()
+        Subscription updatedSubscription = SubscriptionBuilder.subscription(subscription.getQualifiedName())
+                .withDescription("foo bar").build()
+        subscriptionRepository.updateSubscription(updatedSubscription)
+
+        and:
+        assertNodesAreDifferent(subscriptionPath, Subscription.class)
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncSubscription(subscription.getQualifiedName(), DC_1_NAME)
+
+        then:
+        assertNodesContains(subscriptionPath, updatedSubscription)
+    }
+
+    def "should sync subscription in all DCs to primary datacenter value"() {
+        given:
+        def (Group _, Topic __, Subscription subscription, String subscriptionPath) = setupSubscription()
+
+        and:
+        removeNode(DC_1_NAME, subscriptionPath)
+
+        and:
+        assertNodeDoesNotExist(DC_1_NAME, subscriptionPath)
+        assertNodeContains(DC_2_NAME, subscriptionPath, subscription)
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncSubscription(subscription.getQualifiedName(), DC_1_NAME)
+
+        then:
+        assertNodesDoNotExist(subscriptionPath)
+    }
+
+    def "topic sync should fail if group does not exist in replica datacenter"() {
+        given:
+        def (Group group, Topic topic, String _) = setupTopic()
+
+        and:
+        removeNode(DC_1_NAME, paths.groupPath(group.getGroupName()))
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncTopic(topic.getName(), DC_2_NAME)
+
+        then:
+        thrown GroupNotExistsException
+    }
+
+    def "subscription sync should fail if group does not exist in replica datacenter"() {
+        given:
+        def (Group group, Topic _, Subscription subscription, String __) = setupSubscription()
+
+        and:
+        removeNode(DC_1_NAME, paths.groupPath(group.getGroupName()))
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncSubscription(subscription.getQualifiedName(), DC_2_NAME)
+
+        then:
+        thrown TopicNotExistsException
+    }
+
+    def "subscription sync should fail if topic does not exist in replica datacenter"() {
+        given:
+        def (Group _, Topic topic, Subscription subscription, String __) = setupSubscription()
+
+        and:
+        removeNode(DC_1_NAME, paths.topicPath(topic.getName()))
+
+        and:
+        def consistencyService = new DcConsistencyService(repositoryManager, objectMapper, new ConsistencyCheckerProperties(), metricsFacade)
+
+        when:
+        consistencyService.syncSubscription(subscription.getQualifiedName(), DC_2_NAME)
+
+        then:
+        thrown TopicNotExistsException
+    }
+
+    private def setupGroup() {
+        Group group = groupWithRandomName().build()
+        executor.execute(new CreateGroupRepositoryCommand(group))
+        String groupPath = paths.groupPath(group.groupName)
+        return [group, groupPath]
+    }
+
+    private def setupTopic() {
+        Group group = groupWithRandomName().build()
+        Topic topic = randomTopic(group.getGroupName(), "").build()
+        executor.execute(new CreateGroupRepositoryCommand(group))
+        executor.execute(new CreateTopicRepositoryCommand(topic))
+        String topicPath = paths.topicPath(topic.getName())
+        return [group, topic, topicPath]
+    }
+
+    private def setupSubscription() {
+        Group group = groupWithRandomName().build()
+        Topic topic = randomTopic(group.getGroupName(), "").build()
+        Subscription subscription = subscriptionWithRandomName(topic.getName()).build()
+        executor.execute(new CreateGroupRepositoryCommand(group))
+        executor.execute(new CreateTopicRepositoryCommand(topic))
+        executor.execute(new CreateSubscriptionRepositoryCommand(subscription))
+        String subscriptionPath = paths.subscriptionPath(subscription)
+        return [group, topic, subscription, subscriptionPath]
+    }
+
+
+    private <T> void assertNodeContains(String dc, String path, T expected) {
+        def zkClient = findClientByDc(manager.clients, dc)
+        def data = zkClient.curatorFramework.getData().forPath(path)
+        def actual = objectMapper.readValue(data, expected.class)
+        assert actual == expected
+    }
+
+    private <T> void assertNodesContains(String path, T expected) {
+        manager.clients.each {
+            def data = it.curatorFramework.getData().forPath(path)
+            def actual = objectMapper.readValue(data, expected.class)
+            assert actual == expected
+        }
+    }
+
+    private def assertNodeDoesNotExist(String dc, String path) {
+        def zkClient = findClientByDc(manager.clients, dc)
+        zkClient.curatorFramework.checkExists().forPath(path) == null
+    }
+
+    private def assertNodesDoNotExist(String path) {
+        manager.clients.each {
+            assert it.curatorFramework.checkExists().forPath(path) == null
+        }
+    }
+
+    private <T> void assertNodesAreDifferent(String path, Class<T> clazz) {
+        Set<T> values = new HashSet<>()
+        manager.clients.each {
+            def data = it.curatorFramework.getData().forPath(path)
+            def value = objectMapper.readValue(data, clazz)
+            values.add(value)
+        }
+        assert values.size() > 1
+    }
+
+    private def removeNode(String dc, String path) {
+        def zkClient = findClientByDc(manager.clients, dc)
+        zkClient.curatorFramework.delete()
+                .deletingChildrenIfNeeded()
+                .forPath(path)
+    }
+
+    private static setupZookeeperPath(ZookeeperClient zookeeperClient, String path) {
+        def healthCheckPathExists = zookeeperClient.curatorFramework
+                .checkExists()
+                .forPath(path) != null
+        if (!healthCheckPathExists) {
+            zookeeperClient.curatorFramework
+                    .create()
+                    .creatingParentContainersIfNeeded()
+                    .forPath(path)
+        }
+    }
+}