diff --git a/src/GitReleaseManager.Cli/GitReleaseManager.Cli.csproj b/src/GitReleaseManager.Cli/GitReleaseManager.Cli.csproj
index 43f1f73b..caa44e9b 100644
--- a/src/GitReleaseManager.Cli/GitReleaseManager.Cli.csproj
+++ b/src/GitReleaseManager.Cli/GitReleaseManager.Cli.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <LangVersion>8.0</LangVersion>
         <OutputType>Exe</OutputType>
diff --git a/src/GitReleaseManager.Cli/Program.cs b/src/GitReleaseManager.Cli/Program.cs
index dc44e89c..c45e7051 100644
--- a/src/GitReleaseManager.Cli/Program.cs
+++ b/src/GitReleaseManager.Cli/Program.cs
@@ -110,6 +110,11 @@ private static void RegisterServices(BaseSubOptions options)
                 RegisterVcsProvider(vcsOptions, serviceCollection);
             }
 
+            if (options is CreateSubOptions createOptions && !string.IsNullOrEmpty(createOptions.OutputPath))
+            {
+                configuration.Create.AllowUpdateToPublishedRelease = false;
+            }
+
             serviceCollection = serviceCollection
                 .AddTransient((services) => new TemplateFactory(services.GetRequiredService<IFileSystem>(), services.GetRequiredService<Config>(), TemplateKind.Create));
 
@@ -197,21 +202,53 @@ private static Task<int> ExecuteCommand<TOptions>(TOptions options)
         private static void LogOptions(BaseSubOptions options)
             => Log.Debug("{@Options}", options);
 
+        private static void RegisterKeyedVcsProvider<TVcsImplementation>(object provider, IServiceCollection serviceCollection)
+            where TVcsImplementation : class, IVcsProvider
+        {
+            static IVcsProvider ResolveService(IServiceProvider service, object key) => service.GetRequiredKeyedService<IVcsProvider>(key);
+
+            provider ??= "null";
+
+            Log.Debug("Registering {Type} with Service Key {Key}", typeof(IVcsProvider), provider);
+
+            if (typeof(TVcsImplementation) != typeof(NullReleasesProvider))
+            {
+                serviceCollection.AddKeyedSingleton<IVcsProvider, TVcsImplementation>(provider);
+            }
+
+            serviceCollection
+                .AddKeyedTransient<IAssetsProvider>(provider, ResolveService)
+                .AddKeyedTransient<ICommitsProvider>(provider, ResolveService)
+                .AddKeyedTransient<IIssuesProvider>(provider, ResolveService)
+                .AddKeyedTransient<IMilestonesProvider>(provider, ResolveService)
+                .AddKeyedTransient<IReleasesProvider>(provider, ResolveService);
+        }
+
         private static void RegisterVcsProvider(BaseVcsOptions vcsOptions, IServiceCollection serviceCollection)
         {
             Log.Information("Using {Provider} as VCS Provider", vcsOptions.Provider);
-            if (vcsOptions.Provider == VcsProvider.GitLab)
+
+            serviceCollection.AddKeyedSingleton<IVcsProvider>("null", (service, _) => new NullReleasesProvider(vcsOptions.Provider.ToString(), service.GetRequiredService<ILogger>()));
+            RegisterKeyedVcsProvider<NullReleasesProvider>(null, serviceCollection);
+            RegisterKeyedVcsProvider<GitHubProvider>(VcsProvider.GitHub, serviceCollection);
+
+            serviceCollection
+                .AddSingleton<IGitLabClient>((_) => new GitLabClient("https://gitlab.com", vcsOptions.Token));
+
+            serviceCollection
+                .AddSingleton<IGitHubClient>((_) => new GitHubClient(new ProductHeaderValue("GitReleaseManager")) { Credentials = new Credentials(vcsOptions.Token) });
+
+            serviceCollection.AddTransient((service) => service.GetKeyedService<IVcsProvider>(vcsOptions.Provider) ?? service.GetRequiredKeyedService<IVcsProvider>("null"));
+
+            if (vcsOptions is CreateSubOptions createOptions && !string.IsNullOrEmpty(createOptions.OutputPath))
             {
-                serviceCollection
-                    .AddSingleton<IGitLabClient>((_) => new GitLabClient("https://gitlab.com", vcsOptions.Token))
-                    .AddSingleton<IVcsProvider, GitLabProvider>();
+                serviceCollection.AddSingleton<IReleasesProvider>((service) => new LocalProvider(
+                    service.GetRequiredService<IFileSystem>(),
+                    createOptions.OutputPath));
             }
             else
             {
-                // default to Github
-                serviceCollection
-                    .AddSingleton<IGitHubClient>((_) => new GitHubClient(new ProductHeaderValue("GitReleaseManager")) { Credentials = new Credentials(vcsOptions.Token) })
-                    .AddSingleton<IVcsProvider, GitHubProvider>();
+                serviceCollection.AddTransient((service) => service.GetKeyedService<IReleasesProvider>(vcsOptions.Provider) ?? service.GetRequiredKeyedService<IReleasesProvider>("null"));
             }
         }
     }
diff --git a/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs b/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
index 86306af7..eb885feb 100644
--- a/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
+++ b/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
@@ -47,6 +47,7 @@ public class VcsServiceTests
         private IReleaseNotesBuilder _releaseNotesBuilder;
         private ILogger _logger;
         private IVcsProvider _vcsProvider;
+        private IReleasesProvider _releaseProvider;
         private Config _configuration;
         private VcsService _vcsService;
 
@@ -110,8 +111,9 @@ public void Setup()
             _releaseNotesBuilder = Substitute.For<IReleaseNotesBuilder>();
             _logger = Substitute.For<ILogger>();
             _vcsProvider = Substitute.For<IVcsProvider>();
+            _releaseProvider = Substitute.For<IVcsProvider>();
             _configuration = new Config();
-            _vcsService = new VcsService(_vcsProvider, _logger, _releaseNotesBuilder, _releaseNotesExporter, _configuration);
+            _vcsService = new VcsService(_vcsProvider, _releaseProvider, _logger, _releaseNotesBuilder, _releaseNotesExporter, _configuration);
         }
 
         [Test]
@@ -121,12 +123,12 @@ public async Task Should_Add_Assets()
 
             var assetsCount = _assets.Count;
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(release);
 
             await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, _assets).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<ReleaseAsset>()).ConfigureAwait(false);
             await _vcsProvider.Received(assetsCount).UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
 
@@ -144,12 +146,12 @@ public async Task Should_Add_Assets_With_Deleting_Existing_Assets()
             var releaseAssetsCount = release.Assets.Count;
             var assetsCount = _assets.Count;
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(release);
 
             await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, _assets).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
             await _vcsProvider.Received(releaseAssetsCount).DeleteAssetAsync(OWNER, REPOSITORY, releaseAsset).ConfigureAwait(false);
             await _vcsProvider.Received(assetsCount).UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
 
@@ -166,13 +168,13 @@ public async Task Should_Throw_Exception_On_Adding_Assets_When_Asset_File_Not_Ex
 
             _assets[0] = assetFilePath;
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(release);
 
             var ex = await Should.ThrowAsync<FileNotFoundException>(() => _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, _assets)).ConfigureAwait(false);
             ex.Message.ShouldContain(assetFilePath);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<ReleaseAsset>()).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
         }
@@ -182,7 +184,7 @@ public async Task Should_Do_Nothing_On_Missing_Assets(IList<string> assets)
         {
             await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, assets).ConfigureAwait(false);
 
-            await _vcsProvider.DidNotReceive().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.DidNotReceive().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<ReleaseAsset>()).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().UploadAssetAsync(Arg.Any<Release>(), Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
         }
@@ -306,18 +308,18 @@ public async Task Should_Create_Release_From_Milestone()
             _releaseNotesBuilder.BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME)
                 .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult<Release>(null));
 
-            _vcsProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
+            _releaseProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
                 .Returns(Task.FromResult(release));
 
             var result = await _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, null).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
             await _releaseNotesBuilder.Received(1).BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
-            await _vcsProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _releaseProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
                 o.Body == RELEASE_NOTES &&
                 o.Name == MILESTONE_TITLE &&
                 o.TagName == MILESTONE_TITLE)).ConfigureAwait(false);
@@ -336,10 +338,10 @@ public async Task Should_Create_Release_From_Milestone_With_Assets()
             _releaseNotesBuilder.BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME)
                 .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult<Release>(null));
 
-            _vcsProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
+            _releaseProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
                 .Returns(Task.FromResult(release));
 
             var result = await _vcsService.CreateReleaseFromMilestoneAsync(
@@ -355,8 +357,8 @@ public async Task Should_Create_Release_From_Milestone_With_Assets()
             result.ShouldBeSameAs(release);
 
             await _releaseNotesBuilder.Received(1).BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
-            await _vcsProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _releaseProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
                 o.Body == RELEASE_NOTES &&
                 o.Name == MILESTONE_TITLE &&
                 o.TagName == MILESTONE_TITLE)).ConfigureAwait(false);
@@ -373,18 +375,18 @@ public async Task Should_Create_Release_From_Milestone_Using_Template_File()
             _releaseNotesBuilder.BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesTemplate)
                 .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult<Release>(null));
 
-            _vcsProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
+            _releaseProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
                 .Returns(Task.FromResult(release));
 
             var result = await _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, _releaseNotesTemplateFilePath).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
             await _releaseNotesBuilder.Received(1).BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesTemplate).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
-            await _vcsProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _releaseProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
                 o.Body == RELEASE_NOTES &&
                 o.Name == MILESTONE_TITLE &&
                 o.TagName == MILESTONE_TITLE)).ConfigureAwait(false);
@@ -397,7 +399,7 @@ await _vcsProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Rele
         [Ignore("This may be handled by the TemplateLoader instead")]
         public async Task Should_Throw_Exception_On_Creating_Release_With_Empty_Template()
         {
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
             await Should.ThrowAsync<ArgumentException>(() => _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, _releaseNotesEmptyTemplateFilePath)).ConfigureAwait(false);
@@ -409,7 +411,7 @@ public async Task Should_Throw_Exception_On_Creating_Release_With_Empty_Template
         [Ignore("This may be handled by the TemplateLoader instead")]
         public async Task Should_Throw_Exception_On_Creating_Release_With_Invalid_Template_File_Path()
         {
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
             var fileName = "InvalidReleaseNotesTemplate.txt";
@@ -434,18 +436,18 @@ public async Task Should_Update_Published_Release_On_Creating_Release_From_Miles
             _releaseNotesBuilder.BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME)
                 .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release)
+            _releaseProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release)
                 .Returns(Task.FromResult(new Release()));
 
             var result = await _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, null).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
             await _releaseNotesBuilder.Received(1).BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
-            await _vcsProvider.Received(1).UpdateReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _releaseProvider.Received(1).UpdateReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
 
             _logger.Received(1).Warning(Arg.Any<string>(), MILESTONE_TITLE);
             _logger.Received(1).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
@@ -462,14 +464,14 @@ public async Task Should_Throw_Exception_While_Updating_Published_Release_On_Cre
             _releaseNotesBuilder.BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME)
                 .Returns(Task.FromResult(RELEASE_NOTES));
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult(release));
 
             var ex = await Should.ThrowAsync<InvalidOperationException>(() => _vcsService.CreateReleaseFromMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, MILESTONE_TITLE, null, null, false, null)).ConfigureAwait(false);
             ex.Message.ShouldBe($"Release with tag '{MILESTONE_TITLE}' not in draft state, so not updating");
 
             await _releaseNotesBuilder.Received(1).BuildReleaseNotesAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ReleaseTemplates.DEFAULT_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
         }
 
         [Test]
@@ -477,17 +479,17 @@ public async Task Should_Create_Release_From_InputFile()
         {
             var release = new Release();
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult<Release>(null));
 
-            _vcsProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
+            _releaseProvider.CreateReleaseAsync(OWNER, REPOSITORY, Arg.Any<Release>())
                 .Returns(Task.FromResult(release));
 
             var result = await _vcsService.CreateReleaseFromInputFileAsync(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesFilePath, null, null, false).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
-            await _vcsProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _releaseProvider.Received(1).CreateReleaseAsync(OWNER, REPOSITORY, Arg.Is<Release>(o =>
                 o.Body == RELEASE_NOTES &&
                 o.Name == MILESTONE_TITLE &&
                 o.TagName == MILESTONE_TITLE)).ConfigureAwait(false);
@@ -505,17 +507,17 @@ public async Task Should_Update_Published_Release_On_Creating_Release_From_Input
 
             _configuration.Create.AllowUpdateToPublishedRelease = updatePublishedRelease;
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release)
+            _releaseProvider.UpdateReleaseAsync(OWNER, REPOSITORY, release)
                 .Returns(Task.FromResult(new Release()));
 
             var result = await _vcsService.CreateReleaseFromInputFileAsync(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesFilePath, null, null, false).ConfigureAwait(false);
             result.ShouldBeSameAs(release);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
-            await _vcsProvider.Received(1).UpdateReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _releaseProvider.Received(1).UpdateReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
 
             _logger.Received(1).Warning(Arg.Any<string>(), MILESTONE_TITLE);
             _logger.Received(1).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
@@ -529,13 +531,13 @@ public async Task Should_Throw_Exception_While_Updating_Published_Release_On_Cre
 
             _configuration.Create.AllowUpdateToPublishedRelease = false;
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE)
                 .Returns(Task.FromResult(release));
 
             var ex = await Should.ThrowAsync<InvalidOperationException>(() => _vcsService.CreateReleaseFromInputFileAsync(OWNER, REPOSITORY, MILESTONE_TITLE, _releaseNotesFilePath, null, null, false)).ConfigureAwait(false);
             ex.Message.ShouldBe($"Release with tag '{MILESTONE_TITLE}' not in draft state, so not updating");
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
         }
 
         [Test]
@@ -558,16 +560,16 @@ public async Task Should_Delete_Draft_Release()
                 Draft = true,
             };
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.DeleteReleaseAsync(OWNER, REPOSITORY, release)
+            _releaseProvider.DeleteReleaseAsync(OWNER, REPOSITORY, release)
                 .Returns(Task.CompletedTask);
 
             await _vcsService.DiscardReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).DeleteReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.Received(1).DeleteReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
         }
 
         [Test]
@@ -575,26 +577,26 @@ public async Task Should_Not_Delete_Published_Release()
         {
             var release = new Release { Id = 1 };
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
             await _vcsService.DiscardReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.DidNotReceive().DeleteReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
             _logger.Received(1).Warning(Arg.Any<string>(), TAG_NAME);
         }
 
         [Test]
         public async Task Should_Log_An_Warning_On_Deleting_Release_For_Non_Existing_Tag()
         {
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
             await _vcsService.DiscardReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceiveWithAnyArgs().DeleteReleaseAsync(OWNER, REPOSITORY, default).ConfigureAwait(false);
+            await _releaseProvider.Received().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.DidNotReceiveWithAnyArgs().DeleteReleaseAsync(OWNER, REPOSITORY, default).ConfigureAwait(false);
             _logger.Received(1).Warning(UNABLE_TO_FOUND_RELEASE_MESSAGE, TAG_NAME, OWNER, REPOSITORY);
         }
 
@@ -603,16 +605,16 @@ public async Task Should_Publish_Release()
         {
             var release = new Release { Id = 1 };
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release)
+            _releaseProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release)
                 .Returns(Task.CompletedTask);
 
             await _vcsService.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.Received(1).PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release).ConfigureAwait(false);
             _logger.Received(1).Verbose(Arg.Any<string>(), TAG_NAME, OWNER, REPOSITORY);
             _logger.Received(1).Debug(Arg.Any<string>(), Arg.Any<Release>());
         }
@@ -620,13 +622,13 @@ public async Task Should_Publish_Release()
         [Test]
         public async Task Should_Log_An_Warning_On_Publishing_Release_For_Non_Existing_Tag()
         {
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
             await _vcsService.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
-            await _vcsProvider.Received().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceiveWithAnyArgs().PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, default).ConfigureAwait(false);
+            await _releaseProvider.Received().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.DidNotReceiveWithAnyArgs().PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, default).ConfigureAwait(false);
             _logger.Received(1).Warning(Arg.Any<string>(), TAG_NAME, OWNER, REPOSITORY);
         }
 
@@ -636,7 +638,7 @@ public async Task Should_Get_Release_Notes()
             var releases = Enumerable.Empty<Release>();
             var releaseNotes = "Release Notes";
 
-            _vcsProvider.GetReleasesAsync(OWNER, REPOSITORY, SKIP_PRERELEASES)
+            _releaseProvider.GetReleasesAsync(OWNER, REPOSITORY, SKIP_PRERELEASES)
                 .Returns(Task.FromResult(releases));
 
             _releaseNotesExporter.ExportReleaseNotes(Arg.Any<IEnumerable<Release>>())
@@ -645,8 +647,8 @@ public async Task Should_Get_Release_Notes()
             var result = await _vcsService.ExportReleasesAsync(OWNER, REPOSITORY, null, SKIP_PRERELEASES).ConfigureAwait(false);
             result.ShouldBeSameAs(releaseNotes);
 
-            await _vcsProvider.DidNotReceive().GetReleaseAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>()).ConfigureAwait(false);
-            await _vcsProvider.Received(1).GetReleasesAsync(OWNER, REPOSITORY, SKIP_PRERELEASES).ConfigureAwait(false);
+            await _releaseProvider.DidNotReceive().GetReleaseAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>()).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleasesAsync(OWNER, REPOSITORY, SKIP_PRERELEASES).ConfigureAwait(false);
             _logger.Received(1).Verbose(Arg.Any<string>(), OWNER, REPOSITORY);
             _releaseNotesExporter.Received(1).ExportReleaseNotes(Arg.Any<IEnumerable<Release>>());
         }
@@ -656,7 +658,7 @@ public async Task Should_Get_Release_Notes_For_Tag()
         {
             var release = new Release();
 
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
             _releaseNotesExporter.ExportReleaseNotes(Arg.Any<IEnumerable<Release>>())
@@ -665,8 +667,8 @@ public async Task Should_Get_Release_Notes_For_Tag()
             var result = await _vcsService.ExportReleasesAsync(OWNER, REPOSITORY, TAG_NAME, SKIP_PRERELEASES).ConfigureAwait(false);
             result.ShouldBeSameAs(RELEASE_NOTES);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().GetReleasesAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<bool>()).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.DidNotReceive().GetReleasesAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<bool>()).ConfigureAwait(false);
             _logger.Received(1).Verbose(Arg.Any<string>(), OWNER, REPOSITORY, TAG_NAME);
             _releaseNotesExporter.Received(1).ExportReleaseNotes(Arg.Any<IEnumerable<Release>>());
         }
@@ -674,7 +676,7 @@ public async Task Should_Get_Release_Notes_For_Tag()
         [Test]
         public async Task Should_Get_Default_Release_Notes_For_Non_Existent_Tag()
         {
-            _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
+            _releaseProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromException<Release>(_notFoundException));
 
             _releaseNotesExporter.ExportReleaseNotes(Arg.Any<IEnumerable<Release>>())
@@ -683,7 +685,7 @@ public async Task Should_Get_Default_Release_Notes_For_Non_Existent_Tag()
             var result = await _vcsService.ExportReleasesAsync(OWNER, REPOSITORY, TAG_NAME, SKIP_PRERELEASES).ConfigureAwait(false);
             result.ShouldBeSameAs(RELEASE_NOTES);
 
-            await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
+            await _releaseProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
             _logger.Received(1).Warning(UNABLE_TO_FOUND_RELEASE_MESSAGE, TAG_NAME, OWNER, REPOSITORY);
             _releaseNotesExporter.Received(1).ExportReleaseNotes(Arg.Any<IEnumerable<Release>>());
         }
diff --git a/src/GitReleaseManager.Core/GitReleaseManager.Core.csproj b/src/GitReleaseManager.Core/GitReleaseManager.Core.csproj
index bca953b3..6caf0ced 100644
--- a/src/GitReleaseManager.Core/GitReleaseManager.Core.csproj
+++ b/src/GitReleaseManager.Core/GitReleaseManager.Core.csproj
@@ -4,6 +4,8 @@
     <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v15.0\TextTemplating\Microsoft.TextTemplating.targets" Condition="Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v15.0\TextTemplating\Microsoft.TextTemplating.targets')" />
     <PropertyGroup>
         <LangVersion>8.0</LangVersion>
+        <!-- Uncomment the below property when langversion is updated to 9.0 or higher (optimally 11.0). -->
+        <!--<DefineConstants>$(DefineConstants);USE_GENERATED_REGEX</DefineConstants>-->
         <TargetFrameworks>net6.0;net7.0</TargetFrameworks>
         <Title>GitReleaseManager.Core</Title>
         <Description>Create release notes in markdown given a milestone</Description>
diff --git a/src/GitReleaseManager.Core/Helpers/FileSystem.cs b/src/GitReleaseManager.Core/Helpers/FileSystem.cs
index c6f53827..996fc5c5 100644
--- a/src/GitReleaseManager.Core/Helpers/FileSystem.cs
+++ b/src/GitReleaseManager.Core/Helpers/FileSystem.cs
@@ -19,6 +19,21 @@ public void Copy(string @source, string destination, bool overwrite)
             File.Copy(@source, destination, overwrite);
         }
 
+        public void CreateDirectory(string path)
+        {
+            // It is safe to call CreateDirectory, if the directory
+            // already exists these are no-op.
+
+            if (string.IsNullOrEmpty(path))
+            {
+                Directory.CreateDirectory(Environment.CurrentDirectory);
+            }
+            else
+            {
+                Directory.CreateDirectory(path);
+            }
+        }
+
         public void Move(string @source, string destination)
         {
             File.Move(@source, destination);
@@ -59,9 +74,19 @@ public IEnumerable<string> DirectoryGetFiles(string directory, string searchPatt
             return Directory.GetFiles(directory, searchPattern, searchOption);
         }
 
+        public Stream OpenRead(string path)
+        {
+            return File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
+        }
+
         public Stream OpenWrite(string path)
         {
-            return File.OpenWrite(path);
+            return OpenWrite(path, overwrite: false);
+        }
+
+        public Stream OpenWrite(string path, bool overwrite)
+        {
+            return File.Open(path, overwrite ? FileMode.Create : FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read);
         }
     }
 }
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Helpers/IFileSystem.cs b/src/GitReleaseManager.Core/Helpers/IFileSystem.cs
index eb85b7fc..12fdb938 100644
--- a/src/GitReleaseManager.Core/Helpers/IFileSystem.cs
+++ b/src/GitReleaseManager.Core/Helpers/IFileSystem.cs
@@ -7,6 +7,8 @@ public interface IFileSystem
     {
         void Copy(string source, string destination, bool overwrite);
 
+        void CreateDirectory(string path);
+
         void Move(string source, string destination);
 
         bool Exists(string file);
@@ -21,6 +23,9 @@ public interface IFileSystem
 
         IEnumerable<string> DirectoryGetFiles(string directory, string searchPattern, SearchOption searchOption);
 
+        Stream OpenRead(string path);
+
         Stream OpenWrite(string path);
+        Stream OpenWrite(string path, bool overwrite);
     }
 }
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Options/CreateSubOptions.cs b/src/GitReleaseManager.Core/Options/CreateSubOptions.cs
index 34d0d7c5..85721e9d 100644
--- a/src/GitReleaseManager.Core/Options/CreateSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/CreateSubOptions.cs
@@ -29,5 +29,8 @@ public class CreateSubOptions : BaseVcsOptions
 
         [Option("allowEmpty", Required = false, HelpText = "Allow the creation of an empty set of release notes. In this mode, milestone and input file path will be ignored.")]
         public bool AllowEmpty { get; set; }
+
+        [Option("output", Required = false, HelpText = "The path to a local file location where the release notes will be created, instead of creating in remotely on the specified provider.")]
+        public string OutputPath { get; set; }
     }
 }
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Provider/GitHubProvider.cs b/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
index 68d19c4a..f14be17d 100644
--- a/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
+++ b/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
@@ -35,6 +35,8 @@ public GitHubProvider(IGitHubClient gitHubClient, IMapper mapper)
             _mapper = mapper;
         }
 
+        public string Name => "GitHub";
+
         public Task DeleteAssetAsync(string owner, string repository, ReleaseAsset asset)
         {
             return ExecuteAsync(async () =>
diff --git a/src/GitReleaseManager.Core/Provider/GitLabProvider.cs b/src/GitReleaseManager.Core/Provider/GitLabProvider.cs
index c2371c72..0349bf70 100644
--- a/src/GitReleaseManager.Core/Provider/GitLabProvider.cs
+++ b/src/GitReleaseManager.Core/Provider/GitLabProvider.cs
@@ -43,6 +43,8 @@ public GitLabProvider(IGitLabClient gitLabClient, IMapper mapper, ILogger logger
             _logger = logger;
         }
 
+        public string Name => "GitLab";
+
         public Task DeleteAssetAsync(string owner, string repository, ReleaseAsset asset)
         {
             // TODO: This is a discussion here:
diff --git a/src/GitReleaseManager.Core/Provider/IAssetsProvider.cs b/src/GitReleaseManager.Core/Provider/IAssetsProvider.cs
new file mode 100644
index 00000000..25bacc39
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/IAssetsProvider.cs
@@ -0,0 +1,14 @@
+namespace GitReleaseManager.Core.Provider
+{
+    using System.Threading.Tasks;
+    using GitReleaseManager.Core.Model;
+
+    public interface IAssetsProvider
+    {
+        bool SupportsAssets { get; }
+
+        Task DeleteAssetAsync(string owner, string repository, ReleaseAsset asset);
+
+        Task UploadAssetAsync(Release release, ReleaseAssetUpload releaseAssetUpload);
+    }
+}
diff --git a/src/GitReleaseManager.Core/Provider/ICommitsProvider.cs b/src/GitReleaseManager.Core/Provider/ICommitsProvider.cs
new file mode 100644
index 00000000..42a2cd57
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/ICommitsProvider.cs
@@ -0,0 +1,13 @@
+namespace GitReleaseManager.Core.Provider
+{
+    using System.Threading.Tasks;
+
+    public interface ICommitsProvider
+    {
+        bool SupportsCommits { get; }
+
+        Task<int> GetCommitsCountAsync(string owner, string repository, string baseCommit, string headCommit);
+
+        string GetCommitsUrl(string owner, string repository, string head, string baseCommit = null);
+    }
+}
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Provider/IIssuesProvider.cs b/src/GitReleaseManager.Core/Provider/IIssuesProvider.cs
new file mode 100644
index 00000000..9d91cccd
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/IIssuesProvider.cs
@@ -0,0 +1,20 @@
+namespace GitReleaseManager.Core.Provider
+{
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using GitReleaseManager.Core.Model;
+
+    public interface IIssuesProvider
+    {
+        bool SupportIssues { get; }
+        bool SupportIssueComments { get; }
+
+        Task CreateIssueCommentAsync(string owner, string repository, Issue issue, string comment);
+
+        Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, Issue issue);
+
+        Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, Milestone milstone, ItemStateFilter itemStateFilter = ItemStateFilter.All);
+
+        string GetIssueType(Issue issue);
+    }
+}
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Provider/ILabelsProvider.cs b/src/GitReleaseManager.Core/Provider/ILabelsProvider.cs
new file mode 100644
index 00000000..b7c00a59
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/ILabelsProvider.cs
@@ -0,0 +1,17 @@
+namespace GitReleaseManager.Core.Provider
+{
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using GitReleaseManager.Core.Model;
+
+    public interface ILabelsProvider
+    {
+        bool SupportsLabels { get; }
+
+        Task CreateLabelAsync(string owner, string repository, Label label);
+
+        Task DeleteLabelAsync(string owner, string repository, Label label);
+
+        Task<IEnumerable<Label>> GetLabelsAsync(string owner, string repository);
+    }
+}
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Provider/IMilestonesProvider.cs b/src/GitReleaseManager.Core/Provider/IMilestonesProvider.cs
new file mode 100644
index 00000000..de569249
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/IMilestonesProvider.cs
@@ -0,0 +1,19 @@
+namespace GitReleaseManager.Core.Provider
+{
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using GitReleaseManager.Core.Model;
+
+    public interface IMilestonesProvider
+    {
+        bool SupportMilestones { get; }
+
+        Task<Milestone> GetMilestoneAsync(string owner, string repository, string milestoneTitle, ItemStateFilter itemStateFilter = ItemStateFilter.All);
+
+        Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repository, ItemStateFilter itemStateFilter = ItemStateFilter.All);
+
+        Task SetMilestoneStateAsync(string owner, string repository, Milestone milestone, ItemState itemState);
+
+        string GetMilestoneQueryString();
+    }
+}
diff --git a/src/GitReleaseManager.Core/Provider/IRateLimitProvider.cs b/src/GitReleaseManager.Core/Provider/IRateLimitProvider.cs
new file mode 100644
index 00000000..2900ec14
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/IRateLimitProvider.cs
@@ -0,0 +1,9 @@
+namespace GitReleaseManager.Core.Provider
+{
+    using GitReleaseManager.Core.Model;
+
+    public interface IRateLimitProvider
+    {
+        RateLimit GetRateLimit();
+    }
+}
diff --git a/src/GitReleaseManager.Core/Provider/IReleasesProvider.cs b/src/GitReleaseManager.Core/Provider/IReleasesProvider.cs
new file mode 100644
index 00000000..e8ca3171
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/IReleasesProvider.cs
@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Model;
+
+namespace GitReleaseManager.Core.Provider
+{
+    public interface IReleasesProvider
+    {
+        bool SupportReleases { get; }
+
+        Task<Release> CreateReleaseAsync(string owner, string repository, Release release);
+
+        Task DeleteReleaseAsync(string owner, string repository, Release release);
+
+        Task<Release> GetReleaseAsync(string owner, string repository, string tagName);
+
+        Task<IEnumerable<Release>> GetReleasesAsync(string owner, string repository, bool skipPrereleases);
+
+        Task PublishReleaseAsync(string owner, string repository, string tagName, Release release);
+
+        Task UpdateReleaseAsync(string owner, string repository, Release release);
+    }
+}
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Provider/IVcsProvider.cs b/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
index a7bf82a8..7984d4a2 100644
--- a/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
+++ b/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
@@ -4,50 +4,7 @@
 
 namespace GitReleaseManager.Core.Provider
 {
-    public interface IVcsProvider
+    public interface IVcsProvider : IAssetsProvider, ICommitsProvider, IIssuesProvider, IMilestonesProvider, IRateLimitProvider, IReleasesProvider
     {
-        Task DeleteAssetAsync(string owner, string repository, ReleaseAsset asset);
-
-        Task UploadAssetAsync(Release release, ReleaseAssetUpload releaseAssetUpload);
-
-        Task<int> GetCommitsCountAsync(string owner, string repository, string @base, string head);
-
-        string GetCommitsUrl(string owner, string repository, string head, string @base = null);
-
-        Task CreateIssueCommentAsync(string owner, string repository, Issue issue, string comment);
-
-        Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, Milestone milstone, ItemStateFilter itemStateFilter = ItemStateFilter.All);
-
-        Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, Issue issue);
-
-        Task CreateLabelAsync(string owner, string repository, Label label);
-
-        Task DeleteLabelAsync(string owner, string repository, Label label);
-
-        Task<IEnumerable<Label>> GetLabelsAsync(string owner, string repository);
-
-        Task<Milestone> GetMilestoneAsync(string owner, string repository, string milestoneTitle, ItemStateFilter itemStateFilter = ItemStateFilter.All);
-
-        Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repository, ItemStateFilter itemStateFilter = ItemStateFilter.All);
-
-        Task SetMilestoneStateAsync(string owner, string repository, Milestone milestone, ItemState itemState);
-
-        Task<Release> CreateReleaseAsync(string owner, string repository, Release release);
-
-        Task DeleteReleaseAsync(string owner, string repository, Release release);
-
-        Task<Release> GetReleaseAsync(string owner, string repository, string tagName);
-
-        Task<IEnumerable<Release>> GetReleasesAsync(string owner, string repository, bool skipPrereleases);
-
-        Task PublishReleaseAsync(string owner, string repository, string tagName, Release release);
-
-        Task UpdateReleaseAsync(string owner, string repository, Release release);
-
-        RateLimit GetRateLimit();
-
-        string GetMilestoneQueryString();
-
-        string GetIssueType(Issue issue);
     }
 }
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Provider/LocalProvider.cs b/src/GitReleaseManager.Core/Provider/LocalProvider.cs
new file mode 100644
index 00000000..7c6ff8db
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/LocalProvider.cs
@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Model;
+
+namespace GitReleaseManager.Core.Provider
+{
+    public partial class LocalProvider : IReleasesProvider
+    {
+        private const string NAME_AND_TAG_REGEX = @"^#+\s*(?<NAME>[^\(\r\n]+)(?:\s*\((?<TAG_NAME>[^\)\r\n]+))?";
+        private readonly IFileSystem _fileSystem;
+        private readonly string _outputPath;
+
+        public LocalProvider(IFileSystem fileSystem, string outputPath)
+        {
+            _fileSystem = fileSystem;
+            _outputPath = outputPath;
+        }
+
+        public bool SupportReleases => true;
+
+        public async Task<Release> CreateReleaseAsync(string owner, string repository, Release release)
+        {
+            ArgumentNullException.ThrowIfNull(release);
+
+            string directory = Path.GetDirectoryName(_outputPath) ?? Environment.CurrentDirectory;
+            _fileSystem.CreateDirectory(directory);
+
+#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
+            await using (var stream = _fileSystem.OpenWrite(_outputPath, overwrite: true))
+            await using (StreamWriter writer = new StreamWriter(stream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true)))
+#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
+            {
+                await writer.WriteAsync("# ").ConfigureAwait(false);
+                await writer.WriteAsync(release.Name ?? release.TagName).ConfigureAwait(false);
+
+                if (release.Name != null && release.Name != release.TagName)
+                {
+                    await writer.WriteAsync(" (").ConfigureAwait(false);
+                    await writer.WriteAsync(release.TagName).ConfigureAwait(false);
+                    await writer.WriteLineAsync(")").ConfigureAwait(false);
+                }
+                else
+                {
+                    await writer.WriteLineAsync().ConfigureAwait(false);
+                }
+
+                await writer.WriteLineAsync().ConfigureAwait(false);
+
+                await writer.WriteLineAsync(release.Body).ConfigureAwait(false);
+
+                await writer.FlushAsync().ConfigureAwait(false);
+            }
+
+            release.CreatedAt = DateTime.UtcNow;
+            release.HtmlUrl = _outputPath;
+
+            return release;
+        }
+
+        public Task DeleteReleaseAsync(string owner, string repository, Release release)
+        {
+            _fileSystem.Delete(_outputPath);
+
+            return Task.CompletedTask;
+        }
+
+        public async Task<Release> GetReleaseAsync(string owner, string repository, string tagName)
+        {
+            Release release = new Release();
+            await using (var stream = _fileSystem.OpenRead(_outputPath))
+            using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
+            {
+                var line = await reader.ReadLineAsync();
+                var titleMatch = NameAndTagNameRegex().Match(line);
+
+                if (titleMatch.Success)
+                {
+                    release.Name = titleMatch.Groups["NAME"].Value;
+
+                    if (titleMatch.Groups["TAG_NAME"].Success)
+                    {
+                        release.TagName = titleMatch.Groups["TAG_NAME"].Value;
+                    }
+                }
+
+                line = await reader.ReadLineAsync();
+
+                while (string.IsNullOrEmpty(line))
+                {
+                    line = await reader.ReadLineAsync();
+                }
+
+                var body = new StringBuilder(line).AppendLine();
+                var block = await reader.ReadToEndAsync();
+
+                if (block.Length > 0)
+                {
+                    body.Append(block);
+                }
+
+                if (release.Name.Length == 0 && body.Length == 0)
+                {
+                    return null;
+                }
+                else
+                {
+                    release.Body = body.ToString();
+                    release.Draft = true;
+                    release.HtmlUrl = _outputPath;
+                    release.Prerelease = Regex.IsMatch(@"^\d\.+-[a-z]", release.Name, RegexOptions.IgnoreCase | RegexOptions.Compiled);
+                }
+            }
+
+            return release;
+        }
+
+        public Task<IEnumerable<Release>> GetReleasesAsync(string owner, string repository, bool skipPrereleases)
+        {
+            return Task.FromResult<IEnumerable<Release>>(null);
+        }
+
+        public Task PublishReleaseAsync(string owner, string repository, string tagName, Release release)
+        {
+            // No-op
+            return Task.CompletedTask;
+        }
+
+        public async Task UpdateReleaseAsync(string owner, string repository, Release release)
+        {
+            await DeleteReleaseAsync(owner, repository, release).ConfigureAwait(false);
+            await CreateReleaseAsync(owner, repository, release).ConfigureAwait(false);
+        }
+
+#if NET7_0_OR_GREATER && USE_GENERATED_REGEX
+        [GeneratedRegex(NAME_AND_TAG_REGEX, RegexOptions.IgnoreCase)]
+        private static partial Regex NameAndTagNameRegex();
+#else
+        private static Regex NameAndTagNameRegex()
+        {
+            return new Regex(NAME_AND_TAG_REGEX, RegexOptions.IgnoreCase | RegexOptions.Compiled);
+        }
+#endif
+    }
+}
diff --git a/src/GitReleaseManager.Core/Provider/NullReleasesProvider.cs b/src/GitReleaseManager.Core/Provider/NullReleasesProvider.cs
new file mode 100644
index 00000000..bd353ebf
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/NullReleasesProvider.cs
@@ -0,0 +1,167 @@
+namespace GitReleaseManager.Core.Provider
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using GitReleaseManager.Core.Model;
+    using Serilog;
+
+    public class NullReleasesProvider : IVcsProvider
+    {
+        private readonly string _vcsProvider;
+        private readonly ILogger _logger;
+
+        public NullReleasesProvider(string vcsProvider, ILogger logger)
+        {
+            _vcsProvider = vcsProvider;
+            _logger = logger;
+        }
+
+        public bool SupportsAssets => false;
+
+        public bool SupportsCommits => false;
+
+        public bool SupportIssues => false;
+
+        public bool SupportIssueComments => false;
+
+        public bool SupportMilestones => false;
+
+        public bool SupportReleases => false;
+
+        public Task CreateIssueCommentAsync(string owner, string repository, Issue issue, string comment)
+        {
+            _logger.Warning("The provider '{Provider}' do not support creating issue comments!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+
+        public Task CreateLabelAsync(string owner, string repository, Label label)
+        {
+            _logger.Warning("The provider '{Provider}' do not support creating labels!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+
+        public Task<Release> CreateReleaseAsync(string owner, string repository, Release release)
+        {
+            _logger.Warning("The provider '{Provider}' do not support creating releases!", _vcsProvider);
+            return Task.FromResult<Release>(null);
+        }
+
+        public Task DeleteAssetAsync(string owner, string repository, ReleaseAsset asset)
+        {
+            _logger.Warning("The provider '{Provider}' do not support deleting assets!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+
+        public Task DeleteLabelAsync(string owner, string repository, Label label)
+        {
+            _logger.Warning("The provider '{Provider}' do not support deleting labels!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+
+        public Task DeleteReleaseAsync(string owner, string repository, Release release)
+        {
+            _logger.Warning("The provider '{Provider}' do not support releases labels!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+
+        public Task<int> GetCommitsCountAsync(string owner, string repository, string @base, string head)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring commits!", _vcsProvider);
+            return Task.FromResult(0);
+        }
+
+        public string GetCommitsUrl(string owner, string repository, string head, string @base = null)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring commits!", _vcsProvider);
+            return null;
+        }
+
+        public Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, Issue issue)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring issue comments!", _vcsProvider);
+            return Task.FromResult(Enumerable.Empty<IssueComment>());
+        }
+
+        public Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, Milestone milstone, ItemStateFilter itemStateFilter = ItemStateFilter.All)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring issues!", _vcsProvider);
+            return Task.FromResult(Enumerable.Empty<Issue>());
+        }
+
+        public string GetIssueType(Issue issue)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring issues!", _vcsProvider);
+            return null;
+        }
+
+        public Task<IEnumerable<Label>> GetLabelsAsync(string owner, string repository)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring labels!", _vcsProvider);
+            return Task.FromResult(Enumerable.Empty<Label>());
+        }
+
+        public Task<Milestone> GetMilestoneAsync(string owner, string repository, string milestoneTitle, ItemStateFilter itemStateFilter = ItemStateFilter.All)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring milestones!", _vcsProvider);
+            return Task.FromResult<Milestone>(null);
+        }
+
+        public string GetMilestoneQueryString()
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring milestones!", _vcsProvider);
+            return null;
+        }
+
+        public Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repository, ItemStateFilter itemStateFilter = ItemStateFilter.All)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring milestones!", _vcsProvider);
+            return Task.FromResult(Enumerable.Empty<Milestone>());
+        }
+
+        public RateLimit GetRateLimit()
+        {
+            return new RateLimit
+            {
+                Limit = int.MaxValue,
+                Remaining = int.MaxValue,
+            };
+        }
+
+        public Task<Release> GetReleaseAsync(string owner, string repository, string tagName)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring releases!", _vcsProvider);
+            return Task.FromResult<Release>(null);
+        }
+
+        public Task<IEnumerable<Release>> GetReleasesAsync(string owner, string repository, bool skipPrereleases)
+        {
+            _logger.Warning("The provider '{Provider}' do not support acquiring releases!", _vcsProvider);
+            return Task.FromResult(Enumerable.Empty<Release>());
+        }
+
+        public Task PublishReleaseAsync(string owner, string repository, string tagName, Release release)
+        {
+            _logger.Warning("The provider '{Provider}' do not support publishing releases!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+
+        public Task SetMilestoneStateAsync(string owner, string repository, Milestone milestone, ItemState itemState)
+        {
+            _logger.Warning("The provider '{Provider} do not support updating milestones!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+
+        public Task UpdateReleaseAsync(string owner, string repository, Release release)
+        {
+            _logger.Warning("The provider '{Provider}' do not support updating releases!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+
+        public Task UploadAssetAsync(Release release, ReleaseAssetUpload releaseAssetUpload)
+        {
+            _logger.Warning("The provider '{Provider}' do not support uploading assets!", _vcsProvider);
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/src/GitReleaseManager.Core/VcsService.cs b/src/GitReleaseManager.Core/VcsService.cs
index 601a20b3..d6cb5501 100644
--- a/src/GitReleaseManager.Core/VcsService.cs
+++ b/src/GitReleaseManager.Core/VcsService.cs
@@ -23,15 +23,37 @@ public class VcsService : IVcsService
         private const string UNABLE_TO_FOUND_MILESTONE_MESSAGE = "Unable to find a {State} milestone with title '{Title}' on '{Owner}/{Repository}'";
         private const string UNABLE_TO_FOUND_RELEASE_MESSAGE = "Unable to find a release with tag '{TagName}' on '{Owner}/{Repository}'";
 
-        private readonly IVcsProvider _vcsProvider;
+        private readonly IAssetsProvider _assetsProvider;
+        private readonly ICommitsProvider _commitsProvider;
+        private readonly IIssuesProvider _issuesProvider;
+        private readonly ILabelsProvider _labelsProvider;
+        private readonly IMilestonesProvider _milestonesProvider;
+        private readonly IRateLimitProvider _rateLimitProvider;
+        private readonly IReleasesProvider _releaseProvider;
         private readonly ILogger _logger;
         private readonly IReleaseNotesBuilder _releaseNotesBuilder;
         private readonly IReleaseNotesExporter _releaseNotesExporter;
         private readonly Config _configuration;
 
-        public VcsService(IVcsProvider vcsProvider, ILogger logger, IReleaseNotesBuilder releaseNotesBuilder, IReleaseNotesExporter releaseNotesExporter, Config configuration)
+        public VcsService(
+            IAssetsProvider assetsProvider,
+            ICommitsProvider commitsProvider,
+            IIssuesProvider issuesProvider,
+            ILabelsProvider labelsProvider,
+            IMilestonesProvider milestonesProvider,
+            IRateLimitProvider rateLimitProvider,
+            IReleasesProvider releaseProvider,
+            ILogger logger,
+            IReleaseNotesBuilder releaseNotesBuilder,
+            IReleaseNotesExporter releaseNotesExporter,
+            Config configuration)
         {
-            _vcsProvider = vcsProvider;
+            _assetsProvider = assetsProvider;
+            _commitsProvider = commitsProvider;
+            _issuesProvider = issuesProvider;
+            _labelsProvider = labelsProvider;
+            _milestonesProvider = milestonesProvider;
+            _releaseProvider = releaseProvider;
             _logger = logger;
             _releaseNotesBuilder = releaseNotesBuilder;
             _releaseNotesExporter = releaseNotesExporter;
@@ -75,16 +97,16 @@ private async Task<Release> CreateReleaseAsync(string owner, string repository,
         {
             Release release;
 
-            release = await _vcsProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
+            release = await _releaseProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
 
             if (release == null)
             {
                 release = CreateReleaseModel(name, tagName, body, prerelease, targetCommitish);
 
-                _logger.Verbose("Creating new release with tag '{TagName}' on '{Owner}/{Repository}'", tagName, owner, repository);
+                _logger.Verbose("Creating new release with tag '{TagName}' on '{Owner}/{Repository}", tagName, owner, repository);
                 _logger.Debug("{@Release}", release);
 
-                release = await _vcsProvider.CreateReleaseAsync(owner, repository, release).ConfigureAwait(false);
+                release = await _releaseProvider.CreateReleaseAsync(owner, repository, release).ConfigureAwait(false);
             }
             else
             {
@@ -99,7 +121,7 @@ private async Task<Release> CreateReleaseAsync(string owner, string repository,
                 _logger.Verbose("Updating release with tag '{TagName}' on '{Owner}/{Repository}'", tagName, owner, repository);
                 _logger.Debug("{@Release}", release);
 
-                await _vcsProvider.UpdateReleaseAsync(owner, repository, release).ConfigureAwait(false);
+                await _releaseProvider.UpdateReleaseAsync(owner, repository, release).ConfigureAwait(false);
             }
 
             await AddAssetsAsync(owner, repository, tagName, assets, release).ConfigureAwait(false);
@@ -111,11 +133,11 @@ public async Task DiscardReleaseAsync(string owner, string repository, string ta
         {
             try
             {
-                var release = await _vcsProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
+                var release = await _releaseProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
 
                 if (release.Draft)
                 {
-                    await _vcsProvider.DeleteReleaseAsync(owner, repository, release).ConfigureAwait(false);
+                    await _releaseProvider.DeleteReleaseAsync(owner, repository, release).ConfigureAwait(false);
                 }
                 else
                 {
@@ -132,11 +154,17 @@ public async Task DiscardReleaseAsync(string owner, string repository, string ta
 
         private async Task AddAssetsAsync(string owner, string repository, string tagName, IList<string> assets, Release currentRelease)
         {
+            if (_releaseProvider is LocalProvider)
+            {
+                _logger.Error("Assets can not be added when outputting the release notes to a file.");
+                return;
+            }
+
             if (assets?.Any() == true)
             {
                 try
                 {
-                    var release = currentRelease ?? await _vcsProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
+                    var release = currentRelease ?? await _releaseProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
 
                     foreach (var asset in assets)
                     {
@@ -152,15 +180,7 @@ private async Task AddAssetsAsync(string owner, string repository, string tagNam
                         if (existingAsset != null)
                         {
                             _logger.Warning("Requested asset to be uploaded already exists on draft release, replacing with new file: {AssetPath}", asset);
-
-                            if (_vcsProvider is GitLabProvider)
-                            {
-                                _logger.Error("Deleting assets is not currently supported when targeting GitLab.");
-                            }
-                            else
-                            {
-                                await _vcsProvider.DeleteAssetAsync(owner, repository, existingAsset).ConfigureAwait(false);
-                            }
+                            await _assetsProvider.DeleteAssetAsync(owner, repository, existingAsset).ConfigureAwait(false);
                         }
 
                         var upload = new ReleaseAssetUpload
@@ -173,10 +193,10 @@ private async Task AddAssetsAsync(string owner, string repository, string tagNam
                         _logger.Verbose("Uploading asset '{FileName}' to release '{TagName}' on '{Owner}/{Repository}'", assetFileName, tagName, owner, repository);
                         _logger.Debug("{@Upload}", upload);
 
-                        await _vcsProvider.UploadAssetAsync(release, upload).ConfigureAwait(false);
+                        await _assetsProvider.UploadAssetAsync(release, upload).ConfigureAwait(false);
 
                         // Make sure to tidy up the stream that was created above
-                        upload.RawData.Dispose();
+                        await upload.RawData.DisposeAsync().ConfigureAwait(false);
                     }
 
                     if (_configuration.Create.IncludeShaSection)
@@ -211,7 +231,7 @@ private async Task AddAssetsAsync(string owner, string repository, string tagNam
                         _logger.Verbose("Updating release notes with SHA checksum");
                         _logger.Debug("{@Release}", release);
 
-                        await _vcsProvider.UpdateReleaseAsync(owner, repository, release).ConfigureAwait(false);
+                        await _releaseProvider.UpdateReleaseAsync(owner, repository, release).ConfigureAwait(false);
                     }
                 }
                 catch (NotFoundException)
@@ -228,14 +248,14 @@ public async Task<string> ExportReleasesAsync(string owner, string repository, s
             if (string.IsNullOrWhiteSpace(tagName))
             {
                 _logger.Verbose("Finding all releases on '{Owner}/{Repository}'", owner, repository);
-                releases = await _vcsProvider.GetReleasesAsync(owner, repository, skipPrereleases).ConfigureAwait(false);
+                releases = await _releaseProvider.GetReleasesAsync(owner, repository, skipPrereleases).ConfigureAwait(false);
             }
             else
             {
                 try
                 {
                     _logger.Verbose("Finding release with tag '{TagName}' on '{Owner}/{Repository}'", owner, repository, tagName);
-                    var release = await _vcsProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
+                    var release = await _releaseProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
                     releases = new List<Release> { release };
                 }
                 catch (NotFoundException)
@@ -252,10 +272,11 @@ public async Task CloseMilestoneAsync(string owner, string repository, string mi
             try
             {
                 _logger.Verbose("Finding open milestone with title '{Title}' on '{Owner}/{Repository}'", milestoneTitle, owner, repository);
-                var milestone = await _vcsProvider.GetMilestoneAsync(owner, repository, milestoneTitle, ItemStateFilter.Open).ConfigureAwait(false);
+                var milestone = await _milestonesProvider.GetMilestoneAsync(owner, repository, milestoneTitle, ItemStateFilter.Open).ConfigureAwait(false);
 
+                // TODO: Verify that the milestone is not null.
                 _logger.Verbose("Closing milestone '{Title}' on '{Owner}/{Repository}'", milestoneTitle, owner, repository);
-                await _vcsProvider.SetMilestoneStateAsync(owner, repository, milestone, ItemState.Closed).ConfigureAwait(false);
+                await _milestonesProvider.SetMilestoneStateAsync(owner, repository, milestone, ItemState.Open).ConfigureAwait(false);
 
                 if (_configuration.Close.IssueComments)
                 {
@@ -273,10 +294,12 @@ public async Task OpenMilestoneAsync(string owner, string repository, string mil
             try
             {
                 _logger.Verbose("Finding closed milestone with title '{Title}' on '{Owner}/{Repository}'", milestoneTitle, owner, repository);
-                var milestone = await _vcsProvider.GetMilestoneAsync(owner, repository, milestoneTitle, ItemStateFilter.Closed).ConfigureAwait(false);
+                var milestone = await _milestonesProvider.GetMilestoneAsync(owner, repository, milestoneTitle, ItemStateFilter.Closed).ConfigureAwait(false);
+
+                // TODO: Verify that the milestone is not null.
 
                 _logger.Verbose("Opening milestone '{Title}' on '{Owner}/{Repository}'", milestoneTitle, owner, repository);
-                await _vcsProvider.SetMilestoneStateAsync(owner, repository, milestone, ItemState.Open).ConfigureAwait(false);
+                await _milestonesProvider.SetMilestoneStateAsync(owner, repository, milestone, ItemState.Open).ConfigureAwait(false);
             }
             catch (NotFoundException)
             {
@@ -288,12 +311,12 @@ public async Task PublishReleaseAsync(string owner, string repository, string ta
         {
             try
             {
-                var release = await _vcsProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
+                var release = await _releaseProvider.GetReleaseAsync(owner, repository, tagName).ConfigureAwait(false);
 
                 _logger.Verbose("Publishing release '{TagName}' on '{Owner}/{Repository}'", tagName, owner, repository);
                 _logger.Debug("{@Release}", release);
 
-                await _vcsProvider.PublishReleaseAsync(owner, repository, tagName, release).ConfigureAwait(false);
+                await _releaseProvider.PublishReleaseAsync(owner, repository, tagName, release).ConfigureAwait(false);
             }
             catch (NotFoundException)
             {
@@ -318,16 +341,18 @@ public async Task CreateLabelsAsync(string owner, string repository)
                 }
 
                 _logger.Verbose("Grabbing all existing labels on '{Owner}/{Repository}'", owner, repository);
-                var labels = await _vcsProvider.GetLabelsAsync(owner, repository).ConfigureAwait(false);
+                var labels = await _labelsProvider.GetLabelsAsync(owner, repository).ConfigureAwait(false);
+
+                // TODO: verify that the labels are not null
 
                 _logger.Verbose("Removing existing labels");
                 _logger.Debug("{@Labels}", labels);
-                var deleteLabelsTasks = labels.Select(label => _vcsProvider.DeleteLabelAsync(owner, repository, label));
+                var deleteLabelsTasks = labels.Select(label => _labelsProvider.DeleteLabelAsync(owner, repository, label));
                 await Task.WhenAll(deleteLabelsTasks).ConfigureAwait(false);
 
                 _logger.Verbose("Creating new standard labels");
                 _logger.Debug("{@Labels}", newLabels);
-                var createLabelsTasks = newLabels.Select(label => _vcsProvider.CreateLabelAsync(owner, repository, label));
+                var createLabelsTasks = newLabels.Select(label => _labelsProvider.CreateLabelAsync(owner, repository, label));
                 await Task.WhenAll(createLabelsTasks).ConfigureAwait(false);
             }
             else
@@ -384,7 +409,7 @@ private async Task AddIssueCommentsAsync(string owner, string repository, Milest
             var issueComment = detectionComment + "\n" + _configuration.Close.IssueCommentFormat.ReplaceTemplate(new { owner, repository, Milestone = milestone.Title });
 
             _logger.Verbose("Finding issues with milestone: '{Milestone}", milestone.PublicNumber);
-            var issues = await _vcsProvider.GetIssuesAsync(owner, repository, milestone, ItemStateFilter.Closed).ConfigureAwait(false);
+            var issues = await _issuesProvider.GetIssuesAsync(owner, repository, milestone, ItemStateFilter.Closed).ConfigureAwait(false);
 
             foreach (var issue in issues)
             {
@@ -392,11 +417,11 @@ private async Task AddIssueCommentsAsync(string owner, string repository, Milest
 
                 try
                 {
-                    var issueType = _vcsProvider.GetIssueType(issue);
+                    var issueType = _issuesProvider.GetIssueType(issue);
                     if (!await CommentsIncludeStringAsync(owner, repository, issue, detectionComment).ConfigureAwait(false))
                     {
                         _logger.Information("Adding release comment for {IssueType} #{IssueNumber}", issueType, issue.PublicNumber);
-                        await _vcsProvider.CreateIssueCommentAsync(owner, repository, issue, issueComment).ConfigureAwait(false);
+                        await _issuesProvider.CreateIssueCommentAsync(owner, repository, issue, issueComment).ConfigureAwait(false);
                     }
                     else
                     {
@@ -414,14 +439,14 @@ private async Task AddIssueCommentsAsync(string owner, string repository, Milest
         private async Task<bool> CommentsIncludeStringAsync(string owner, string repository, Issue issue, string comment)
         {
             _logger.Verbose("Finding issue comment created by GitReleaseManager for issue #{IssueNumber}", issue.PublicNumber);
-            var issueComments = await _vcsProvider.GetIssueCommentsAsync(owner, repository, issue).ConfigureAwait(false);
+            var issueComments = await _issuesProvider.GetIssueCommentsAsync(owner, repository, issue).ConfigureAwait(false);
 
             return issueComments.Any(c => c.Body.Contains(comment));
         }
 
         private void SleepWhenRateIsLimited()
         {
-            var rateLimit = _vcsProvider.GetRateLimit();
+            var rateLimit = _rateLimitProvider.GetRateLimit();
 
             if (rateLimit?.Remaining == 0)
             {