diff --git a/onadata/apps/api/tests/viewsets/test_abstract_viewset.py b/onadata/apps/api/tests/viewsets/test_abstract_viewset.py
index dc109421f2..845992522f 100644
--- a/onadata/apps/api/tests/viewsets/test_abstract_viewset.py
+++ b/onadata/apps/api/tests/viewsets/test_abstract_viewset.py
@@ -2,6 +2,7 @@
 """
 Test base class for API viewset tests.
 """
+
 import json
 import os
 import re
@@ -11,6 +12,7 @@
 from django.conf import settings
 from django.contrib.auth import authenticate, get_user_model
 from django.contrib.auth.models import Permission
+from django.db.models.signals import post_save
 from django.test import TestCase
 
 import requests
@@ -42,8 +44,10 @@
 from onadata.apps.logger.views import submission
 from onadata.apps.logger.xform_instance_parser import clean_and_parse_xml
 from onadata.apps.main import tests as main_tests
-from onadata.apps.main.tests.test_base import TestBase
 from onadata.apps.main.models import MetaData, UserProfile
+from onadata.apps.main.tests.test_base import TestBase
+from onadata.apps.viewer.models import DataDictionary
+from onadata.apps.viewer.models.data_dictionary import create_export_repeat_register
 from onadata.libs.serializers.project_serializer import ProjectSerializer
 from onadata.libs.utils.common_tools import merge_dicts
 
@@ -133,6 +137,20 @@ def setUp(self):
         self.factory = APIRequestFactory()
         self._login_user_and_profile()
         self.maxDiff = None
+        # Disable signals
+        post_save.disconnect(
+            sender=DataDictionary, dispatch_uid="create_export_repeat_register"
+        )
+
+    def tearDown(self):
+        # Enable signals
+        post_save.connect(
+            sender=DataDictionary,
+            dispatch_uid="create_export_repeat_register",
+            receiver=create_export_repeat_register,
+        )
+
+        TestCase.tearDown(self)
 
     def user_profile_data(self):
         """Returns the user profile python object."""
diff --git a/onadata/apps/logger/tests/models/test_instance.py b/onadata/apps/logger/tests/models/test_instance.py
index c2bfcbeeac..7fafbf61e5 100644
--- a/onadata/apps/logger/tests/models/test_instance.py
+++ b/onadata/apps/logger/tests/models/test_instance.py
@@ -1228,8 +1228,7 @@ def test_register_repeats(self):
         |         | form_title  | form_id         |                     |
         |         | Births      | births          |                     |
         """
-        self._publish_markdown(md, self.user, project)
-        xform = XForm.objects.all().order_by("-pk").first()
+        xform = self._publish_markdown(md, self.user, project)
         xml = (
             '<?xml version="1.0" encoding="UTF-8"?>'
             '<data xmlns:jr="http://openrosa.org/javarosa" xmlns:orx='
diff --git a/onadata/apps/main/tests/test_csv_export.py b/onadata/apps/main/tests/test_csv_export.py
index db1ca74bb1..aca24b173f 100644
--- a/onadata/apps/main/tests/test_csv_export.py
+++ b/onadata/apps/main/tests/test_csv_export.py
@@ -2,17 +2,19 @@
 """
 Test CSV Exports
 """
+
 import csv
 import os
 
 from django.core.files.storage import get_storage_class
+from django.db.models.signals import post_save
 from django.utils.dateparse import parse_datetime
 
-from onadata.apps.viewer.models.data_dictionary import DataDictionary
-from onadata.apps.viewer.models.export import Export
 from onadata.apps.logger.models import XForm
-from onadata.libs.utils.export_tools import generate_export
 from onadata.apps.main.tests.test_base import TestBase
+from onadata.apps.viewer.models import DataDictionary, Export
+from onadata.apps.viewer.models.data_dictionary import create_export_repeat_register
+from onadata.libs.utils.export_tools import generate_export
 
 
 class TestCsvExport(TestBase):
@@ -23,150 +25,161 @@ class TestCsvExport(TestBase):
     def setUp(self):
         self._create_user_and_login()
 
-        self.fixture_dir = os.path.join(
-            self.this_directory, 'fixtures', 'csv_export')
-        self._submission_time = parse_datetime('2013-02-18 15:54:01Z')
+        self.fixture_dir = os.path.join(self.this_directory, "fixtures", "csv_export")
+        self._submission_time = parse_datetime("2013-02-18 15:54:01Z")
         self.options = {"extension": "csv"}
         self.xform = None
+        # Disable signals
+        post_save.disconnect(
+            sender=DataDictionary, dispatch_uid="create_export_repeat_register"
+        )
+
+    def tearDown(self):
+        # Reconnect signals
+        post_save.connect(
+            sender=DataDictionary,
+            dispatch_uid="create_export_repeat_register",
+            receiver=create_export_repeat_register,
+        )
+
+        super().tearDown()
 
     def test_csv_export_output(self):
         """
         Test CSV export output
         """
-        path = os.path.join(self.fixture_dir, 'tutorial_w_repeats.xlsx')
+        path = os.path.join(self.fixture_dir, "tutorial_w_repeats.xlsx")
         self._publish_xls_file_and_set_xform(path)
-        path = os.path.join(self.fixture_dir, 'tutorial_w_repeats.xml')
-        self._make_submission(
-            path, forced_submission_time=self._submission_time)
+        path = os.path.join(self.fixture_dir, "tutorial_w_repeats.xml")
+        self._make_submission(path, forced_submission_time=self._submission_time)
         # test csv
 
-        export = generate_export(
-            Export.CSV_EXPORT,
-            self.xform,
-            None,
-            self.options)
+        export = generate_export(Export.CSV_EXPORT, self.xform, None, self.options)
         storage = get_storage_class()()
         self.assertTrue(storage.exists(export.filepath))
         path, ext = os.path.splitext(export.filename)
-        self.assertEqual(ext, '.csv')
-        test_file_path = os.path.join(
-            self.fixture_dir, 'tutorial_w_repeats.csv')
-        with storage.open(export.filepath, 'r') as csv_file:
+        self.assertEqual(ext, ".csv")
+        test_file_path = os.path.join(self.fixture_dir, "tutorial_w_repeats.csv")
+        with storage.open(export.filepath, "r") as csv_file:
             self._test_csv_files(csv_file, test_file_path)
 
     def test_csv_nested_repeat_output(self):
         """
         Test CSV export with nested repeats
         """
-        path = os.path.join(self.fixture_dir, 'double_repeat.xlsx')
+        path = os.path.join(self.fixture_dir, "double_repeat.xlsx")
         self._publish_xls_file(path)
-        self.xform = XForm.objects.get(id_string='double_repeat')
-        path = os.path.join(self.fixture_dir, 'instance.xml')
-        self._make_submission(
-            path, forced_submission_time=self._submission_time)
+        self.xform = XForm.objects.get(id_string="double_repeat")
+        path = os.path.join(self.fixture_dir, "instance.xml")
+        self._make_submission(path, forced_submission_time=self._submission_time)
         self.maxDiff = None
         data_dictionary = DataDictionary.objects.all()[0]
         xpaths = [
-            u'/data/bed_net[1]/member[1]/name',
-            u'/data/bed_net[1]/member[2]/name',
-            u'/data/bed_net[2]/member[1]/name',
-            u'/data/bed_net[2]/member[2]/name',
-            u'/data/meta/instanceID'
+            "/data/bed_net[1]/member[1]/name",
+            "/data/bed_net[1]/member[2]/name",
+            "/data/bed_net[2]/member[1]/name",
+            "/data/bed_net[2]/member[2]/name",
+            "/data/meta/instanceID",
         ]
         self.assertEqual(data_dictionary.xpaths(repeat_iterations=2), xpaths)
         # test csv
-        export = generate_export(
-            Export.CSV_EXPORT,
-            self.xform,
-            None,
-            self.options)
+        export = generate_export(Export.CSV_EXPORT, self.xform, None, self.options)
         storage = get_storage_class()()
         self.assertTrue(storage.exists(export.filepath))
         path, ext = os.path.splitext(export.filename)
-        self.assertEqual(ext, '.csv')
-        test_file_path = os.path.join(self.fixture_dir, 'export.csv')
-        with storage.open(export.filepath, 'r') as csv_file:
+        self.assertEqual(ext, ".csv")
+        test_file_path = os.path.join(self.fixture_dir, "export.csv")
+        with storage.open(export.filepath, "r") as csv_file:
             self._test_csv_files(csv_file, test_file_path)
 
     def test_dotted_fields_csv_export(self):
         """
         Test CSV export with dotted field names
         """
-        path = os.path.join(os.path.dirname(__file__), 'fixtures', 'userone',
-                            'userone_with_dot_name_fields.xlsx')
+        path = os.path.join(
+            os.path.dirname(__file__),
+            "fixtures",
+            "userone",
+            "userone_with_dot_name_fields.xlsx",
+        )
         self._publish_xls_file_and_set_xform(path)
-        path = os.path.join(os.path.dirname(__file__), 'fixtures', 'userone',
-                            'userone_with_dot_name_fields.xml')
-        self._make_submission(
-            path, forced_submission_time=self._submission_time)
+        path = os.path.join(
+            os.path.dirname(__file__),
+            "fixtures",
+            "userone",
+            "userone_with_dot_name_fields.xml",
+        )
+        self._make_submission(path, forced_submission_time=self._submission_time)
         # test csv
-        self.options['id_string'] = 'userone'
-        export = generate_export(
-            Export.CSV_EXPORT,
-            self.xform,
-            None,
-            self.options)
+        self.options["id_string"] = "userone"
+        export = generate_export(Export.CSV_EXPORT, self.xform, None, self.options)
         storage = get_storage_class()()
         self.assertTrue(storage.exists(export.filepath))
         path, ext = os.path.splitext(export.filename)
-        self.assertEqual(ext, '.csv')
+        self.assertEqual(ext, ".csv")
         test_file_path = os.path.join(
-            os.path.dirname(__file__), 'fixtures', 'userone',
-            'userone_with_dot_name_fields.csv')
-        with storage.open(export.filepath, 'r') as csv_file:
+            os.path.dirname(__file__),
+            "fixtures",
+            "userone",
+            "userone_with_dot_name_fields.csv",
+        )
+        with storage.open(export.filepath, "r") as csv_file:
             self._test_csv_files(csv_file, test_file_path)
 
     def test_csv_truncated_titles(self):
         """
         Test CSV export with removed_group_name = True
         """
-        path = os.path.join(self.fixture_dir, 'tutorial_w_repeats.xlsx')
+        path = os.path.join(self.fixture_dir, "tutorial_w_repeats.xlsx")
         self._publish_xls_file_and_set_xform(path)
-        path = os.path.join(self.fixture_dir, 'tutorial_w_repeats.xml')
-        self._make_submission(
-            path, forced_submission_time=self._submission_time)
+        path = os.path.join(self.fixture_dir, "tutorial_w_repeats.xml")
+        self._make_submission(path, forced_submission_time=self._submission_time)
         # test csv
-        self.options['remove_group_name'] = True
-        export = generate_export(
-            Export.CSV_EXPORT,
-            self.xform,
-            None,
-            self.options)
+        self.options["remove_group_name"] = True
+        export = generate_export(Export.CSV_EXPORT, self.xform, None, self.options)
         storage = get_storage_class()()
         self.assertTrue(storage.exists(export.filepath))
         path, ext = os.path.splitext(export.filename)
-        self.assertEqual(ext, '.csv')
+        self.assertEqual(ext, ".csv")
         test_file_path = os.path.join(
-            self.fixture_dir, 'tutorial_w_repeats_truncate_titles.csv')
-        with storage.open(export.filepath, 'r') as csv_file:
+            self.fixture_dir, "tutorial_w_repeats_truncate_titles.csv"
+        )
+        with storage.open(export.filepath, "r") as csv_file:
             self._test_csv_files(csv_file, test_file_path)
 
     def test_csv_repeat_with_note(self):
         """
         Test that note field in repeat is not in csv export
         """
-        path = os.path.join(self.fixture_dir, 'repeat_w_note.xlsx')
+        path = os.path.join(self.fixture_dir, "repeat_w_note.xlsx")
         self._publish_xls_file_and_set_xform(path)
-        path = os.path.join(self.fixture_dir, 'repeat_w_note.xml')
-        self._make_submission(
-            path, forced_submission_time=self._submission_time)
-        export = generate_export(
-            Export.CSV_EXPORT,
-            self.xform,
-            None,
-            self.options)
+        path = os.path.join(self.fixture_dir, "repeat_w_note.xml")
+        self._make_submission(path, forced_submission_time=self._submission_time)
+        export = generate_export(Export.CSV_EXPORT, self.xform, None, self.options)
         storage = get_storage_class()()
         self.assertTrue(storage.exists(export.filepath))
         path, ext = os.path.splitext(export.filename)
-        self.assertEqual(ext, '.csv')
-        with storage.open(export.filepath, 'r') as csv_file:
+        self.assertEqual(ext, ".csv")
+        with storage.open(export.filepath, "r") as csv_file:
             reader = csv.reader(csv_file)
             rows = [row for row in reader]
             actual_headers = [h for h in rows[0]]
             expected_headers = [
-                'chnum', 'chrepeat[1]/chname', 'chrepeat[2]/chname',
-                'meta/instanceID', '_id', '_uuid', '_submission_time',
-                '_date_modified', '_tags', '_notes', '_version',
-                '_duration', '_submitted_by', '_total_media',
-                '_media_count', '_media_all_received']
+                "chnum",
+                "chrepeat[1]/chname",
+                "chrepeat[2]/chname",
+                "meta/instanceID",
+                "_id",
+                "_uuid",
+                "_submission_time",
+                "_date_modified",
+                "_tags",
+                "_notes",
+                "_version",
+                "_duration",
+                "_submitted_by",
+                "_total_media",
+                "_media_count",
+                "_media_all_received",
+            ]
             self.assertEqual(sorted(expected_headers), sorted(actual_headers))
diff --git a/onadata/apps/viewer/models/data_dictionary.py b/onadata/apps/viewer/models/data_dictionary.py
index 7bc55529c8..2d3845dfba 100644
--- a/onadata/apps/viewer/models/data_dictionary.py
+++ b/onadata/apps/viewer/models/data_dictionary.py
@@ -35,6 +35,7 @@
     PROJ_FORMS_CACHE,
     safe_delete,
 )
+from onadata.libs.utils.common_tags import EXPORT_REPEAT_REGISTER
 from onadata.libs.utils.model_tools import get_columns_with_hxl, set_uuid
 
 
@@ -438,3 +439,21 @@ def invalidate_caches(sender, instance=None, created=False, **kwargs):
     sender=DataDictionary,
     dispatch_uid="xform_invalidate_caches",
 )
+
+
+def create_export_repeat_register(sender, instance=None, created=False, **kwargs):
+    """Create export repeat register for the form"""
+    if created:
+        MetaData.objects.create(
+            content_type=ContentType.objects.get_for_model(instance),
+            object_id=instance.pk,
+            data_type=EXPORT_REPEAT_REGISTER,
+            data_value="",
+        )
+
+
+post_save.connect(
+    create_export_repeat_register,
+    sender=DataDictionary,
+    dispatch_uid="create_export_repeat_register",
+)
diff --git a/onadata/apps/viewer/models/tests/test_data_dictionary.py b/onadata/apps/viewer/models/tests/test_data_dictionary.py
index e292faddd1..3be2b032b1 100644
--- a/onadata/apps/viewer/models/tests/test_data_dictionary.py
+++ b/onadata/apps/viewer/models/tests/test_data_dictionary.py
@@ -2,6 +2,7 @@
 
 import json
 
+from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
 
 from onadata.apps.logger.models.entity_list import EntityList
@@ -307,3 +308,15 @@ def test_cache_invalidated(self):
 
         for key in cache_keys:
             self.assertIsNone(cache.get(key))
+
+    def test_export_repeat_register_created(self):
+        """Export repeat register is created when form is published"""
+        xform = self._publish_markdown(self.registration_form, self.user)
+        content_type = ContentType.objects.get_for_model(xform)
+        exists = MetaData.objects.filter(
+            data_type="export_repeat_register",
+            object_id=xform.pk,
+            content_type=content_type,
+        ).exists()
+
+        self.assertTrue(exists)
diff --git a/onadata/libs/tests/utils/test_csv_builder.py b/onadata/libs/tests/utils/test_csv_builder.py
index f7abbc840e..7566b5afca 100644
--- a/onadata/libs/tests/utils/test_csv_builder.py
+++ b/onadata/libs/tests/utils/test_csv_builder.py
@@ -10,6 +10,7 @@
 from unittest.mock import patch
 
 from django.contrib.contenttypes.models import ContentType
+from django.db.models.signals import post_save
 from django.test.utils import override_settings
 from django.utils.dateparse import parse_datetime
 
@@ -19,6 +20,8 @@
 from onadata.apps.logger.xform_instance_parser import xform_instance_to_dict
 from onadata.apps.main.models.meta_data import MetaData
 from onadata.apps.main.tests.test_base import TestBase
+from onadata.apps.viewer.models import DataDictionary
+from onadata.apps.viewer.models.data_dictionary import create_export_repeat_register
 from onadata.libs.utils.common_tags import NA_REP
 from onadata.libs.utils.csv_builder import (
     AbstractDataFrameBuilder,
@@ -63,6 +66,20 @@ class TestCSVDataFrameBuilder(TestBase):
     def setUp(self):
         self._create_user_and_login()
         self._submission_time = parse_datetime("2013-02-18 15:54:01Z")
+        # Disable signals
+        post_save.disconnect(
+            sender=DataDictionary, dispatch_uid="create_export_repeat_register"
+        )
+
+    def tearDown(self):
+        # Enable signals
+        post_save.connect(
+            sender=DataDictionary,
+            dispatch_uid="create_export_repeat_register",
+            receiver=create_export_repeat_register,
+        )
+
+        super().tearDown()
 
     def _publish_xls_fixture_set_xform(self, fixture):
         """
@@ -132,8 +149,6 @@ def test_csv_dataframe_export_to(self, mock_register_repeats):
         cursor = (
             self.xform.instances.all().order_by("id").values_list("json", flat=True)
         )
-        # De-register repeats, simulate case where repeats are not registered
-        MetaData.objects.filter(data_type="export_repeat_register").delete()
         csv_df_builder.export_to(temp_file.name, cursor)
         csv_fixture_path = os.path.join(
             os.path.dirname(os.path.abspath(__file__)),
diff --git a/onadata/libs/tests/utils/test_logger_tools.py b/onadata/libs/tests/utils/test_logger_tools.py
index 397a9f37b1..f4c84d2767 100644
--- a/onadata/libs/tests/utils/test_logger_tools.py
+++ b/onadata/libs/tests/utils/test_logger_tools.py
@@ -1166,6 +1166,9 @@ class RegisterInstanceExportRepeatsTestCase(TestBase):
     def setUp(self):
         super().setUp()
 
+        # Disable signals
+        post_save.disconnect(sender=Instance, dispatch_uid="register_export_repeats")
+
         self.project = get_user_default_project(self.user)
         md = """
         | survey |
@@ -1181,8 +1184,7 @@ def setUp(self):
         |         | form_title  | form_id         |                     |
         |         | Births      | births          |                     |
         """
-        self._publish_markdown(md, self.user, self.project)
-        self.xform = XForm.objects.all().order_by("-pk").first()
+        self.xform = self._publish_markdown(md, self.user, self.project)
         self.xml = (
             '<?xml version="1.0" encoding="UTF-8"?>'
             '<data xmlns:jr="http://openrosa.org/javarosa" xmlns:orx='
@@ -1211,78 +1213,66 @@ def setUp(self):
             "</meta>"
             "</data>"
         )
-        # Disable signals to avoid creating MetaData
-        post_save.disconnect(sender=Instance, dispatch_uid="register_export_repeats")
         self.instance = Instance.objects.create(
             xml=self.xml, user=self.user, xform=self.xform
         )
+        self.register = MetaData.objects.get(
+            data_type="export_repeat_register",
+            object_id=self.xform.pk,
+            content_type=ContentType.objects.get_for_model(self.xform),
+        )
 
-    def test_repeat_count_create(self):
-        """MetaData of type export_repeat_register is created"""
+    def test_repeat_register_not_found(self):
+        """Nothing happens if export repeat register is not found"""
+        self.register.delete()
         register_instance_export_repeats(self.instance)
 
-        metadata = MetaData.objects.get(data_type="export_repeat_register")
-        self.assertEqual(metadata.extra_data.get("hospital_repeat"), 2)
-        self.assertEqual(metadata.extra_data.get("child_repeat"), 2)
+        exists = MetaData.objects.filter(data_type="export_repeat_register").exists()
+        self.assertFalse(exists)
 
     def test_incoming_repeat_max_greater(self):
         """Repeat count is incremented if incoming repeat count is greater"""
-        metadata = MetaData.objects.create(
-            content_type=ContentType.objects.get_for_model(self.xform),
-            object_id=self.xform.id,
-            data_type="export_repeat_register",
-            extra_data={
-                "hospital_repeat": 1,
-                "child_repeat": 1,
-            },
-            data_value="",
-        )
+        self.register.extra_data = {
+            "hospital_repeat": 1,
+            "child_repeat": 1,
+        }
+        self.register.save()
         register_instance_export_repeats(self.instance)
 
-        metadata.refresh_from_db()
-        self.assertEqual(metadata.extra_data.get("hospital_repeat"), 2)
-        self.assertEqual(metadata.extra_data.get("child_repeat"), 2)
+        self.register.refresh_from_db()
+        self.assertEqual(self.register.extra_data.get("hospital_repeat"), 2)
+        self.assertEqual(self.register.extra_data.get("child_repeat"), 2)
 
     def test_incoming_repeat_max_less(self):
         """Repeat count is unchanged if incoming repeat count is less"""
-        metadata = MetaData.objects.create(
-            content_type=ContentType.objects.get_for_model(self.xform),
-            object_id=self.xform.id,
-            data_type="export_repeat_register",
-            extra_data={
-                "hospital_repeat": 3,
-                "child_repeat": 3,
-            },
-            data_value="",
-        )
+        self.register.extra_data = {
+            "hospital_repeat": 3,
+            "child_repeat": 3,
+        }
+        self.register.save()
         register_instance_export_repeats(self.instance)
 
-        metadata.refresh_from_db()
+        self.register.refresh_from_db()
         # repeat counts remain unchanged
-        self.assertEqual(metadata.extra_data.get("hospital_repeat"), 3)
-        self.assertEqual(metadata.extra_data.get("child_repeat"), 3)
+        self.assertEqual(self.register.extra_data.get("hospital_repeat"), 3)
+        self.assertEqual(self.register.extra_data.get("child_repeat"), 3)
 
     def test_incoming_repeat_max_equal(self):
         """Repeat count is unchanged if incoming repeat count is equal"""
-        metadata = MetaData.objects.create(
-            content_type=ContentType.objects.get_for_model(self.xform),
-            object_id=self.xform.id,
-            data_type="export_repeat_register",
-            extra_data={
-                "hospital_repeat": 2,
-                "child_repeat": 2,
-            },
-            data_value="",
-        )
+        self.register.extra_data = {
+            "hospital_repeat": 2,
+            "child_repeat": 2,
+        }
+        self.register.save()
         register_instance_export_repeats(self.instance)
 
-        metadata.refresh_from_db()
+        self.register.refresh_from_db()
         # repeat counts remain unchanged
-        self.assertEqual(metadata.extra_data.get("hospital_repeat"), 2)
-        self.assertEqual(metadata.extra_data.get("child_repeat"), 2)
+        self.assertEqual(self.register.extra_data.get("hospital_repeat"), 2)
+        self.assertEqual(self.register.extra_data.get("child_repeat"), 2)
 
     def test_no_repeats(self):
-        """Instance has no repeats"""
+        """No change in register if no repeats are found in the instance"""
         md = """
         | survey |
         |        | type         | name            | label               |
@@ -1306,61 +1296,16 @@ def test_no_repeats(self):
             "</data>"
         )
         instance = Instance.objects.create(xml=xml, user=self.user, xform=xform)
-
-        register_instance_export_repeats(instance)
-
-        exists = MetaData.objects.filter(data_type="export_repeat_register").exists()
-        self.assertTrue(exists)
-        metadata = MetaData.objects.get(data_type="export_repeat_register")
-        self.assertEqual(metadata.extra_data, {})
-
-    def test_create_register_previous_candidates(self):
-        """Previous submissions are considered when creating repeat register"""
-        # Existing submission with a higher repeat count for hospital_repeat
-        xml = (
-            '<?xml version="1.0" encoding="UTF-8"?>'
-            '<data xmlns:jr="http://openrosa.org/javarosa" xmlns:orx='
-            '"http://openrosa.org/xforms" id="trees_update" version="2024050801">'
-            f"<formhub><uuid>{self.xform.uuid}</uuid></formhub>"
-            "<hospital_repeat>"
-            "<hospital>Aga Khan</hospital>"
-            "<child_repeat>"
-            "<name>Zakayo</name>"
-            "<birthweight>3.3</birthweight>"
-            "</child_repeat>"
-            "<child_repeat>"
-            "<name>Melania</name>"
-            "<birthweight>3.5</birthweight>"
-            "</child_repeat>"
-            "</hospital_repeat>"
-            "<hospital_repeat>"
-            "<hospital>Mama Lucy</hospital>"
-            "<child_repeat>"
-            "<name>Winnie</name>"
-            "<birthweight>3.1</birthweight>"
-            "</child_repeat>"
-            "</hospital_repeat>"
-            "<hospital_repeat>"
-            "<hospital>Nairobi West</hospital>"
-            "<child_repeat>"
-            "<name>Tom</name>"
-            "<birthweight>3.1</birthweight>"
-            "</child_repeat>"
-            "</hospital_repeat>"
-            "<meta>"
-            "<instanceID>uuid:cb5eb8fe-a046-4e75-9c7f-72183b871698</instanceID>"
-            "</meta>"
-            "</data>"
+        register = MetaData.objects.get(
+            content_type=ContentType.objects.get_for_model(xform),
+            object_id=self.xform.id,
+            data_type="export_repeat_register",
         )
-        Instance.objects.create(xml=xml, user=self.user, xform=self.xform)
 
-        register_instance_export_repeats(self.instance)
+        register_instance_export_repeats(instance)
+        register.refresh_from_db()
 
-        metadata = MetaData.objects.get(data_type="export_repeat_register")
-        # The previous submission should be considered since it has the most repeats
-        # for hospital_repeat
-        self.assertEqual(metadata.extra_data.get("hospital_repeat"), 3)
-        self.assertEqual(metadata.extra_data.get("child_repeat"), 2)
+        self.assertEqual(register.extra_data, {})
 
     def test_submission_review_enabled(self):
         """When submission review is enabled, only approved Instance is registered"""
@@ -1371,9 +1316,9 @@ def test_submission_review_enabled(self):
         )
         register_instance_export_repeats(self.instance)
 
-        metadata = MetaData.objects.get(data_type="export_repeat_register")
+        self.register.refresh_from_db()
 
-        self.assertEqual(metadata.extra_data, {})
+        self.assertEqual(self.register.extra_data, {})
 
         # Approve submission
         SubmissionReview.objects.create(
@@ -1382,9 +1327,9 @@ def test_submission_review_enabled(self):
 
         register_instance_export_repeats(self.instance)
 
-        metadata.refresh_from_db()
+        self.register.refresh_from_db()
 
-        self.assertEqual(metadata.extra_data.get("hospital_repeat"), 2)
+        self.assertEqual(self.register.extra_data.get("hospital_repeat"), 2)
 
 
 class RegisterXFormExportRepeatsTestCase(TestBase):
@@ -1393,6 +1338,9 @@ class RegisterXFormExportRepeatsTestCase(TestBase):
     def setUp(self):
         super().setUp()
 
+        # Disable signals
+        post_save.disconnect(sender=Instance, dispatch_uid="register_export_repeats")
+
         self.project = get_user_default_project(self.user)
         md = """
         | survey |
@@ -1408,8 +1356,7 @@ def setUp(self):
         |         | form_title  | form_id         |                     |
         |         | Births      | births          |                     |
         """
-        self._publish_markdown(md, self.user, self.project)
-        self.xform = XForm.objects.all().order_by("-pk").first()
+        self.xform = self._publish_markdown(md, self.user, self.project)
         xml = (
             '<?xml version="1.0" encoding="UTF-8"?>'
             '<data xmlns:jr="http://openrosa.org/javarosa" xmlns:orx='
@@ -1438,14 +1385,19 @@ def setUp(self):
             "</meta>"
             "</data>"
         )
-        # Disable signals to avoid creating MetaData
-        post_save.disconnect(sender=Instance, dispatch_uid="register_export_repeats")
         self.instance = Instance.objects.create(
             xml=xml, user=self.user, xform=self.xform
         )
+        self.register = MetaData.objects.get(
+            data_type="export_repeat_register",
+            object_id=self.xform.pk,
+            content_type=ContentType.objects.get_for_model(self.xform),
+        )
 
     def test_register(self):
         """Repeats from all instances are registered"""
+        self.assertEqual(self.register.extra_data, {})
+
         register_xform_export_repeats(self.xform)
 
         metadata = MetaData.objects.get(data_type="export_repeat_register")
diff --git a/onadata/libs/utils/logger_tools.py b/onadata/libs/utils/logger_tools.py
index 1d5edf63fe..807eda649c 100644
--- a/onadata/libs/utils/logger_tools.py
+++ b/onadata/libs/utils/logger_tools.py
@@ -1592,24 +1592,6 @@ def _update_export_repeat_register(instance: Instance, metadata: MetaData) -> No
             )
 
 
-def _get_export_repeat_register(xform: XForm) -> tuple[MetaData, bool]:
-    """Get or create the export repeat register
-
-    :param xform: XForm object
-    :return: Tuple of MetaData object and a boolean indicating if it was
-            created
-    """
-    content_type = ContentType.objects.get_for_model(xform)
-    obj, created = MetaData.objects.get_or_create(
-        content_type=content_type,
-        object_id=xform.pk,
-        data_type=EXPORT_REPEAT_REGISTER,
-        defaults={"data_value": ""},
-    )
-
-    return obj, created
-
-
 def _is_submission_approved(instance: Instance) -> bool:
     """Check if a submission has been approved
 
@@ -1640,13 +1622,19 @@ def register_instance_export_repeats(instance: Instance) -> None:
 
     :param instance: Instance object
     """
-    metadata, created = _get_export_repeat_register(instance.xform)
+    content_type = ContentType.objects.get_for_model(instance.xform)
 
-    if created:
-        register_xform_export_repeats(instance.xform)
+    try:
+        metadata = MetaData.objects.get(
+            content_type=content_type,
+            object_id=instance.xform.pk,
+            data_type=EXPORT_REPEAT_REGISTER,
+        )
 
-    else:
-        _update_export_repeat_register(instance, metadata)
+    except MetaData.DoesNotExist:
+        return
+
+    _update_export_repeat_register(instance, metadata)
 
 
 @transaction.atomic()
@@ -1655,7 +1643,13 @@ def register_xform_export_repeats(xform: XForm) -> None:
 
     :param xform: XForm object
     """
-    metadata, _ = _get_export_repeat_register(xform)
+    content_type = ContentType.objects.get_for_model(xform)
+    metadata, _ = MetaData.objects.get_or_create(
+        content_type=content_type,
+        object_id=xform.pk,
+        data_type=EXPORT_REPEAT_REGISTER,
+        defaults={"data_value": ""},
+    )
     instance_qs = xform.instances.filter(deleted_at__isnull=True)
 
     for instance in queryset_iterator(instance_qs):