diff --git a/src/Umbraco.Core/Configuration/Grid/GridConfig.cs b/src/Umbraco.Core/Configuration/Grid/GridConfig.cs
index 72c720e3d6..363dc7b048 100644
--- a/src/Umbraco.Core/Configuration/Grid/GridConfig.cs
+++ b/src/Umbraco.Core/Configuration/Grid/GridConfig.cs
@@ -1,7 +1,5 @@
-using System.IO;
-using Umbraco.Core.Cache;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Hosting;
-using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Manifest;
 using Umbraco.Core.Serialization;
@@ -10,9 +8,9 @@ namespace Umbraco.Core.Configuration.Grid
 {
     public class GridConfig : IGridConfig
     {
-        public GridConfig(AppCaches appCaches, IIOHelper ioHelper, IManifestParser manifestParser, IJsonSerializer jsonSerializer, IHostingEnvironment hostingEnvironment)
+        public GridConfig(AppCaches appCaches, IManifestParser manifestParser, IJsonSerializer jsonSerializer, IHostingEnvironment hostingEnvironment, ILogger logger)
         {
-            EditorsConfig = new GridEditorsConfig(appCaches, ioHelper, manifestParser, jsonSerializer, hostingEnvironment.IsDebugMode);
+            EditorsConfig = new GridEditorsConfig(appCaches, hostingEnvironment, manifestParser, jsonSerializer, logger);
         }
 
         public IGridEditorsConfig EditorsConfig { get; }
diff --git a/src/Umbraco.Core/Configuration/Grid/GridEditorsConfig.cs b/src/Umbraco.Core/Configuration/Grid/GridEditorsConfig.cs
index 410c83ff1a..6cf985fecb 100644
--- a/src/Umbraco.Core/Configuration/Grid/GridEditorsConfig.cs
+++ b/src/Umbraco.Core/Configuration/Grid/GridEditorsConfig.cs
@@ -1,9 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Umbraco.Composing;
 using Umbraco.Core.Cache;
-using Umbraco.Core.IO;
+using Umbraco.Core.Hosting;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Manifest;
 using Umbraco.Core.PropertyEditors;
@@ -14,18 +13,19 @@ namespace Umbraco.Core.Configuration.Grid
     internal class GridEditorsConfig : IGridEditorsConfig
     {
         private readonly AppCaches _appCaches;
-        private readonly IIOHelper _ioHelper;
+        private readonly IHostingEnvironment _hostingEnvironment;
         private readonly IManifestParser _manifestParser;
-        private readonly bool _isDebug;
-        private readonly IJsonSerializer _jsonSerializer;
 
-        public GridEditorsConfig(AppCaches appCaches, IIOHelper ioHelper, IManifestParser manifestParser,IJsonSerializer jsonSerializer, bool isDebug)
+        private readonly IJsonSerializer _jsonSerializer;
+        private readonly ILogger _logger;
+
+        public GridEditorsConfig(AppCaches appCaches, IHostingEnvironment hostingEnvironment, IManifestParser manifestParser,IJsonSerializer jsonSerializer, ILogger logger)
         {
             _appCaches = appCaches;
-            _ioHelper = ioHelper;
+            _hostingEnvironment = hostingEnvironment;
             _manifestParser = manifestParser;
             _jsonSerializer = jsonSerializer;
-            _isDebug = isDebug;
+            _logger = logger;
         }
 
         public IEnumerable<IGridEditorConfig> Editors
@@ -34,7 +34,7 @@ namespace Umbraco.Core.Configuration.Grid
             {
                 List<IGridEditorConfig> GetResult()
                 {
-                    var configFolder = new DirectoryInfo(_ioHelper.MapPath(Constants.SystemDirectories.Config));
+                    var configFolder = new DirectoryInfo(_hostingEnvironment.MapPathContentRoot(Constants.SystemDirectories.Config));
                     var editors = new List<IGridEditorConfig>();
                     var gridConfig = Path.Combine(configFolder.FullName, "grid.editors.config.js");
                     if (File.Exists(gridConfig))
@@ -47,7 +47,7 @@ namespace Umbraco.Core.Configuration.Grid
                         }
                         catch (Exception ex)
                         {
-                            Current.Logger.Error<GridEditorsConfig>(ex, "Could not parse the contents of grid.editors.config.js into a JSON array '{Json}", sourceString);
+                            _logger.Error<GridEditorsConfig>(ex, "Could not parse the contents of grid.editors.config.js into a JSON array '{Json}", sourceString);
                         }
                     }
 
@@ -61,7 +61,7 @@ namespace Umbraco.Core.Configuration.Grid
                 }
 
                 //cache the result if debugging is disabled
-                var result = _isDebug
+                var result = _hostingEnvironment.IsDebugMode
                     ? GetResult()
                     : _appCaches.RuntimeCache.GetCacheItem<List<IGridEditorConfig>>(typeof(GridEditorsConfig) + ".Editors",GetResult, TimeSpan.FromMinutes(10));
 
diff --git a/src/Umbraco.Tests.Common/TestHelperBase.cs b/src/Umbraco.Tests.Common/TestHelperBase.cs
index ce20e723df..b79fb67fe7 100644
--- a/src/Umbraco.Tests.Common/TestHelperBase.cs
+++ b/src/Umbraco.Tests.Common/TestHelperBase.cs
@@ -16,7 +16,6 @@ using Umbraco.Net;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Serialization;
 using Umbraco.Core.Strings;
-using Umbraco.Core.Sync;
 using Umbraco.Web;
 using Umbraco.Web.Routing;
 
diff --git a/src/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj b/src/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj
index e203d378ef..1b49f4d7bc 100644
--- a/src/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj
+++ b/src/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj
@@ -30,6 +30,7 @@
       <ProjectReference Include="..\Umbraco.Infrastructure\Umbraco.Infrastructure.csproj" />
       <ProjectReference Include="..\Umbraco.Tests.Common\Umbraco.Tests.Common.csproj" />
       <ProjectReference Include="..\Umbraco.Web.BackOffice\Umbraco.Web.BackOffice.csproj" />
+      <ProjectReference Include="..\Umbraco.Web.Website\Umbraco.Web.Website.csproj" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/Umbraco.Tests.UnitTests/Umbraco.Tests.UnitTests.csproj b/src/Umbraco.Tests.UnitTests/Umbraco.Tests.UnitTests.csproj
index 67d822fb03..7649de4aa0 100644
--- a/src/Umbraco.Tests.UnitTests/Umbraco.Tests.UnitTests.csproj
+++ b/src/Umbraco.Tests.UnitTests/Umbraco.Tests.UnitTests.csproj
@@ -22,6 +22,7 @@
       <ProjectReference Include="..\Umbraco.Tests.Common\Umbraco.Tests.Common.csproj" />
       <ProjectReference Include="..\Umbraco.Web.BackOffice\Umbraco.Web.BackOffice.csproj" />
       <ProjectReference Include="..\Umbraco.Web.Common\Umbraco.Web.Common.csproj" />
+      <ProjectReference Include="..\Umbraco.Web.Website\Umbraco.Web.Website.csproj" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/Umbraco.Tests.UnitTests/Umbraco.Web.Website/Controllers/SurfaceControllerTests.cs b/src/Umbraco.Tests.UnitTests/Umbraco.Web.Website/Controllers/SurfaceControllerTests.cs
new file mode 100644
index 0000000000..1b4630c2da
--- /dev/null
+++ b/src/Umbraco.Tests.UnitTests/Umbraco.Web.Website/Controllers/SurfaceControllerTests.cs
@@ -0,0 +1,236 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Hosting;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.Services;
+using Umbraco.Tests.Common;
+using Umbraco.Tests.Common.Builders;
+using Umbraco.Tests.Testing;
+using Umbraco.Web;
+using Umbraco.Web.PublishedCache;
+using Umbraco.Web.Routing;
+using Umbraco.Web.Website;
+using Umbraco.Web.Website.Controllers;
+
+namespace Umbraco.Tests.Integration
+{
+    [TestFixture]
+    [UmbracoTest(WithApplication = true)]
+    public class SurfaceControllerTests
+    {
+        private IUmbracoContextAccessor _umbracoContextAccessor;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _umbracoContextAccessor = new TestUmbracoContextAccessor();
+        }
+
+        [Test]
+        public void Can_Construct_And_Get_Result()
+        {
+            var httpContextAccessor = Mock.Of<IHttpContextAccessor>();
+            var hostingEnvironment = Mock.Of<IHostingEnvironment>();
+            var globalSettings = new GlobalSettingsBuilder().Build();
+
+            var umbracoContextFactory = new UmbracoContextFactory(
+                _umbracoContextAccessor,
+                Mock.Of<IPublishedSnapshotService>(),
+                new TestVariationContextAccessor(),
+                new TestDefaultCultureAccessor(),
+                globalSettings,
+                Mock.Of<IUserService>(),
+                hostingEnvironment,
+                new UriUtility(hostingEnvironment),
+                httpContextAccessor,
+                Mock.Of<ICookieManager>(),
+                Mock.Of<IRequestAccessor>());
+
+            var umbracoContextReference = umbracoContextFactory.EnsureUmbracoContext();
+            var umbracoContext = umbracoContextReference.UmbracoContext;
+
+            var umbracoContextAccessor = new TestUmbracoContextAccessor(umbracoContext);
+
+            var ctrl = new TestSurfaceController(umbracoContextAccessor, Mock.Of<IPublishedContentQuery>(), Mock.Of<IPublishedUrlProvider>());
+
+            var result = ctrl.Index();
+
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public void Umbraco_Context_Not_Null()
+        {
+            var globalSettings = new GlobalSettingsBuilder().Build();
+            var httpContextAccessor = Mock.Of<IHttpContextAccessor>();
+            var hostingEnvironment = Mock.Of<IHostingEnvironment>();
+
+            var umbracoContextFactory = new UmbracoContextFactory(
+                _umbracoContextAccessor,
+                Mock.Of<IPublishedSnapshotService>(),
+                new TestVariationContextAccessor(),
+                new TestDefaultCultureAccessor(),
+                globalSettings,
+                Mock.Of<IUserService>(),
+                hostingEnvironment,
+                new UriUtility(hostingEnvironment),
+                httpContextAccessor,
+                Mock.Of<ICookieManager>(),
+                Mock.Of<IRequestAccessor>());
+
+            var umbracoContextReference = umbracoContextFactory.EnsureUmbracoContext();
+            var umbCtx = umbracoContextReference.UmbracoContext;
+
+            var umbracoContextAccessor = new TestUmbracoContextAccessor(umbCtx);
+
+            var ctrl = new TestSurfaceController(umbracoContextAccessor, Mock.Of<IPublishedContentQuery>(), Mock.Of<IPublishedUrlProvider>());
+
+            Assert.IsNotNull(ctrl.UmbracoContext);
+        }
+
+        [Test]
+        public void Can_Lookup_Content()
+        {
+            var publishedSnapshot = new Mock<IPublishedSnapshot>();
+            publishedSnapshot.Setup(x => x.Members).Returns(Mock.Of<IPublishedMemberCache>());
+            var content = new Mock<IPublishedContent>();
+            content.Setup(x => x.Id).Returns(2);
+
+            var publishedSnapshotService = new Mock<IPublishedSnapshotService>();
+            var httpContextAccessor = Mock.Of<IHttpContextAccessor>();
+            var hostingEnvironment = Mock.Of<IHostingEnvironment>();
+            var globalSettings = new GlobalSettingsBuilder().Build();
+
+            var umbracoContextFactory = new UmbracoContextFactory(
+                _umbracoContextAccessor,
+                publishedSnapshotService.Object,
+                new TestVariationContextAccessor(),
+                new TestDefaultCultureAccessor(),
+                globalSettings,
+                Mock.Of<IUserService>(),
+                hostingEnvironment,
+                new UriUtility(hostingEnvironment),
+                httpContextAccessor,
+                Mock.Of<ICookieManager>(),
+                Mock.Of<IRequestAccessor>());
+
+            var umbracoContextReference = umbracoContextFactory.EnsureUmbracoContext();
+            var umbracoContext = umbracoContextReference.UmbracoContext;
+
+            var umbracoContextAccessor = new TestUmbracoContextAccessor(umbracoContext);
+
+            var publishedContentQuery = Mock.Of<IPublishedContentQuery>(query => query.Content(2) == content.Object);
+
+            var ctrl = new TestSurfaceController(umbracoContextAccessor, publishedContentQuery, Mock.Of<IPublishedUrlProvider>());
+            var result = ctrl.GetContent(2) as PublishedContentResult;
+
+            Assert.IsNotNull(result);
+            Assert.IsNotNull(result.Content);
+            Assert.AreEqual(2, result.Content.Id);
+        }
+
+
+        [Test]
+        public void Mock_Current_Page()
+        {
+            var globalSettings = new GlobalSettingsBuilder().Build();
+            var httpContextAccessor = Mock.Of<IHttpContextAccessor>();
+            var hostingEnvironment = Mock.Of<IHostingEnvironment>();
+
+            var umbracoContextFactory = new UmbracoContextFactory(
+                _umbracoContextAccessor,
+                Mock.Of<IPublishedSnapshotService>(),
+                new TestVariationContextAccessor(),
+                new TestDefaultCultureAccessor(),
+                globalSettings,
+                Mock.Of<IUserService>(),
+                hostingEnvironment,
+                new UriUtility(hostingEnvironment),
+                httpContextAccessor,
+                Mock.Of<ICookieManager>(),
+                Mock.Of<IRequestAccessor>());
+
+            var umbracoContextReference = umbracoContextFactory.EnsureUmbracoContext();
+            var umbracoContext = umbracoContextReference.UmbracoContext;
+
+            var umbracoContextAccessor = new TestUmbracoContextAccessor(umbracoContext);
+
+            var content = Mock.Of<IPublishedContent>(publishedContent => publishedContent.Id == 12345);
+
+            var publishedRequestMock = new Mock<IPublishedRequest>();
+            publishedRequestMock.Setup(x => x.PublishedContent).Returns(content);
+
+           var routeDefinition = new RouteDefinition
+            {
+                PublishedRequest = publishedRequestMock.Object
+            };
+
+            var routeData = new RouteData();
+            routeData.DataTokens.Add(Core.Constants.Web.UmbracoRouteDefinitionDataToken, routeDefinition);
+
+            var ctrl = new TestSurfaceController(umbracoContextAccessor, Mock.Of<IPublishedContentQuery>(), Mock.Of<IPublishedUrlProvider>());
+            ctrl.ControllerContext = new ControllerContext()
+            {
+                HttpContext = Mock.Of<HttpContext>(),
+                RouteData = routeData
+            };
+
+            var result = ctrl.GetContentFromCurrentPage() as PublishedContentResult;
+
+            Assert.AreEqual(12345, result.Content.Id);
+        }
+
+
+        public class TestSurfaceController : SurfaceController
+        {
+            private readonly IPublishedContentQuery _publishedContentQuery;
+
+            public TestSurfaceController(IUmbracoContextAccessor umbracoContextAccessor, IPublishedContentQuery publishedContentQuery, IPublishedUrlProvider publishedUrlProvider)
+                : base(umbracoContextAccessor, null, ServiceContext.CreatePartial(), AppCaches.Disabled, null, null, publishedUrlProvider)
+            {
+                _publishedContentQuery = publishedContentQuery;
+            }
+
+            public IActionResult Index()
+            {
+                // ReSharper disable once Mvc.ViewNotResolved
+                return View();
+            }
+
+            public IActionResult GetContent(int id)
+            {
+                var content = _publishedContentQuery.Content(id);
+
+                return new PublishedContentResult(content);
+            }
+
+            public IActionResult GetContentFromCurrentPage()
+            {
+                var content = CurrentPage;
+
+                return new PublishedContentResult(content);
+            }
+        }
+
+        public class PublishedContentResult : IActionResult
+        {
+            public IPublishedContent Content { get; set; }
+
+            public PublishedContentResult(IPublishedContent content)
+            {
+                Content = content;
+            }
+
+            public Task ExecuteResultAsync(ActionContext context)
+            {
+                return Task.CompletedTask;
+            }
+        }
+    }
+}
diff --git a/src/Umbraco.Web.BackOffice/ActionResults/JsonNetResult.cs b/src/Umbraco.Web.BackOffice/ActionResults/JsonNetResult.cs
new file mode 100644
index 0000000000..db5c7a8510
--- /dev/null
+++ b/src/Umbraco.Web.BackOffice/ActionResults/JsonNetResult.cs
@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+
+namespace Umbraco.Web.BackOffice.ActionResults
+{
+    /// <summary>
+    /// Custom json result using newtonsoft json.net
+    /// </summary>
+    public class JsonNetResult : IActionResult
+    {
+        public Encoding ContentEncoding { get; set; }
+        public string ContentType { get; set; }
+        public object Data { get; set; }
+
+        public JsonSerializerSettings SerializerSettings { get; set; }
+        public Formatting Formatting { get; set; }
+
+        public JsonNetResult()
+        {
+            SerializerSettings = new JsonSerializerSettings();
+        }
+
+        public Task ExecuteResultAsync(ActionContext context)
+        {
+            if (context is null)
+                throw new ArgumentNullException(nameof(context));
+
+            var response = context.HttpContext.Response;
+
+            response.ContentType = string.IsNullOrEmpty(ContentType) == false
+                ? ContentType
+                : System.Net.Mime.MediaTypeNames.Application.Json;
+
+            if (!(ContentEncoding is null))
+                response.Headers.Add(Microsoft.Net.Http.Headers.HeaderNames.ContentEncoding, ContentEncoding.ToString());
+
+            if (!(Data is null))
+            {
+                using var bodyWriter = new StreamWriter(response.Body);
+                using var writer = new JsonTextWriter(bodyWriter) { Formatting = Formatting };
+                var serializer = JsonSerializer.Create(SerializerSettings);
+                serializer.Serialize(writer, Data);
+            }
+
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/src/Umbraco.Web.BackOffice/Controllers/BackOfficeController.cs b/src/Umbraco.Web.BackOffice/Controllers/BackOfficeController.cs
index c99498bf57..c5507f00bf 100644
--- a/src/Umbraco.Web.BackOffice/Controllers/BackOfficeController.cs
+++ b/src/Umbraco.Web.BackOffice/Controllers/BackOfficeController.cs
@@ -1,9 +1,18 @@
-using System.Threading.Tasks;
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+using Umbraco.Core;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Configuration.Grid;
 using Umbraco.Core.Hosting;
+using Umbraco.Core.Services;
 using Umbraco.Core.WebAssets;
 using Umbraco.Net;
+using Umbraco.Web.BackOffice.ActionResults;
 using Umbraco.Web.BackOffice.Filters;
 using Umbraco.Web.Common.ActionResults;
 using Umbraco.Web.WebAssets;
@@ -18,12 +27,20 @@ namespace Umbraco.Web.BackOffice.Controllers
         private readonly IRuntimeMinifier _runtimeMinifier;
         private readonly IGlobalSettings _globalSettings;
         private readonly IHostingEnvironment _hostingEnvironment;
+        private readonly IUmbracoApplicationLifetime _umbracoApplicationLifetime;
+        private readonly IUmbracoContextAccessor _umbracoContextAccessor;
+        private readonly ILocalizedTextService _textService;
+        private readonly IGridConfig _gridConfig;
 
-        public BackOfficeController(IRuntimeMinifier runtimeMinifier, IGlobalSettings globalSettings, IHostingEnvironment hostingEnvironment)
+        public BackOfficeController(IRuntimeMinifier runtimeMinifier, IGlobalSettings globalSettings, IHostingEnvironment hostingEnvironment, IUmbracoApplicationLifetime umbracoApplicationLifetime, IUmbracoContextAccessor umbracoContextAccessor, ILocalizedTextService textService, IGridConfig gridConfig)
         {
             _runtimeMinifier = runtimeMinifier;
             _globalSettings = globalSettings;
             _hostingEnvironment = hostingEnvironment;
+            _umbracoApplicationLifetime = umbracoApplicationLifetime;
+            _umbracoContextAccessor = umbracoContextAccessor;
+            _textService = textService;
+            _gridConfig = gridConfig ?? throw new ArgumentNullException(nameof(gridConfig));
         }
 
         [HttpGet]
@@ -44,5 +61,53 @@ namespace Umbraco.Web.BackOffice.Controllers
 
             return new JavaScriptResult(result);
         }
+
+        /// <summary>
+        /// Get the json localized text for a given culture or the culture for the current user
+        /// </summary>
+        /// <param name="culture"></param>
+        /// <returns></returns>
+        [HttpGet]
+        public JsonNetResult LocalizedText(string culture = null)
+        {
+            var securityHelper = _umbracoContextAccessor.GetRequiredUmbracoContext().Security;
+            var isAuthenticated = securityHelper.IsAuthenticated();
+
+            var cultureInfo = string.IsNullOrWhiteSpace(culture)
+                //if the user is logged in, get their culture, otherwise default to 'en'
+                ? isAuthenticated
+                    //current culture is set at the very beginning of each request
+                    ? Thread.CurrentThread.CurrentCulture
+                    : CultureInfo.GetCultureInfo(_globalSettings.DefaultUILanguage)
+                : CultureInfo.GetCultureInfo(culture);
+
+            var allValues = _textService.GetAllStoredValues(cultureInfo);
+            var pathedValues = allValues.Select(kv =>
+            {
+                var slashIndex = kv.Key.IndexOf('/');
+                var areaAlias = kv.Key.Substring(0, slashIndex);
+                var valueAlias = kv.Key.Substring(slashIndex + 1);
+                return new
+                {
+                    areaAlias,
+                    valueAlias,
+                    value = kv.Value
+                };
+            });
+
+            var nestedDictionary = pathedValues
+                .GroupBy(pv => pv.areaAlias)
+                .ToDictionary(pv => pv.Key, pv =>
+                    pv.ToDictionary(pve => pve.valueAlias, pve => pve.value));
+
+            return new JsonNetResult { Data = nestedDictionary, Formatting = Formatting.None };
+        }
+
+        //[UmbracoAuthorize(Order = 0)] TODO: Re-implement UmbracoAuthorizeAttribute
+        [HttpGet]
+        public JsonNetResult GetGridConfig()
+        {
+            return new JsonNetResult { Data = _gridConfig.EditorsConfig.Editors, Formatting = Formatting.None };
+        }
     }
 }
diff --git a/src/Umbraco.Web.BackOffice/Filters/UmbracoAuthorizeFilter.cs b/src/Umbraco.Web.BackOffice/Filters/UmbracoAuthorizeFilter.cs
index 9a590b5c87..5aec94e70a 100644
--- a/src/Umbraco.Web.BackOffice/Filters/UmbracoAuthorizeFilter.cs
+++ b/src/Umbraco.Web.BackOffice/Filters/UmbracoAuthorizeFilter.cs
@@ -1,10 +1,12 @@
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.AspNetCore.Routing;
 using System;
 using Umbraco.Core;
 using Umbraco.Extensions;
 using Umbraco.Web.Security;
+using IHostingEnvironment = Umbraco.Core.Hosting.IHostingEnvironment;
 
 namespace Umbraco.Web.BackOffice.Filters
 {
@@ -20,13 +22,27 @@ namespace Umbraco.Web.BackOffice.Filters
         /// Can be used by unit tests to enable/disable this filter
         /// </summary>
         internal static bool Enable = true;
-        
+        private readonly IHostingEnvironment _hostingEnvironment;
         private readonly IUmbracoContextAccessor _umbracoContext;
         private readonly IRuntimeState _runtimeState;
         private readonly LinkGenerator _linkGenerator;
         private readonly bool _redirectToUmbracoLogin;
         private string _redirectUrl;
 
+        private UmbracoAuthorizeFilter(
+            IHostingEnvironment hostingEnvironment,
+            IUmbracoContextAccessor umbracoContext,
+            IRuntimeState runtimeState, LinkGenerator linkGenerator,
+            bool redirectToUmbracoLogin, string redirectUrl)
+        {
+            _hostingEnvironment = hostingEnvironment ?? throw new ArgumentNullException(nameof(hostingEnvironment));
+            _umbracoContext = umbracoContext ?? throw new ArgumentNullException(nameof(umbracoContext));
+            _runtimeState = runtimeState ?? throw new ArgumentNullException(nameof(runtimeState));
+            _linkGenerator = linkGenerator ?? throw new ArgumentNullException(nameof(linkGenerator));
+            _redirectToUmbracoLogin = redirectToUmbracoLogin;
+            _redirectUrl = redirectUrl;
+        }
+
         /// <summary>
         /// Default constructor
         /// </summary>
@@ -34,11 +50,9 @@ namespace Umbraco.Web.BackOffice.Filters
         /// <param name="runtimeState"></param>
         /// <param name="linkGenerator"></param>
         public UmbracoAuthorizeFilter(
-            IUmbracoContextAccessor umbracoContext, IRuntimeState runtimeState, LinkGenerator linkGenerator)
-        {
-            _umbracoContext = umbracoContext ?? throw new ArgumentNullException(nameof(umbracoContext));
-            _runtimeState = runtimeState ?? throw new ArgumentNullException(nameof(runtimeState));
-            _linkGenerator = linkGenerator ?? throw new ArgumentNullException(nameof(linkGenerator));
+            IHostingEnvironment hostingEnvironment, IUmbracoContextAccessor umbracoContext, IRuntimeState runtimeState, LinkGenerator linkGenerator)
+            : this(hostingEnvironment, umbracoContext, runtimeState, linkGenerator, false, null)
+        {            
         }
 
         /// <summary>
@@ -49,11 +63,10 @@ namespace Umbraco.Web.BackOffice.Filters
         /// <param name="linkGenerator"></param>
         /// <param name="redirectToUmbracoLogin">If true will redirect to the umbraco login page if not authorized</param>
         public UmbracoAuthorizeFilter(
-            IUmbracoContextAccessor umbracoContext, IRuntimeState runtimeState, LinkGenerator linkGenerator,
+            IHostingEnvironment hostingEnvironment, IUmbracoContextAccessor umbracoContext, IRuntimeState runtimeState, LinkGenerator linkGenerator,
             bool redirectToUmbracoLogin)
-            : this(umbracoContext, runtimeState, linkGenerator)
+            : this(hostingEnvironment, umbracoContext, runtimeState, linkGenerator, redirectToUmbracoLogin, null)
         {            
-            _redirectToUmbracoLogin = redirectToUmbracoLogin;
         }
 
         /// <summary>
@@ -64,11 +77,10 @@ namespace Umbraco.Web.BackOffice.Filters
         /// /// <param name="linkGenerator"></param>
         /// <param name="redirectUrl">If specified will redirect to this URL if not authorized</param>
         public UmbracoAuthorizeFilter(
-            IUmbracoContextAccessor umbracoContext, IRuntimeState runtimeState, LinkGenerator linkGenerator,
+            IHostingEnvironment hostingEnvironment, IUmbracoContextAccessor umbracoContext, IRuntimeState runtimeState, LinkGenerator linkGenerator,
             string redirectUrl)
-            : this(umbracoContext, runtimeState, linkGenerator)
+            : this(hostingEnvironment, umbracoContext, runtimeState, linkGenerator, false, redirectUrl)
         {
-            _redirectUrl = redirectUrl;
         }
 
         public void OnAuthorization(AuthorizationFilterContext context)
@@ -77,7 +89,7 @@ namespace Umbraco.Web.BackOffice.Filters
             {
                 if (_redirectToUmbracoLogin)
                 {
-                    _redirectUrl = _linkGenerator.GetBackOfficeUrl();
+                    _redirectUrl = _linkGenerator.GetBackOfficeUrl(_hostingEnvironment);
                 }
 
                 if (!_redirectUrl.IsNullOrWhiteSpace())
diff --git a/src/Umbraco.Web.Common/Extensions/LinkGeneratorExtensions.cs b/src/Umbraco.Web.Common/Extensions/LinkGeneratorExtensions.cs
index 5ac3412d61..aa7700eca0 100644
--- a/src/Umbraco.Web.Common/Extensions/LinkGeneratorExtensions.cs
+++ b/src/Umbraco.Web.Common/Extensions/LinkGeneratorExtensions.cs
@@ -3,6 +3,7 @@ using Umbraco.Core;
 using Microsoft.AspNetCore.Routing;
 using System.Reflection;
 using Umbraco.Web.Common.Install;
+using Umbraco.Core.Hosting;
 
 namespace Umbraco.Extensions
 {
@@ -13,7 +14,7 @@ namespace Umbraco.Extensions
         /// </summary>
         /// <param name="url"></param>
         /// <returns></returns>
-        public static string GetBackOfficeUrl(this LinkGenerator linkGenerator)
+        public static string GetBackOfficeUrl(this LinkGenerator linkGenerator, IHostingEnvironment hostingEnvironment)
         {
 
             Type backOfficeControllerType;
@@ -22,9 +23,9 @@ namespace Umbraco.Extensions
                 backOfficeControllerType = Assembly.Load("Umbraco.Web.BackOffice")?.GetType("Umbraco.Web.BackOffice.Controllers.BackOfficeController");
                 if (backOfficeControllerType == null) return "/"; // this would indicate that the installer is installed without the back office
             }
-            catch (Exception)
+            catch
             {
-                return "/"; // this would indicate that the installer is installed without the back office
+                return hostingEnvironment.ApplicationVirtualPath; // this would indicate that the installer is installed without the back office
             }
 
             return linkGenerator.GetPathByAction("Default", ControllerExtensions.GetControllerName(backOfficeControllerType), new { area = Constants.Web.Mvc.BackOfficeApiArea });
@@ -37,7 +38,7 @@ namespace Umbraco.Extensions
         /// <returns></returns>
         public static string GetInstallerUrl(this LinkGenerator linkGenerator)
         {
-            return linkGenerator.GetPathByAction("Index", ControllerExtensions.GetControllerName<InstallController>(), new { area = Constants.Web.Mvc.InstallArea });
+            return linkGenerator.GetPathByAction(nameof(InstallController.Index), ControllerExtensions.GetControllerName<InstallController>(), new { area = Constants.Web.Mvc.InstallArea });
         }
     }
 }
diff --git a/src/Umbraco.Web.Common/Install/InstallAreaRoutes.cs b/src/Umbraco.Web.Common/Install/InstallAreaRoutes.cs
index 6f1f378809..b21495e27d 100644
--- a/src/Umbraco.Web.Common/Install/InstallAreaRoutes.cs
+++ b/src/Umbraco.Web.Common/Install/InstallAreaRoutes.cs
@@ -51,7 +51,7 @@ namespace Umbraco.Web.Common.Install
                     endpoints.MapGet($"{installPathSegment}/{{controller?}}/{{action?}}", context =>
                     {
                         // redirect to umbraco
-                        context.Response.Redirect(_linkGenerator.GetBackOfficeUrl(), false);
+                        context.Response.Redirect(_linkGenerator.GetBackOfficeUrl(_hostingEnvironment), false);
                         return Task.CompletedTask;
                     });
 
diff --git a/src/Umbraco.Web.Common/Security/WebSecurity.cs b/src/Umbraco.Web.Common/Security/WebSecurity.cs
index 5f54d2e9ee..e87720dc86 100644
--- a/src/Umbraco.Web.Common/Security/WebSecurity.cs
+++ b/src/Umbraco.Web.Common/Security/WebSecurity.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using Umbraco.Composing;
 using Umbraco.Core;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Web.Security;
@@ -11,46 +12,46 @@ namespace Umbraco.Web.Common.Security
 
     public class WebSecurity : IWebSecurity
     {
-        public IUser CurrentUser => throw new NotImplementedException();
+        public IUser CurrentUser => new User(Current.Configs.Global());
 
         public ValidateRequestAttempt AuthorizeRequest(bool throwExceptions = false)
         {
-            throw new NotImplementedException();
+            return ValidateRequestAttempt.Success;
         }
 
         public void ClearCurrentLogin()
         {
-            throw new NotImplementedException();
+            //throw new NotImplementedException();
         }
 
         public Attempt<int> GetUserId()
         {
-            throw new NotImplementedException();
+            return Attempt.Succeed(-1);
         }
 
         public bool IsAuthenticated()
         {
-            throw new NotImplementedException();
+            return true;
         }
 
         public double PerformLogin(int userId)
         {
-            throw new NotImplementedException();
+            return 100;
         }
 
         public bool UserHasSectionAccess(string section, IUser user)
         {
-            throw new NotImplementedException();
+            return true;
         }
 
         public bool ValidateCurrentUser()
         {
-            throw new NotImplementedException();
+            return true;
         }
 
         public ValidateRequestAttempt ValidateCurrentUser(bool throwExceptions, bool requiresApproval = true)
         {
-            throw new NotImplementedException();
+            return ValidateRequestAttempt.Success;
         }
     }
 }
diff --git a/src/Umbraco.Web.UI/config/grid.editors.config.js b/src/Umbraco.Web.UI.NetCore/Config/grid.editors.config.js
similarity index 100%
rename from src/Umbraco.Web.UI/config/grid.editors.config.js
rename to src/Umbraco.Web.UI.NetCore/Config/grid.editors.config.js
diff --git a/src/Umbraco.Web.UI.NetCore/Controllers/TestBackOfficeUmbracoApiController.cs b/src/Umbraco.Web.UI.NetCore/Controllers/TestBackOfficeUmbracoApiController.cs
deleted file mode 100644
index d5cddb508a..0000000000
--- a/src/Umbraco.Web.UI.NetCore/Controllers/TestBackOfficeUmbracoApiController.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.AspNetCore.Mvc;
-using Umbraco.Web.Common.Attributes;
-using Umbraco.Web.Common.Controllers;
-
-namespace Umbraco.Web.UI.NetCore.Controllers
-{
-    [PluginController("Test")]
-    [IsBackOffice]
-    public class TestBackOfficeUmbracoApiController : UmbracoApiController
-    {
-        [HttpGet]
-        public IActionResult Index()
-        {
-            return Content("hello world");
-        }
-    }
-}
diff --git a/src/Umbraco.Web.UI.NetCore/Startup.cs b/src/Umbraco.Web.UI.NetCore/Startup.cs
index 27b54a9503..a703e7c20a 100644
--- a/src/Umbraco.Web.UI.NetCore/Startup.cs
+++ b/src/Umbraco.Web.UI.NetCore/Startup.cs
@@ -1,6 +1,7 @@
 using System;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Server.Kestrel.Core;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -49,6 +50,13 @@ namespace Umbraco.Web.UI.BackOffice
             {
                 options.ShouldProfile = request => false; // WebProfiler determine and start profiling. We should not use the MiniProfilerMiddleware to also profile
             });
+
+            // If using Kestrel: https://stackoverflow.com/a/55196057
+            services.Configure<KestrelServerOptions>(options =>
+            {
+                options.AllowSynchronousIO = true;
+            });
+
         }
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
diff --git a/src/Umbraco.Web.UI.NetCore/Umbraco.Web.UI.NetCore.csproj b/src/Umbraco.Web.UI.NetCore/Umbraco.Web.UI.NetCore.csproj
index 966cb9c86e..219b819b11 100644
--- a/src/Umbraco.Web.UI.NetCore/Umbraco.Web.UI.NetCore.csproj
+++ b/src/Umbraco.Web.UI.NetCore/Umbraco.Web.UI.NetCore.csproj
@@ -13,6 +13,7 @@
     </ItemGroup>
 
     <ItemGroup>
+      <Folder Include="Controllers\" />
       <Folder Include="Views\" />
       <Folder Include="wwwroot\Media" />
       <Folder Include="wwwroot\Umbraco\views\install" />
@@ -63,6 +64,7 @@
     </ItemGroup>
 
     <ItemGroup>
+      <Content Include="Config\grid.editors.config.js" />
       <Content Include="Config\logviewer.searches.config.js" />
     </ItemGroup>
 
diff --git a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
index 5e66765379..8c0b98787c 100644
--- a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
+++ b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
@@ -142,7 +142,6 @@
       <DesignTimeSharedInput>True</DesignTimeSharedInput>
       <DependentUpon>Settings.settings</DependentUpon>
     </Compile>
-    <Content Include="Config\grid.editors.config.js" />
     <Content Include="Config\Lang\cs-CZ.user.xml" />
     <Content Include="Config\Lang\da-DK.user.xml" />
     <Content Include="Config\Lang\de-DE.user.xml" />
diff --git a/src/Umbraco.Web.UI/Umbraco/Views/AuthorizeUpgrade.cshtml b/src/Umbraco.Web.UI/Umbraco/Views/AuthorizeUpgrade.cshtml
index 7984bf14f7..6cd3d18be1 100644
--- a/src/Umbraco.Web.UI/Umbraco/Views/AuthorizeUpgrade.cshtml
+++ b/src/Umbraco.Web.UI/Umbraco/Views/AuthorizeUpgrade.cshtml
@@ -19,7 +19,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 
     <title>Umbraco</title>
-     
+
     @Html.Raw(runtimeMinifier.RenderCssHere(BackOfficeWebAssets.UmbracoUpgradeCssBundleName));
 
     @*Because we're lazy loading angular js, the embedded cloak style will not be loaded initially, but we need it*@
@@ -45,7 +45,7 @@
         });
     }
 
-@Html.BareMinimumServerVariablesScript(Url, Model.Features, Model.GlobalSettings, Model.UmbracoVersion, Model.ContentSettings, Model.TreeCollection, Model.HttpContextAccessor, Model.HostingEnvironment, Model.RuntimeSettings, Model.SecuritySettings, runtimeMinifier)
+@Html.BareMinimumServerVariablesScript(Url, Model.Features, Model.GlobalSettings, Model.UmbracoVersion, Model.ContentSettings, Model.TreeCollection, Model.HostingEnvironment, Model.RuntimeSettings, Model.SecuritySettings, runtimeMinifier)
 
 <script type="text/javascript">
     document.angularReady = function (app) {
diff --git a/src/Umbraco.Web.UI/Umbraco/Views/Default.cshtml b/src/Umbraco.Web.UI/Umbraco/Views/Default.cshtml
index c695eb5131..3dae0888d9 100644
--- a/src/Umbraco.Web.UI/Umbraco/Views/Default.cshtml
+++ b/src/Umbraco.Web.UI/Umbraco/Views/Default.cshtml
@@ -103,7 +103,7 @@
                on-login="hideLoginScreen()">
     </umb-login>
 
-@Html.BareMinimumServerVariablesScript(Url, Model.Features, Model.GlobalSettings, Model.UmbracoVersion, Model.ContentSettings, Model.TreeCollection, Model.HttpContextAccessor, Model.HostingEnvironment, Model.RuntimeSettings, Model.SecuritySettings, Current.RuntimeMinifier)
+@Html.BareMinimumServerVariablesScript(Url, Model.Features, Model.GlobalSettings, Model.UmbracoVersion, Model.ContentSettings, Model.TreeCollection, Model.HostingEnvironment, Model.RuntimeSettings, Model.SecuritySettings, Current.RuntimeMinifier)
 
 <script>
 
diff --git a/src/Umbraco.Web.Website/ActionResults/RedirectToUmbracoPageResult.cs b/src/Umbraco.Web.Website/ActionResults/RedirectToUmbracoPageResult.cs
new file mode 100644
index 0000000000..d271e63e2f
--- /dev/null
+++ b/src/Umbraco.Web.Website/ActionResults/RedirectToUmbracoPageResult.cs
@@ -0,0 +1,178 @@
+using System;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Web;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.Extensions.DependencyInjection;
+using Umbraco.Core;
+using Umbraco.Core.IO;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Web.Routing;
+
+namespace Umbraco.Web.Website.ActionResults
+{
+    /// <summary>
+    /// Redirects to an Umbraco page by Id or Entity
+    /// </summary>
+    public class RedirectToUmbracoPageResult : IActionResult
+    {
+        private IPublishedContent _publishedContent;
+        private readonly int _pageId;
+        private readonly NameValueCollection _queryStringValues;
+        private readonly IPublishedUrlProvider _publishedUrlProvider;
+        private readonly IUmbracoContextAccessor _umbracoContextAccessor;
+        private string _url;
+
+        private string Url
+        {
+            get
+            {
+                if (!string.IsNullOrWhiteSpace(_url)) return _url;
+
+                if (PublishedContent is null)
+                    throw new InvalidOperationException($"Cannot redirect, no entity was found for id {PageId}");
+
+                var result = _publishedUrlProvider.GetUrl(PublishedContent.Id);
+
+                if (result == "#")
+                    throw new InvalidOperationException(
+                        $"Could not route to entity with id {PageId}, the NiceUrlProvider could not generate a URL");
+
+                _url = result;
+
+                return _url;
+            }
+        }
+
+        private int PageId => _pageId;
+
+        private IPublishedContent PublishedContent
+        {
+            get
+            {
+                if (!(_publishedContent is null)) return _publishedContent;
+
+                //need to get the URL for the page
+                _publishedContent = _umbracoContextAccessor.GetRequiredUmbracoContext().Content.GetById(_pageId);
+
+               return _publishedContent;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new RedirectToUmbracoResult
+        /// </summary>
+        /// <param name="pageId"></param>
+        /// <param name="publishedUrlProvider"></param>
+        public RedirectToUmbracoPageResult(int pageId, IPublishedUrlProvider publishedUrlProvider, IUmbracoContextAccessor umbracoContextAccessor)
+        {
+            _pageId = pageId;
+            _publishedUrlProvider = publishedUrlProvider;
+            _umbracoContextAccessor = umbracoContextAccessor;
+        }
+
+        /// <summary>
+        /// Creates a new RedirectToUmbracoResult
+        /// </summary>
+        /// <param name="pageId"></param>
+        /// <param name="queryStringValues"></param>
+        /// <param name="publishedUrlProvider"></param>
+        public RedirectToUmbracoPageResult(int pageId, NameValueCollection queryStringValues, IPublishedUrlProvider publishedUrlProvider, IUmbracoContextAccessor umbracoContextAccessor)
+        {
+            _pageId = pageId;
+            _queryStringValues = queryStringValues;
+            _publishedUrlProvider = publishedUrlProvider;
+            _umbracoContextAccessor = umbracoContextAccessor;
+        }
+
+        /// <summary>
+        /// Creates a new RedirectToUmbracoResult
+        /// </summary>
+        /// <param name="pageId"></param>
+        /// <param name="queryString"></param>
+        /// <param name="publishedUrlProvider"></param>
+        public RedirectToUmbracoPageResult(int pageId, string queryString, IPublishedUrlProvider publishedUrlProvider, IUmbracoContextAccessor umbracoContextAccessor)
+        {
+            _pageId = pageId;
+            _queryStringValues = ParseQueryString(queryString);
+            _publishedUrlProvider = publishedUrlProvider;
+            _umbracoContextAccessor = umbracoContextAccessor;
+        }
+
+        /// <summary>
+        /// Creates a new RedirectToUmbracoResult
+        /// </summary>
+        /// <param name="publishedContent"></param>
+        /// <param name="publishedUrlProvider"></param>
+        /// <param name="umbracoContextAccessor"></param>
+        public RedirectToUmbracoPageResult(IPublishedContent publishedContent, IPublishedUrlProvider publishedUrlProvider, IUmbracoContextAccessor umbracoContextAccessor)
+        {
+            _publishedContent = publishedContent;
+            _pageId = publishedContent.Id;
+            _publishedUrlProvider = publishedUrlProvider;
+            _umbracoContextAccessor = umbracoContextAccessor;
+        }
+
+        /// <summary>
+        /// Creates a new RedirectToUmbracoResult
+        /// </summary>
+        /// <param name="publishedContent"></param>
+        /// <param name="queryStringValues"></param>
+        /// <param name="publishedUrlProvider"></param>
+        /// <param name="umbracoContextAccessor"></param>
+        public RedirectToUmbracoPageResult(IPublishedContent publishedContent, NameValueCollection queryStringValues, IPublishedUrlProvider publishedUrlProvider, IUmbracoContextAccessor umbracoContextAccessor)
+        {
+            _publishedContent = publishedContent;
+            _pageId = publishedContent.Id;
+            _queryStringValues = queryStringValues;
+            _publishedUrlProvider = publishedUrlProvider;
+            _umbracoContextAccessor = umbracoContextAccessor;
+        }
+
+        /// <summary>
+        /// Creates a new RedirectToUmbracoResult
+        /// </summary>
+        /// <param name="publishedContent"></param>
+        /// <param name="queryString"></param>
+        /// <param name="publishedUrlProvider"></param>
+        /// <param name="umbracoContextAccessor"></param>
+        public RedirectToUmbracoPageResult(IPublishedContent publishedContent, string queryString, IPublishedUrlProvider publishedUrlProvider, IUmbracoContextAccessor umbracoContextAccessor)
+        {
+            _publishedContent = publishedContent;
+            _pageId = publishedContent.Id;
+            _queryStringValues = ParseQueryString(queryString);
+            _publishedUrlProvider = publishedUrlProvider;
+            _umbracoContextAccessor = umbracoContextAccessor;
+        }
+
+        public Task ExecuteResultAsync(ActionContext context)
+        {
+            if (context is null) throw new ArgumentNullException(nameof(context));
+
+            var httpContext = context.HttpContext;
+            var ioHelper = httpContext.RequestServices.GetRequiredService<IIOHelper>();
+            var destinationUrl = ioHelper.ResolveUrl(Url);
+
+            if (!(_queryStringValues is null) && _queryStringValues.Count > 0)
+            {
+                destinationUrl += "?" + string.Join("&",
+                                                       _queryStringValues.AllKeys.Select(x => x + "=" + HttpUtility.UrlEncode(_queryStringValues[x])));
+            }
+
+            var tempDataDictionaryFactory = context.HttpContext.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
+            var tempData = tempDataDictionaryFactory.GetTempData(context.HttpContext);
+            tempData?.Keep();
+
+            httpContext.Response.Redirect(destinationUrl);
+
+            return Task.CompletedTask;
+        }
+
+        private NameValueCollection ParseQueryString(string queryString)
+        {
+            return !string.IsNullOrEmpty(queryString) ? HttpUtility.ParseQueryString(queryString) : null;
+        }
+    }
+}
diff --git a/src/Umbraco.Web.Website/ActionResults/RedirectToUmbracoUrlResult.cs b/src/Umbraco.Web.Website/ActionResults/RedirectToUmbracoUrlResult.cs
new file mode 100644
index 0000000000..6a7b4d678d
--- /dev/null
+++ b/src/Umbraco.Web.Website/ActionResults/RedirectToUmbracoUrlResult.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Umbraco.Web.Website.ActionResults
+{
+    /// <summary>
+    /// Redirects to the current URL rendering an Umbraco page including it's query strings
+    /// </summary>
+    /// <remarks>
+    /// This is useful if you need to redirect
+    /// to the current page but the current page is actually a rewritten URL normally done with something like
+    /// Server.Transfer. It is also handy if you want to persist the query strings.
+    /// </remarks>
+    public class RedirectToUmbracoUrlResult : IActionResult
+    {
+        private readonly IUmbracoContext _umbracoContext;
+
+        /// <summary>
+        /// Creates a new RedirectToUmbracoResult
+        /// </summary>
+        /// <param name="umbracoContext"></param>
+        public RedirectToUmbracoUrlResult(IUmbracoContext umbracoContext)
+        {
+            _umbracoContext = umbracoContext;
+        }
+
+        public Task ExecuteResultAsync(ActionContext context)
+        {
+            if (context is null) throw new ArgumentNullException(nameof(context));
+
+            var destinationUrl = _umbracoContext.OriginalRequestUrl.PathAndQuery;
+            var tempDataDictionaryFactory = context.HttpContext.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
+            var tempData = tempDataDictionaryFactory.GetTempData(context.HttpContext);
+            tempData?.Keep();
+
+            context.HttpContext.Response.Redirect(destinationUrl);
+
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/src/Umbraco.Web.Website/ActionResults/UmbracoPageResult.cs b/src/Umbraco.Web.Website/ActionResults/UmbracoPageResult.cs
new file mode 100644
index 0000000000..62942541e9
--- /dev/null
+++ b/src/Umbraco.Web.Website/ActionResults/UmbracoPageResult.cs
@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Abstractions;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.AspNetCore.Mvc.ViewEngines;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Extensions;
+
+namespace Umbraco.Web.Website.ActionResults
+{
+    /// <summary>
+    /// Used by posted forms to proxy the result to the page in which the current URL matches on
+    /// </summary>
+    public class UmbracoPageResult : IActionResult
+    {
+        private readonly IProfilingLogger _profilingLogger;
+
+        public UmbracoPageResult(IProfilingLogger profilingLogger)
+        {
+            _profilingLogger = profilingLogger;
+        }
+
+        public Task ExecuteResultAsync(ActionContext context)
+        {
+            var routeData = context.RouteData;
+
+            ResetRouteData(routeData);
+            ValidateRouteData(routeData);
+
+            var factory = context.HttpContext.RequestServices.GetRequiredService<IControllerFactory>();
+            Controller controller = null;
+
+            if (!(context is ControllerContext controllerContext))
+                return Task.FromCanceled(new System.Threading.CancellationToken());
+
+            try
+            {
+                controller = CreateController(controllerContext, factory);
+
+                CopyControllerData(controllerContext, controller);
+
+                ExecuteControllerAction(controllerContext, controller);
+            }
+            finally
+            {
+                CleanupController(controllerContext, controller, factory);
+            }
+
+            return Task.CompletedTask;
+        }
+
+        /// <summary>
+        /// Executes the controller action
+        /// </summary>
+        private void ExecuteControllerAction(ControllerContext context, Controller controller)
+        {
+            using (_profilingLogger.TraceDuration<UmbracoPageResult>("Executing Umbraco RouteDefinition controller", "Finished"))
+            {
+                //TODO I do not think this will work, We need to test this, when we can, in the .NET Core executable.
+                var aec = new ActionExecutingContext(context, new List<IFilterMetadata>(), new Dictionary<string, object>(), controller);
+                var actionExecutedDelegate = CreateActionExecutedDelegate(aec);
+
+                controller.OnActionExecutionAsync(aec, actionExecutedDelegate);
+            }
+        }
+
+        /// <summary>
+        /// Creates action execution delegate from ActionExecutingContext
+        /// </summary>
+        private static ActionExecutionDelegate CreateActionExecutedDelegate(ActionExecutingContext context)
+        {
+            var actionExecutedContext = new ActionExecutedContext(context, context.Filters, context.Controller)
+            {
+                Result = context.Result,
+            };
+            return () => Task.FromResult(actionExecutedContext);
+        }
+
+        /// <summary>
+        /// Since we could be returning the current page from a surface controller posted values in which the routing values are changed, we
+        /// need to revert these values back to nothing in order for the normal page to render again.
+        /// </summary>
+        private static void ResetRouteData(RouteData routeData)
+        {
+            routeData.DataTokens["area"] = null;
+            routeData.DataTokens["Namespaces"] = null;
+        }
+
+        /// <summary>
+        /// Validate that the current page execution is not being handled by the normal umbraco routing system
+        /// </summary>
+        private static void ValidateRouteData(RouteData routeData)
+        {
+            if (routeData.DataTokens.ContainsKey(Constants.Web.UmbracoRouteDefinitionDataToken) == false)
+            {
+                throw new InvalidOperationException("Can only use " + typeof(UmbracoPageResult).Name +
+                                                    " in the context of an Http POST when using a SurfaceController form");
+            }
+        }
+
+        /// <summary>
+        /// Ensure ModelState, ViewData and TempData is copied across
+        /// </summary>
+        private static void CopyControllerData(ControllerContext context, Controller controller)
+        {
+            controller.ViewData.ModelState.Merge(context.ModelState);
+
+            foreach (var d in controller.ViewData)
+                controller.ViewData[d.Key] = d.Value;
+
+            // We cannot simply merge the temp data because during controller execution it will attempt to 'load' temp data
+            // but since it has not been saved, there will be nothing to load and it will revert to nothing, so the trick is
+            // to Save the state of the temp data first then it will automatically be picked up.
+            // http://issues.umbraco.org/issue/U4-1339
+
+            var targetController = controller;
+            var tempDataDictionaryFactory = context.HttpContext.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
+            var tempData = tempDataDictionaryFactory.GetTempData(context.HttpContext);
+
+            targetController.TempData = tempData;
+            targetController.TempData.Save();
+        }
+
+        /// <summary>
+        /// Creates a controller using the controller factory
+        /// </summary>
+        private static Controller CreateController(ControllerContext context, IControllerFactory factory)
+        {
+            if (!(factory.CreateController(context) is Controller controller))
+                throw new InvalidOperationException("Could not create controller with name " + context.ActionDescriptor.ControllerName + ".");
+
+            return controller;
+        }
+
+        /// <summary>
+        /// Cleans up the controller by releasing it using the controller factory, and by disposing it.
+        /// </summary>
+        private static void CleanupController(ControllerContext context, Controller controller, IControllerFactory factory)
+        {
+            if (!(controller is null))
+                factory.ReleaseController(context, controller);
+
+            controller?.DisposeIfDisposable();
+        }
+
+        private class DummyView : IView
+        {
+            public DummyView(string path)
+            {
+                Path = path;
+            }
+
+            public Task RenderAsync(ViewContext context)
+            {
+                return Task.CompletedTask;
+            }
+
+            public string Path { get; }
+        }
+    }
+}
diff --git a/src/Umbraco.Web.Website/Controllers/SurfaceController.cs b/src/Umbraco.Web.Website/Controllers/SurfaceController.cs
new file mode 100644
index 0000000000..161fe1750f
--- /dev/null
+++ b/src/Umbraco.Web.Website/Controllers/SurfaceController.cs
@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Specialized;
+using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Services;
+using Umbraco.Web.Common.Controllers;
+using Umbraco.Web.Routing;
+using Umbraco.Web.Website.ActionResults;
+
+namespace Umbraco.Web.Website.Controllers
+{
+    /// <summary>
+    /// Provides a base class for front-end add-in controllers.
+    /// </summary>
+    // TODO: Migrate MergeModelStateToChildAction and MergeParentContextViewData action filters
+    // [MergeModelStateToChildAction]
+    // [MergeParentContextViewData]
+    public abstract class SurfaceController : PluginController
+    {
+        private readonly IPublishedUrlProvider _publishedUrlProvider;
+
+        /// <summary>
+        /// Gets the current page.
+        /// </summary>
+        protected virtual IPublishedContent CurrentPage
+        {
+            get
+            {
+                var routeDefAttempt = TryGetRouteDefinitionFromAncestorViewContexts();
+                if (routeDefAttempt.Success == false)
+                    throw routeDefAttempt.Exception;
+
+                var routeDef = routeDefAttempt.Result;
+                return routeDef.PublishedRequest.PublishedContent;
+            }
+        }
+
+        protected SurfaceController(IUmbracoContextAccessor umbracoContextAccessor, IUmbracoDatabaseFactory databaseFactory, ServiceContext services, AppCaches appCaches, ILogger logger, IProfilingLogger profilingLogger, IPublishedUrlProvider publishedUrlProvider)
+            : base(umbracoContextAccessor, databaseFactory, services, appCaches, logger, profilingLogger)
+        {
+            _publishedUrlProvider = publishedUrlProvider;
+        }
+
+        /// <summary>
+        /// Redirects to the Umbraco page with the given id
+        /// </summary>
+        /// <param name="pageId"></param>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToUmbracoPage(int pageId)
+        {
+            return new RedirectToUmbracoPageResult(pageId, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the Umbraco page with the given id and passes provided querystring
+        /// </summary>
+        /// <param name="pageId"></param>
+        /// <param name="queryStringValues"></param>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToUmbracoPage(int pageId, NameValueCollection queryStringValues)
+        {
+            return new RedirectToUmbracoPageResult(pageId, queryStringValues, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the Umbraco page with the given id and passes provided querystring
+        /// </summary>
+        /// <param name="pageId"></param>
+        /// <param name="queryString"></param>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToUmbracoPage(int pageId, string queryString)
+        {
+            return new RedirectToUmbracoPageResult(pageId, queryString, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the Umbraco page with the given published content
+        /// </summary>
+        /// <param name="publishedContent"></param>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToUmbracoPage(IPublishedContent publishedContent)
+        {
+            return new RedirectToUmbracoPageResult(publishedContent, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the Umbraco page with the given published content and passes provided querystring
+        /// </summary>
+        /// <param name="publishedContent"></param>
+        /// <param name="queryStringValues"></param>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToUmbracoPage(IPublishedContent publishedContent, NameValueCollection queryStringValues)
+        {
+            return new RedirectToUmbracoPageResult(publishedContent, queryStringValues, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the Umbraco page with the given published content and passes provided querystring
+        /// </summary>
+        /// <param name="publishedContent"></param>
+        /// <param name="queryString"></param>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToUmbracoPage(IPublishedContent publishedContent, string queryString)
+        {
+            return new RedirectToUmbracoPageResult(publishedContent, queryString, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the currently rendered Umbraco page
+        /// </summary>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToCurrentUmbracoPage()
+        {
+            return new RedirectToUmbracoPageResult(CurrentPage, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the currently rendered Umbraco page and passes provided querystring
+        /// </summary>
+        /// <param name="queryStringValues"></param>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToCurrentUmbracoPage(NameValueCollection queryStringValues)
+        {
+            return new RedirectToUmbracoPageResult(CurrentPage, queryStringValues, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the currently rendered Umbraco page and passes provided querystring
+        /// </summary>
+        /// <param name="queryString"></param>
+        /// <returns></returns>
+        protected RedirectToUmbracoPageResult RedirectToCurrentUmbracoPage(string queryString)
+        {
+            return new RedirectToUmbracoPageResult(CurrentPage, queryString, _publishedUrlProvider, UmbracoContextAccessor);
+        }
+
+        /// <summary>
+        /// Redirects to the currently rendered Umbraco URL
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>
+        /// This is useful if you need to redirect
+        /// to the current page but the current page is actually a rewritten URL normally done with something like
+        /// Server.Transfer.*
+        /// </remarks>
+        protected RedirectToUmbracoUrlResult RedirectToCurrentUmbracoUrl()
+        {
+            return new RedirectToUmbracoUrlResult(UmbracoContext);
+        }
+
+        /// <summary>
+        /// Returns the currently rendered Umbraco page
+        /// </summary>
+        /// <returns></returns>
+        protected UmbracoPageResult CurrentUmbracoPage()
+        {
+            return new UmbracoPageResult(ProfilingLogger);
+        }
+
+        /// <summary>
+        /// we need to recursively find the route definition based on the parent view context
+        /// </summary>
+        /// <returns></returns>
+        private Attempt<RouteDefinition> TryGetRouteDefinitionFromAncestorViewContexts()
+        {
+            var currentContext = ControllerContext;
+            while (!(currentContext is null))
+            {
+                var currentRouteData = currentContext.RouteData;
+                if (currentRouteData.DataTokens.ContainsKey(Core.Constants.Web.UmbracoRouteDefinitionDataToken))
+                    return Attempt.Succeed((RouteDefinition)currentRouteData.DataTokens[Core.Constants.Web.UmbracoRouteDefinitionDataToken]);
+            }
+
+            return Attempt<RouteDefinition>.Fail(
+                new InvalidOperationException("Cannot find the Umbraco route definition in the route values, the request must be made in the context of an Umbraco request"));
+        }
+    }
+}
diff --git a/src/Umbraco.Web.Website/RouteDefinition.cs b/src/Umbraco.Web.Website/RouteDefinition.cs
new file mode 100644
index 0000000000..02eab6ae77
--- /dev/null
+++ b/src/Umbraco.Web.Website/RouteDefinition.cs
@@ -0,0 +1,29 @@
+using System;
+using Umbraco.Web.Routing;
+
+namespace Umbraco.Web.Website
+{
+    /// <summary>
+    /// Represents the data required to route to a specific controller/action during an Umbraco request
+    /// </summary>
+    public class RouteDefinition
+    {
+        public string ControllerName { get; set; }
+        public string ActionName { get; set; }
+
+        /// <summary>
+        /// The Controller type found for routing to
+        /// </summary>
+        public Type ControllerType { get; set; }
+
+        /// <summary>
+        /// Everything related to the current content request including the requested content
+        /// </summary>
+        public IPublishedRequest PublishedRequest { get; set; }
+
+        /// <summary>
+        /// Gets/sets whether the current request has a hijacked route/user controller routed for it
+        /// </summary>
+        public bool HasHijackedRoute { get; set; }
+    }
+}
diff --git a/src/Umbraco.Web/Editors/BackOfficeController.cs b/src/Umbraco.Web/Editors/BackOfficeController.cs
index 34a08a37ca..605690444e 100644
--- a/src/Umbraco.Web/Editors/BackOfficeController.cs
+++ b/src/Umbraco.Web/Editors/BackOfficeController.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
@@ -15,7 +14,6 @@ using Umbraco.Core;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
-using Umbraco.Core.Manifest;
 using Umbraco.Web.Models;
 using Umbraco.Web.Mvc;
 using Umbraco.Core.Services;
@@ -23,12 +21,9 @@ using Umbraco.Web.Features;
 using Umbraco.Web.Models.Identity;
 using Umbraco.Web.Security;
 using Constants = Umbraco.Core.Constants;
-using JArray = Newtonsoft.Json.Linq.JArray;
 using Umbraco.Core.Configuration.Grid;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Hosting;
-using Umbraco.Core.IO;
-using Umbraco.Core.Runtime;
 using Umbraco.Core.WebAssets;
 using Umbraco.Web.Trees;
 using Umbraco.Web.WebAssets;
@@ -52,7 +47,6 @@ namespace Umbraco.Web.Editors
         private readonly IContentSettings _contentSettings;
         private readonly TreeCollection _treeCollection;
         private readonly IHostingEnvironment _hostingEnvironment;
-        private readonly IHttpContextAccessor _httpContextAccessor;
         private readonly IRuntimeSettings _runtimeSettings;
         private readonly ISecuritySettings _securitySettings;
         private readonly IRuntimeMinifier _runtimeMinifier;
@@ -84,7 +78,6 @@ namespace Umbraco.Web.Editors
             _contentSettings = contentSettings ?? throw new ArgumentNullException(nameof(contentSettings));
             _treeCollection = treeCollection ?? throw new ArgumentNullException(nameof(treeCollection));
             _hostingEnvironment = hostingEnvironment;
-            _httpContextAccessor = httpContextAccessor;
             _runtimeSettings = settings;
             _securitySettings = securitySettings;
             _runtimeMinifier = runtimeMinifier;
@@ -194,6 +187,7 @@ namespace Umbraco.Web.Editors
         /// </summary>
         /// <param name="culture"></param>
         /// <returns></returns>
+        /// <remarks>Migrated already to .Net Core</remarks>
         [HttpGet]
         public JsonNetResult LocalizedText(string culture = null)
         {
@@ -240,6 +234,7 @@ namespace Umbraco.Web.Editors
             return JavaScript(result);
         }
 
+        /// Migrated already to .Net Core
         [UmbracoAuthorize(Order = 0)]
         [HttpGet]
         public JsonNetResult GetGridConfig()
@@ -257,7 +252,7 @@ namespace Umbraco.Web.Editors
         [MinifyJavaScriptResult(Order = 1)]
         public JavaScriptResult ServerVariables()
         {
-            var serverVars = new BackOfficeServerVariables(Url, _runtimeState, _features, GlobalSettings, _umbracoVersion, _contentSettings, _treeCollection, _httpContextAccessor, _hostingEnvironment, _runtimeSettings, _securitySettings, _runtimeMinifier);
+            var serverVars = new BackOfficeServerVariables(Url, _runtimeState, _features, GlobalSettings, _umbracoVersion, _contentSettings, _treeCollection, _hostingEnvironment, _runtimeSettings, _securitySettings, _runtimeMinifier);
 
             //cache the result if debugging is disabled
             var result = _hostingEnvironment.IsDebugMode
diff --git a/src/Umbraco.Web/Editors/BackOfficeServerVariables.cs b/src/Umbraco.Web/Editors/BackOfficeServerVariables.cs
index 274fb34a33..cf63fc2131 100644
--- a/src/Umbraco.Web/Editors/BackOfficeServerVariables.cs
+++ b/src/Umbraco.Web/Editors/BackOfficeServerVariables.cs
@@ -51,7 +51,6 @@ namespace Umbraco.Web.Editors
             IUmbracoVersion umbracoVersion,
             IContentSettings contentSettings,
             TreeCollection treeCollection,
-            IHttpContextAccessor httpContextAccessor,
             IHostingEnvironment hostingEnvironment,
             IRuntimeSettings settings,
             ISecuritySettings securitySettings,
@@ -64,7 +63,6 @@ namespace Umbraco.Web.Editors
             _umbracoVersion = umbracoVersion;
             _contentSettings = contentSettings ?? throw new ArgumentNullException(nameof(contentSettings));
             _treeCollection = treeCollection ?? throw new ArgumentNullException(nameof(treeCollection));
-            _httpContextAccessor = httpContextAccessor;
             _hostingEnvironment = hostingEnvironment;
             _settings = settings;
             _securitySettings = securitySettings;
diff --git a/src/Umbraco.Web/HtmlHelperBackOfficeExtensions.cs b/src/Umbraco.Web/HtmlHelperBackOfficeExtensions.cs
index e680f155ca..bf1ad35bec 100644
--- a/src/Umbraco.Web/HtmlHelperBackOfficeExtensions.cs
+++ b/src/Umbraco.Web/HtmlHelperBackOfficeExtensions.cs
@@ -46,9 +46,9 @@ namespace Umbraco.Web
         /// These are the bare minimal server variables that are required for the application to start without being authenticated,
         /// we will load the rest of the server vars after the user is authenticated.
         /// </remarks>
-        public static IHtmlString BareMinimumServerVariablesScript(this HtmlHelper html, UrlHelper uri, UmbracoFeatures features, IGlobalSettings globalSettings, IUmbracoVersion umbracoVersion, IContentSettings contentSettings, TreeCollection treeCollection, IHttpContextAccessor httpContextAccessor, IHostingEnvironment hostingEnvironment, IRuntimeSettings settings, ISecuritySettings securitySettings, IRuntimeMinifier runtimeMinifier)
+        public static IHtmlString BareMinimumServerVariablesScript(this HtmlHelper html, UrlHelper uri, UmbracoFeatures features, IGlobalSettings globalSettings, IUmbracoVersion umbracoVersion, IContentSettings contentSettings, TreeCollection treeCollection, IHostingEnvironment hostingEnvironment, IRuntimeSettings settings, ISecuritySettings securitySettings, IRuntimeMinifier runtimeMinifier)
         {
-            var serverVars = new BackOfficeServerVariables(uri, Current.RuntimeState, features, globalSettings, umbracoVersion, contentSettings, treeCollection, httpContextAccessor, hostingEnvironment, settings, securitySettings, runtimeMinifier);
+            var serverVars = new BackOfficeServerVariables(uri, Current.RuntimeState, features, globalSettings, umbracoVersion, contentSettings, treeCollection, hostingEnvironment, settings, securitySettings, runtimeMinifier);
             var minVars = serverVars.BareMinimumServerVariables();
 
             var str = @"<script type=""text/javascript"">
diff --git a/src/Umbraco.Web/Mvc/JsonNetResult.cs b/src/Umbraco.Web/Mvc/JsonNetResult.cs
index da6780451e..c086b5f375 100644
--- a/src/Umbraco.Web/Mvc/JsonNetResult.cs
+++ b/src/Umbraco.Web/Mvc/JsonNetResult.cs
@@ -13,6 +13,7 @@ namespace Umbraco.Web.Mvc
     /// <summary>
     /// Custom json result using newtonsoft json.net
     /// </summary>
+    /// Migrated already to .Net Core
     public class JsonNetResult : ActionResult
     {
         public Encoding ContentEncoding { get; set; }
diff --git a/src/Umbraco.Web/Mvc/RedirectToUmbracoPageResult.cs b/src/Umbraco.Web/Mvc/RedirectToUmbracoPageResult.cs
index 46d6019860..e379f569e0 100644
--- a/src/Umbraco.Web/Mvc/RedirectToUmbracoPageResult.cs
+++ b/src/Umbraco.Web/Mvc/RedirectToUmbracoPageResult.cs
@@ -14,6 +14,7 @@ namespace Umbraco.Web.Mvc
     /// <summary>
     /// Redirects to an Umbraco page by Id or Entity
     /// </summary>
+    /// Migrated already to .Net Core
     public class RedirectToUmbracoPageResult : ActionResult
     {
         private IPublishedContent _publishedContent;
diff --git a/src/Umbraco.Web/Mvc/RedirectToUmbracoUrlResult.cs b/src/Umbraco.Web/Mvc/RedirectToUmbracoUrlResult.cs
index 3690e98790..6f97bff534 100644
--- a/src/Umbraco.Web/Mvc/RedirectToUmbracoUrlResult.cs
+++ b/src/Umbraco.Web/Mvc/RedirectToUmbracoUrlResult.cs
@@ -11,6 +11,7 @@ namespace Umbraco.Web.Mvc
     /// to the current page but the current page is actually a rewritten URL normally done with something like
     /// Server.Transfer. It is also handy if you want to persist the query strings.
     /// </remarks>
+    /// Migrated already to .Net Core
     public class RedirectToUmbracoUrlResult : ActionResult
     {
         private readonly IUmbracoContext _umbracoContext;
diff --git a/src/Umbraco.Web/Mvc/RouteDefinition.cs b/src/Umbraco.Web/Mvc/RouteDefinition.cs
index 94f97e7e11..45e759fd66 100644
--- a/src/Umbraco.Web/Mvc/RouteDefinition.cs
+++ b/src/Umbraco.Web/Mvc/RouteDefinition.cs
@@ -7,6 +7,7 @@ namespace Umbraco.Web.Mvc
     /// <summary>
     /// Represents the data required to route to a specific controller/action during an Umbraco request
     /// </summary>
+    /// Migrated already to .Net Core
     public class RouteDefinition
     {
         public string ControllerName { get; set; }
diff --git a/src/Umbraco.Web/Mvc/SurfaceController.cs b/src/Umbraco.Web/Mvc/SurfaceController.cs
index 877a3c31d8..b9c857a8b3 100644
--- a/src/Umbraco.Web/Mvc/SurfaceController.cs
+++ b/src/Umbraco.Web/Mvc/SurfaceController.cs
@@ -13,6 +13,8 @@ namespace Umbraco.Web.Mvc
     /// <summary>
     /// Provides a base class for front-end add-in controllers.
     /// </summary>
+    /// Migrated already to .Net Core without MergeModelStateToChildAction and MergeParentContextViewData action filters
+    /// TODO: Migrate MergeModelStateToChildAction and MergeParentContextViewData action filters
     [MergeModelStateToChildAction]
     [MergeParentContextViewData]
     public abstract class SurfaceController : PluginController
diff --git a/src/Umbraco.Web/Mvc/UmbracoPageResult.cs b/src/Umbraco.Web/Mvc/UmbracoPageResult.cs
index 75804b47bb..30c990a981 100644
--- a/src/Umbraco.Web/Mvc/UmbracoPageResult.cs
+++ b/src/Umbraco.Web/Mvc/UmbracoPageResult.cs
@@ -10,6 +10,7 @@ namespace Umbraco.Web.Mvc
     /// <summary>
     /// Used by posted forms to proxy the result to the page in which the current URL matches on
     /// </summary>
+    /// Migrated already to .Net Core
     public class UmbracoPageResult : ActionResult
     {
         private readonly IProfilingLogger _profilingLogger;