diff --git a/e2e_config.test.json b/e2e_config.test.json
index b0b7aa4..e8fe44d 100644
--- a/e2e_config.test.json
+++ b/e2e_config.test.json
@@ -1,9 +1,8 @@
 {
   "accounts.account.id": "ACC-9042-0088",
   "accounts.api_token.id": "TKN-8857-1729",
-  "accounts.buyer.account.id": "ACC-1086-6867",
+  "accounts.client_account.id": "ACC-1086-6867",
   "accounts.buyer.id": "BUY-1591-2112",
-  "accounts.licensee.account.id": "ACC-1086-6867",
   "accounts.licensee.group.id": "UGR-2757-7226",
   "accounts.licensee.id": "LCE-5758-4071-6507",
   "accounts.module.id": "MOD-1756",
diff --git a/seed/accounts/account.py b/seed/accounts/account.py
new file mode 100644
index 0000000..a6f373a
--- /dev/null
+++ b/seed/accounts/account.py
@@ -0,0 +1,38 @@
+import logging
+import os
+from functools import partial
+
+from dependency_injector.wiring import Provide, inject
+
+from seed.container import Container
+from seed.context import Context
+from seed.helper import init_resource
+
+logger = logging.getLogger(__name__)
+
+
+@inject
+async def init_account_id(env_var: str, context: Context = Provide[Container.context]) -> str:  # noqa: RUF029
+    """Generic initializer for account IDs from environment variables."""
+    account_id = os.getenv(env_var)
+    if not account_id:
+        raise ValueError(f"{env_var} environment variable is required")
+    return account_id
+
+
+async def seed_account_ids() -> None:
+    """Seed account."""
+    logger.debug("Seeding vendor account ...")
+    await init_resource(
+        "accounts.account.id",
+        partial(init_account_id, "VENDOR_ACCOUNT_ID", context=Provide[Container.context]),
+    )
+    await init_resource(
+        "accounts.client_account.id",
+        partial(init_account_id, "CLIENT_ACCOUNT_ID", context=Provide[Container.context]),
+    )
+    await init_resource(
+        "accounts.operations_account.id",
+        partial(init_account_id, "OPERATIONS_ACCOUNT_ID", context=Provide[Container.context]),
+    )
+    logger.debug("Seeding account completed.")
diff --git a/seed/accounts/accounts.py b/seed/accounts/accounts.py
index 389a61c..cf11ca3 100644
--- a/seed/accounts/accounts.py
+++ b/seed/accounts/accounts.py
@@ -1,5 +1,6 @@
 import logging
 
+from seed.accounts.account import seed_account_ids
 from seed.accounts.api_tokens import seed_api_token
 from seed.accounts.buyer import seed_buyer
 from seed.accounts.licensee import seed_licensee
@@ -10,9 +11,12 @@
 logger = logging.getLogger(__name__)
 
 
-async def seed_accounts() -> None:  # noqa: WPS217
+async def seed_accounts() -> None:  # noqa: WPS217, WPS213
     """Seed accounts data including account."""
     logger.debug("Seeding accounts ...")
+
+    await seed_account_ids()
+
     await seed_seller()
     await seed_buyer()
     await seed_module()
diff --git a/seed/accounts/api_tokens.py b/seed/accounts/api_tokens.py
index 4dfd984..9da9a0f 100644
--- a/seed/accounts/api_tokens.py
+++ b/seed/accounts/api_tokens.py
@@ -1,5 +1,4 @@
 import logging
-import os
 
 from dependency_injector.wiring import Provide, inject
 
@@ -7,38 +6,18 @@
 from mpt_api_client.resources.accounts.api_tokens import ApiToken
 from seed.container import Container
 from seed.context import Context
+from seed.helper import init_resource, require_context_id
 
 logger = logging.getLogger(__name__)
 
 
-@inject
-async def get_api_token(
-    context: Context = Provide[Container.context],
-    mpt_ops: AsyncMPTClient = Provide[Container.mpt_operations],
-) -> ApiToken | None:
-    """Get API token from context or fetch from API."""
-    api_token_id = context.get_string("accounts.api_token.id")
-    if not api_token_id:
-        return None
-    try:
-        api_token = context.get_resource("accounts.api_token", api_token_id)
-    except ValueError:
-        api_token = None
-    if not isinstance(api_token, ApiToken):
-        api_token = await mpt_ops.accounts.api_tokens.get(api_token_id)
-        context.set_resource("accounts.api_token", api_token)
-        context["accounts.api_token.id"] = api_token.id
-        return api_token
-    return api_token
-
-
 @inject
 def build_api_token_data(
     context: Context = Provide[Container.context],
 ) -> dict[str, object]:
     """Get API token data dictionary for creation."""
-    account_id = os.getenv("CLIENT_ACCOUNT_ID")
-    module_id = context.get_string("accounts.module.id")
+    account_id = require_context_id(context, "accounts.client_account.id", "creating API token")
+    module_id = require_context_id(context, "accounts.module.id", "creating API token")
     return {
         "account": {"id": account_id},
         "name": "E2E Seeded API Token",
@@ -49,27 +28,18 @@ def build_api_token_data(
 
 
 @inject
-async def init_api_token(
+async def create_api_token(
     context: Context = Provide[Container.context],
     mpt_ops: AsyncMPTClient = Provide[Container.mpt_operations],
 ) -> ApiToken:
-    """Get or create API token."""
-    api_token = await get_api_token(context=context, mpt_ops=mpt_ops)
-    if api_token is None:
-        logger.debug("Creating API token ...")
-        api_token_data = build_api_token_data(context=context)
-        api_token = await mpt_ops.accounts.api_tokens.create(api_token_data)
-        context.set_resource("accounts.api_token", api_token)
-        context["accounts.api_token.id"] = api_token.id
-        logger.info("API token created: %s", api_token.id)
-    else:
-        logger.info("API token found: %s", api_token.id)
-    return api_token
+    """Creates an API token."""
+    logger.debug("Creating API token ...")
+    api_token_data = build_api_token_data(context=context)
+    return await mpt_ops.accounts.api_tokens.create(api_token_data)
 
 
-@inject
 async def seed_api_token() -> None:
     """Seed API token."""
     logger.debug("Seeding API token ...")
-    await init_api_token()
+    await init_resource("accounts.api_token.id", create_api_token)
     logger.debug("Seeding API token completed.")
diff --git a/seed/accounts/buyer.py b/seed/accounts/buyer.py
index d3840e6..e407168 100644
--- a/seed/accounts/buyer.py
+++ b/seed/accounts/buyer.py
@@ -1,5 +1,4 @@
 import logging
-import os
 
 from dependency_injector.wiring import Provide, inject
 
@@ -7,44 +6,21 @@
 from mpt_api_client.resources.accounts.buyers import Buyer
 from seed.container import Container
 from seed.context import Context
+from seed.helper import init_resource, require_context_id
 from seed.static.static import ICON
 
 logger = logging.getLogger(__name__)
 
 
-@inject
-async def get_buyer(
-    context: Context = Provide[Container.context],
-    mpt_operations: AsyncMPTClient = Provide[Container.mpt_operations],
-) -> Buyer | None:
-    """Get buyer from context or fetch from API."""
-    buyer_id = context.get_string("accounts.buyer.id")
-    if not buyer_id:
-        return None
-    try:
-        buyer = context.get_resource("accounts.buyer", buyer_id)
-    except ValueError:
-        buyer = None
-    if not isinstance(buyer, Buyer):
-        buyer = await mpt_operations.accounts.buyers.get(buyer_id)
-        context.set_resource("accounts.buyer", buyer)
-        context["accounts.buyer.id"] = buyer.id
-        return buyer
-    return buyer
-
-
 @inject
 def build_buyer_data(context: Context = Provide[Container.context]) -> dict[str, object]:
     """Build buyer data dictionary for creation."""
-    buyer_account_id = os.getenv("CLIENT_ACCOUNT_ID")
-    if not buyer_account_id:
-        raise ValueError("CLIENT_ACCOUNT_ID environment variable is required")
-    seller_id = context.get_string("accounts.seller.id")
-    if not seller_id:
-        raise ValueError("accounts.seller.id missing from context; seed seller before buyer.")
+    client_account_id = require_context_id(context, "accounts.client_account.id", "creating buyer")
+    seller_id = require_context_id(context, "accounts.seller.id", "creating buyer")
+
     return {
         "name": "E2E Seeded Buyer",
-        "account": {"id": buyer_account_id},
+        "account": {"id": client_account_id},
         "sellers": [{"id": seller_id}],
         "contact": {
             "firstName": "first",
@@ -62,31 +38,19 @@ def build_buyer_data(context: Context = Provide[Container.context]) -> dict[str,
 
 
 @inject
-async def init_buyer(
+async def create_buyer(
     context: Context = Provide[Container.context],
     mpt_operations: AsyncMPTClient = Provide[Container.mpt_operations],
 ) -> Buyer:
-    """Get or create buyer."""
-    buyer = await get_buyer(context=context, mpt_operations=mpt_operations)
-    if buyer is None:
-        buyer_data = build_buyer_data(context=context)
-        logger.debug("Creating buyer ...")
-        with ICON.open("rb") as icon_fd:
-            created = await mpt_operations.accounts.buyers.create(buyer_data, file=icon_fd)
-        if isinstance(created, Buyer):
-            context.set_resource("accounts.buyer", created)
-            context["accounts.buyer.id"] = created.id
-            logger.info("Buyer created: %s", created.id)
-            return created
-        logger.warning("Buyer creation failed")  # type: ignore[unreachable]
-        raise ValueError("Buyer creation failed")
-    logger.info("Buyer found: %s", buyer.id)
-    return buyer
+    """Creates a buyer."""
+    buyer_data = build_buyer_data(context=context)
+    logger.debug("Creating buyer ...")
+    with ICON.open("rb") as icon_fd:
+        return await mpt_operations.accounts.buyers.create(buyer_data, file=icon_fd)
 
 
-@inject
 async def seed_buyer() -> None:
     """Seed buyer."""
     logger.debug("Seeding buyer ...")
-    await init_buyer()
+    await init_resource("accounts.buyer.id", create_buyer)
     logger.debug("Seeding buyer completed.")
diff --git a/seed/accounts/licensee.py b/seed/accounts/licensee.py
index b8a8274..f8a0bff 100644
--- a/seed/accounts/licensee.py
+++ b/seed/accounts/licensee.py
@@ -1,5 +1,4 @@
 import logging
-import os
 
 from dependency_injector.wiring import Provide, inject
 
@@ -7,50 +6,24 @@
 from mpt_api_client.resources.accounts.licensees import Licensee
 from seed.container import Container
 from seed.context import Context
+from seed.helper import init_resource, require_context_id
 from seed.static.static import ICON
 
 logger = logging.getLogger(__name__)
 
 
-@inject
-async def get_licensee(
-    context: Context = Provide[Container.context],
-    mpt_client: AsyncMPTClient = Provide[Container.mpt_client],
-) -> Licensee | None:
-    """Get licensee from context or fetch from API."""
-    licensee_id = context.get_string("accounts.licensee.id")
-    if not licensee_id:
-        return None
-    try:
-        licensee = context.get_resource("accounts.licensee", licensee_id)
-    except ValueError:
-        licensee = None
-    if not isinstance(licensee, Licensee):
-        licensee = await mpt_client.accounts.licensees.get(licensee_id)
-        context.set_resource("accounts.licensee", licensee)
-        context["accounts.licensee.id"] = licensee.id
-        return licensee
-    return licensee
-
-
 @inject
 def build_licensee_data(  # noqa: WPS238
     context: Context = Provide[Container.context],
 ) -> dict[str, object]:
     """Get licensee data dictionary for creation."""
-    account_id = os.getenv("CLIENT_ACCOUNT_ID")
-    if not account_id:
-        raise ValueError("CLIENT_ACCOUNT_ID environment variable is required")
-    seller_id = context.get_string("accounts.seller.id")
-    if not seller_id:
-        raise ValueError("Seller ID is required in context")
-    buyer_id = context.get_string("accounts.buyer.id")
-    if not buyer_id:
-        raise ValueError("Buyer ID is required in context")
-    group = context.get_resource("accounts.user_group")
-    if group is None:
-        raise ValueError("User group is required in context")
+    account_id = require_context_id(context, "accounts.client_account.id", "creating licensee")
+    seller_id = require_context_id(context, "accounts.seller.id", "creating licensee")
+    buyer_id = require_context_id(context, "accounts.buyer.id", "creating licensee")
+    group_id = require_context_id(context, "accounts.user_group.id", "creating licensee")
+
     licensee_type = "Client"
+
     return {
         "name": "E2E Seeded Licensee",
         "address": {
@@ -65,7 +38,7 @@ def build_licensee_data(  # noqa: WPS238
         "buyer": {"id": buyer_id},
         "account": {"id": account_id},
         "eligibility": {"client": True, "partner": False},
-        "groups": [{"id": group.id}],
+        "groups": [{"id": group_id}],
         "type": licensee_type,
         "status": "Enabled",
         "defaultLanguage": "en-US",
@@ -73,31 +46,19 @@ def build_licensee_data(  # noqa: WPS238
 
 
 @inject
-async def init_licensee(
+async def create_licensee(
     context: Context = Provide[Container.context],
     mpt_client: AsyncMPTClient = Provide[Container.mpt_client],
 ) -> Licensee:
-    """Get or create licensee."""
-    licensee = await get_licensee(context=context, mpt_client=mpt_client)
-    if licensee is None:
-        licensee_data = build_licensee_data(context=context)
-        logger.debug("Creating licensee ...")
-        with ICON.open("rb") as icon_file:
-            created = await mpt_client.accounts.licensees.create(licensee_data, file=icon_file)
-        if isinstance(created, Licensee):
-            context.set_resource("accounts.licensee", created)
-            context["accounts.licensee.id"] = created.id
-            logger.info("Licensee created: %s", created.id)
-            return created
-        logger.warning("Licensee creation failed")  # type: ignore[unreachable]
-        raise ValueError("Licensee creation failed")
-    logger.info("Licensee found: %s", licensee.id)
-    return licensee
+    """Creates a licensee."""
+    licensee_data = build_licensee_data(context=context)
+    logger.debug("Creating licensee ...")
+    with ICON.open("rb") as icon_fd:
+        return await mpt_client.accounts.licensees.create(licensee_data, file=icon_fd)
 
 
-@inject
 async def seed_licensee() -> None:
     """Seed licensee."""
     logger.debug("Seeding licensee ...")
-    await init_licensee()
+    await init_resource("accounts.licensee.id", create_licensee)
     logger.info("Seeding licensee completed.")
diff --git a/seed/accounts/module.py b/seed/accounts/module.py
index 5c9efa3..99c56b6 100644
--- a/seed/accounts/module.py
+++ b/seed/accounts/module.py
@@ -7,66 +7,32 @@
 from mpt_api_client.rql.query_builder import RQLQuery
 from seed.container import Container
 from seed.context import Context
+from seed.helper import init_resource
 
 logger = logging.getLogger(__name__)
 
 
-@inject
-async def get_module(
-    context: Context = Provide[Container.context],
-    mpt_operations: AsyncMPTClient = Provide[Container.mpt_operations],
-) -> Module | None:
-    """Get module from context or fetch from API."""
-    module_id = context.get_string("accounts.module.id")
-    if not module_id:
-        return None
-    try:
-        module = context.get_resource("accounts.module", module_id)
-    except ValueError:
-        module = None
-    if not isinstance(module, Module):
-        module = await mpt_operations.accounts.modules.get(module_id)
-        context.set_resource("accounts.module", module)
-        context["accounts.module.id"] = module.id
-        return module
-    return module
-
-
 @inject
 async def refresh_module(
     context: Context = Provide[Container.context],
     mpt_operations: AsyncMPTClient = Provide[Container.mpt_operations],
 ) -> Module | None:
     """Refresh module in context (always fetch)."""
-    module = await get_module(context=context, mpt_operations=mpt_operations)
-    if module is None:
-        filtered_modules = mpt_operations.accounts.modules.filter(
-            RQLQuery(name="Access Management")
-        )
-        modules = [mod async for mod in filtered_modules.iterate()]
-        if modules:
-            first_module = modules[0]
-            if isinstance(first_module, Module):
-                context["accounts.module.id"] = first_module.id
-                context.set_resource("accounts.module", first_module)
-                return first_module
-            logger.warning("First module is not a Module instance.")  # type: ignore[unreachable]
-            return None
-        logger.warning("Module 'Access Management' not found.")
-        return None
+    module = None
+    filtered_modules = mpt_operations.accounts.modules.filter(RQLQuery(name="Access Management"))
+    modules = [mod async for mod in filtered_modules.iterate()]
+    if modules:
+        first_module = modules[0]
+        if isinstance(first_module, Module):
+            context["accounts.module.id"] = first_module.id
+            module = first_module
+        logger.warning("First module is not a Module instance.")
+    logger.warning("Module 'Access Management' not found.")
     return module
 
 
-@inject
-async def seed_module() -> Module:
+async def seed_module() -> None:
     """Seed module."""
     logger.debug("Seeding module ...")
-    existing_module = await get_module()
-    if existing_module is None:
-        refreshed = await refresh_module()
-        logger.debug("Seeding module completed.")
-        if refreshed is None:
-            raise ValueError("Could not seed module: no valid Module found.")
-        return refreshed
+    await init_resource("accounts.module.id", refresh_module)
     logger.debug("Seeding module completed.")
-    return existing_module
diff --git a/seed/accounts/seller.py b/seed/accounts/seller.py
index 6159918..610de87 100644
--- a/seed/accounts/seller.py
+++ b/seed/accounts/seller.py
@@ -6,32 +6,11 @@
 from mpt_api_client import AsyncMPTClient
 from mpt_api_client.resources.accounts.sellers import Seller
 from seed.container import Container
-from seed.context import Context
+from seed.helper import init_resource
 
 logger = logging.getLogger(__name__)
 
 
-@inject
-async def get_seller(
-    context: Context = Provide[Container.context],
-    mpt_operations: AsyncMPTClient = Provide[Container.mpt_operations],
-) -> Seller | None:
-    """Get seller from context or fetch from API."""
-    seller_id = context.get_string("accounts.seller.id")
-    if not seller_id:
-        return None
-    try:
-        seller = context.get_resource("accounts.seller", seller_id)
-    except ValueError:
-        seller = None
-    if not isinstance(seller, Seller):
-        seller = await mpt_operations.accounts.sellers.get(seller_id)
-        context.set_resource("accounts.seller", seller)
-        context["accounts.seller.id"] = seller.id
-        return seller
-    return seller
-
-
 def build_seller_data(external_id: str | None = None) -> dict[str, object]:
     """Get seller data dictionary for creation."""
     if external_id is None:
@@ -51,29 +30,16 @@ def build_seller_data(external_id: str | None = None) -> dict[str, object]:
 
 
 @inject
-async def init_seller(
-    context: Context = Provide[Container.context],
+async def create_seller(
     mpt_operations: AsyncMPTClient = Provide[Container.mpt_operations],
-) -> Seller | None:
-    """Get or create seller. Returns Seller if successful, None otherwise."""
-    seller = await get_seller()
-    if seller is None:
-        logger.debug("Creating seller ...")
-        seller_data = build_seller_data()
-        created = await mpt_operations.accounts.sellers.create(seller_data)
-        if isinstance(created, Seller):
-            context.set_resource("accounts.seller", created)
-            context["accounts.seller.id"] = created.id
-            logger.info("Seller created: %s", created.id)
-            return created
-        logger.warning("Seller creation failed")  # type: ignore[unreachable]
-        return None
-    logger.info("Seller already exists: %s", seller.id)
-    return seller
+) -> Seller:
+    """Creates a seller."""
+    seller_data = build_seller_data()
+    return await mpt_operations.accounts.sellers.create(seller_data)
 
 
 async def seed_seller() -> None:
     """Seed seller."""
     logger.debug("Seeding seller ...")
-    await init_seller()
+    await init_resource("accounts.seller.id", create_seller)
     logger.debug("Seeding seller completed.")
diff --git a/seed/accounts/user_group.py b/seed/accounts/user_group.py
index db064ca..cdc33af 100644
--- a/seed/accounts/user_group.py
+++ b/seed/accounts/user_group.py
@@ -1,6 +1,4 @@
-# mypy: disable-error-code=unreachable
 import logging
-import os
 
 from dependency_injector.wiring import Provide, inject
 
@@ -8,40 +6,19 @@
 from mpt_api_client.resources.accounts.user_groups import UserGroup
 from seed.container import Container
 from seed.context import Context
+from seed.helper import init_resource, require_context_id
 
 logger = logging.getLogger(__name__)
 
 
-@inject
-async def get_user_group(
-    context: Context = Provide[Container.context],
-    mpt_operations: AsyncMPTClient = Provide[Container.mpt_operations],
-) -> UserGroup | None:
-    """Get user group from context or fetch from API."""
-    user_group_id = context.get_string("accounts.user_group.id")
-    if not user_group_id:
-        return None
-    try:
-        user_group = context.get_resource("accounts.user_group", user_group_id)
-    except ValueError:
-        user_group = None
-    if not isinstance(user_group, UserGroup):
-        user_group = await mpt_operations.accounts.user_groups.get(user_group_id)
-        context.set_resource("accounts.user_group", user_group)
-        context["accounts.user_group.id"] = user_group.id
-        return user_group
-    return user_group
-
-
 @inject
 def build_user_group_data(
     context: Context = Provide[Container.context],
 ) -> dict[str, object]:
     """Get user group data dictionary for creation."""
-    account_id = os.getenv("CLIENT_ACCOUNT_ID")
-    if not account_id:
-        raise ValueError("CLIENT_ACCOUNT_ID environment variable is required")
-    module_id = context.get_string("accounts.module.id")
+    account_id = require_context_id(context, "accounts.client_account.id", "creating user group")
+    module_id = require_context_id(context, "accounts.module.id", "creating user group")
+
     return {
         "name": "E2E Seeded User Group",
         "account": {"id": account_id},
@@ -53,33 +30,17 @@ def build_user_group_data(
 
 
 @inject
-async def init_user_group(
+async def create_user_group(
     context: Context = Provide[Container.context],
     mpt_operations: AsyncMPTClient = Provide[Container.mpt_operations],
-) -> UserGroup | None:
-    """Get or create user group."""
-    user_group = await get_user_group(context=context, mpt_operations=mpt_operations)
-    if user_group is not None:
-        logger.info("User group already exists: %s", user_group.id)
-        return user_group
-
-    logger.debug("Creating user group ...")
+) -> UserGroup:
+    """Creates a user group."""
     user_group_data = build_user_group_data(context=context)
-    created = await mpt_operations.accounts.user_groups.create(user_group_data)
-    if isinstance(created, UserGroup):
-        context.set_resource("accounts.user_group", created)
-        context["accounts.user_group.id"] = created.id
-        logger.info("User group created: %s", created.id)
-        return created
+    return await mpt_operations.accounts.user_groups.create(user_group_data)
 
-    logger.warning("User group creation failed")
-    return None
 
-
-@inject
-async def seed_user_group() -> UserGroup | None:
+async def seed_user_group() -> None:
     """Seed user group."""
     logger.debug("Seeding user group ...")
-    user_group = await init_user_group()
+    await init_resource("accounts.user_group.id", create_user_group)
     logger.debug("Seeding user group completed.")
-    return user_group
diff --git a/seed/helper.py b/seed/helper.py
index 6cc4ae3..c267502 100644
--- a/seed/helper.py
+++ b/seed/helper.py
@@ -79,6 +79,6 @@ async def init_resource(
     id_value = context.get_string(namespace)
     if not id_value:
         resource = await resource_factory()
-        id_value = resource.id
+        id_value = resource if isinstance(resource, str) else resource.id
         context[namespace] = id_value
     return id_value
diff --git a/tests/e2e/accounts/buyers/conftest.py b/tests/e2e/accounts/buyers/conftest.py
index 06c753d..fce252d 100644
--- a/tests/e2e/accounts/buyers/conftest.py
+++ b/tests/e2e/accounts/buyers/conftest.py
@@ -7,10 +7,10 @@ def invalid_buyer_id():
 
 
 @pytest.fixture
-def buyer_factory(buyer_account_id):
+def buyer_factory(client_account_id):
     def _buyer(
         name="E2E Created Buyer",
-        account_id: str = buyer_account_id,
+        account_id: str = client_account_id,
     ):
         return {
             "name": name,
diff --git a/tests/e2e/accounts/buyers/test_async_buyers.py b/tests/e2e/accounts/buyers/test_async_buyers.py
index 388ae95..cb9b8b3 100644
--- a/tests/e2e/accounts/buyers/test_async_buyers.py
+++ b/tests/e2e/accounts/buyers/test_async_buyers.py
@@ -7,11 +7,11 @@
 
 
 @pytest.fixture
-async def async_created_buyer(async_mpt_ops, buyer_factory, buyer_account_id, account_icon):
+async def async_created_buyer(async_mpt_ops, buyer_factory, client_account_id, account_icon):
     """Fixture to create and yield an asynchronous buyer for testing."""
     new_buyer_request_data = buyer_factory(
         name="E2E Created Buyer",
-        account_id=buyer_account_id,
+        account_id=client_account_id,
     )
 
     new_buyer = await async_mpt_ops.accounts.buyers.create(
@@ -78,10 +78,10 @@ async def test_delete_buyer_not_found(async_mpt_ops, invalid_buyer_id):
 
 
 async def test_update_buyer(
-    async_mpt_ops, buyer_factory, buyer_account_id, account_icon, async_created_buyer
+    async_mpt_ops, buyer_factory, client_account_id, account_icon, async_created_buyer
 ):
     """Test updating a buyer asynchronously."""
-    updated_buyer_data = buyer_factory(name="E2E Updated Buyer", account_id=buyer_account_id)
+    updated_buyer_data = buyer_factory(name="E2E Updated Buyer", account_id=client_account_id)
 
     result = await async_mpt_ops.accounts.buyers.update(
         async_created_buyer.id, updated_buyer_data, file=account_icon
@@ -91,10 +91,10 @@ async def test_update_buyer(
 
 
 async def test_update_buyer_not_found(
-    async_mpt_ops, buyer_factory, buyer_account_id, account_icon, invalid_buyer_id
+    async_mpt_ops, buyer_factory, client_account_id, account_icon, invalid_buyer_id
 ):
     """Test updating a non-existent buyer raises a 404 error."""
-    updated_buyer_data = buyer_factory(name="Nonexistent Buyer", account_id=buyer_account_id)
+    updated_buyer_data = buyer_factory(name="Nonexistent Buyer", account_id=client_account_id)
 
     with pytest.raises(MPTAPIError, match=r"404 Not Found"):
         await async_mpt_ops.accounts.buyers.update(
diff --git a/tests/e2e/accounts/buyers/test_sync_buyers.py b/tests/e2e/accounts/buyers/test_sync_buyers.py
index b7acc44..86cc320 100644
--- a/tests/e2e/accounts/buyers/test_sync_buyers.py
+++ b/tests/e2e/accounts/buyers/test_sync_buyers.py
@@ -7,11 +7,11 @@
 
 
 @pytest.fixture
-def created_buyer(mpt_ops, buyer_factory, buyer_account_id, account_icon):
+def created_buyer(mpt_ops, buyer_factory, client_account_id, account_icon):
     """Fixture to create and yield a buyer for testing."""
     new_buyer_request_data = buyer_factory(
         name="E2E Created Buyer",
-        account_id=buyer_account_id,
+        account_id=client_account_id,
     )
 
     new_buyer = mpt_ops.accounts.buyers.create(new_buyer_request_data, file=account_icon)
@@ -75,9 +75,9 @@ def test_delete_buyer_not_found(mpt_ops, invalid_buyer_id):
         mpt_ops.accounts.buyers.delete(invalid_buyer_id)
 
 
-def test_update_buyer(mpt_ops, buyer_factory, buyer_account_id, account_icon, created_buyer):
+def test_update_buyer(mpt_ops, buyer_factory, client_account_id, account_icon, created_buyer):
     """Test updating a buyer synchronously."""
-    updated_buyer_data = buyer_factory(name="E2E Updated Buyer", account_id=buyer_account_id)
+    updated_buyer_data = buyer_factory(name="E2E Updated Buyer", account_id=client_account_id)
 
     result = mpt_ops.accounts.buyers.update(created_buyer.id, updated_buyer_data, file=account_icon)
 
@@ -85,10 +85,10 @@ def test_update_buyer(mpt_ops, buyer_factory, buyer_account_id, account_icon, cr
 
 
 def test_update_buyer_not_found(
-    mpt_ops, buyer_factory, buyer_account_id, account_icon, invalid_buyer_id
+    mpt_ops, buyer_factory, client_account_id, account_icon, invalid_buyer_id
 ):
     """Test updating a non-existent buyer raises a 404 error."""
-    updated_buyer_data = buyer_factory(name="Nonexistent Buyer", account_id=buyer_account_id)
+    updated_buyer_data = buyer_factory(name="Nonexistent Buyer", account_id=client_account_id)
 
     with pytest.raises(MPTAPIError, match=r"404 Not Found"):
         mpt_ops.accounts.buyers.update(invalid_buyer_id, updated_buyer_data, file=account_icon)
diff --git a/tests/e2e/accounts/licensees/conftest.py b/tests/e2e/accounts/licensees/conftest.py
index c62b95e..aef3e18 100644
--- a/tests/e2e/accounts/licensees/conftest.py
+++ b/tests/e2e/accounts/licensees/conftest.py
@@ -1,11 +1,6 @@
 import pytest
 
 
-@pytest.fixture
-def licensee_account_id(e2e_config):
-    return e2e_config["accounts.licensee.account.id"]
-
-
 @pytest.fixture
 def licensee_group_id(e2e_config):
     return e2e_config["accounts.licensee.group.id"]
@@ -17,12 +12,12 @@ def invalid_licensee_id():
 
 
 @pytest.fixture
-def licensee_factory(seller_id, buyer_id, user_group_factory, licensee_account_id):
+def licensee_factory(seller_id, buyer_id, user_group_factory, client_account_id):
     def _licensee(
         name: str = "Test E2E Licensee",
         licensee_type: str = "Client",
     ):
-        group = user_group_factory(user_group_account_id=licensee_account_id)
+        group = user_group_factory(user_group_account_id=client_account_id)
 
         return {
             "name": name,
@@ -36,7 +31,7 @@ def _licensee(
             "useBuyerAddress": False,
             "seller": {"id": seller_id},
             "buyer": {"id": buyer_id},
-            "account": {"id": licensee_account_id},
+            "account": {"id": client_account_id},
             "eligibility": {"client": True, "partner": False},
             "groups": [group],
             "type": licensee_type,
diff --git a/tests/e2e/catalog/pricing_policies/conftest.py b/tests/e2e/catalog/pricing_policies/conftest.py
index 546f35a..c002447 100644
--- a/tests/e2e/catalog/pricing_policies/conftest.py
+++ b/tests/e2e/catalog/pricing_policies/conftest.py
@@ -4,11 +4,11 @@
 
 
 @pytest.fixture
-def pricing_policy_data(buyer_account_id, product_id):
+def pricing_policy_data(client_account_id, product_id):
     return {
         "name": "e2e - pricing policy please delete",
         "description": "Test pricing policy description",
-        "client": {"id": buyer_account_id},
+        "client": {"id": client_account_id},
         "product": {"id": product_id},
         "eligibility": {"client": True, "partner": False},
         "margin": "0.20",
diff --git a/tests/e2e/conftest.py b/tests/e2e/conftest.py
index 14985b5..bb2beea 100644
--- a/tests/e2e/conftest.py
+++ b/tests/e2e/conftest.py
@@ -123,6 +123,11 @@ def account_id(e2e_config):
     return e2e_config["accounts.account.id"]
 
 
+@pytest.fixture
+def client_account_id(e2e_config):
+    return e2e_config["accounts.client_account.id"]
+
+
 @pytest.fixture
 def seller_id(e2e_config):
     return e2e_config["accounts.seller.id"]
@@ -133,11 +138,6 @@ def buyer_id(e2e_config):
     return e2e_config["accounts.buyer.id"]
 
 
-@pytest.fixture
-def buyer_account_id(e2e_config):
-    return e2e_config["accounts.buyer.account.id"]
-
-
 @pytest.fixture
 def licensee_id(e2e_config):
     return e2e_config["accounts.licensee.id"]
diff --git a/tests/seed/accounts/test_account.py b/tests/seed/accounts/test_account.py
new file mode 100644
index 0000000..ef9e941
--- /dev/null
+++ b/tests/seed/accounts/test_account.py
@@ -0,0 +1,36 @@
+import pytest
+
+from seed.accounts.account import init_account_id, seed_account_ids
+from seed.context import Context
+
+
+@pytest.fixture
+def context_without_data() -> Context:
+    return Context()
+
+
+@pytest.mark.parametrize(
+    ("env_var", "env_value"),
+    [
+        ("VENDOR_ACCOUNT_ID", "vendor-789"),
+        ("CLIENT_ACCOUNT_ID", "client-012"),
+        ("OPERATIONS_ACCOUNT_ID", "ops-345"),
+    ],
+)
+async def test_init_account_id(monkeypatch, context_without_data, env_var, env_value):
+    monkeypatch.setenv(env_var, env_value)
+    result = await init_account_id(env_var, context=context_without_data)
+    assert result == env_value
+
+
+async def test_seed_account_ids(mocker):
+    init_resource = mocker.patch(
+        "seed.accounts.account.init_resource",
+        new_callable=mocker.AsyncMock,
+    )
+
+    await seed_account_ids()
+
+    init_resource.assert_any_call("accounts.account.id", mocker.ANY)
+    init_resource.assert_any_call("accounts.client_account.id", mocker.ANY)
+    init_resource.assert_any_call("accounts.operations_account.id", mocker.ANY)
diff --git a/tests/seed/accounts/test_accounts.py b/tests/seed/accounts/test_accounts.py
index 64aa1ac..3404008 100644
--- a/tests/seed/accounts/test_accounts.py
+++ b/tests/seed/accounts/test_accounts.py
@@ -2,6 +2,9 @@
 
 
 async def test_seed_accounts(mocker):  # noqa: WPS210
+    mock_seed_account_ids = mocker.patch(
+        "seed.accounts.accounts.seed_account_ids", new_callable=mocker.AsyncMock
+    )
     mock_seed_seller = mocker.patch(
         "seed.accounts.accounts.seed_seller", new_callable=mocker.AsyncMock
     )
@@ -22,6 +25,7 @@ async def test_seed_accounts(mocker):  # noqa: WPS210
     )
     await seed_accounts()  # act
     mocks = [
+        mock_seed_account_ids,
         mock_seed_seller,
         mock_seed_buyer,
         mock_seed_module,
diff --git a/tests/seed/accounts/test_api_token.py b/tests/seed/accounts/test_api_token.py
index ffbeafa..07cd8eb 100644
--- a/tests/seed/accounts/test_api_token.py
+++ b/tests/seed/accounts/test_api_token.py
@@ -1,73 +1,56 @@
 import pytest
 
-from mpt_api_client.resources.accounts.api_tokens import ApiToken, AsyncApiTokensService
 from seed.accounts.api_tokens import (
     build_api_token_data,
-    get_api_token,
-    init_api_token,
+    create_api_token,
     seed_api_token,
 )
+from seed.context import Context
 
 
 @pytest.fixture
-def api_token():
-    return ApiToken({"id": "TOK-123", "name": "Test Token"})
+def context_with_data() -> Context:
+    ctx = Context()
+    ctx["accounts.client_account.id"] = "client-acct-789"
+    ctx["accounts.module.id"] = "mod-123"
+    return ctx
 
 
-@pytest.fixture
-def api_tokens_service(mocker):
-    return mocker.Mock(spec=AsyncApiTokensService)
-
-
-async def test_get_api_token(context, operations_client, api_token, api_tokens_service):
-    context["accounts.api_token.id"] = api_token.id
-    api_tokens_service.get.return_value = api_token
-    operations_client.accounts.api_tokens = api_tokens_service
-
-    result = await get_api_token(context=context, mpt_ops=operations_client)
-
-    assert result == api_token
-    assert context.get_resource("accounts.api_token", api_token.id) == api_token
-
-
-async def test_get_api_token_without_id(context):
-    result = await get_api_token(context=context)
-    assert result is None
-
-
-async def test_init_api_token(context, operations_client, api_tokens_service, api_token, mocker):
-    api_tokens_service.create.return_value = api_token
-    operations_client.accounts.api_tokens = api_tokens_service
-    mock_get_api_token = mocker.patch(
-        "seed.accounts.api_tokens.get_api_token", new_callable=mocker.AsyncMock
-    )
-    mock_build_api_token_data = mocker.patch("seed.accounts.api_tokens.build_api_token_data")
-    mock_get_api_token.return_value = None
-    mock_build_api_token_data.return_value = {"any": "payload"}
-    result = await init_api_token(context=context, mpt_ops=operations_client)
-    assert result == api_token
-    api_tokens_service.create.assert_called_once()
-
-
-def test_build_api_token_data(context, monkeypatch):
-    monkeypatch.setenv("CLIENT_ACCOUNT_ID", "ACC-1086-6867")
-    context["accounts.module.id"] = "MOD-456"
+def test_build_api_token_data(context_with_data):
     expected_data = {
-        "account": {"id": "ACC-1086-6867"},
+        "account": {"id": "client-acct-789"},
         "name": "E2E Seeded API Token",
         "description": "This is a seeded API token for end-to-end testing.",
         "icon": "",
-        "modules": [{"id": "MOD-456"}],
+        "modules": [{"id": "mod-123"}],
     }
 
-    result = build_api_token_data(context=context)
+    result = build_api_token_data(context=context_with_data)
 
     assert result == expected_data
 
 
+async def test_create_api_token(mocker, operations_client, context_with_data):
+    create_mock = mocker.AsyncMock(return_value={"id": "api-token-1"})
+    operations_client.accounts.api_tokens.create = create_mock
+
+    result = await create_api_token(
+        context=context_with_data,
+        mpt_ops=operations_client,
+    )
+
+    assert result == {"id": "api-token-1"}
+    args, _ = create_mock.await_args
+    payload = args[0]
+    assert payload["account"]["id"] == "client-acct-789"
+    assert payload["modules"][0]["id"] == "mod-123"
+
+
 async def test_seed_api_token(mocker):
-    mock_init_api_token = mocker.patch(
-        "seed.accounts.api_tokens.init_api_token", new_callable=mocker.AsyncMock
+    mock_init_resource = mocker.patch(
+        "seed.accounts.api_tokens.init_resource", new_callable=mocker.AsyncMock
     )
-    await seed_api_token()  # act
-    mock_init_api_token.assert_awaited_once()
+
+    await seed_api_token()
+
+    mock_init_resource.assert_called_once_with("accounts.api_token.id", create_api_token)
diff --git a/tests/seed/accounts/test_buyer.py b/tests/seed/accounts/test_buyer.py
index d54b316..08246be 100644
--- a/tests/seed/accounts/test_buyer.py
+++ b/tests/seed/accounts/test_buyer.py
@@ -1,43 +1,22 @@
 import pytest
 
-from mpt_api_client.resources.accounts.buyers import AsyncBuyersService, Buyer
-from seed.accounts.buyer import build_buyer_data, get_buyer, init_buyer, seed_buyer
+from seed.accounts.buyer import build_buyer_data, create_buyer, seed_buyer
 from seed.context import Context
 
 
 @pytest.fixture
-def buyer():
-    return Buyer({"id": "BUY-123", "name": "Test Buyer"})
+def context_with_data() -> Context:
+    ctx = Context()
+    ctx["accounts.client_account.id"] = "ACC-1111-1111"
+    ctx["accounts.seller.id"] = "SEL-2222-2222"
+    return ctx
 
 
-@pytest.fixture
-def buyers_service(mocker):
-    return mocker.Mock(spec=AsyncBuyersService)
-
-
-async def test_get_buyer(context: Context, operations_client, buyer, buyers_service):
-    context["accounts.buyer.id"] = buyer.id
-    buyers_service.get.return_value = buyer
-    operations_client.accounts.buyers = buyers_service
-
-    result = await get_buyer(context=context, mpt_operations=operations_client)
-
-    assert result == buyer
-    assert context.get_resource("accounts.buyer", buyer.id) == buyer
-
-
-async def test_get_buyer_without_id(context: Context):
-    result = await get_buyer(context=context)
-    assert result is None
-
-
-def test_build_buyer_data(context: Context):
-    context["accounts.account.id"] = "ACC-1086-6867"
-    context["accounts.seller.id"] = "SEL-9999-9999"
+def test_build_buyer_data(context_with_data):
     expected_data = {
         "name": "E2E Seeded Buyer",
         "account": {
-            "id": "ACC-1086-6867",
+            "id": "ACC-1111-1111",
         },
         "contact": {
             "firstName": "first",
@@ -51,44 +30,36 @@ def test_build_buyer_data(context: Context):
             "postCode": "12345",
             "country": "US",
         },
-        "sellers": [{"id": "SEL-9999-9999"}],
+        "sellers": [{"id": "SEL-2222-2222"}],
     }
 
-    result = build_buyer_data(context=context)
+    result = build_buyer_data(context=context_with_data)
 
     assert result == expected_data
 
 
-async def test_init_buyer(context: Context, operations_client, buyers_service, buyer, mocker):
-    buyers_service.create.return_value = buyer
-    operations_client.accounts.buyers = buyers_service
-    mock_get_buyer = mocker.patch("seed.accounts.buyer.get_buyer", new_callable=mocker.AsyncMock)
-    mock_get_buyer.return_value = buyer
-    result = await init_buyer(context=context, mpt_operations=operations_client)
-    assert result == buyer
-    buyers_service.create.assert_not_called()
+async def test_create_buyer(mocker, operations_client, context_with_data):
+    create_mock = mocker.AsyncMock(return_value={"id": "buyer-1"})
+    operations_client.accounts.buyers.create = create_mock
 
+    result = await create_buyer(
+        context=context_with_data,
+        mpt_operations=operations_client,
+    )
 
-async def test_init_buyer_create_new(  # noqa: WPS211
-    context: Context,
-    operations_client,
-    buyers_service,
-    buyer,
-    monkeypatch,
-    fs,
-):
-    buyers_service.create.return_value = buyer
-    operations_client.accounts.buyers = buyers_service
-    monkeypatch.setenv("CLIENT_ACCOUNT_ID", "ACC-1086-6867")
-    context["accounts.seller.id"] = "SEL-9999-9999"
-    fs.create_file("/fake/path/buyer.txt", contents=b"fake_buyer_bytes")
-    fs.create_file("/mpt_api_client/seed/data/logo.png", contents=b"fake_icon_bytes")
-    result = await init_buyer(context=context, mpt_operations=operations_client)
-    assert result == buyer
-    buyers_service.create.assert_called_once()
+    assert result == {"id": "buyer-1"}
+    args, _ = create_mock.await_args
+    payload = args[0]
+    assert payload["name"] == "E2E Seeded Buyer"
+    assert payload["account"]["id"] == "ACC-1111-1111"
+    assert payload["sellers"][0]["id"] == "SEL-2222-2222"
 
 
 async def test_seed_buyer(mocker):
-    mock_init_buyer = mocker.patch("seed.accounts.buyer.init_buyer", new_callable=mocker.AsyncMock)
-    await seed_buyer()  # act
-    mock_init_buyer.assert_awaited_once()
+    mock_init_resource = mocker.patch(
+        "seed.accounts.buyer.init_resource", new_callable=mocker.AsyncMock
+    )
+
+    await seed_buyer()
+
+    mock_init_resource.assert_awaited_once()
diff --git a/tests/seed/accounts/test_licensee.py b/tests/seed/accounts/test_licensee.py
index d52809b..fcfce8d 100644
--- a/tests/seed/accounts/test_licensee.py
+++ b/tests/seed/accounts/test_licensee.py
@@ -1,60 +1,20 @@
 import pytest
 
-from mpt_api_client.models.model import Model
-from mpt_api_client.resources.accounts.licensees import AsyncLicenseesService, Licensee
-from seed.accounts.licensee import build_licensee_data, get_licensee, init_licensee, seed_licensee
+from seed.accounts.licensee import build_licensee_data, create_licensee, seed_licensee
 from seed.context import Context
 
 
 @pytest.fixture
-def licensee():
-    return Licensee({
-        "id": "LIC-123",
-        "name": "E2E Seeded Licensee",
-        "account": {"id": "ACC-1086-6867"},
-        "contact": {
-            "firstName": "first",
-            "lastName": "last",
-            "email": "created.licensee@example.com",
-        },
-        "address": {
-            "addressLine1": "123 Main St",
-            "city": "Los Angeles",
-            "state": "CA",
-            "postCode": "67890",
-            "country": "US",
-        },
-        "group": {"id": "UG-123"},
-    })
-
-
-@pytest.fixture
-def licensees_service(mocker):
-    return mocker.Mock(spec=AsyncLicenseesService)
+def context_with_data() -> Context:
+    ctx = Context()
+    ctx["accounts.client_account.id"] = "ACC-1111-1111"
+    ctx["accounts.seller.id"] = "SEL-2222-2222"
+    ctx["accounts.buyer.id"] = "BUY-3333-3333"
+    ctx["accounts.user_group.id"] = "UGR-4444-4444"
+    return ctx
 
 
-async def test_get_licensee(context: Context, client_client, licensee, licensees_service):
-    context["accounts.licensee.id"] = licensee.id
-    licensees_service.get.return_value = licensee
-    client_client.accounts.licensees = licensees_service
-
-    result = await get_licensee(context=context, mpt_client=client_client)
-
-    assert result == licensee
-    assert context.get_resource("accounts.licensee", licensee.id) == licensee
-
-
-async def test_get_licensee_without_id(context: Context):
-    licensee = await get_licensee(context=context)
-    assert licensee is None
-
-
-def test_build_licensee_data(context: Context, monkeypatch):
-    monkeypatch.setenv("CLIENT_ACCOUNT_ID", "ACC-1086-6867")
-    context["accounts.user_group.id"] = "UG-123"
-    context.set_resource("accounts.user_group", Model({"id": "UG-123"}))
-    context["accounts.seller.id"] = "SEL-123"
-    context["accounts.buyer.id"] = "BUY-123"
+def test_build_licensee_data(context_with_data):
     expected = {
         "name": "E2E Seeded Licensee",
         "address": {
@@ -65,63 +25,45 @@ def test_build_licensee_data(context: Context, monkeypatch):
             "country": "US",
         },
         "useBuyerAddress": False,
-        "seller": {"id": "SEL-123"},
-        "buyer": {"id": "BUY-123"},
-        "account": {"id": "ACC-1086-6867"},
+        "seller": {"id": "SEL-2222-2222"},
+        "buyer": {"id": "BUY-3333-3333"},
+        "account": {"id": "ACC-1111-1111"},
         "eligibility": {"client": True, "partner": False},
-        "groups": [{"id": "UG-123"}],
+        "groups": [{"id": "UGR-4444-4444"}],
         "type": "Client",
         "status": "Enabled",
         "defaultLanguage": "en-US",
     }
 
-    result = build_licensee_data(context=context)
+    result = build_licensee_data(context=context_with_data)
 
     assert result == expected
 
 
-async def test_init_licensee(  # noqa: WPS211
-    context: Context, client_client, licensees_service, licensee, monkeypatch, mocker, fs
-):
-    licensees_service.create.return_value = licensee
-    client_client.accounts.licensees = licensees_service
-    monkeypatch.setenv("CLIENT_ACCOUNT_ID", "ACC-1086-6867")
-    context["accounts.user_group.id"] = "UG-123"
-    context.set_resource("accounts.user_group", Model({"id": "UG-123"}))
-    context["accounts.seller.id"] = "SEL-123"
-    context["accounts.buyer.id"] = "BUY-123"
-    mock_get_licensee = mocker.patch(
-        "seed.accounts.licensee.get_licensee", new_callable=mocker.AsyncMock
-    )
-    mocker.patch(
-        "seed.accounts.licensee.build_licensee_data", return_value=build_licensee_data(context)
-    )
-    mock_get_licensee.return_value = None
-    fs.create_file("/mpt_api_client/seed/data/logo.png", contents=b"fake_icon_bytes")
-    result = await init_licensee(context=context, mpt_client=client_client)
-    assert result == licensee
-    licensees_service.create.assert_called_once()
+async def test_create_licensee(mocker, client_client, context_with_data):  # noqa: WPS218
+    create_mock = mocker.AsyncMock(return_value={"id": "licensee-1"})
+    client_client.accounts.licensees.create = create_mock
 
+    result = await create_licensee(
+        context=context_with_data,
+        mpt_client=client_client,
+    )
 
-async def test_init_licensee_create_new(  # noqa: WPS211
-    context: Context, client_client, licensees_service, licensee, monkeypatch, fs, mocker
-):
-    licensees_service.create.return_value = licensee
-    client_client.accounts.licensees = licensees_service
-    monkeypatch.setenv("CLIENT_ACCOUNT_ID", "ACC-1086-6867")
-    context["accounts.user_group.id"] = "UG-123"
-    context.set_resource("accounts.user_group", Model({"id": "UG-123"}))
-    context["accounts.seller.id"] = "SEL-123"
-    context["accounts.buyer.id"] = "BUY-123"
-    fs.create_file("/mpt_api_client/seed/data/logo.png", contents=b"fake_icon_bytes")
-    result = await init_licensee(context=context, mpt_client=client_client)
-    assert result == licensee
-    licensees_service.create.assert_called_once()
+    assert result == {"id": "licensee-1"}
+    args, _ = create_mock.await_args
+    payload = args[0]
+    assert payload["name"] == "E2E Seeded Licensee"
+    assert payload["account"]["id"] == "ACC-1111-1111"
+    assert payload["seller"]["id"] == "SEL-2222-2222"
+    assert payload["buyer"]["id"] == "BUY-3333-3333"
+    assert payload["groups"][0]["id"] == "UGR-4444-4444"
 
 
 async def test_seed_licensee(mocker):
-    mock_init_licensee = mocker.patch(
-        "seed.accounts.licensee.init_licensee", new_callable=mocker.AsyncMock
+    mock_init_resource = mocker.patch(
+        "seed.accounts.licensee.init_resource", new_callable=mocker.AsyncMock
     )
-    await seed_licensee()  # act
-    mock_init_licensee.assert_awaited_once()
+
+    await seed_licensee()
+
+    mock_init_resource.assert_awaited_once()
diff --git a/tests/seed/accounts/test_module.py b/tests/seed/accounts/test_module.py
index 432d1dc..721585e 100644
--- a/tests/seed/accounts/test_module.py
+++ b/tests/seed/accounts/test_module.py
@@ -1,7 +1,7 @@
 import pytest
 
 from mpt_api_client.resources.accounts.modules import AsyncModulesService, Module
-from seed.accounts.module import get_module, refresh_module, seed_module
+from seed.accounts.module import refresh_module, seed_module
 from seed.context import Context
 
 
@@ -19,6 +19,13 @@ async def __anext__(self):
             raise StopAsyncIteration from err
 
 
+@pytest.fixture
+def context_with_data() -> Context:
+    ctx = Context()
+    ctx["accounts.module.id"] = "MOD-123"
+    return ctx
+
+
 @pytest.fixture
 def module():
     return Module({"id": "MOD-123", "name": "Test Module"})
@@ -33,61 +40,26 @@ def async_iter(iter_items):
     yield from iter_items
 
 
-async def test_get_module(context: Context, operations_client, module, modules_service):
-    context["accounts.module.id"] = module.id
-    modules_service.get.return_value = module
-    operations_client.accounts.modules = modules_service
-
-    result = await get_module(context=context, mpt_operations=operations_client)
-
-    assert result == module
-    assert context.get_resource("accounts.module", module.id) == module
-
-
-async def test_get_module_without_id(context: Context):
-    result = await get_module(context=context)
-    assert result is None
-
-
-async def test_refresh_module(context: Context, operations_client, modules_service, module, mocker):
-    modules_service.refresh = mocker.AsyncMock(return_value=module)
-    operations_client.accounts.modules = modules_service
-    context["accounts.module.id"] = module.id
-    mock_get_module = mocker.patch("seed.accounts.module.get_module", new_callable=mocker.AsyncMock)
-    mocker.patch("seed.accounts.module.Module", new=Module)
-    mocker.patch.object(
-        operations_client.accounts.modules, "filter", return_value=mocker.AsyncMock()
-    )
-    mock_get_module.return_value = None
-    modules_filter = operations_client.accounts.modules.filter
-    modules_filter.return_value.iterate = lambda: DummyAsyncIterator([module])
-    result = await refresh_module(context=context, mpt_operations=operations_client)
-    assert result == module
-
-
-async def test_refresh_module_get_new(
-    context: Context, operations_client, modules_service, module, mocker
+async def test_refresh_module(
+    context_with_data, operations_client, modules_service, module, mocker
 ):
     modules_service.refresh = mocker.AsyncMock(return_value=module)
     operations_client.accounts.modules = modules_service
-    context["accounts.module.id"] = module.id
-    mock_get_module = mocker.patch("seed.accounts.module.get_module", new_callable=mocker.AsyncMock)
     mocker.patch("seed.accounts.module.Module", new=Module)
     mocker.patch.object(
         operations_client.accounts.modules, "filter", return_value=mocker.AsyncMock()
     )
-    mock_get_module.return_value = None
     modules_filter = operations_client.accounts.modules.filter
     modules_filter.return_value.iterate = lambda: DummyAsyncIterator([module])
-    result = await refresh_module(context=context, mpt_operations=operations_client)
+    result = await refresh_module(context=context_with_data, mpt_operations=operations_client)
     assert result == module
 
 
 async def test_seed_module(mocker):
-    mock_get_module = mocker.patch("seed.accounts.module.get_module", new_callable=mocker.AsyncMock)
-    mock_refresh_module = mocker.patch(
-        "seed.accounts.module.refresh_module", new_callable=mocker.AsyncMock
+    mock_init_resource = mocker.patch(
+        "seed.accounts.module.init_resource", new_callable=mocker.AsyncMock
     )
-    mock_get_module.return_value = None
+
     await seed_module()
-    mock_refresh_module.assert_awaited_once()
+
+    mock_init_resource.assert_awaited_once()
diff --git a/tests/seed/accounts/test_seller.py b/tests/seed/accounts/test_seller.py
index 5d53fc7..58062f4 100644
--- a/tests/seed/accounts/test_seller.py
+++ b/tests/seed/accounts/test_seller.py
@@ -1,34 +1,12 @@
 import pytest
 
-from mpt_api_client.resources.accounts.sellers import AsyncSellersService, Seller
-from seed.accounts.seller import build_seller_data, get_seller, init_seller, seed_seller
+from seed.accounts.seller import build_seller_data, create_seller, seed_seller
 from seed.context import Context
 
 
 @pytest.fixture
-def seller():
-    return Seller({"id": "SEL-123", "name": "Test Seller"})
-
-
-@pytest.fixture
-def sellers_service(mocker):
-    return mocker.Mock(spec=AsyncSellersService)
-
-
-async def test_get_seller(context: Context, operations_client, seller, sellers_service):
-    context["accounts.seller.id"] = seller.id
-    sellers_service.get.return_value = seller
-    operations_client.accounts.sellers = sellers_service
-
-    result = await get_seller(context=context, mpt_operations=operations_client)
-
-    assert result == seller
-    assert context.get_resource("accounts.seller", seller.id) == seller
-
-
-async def test_get_seller_without_id(context: Context):
-    result = await get_seller(context=context)
-    assert result is None
+def context_without_data() -> Context:
+    return Context()
 
 
 def test_build_seller_data():
@@ -51,32 +29,25 @@ def test_build_seller_data():
     assert result == seller_data
 
 
-async def test_init_seller(context: Context, operations_client, sellers_service, seller, mocker):
-    sellers_service.create.return_value = seller
-    operations_client.accounts.sellers = sellers_service
-    mocker.patch("seed.accounts.seller.get_seller", return_value=None)
-    result = await init_seller(context=context, mpt_operations=operations_client)
-    assert result == seller
-    sellers_service.create.assert_called_once()
-
+async def test_create_seller(mocker, operations_client):
+    create_mock = mocker.AsyncMock(return_value={"id": "SEL-1111-1111"})
+    operations_client.accounts.sellers.create = create_mock
 
-async def test_init_seller_create_new(
-    context: Context, operations_client, sellers_service, seller, mocker
-):
-    sellers_service.create.return_value = seller
-    operations_client.accounts.sellers = sellers_service
-    mocker.patch("seed.accounts.seller.get_seller", return_value=None)
-    mocker.patch(
-        "seed.accounts.seller.build_seller_data", return_value=build_seller_data("test-external-id")
+    result = await create_seller(
+        mpt_operations=operations_client,
     )
-    result = await init_seller(context, mpt_operations=operations_client)
-    assert result == seller
-    sellers_service.create.assert_called_once()
+
+    assert result == {"id": "SEL-1111-1111"}
+    args, _ = create_mock.await_args
+    payload = args[0]
+    assert payload["name"] == "E2E Seeded Seller"
 
 
 async def test_seed_seller(mocker):
-    mock_init_seller = mocker.patch(
-        "seed.accounts.seller.init_seller", new_callable=mocker.AsyncMock
+    mock_init_resource = mocker.patch(
+        "seed.accounts.seller.init_resource", new_callable=mocker.AsyncMock
     )
-    await seed_seller()  # act
-    mock_init_seller.assert_awaited_once()
+
+    await seed_seller()
+
+    mock_init_resource.assert_awaited_once()
diff --git a/tests/seed/accounts/test_user_group.py b/tests/seed/accounts/test_user_group.py
index 21d40bb..7b4191d 100644
--- a/tests/seed/accounts/test_user_group.py
+++ b/tests/seed/accounts/test_user_group.py
@@ -1,80 +1,58 @@
 import pytest
 
-from mpt_api_client.resources.accounts.user_groups import AsyncUserGroupsService, UserGroup
 from seed.accounts.user_group import (
     build_user_group_data,
-    get_user_group,
-    init_user_group,
+    create_user_group,
     seed_user_group,
 )
 from seed.context import Context
 
 
 @pytest.fixture
-def user_group():
-    return UserGroup({"id": "UG-123", "name": "Test User Group"})
+def context_with_data() -> Context:
+    ctx = Context()
+    ctx["accounts.client_account.id"] = "ACC-1111-1111"
+    ctx["accounts.module.id"] = "MOD-456"
+    return ctx
 
 
-@pytest.fixture
-def user_groups_service(mocker):
-    return mocker.Mock(spec=AsyncUserGroupsService)
-
-
-async def test_get_user_group(context: Context, operations_client, user_group, user_groups_service):
-    context["accounts.user_group.id"] = user_group.id
-    user_groups_service.get.return_value = user_group
-    operations_client.accounts.user_groups = user_groups_service
-
-    result = await get_user_group(context=context, mpt_operations=operations_client)
-
-    assert result == user_group
-    assert context.get_resource("accounts.user_group", user_group.id) == user_group
-
-
-async def test_get_user_group_without_id(context: Context):
-    result = await get_user_group(context=context)
-    assert result is None
-
-
-async def test_init_user_group(  # noqa: WPS211
-    context: Context, operations_client, user_groups_service, user_group, monkeypatch, mocker
-):
-    user_groups_service.create.return_value = user_group
-    operations_client.accounts.user_groups = user_groups_service
-    monkeypatch.setenv("CLIENT_ACCOUNT_ID", "ACC-1086-6867")
-    context["accounts.module.id"] = "MOD-456"
-    mocker.patch(
-        "seed.accounts.user_group.get_user_group", new_callable=mocker.AsyncMock, return_value=None
-    )
-    mocker.patch(
-        "seed.accounts.user_group.build_user_group_data",
-        return_value=build_user_group_data(context),
-    )
-    result = await init_user_group(context=context, mpt_operations=operations_client)
-    assert result == user_group
-    user_groups_service.create.assert_called_once()
-
-
-def test_build_user_group_data(context: Context, monkeypatch):
-    monkeypatch.setenv("CLIENT_ACCOUNT_ID", "ACC-1086-6867")
-    context["accounts.module.id"] = "MOD-456"
+def test_build_user_group_data(context_with_data):
     expected_data = {
         "name": "E2E Seeded User Group",
-        "account": {"id": "ACC-1086-6867"},
+        "account": {"id": "ACC-1111-1111"},
         "buyers": None,
         "logo": "",
         "description": "User group for E2E tests",
         "modules": [{"id": "MOD-456"}],
     }
 
-    result = build_user_group_data(context)
+    result = build_user_group_data(context=context_with_data)
 
     assert result == expected_data
 
 
+async def test_create_user_group(mocker, operations_client, context_with_data):
+    create_mock = mocker.AsyncMock(return_value={"id": "UGR-1111-1111"})
+    operations_client.accounts.user_groups.create = create_mock
+
+    result = await create_user_group(
+        context=context_with_data,
+        mpt_operations=operations_client,
+    )
+
+    assert result == {"id": "UGR-1111-1111"}
+    args, _ = create_mock.await_args
+    payload = args[0]
+    assert payload["name"] == "E2E Seeded User Group"
+    assert payload["account"]["id"] == "ACC-1111-1111"
+    assert payload["modules"][0]["id"] == "MOD-456"
+
+
 async def test_seed_user_group(mocker):
-    mock_init_user_group = mocker.patch(
-        "seed.accounts.user_group.init_user_group", new_callable=mocker.AsyncMock
+    mock_init_resource = mocker.patch(
+        "seed.accounts.user_group.init_resource", new_callable=mocker.AsyncMock
     )
-    await seed_user_group()  # act
-    mock_init_user_group.assert_awaited_once()
+
+    await seed_user_group()
+
+    mock_init_resource.assert_awaited_once()