diff --git a/Eternelle.slnx b/Eternelle.slnx
index b2c3b55..933c179 100644
--- a/Eternelle.slnx
+++ b/Eternelle.slnx
@@ -1,4 +1,19 @@
 <Solution>
+  <Folder Name="/docs/">
+    <File Path="docs/feature-gift-contributions.md" />
+    <File Path="docs/feature-guest-photo-upload.md" />
+    <File Path="docs/module-conventions.md" />
+  </Folder>
+  <Folder Name="/docs/superpowers/" />
+  <Folder Name="/docs/superpowers/plans/">
+    <File Path="docs/superpowers/plans/2026-05-20-users-module.md" />
+    <File Path="docs/superpowers/plans/2026-05-24-weddings-inbox-outbox-alignment.md" />
+    <File Path="docs/superpowers/plans/2026-05-27-catalog-module.md" />
+  </Folder>
+  <Folder Name="/docs/superpowers/specs/">
+    <File Path="docs/superpowers/specs/2026-05-20-users-module-design.md" />
+    <File Path="docs/superpowers/specs/2026-05-27-catalog-module-design.md" />
+  </Folder>
   <Folder Name="/Solution Items/">
     <File Path=".editorconfig" />
     <File Path="Directory.Build.props" />
@@ -15,6 +30,13 @@
     <Project Path="src/Common/Eternelle.Common.Presentation/Eternelle.Common.Presentation.csproj" Id="54cfc49d-e0bb-44a0-84ac-ee35515c1b5e" />
   </Folder>
   <Folder Name="/src/Modules/" />
+  <Folder Name="/src/Modules/Catalog/">
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj" />
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj" />
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj" />
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj" />
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj" />
+  </Folder>
   <Folder Name="/src/Modules/Users/">
     <Project Path="src/Modules/Users/Eternelle.Modules.Users.Application/Eternelle.Modules.Users.Application.csproj" Id="27530601-1743-4d73-80d3-bddbf28d8eb2" />
     <Project Path="src/Modules/Users/Eternelle.Modules.Users.Domain/Eternelle.Modules.Users.Domain.csproj" Id="823bb7bc-2382-4588-a404-73ae27f49b02" />
diff --git a/src/API/Eternelle.Api/Eternelle.Api.csproj b/src/API/Eternelle.Api/Eternelle.Api.csproj
index cc488d7..991e197 100644
--- a/src/API/Eternelle.Api/Eternelle.Api.csproj
+++ b/src/API/Eternelle.Api/Eternelle.Api.csproj
@@ -21,6 +21,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\Modules\Catalog\Eternelle.Modules.Catalog.Infrastructure\Eternelle.Modules.Catalog.Infrastructure.csproj" />
     <ProjectReference Include="..\..\Modules\Users\Eternelle.Modules.Users.Infrastructure\Eternelle.Modules.Users.Infrastructure.csproj" />
     <ProjectReference Include="..\..\Modules\Weddings\Eternelle.Modules.Weddings.Infrastructure\Eternelle.Modules.Weddings.Infrastructure.csproj" />
   </ItemGroup>
diff --git a/src/API/Eternelle.Api/Extensions/MigrationExtensions.cs b/src/API/Eternelle.Api/Extensions/MigrationExtensions.cs
index b56f3b5..0d62e02 100644
--- a/src/API/Eternelle.Api/Extensions/MigrationExtensions.cs
+++ b/src/API/Eternelle.Api/Extensions/MigrationExtensions.cs
@@ -1,3 +1,4 @@
+using Eternelle.Modules.Catalog.Infrastructure.Database;
 using Eternelle.Modules.Users.Infrastructure.Database;
 using Eternelle.Modules.Weddings.Infrastructure.Database;
 using Microsoft.EntityFrameworkCore;
@@ -12,6 +13,7 @@ public static void ApplyMigrations(this IApplicationBuilder app)
 
         ApplyMigration<WeddingsDbContext>(scope);
         ApplyMigration<UsersDbContext>(scope);
+        ApplyMigration<CatalogDbContext>(scope);
     }
 
     private static void ApplyMigration<TDbContext>(IServiceScope scope)
diff --git a/src/API/Eternelle.Api/Program.cs b/src/API/Eternelle.Api/Program.cs
index b77968e..df3a262 100644
--- a/src/API/Eternelle.Api/Program.cs
+++ b/src/API/Eternelle.Api/Program.cs
@@ -6,6 +6,7 @@
 using Eternelle.Common.Infrastructure;
 using Eternelle.Common.Infrastructure.Configuration;
 using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Modules.Catalog.Infrastructure;
 using Eternelle.Modules.Users.Infrastructure;
 using Eternelle.Modules.Weddings.Infrastructure;
 using Eternelle.Modules.Weddings.Presentation;
@@ -25,7 +26,8 @@
 
 builder.Services.AddApplication([
     Eternelle.Modules.Weddings.Application.AssemblyReference.Assembly,
-    Eternelle.Modules.Users.Application.AssemblyReference.Assembly
+    Eternelle.Modules.Users.Application.AssemblyReference.Assembly,
+    Eternelle.Modules.Catalog.Application.AssemblyReference.Assembly
 ]);
 
 string databaseConnectionString = builder.Configuration.GetConnectionStringOrThrow("Database");
@@ -37,7 +39,7 @@
     databaseConnectionString: databaseConnectionString,
     redisConnectionString: redisConnectionString);
 
-builder.Configuration.AddModuleConfiguration(["weddings", "users"]);
+builder.Configuration.AddModuleConfiguration(["weddings", "users", "catalog"]);
 
 Uri keyCloakHealthUrl = builder.Configuration.GetKeyCloakHealthUrl();
 
@@ -50,6 +52,8 @@
 
 builder.Services.AddUsersModule(builder.Configuration);
 
+builder.Services.AddCatalogModule(builder.Configuration);
+
 builder.Services.AddRateLimiter(options =>
 {
     // IP-based fixed-window limiter for the public guest photo upload endpoint.
diff --git a/src/API/Eternelle.Api/modules.catalog.Development.json b/src/API/Eternelle.Api/modules.catalog.Development.json
new file mode 100644
index 0000000..61dfc8c
--- /dev/null
+++ b/src/API/Eternelle.Api/modules.catalog.Development.json
@@ -0,0 +1,8 @@
+{
+  "Catalog": {
+    "Outbox": {
+      "IntervalInSeconds": 10,
+      "BatchSize": 10
+    }
+  }
+}
diff --git a/src/API/Eternelle.Api/modules.catalog.json b/src/API/Eternelle.Api/modules.catalog.json
new file mode 100644
index 0000000..61dfc8c
--- /dev/null
+++ b/src/API/Eternelle.Api/modules.catalog.json
@@ -0,0 +1,8 @@
+{
+  "Catalog": {
+    "Outbox": {
+      "IntervalInSeconds": 10,
+      "BatchSize": 10
+    }
+  }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Abstractions/Data/IUnitOfWork.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Abstractions/Data/IUnitOfWork.cs
new file mode 100644
index 0000000..a47c928
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Abstractions/Data/IUnitOfWork.cs
@@ -0,0 +1,6 @@
+namespace Eternelle.Modules.Catalog.Application.Abstractions.Data;
+
+public interface IUnitOfWork
+{
+    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/AssemblyReference.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/AssemblyReference.cs
new file mode 100644
index 0000000..5600467
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/AssemblyReference.cs
@@ -0,0 +1,8 @@
+using System.Reflection;
+
+namespace Eternelle.Modules.Catalog.Application;
+
+public static class AssemblyReference
+{
+    public static readonly Assembly Assembly = typeof(AssemblyReference).Assembly;
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj
new file mode 100644
index 0000000..a6c704f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.Domain\Eternelle.Modules.Catalog.Domain.csproj" />
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.IntegrationEvents\Eternelle.Modules.Catalog.IntegrationEvents.csproj" />
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Application\Eternelle.Common.Application.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommand.cs
new file mode 100644
index 0000000..3f7a747
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommand.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
+
+public sealed record AddSectionVariantCommand(
+    Guid TemplateId,
+    SectionId SectionId,
+    string Variant,
+    bool IsDefault,
+    PriceClass PriceClass,
+    int? UploadLimit) : ICommand;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandHandler.cs
new file mode 100644
index 0000000..4dcd906
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandHandler.cs
@@ -0,0 +1,39 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
+
+internal sealed class AddSectionVariantCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<AddSectionVariantCommand>
+{
+    public async Task<Result> Handle(AddSectionVariantCommand command, CancellationToken cancellationToken)
+    {
+        Template? template = await templateRepository.GetAsync(new TemplateId(command.TemplateId), cancellationToken);
+        if (template is null)
+        {
+            return Result.Failure(TemplateErrors.NotFound(new TemplateId(command.TemplateId)));
+        }
+
+        Result addResult = template.AddSectionVariant(
+            command.SectionId, command.Variant.Trim(), command.IsDefault, command.PriceClass,
+            command.UploadLimit, dateTimeProvider.UtcNow);
+        if (addResult.IsFailure)
+        {
+            return addResult;
+        }
+
+        templateRepository.Update(template);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        await cacheService.RemoveAsync(CatalogCacheKeys.TemplateById(command.TemplateId), cancellationToken);
+
+        return Result.Success();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs
new file mode 100644
index 0000000..f1e3654
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs
@@ -0,0 +1,16 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
+
+internal sealed class AddSectionVariantCommandValidator : AbstractValidator<AddSectionVariantCommand>
+{
+    public AddSectionVariantCommandValidator()
+    {
+        RuleFor(c => c.TemplateId).NotEmpty();
+        RuleFor(c => c.SectionId).IsInEnum();
+        RuleFor(c => c.Variant).NotEmpty().MaximumLength(TemplateSectionVariant.MaxVariantLength);
+        RuleFor(c => c.PriceClass).IsInEnum();
+        RuleFor(c => c.UploadLimit).GreaterThan(0).When(c => c.UploadLimit is not null);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommand.cs
new file mode 100644
index 0000000..68cfaf0
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommand.cs
@@ -0,0 +1,9 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSupportedSection;
+
+public sealed record AddSupportedSectionCommand(
+    Guid TemplateId,
+    SectionId SectionId,
+    int DisplayOrder) : ICommand;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandHandler.cs
new file mode 100644
index 0000000..a988833
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandHandler.cs
@@ -0,0 +1,37 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSupportedSection;
+
+internal sealed class AddSupportedSectionCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<AddSupportedSectionCommand>
+{
+    public async Task<Result> Handle(AddSupportedSectionCommand command, CancellationToken cancellationToken)
+    {
+        Template? template = await templateRepository.GetAsync(new TemplateId(command.TemplateId), cancellationToken);
+        if (template is null)
+        {
+            return Result.Failure(TemplateErrors.NotFound(new TemplateId(command.TemplateId)));
+        }
+
+        Result addResult = template.AddSupportedSection(command.SectionId, command.DisplayOrder, dateTimeProvider.UtcNow);
+        if (addResult.IsFailure)
+        {
+            return addResult;
+        }
+
+        templateRepository.Update(template);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        await cacheService.RemoveAsync(CatalogCacheKeys.TemplateById(command.TemplateId), cancellationToken);
+
+        return Result.Success();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandValidator.cs
new file mode 100644
index 0000000..be601cc
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandValidator.cs
@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSupportedSection;
+
+internal sealed class AddSupportedSectionCommandValidator : AbstractValidator<AddSupportedSectionCommand>
+{
+    public AddSupportedSectionCommandValidator()
+    {
+        RuleFor(c => c.TemplateId).NotEmpty();
+        RuleFor(c => c.SectionId).IsInEnum();
+        RuleFor(c => c.DisplayOrder).GreaterThanOrEqualTo(0);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommand.cs
new file mode 100644
index 0000000..4b5806e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommand.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Application.Messaging;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddTemplateTheme;
+
+public sealed record AddTemplateThemeCommand(
+    Guid TemplateId,
+    int ThemeIndex,
+    string Name,
+    IReadOnlyDictionary<string, string> Colors,
+    IReadOnlyDictionary<string, string> Typography,
+    IReadOnlyDictionary<string, string>? Textures,
+    bool IsDark) : ICommand;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandHandler.cs
new file mode 100644
index 0000000..5dca8fc
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandHandler.cs
@@ -0,0 +1,48 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddTemplateTheme;
+
+internal sealed class AddTemplateThemeCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<AddTemplateThemeCommand>
+{
+    public async Task<Result> Handle(AddTemplateThemeCommand command, CancellationToken cancellationToken)
+    {
+        Template? template = await templateRepository.GetAsync(new TemplateId(command.TemplateId), cancellationToken);
+        if (template is null)
+        {
+            return Result.Failure(TemplateErrors.NotFound(new TemplateId(command.TemplateId)));
+        }
+
+        Result<TemplateThemeName> nameResult = TemplateThemeName.Create(command.Name);
+        if (nameResult.IsFailure)
+        {
+            return Result.Failure(nameResult.Error);
+        }
+
+        var colors = new ThemeColors(command.Colors);
+        var typography = new ThemeTypography(command.Typography);
+        ThemeTextures? textures = command.Textures is null ? null : new ThemeTextures(command.Textures);
+
+        Result addResult = template.AddTheme(
+            command.ThemeIndex, nameResult.Value, colors, typography, textures, command.IsDark, dateTimeProvider.UtcNow);
+        if (addResult.IsFailure)
+        {
+            return addResult;
+        }
+
+        templateRepository.Update(template);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        await cacheService.RemoveAsync(CatalogCacheKeys.TemplateById(command.TemplateId), cancellationToken);
+
+        return Result.Success();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs
new file mode 100644
index 0000000..b135666
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs
@@ -0,0 +1,17 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddTemplateTheme;
+
+internal sealed class AddTemplateThemeCommandValidator : AbstractValidator<AddTemplateThemeCommand>
+{
+    public AddTemplateThemeCommandValidator()
+    {
+        RuleFor(c => c.TemplateId).NotEmpty();
+        RuleFor(c => c.ThemeIndex).GreaterThanOrEqualTo(0);
+        RuleFor(c => c.Name).NotEmpty().MaximumLength(TemplateThemeName.MaxLength);
+        RuleFor(c => c.Colors).NotEmpty();
+        RuleFor(c => c.Typography).NotEmpty();
+        RuleFor(c => c.Textures).NotEmpty().When(c => c.Textures is not null);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CatalogCacheKeys.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CatalogCacheKeys.cs
new file mode 100644
index 0000000..3c462ce
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CatalogCacheKeys.cs
@@ -0,0 +1,18 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates;
+
+internal static class CatalogCacheKeys
+{
+    public static string TemplateById(Guid templateId) => $"catalog:template:{templateId}";
+
+    public static string TemplateList(TemplateTier? tier) =>
+        tier is null ? "catalog:templates:all" : $"catalog:templates:{tier}";
+
+    public static IReadOnlyList<string> AllTemplateListKeys() =>
+    [
+        TemplateList(null),
+        TemplateList(TemplateTier.FirstClass),
+        TemplateList(TemplateTier.Signature)
+    ];
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommand.cs
new file mode 100644
index 0000000..8af09bb
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommand.cs
@@ -0,0 +1,11 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
+
+public sealed record CreateTemplateCommand(
+    string Name,
+    string? Description,
+    TemplateTier Tier,
+    string? PreviewImageUrl,
+    IReadOnlyList<string>? Features) : ICommand<Guid>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs
new file mode 100644
index 0000000..375f5fb
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs
@@ -0,0 +1,84 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.Extensions.Logging;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
+
+internal sealed class CreateTemplateCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider,
+    ILogger<CreateTemplateCommandHandler> logger) : ICommandHandler<CreateTemplateCommand, Guid>
+{
+    public async Task<Result<Guid>> Handle(CreateTemplateCommand command, CancellationToken cancellationToken)
+    {
+        Result<TemplateName> nameResult = TemplateName.Create(command.Name);
+        if (nameResult.IsFailure)
+        {
+            return Result.Failure<Guid>(nameResult.Error);
+        }
+
+        TemplateDescription? description = null;
+        if (command.Description is not null)
+        {
+            Result<TemplateDescription> descriptionResult = TemplateDescription.Create(command.Description);
+            if (descriptionResult.IsFailure)
+            {
+                return Result.Failure<Guid>(descriptionResult.Error);
+            }
+            description = descriptionResult.Value;
+        }
+
+        ImageUrl? previewImageUrl = null;
+        if (command.PreviewImageUrl is not null)
+        {
+            Result<ImageUrl> previewResult = ImageUrl.Create(command.PreviewImageUrl);
+            if (previewResult.IsFailure)
+            {
+                return Result.Failure<Guid>(previewResult.Error);
+            }
+            previewImageUrl = previewResult.Value;
+        }
+
+        if (await templateRepository.NameExistsAsync(nameResult.Value.Value, cancellationToken))
+        {
+            return Result.Failure<Guid>(TemplateErrors.NameTaken);
+        }
+
+        Result<Template> templateResult = Template.Create(
+            nameResult.Value,
+            description,
+            command.Tier,
+            previewImageUrl,
+            command.Features ?? [],
+            dateTimeProvider.UtcNow);
+
+        if (templateResult.IsFailure)
+        {
+            return Result.Failure<Guid>(templateResult.Error);
+        }
+
+        templateRepository.Insert(templateResult.Value);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        foreach (string key in CatalogCacheKeys.AllTemplateListKeys())
+        {
+            try
+            {
+                await cacheService.RemoveAsync(key, cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to evict cache key '{Key}' after creating template {TemplateId}", key, templateResult.Value.Id.Value);
+            }
+        }
+
+        return templateResult.Value.Id.Value;
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandValidator.cs
new file mode 100644
index 0000000..c6cb900
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandValidator.cs
@@ -0,0 +1,16 @@
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
+
+internal sealed class CreateTemplateCommandValidator : AbstractValidator<CreateTemplateCommand>
+{
+    public CreateTemplateCommandValidator()
+    {
+        RuleFor(c => c.Name).NotEmpty().MaximumLength(TemplateName.MaxLength);
+        RuleFor(c => c.Description).MaximumLength(TemplateDescription.MaxLength).When(c => c.Description is not null);
+        RuleFor(c => c.Tier).IsInEnum();
+        RuleFor(c => c.PreviewImageUrl).MaximumLength(ImageUrl.MaxLength).When(c => c.PreviewImageUrl is not null);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQuery.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQuery.cs
new file mode 100644
index 0000000..b5c92f8
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQuery.cs
@@ -0,0 +1,8 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetSectionVariants;
+
+public sealed record GetSectionVariantsQuery(Guid TemplateId, SectionId SectionId)
+    : IQuery<IReadOnlyList<SectionVariantResponse>>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQueryHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQueryHandler.cs
new file mode 100644
index 0000000..8823201
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQueryHandler.cs
@@ -0,0 +1,41 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetSectionVariants;
+
+internal sealed class GetSectionVariantsQueryHandler(IDbConnectionFactory dbConnectionFactory)
+    : IQueryHandler<GetSectionVariantsQuery, IReadOnlyList<SectionVariantResponse>>
+{
+    public async Task<Result<IReadOnlyList<SectionVariantResponse>>> Handle(
+        GetSectionVariantsQuery query,
+        CancellationToken cancellationToken)
+    {
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        const string sql =
+            $"""
+            SELECT
+                id           AS {nameof(SectionVariantResponse.Id)},
+                section_id   AS {nameof(SectionVariantResponse.SectionId)},
+                variant      AS {nameof(SectionVariantResponse.Variant)},
+                is_default   AS {nameof(SectionVariantResponse.IsDefault)},
+                price_class  AS {nameof(SectionVariantResponse.PriceClass)},
+                upload_limit AS {nameof(SectionVariantResponse.UploadLimit)}
+            FROM catalog.template_section_variants
+            WHERE template_id = @TemplateId AND section_id = @SectionId
+            ORDER BY variant ASC
+            """;
+
+        IEnumerable<SectionVariantResponse> rows = await connection.QueryAsync<SectionVariantResponse>(
+            new CommandDefinition(
+                sql,
+                new { query.TemplateId, SectionId = query.SectionId.ToString() },
+                cancellationToken: cancellationToken));
+
+        return Result.Success<IReadOnlyList<SectionVariantResponse>>([.. rows]);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQuery.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQuery.cs
new file mode 100644
index 0000000..1481e10
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQuery.cs
@@ -0,0 +1,7 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetSupportedSections;
+
+public sealed record GetSupportedSectionsQuery(Guid TemplateId)
+    : IQuery<IReadOnlyList<SupportedSectionResponse>>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQueryHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQueryHandler.cs
new file mode 100644
index 0000000..cd09b42
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQueryHandler.cs
@@ -0,0 +1,35 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetSupportedSections;
+
+internal sealed class GetSupportedSectionsQueryHandler(IDbConnectionFactory dbConnectionFactory)
+    : IQueryHandler<GetSupportedSectionsQuery, IReadOnlyList<SupportedSectionResponse>>
+{
+    public async Task<Result<IReadOnlyList<SupportedSectionResponse>>> Handle(
+        GetSupportedSectionsQuery query,
+        CancellationToken cancellationToken)
+    {
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        const string sql =
+            $"""
+            SELECT
+                id            AS {nameof(SupportedSectionResponse.Id)},
+                section_id    AS {nameof(SupportedSectionResponse.SectionId)},
+                display_order AS {nameof(SupportedSectionResponse.DisplayOrder)}
+            FROM catalog.template_supported_sections
+            WHERE template_id = @TemplateId
+            ORDER BY display_order ASC
+            """;
+
+        IEnumerable<SupportedSectionResponse> rows = await connection.QueryAsync<SupportedSectionResponse>(
+            new CommandDefinition(sql, new { query.TemplateId }, cancellationToken: cancellationToken));
+
+        return Result.Success<IReadOnlyList<SupportedSectionResponse>>([.. rows]);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQuery.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQuery.cs
new file mode 100644
index 0000000..ef46ba7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQuery.cs
@@ -0,0 +1,5 @@
+using Eternelle.Common.Application.Messaging;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+public sealed record GetTemplateByIdQuery(Guid TemplateId) : IQuery<TemplateDetailResponse>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQueryHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQueryHandler.cs
new file mode 100644
index 0000000..f8ea139
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQueryHandler.cs
@@ -0,0 +1,107 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+internal sealed class GetTemplateByIdQueryHandler(
+    IDbConnectionFactory dbConnectionFactory,
+    ICacheService cacheService)
+    : IQueryHandler<GetTemplateByIdQuery, TemplateDetailResponse>
+{
+    public async Task<Result<TemplateDetailResponse>> Handle(
+        GetTemplateByIdQuery query,
+        CancellationToken cancellationToken)
+    {
+        string cacheKey = CatalogCacheKeys.TemplateById(query.TemplateId);
+
+        TemplateDetailResponse? cached =
+            await cacheService.GetAsync<TemplateDetailResponse>(cacheKey, cancellationToken);
+        if (cached is not null)
+        {
+            return Result.Success(cached);
+        }
+
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        const string headSql =
+            """
+            SELECT id, name, description, tier, preview_image_url
+            FROM catalog.templates
+            WHERE id = @TemplateId
+            """;
+
+        TemplateHeadRow? head = await connection.QuerySingleOrDefaultAsync<TemplateHeadRow>(
+            new CommandDefinition(headSql, new { query.TemplateId }, cancellationToken: cancellationToken));
+
+        if (head is null)
+        {
+            return Result.Failure<TemplateDetailResponse>(
+                TemplateErrors.NotFound(new TemplateId(query.TemplateId)));
+        }
+
+        const string themesSql =
+            $"""
+            SELECT
+                id            AS {nameof(ThemeResponse.Id)},
+                theme_index   AS {nameof(ThemeResponse.ThemeIndex)},
+                name          AS {nameof(ThemeResponse.Name)},
+                colors        AS {nameof(ThemeResponse.ColorsJson)},
+                typography    AS {nameof(ThemeResponse.TypographyJson)},
+                textures      AS {nameof(ThemeResponse.TexturesJson)},
+                is_dark       AS {nameof(ThemeResponse.IsDark)}
+            FROM catalog.template_themes
+            WHERE template_id = @TemplateId
+            ORDER BY theme_index ASC
+            """;
+
+        const string sectionsSql =
+            $"""
+            SELECT
+                id            AS {nameof(SupportedSectionResponse.Id)},
+                section_id    AS {nameof(SupportedSectionResponse.SectionId)},
+                display_order AS {nameof(SupportedSectionResponse.DisplayOrder)}
+            FROM catalog.template_supported_sections
+            WHERE template_id = @TemplateId
+            ORDER BY display_order ASC
+            """;
+
+        const string variantsSql =
+            $"""
+            SELECT
+                id           AS {nameof(SectionVariantResponse.Id)},
+                section_id   AS {nameof(SectionVariantResponse.SectionId)},
+                variant      AS {nameof(SectionVariantResponse.Variant)},
+                is_default   AS {nameof(SectionVariantResponse.IsDefault)},
+                price_class  AS {nameof(SectionVariantResponse.PriceClass)},
+                upload_limit AS {nameof(SectionVariantResponse.UploadLimit)}
+            FROM catalog.template_section_variants
+            WHERE template_id = @TemplateId
+            ORDER BY section_id ASC, variant ASC
+            """;
+
+        object args = new { TemplateId = head.Id };
+
+        IEnumerable<ThemeResponse> themes = await connection.QueryAsync<ThemeResponse>(
+            new CommandDefinition(themesSql, args, cancellationToken: cancellationToken));
+        IEnumerable<SupportedSectionResponse> sections = await connection.QueryAsync<SupportedSectionResponse>(
+            new CommandDefinition(sectionsSql, args, cancellationToken: cancellationToken));
+        IEnumerable<SectionVariantResponse> variants = await connection.QueryAsync<SectionVariantResponse>(
+            new CommandDefinition(variantsSql, args, cancellationToken: cancellationToken));
+
+        var result = new TemplateDetailResponse(
+            head.Id, head.Name, head.Description, head.Tier, head.PreviewImageUrl,
+            [.. themes], [.. sections], [.. variants]);
+
+        await cacheService.SetAsync(cacheKey, result, TimeSpan.FromMinutes(30), cancellationToken);
+
+        return Result.Success(result);
+    }
+
+    private sealed record TemplateHeadRow(
+        Guid Id, string Name, string? Description, string Tier, string? PreviewImageUrl);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/TemplateDetailResponse.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/TemplateDetailResponse.cs
new file mode 100644
index 0000000..7e5495d
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/TemplateDetailResponse.cs
@@ -0,0 +1,33 @@
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+public sealed record TemplateDetailResponse(
+    Guid Id,
+    string Name,
+    string? Description,
+    string Tier,
+    string? PreviewImageUrl,
+    IReadOnlyList<ThemeResponse> Themes,
+    IReadOnlyList<SupportedSectionResponse> Sections,
+    IReadOnlyList<SectionVariantResponse> Variants);
+
+public sealed record ThemeResponse(
+    Guid Id,
+    int ThemeIndex,
+    string Name,
+    string ColorsJson,
+    string TypographyJson,
+    string? TexturesJson,
+    bool IsDark);
+
+public sealed record SupportedSectionResponse(
+    Guid Id,
+    string SectionId,
+    int DisplayOrder);
+
+public sealed record SectionVariantResponse(
+    Guid Id,
+    string SectionId,
+    string Variant,
+    bool IsDefault,
+    string PriceClass,
+    int? UploadLimit);
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQuery.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQuery.cs
new file mode 100644
index 0000000..30f0c72
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQuery.cs
@@ -0,0 +1,7 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplates;
+
+public sealed record GetTemplatesQuery(TemplateTier? Tier)
+    : IQuery<IReadOnlyList<TemplateSummaryResponse>>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQueryHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQueryHandler.cs
new file mode 100644
index 0000000..ba986fd
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQueryHandler.cs
@@ -0,0 +1,52 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplates;
+
+internal sealed class GetTemplatesQueryHandler(
+    IDbConnectionFactory dbConnectionFactory,
+    ICacheService cacheService)
+    : IQueryHandler<GetTemplatesQuery, IReadOnlyList<TemplateSummaryResponse>>
+{
+    public async Task<Result<IReadOnlyList<TemplateSummaryResponse>>> Handle(
+        GetTemplatesQuery query,
+        CancellationToken cancellationToken)
+    {
+        string cacheKey = CatalogCacheKeys.TemplateList(query.Tier);
+
+        IReadOnlyList<TemplateSummaryResponse>? cached =
+            await cacheService.GetAsync<IReadOnlyList<TemplateSummaryResponse>>(cacheKey, cancellationToken);
+        if (cached is not null)
+        {
+            return Result.Success(cached);
+        }
+
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        const string sql =
+            $"""
+             SELECT
+                 t.id                AS {nameof(TemplateSummaryResponse.Id)},
+                 t.name              AS {nameof(TemplateSummaryResponse.Name)},
+                 t.description       AS {nameof(TemplateSummaryResponse.Description)},
+                 t.tier              AS {nameof(TemplateSummaryResponse.Tier)},
+                 t.preview_image_url AS {nameof(TemplateSummaryResponse.PreviewImageUrl)}
+             FROM catalog.templates t
+             WHERE (@Tier IS NULL OR t.tier = @Tier)
+             ORDER BY t.name ASC
+             """;
+
+        IEnumerable<TemplateSummaryResponse> rows = await connection.QueryAsync<TemplateSummaryResponse>(
+            new CommandDefinition(sql, new { Tier = query.Tier?.ToString() }, cancellationToken: cancellationToken));
+
+        IReadOnlyList<TemplateSummaryResponse> result = [.. rows];
+
+        await cacheService.SetAsync(cacheKey, result, TimeSpan.FromMinutes(30), cancellationToken);
+
+        return Result.Success(result);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/TemplateSummaryResponse.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/TemplateSummaryResponse.cs
new file mode 100644
index 0000000..ececb74
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/TemplateSummaryResponse.cs
@@ -0,0 +1,8 @@
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplates;
+
+public sealed record TemplateSummaryResponse(
+    Guid Id,
+    string Name,
+    string? Description,
+    string Tier,
+    string? PreviewImageUrl);
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/TemplateManifestChangedDomainEventHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/TemplateManifestChangedDomainEventHandler.cs
new file mode 100644
index 0000000..a9f5c8e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/TemplateManifestChangedDomainEventHandler.cs
@@ -0,0 +1,27 @@
+using Eternelle.Common.Application.EventBus;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Eternelle.Modules.Catalog.IntegrationEvents;
+
+namespace Eternelle.Modules.Catalog.Application.Templates;
+
+internal sealed class TemplateManifestChangedDomainEventHandler(IEventBus eventBus)
+    : DomainEventHandler<TemplateManifestChangedDomainEvent>
+{
+    public override async Task Handle(
+        TemplateManifestChangedDomainEvent domainEvent,
+        CancellationToken cancellationToken = default)
+    {
+        await eventBus.PublishAsync(
+            new CatalogTemplateManifestChangedIntegrationEvent(
+                domainEvent.Id,
+                domainEvent.OccurredOnUtc,
+                domainEvent.TemplateId.Value,
+                domainEvent.Name,
+                domainEvent.Tier,
+                domainEvent.SectionIds,
+                [.. domainEvent.Variants.Select(v => new SectionVariantManifest(
+                    v.SectionId, v.Variant, v.PriceClass, v.IsDefault, v.UploadLimit))]),
+            cancellationToken);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommand.cs
new file mode 100644
index 0000000..c4c468c
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommand.cs
@@ -0,0 +1,10 @@
+using Eternelle.Common.Application.Messaging;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.UpdateTemplate;
+
+public sealed record UpdateTemplateCommand(
+    Guid TemplateId,
+    string Name,
+    string? Description,
+    string? PreviewImageUrl,
+    IReadOnlyList<string>? Features) : ICommand;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandHandler.cs
new file mode 100644
index 0000000..cdcebf3
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandHandler.cs
@@ -0,0 +1,82 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.UpdateTemplate;
+
+internal sealed class UpdateTemplateCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<UpdateTemplateCommand>
+{
+    public async Task<Result> Handle(UpdateTemplateCommand command, CancellationToken cancellationToken)
+    {
+        Template? template = await templateRepository.GetAsync(new TemplateId(command.TemplateId), cancellationToken);
+        if (template is null)
+        {
+            return Result.Failure(TemplateErrors.NotFound(new TemplateId(command.TemplateId)));
+        }
+
+        Result<TemplateName> nameResult = TemplateName.Create(command.Name);
+        if (nameResult.IsFailure)
+        {
+            return Result.Failure(nameResult.Error);
+        }
+
+        if (!string.Equals(nameResult.Value.Value, template.Name.Value, StringComparison.Ordinal) &&
+            await templateRepository.NameExistsAsync(nameResult.Value.Value, cancellationToken))
+        {
+            return Result.Failure(TemplateErrors.NameTaken);
+        }
+
+        TemplateDescription? description = null;
+        if (command.Description is not null)
+        {
+            Result<TemplateDescription> descriptionResult = TemplateDescription.Create(command.Description);
+            if (descriptionResult.IsFailure)
+            {
+                return Result.Failure(descriptionResult.Error);
+            }
+            description = descriptionResult.Value;
+        }
+
+        ImageUrl? previewImageUrl = null;
+        if (command.PreviewImageUrl is not null)
+        {
+            Result<ImageUrl> previewResult = ImageUrl.Create(command.PreviewImageUrl);
+            if (previewResult.IsFailure)
+            {
+                return Result.Failure(previewResult.Error);
+            }
+            previewImageUrl = previewResult.Value;
+        }
+
+        Result updateResult = template.UpdateDetails(
+            nameResult.Value, description, previewImageUrl, command.Features ?? [], dateTimeProvider.UtcNow);
+        if (updateResult.IsFailure)
+        {
+            return updateResult;
+        }
+
+        templateRepository.Update(template);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        await InvalidateAsync(cacheService, command.TemplateId, cancellationToken);
+
+        return Result.Success();
+    }
+
+    private static async Task InvalidateAsync(ICacheService cacheService, Guid templateId, CancellationToken cancellationToken)
+    {
+        await cacheService.RemoveAsync(CatalogCacheKeys.TemplateById(templateId), cancellationToken);
+        foreach (string key in CatalogCacheKeys.AllTemplateListKeys())
+        {
+            await cacheService.RemoveAsync(key, cancellationToken);
+        }
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandValidator.cs
new file mode 100644
index 0000000..1897dc7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandValidator.cs
@@ -0,0 +1,16 @@
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.UpdateTemplate;
+
+internal sealed class UpdateTemplateCommandValidator : AbstractValidator<UpdateTemplateCommand>
+{
+    public UpdateTemplateCommandValidator()
+    {
+        RuleFor(c => c.TemplateId).NotEmpty();
+        RuleFor(c => c.Name).NotEmpty().MaximumLength(TemplateName.MaxLength);
+        RuleFor(c => c.Description).MaximumLength(TemplateDescription.MaxLength).When(c => c.Description is not null);
+        RuleFor(c => c.PreviewImageUrl).MaximumLength(ImageUrl.MaxLength).When(c => c.PreviewImageUrl is not null);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/AssemblyInfo.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/AssemblyInfo.cs
new file mode 100644
index 0000000..34b942b
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/AssemblyInfo.cs
@@ -0,0 +1,6 @@
+using System.Runtime.CompilerServices;
+
+// Allow the Infrastructure layer to access internal members — specifically
+// FromPersistence() factory methods on value objects, which bypass Create()
+// validation for values that were already validated on write.
+[assembly: InternalsVisibleTo("Eternelle.Modules.Catalog.Infrastructure")]
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj
new file mode 100644
index 0000000..06763b3
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Domain\Eternelle.Common.Domain.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrl.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrl.cs
new file mode 100644
index 0000000..917e306
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrl.cs
@@ -0,0 +1,38 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Shared;
+
+public sealed record ImageUrl
+{
+    public const int MaxLength = 2048;
+
+    private ImageUrl(string value) => Value = value;
+
+    public string Value { get; }
+
+    public static Result<ImageUrl> Create(string? raw)
+    {
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            return Result.Failure<ImageUrl>(ImageUrlErrors.Empty);
+        }
+
+        string trimmed = raw.Trim();
+
+        if (trimmed.Length > MaxLength)
+        {
+            return Result.Failure<ImageUrl>(ImageUrlErrors.TooLong);
+        }
+
+        if (!Uri.TryCreate(trimmed, UriKind.RelativeOrAbsolute, out _))
+        {
+            return Result.Failure<ImageUrl>(ImageUrlErrors.InvalidFormat);
+        }
+
+        return Result.Success(new ImageUrl(trimmed));
+    }
+
+    public override string ToString() => Value;
+
+    internal static ImageUrl FromPersistence(string value) => new(value);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrlErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrlErrors.cs
new file mode 100644
index 0000000..df5ecce
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrlErrors.cs
@@ -0,0 +1,15 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Shared;
+
+internal static class ImageUrlErrors
+{
+    public static readonly Error Empty =
+        Error.Problem("ImageUrl.Empty", "Image URL must not be empty");
+
+    public static readonly Error TooLong =
+        Error.Problem("ImageUrl.TooLong", $"Image URL must not exceed {ImageUrl.MaxLength} characters");
+
+    public static readonly Error InvalidFormat =
+        Error.Problem("ImageUrl.InvalidFormat", "Image URL must be a valid URI");
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ITemplateRepository.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ITemplateRepository.cs
new file mode 100644
index 0000000..0a589a7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ITemplateRepository.cs
@@ -0,0 +1,12 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public interface ITemplateRepository
+{
+    Task<Template?> GetAsync(TemplateId id, CancellationToken cancellationToken = default);
+
+    Task<bool> NameExistsAsync(string name, CancellationToken cancellationToken = default);
+
+    void Insert(Template template);
+
+    void Update(Template template);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/PriceClass.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/PriceClass.cs
new file mode 100644
index 0000000..21ef21e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/PriceClass.cs
@@ -0,0 +1,8 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public enum PriceClass
+{
+    Free = 1,
+    Pro = 2,
+    Plus = 3
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/SectionId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/SectionId.cs
new file mode 100644
index 0000000..d87cdaa
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/SectionId.cs
@@ -0,0 +1,20 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+// Persisted as the enum NAME (string) so the Tenancy module can match selections
+// against this catalog by a stable identifier. Do not renumber/rename without a migration.
+public enum SectionId
+{
+    Hero,
+    Story,
+    Entourage,
+    DressCode,
+    Gallery,
+    GiftGuide,
+    Guestbook,
+    Venue,
+    Reminders,
+    Rsvp,
+    VendorCredits,
+    SnapShare,
+    GuestUploads
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs
new file mode 100644
index 0000000..d7640b8
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs
@@ -0,0 +1,152 @@
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Domain.Shared;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class Template : Entity
+{
+    private readonly List<TemplateTheme> _themes = [];
+    private readonly List<TemplateSupportedSection> _supportedSections = [];
+    private readonly List<TemplateSectionVariant> _sectionVariants = [];
+
+    private Template() { }
+
+    public TemplateId Id { get; private set; }
+    public TemplateName Name { get; private set; } = null!;
+    public TemplateDescription? Description { get; private set; }
+    public TemplateTier Tier { get; private set; }
+    public ImageUrl? PreviewImageUrl { get; private set; }
+    public IReadOnlyList<string> Features { get; private set; } = [];
+    public DateTime CreatedAtUtc { get; private set; }
+    public DateTime UpdatedAtUtc { get; private set; }
+
+    public IReadOnlyCollection<TemplateTheme> Themes => _themes.AsReadOnly();
+    public IReadOnlyCollection<TemplateSupportedSection> SupportedSections => _supportedSections.AsReadOnly();
+    public IReadOnlyCollection<TemplateSectionVariant> SectionVariants => _sectionVariants.AsReadOnly();
+
+    public static Result<Template> Create(
+        TemplateName name,
+        TemplateDescription? description,
+        TemplateTier tier,
+        ImageUrl? previewImageUrl,
+        IReadOnlyList<string> features,
+        DateTime utcNow)
+    {
+        var template = new Template
+        {
+            Id = TemplateId.New(),
+            Name = name,
+            Description = description,
+            Tier = tier,
+            PreviewImageUrl = previewImageUrl,
+            Features = [..features],
+            CreatedAtUtc = utcNow,
+            UpdatedAtUtc = utcNow
+        };
+
+        template.Raise(new TemplateCreatedDomainEvent(template.Id, name.Value, tier.ToString()));
+        template.Raise(template.BuildManifestEvent());
+
+        return Result.Success(template);
+    }
+
+    public Result UpdateDetails(
+        TemplateName name,
+        TemplateDescription? description,
+        ImageUrl? previewImageUrl,
+        IReadOnlyList<string> features,
+        DateTime utcNow)
+    {
+        Name = name;
+        Description = description;
+        PreviewImageUrl = previewImageUrl;
+        Features = [..features];
+        UpdatedAtUtc = utcNow;
+
+        Raise(BuildManifestEvent());
+
+        return Result.Success();
+    }
+
+    public Result AddTheme(
+        int themeIndex,
+        TemplateThemeName name,
+        ThemeColors colors,
+        ThemeTypography typography,
+        ThemeTextures? textures,
+        bool isDark,
+        DateTime utcNow)
+    {
+        if (_themes.Any(t => t.ThemeIndex == themeIndex))
+        {
+            return Result.Failure(TemplateErrors.DuplicateThemeIndex);
+        }
+
+        _themes.Add(TemplateTheme.Create(Id, themeIndex, name, colors, typography, textures, isDark));
+        UpdatedAtUtc = utcNow;
+
+        Raise(BuildManifestEvent());
+
+        return Result.Success();
+    }
+
+    public Result AddSupportedSection(SectionId sectionId, int displayOrder, DateTime utcNow)
+    {
+        if (_supportedSections.Any(s => s.SectionId == sectionId))
+        {
+            return Result.Failure(TemplateErrors.SectionAlreadySupported);
+        }
+
+        _supportedSections.Add(TemplateSupportedSection.Create(Id, sectionId, displayOrder));
+        UpdatedAtUtc = utcNow;
+
+        Raise(BuildManifestEvent());
+
+        return Result.Success();
+    }
+
+    public Result AddSectionVariant(
+        SectionId sectionId,
+        string variant,
+        bool isDefault,
+        PriceClass priceClass,
+        int? uploadLimit,
+        DateTime utcNow)
+    {
+        if (_supportedSections.All(s => s.SectionId != sectionId))
+        {
+            return Result.Failure(TemplateErrors.SectionNotSupported);
+        }
+
+        if (_sectionVariants.Any(v => v.SectionId == sectionId &&
+                                      string.Equals(v.Variant, variant, StringComparison.OrdinalIgnoreCase)))
+        {
+            return Result.Failure(TemplateErrors.DuplicateVariant);
+        }
+
+        if (isDefault && _sectionVariants.Any(v => v.SectionId == sectionId && v.IsDefault))
+        {
+            return Result.Failure(TemplateErrors.DuplicateDefaultVariant);
+        }
+
+        _sectionVariants.Add(TemplateSectionVariant.Create(Id, sectionId, variant, isDefault, priceClass, uploadLimit));
+        UpdatedAtUtc = utcNow;
+
+        Raise(BuildManifestEvent());
+
+        return Result.Success();
+    }
+
+    private TemplateManifestChangedDomainEvent BuildManifestEvent() =>
+        new(
+            Id,
+            Name.Value,
+            Tier.ToString(),
+            [.. _supportedSections.Select(s => s.SectionId.ToString())],
+            [.. _sectionVariants.Select(v => new TemplateManifestItem(
+                v.SectionId.ToString(),
+                v.Variant,
+                v.PriceClass.ToString(),
+                v.IsDefault,
+                v.UploadLimit))]);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateCreatedDomainEvent.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateCreatedDomainEvent.cs
new file mode 100644
index 0000000..f42b3e9
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateCreatedDomainEvent.cs
@@ -0,0 +1,13 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateCreatedDomainEvent(
+    TemplateId templateId,
+    string name,
+    string tier) : DomainEvent
+{
+    public TemplateId TemplateId { get; init; } = templateId;
+    public string Name { get; init; } = name;
+    public string Tier { get; init; } = tier;
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescription.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescription.cs
new file mode 100644
index 0000000..0956f2e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescription.cs
@@ -0,0 +1,33 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed record TemplateDescription
+{
+    public const int MaxLength = 1000;
+
+    private TemplateDescription(string value) => Value = value;
+
+    public string Value { get; }
+
+    public static Result<TemplateDescription> Create(string? raw)
+    {
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            return Result.Failure<TemplateDescription>(TemplateDescriptionErrors.Empty);
+        }
+
+        string trimmed = raw.Trim();
+
+        if (trimmed.Length > MaxLength)
+        {
+            return Result.Failure<TemplateDescription>(TemplateDescriptionErrors.TooLong);
+        }
+
+        return Result.Success(new TemplateDescription(trimmed));
+    }
+
+    public override string ToString() => Value;
+
+    internal static TemplateDescription FromPersistence(string value) => new(value);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescriptionErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescriptionErrors.cs
new file mode 100644
index 0000000..f10497f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescriptionErrors.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+internal static class TemplateDescriptionErrors
+{
+    public static readonly Error Empty =
+        Error.Problem("TemplateDescription.Empty", "Template description must not be empty when provided");
+
+    public static readonly Error TooLong =
+        Error.Problem("TemplateDescription.TooLong", $"Template description must not exceed {TemplateDescription.MaxLength} characters");
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateErrors.cs
new file mode 100644
index 0000000..f53d8ec
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateErrors.cs
@@ -0,0 +1,27 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public static class TemplateErrors
+{
+    public static Error NotFound(TemplateId id) =>
+        Error.NotFound("Catalog.Template.NotFound", $"Template '{id.Value}' was not found.");
+
+    public static readonly Error NameTaken =
+        Error.Conflict("Catalog.Template.NameTaken", "A template with this name already exists.");
+
+    public static readonly Error DuplicateThemeIndex =
+        Error.Conflict("Catalog.Template.DuplicateThemeIndex", "A theme with this index already exists for the template.");
+
+    public static readonly Error SectionAlreadySupported =
+        Error.Conflict("Catalog.Template.SectionAlreadySupported", "This section is already supported by the template.");
+
+    public static readonly Error SectionNotSupported =
+        Error.Problem("Catalog.Template.SectionNotSupported", "A variant cannot be added for a section the template does not support.");
+
+    public static readonly Error DuplicateDefaultVariant =
+        Error.Conflict("Catalog.Template.DuplicateDefaultVariant", "Only one default variant is allowed per section.");
+
+    public static readonly Error DuplicateVariant =
+        Error.Conflict("Catalog.Template.DuplicateVariant", "This variant already exists for the section.");
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateId.cs
new file mode 100644
index 0000000..619eb4c
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateId.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public readonly record struct TemplateId(Guid Value)
+{
+    public static TemplateId New() => new(Guid.CreateVersion7());
+    public override string ToString() => Value.ToString();
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs
new file mode 100644
index 0000000..17ba61f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs
@@ -0,0 +1,17 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateManifestChangedDomainEvent(
+    TemplateId templateId,
+    string name,
+    string tier,
+    IReadOnlyList<string> sectionIds,
+    IReadOnlyList<TemplateManifestItem> variants) : DomainEvent
+{
+    public TemplateId TemplateId { get; init; } = templateId;
+    public string Name { get; init; } = name;
+    public string Tier { get; init; } = tier;
+    public IReadOnlyList<string> SectionIds { get; init; } = [..sectionIds];
+    public IReadOnlyList<TemplateManifestItem> Variants { get; init; } = [..variants];
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestItem.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestItem.cs
new file mode 100644
index 0000000..15f0c9b
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestItem.cs
@@ -0,0 +1,8 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed record TemplateManifestItem(
+    string SectionId,
+    string Variant,
+    string PriceClass,
+    bool IsDefault,
+    int? UploadLimit);
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateName.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateName.cs
new file mode 100644
index 0000000..7f7a9c6
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateName.cs
@@ -0,0 +1,33 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed record TemplateName
+{
+    public const int MaxLength = 150;
+
+    private TemplateName(string value) => Value = value;
+
+    public string Value { get; }
+
+    public static Result<TemplateName> Create(string? raw)
+    {
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            return Result.Failure<TemplateName>(TemplateNameErrors.Empty);
+        }
+
+        string trimmed = raw.Trim();
+
+        if (trimmed.Length > MaxLength)
+        {
+            return Result.Failure<TemplateName>(TemplateNameErrors.TooLong);
+        }
+
+        return Result.Success(new TemplateName(trimmed));
+    }
+
+    public override string ToString() => Value;
+
+    internal static TemplateName FromPersistence(string value) => new(value);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateNameErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateNameErrors.cs
new file mode 100644
index 0000000..cd2ef8b
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateNameErrors.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+internal static class TemplateNameErrors
+{
+    public static readonly Error Empty =
+        Error.Problem("TemplateName.Empty", "Template name must not be empty");
+
+    public static readonly Error TooLong =
+        Error.Problem("TemplateName.TooLong", $"Template name must not exceed {TemplateName.MaxLength} characters");
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
new file mode 100644
index 0000000..29d42e5
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
@@ -0,0 +1,37 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateSectionVariant : Entity
+{
+    public const int MaxVariantLength = 100;
+
+    private TemplateSectionVariant() { }
+
+    public TemplateSectionVariantId Id { get; private set; }
+    public TemplateId TemplateId { get; private set; }
+    public SectionId SectionId { get; private set; }
+    public string Variant { get; private set; } = null!; // always set via Create() factory before exposure
+    public bool IsDefault { get; private set; }
+    public PriceClass PriceClass { get; private set; }
+
+    public int? UploadLimit { get; private set; }
+
+    internal static TemplateSectionVariant Create(
+        TemplateId templateId,
+        SectionId sectionId,
+        string variant,
+        bool isDefault,
+        PriceClass priceClass,
+        int? uploadLimit) =>
+        new()
+        {
+            Id = TemplateSectionVariantId.New(),
+            TemplateId = templateId,
+            SectionId = sectionId,
+            Variant = variant,
+            IsDefault = isDefault,
+            PriceClass = priceClass,
+            UploadLimit = uploadLimit
+        };
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariantId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariantId.cs
new file mode 100644
index 0000000..c585487
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariantId.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public readonly record struct TemplateSectionVariantId(Guid Value)
+{
+    public static TemplateSectionVariantId New() => new(Guid.CreateVersion7());
+    public override string ToString() => Value.ToString();
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSection.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSection.cs
new file mode 100644
index 0000000..d63c398
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSection.cs
@@ -0,0 +1,25 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateSupportedSection : Entity
+{
+    private TemplateSupportedSection() { }
+
+    public TemplateSupportedSectionId Id { get; private set; }
+    public TemplateId TemplateId { get; private set; }
+    public SectionId SectionId { get; private set; }
+    public int DisplayOrder { get; private set; }
+
+    internal static TemplateSupportedSection Create(
+        TemplateId templateId,
+        SectionId sectionId,
+        int displayOrder) =>
+        new()
+        {
+            Id = TemplateSupportedSectionId.New(),
+            TemplateId = templateId,
+            SectionId = sectionId,
+            DisplayOrder = displayOrder
+        };
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSectionId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSectionId.cs
new file mode 100644
index 0000000..0f50248
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSectionId.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public readonly record struct TemplateSupportedSectionId(Guid Value)
+{
+    public static TemplateSupportedSectionId New() => new(Guid.CreateVersion7());
+    public override string ToString() => Value.ToString();
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs
new file mode 100644
index 0000000..0021eab
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs
@@ -0,0 +1,38 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateTheme : Entity
+{
+    private TemplateTheme() { }
+
+    public TemplateThemeId Id { get; private set; }
+    public TemplateId TemplateId { get; private set; }
+    public int ThemeIndex { get; private set; }
+    // null! is safe: all three are set before exposure via Create() or EF Core materialization
+    public TemplateThemeName Name { get; private set; } = null!;
+    public ThemeColors Colors { get; private set; } = null!;
+    public ThemeTypography Typography { get; private set; } = null!;
+    public ThemeTextures? Textures { get; private set; }
+    public bool IsDark { get; private set; }
+
+    internal static TemplateTheme Create(
+        TemplateId templateId,
+        int themeIndex,
+        TemplateThemeName name,
+        ThemeColors colors,
+        ThemeTypography typography,
+        ThemeTextures? textures,
+        bool isDark) =>
+        new()
+        {
+            Id = TemplateThemeId.New(),
+            TemplateId = templateId,
+            ThemeIndex = themeIndex,
+            Name = name,
+            Colors = colors,
+            Typography = typography,
+            Textures = textures,
+            IsDark = isDark
+        };
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeId.cs
new file mode 100644
index 0000000..d0c1508
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeId.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public readonly record struct TemplateThemeId(Guid Value)
+{
+    public static TemplateThemeId New() => new(Guid.CreateVersion7());
+    public override string ToString() => Value.ToString();
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeName.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeName.cs
new file mode 100644
index 0000000..6a14a29
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeName.cs
@@ -0,0 +1,33 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed record TemplateThemeName
+{
+    public const int MaxLength = 100;
+
+    private TemplateThemeName(string value) => Value = value;
+
+    public string Value { get; }
+
+    public static Result<TemplateThemeName> Create(string? raw)
+    {
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            return Result.Failure<TemplateThemeName>(TemplateThemeNameErrors.Empty);
+        }
+
+        string trimmed = raw.Trim();
+
+        if (trimmed.Length > MaxLength)
+        {
+            return Result.Failure<TemplateThemeName>(TemplateThemeNameErrors.TooLong);
+        }
+
+        return Result.Success(new TemplateThemeName(trimmed));
+    }
+
+    public override string ToString() => Value;
+
+    internal static TemplateThemeName FromPersistence(string value) => new(value);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeNameErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeNameErrors.cs
new file mode 100644
index 0000000..2fcf177
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeNameErrors.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+internal static class TemplateThemeNameErrors
+{
+    public static readonly Error Empty =
+        Error.Problem("TemplateThemeName.Empty", "Theme name must not be empty");
+
+    public static readonly Error TooLong =
+        Error.Problem("TemplateThemeName.TooLong", $"Theme name must not exceed {TemplateThemeName.MaxLength} characters");
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTier.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTier.cs
new file mode 100644
index 0000000..1c94a31
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTier.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public enum TemplateTier
+{
+    FirstClass = 1,
+    Signature = 2
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ThemeStyling.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ThemeStyling.cs
new file mode 100644
index 0000000..5301c1f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ThemeStyling.cs
@@ -0,0 +1,9 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+// Serialized to jsonb columns. Dictionaries keep the schema open for design tokens
+// (e.g. { "primary": "#1a1a1a", "accent": "#c8a96a" }) without a migration per token.
+public sealed record ThemeColors(IReadOnlyDictionary<string, string> Tokens);
+
+public sealed record ThemeTypography(IReadOnlyDictionary<string, string> Tokens);
+
+public sealed record ThemeTextures(IReadOnlyDictionary<string, string> Tokens);
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/CatalogModule.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/CatalogModule.cs
new file mode 100644
index 0000000..0bbbffd
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/CatalogModule.cs
@@ -0,0 +1,78 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Infrastructure.Outbox;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+using Eternelle.Modules.Catalog.Infrastructure.Outbox;
+using Eternelle.Modules.Catalog.Infrastructure.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Eternelle.Modules.Catalog.Infrastructure;
+
+public static class CatalogModule
+{
+    public static IServiceCollection AddCatalogModule(
+        this IServiceCollection services,
+        IConfiguration configuration)
+    {
+        services.AddDomainEventHandlers();
+
+        services.AddInfrastructure(configuration);
+
+        services.AddEndpoints(Presentation.AssemblyReference.Assembly);
+
+        return services;
+    }
+
+    private static void AddInfrastructure(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddDbContext<CatalogDbContext>((sp, options) =>
+            options
+                .UseNpgsql(
+                    configuration.GetConnectionString("Database"),
+                    npgsqlOptions => npgsqlOptions
+                        .MigrationsHistoryTable(HistoryRepository.DefaultTableName, Schemas.Catalog))
+                .UseSnakeCaseNamingConvention()
+                .AddInterceptors(sp.GetRequiredService<InsertOutboxMessagesInterceptor>()));
+
+        services.AddScoped<IUnitOfWork>(sp => sp.GetRequiredService<CatalogDbContext>());
+
+        services.AddScoped<ITemplateRepository, TemplateRepository>();
+
+        services.AddOptions<OutboxOptions>()
+            .Bind(configuration.GetSection("Catalog:Outbox"))
+            .Validate(o => o.IntervalInSeconds > 0 && o.BatchSize > 0,
+                "Catalog:Outbox: IntervalInSeconds and BatchSize must be greater than 0.")
+            .ValidateOnStart();
+
+        services.ConfigureOptions<ConfigureProcessOutboxJob>();
+    }
+
+    private static void AddDomainEventHandlers(this IServiceCollection services)
+    {
+        Type[] domainEventHandlers = Application.AssemblyReference.Assembly
+            .GetTypes()
+            .Where(t => t.IsAssignableTo(typeof(IDomainEventHandler)))
+            .ToArray();
+
+        foreach (Type domainEventHandler in domainEventHandlers)
+        {
+            services.TryAddScoped(domainEventHandler);
+
+            Type domainEvent = domainEventHandler
+                .GetInterfaces()
+                .Single(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IDomainEventHandler<>))
+                .GetGenericArguments()
+                .Single();
+
+            Type closedIdempotentHandler = typeof(IdempotentDomainEventHandler<>).MakeGenericType(domainEvent);
+
+            services.Decorate(domainEventHandler, closedIdempotentHandler);
+        }
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/CatalogDbContext.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/CatalogDbContext.cs
new file mode 100644
index 0000000..7df1f75
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/CatalogDbContext.cs
@@ -0,0 +1,35 @@
+using Eternelle.Common.Infrastructure.Outbox;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+using Eternelle.Modules.Catalog.Infrastructure.Templates;
+using Microsoft.EntityFrameworkCore;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database;
+
+public sealed class CatalogDbContext(DbContextOptions<CatalogDbContext> options)
+    : DbContext(options), IUnitOfWork
+{
+    internal DbSet<Template> Templates { get; set; }
+
+    protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
+    {
+        configurationBuilder.Properties<TemplateId>().HaveConversion<TemplateIdConverter>();
+        configurationBuilder.Properties<TemplateThemeId>().HaveConversion<TemplateThemeIdConverter>();
+        configurationBuilder.Properties<TemplateSupportedSectionId>().HaveConversion<TemplateSupportedSectionIdConverter>();
+        configurationBuilder.Properties<TemplateSectionVariantId>().HaveConversion<TemplateSectionVariantIdConverter>();
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.HasDefaultSchema(Schemas.Catalog);
+
+        modelBuilder.ApplyConfiguration(new OutboxMessageConfiguration());
+        modelBuilder.ApplyConfiguration(new OutboxMessageConsumerConfiguration());
+
+        modelBuilder.ApplyConfiguration(new TemplateConfiguration());
+        modelBuilder.ApplyConfiguration(new TemplateThemeConfiguration());
+        modelBuilder.ApplyConfiguration(new TemplateSupportedSectionConfiguration());
+        modelBuilder.ApplyConfiguration(new TemplateSectionVariantConfiguration());
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateIdConverter.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateIdConverter.cs
new file mode 100644
index 0000000..8bf1b1d
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateIdConverter.cs
@@ -0,0 +1,7 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+
+internal sealed class TemplateIdConverter()
+    : ValueConverter<TemplateId, Guid>(id => id.Value, value => new TemplateId(value));
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSectionVariantIdConverter.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSectionVariantIdConverter.cs
new file mode 100644
index 0000000..0ee72b9
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSectionVariantIdConverter.cs
@@ -0,0 +1,7 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+
+internal sealed class TemplateSectionVariantIdConverter()
+    : ValueConverter<TemplateSectionVariantId, Guid>(id => id.Value, value => new TemplateSectionVariantId(value));
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSupportedSectionIdConverter.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSupportedSectionIdConverter.cs
new file mode 100644
index 0000000..bded9a7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSupportedSectionIdConverter.cs
@@ -0,0 +1,7 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+
+internal sealed class TemplateSupportedSectionIdConverter()
+    : ValueConverter<TemplateSupportedSectionId, Guid>(id => id.Value, value => new TemplateSupportedSectionId(value));
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateThemeIdConverter.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateThemeIdConverter.cs
new file mode 100644
index 0000000..394e2a1
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateThemeIdConverter.cs
@@ -0,0 +1,7 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+
+internal sealed class TemplateThemeIdConverter()
+    : ValueConverter<TemplateThemeId, Guid>(id => id.Value, value => new TemplateThemeId(value));
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.Designer.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.Designer.cs
new file mode 100644
index 0000000..cb09aa6
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.Designer.cs
@@ -0,0 +1,302 @@
+// <auto-generated />
+using System;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Migrations
+{
+    [DbContext(typeof(CatalogDbContext))]
+    [Migration("20260527094230_InitialCatalog")]
+    partial class InitialCatalog
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("catalog")
+                .HasAnnotation("ProductVersion", "10.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("jsonb")
+                        .HasColumnName("content");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<DateTime>("OccurredOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on_utc");
+
+                    b.Property<DateTime?>("ProcessedOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_on_utc");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_outbox_messages");
+
+                    b.ToTable("outbox_messages", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessageConsumer", b =>
+                {
+                    b.Property<Guid>("OutboxMessageId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("outbox_message_id");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("name");
+
+                    b.HasKey("OutboxMessageId", "Name")
+                        .HasName("pk_outbox_message_consumers");
+
+                    b.ToTable("outbox_message_consumers", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.Template", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at_utc");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Features")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("features");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("character varying(150)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("PreviewImageUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)")
+                        .HasColumnName("preview_image_url");
+
+                    b.Property<string>("Tier")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("tier");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at_utc");
+
+                    b.HasKey("Id")
+                        .HasName("pk_templates");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_templates_name");
+
+                    b.ToTable("templates", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSectionVariant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_default");
+
+                    b.Property<string>("PriceClass")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("price_class");
+
+                    b.Property<string>("SectionId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("section_id");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.Property<int?>("UploadLimit")
+                        .HasColumnType("integer")
+                        .HasColumnName("upload_limit");
+
+                    b.Property<string>("Variant")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("variant");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_section_variants");
+
+                    b.HasIndex("TemplateId", "SectionId")
+                        .IsUnique()
+                        .HasDatabaseName("ux_template_section_variants_one_default")
+                        .HasFilter("is_default = true");
+
+                    b.HasIndex("TemplateId", "SectionId", "Variant")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_section_variants_template_id_section_id_variant");
+
+                    b.ToTable("template_section_variants", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSupportedSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<int>("DisplayOrder")
+                        .HasColumnType("integer")
+                        .HasColumnName("display_order");
+
+                    b.Property<string>("SectionId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("section_id");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_supported_sections");
+
+                    b.HasIndex("TemplateId", "SectionId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_supported_sections_template_id_section_id");
+
+                    b.ToTable("template_supported_sections", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateTheme", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Colors")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("colors");
+
+                    b.Property<bool>("IsDark")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_dark");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("name");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.Property<string>("Textures")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("textures");
+
+                    b.Property<int>("ThemeIndex")
+                        .HasColumnType("integer")
+                        .HasColumnName("theme_index");
+
+                    b.Property<string>("Typography")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("typography");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_themes");
+
+                    b.HasIndex("TemplateId", "ThemeIndex")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_themes_template_id_theme_index");
+
+                    b.ToTable("template_themes", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSectionVariant", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("SectionVariants")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_section_variants_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSupportedSection", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("SupportedSections")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_supported_sections_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateTheme", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("Themes")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_themes_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.Template", b =>
+                {
+                    b.Navigation("SectionVariants");
+
+                    b.Navigation("SupportedSections");
+
+                    b.Navigation("Themes");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
new file mode 100644
index 0000000..67c9429
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
@@ -0,0 +1,247 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Migrations;
+
+/// <inheritdoc />
+public partial class InitialCatalog : Migration
+{
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "catalog");
+
+            migrationBuilder.CreateTable(
+                name: "outbox_message_consumers",
+                schema: "catalog",
+                columns: table => new
+                {
+                    outbox_message_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    name = table.Column<string>(type: "character varying(500)", maxLength: 500, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_outbox_message_consumers", x => new { x.outbox_message_id, x.name });
+                });
+
+            migrationBuilder.CreateTable(
+                name: "outbox_messages",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    type = table.Column<string>(type: "text", nullable: false),
+                    content = table.Column<string>(type: "jsonb", maxLength: 2000, nullable: false),
+                    occurred_on_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    processed_on_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    error = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_outbox_messages", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "templates",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    name = table.Column<string>(type: "character varying(150)", maxLength: 150, nullable: false),
+                    description = table.Column<string>(type: "character varying(1000)", maxLength: 1000, nullable: true),
+                    tier = table.Column<string>(type: "text", nullable: false),
+                    preview_image_url = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    features = table.Column<string>(type: "jsonb", nullable: false),
+                    created_at_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    updated_at_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_templates", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "template_section_variants",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    template_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    section_id = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
+                    variant = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
+                    is_default = table.Column<bool>(type: "boolean", nullable: false),
+                    price_class = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
+                    upload_limit = table.Column<int>(type: "integer", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_template_section_variants", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_template_section_variants_templates_template_id",
+                        column: x => x.template_id,
+                        principalSchema: "catalog",
+                        principalTable: "templates",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "template_supported_sections",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    template_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    section_id = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
+                    display_order = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_template_supported_sections", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_template_supported_sections_templates_template_id",
+                        column: x => x.template_id,
+                        principalSchema: "catalog",
+                        principalTable: "templates",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "template_themes",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    template_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    theme_index = table.Column<int>(type: "integer", nullable: false),
+                    name = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
+                    colors = table.Column<string>(type: "jsonb", nullable: false),
+                    typography = table.Column<string>(type: "jsonb", nullable: false),
+                    textures = table.Column<string>(type: "jsonb", nullable: true),
+                    is_dark = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_template_themes", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_template_themes_templates_template_id",
+                        column: x => x.template_id,
+                        principalSchema: "catalog",
+                        principalTable: "templates",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "ix_template_section_variants_template_id_section_id_variant",
+                schema: "catalog",
+                table: "template_section_variants",
+                columns: ["template_id", "section_id", "variant"],
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ux_template_section_variants_one_default",
+                schema: "catalog",
+                table: "template_section_variants",
+                columns: ["template_id", "section_id"],
+                unique: true,
+                filter: "is_default = true");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_template_supported_sections_template_id_section_id",
+                schema: "catalog",
+                table: "template_supported_sections",
+                columns: ["template_id", "section_id"],
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_template_themes_template_id_theme_index",
+                schema: "catalog",
+                table: "template_themes",
+                columns: ["template_id", "theme_index"],
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_templates_name",
+                schema: "catalog",
+                table: "templates",
+                column: "name",
+                unique: true);
+
+            migrationBuilder.Sql(
+                """
+                INSERT INTO catalog.templates (id, name, description, tier, preview_image_url, features, created_at_utc, updated_at_utc)
+                VALUES (
+                    '0190a000-0000-7000-8000-000000000001',
+                    'Kapilya',
+                    'A classic Filipino chapel-inspired wedding template.',
+                    'FirstClass',
+                    NULL,
+                    '[]'::jsonb,
+                    now(),
+                    now());
+
+                INSERT INTO catalog.template_themes (id, template_id, theme_index, name, colors, typography, textures, is_dark)
+                VALUES
+                    ('0190a000-0000-7000-8000-000000000010', '0190a000-0000-7000-8000-000000000001', 0, 'Ivory',
+                     '{"primary":"#1a1a1a","accent":"#c8a96a","background":"#faf7f2"}'::jsonb,
+                     '{"heading":"Cormorant","body":"Inter"}'::jsonb, NULL, false),
+                    ('0190a000-0000-7000-8000-000000000011', '0190a000-0000-7000-8000-000000000001', 1, 'Midnight',
+                     '{"primary":"#f5f5f5","accent":"#c8a96a","background":"#10100f"}'::jsonb,
+                     '{"heading":"Cormorant","body":"Inter"}'::jsonb, NULL, true);
+
+                INSERT INTO catalog.template_supported_sections (id, template_id, section_id, display_order)
+                VALUES
+                    ('0190a000-0000-7000-8000-000000000020', '0190a000-0000-7000-8000-000000000001', 'Hero', 0),
+                    ('0190a000-0000-7000-8000-000000000021', '0190a000-0000-7000-8000-000000000001', 'Story', 1),
+                    ('0190a000-0000-7000-8000-000000000022', '0190a000-0000-7000-8000-000000000001', 'Entourage', 2),
+                    ('0190a000-0000-7000-8000-000000000023', '0190a000-0000-7000-8000-000000000001', 'Venue', 3),
+                    ('0190a000-0000-7000-8000-000000000024', '0190a000-0000-7000-8000-000000000001', 'Rsvp', 4),
+                    ('0190a000-0000-7000-8000-000000000025', '0190a000-0000-7000-8000-000000000001', 'GuestUploads', 5);
+
+                INSERT INTO catalog.template_section_variants (id, template_id, section_id, variant, is_default, price_class, upload_limit)
+                VALUES
+                    ('0190a000-0000-7000-8000-000000000030', '0190a000-0000-7000-8000-000000000001', 'Hero', 'classic', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000031', '0190a000-0000-7000-8000-000000000001', 'Hero', 'editorial', false, 'Plus', NULL),
+                    ('0190a000-0000-7000-8000-000000000032', '0190a000-0000-7000-8000-000000000001', 'Story', 'classic', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000033', '0190a000-0000-7000-8000-000000000001', 'Entourage', 'grid', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000034', '0190a000-0000-7000-8000-000000000001', 'Venue', 'map', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000035', '0190a000-0000-7000-8000-000000000001', 'Rsvp', 'simple', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000036', '0190a000-0000-7000-8000-000000000001', 'GuestUploads', 'free', true, 'Free', 50),
+                    ('0190a000-0000-7000-8000-000000000037', '0190a000-0000-7000-8000-000000000001', 'GuestUploads', 'pro', false, 'Pro', 250),
+                    ('0190a000-0000-7000-8000-000000000038', '0190a000-0000-7000-8000-000000000001', 'GuestUploads', 'plus', false, 'Plus', NULL);
+                """);
+        }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+        migrationBuilder.DropTable(
+            name: "outbox_message_consumers",
+            schema: "catalog");
+
+        migrationBuilder.DropTable(
+            name: "outbox_messages",
+            schema: "catalog");
+
+        migrationBuilder.DropTable(
+            name: "template_section_variants",
+            schema: "catalog");
+
+        migrationBuilder.DropTable(
+            name: "template_supported_sections",
+            schema: "catalog");
+
+        migrationBuilder.DropTable(
+            name: "template_themes",
+            schema: "catalog");
+
+        migrationBuilder.DropTable(
+            name: "templates",
+            schema: "catalog");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/CatalogDbContextModelSnapshot.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/CatalogDbContextModelSnapshot.cs
new file mode 100644
index 0000000..50e4645
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/CatalogDbContextModelSnapshot.cs
@@ -0,0 +1,299 @@
+// <auto-generated />
+using System;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Migrations
+{
+    [DbContext(typeof(CatalogDbContext))]
+    partial class CatalogDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("catalog")
+                .HasAnnotation("ProductVersion", "10.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("jsonb")
+                        .HasColumnName("content");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<DateTime>("OccurredOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on_utc");
+
+                    b.Property<DateTime?>("ProcessedOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_on_utc");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_outbox_messages");
+
+                    b.ToTable("outbox_messages", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessageConsumer", b =>
+                {
+                    b.Property<Guid>("OutboxMessageId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("outbox_message_id");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("name");
+
+                    b.HasKey("OutboxMessageId", "Name")
+                        .HasName("pk_outbox_message_consumers");
+
+                    b.ToTable("outbox_message_consumers", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.Template", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at_utc");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Features")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("features");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("character varying(150)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("PreviewImageUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)")
+                        .HasColumnName("preview_image_url");
+
+                    b.Property<string>("Tier")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("tier");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at_utc");
+
+                    b.HasKey("Id")
+                        .HasName("pk_templates");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_templates_name");
+
+                    b.ToTable("templates", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSectionVariant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_default");
+
+                    b.Property<string>("PriceClass")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("price_class");
+
+                    b.Property<string>("SectionId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("section_id");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.Property<int?>("UploadLimit")
+                        .HasColumnType("integer")
+                        .HasColumnName("upload_limit");
+
+                    b.Property<string>("Variant")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("variant");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_section_variants");
+
+                    b.HasIndex("TemplateId", "SectionId")
+                        .IsUnique()
+                        .HasDatabaseName("ux_template_section_variants_one_default")
+                        .HasFilter("is_default = true");
+
+                    b.HasIndex("TemplateId", "SectionId", "Variant")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_section_variants_template_id_section_id_variant");
+
+                    b.ToTable("template_section_variants", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSupportedSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<int>("DisplayOrder")
+                        .HasColumnType("integer")
+                        .HasColumnName("display_order");
+
+                    b.Property<string>("SectionId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("section_id");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_supported_sections");
+
+                    b.HasIndex("TemplateId", "SectionId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_supported_sections_template_id_section_id");
+
+                    b.ToTable("template_supported_sections", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateTheme", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Colors")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("colors");
+
+                    b.Property<bool>("IsDark")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_dark");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("name");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.Property<string>("Textures")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("textures");
+
+                    b.Property<int>("ThemeIndex")
+                        .HasColumnType("integer")
+                        .HasColumnName("theme_index");
+
+                    b.Property<string>("Typography")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("typography");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_themes");
+
+                    b.HasIndex("TemplateId", "ThemeIndex")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_themes_template_id_theme_index");
+
+                    b.ToTable("template_themes", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSectionVariant", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("SectionVariants")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_section_variants_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSupportedSection", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("SupportedSections")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_supported_sections_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateTheme", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("Themes")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_themes_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.Template", b =>
+                {
+                    b.Navigation("SectionVariants");
+
+                    b.Navigation("SupportedSections");
+
+                    b.Navigation("Themes");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Schemas.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Schemas.cs
new file mode 100644
index 0000000..ee3561e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Schemas.cs
@@ -0,0 +1,6 @@
+namespace Eternelle.Modules.Catalog.Infrastructure.Database;
+
+internal static class Schemas
+{
+    internal const string Catalog = "catalog";
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj
new file mode 100644
index 0000000..6e1754e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.Application\Eternelle.Modules.Catalog.Application.csproj" />
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.Presentation\Eternelle.Modules.Catalog.Presentation.csproj" />
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Infrastructure\Eternelle.Common.Infrastructure.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ConfigureProcessOutboxJob.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ConfigureProcessOutboxJob.cs
new file mode 100644
index 0000000..733c950
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ConfigureProcessOutboxJob.cs
@@ -0,0 +1,29 @@
+using Microsoft.Extensions.Options;
+using Quartz;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Outbox;
+
+internal sealed class ConfigureProcessOutboxJob(IOptions<OutboxOptions> outboxOptions)
+    : IConfigureOptions<QuartzOptions>
+{
+    private readonly OutboxOptions _outboxOptions = outboxOptions.Value;
+
+    public void Configure(QuartzOptions options)
+    {
+        if (_outboxOptions.IntervalInSeconds <= 0)
+        {
+            throw new InvalidOperationException(
+                $"Catalog:Outbox:IntervalInSeconds must be a positive integer. Current value: {_outboxOptions.IntervalInSeconds}");
+        }
+
+        string jobName = typeof(ProcessOutboxJob).FullName!;
+
+        options
+            .AddJob<ProcessOutboxJob>(configure => configure.WithIdentity(jobName))
+            .AddTrigger(configure =>
+                configure
+                    .ForJob(jobName)
+                    .WithSimpleSchedule(schedule =>
+                        schedule.WithIntervalInSeconds(_outboxOptions.IntervalInSeconds).RepeatForever()));
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/IdempotentDomainEventHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/IdempotentDomainEventHandler.cs
new file mode 100644
index 0000000..84fc61e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/IdempotentDomainEventHandler.cs
@@ -0,0 +1,62 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Common.Infrastructure.Outbox;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Outbox;
+
+internal sealed class IdempotentDomainEventHandler<TDomainEvent>(
+    IDomainEventHandler<TDomainEvent> decorated,
+    IDbConnectionFactory dbConnectionFactory)
+    : DomainEventHandler<TDomainEvent>
+    where TDomainEvent : IDomainEvent
+{
+    public override async Task Handle(TDomainEvent domainEvent, CancellationToken cancellationToken = default)
+    {
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        var outboxMessageConsumer = new OutboxMessageConsumer(domainEvent.Id, decorated.GetType().Name);
+
+        if (await OutboxConsumerExistsAsync(connection, outboxMessageConsumer))
+        {
+            return;
+        }
+
+        await decorated.Handle(domainEvent, cancellationToken);
+
+        await InsertOutboxConsumerAsync(connection, outboxMessageConsumer);
+    }
+
+    private static async Task<bool> OutboxConsumerExistsAsync(
+        DbConnection dbConnection,
+        OutboxMessageConsumer outboxMessageConsumer)
+    {
+        const string sql =
+            $"""
+            SELECT EXISTS(
+                SELECT 1
+                FROM {Schemas.Catalog}.outbox_message_consumers
+                WHERE outbox_message_id = @OutboxMessageId AND
+                      name = @Name
+            )
+            """;
+
+        return await dbConnection.ExecuteScalarAsync<bool>(sql, outboxMessageConsumer);
+    }
+
+    private static async Task InsertOutboxConsumerAsync(
+        DbConnection dbConnection,
+        OutboxMessageConsumer outboxMessageConsumer)
+    {
+        const string sql =
+            $"""
+            INSERT INTO {Schemas.Catalog}.outbox_message_consumers(outbox_message_id, name)
+            VALUES (@OutboxMessageId, @Name)
+            """;
+
+        await dbConnection.ExecuteAsync(sql, outboxMessageConsumer);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/OutboxOptions.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/OutboxOptions.cs
new file mode 100644
index 0000000..e682248
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/OutboxOptions.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Infrastructure.Outbox;
+
+internal sealed class OutboxOptions
+{
+    public int IntervalInSeconds { get; init; }
+    public int BatchSize { get; init; }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ProcessOutboxJob.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ProcessOutboxJob.cs
new file mode 100644
index 0000000..4971840
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ProcessOutboxJob.cs
@@ -0,0 +1,144 @@
+using System.Data;
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Common.Infrastructure.Outbox;
+using Eternelle.Common.Infrastructure.Serialization;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
+using Quartz;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Outbox;
+
+[DisallowConcurrentExecution]
+internal sealed partial class ProcessOutboxJob(
+    IDbConnectionFactory dbConnectionFactory,
+    IServiceScopeFactory serviceScopeFactory,
+    IDateTimeProvider dateTimeProvider,
+    IOptions<OutboxOptions> outboxOptions,
+    ILogger<ProcessOutboxJob> logger) : IJob
+{
+    private const string ModuleName = "Catalog";
+
+    public async Task Execute(IJobExecutionContext context)
+    {
+        LogBeginProcessing(logger, ModuleName);
+
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+        await using DbTransaction transaction = await connection.BeginTransactionAsync();
+
+        IReadOnlyList<OutboxMessageResponse> outboxMessages = await GetOutboxMessagesAsync(connection, transaction);
+
+        foreach (OutboxMessageResponse outboxMessage in outboxMessages)
+        {
+            Exception? exception = null;
+
+            try
+            {
+                IDomainEvent domainEvent = JsonConvert.DeserializeObject<IDomainEvent>(
+                    outboxMessage.Content,
+                    SerializerSettings.Instance)!;
+
+                using IServiceScope scope = serviceScopeFactory.CreateScope();
+
+                IEnumerable<IDomainEventHandler> handlers = DomainEventHandlersFactory.GetHandlers(
+                    domainEvent.GetType(),
+                    scope.ServiceProvider,
+                    Application.AssemblyReference.Assembly);
+
+                foreach (IDomainEventHandler domainEventHandler in handlers)
+                {
+                    await domainEventHandler.Handle(domainEvent, context.CancellationToken);
+                }
+            }
+            catch (Exception caughtException)
+            {
+                LogProcessingError(logger, caughtException, ModuleName, outboxMessage.Id);
+
+                exception = caughtException;
+            }
+
+            await UpdateOutboxMessageAsync(connection, transaction, outboxMessage, exception);
+        }
+
+        await transaction.CommitAsync();
+
+        LogCompleted(logger, ModuleName);
+    }
+
+    private async Task<IReadOnlyList<OutboxMessageResponse>> GetOutboxMessagesAsync(
+        IDbConnection connection,
+        IDbTransaction transaction)
+    {
+        string sql =
+            $"""
+             SELECT
+                id AS {nameof(OutboxMessageResponse.Id)},
+                content AS {nameof(OutboxMessageResponse.Content)}
+             FROM catalog.outbox_messages
+             WHERE processed_on_utc IS NULL
+             ORDER BY occurred_on_utc
+             LIMIT {outboxOptions.Value.BatchSize}
+             FOR UPDATE SKIP LOCKED
+             """;
+
+        IEnumerable<OutboxMessageResponse> outboxMessages = await connection.QueryAsync<OutboxMessageResponse>(
+            sql,
+            transaction: transaction);
+
+        return outboxMessages.ToList();
+    }
+
+    private async Task UpdateOutboxMessageAsync(
+        IDbConnection connection,
+        IDbTransaction transaction,
+        OutboxMessageResponse outboxMessage,
+        Exception? exception)
+    {
+        if (exception is null)
+        {
+            const string sql =
+                """
+                UPDATE catalog.outbox_messages
+                SET processed_on_utc = @ProcessedOnUtc,
+                    error = NULL
+                WHERE id = @Id
+                """;
+
+            await connection.ExecuteAsync(
+                sql,
+                new { outboxMessage.Id, ProcessedOnUtc = dateTimeProvider.UtcNow },
+                transaction: transaction);
+        }
+        else
+        {
+            const string sql =
+                """
+                UPDATE catalog.outbox_messages
+                SET error = @Error
+                WHERE id = @Id
+                """;
+
+            await connection.ExecuteAsync(
+                sql,
+                new { outboxMessage.Id, Error = exception.ToString() },
+                transaction: transaction);
+        }
+    }
+
+    internal sealed record OutboxMessageResponse(Guid Id, string Content);
+
+    [LoggerMessage(LogLevel.Information, "{module} - Beginning to process outbox messages")]
+    private static partial void LogBeginProcessing(ILogger logger, string module);
+
+    [LoggerMessage(LogLevel.Information, "{module} - Completed processing outbox messages")]
+    private static partial void LogCompleted(ILogger logger, string module);
+
+    [LoggerMessage(LogLevel.Error, "{module} - Exception while processing outbox message {messageId}")]
+    private static partial void LogProcessingError(ILogger logger, Exception exception, string module, Guid messageId);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateConfiguration.cs
new file mode 100644
index 0000000..18fac0e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateConfiguration.cs
@@ -0,0 +1,63 @@
+using System.Text.Json;
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateConfiguration : IEntityTypeConfiguration<Template>
+{
+    public void Configure(EntityTypeBuilder<Template> builder)
+    {
+        builder.ToTable("templates");
+        builder.HasKey(t => t.Id);
+
+        builder.Property(t => t.Name)
+            .HasConversion(v => v.Value, v => TemplateName.FromPersistence(v))
+            .IsRequired()
+            .HasMaxLength(TemplateName.MaxLength);
+
+        builder.HasIndex(t => t.Name).IsUnique().HasDatabaseName("ix_templates_name");
+
+        builder.Property(t => t.Description)
+            .HasConversion(
+                v => v == null ? null : v.Value,
+                v => v == null ? null : TemplateDescription.FromPersistence(v))
+            .HasMaxLength(TemplateDescription.MaxLength);
+
+        builder.Property(t => t.Tier)
+            .HasConversion<string>()
+            .IsRequired();
+
+        builder.Property(t => t.PreviewImageUrl)
+            .HasConversion(
+                v => v == null ? null : v.Value,
+                v => v == null ? null : ImageUrl.FromPersistence(v))
+            .HasMaxLength(ImageUrl.MaxLength);
+
+        var featuresComparer = new ValueComparer<IReadOnlyList<string>>(
+            (a, b) => a!.SequenceEqual(b!),
+            v => v.Aggregate(0, (hash, item) => HashCode.Combine(hash, item.GetHashCode())),
+            v => v.ToList());
+
+        builder.Property(t => t.Features)
+            .HasColumnType("jsonb")
+            .HasConversion(
+                v => JsonSerializer.Serialize(v, (JsonSerializerOptions?)null),
+                v => JsonSerializer.Deserialize<List<string>>(v, (JsonSerializerOptions?)null) ?? new List<string>())
+            .Metadata.SetValueComparer(featuresComparer);
+
+        builder.Property(t => t.CreatedAtUtc).IsRequired();
+        builder.Property(t => t.UpdatedAtUtc).IsRequired();
+
+        builder.HasMany(t => t.Themes).WithOne().HasForeignKey(x => x.TemplateId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(t => t.SupportedSections).WithOne().HasForeignKey(x => x.TemplateId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(t => t.SectionVariants).WithOne().HasForeignKey(x => x.TemplateId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.Metadata.FindNavigation(nameof(Template.Themes))!.SetPropertyAccessMode(PropertyAccessMode.Field);
+        builder.Metadata.FindNavigation(nameof(Template.SupportedSections))!.SetPropertyAccessMode(PropertyAccessMode.Field);
+        builder.Metadata.FindNavigation(nameof(Template.SectionVariants))!.SetPropertyAccessMode(PropertyAccessMode.Field);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateRepository.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateRepository.cs
new file mode 100644
index 0000000..0aea752
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateRepository.cs
@@ -0,0 +1,22 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateRepository(CatalogDbContext context) : ITemplateRepository
+{
+    public async Task<Template?> GetAsync(TemplateId id, CancellationToken cancellationToken = default) =>
+        await context.Templates
+            .Include(t => t.Themes)
+            .Include(t => t.SupportedSections)
+            .Include(t => t.SectionVariants)
+            .FirstOrDefaultAsync(t => t.Id == id, cancellationToken);
+
+    public async Task<bool> NameExistsAsync(string name, CancellationToken cancellationToken = default) =>
+        await context.Templates.AnyAsync(t => t.Name == TemplateName.FromPersistence(name), cancellationToken);
+
+    public void Insert(Template template) => context.Templates.Add(template);
+
+    public void Update(Template template) => context.Templates.Update(template);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs
new file mode 100644
index 0000000..bea4581
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs
@@ -0,0 +1,41 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateSectionVariantConfiguration : IEntityTypeConfiguration<TemplateSectionVariant>
+{
+    public void Configure(EntityTypeBuilder<TemplateSectionVariant> builder)
+    {
+        builder.ToTable("template_section_variants");
+        builder.HasKey(v => v.Id);
+
+        builder.Property(v => v.TemplateId).IsRequired();
+
+        builder.Property(v => v.SectionId)
+            .HasConversion<string>()
+            .IsRequired()
+            .HasMaxLength(50);
+
+        builder.Property(v => v.Variant).IsRequired().HasMaxLength(TemplateSectionVariant.MaxVariantLength);
+
+        builder.Property(v => v.IsDefault).IsRequired();
+
+        builder.Property(v => v.PriceClass)
+            .HasConversion<string>()
+            .IsRequired()
+            .HasMaxLength(50);
+
+        builder.Property(v => v.UploadLimit);
+
+        builder.HasIndex(v => new { v.TemplateId, v.SectionId, v.Variant })
+            .IsUnique()
+            .HasDatabaseName("ix_template_section_variants_template_id_section_id_variant");
+
+        builder.HasIndex(v => new { v.TemplateId, v.SectionId })
+            .IsUnique()
+            .HasFilter("is_default = true")
+            .HasDatabaseName("ux_template_section_variants_one_default");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSupportedSectionConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSupportedSectionConfiguration.cs
new file mode 100644
index 0000000..d2b0efd
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSupportedSectionConfiguration.cs
@@ -0,0 +1,27 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateSupportedSectionConfiguration : IEntityTypeConfiguration<TemplateSupportedSection>
+{
+    public void Configure(EntityTypeBuilder<TemplateSupportedSection> builder)
+    {
+        builder.ToTable("template_supported_sections");
+        builder.HasKey(s => s.Id);
+
+        builder.Property(s => s.TemplateId).IsRequired();
+
+        builder.Property(s => s.SectionId)
+            .HasConversion<string>()
+            .IsRequired()
+            .HasMaxLength(50);
+
+        builder.Property(s => s.DisplayOrder).IsRequired();
+
+        builder.HasIndex(s => new { s.TemplateId, s.SectionId })
+            .IsUnique()
+            .HasDatabaseName("ix_template_supported_sections_template_id_section_id");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateThemeConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateThemeConfiguration.cs
new file mode 100644
index 0000000..c0f08dd
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateThemeConfiguration.cs
@@ -0,0 +1,49 @@
+using System.Text.Json;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateThemeConfiguration : IEntityTypeConfiguration<TemplateTheme>
+{
+    public void Configure(EntityTypeBuilder<TemplateTheme> builder)
+    {
+        builder.ToTable("template_themes");
+        builder.HasKey(t => t.Id);
+
+        builder.Property(t => t.TemplateId).IsRequired();
+        builder.Property(t => t.ThemeIndex).IsRequired();
+
+        builder.Property(t => t.Name)
+            .HasConversion(v => v.Value, v => TemplateThemeName.FromPersistence(v))
+            .IsRequired()
+            .HasMaxLength(TemplateThemeName.MaxLength);
+
+        builder.Property(t => t.Colors)
+            .HasColumnType("jsonb")
+            .HasConversion(
+                v => JsonSerializer.Serialize(v, (JsonSerializerOptions?)null),
+                v => JsonSerializer.Deserialize<ThemeColors>(v, (JsonSerializerOptions?)null)!)
+            .IsRequired();
+
+        builder.Property(t => t.Typography)
+            .HasColumnType("jsonb")
+            .HasConversion(
+                v => JsonSerializer.Serialize(v, (JsonSerializerOptions?)null),
+                v => JsonSerializer.Deserialize<ThemeTypography>(v, (JsonSerializerOptions?)null)!)
+            .IsRequired();
+
+        builder.Property(t => t.Textures)
+            .HasColumnType("jsonb")
+            .HasConversion(
+                v => v != null ? JsonSerializer.Serialize(v, (JsonSerializerOptions?)null) : null,
+                v => v != null ? JsonSerializer.Deserialize<ThemeTextures>(v, (JsonSerializerOptions?)null) : null);
+
+        builder.Property(t => t.IsDark).IsRequired();
+
+        builder.HasIndex(t => new { t.TemplateId, t.ThemeIndex })
+            .IsUnique()
+            .HasDatabaseName("ix_template_themes_template_id_theme_index");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/CatalogTemplateManifestChangedIntegrationEvent.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/CatalogTemplateManifestChangedIntegrationEvent.cs
new file mode 100644
index 0000000..2b2dc6c
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/CatalogTemplateManifestChangedIntegrationEvent.cs
@@ -0,0 +1,29 @@
+using Eternelle.Common.Application.EventBus;
+
+namespace Eternelle.Modules.Catalog.IntegrationEvents;
+
+public sealed class CatalogTemplateManifestChangedIntegrationEvent : IntegrationEvent
+{
+    public CatalogTemplateManifestChangedIntegrationEvent(
+        Guid id,
+        DateTime occurredOnUtc,
+        Guid templateId,
+        string name,
+        string tier,
+        IReadOnlyList<string> sectionIds,
+        IReadOnlyList<SectionVariantManifest> variants)
+        : base(id, occurredOnUtc)
+    {
+        TemplateId = templateId;
+        Name = name;
+        Tier = tier;
+        SectionIds = sectionIds;
+        Variants = variants;
+    }
+
+    public Guid TemplateId { get; init; }
+    public string Name { get; init; }
+    public string Tier { get; init; }
+    public IReadOnlyList<string> SectionIds { get; init; }
+    public IReadOnlyList<SectionVariantManifest> Variants { get; init; }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj
new file mode 100644
index 0000000..b9e5a29
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Application\Eternelle.Common.Application.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/SectionVariantManifest.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/SectionVariantManifest.cs
new file mode 100644
index 0000000..1a4888f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/SectionVariantManifest.cs
@@ -0,0 +1,8 @@
+namespace Eternelle.Modules.Catalog.IntegrationEvents;
+
+public sealed record SectionVariantManifest(
+    string SectionId,
+    string Variant,
+    string PriceClass,
+    bool IsDefault,
+    int? UploadLimit);
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/AssemblyReference.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/AssemblyReference.cs
new file mode 100644
index 0000000..711bf77
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/AssemblyReference.cs
@@ -0,0 +1,8 @@
+using System.Reflection;
+
+namespace Eternelle.Modules.Catalog.Presentation;
+
+public static class AssemblyReference
+{
+    public static readonly Assembly Assembly = typeof(AssemblyReference).Assembly;
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj
new file mode 100644
index 0000000..297b70e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj
@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.Application\Eternelle.Modules.Catalog.Application.csproj" />
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Presentation\Eternelle.Common.Presentation.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Tags.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Tags.cs
new file mode 100644
index 0000000..143da75
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Tags.cs
@@ -0,0 +1,6 @@
+namespace Eternelle.Modules.Catalog.Presentation;
+
+internal static class Tags
+{
+    internal const string Catalog = "Catalog";
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSectionVariantEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSectionVariantEndpoint.cs
new file mode 100644
index 0000000..a0cc128
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSectionVariantEndpoint.cs
@@ -0,0 +1,36 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class AddSectionVariantEndpoint : IEndpoint
+{
+    internal sealed record Request(string Variant, bool IsDefault, PriceClass PriceClass, int? UploadLimit);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost("catalog/templates/{templateId:guid}/sections/{sectionId}/variants", async (
+            Guid templateId,
+            SectionId sectionId,
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new AddSectionVariantCommand(
+                templateId, sectionId, request.Variant, request.IsDefault, request.PriceClass, request.UploadLimit);
+
+            Result result = await sender.Send(command, cancellationToken);
+
+            return result.Match(Results.NoContent, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSupportedSectionEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSupportedSectionEndpoint.cs
new file mode 100644
index 0000000..80a3a03
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSupportedSectionEndpoint.cs
@@ -0,0 +1,34 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.AddSupportedSection;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class AddSupportedSectionEndpoint : IEndpoint
+{
+    internal sealed record Request(SectionId SectionId, int DisplayOrder);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost("catalog/templates/{templateId:guid}/sections", async (
+            Guid templateId,
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new AddSupportedSectionCommand(templateId, request.SectionId, request.DisplayOrder);
+
+            Result result = await sender.Send(command, cancellationToken);
+
+            return result.Match(Results.NoContent, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddTemplateThemeEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddTemplateThemeEndpoint.cs
new file mode 100644
index 0000000..8ec0032
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddTemplateThemeEndpoint.cs
@@ -0,0 +1,41 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.AddTemplateTheme;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class AddTemplateThemeEndpoint : IEndpoint
+{
+    internal sealed record Request(
+        int ThemeIndex,
+        string Name,
+        IReadOnlyDictionary<string, string> Colors,
+        IReadOnlyDictionary<string, string> Typography,
+        IReadOnlyDictionary<string, string>? Textures,
+        bool IsDark);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost("catalog/templates/{templateId:guid}/themes", async (
+            Guid templateId,
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new AddTemplateThemeCommand(
+                templateId, request.ThemeIndex, request.Name,
+                request.Colors, request.Typography, request.Textures, request.IsDark);
+
+            Result result = await sender.Send(command, cancellationToken);
+
+            return result.Match(Results.NoContent, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/CreateTemplateEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/CreateTemplateEndpoint.cs
new file mode 100644
index 0000000..ad86c18
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/CreateTemplateEndpoint.cs
@@ -0,0 +1,41 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class CreateTemplateEndpoint : IEndpoint
+{
+    internal sealed record Request(
+        string Name,
+        string? Description,
+        TemplateTier Tier,
+        string? PreviewImageUrl,
+        IReadOnlyList<string>? Features);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost("catalog/templates", async (
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new CreateTemplateCommand(
+                request.Name, request.Description, request.Tier, request.PreviewImageUrl, request.Features);
+
+            Result<Guid> result = await sender.Send(command, cancellationToken);
+
+            return result.Match(
+                id => Results.Created($"/catalog/templates/{id}", new { id }),
+                ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetSectionVariantsEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetSectionVariantsEndpoint.cs
new file mode 100644
index 0000000..6c04779
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetSectionVariantsEndpoint.cs
@@ -0,0 +1,32 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.GetSectionVariants;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class GetSectionVariantsEndpoint : IEndpoint
+{
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapGet("catalog/templates/{templateId:guid}/sections/{sectionId}/variants", async (
+            Guid templateId,
+            SectionId sectionId,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            Result<IReadOnlyList<SectionVariantResponse>> result =
+                await sender.Send(new GetSectionVariantsQuery(templateId, sectionId), cancellationToken);
+
+            return result.Match(Results.Ok, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .AllowAnonymous();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplateByIdEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplateByIdEndpoint.cs
new file mode 100644
index 0000000..4c7c68f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplateByIdEndpoint.cs
@@ -0,0 +1,29 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class GetTemplateByIdEndpoint : IEndpoint
+{
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapGet("catalog/templates/{templateId:guid}", async (
+            Guid templateId,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            Result<TemplateDetailResponse> result =
+                await sender.Send(new GetTemplateByIdQuery(templateId), cancellationToken);
+
+            return result.Match(Results.Ok, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .AllowAnonymous();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplatesEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplatesEndpoint.cs
new file mode 100644
index 0000000..7ca21de
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplatesEndpoint.cs
@@ -0,0 +1,30 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplates;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class GetTemplatesEndpoint : IEndpoint
+{
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapGet("catalog/templates", async (
+            TemplateTier? tier,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            Result<IReadOnlyList<TemplateSummaryResponse>> result =
+                await sender.Send(new GetTemplatesQuery(tier), cancellationToken);
+
+            return result.Match(Results.Ok, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .AllowAnonymous();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/UpdateTemplateEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/UpdateTemplateEndpoint.cs
new file mode 100644
index 0000000..ca644c3
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/UpdateTemplateEndpoint.cs
@@ -0,0 +1,38 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.UpdateTemplate;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class UpdateTemplateEndpoint : IEndpoint
+{
+    internal sealed record Request(
+        string Name,
+        string? Description,
+        string? PreviewImageUrl,
+        IReadOnlyList<string>? Features);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPut("catalog/templates/{templateId:guid}", async (
+            Guid templateId,
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new UpdateTemplateCommand(
+                templateId, request.Name, request.Description, request.PreviewImageUrl, request.Features);
+
+            Result result = await sender.Send(command, cancellationToken);
+
+            return result.Match(Results.NoContent, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.Designer.cs b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.Designer.cs
new file mode 100644
index 0000000..cd54970
--- /dev/null
+++ b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.Designer.cs
@@ -0,0 +1,334 @@
+// <auto-generated />
+using System;
+using Eternelle.Modules.Users.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Eternelle.Modules.Users.Infrastructure.Database.Migrations
+{
+    [DbContext(typeof(UsersDbContext))]
+    [Migration("20260527101020_AddCatalogManagePermission")]
+    partial class AddCatalogManagePermission
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("users")
+                .HasAnnotation("ProductVersion", "10.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Inbox.InboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("jsonb")
+                        .HasColumnName("content");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<DateTime>("OccurredOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on_utc");
+
+                    b.Property<DateTime?>("ProcessedOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_on_utc");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_inbox_messages");
+
+                    b.ToTable("inbox_messages", "users");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Inbox.InboxMessageConsumer", b =>
+                {
+                    b.Property<Guid>("InboxMessageId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("inbox_message_id");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("name");
+
+                    b.HasKey("InboxMessageId", "Name")
+                        .HasName("pk_inbox_message_consumers");
+
+                    b.ToTable("inbox_message_consumers", "users");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("jsonb")
+                        .HasColumnName("content");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<DateTime>("OccurredOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on_utc");
+
+                    b.Property<DateTime?>("ProcessedOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_on_utc");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_outbox_messages");
+
+                    b.ToTable("outbox_messages", "users");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessageConsumer", b =>
+                {
+                    b.Property<Guid>("OutboxMessageId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("outbox_message_id");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("name");
+
+                    b.HasKey("OutboxMessageId", "Name")
+                        .HasName("pk_outbox_message_consumers");
+
+                    b.ToTable("outbox_message_consumers", "users");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Users.Domain.Users.Permission", b =>
+                {
+                    b.Property<string>("Code")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("code");
+
+                    b.HasKey("Code")
+                        .HasName("pk_permissions");
+
+                    b.ToTable("permissions", "users");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = "users:read"
+                        },
+                        new
+                        {
+                            Code = "users:update"
+                        });
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Users.Domain.Users.Role", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("name");
+
+                    b.HasKey("Name")
+                        .HasName("pk_roles");
+
+                    b.ToTable("roles", "users");
+
+                    b.HasData(
+                        new
+                        {
+                            Name = "Admin"
+                        },
+                        new
+                        {
+                            Name = "Couple"
+                        },
+                        new
+                        {
+                            Name = "Guest"
+                        });
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Users.Domain.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)")
+                        .HasColumnName("email");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("first_name");
+
+                    b.Property<string>("IdentityId")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("identity_id");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("last_name");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)")
+                        .HasColumnName("phone_number");
+
+                    b.HasKey("Id")
+                        .HasName("pk_users");
+
+                    b.HasIndex("Email")
+                        .IsUnique()
+                        .HasDatabaseName("ix_users_email");
+
+                    b.HasIndex("IdentityId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_users_identity_id");
+
+                    b.ToTable("users", "users");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.Property<string>("PermissionCode")
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("permission_code");
+
+                    b.Property<string>("RoleName")
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("role_name");
+
+                    b.HasKey("PermissionCode", "RoleName")
+                        .HasName("pk_role_permissions");
+
+                    b.HasIndex("RoleName")
+                        .HasDatabaseName("ix_role_permissions_role_name");
+
+                    b.ToTable("role_permissions", "users");
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionCode = "users:read",
+                            RoleName = "Couple"
+                        },
+                        new
+                        {
+                            PermissionCode = "users:update",
+                            RoleName = "Couple"
+                        },
+                        new
+                        {
+                            PermissionCode = "users:read",
+                            RoleName = "Admin"
+                        },
+                        new
+                        {
+                            PermissionCode = "users:update",
+                            RoleName = "Admin"
+                        },
+                        new
+                        {
+                            PermissionCode = "users:read",
+                            RoleName = "Guest"
+                        });
+                });
+
+            modelBuilder.Entity("RoleUser", b =>
+                {
+                    b.Property<string>("RolesName")
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("role_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("RolesName", "UserId")
+                        .HasName("pk_user_roles");
+
+                    b.HasIndex("UserId")
+                        .HasDatabaseName("ix_user_roles_user_id");
+
+                    b.ToTable("user_roles", "users");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Users.Domain.Users.Permission", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_role_permissions_permissions_permission_code");
+
+                    b.HasOne("Eternelle.Modules.Users.Domain.Users.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_role_permissions_roles_role_name");
+                });
+
+            modelBuilder.Entity("RoleUser", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Users.Domain.Users.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RolesName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_user_roles_roles_roles_name");
+
+                    b.HasOne("Eternelle.Modules.Users.Domain.Users.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_user_roles_users_user_id");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs
new file mode 100644
index 0000000..0aa869d
--- /dev/null
+++ b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs
@@ -0,0 +1,33 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Eternelle.Modules.Users.Infrastructure.Database.Migrations;
+
+/// <inheritdoc />
+public partial class AddCatalogManagePermission : Migration
+{
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+        migrationBuilder.Sql(
+            """
+            INSERT INTO users.permissions (code)
+            VALUES ('catalog:manage')
+            ON CONFLICT DO NOTHING;
+
+            INSERT INTO users.role_permissions (permission_code, role_name)
+            VALUES ('catalog:manage', 'Admin')
+            ON CONFLICT DO NOTHING;
+            """);
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+        migrationBuilder.Sql(
+            """
+            DELETE FROM users.role_permissions WHERE permission_code = 'catalog:manage' AND role_name = 'Admin';
+            """);
+    }
+}