diff --git a/docs/ArtifactNamingService.md b/docs/ArtifactNamingService.md
new file mode 100644
index 0000000000..23081a62bc
--- /dev/null
+++ b/docs/ArtifactNamingService.md
@@ -0,0 +1,100 @@
+# Artifact Naming Service
+
+The artifact naming service provides a standardized way to generate consistent names and paths for test artifacts across all extensions.
+
+## Features
+
+### Template-Based Naming
+Use placeholders in angle brackets to create dynamic file names:
+
+```
+<process-name>_<pid>_<id>_hang.dmp
+```
+Resolves to: `MyTests_12345_a1b2c3d4_hang.dmp`
+
+### Complex Path Templates
+Create structured directory layouts:
+
+```
+<root>/artifacts/<os>/<assembly>/dumps/<process-name>_<pid>_<tfm>_<time>.dmp
+```
+Resolves to: `c:/myproject/artifacts/linux/MyTests/dumps/my-child-process_10001_net9.0_2025-09-22T13:49:34.dmp`
+
+### Available Placeholders
+
+| Placeholder | Description | Example |
+|-------------|-------------|---------|
+| `<process-name>` | Name of the process | `MyTests` |
+| `<pid>` | Process ID | `12345` |
+| `<id>` | Short random identifier (8 chars) | `a1b2c3d4` |
+| `<os>` | Operating system | `windows`, `linux`, `macos` |
+| `<assembly>` | Assembly name | `MyTests` |
+| `<tfm>` | Target framework moniker | `net9.0`, `net8.0` |
+| `<time>` | Timestamp (1-second precision) | `2025-09-22T13:49:34` |
+| `<root>` | Project root directory | Found via solution/git/working dir |
+
+### Backward Compatibility
+Legacy patterns are still supported:
+
+```csharp
+// Old pattern
+"myfile_%p.dmp"
+
+// Works with legacy support
+service.ResolveTemplateWithLegacySupport("myfile_%p.dmp", 
+    legacyReplacements: new Dictionary<string, string> { ["%p"] = "12345" });
+```
+
+### Custom Replacements
+Override default values for specific scenarios:
+
+```csharp
+// When dumping a different process than the test host
+var customReplacements = new Dictionary<string, string>
+{
+    ["process-name"] = "Notepad",
+    ["pid"] = "1111"
+};
+
+string result = service.ResolveTemplate("<process-name>_<pid>.dmp", customReplacements);
+// Result: "Notepad_1111.dmp"
+```
+
+## Usage in Extensions
+
+Extensions can use the service through dependency injection:
+
+```csharp
+public class MyExtension
+{
+    private readonly IArtifactNamingService _artifactNamingService;
+    
+    public MyExtension(IServiceProvider serviceProvider)
+    {
+        _artifactNamingService = serviceProvider.GetArtifactNamingService();
+    }
+    
+    public void CreateArtifact(string template)
+    {
+        string fileName = _artifactNamingService.ResolveTemplate(template);
+        // Use fileName for artifact creation
+    }
+}
+```
+
+## Hang Dump Integration
+
+The hang dump extension now uses the artifact naming service and supports both legacy and modern patterns:
+
+```bash
+# Legacy pattern (still works)
+--hangdump-filename "mydump_%p.dmp"
+
+# New template pattern  
+--hangdump-filename "<process-name>_<pid>_<id>_hang.dmp"
+
+# Complex path template
+--hangdump-filename "<root>/dumps/<os>/<process-name>_<pid>_<time>.dmp"
+```
+
+This provides consistent artifact naming across all extensions while maintaining backward compatibility.
\ No newline at end of file
diff --git a/src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpProcessLifetimeHandler.cs b/src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpProcessLifetimeHandler.cs
index 03130bdd14..7802808297 100644
--- a/src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpProcessLifetimeHandler.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpProcessLifetimeHandler.cs
@@ -45,6 +45,7 @@ internal sealed class HangDumpProcessLifetimeHandler : ITestHostProcessLifetimeH
     private readonly ILogger<HangDumpProcessLifetimeHandler> _logger;
     private readonly ManualResetEventSlim _mutexNameReceived = new(false);
     private readonly ManualResetEventSlim _waitConsumerPipeName = new(false);
+    private readonly IArtifactNamingService _artifactNamingService;
 
     private TimeSpan _activityTimerValue = TimeSpan.FromMinutes(30);
     private Task? _waitConnectionTask;
@@ -85,6 +86,7 @@ public HangDumpProcessLifetimeHandler(
         _processHandler = processHandler;
         _clock = clock;
         _testApplicationCancellationTokenSource = serviceProvider.GetTestApplicationCancellationTokenSource();
+        _artifactNamingService = serviceProvider.GetArtifactNamingService();
         _dumpFileNamePattern = $"{Path.GetFileNameWithoutExtension(testApplicationModuleInfo.GetCurrentTestApplicationFullPath())}_%p_hang.dmp";
     }
 
@@ -352,7 +354,32 @@ private async Task TakeDumpAsync()
         await _logger.LogInformationAsync($"Hang dump timeout({_activityTimerValue}) expired.").ConfigureAwait(false);
         await _outputDisplay.DisplayAsync(this, new ErrorMessageOutputDeviceData(string.Format(CultureInfo.InvariantCulture, ExtensionResources.HangDumpTimeoutExpired, _activityTimerValue))).ConfigureAwait(false);
 
-        string finalDumpFileName = _dumpFileNamePattern.Replace("%p", _testHostProcessInformation.PID.ToString(CultureInfo.InvariantCulture));
+        // Create custom replacements for the dumped process
+        string processName;
+        try
+        {
+            using var process = _processHandler.GetProcessById(_testHostProcessInformation.PID);
+            processName = process.ProcessName;
+        }
+        catch
+        {
+            // If we can't get the process name, use a default
+            processName = "testhost";
+        }
+
+        var customReplacements = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["process-name"] = processName,
+            ["pid"] = _testHostProcessInformation.PID.ToString(CultureInfo.InvariantCulture)
+        };
+
+        // Create legacy replacements for backward compatibility
+        var legacyReplacements = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["%p"] = _testHostProcessInformation.PID.ToString(CultureInfo.InvariantCulture)
+        };
+
+        string finalDumpFileName = _artifactNamingService.ResolveTemplateWithLegacySupport(_dumpFileNamePattern, customReplacements, legacyReplacements);
         finalDumpFileName = Path.Combine(_configuration.GetTestResultDirectory(), finalDumpFileName);
 
         ApplicationStateGuard.Ensure(_namedPipeClient is not null);
diff --git a/src/Platform/Microsoft.Testing.Platform/Hosts/TestHostBuilder.cs b/src/Platform/Microsoft.Testing.Platform/Hosts/TestHostBuilder.cs
index 2a88a5c5e1..223779b5d3 100644
--- a/src/Platform/Microsoft.Testing.Platform/Hosts/TestHostBuilder.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Hosts/TestHostBuilder.cs
@@ -101,6 +101,10 @@ public async Task<IHost> BuildAsync(
         serviceProvider.TryAddService(systemMonitor);
         SystemMonitorAsyncFactory systemMonitorAsyncFactory = new();
         serviceProvider.TryAddService(systemMonitorAsyncFactory);
+        
+        // Add artifact naming service
+        ArtifactNamingService artifactNamingService = new(_testApplicationModuleInfo, systemEnvironment, systemClock, processHandler);
+        serviceProvider.TryAddService(artifactNamingService);
 
         PlatformInformation platformInformation = new();
         serviceProvider.AddService(platformInformation);
diff --git a/src/Platform/Microsoft.Testing.Platform/Services/ArtifactNamingService.cs b/src/Platform/Microsoft.Testing.Platform/Services/ArtifactNamingService.cs
new file mode 100644
index 0000000000..e0b1b3d48e
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform/Services/ArtifactNamingService.cs
@@ -0,0 +1,233 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
+
+using Microsoft.Testing.Platform.Helpers;
+
+namespace Microsoft.Testing.Platform.Services;
+
+internal sealed class ArtifactNamingService : IArtifactNamingService
+{
+    private readonly ITestApplicationModuleInfo _testApplicationModuleInfo;
+    private readonly IEnvironment _environment;
+    private readonly IClock _clock;
+    private readonly IProcessHandler _processHandler;
+
+    private static readonly Regex TemplateFieldRegex = new(@"<([^>]+)>", RegexOptions.Compiled);
+
+    public ArtifactNamingService(
+        ITestApplicationModuleInfo testApplicationModuleInfo,
+        IEnvironment environment,
+        IClock clock,
+        IProcessHandler processHandler)
+    {
+        _testApplicationModuleInfo = testApplicationModuleInfo;
+        _environment = environment;
+        _clock = clock;
+        _processHandler = processHandler;
+    }
+
+    public string ResolveTemplate(string template, IDictionary<string, string>? customReplacements = null)
+    {
+        ArgumentGuard.IsNotNullOrEmpty(template);
+
+        var defaultReplacements = GetDefaultReplacements();
+        var allReplacements = MergeReplacements(defaultReplacements, customReplacements);
+
+        return TemplateFieldRegex.Replace(template, match =>
+        {
+            string fieldName = match.Groups[1].Value;
+            return allReplacements.TryGetValue(fieldName, out string? value) ? value : match.Value;
+        });
+    }
+
+    public string ResolveTemplateWithLegacySupport(string template, IDictionary<string, string>? customReplacements = null, IDictionary<string, string>? legacyReplacements = null)
+    {
+        ArgumentGuard.IsNotNullOrEmpty(template);
+
+        // First apply legacy replacements
+        string processedTemplate = template;
+        if (legacyReplacements is not null)
+        {
+            foreach (var (legacyPattern, replacement) in legacyReplacements)
+            {
+                processedTemplate = processedTemplate.Replace(legacyPattern, replacement);
+            }
+        }
+
+        // Then apply modern template resolution
+        return ResolveTemplate(processedTemplate, customReplacements);
+    }
+
+    private Dictionary<string, string> GetDefaultReplacements()
+    {
+        var replacements = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+
+        // Assembly info
+        string? assemblyName = _testApplicationModuleInfo.TryGetAssemblyName();
+        if (!RoslynString.IsNullOrEmpty(assemblyName))
+        {
+            replacements["assembly"] = assemblyName;
+        }
+
+        // Process info
+        using var currentProcess = _processHandler.GetCurrentProcess();
+        replacements["pid"] = currentProcess.Id.ToString(CultureInfo.InvariantCulture);
+        replacements["process-name"] = currentProcess.ProcessName;
+
+        // OS info
+        replacements["os"] = GetOperatingSystemName();
+
+        // Target framework info
+        string tfm = GetTargetFrameworkMoniker();
+        if (!RoslynString.IsNullOrEmpty(tfm))
+        {
+            replacements["tfm"] = tfm;
+        }
+
+        // Time info (precision to 1 second)
+        replacements["time"] = _clock.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss", CultureInfo.InvariantCulture);
+
+        // Random ID for uniqueness
+        replacements["id"] = GenerateShortId();
+
+        // Root directory
+        replacements["root"] = GetRootDirectory();
+
+        return replacements;
+    }
+
+    private static Dictionary<string, string> MergeReplacements(Dictionary<string, string> defaultReplacements, IDictionary<string, string>? customReplacements)
+    {
+        if (customReplacements is null || customReplacements.Count == 0)
+        {
+            return defaultReplacements;
+        }
+
+        var merged = new Dictionary<string, string>(defaultReplacements, StringComparer.OrdinalIgnoreCase);
+        foreach (var (key, value) in customReplacements)
+        {
+            merged[key] = value;
+        }
+
+        return merged;
+    }
+
+    private static string GetOperatingSystemName()
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            return "windows";
+        }
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            return "linux";
+        }
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            return "macos";
+        }
+
+        return "unknown";
+    }
+
+    private static string GetTargetFrameworkMoniker()
+    {
+        // Extract TFM from current runtime
+        string frameworkDescription = RuntimeInformation.FrameworkDescription;
+        
+        if (frameworkDescription.Contains(".NET Core"))
+        {
+            // Try to extract version from .NET Core description
+            var match = Regex.Match(frameworkDescription, @"\.NET Core (\d+\.\d+)");
+            if (match.Success)
+            {
+                return $"netcoreapp{match.Groups[1].Value}";
+            }
+        }
+        else if (frameworkDescription.Contains(".NET "))
+        {
+            // Try to extract version from .NET 5+ description
+            var match = Regex.Match(frameworkDescription, @"\.NET (\d+\.\d+)");
+            if (match.Success)
+            {
+                string version = match.Groups[1].Value;
+                return version switch
+                {
+                    "5.0" => "net5.0",
+                    "6.0" => "net6.0",
+                    "7.0" => "net7.0",
+                    "8.0" => "net8.0",
+                    "9.0" => "net9.0",
+                    "10.0" => "net10.0",
+                    _ => $"net{version}"
+                };
+            }
+        }
+        else if (frameworkDescription.Contains(".NET Framework"))
+        {
+            // Try to extract version from .NET Framework description
+            var match = Regex.Match(frameworkDescription, @"\.NET Framework (\d+\.\d+)");
+            if (match.Success)
+            {
+                return $"net{match.Groups[1].Value.Replace(".", "")}";
+            }
+        }
+
+        return Environment.Version.ToString();
+    }
+
+    private static string GenerateShortId()
+    {
+        return Guid.NewGuid().ToString("N")[..8];
+    }
+
+    private string GetRootDirectory()
+    {
+        string currentDirectory = _testApplicationModuleInfo.GetCurrentTestApplicationDirectory();
+        
+        // Try to find solution root, git root, or working directory
+        string? rootDirectory = FindSolutionRoot(currentDirectory) 
+            ?? FindGitRoot(currentDirectory) 
+            ?? currentDirectory;
+
+        return rootDirectory;
+    }
+
+    private static string? FindSolutionRoot(string startDirectory)
+    {
+        string? directory = startDirectory;
+        while (directory is not null)
+        {
+            if (Directory.GetFiles(directory, "*.sln").Length > 0)
+            {
+                return directory;
+            }
+
+            directory = Directory.GetParent(directory)?.FullName;
+        }
+
+        return null;
+    }
+
+    private static string? FindGitRoot(string startDirectory)
+    {
+        string? directory = startDirectory;
+        while (directory is not null)
+        {
+            if (Directory.Exists(Path.Combine(directory, ".git")))
+            {
+                return directory;
+            }
+
+            directory = Directory.GetParent(directory)?.FullName;
+        }
+
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/src/Platform/Microsoft.Testing.Platform/Services/IArtifactNamingService.cs b/src/Platform/Microsoft.Testing.Platform/Services/IArtifactNamingService.cs
new file mode 100644
index 0000000000..aa2ac0bcf4
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform/Services/IArtifactNamingService.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Testing.Platform.Services;
+
+/// <summary>
+/// Service for generating consistent artifact names and paths using template patterns.
+/// Supports placeholders like &lt;process-name&gt;, &lt;pid&gt;, &lt;id&gt;, &lt;os&gt;, &lt;assembly&gt;, &lt;tfm&gt;, &lt;time&gt;, &lt;root&gt;.
+/// </summary>
+internal interface IArtifactNamingService
+{
+    /// <summary>
+    /// Resolves a template pattern with available field replacements.
+    /// </summary>
+    /// <param name="template">Template pattern with placeholders like '&lt;process-name&gt;_&lt;pid&gt;_hang.dmp'.</param>
+    /// <param name="customReplacements">Optional custom field replacements to override default values.</param>
+    /// <returns>Resolved string with placeholders replaced by actual values.</returns>
+    string ResolveTemplate(string template, IDictionary<string, string>? customReplacements = null);
+
+    /// <summary>
+    /// Resolves a template pattern with backward compatibility for legacy patterns.
+    /// </summary>
+    /// <param name="template">Template pattern that may contain legacy patterns like '%p'.</param>
+    /// <param name="customReplacements">Optional custom field replacements to override default values.</param>
+    /// <param name="legacyReplacements">Legacy pattern replacements for backward compatibility.</param>
+    /// <returns>Resolved string with both new and legacy placeholders replaced.</returns>
+    string ResolveTemplateWithLegacySupport(string template, IDictionary<string, string>? customReplacements = null, IDictionary<string, string>? legacyReplacements = null);
+}
\ No newline at end of file
diff --git a/src/Platform/Microsoft.Testing.Platform/Services/ServiceProviderExtensions.cs b/src/Platform/Microsoft.Testing.Platform/Services/ServiceProviderExtensions.cs
index 1c74ea6a2d..d806c26832 100644
--- a/src/Platform/Microsoft.Testing.Platform/Services/ServiceProviderExtensions.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Services/ServiceProviderExtensions.cs
@@ -206,4 +206,7 @@ internal static IPlatformInformation GetPlatformInformation(this IServiceProvide
 
     internal static IFileLoggerInformation? GetFileLoggerInformation(this IServiceProvider serviceProvider)
         => serviceProvider.GetServiceInternal<IFileLoggerInformation>();
+
+    internal static IArtifactNamingService GetArtifactNamingService(this IServiceProvider serviceProvider)
+        => serviceProvider.GetRequiredServiceInternal<IArtifactNamingService>();
 }
diff --git a/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HangDumpTests.cs b/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HangDumpTests.cs
index 8e113826ef..8a734216b9 100644
--- a/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HangDumpTests.cs
+++ b/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HangDumpTests.cs
@@ -80,6 +80,45 @@ public async Task HangDump_PathWithSpaces_CreateDump()
         Assert.IsNotNull(dumpFile, $"Dump file not found '{TargetFrameworks.NetCurrent}'\n{testHostResult}'");
     }
 
+    [TestMethod]
+    public async Task HangDump_TemplateFileName_CreateDump()
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            // TODO: Investigate failures on macos
+            return;
+        }
+
+        string resultDirectory = Path.Combine(AssetFixture.TargetAssetPath, Guid.NewGuid().ToString("N"), TargetFrameworks.NetCurrent);
+        var testHost = TestInfrastructure.TestHost.LocateFrom(AssetFixture.TargetAssetPath, "HangDump", TargetFrameworks.NetCurrent);
+        TestHostResult testHostResult = await testHost.ExecuteAsync(
+            $"--hangdump --hangdump-timeout 8s --hangdump-filename <process-name>_<pid>_<id>_hang.dmp --results-directory {resultDirectory}",
+            new Dictionary<string, string?>
+            {
+                { "SLEEPTIMEMS1", "4000" },
+                { "SLEEPTIMEMS2", "20000" },
+            },
+            cancellationToken: TestContext.CancellationToken);
+        testHostResult.AssertExitCodeIs(ExitCodes.TestHostProcessExitedNonGracefully);
+        
+        // Verify the dump file uses the template format
+        string[] dumpFiles = Directory.GetFiles(resultDirectory, "*_hang.dmp", SearchOption.AllDirectories);
+        Assert.IsTrue(dumpFiles.Length > 0, $"No dump files found in '{resultDirectory}'\n{testHostResult}'");
+        
+        string dumpFile = dumpFiles[0];
+        string fileName = Path.GetFileNameWithoutExtension(dumpFile);
+        
+        // File should match pattern: <process-name>_<pid>_<id>_hang
+        // The process name should be the test executable name, pid should be numeric, id should be 8 chars
+        Assert.IsTrue(fileName.EndsWith("_hang"), $"File name should end with '_hang'. Actual: {fileName}");
+        
+        string[] parts = fileName.Split('_');
+        Assert.IsTrue(parts.Length >= 3, $"File name should have at least 3 parts separated by '_'. Actual: {fileName}");
+        Assert.IsTrue(int.TryParse(parts[^3], out _), $"Third-to-last part should be PID (numeric). Actual: {parts[^3]}");
+        Assert.AreEqual(8, parts[^2].Length, $"Second-to-last part should be 8-character ID. Actual: {parts[^2]}");
+        Assert.AreEqual("hang", parts[^1], "Last part should be 'hang'");
+    }
+
     [DataRow("Mini")]
     [DataRow("Heap")]
     [DataRow("Triage")]
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Services/ArtifactNamingServiceTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Services/ArtifactNamingServiceTests.cs
new file mode 100644
index 0000000000..92df36a88a
--- /dev/null
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Services/ArtifactNamingServiceTests.cs
@@ -0,0 +1,222 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Runtime.InteropServices;
+
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Services;
+
+using Moq;
+
+namespace Microsoft.Testing.Platform.UnitTests.Services;
+
+[TestClass]
+public sealed class ArtifactNamingServiceTests
+{
+    private readonly Mock<ITestApplicationModuleInfo> _testApplicationModuleInfo = new();
+    private readonly Mock<IEnvironment> _environment = new();
+    private readonly Mock<IClock> _clock = new();
+    private readonly Mock<IProcessHandler> _processHandler = new();
+    private readonly Mock<IProcess> _process = new();
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        _testApplicationModuleInfo.Setup(x => x.TryGetAssemblyName()).Returns("TestAssembly");
+        _testApplicationModuleInfo.Setup(x => x.GetCurrentTestApplicationDirectory()).Returns("/test/directory");
+        
+        _clock.Setup(x => x.UtcNow).Returns(new DateTimeOffset(2025, 9, 22, 13, 49, 34, TimeSpan.Zero));
+        
+        _process.Setup(x => x.Id).Returns(12345);
+        _process.Setup(x => x.ProcessName).Returns("test-process");
+        _processHandler.Setup(x => x.GetCurrentProcess()).Returns(_process.Object);
+    }
+
+    [TestMethod]
+    public void ResolveTemplate_WithBasicPlaceholders_ReplacesCorrectly()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "<process-name>_<pid>_<assembly>.dmp";
+
+        // Act
+        string result = service.ResolveTemplate(template);
+
+        // Assert
+        result.Should().Contain("test-process");
+        result.Should().Contain("12345");
+        result.Should().Contain("TestAssembly");
+        result.Should().MatchRegex(@"test-process_12345_TestAssembly\.dmp");
+    }
+
+    [TestMethod]
+    public void ResolveTemplate_WithTimeAndIdPlaceholders_ReplacesCorrectly()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "<time>_<id>_<os>";
+
+        // Act
+        string result = service.ResolveTemplate(template);
+
+        // Assert
+        result.Should().Contain("2025-09-22T13:49:34");
+        result.Should().MatchRegex(@"2025-09-22T13:49:34_[a-f0-9]{8}_\w+");
+        
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            result.Should().Contain("linux");
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            result.Should().Contain("windows");
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            result.Should().Contain("macos");
+        }
+    }
+
+    [TestMethod]
+    public void ResolveTemplate_WithCustomReplacements_OverridesDefaultValues()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "<process-name>_<pid>_custom.dmp";
+        var customReplacements = new Dictionary<string, string>
+        {
+            ["process-name"] = "custom-process",
+            ["pid"] = "99999"
+        };
+
+        // Act
+        string result = service.ResolveTemplate(template, customReplacements);
+
+        // Assert
+        result.Should().Be("custom-process_99999_custom.dmp");
+    }
+
+    [TestMethod]
+    public void ResolveTemplate_WithUnknownPlaceholder_KeepsPlaceholderAsIs()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "<unknown-field>_<process-name>";
+
+        // Act
+        string result = service.ResolveTemplate(template);
+
+        // Assert
+        result.Should().StartWith("<unknown-field>_");
+        result.Should().Contain("test-process");
+    }
+
+    [TestMethod]
+    public void ResolveTemplateWithLegacySupport_WithLegacyPattern_ReplacesCorrectly()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "dump_%p_hang.dmp";
+        var legacyReplacements = new Dictionary<string, string>
+        {
+            ["%p"] = "54321"
+        };
+
+        // Act
+        string result = service.ResolveTemplateWithLegacySupport(template, legacyReplacements: legacyReplacements);
+
+        // Assert
+        result.Should().Be("dump_54321_hang.dmp");
+    }
+
+    [TestMethod]
+    public void ResolveTemplateWithLegacySupport_WithMixedPatterns_ReplacesCorrectly()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "%p_<process-name>_hang.dmp";
+        var customReplacements = new Dictionary<string, string>
+        {
+            ["process-name"] = "notepad"
+        };
+        var legacyReplacements = new Dictionary<string, string>
+        {
+            ["%p"] = "1111"
+        };
+
+        // Act
+        string result = service.ResolveTemplateWithLegacySupport(template, customReplacements, legacyReplacements);
+
+        // Assert
+        result.Should().Be("1111_notepad_hang.dmp");
+    }
+
+    [TestMethod]
+    public void ResolveTemplate_WithTfmPlaceholder_ReturnsValidTfm()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "<tfm>";
+
+        // Act
+        string result = service.ResolveTemplate(template);
+
+        // Assert
+        // The TFM should be a valid framework identifier
+        result.Should().NotBeEmpty();
+        result.Should().MatchRegex(@"^(net\d+\.\d+|netcoreapp\d+\.\d+|net\d+|\d+\.\d+\.\d+\.\d+)$");
+    }
+
+    [TestMethod]
+    public void ResolveTemplate_WithRootPlaceholder_ReturnsDirectoryPath()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "<root>/artifacts";
+
+        // Act
+        string result = service.ResolveTemplate(template);
+
+        // Assert
+        result.Should().EndWith("/artifacts");
+        result.Should().NotStartWith("<root>");
+    }
+
+    [TestMethod]
+    public void ResolveTemplate_ComplexTemplate_ReplacesAllPlaceholders()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "<root>/artifacts/<os>/<assembly>/dumps/<process-name>_<pid>_<tfm>_<time>.dmp";
+
+        // Act
+        string result = service.ResolveTemplate(template);
+
+        // Assert
+        result.Should().NotContain("<");
+        result.Should().NotContain(">");
+        result.Should().Contain("/artifacts/");
+        result.Should().Contain("/TestAssembly/dumps/");
+        result.Should().Contain("test-process_12345_");
+        result.Should().Contain("2025-09-22T13:49:34.dmp");
+    }
+
+    [TestMethod]
+    public void ResolveTemplate_CaseInsensitiveReplacements_WorksCorrectly()
+    {
+        // Arrange
+        var service = new ArtifactNamingService(_testApplicationModuleInfo.Object, _environment.Object, _clock.Object, _processHandler.Object);
+        string template = "<Process-Name>_<PID>";
+        var customReplacements = new Dictionary<string, string>
+        {
+            ["PROCESS-NAME"] = "CUSTOM",
+            ["pid"] = "777"
+        };
+
+        // Act
+        string result = service.ResolveTemplate(template, customReplacements);
+
+        // Assert
+        result.Should().Be("CUSTOM_777");
+    }
+}
\ No newline at end of file