diff --git a/src/Umbraco.Core/Persistence/Mappers/AccessMapper.cs b/src/Umbraco.Core/Persistence/Mappers/AccessMapper.cs
index 271f208585..33bcdad975 100644
--- a/src/Umbraco.Core/Persistence/Mappers/AccessMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/AccessMapper.cs
@@ -8,8 +8,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(PublicAccessEntry))]
     public sealed class AccessMapper : BaseMapper
     {
-        public AccessMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public AccessMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<PublicAccessEntry, AccessDto>(nameof(PublicAccessEntry.Key), nameof(AccessDto.Id));
             DefineMap<PublicAccessEntry, AccessDto>(nameof(PublicAccessEntry.LoginNodeId), nameof(AccessDto.LoginNodeId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/AuditEntryMapper.cs b/src/Umbraco.Core/Persistence/Mappers/AuditEntryMapper.cs
index 5d23f8edf1..0592a559bb 100644
--- a/src/Umbraco.Core/Persistence/Mappers/AuditEntryMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/AuditEntryMapper.cs
@@ -12,8 +12,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(AuditEntry))]
     public sealed class AuditEntryMapper : BaseMapper
     {
-        public AuditEntryMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public AuditEntryMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<AuditEntry, AuditEntryDto>(nameof(AuditEntry.Id), nameof(AuditEntryDto.Id));
             DefineMap<AuditEntry, AuditEntryDto>(nameof(AuditEntry.PerformingUserId), nameof(AuditEntryDto.PerformingUserId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/AuditItemMapper.cs b/src/Umbraco.Core/Persistence/Mappers/AuditItemMapper.cs
index bada61a097..853cd9f99e 100644
--- a/src/Umbraco.Core/Persistence/Mappers/AuditItemMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/AuditItemMapper.cs
@@ -9,8 +9,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IAuditItem))]
     public sealed class AuditItemMapper : BaseMapper
     {
-        public AuditItemMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public AuditItemMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<AuditItem, LogDto>(nameof(AuditItem.Id), nameof(LogDto.NodeId));
             DefineMap<AuditItem, LogDto>(nameof(AuditItem.CreateDate), nameof(LogDto.Datestamp));
diff --git a/src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs b/src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs
index 3409a5a663..9277b3f926 100644
--- a/src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs
@@ -8,17 +8,43 @@ namespace Umbraco.Core.Persistence.Mappers
 {
     public abstract class BaseMapper : IDiscoverable
     {
-        private readonly ISqlSyntaxProvider _sqlSyntax;
+        // note: using a Lazy<ISqlContext> here because during installs, we are resolving the
+        // mappers way before we have a configured IUmbracoDatabaseFactory, ie way before we
+        // have an ISqlContext - this is some nasty temporal coupling which we might want to
+        // cleanup eventually.
+
+        private readonly Lazy<ISqlContext> _sqlContext;
+        private readonly object _definedLock = new object();
         private readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> _maps;
 
-        protected BaseMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        private ISqlSyntaxProvider _sqlSyntax;
+        private bool _defined;
+
+        protected BaseMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
         {
-            _sqlSyntax = sqlContext.SqlSyntax;
+            _sqlContext = sqlContext;
             _maps = maps;
         }
 
+        protected abstract void DefineMaps();
+
         internal string Map(string propertyName, bool throws = false)
         {
+            lock (_definedLock)
+            {
+                if (!_defined)
+                {
+                    var sqlContext = _sqlContext.Value;
+                    if (sqlContext == null)
+                        throw new InvalidOperationException("Could not get an ISqlContext.");
+                    _sqlSyntax = sqlContext.SqlSyntax;
+
+                    DefineMaps();
+
+                    _defined = true;
+                }
+            }
+
             if (!_maps.TryGetValue(GetType(), out var mapperMaps))
                 throw new InvalidOperationException($"No maps defined for mapper {GetType().FullName}.");
             if (!mapperMaps.TryGetValue(propertyName, out var mappedName))
@@ -26,9 +52,11 @@ namespace Umbraco.Core.Persistence.Mappers
             return mappedName;
         }
 
-        //protected void DefineMap<TSource, TTarget>(string sourceName, Expression<Func<TTarget, object>> targetMember)
         protected void DefineMap<TSource, TTarget>(string sourceName, string targetName)
         {
+            if (_sqlSyntax == null)
+                throw new InvalidOperationException("Do not define maps outside of DefineMaps.");
+
             var sourceType = typeof(TSource);
             var targetType = typeof(TTarget);
 
diff --git a/src/Umbraco.Core/Persistence/Mappers/ConsentMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ConsentMapper.cs
index b8cfefae24..c7eca9909c 100644
--- a/src/Umbraco.Core/Persistence/Mappers/ConsentMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/ConsentMapper.cs
@@ -12,8 +12,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(Consent))]
     public sealed class ConsentMapper : BaseMapper
     {
-        public ConsentMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public ConsentMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Consent, ConsentDto>(nameof(Consent.Id), nameof(ConsentDto.Id));
             DefineMap<Consent, ConsentDto>(nameof(Consent.Current), nameof(ConsentDto.Current));
diff --git a/src/Umbraco.Core/Persistence/Mappers/ContentMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ContentMapper.cs
index 1b75db38ef..f707f27e17 100644
--- a/src/Umbraco.Core/Persistence/Mappers/ContentMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/ContentMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IContent))]
     public sealed class ContentMapper : BaseMapper
     {
-        public ContentMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public ContentMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Content, NodeDto>(nameof(Content.Id), nameof(NodeDto.NodeId));
             DefineMap<Content, NodeDto>(nameof(Content.Key), nameof(NodeDto.UniqueId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/ContentTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ContentTypeMapper.cs
index c87ca1a321..b14fc546c8 100644
--- a/src/Umbraco.Core/Persistence/Mappers/ContentTypeMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/ContentTypeMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IContentType))]
     public sealed class ContentTypeMapper : BaseMapper
     {
-        public ContentTypeMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public ContentTypeMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<ContentType, NodeDto>(nameof(ContentType.Id), nameof(NodeDto.NodeId));
             DefineMap<ContentType, NodeDto>(nameof(ContentType.CreateDate), nameof(NodeDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/DataTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/DataTypeMapper.cs
index 266adb0aeb..5954cb5729 100644
--- a/src/Umbraco.Core/Persistence/Mappers/DataTypeMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/DataTypeMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IDataType))]
     public sealed class DataTypeMapper : BaseMapper
     {
-        public DataTypeMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public DataTypeMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<DataType, NodeDto>(nameof(DataType.Id), nameof(NodeDto.NodeId));
             DefineMap<DataType, NodeDto>(nameof(DataType.CreateDate), nameof(NodeDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/DictionaryMapper.cs b/src/Umbraco.Core/Persistence/Mappers/DictionaryMapper.cs
index 467eb55ebe..f6a0947bd1 100644
--- a/src/Umbraco.Core/Persistence/Mappers/DictionaryMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/DictionaryMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IDictionaryItem))]
     public sealed class DictionaryMapper : BaseMapper
     {
-        public DictionaryMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public DictionaryMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<DictionaryItem, DictionaryDto>(nameof(DictionaryItem.Id), nameof(DictionaryDto.PrimaryKey));
             DefineMap<DictionaryItem, DictionaryDto>(nameof(DictionaryItem.Key), nameof(DictionaryDto.UniqueId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/DictionaryTranslationMapper.cs b/src/Umbraco.Core/Persistence/Mappers/DictionaryTranslationMapper.cs
index 6383604dbe..672c8a4b0a 100644
--- a/src/Umbraco.Core/Persistence/Mappers/DictionaryTranslationMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/DictionaryTranslationMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IDictionaryTranslation))]
     public sealed class DictionaryTranslationMapper : BaseMapper
     {
-        public DictionaryTranslationMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public DictionaryTranslationMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<DictionaryTranslation, LanguageTextDto>(nameof(DictionaryTranslation.Id), nameof(LanguageTextDto.PrimaryKey));
             DefineMap<DictionaryTranslation, LanguageTextDto>(nameof(DictionaryTranslation.Key), nameof(LanguageTextDto.UniqueId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/DomainMapper.cs b/src/Umbraco.Core/Persistence/Mappers/DomainMapper.cs
index 4d91b54691..9106b76f54 100644
--- a/src/Umbraco.Core/Persistence/Mappers/DomainMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/DomainMapper.cs
@@ -9,8 +9,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(UmbracoDomain))]
     public sealed class DomainMapper : BaseMapper
     {
-        public DomainMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public DomainMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<UmbracoDomain, DomainDto>(nameof(UmbracoDomain.Id), nameof(DomainDto.Id));
             DefineMap<UmbracoDomain, DomainDto>(nameof(UmbracoDomain.RootContentId), nameof(DomainDto.RootStructureId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/ExternalLoginMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ExternalLoginMapper.cs
index 3f95dbccc9..223689ec51 100644
--- a/src/Umbraco.Core/Persistence/Mappers/ExternalLoginMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/ExternalLoginMapper.cs
@@ -9,8 +9,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IdentityUserLogin))]
     public sealed class ExternalLoginMapper : BaseMapper
     {
-        public ExternalLoginMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public ExternalLoginMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<IdentityUserLogin, ExternalLoginDto>(nameof(IdentityUserLogin.Id), nameof(ExternalLoginDto.Id));
             DefineMap<IdentityUserLogin, ExternalLoginDto>(nameof(IdentityUserLogin.CreateDate), nameof(ExternalLoginDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/LanguageMapper.cs b/src/Umbraco.Core/Persistence/Mappers/LanguageMapper.cs
index eeb89f9e7c..8941626b79 100644
--- a/src/Umbraco.Core/Persistence/Mappers/LanguageMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/LanguageMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(Language))]
     public sealed class LanguageMapper : BaseMapper
     {
-        public LanguageMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public LanguageMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Language, LanguageDto>(nameof(Language.Id), nameof(LanguageDto.Id));
             DefineMap<Language, LanguageDto>(nameof(Language.IsoCode), nameof(LanguageDto.IsoCode));
diff --git a/src/Umbraco.Core/Persistence/Mappers/MacroMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MacroMapper.cs
index 00eb5ea02f..6a0d803052 100644
--- a/src/Umbraco.Core/Persistence/Mappers/MacroMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/MacroMapper.cs
@@ -9,8 +9,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IMacro))]
     internal sealed class MacroMapper : BaseMapper
     {
-        public MacroMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public MacroMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Macro, MacroDto>(nameof(Macro.Id), nameof(MacroDto.Id));
             DefineMap<Macro, MacroDto>(nameof(Macro.Alias), nameof(MacroDto.Alias));
diff --git a/src/Umbraco.Core/Persistence/Mappers/MediaMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MediaMapper.cs
index 558b5e2eba..e2504594cd 100644
--- a/src/Umbraco.Core/Persistence/Mappers/MediaMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/MediaMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(Umbraco.Core.Models.Media))]
     public sealed class MediaMapper : BaseMapper
     {
-        public MediaMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public MediaMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Models.Media, NodeDto>(nameof(Models.Media.Id), nameof(NodeDto.NodeId));
             DefineMap<Models.Media, NodeDto>(nameof(Models.Media.Key), nameof(NodeDto.UniqueId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/MediaTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MediaTypeMapper.cs
index dabf259ec1..526a2da239 100644
--- a/src/Umbraco.Core/Persistence/Mappers/MediaTypeMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/MediaTypeMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(MediaType))]
     public sealed class MediaTypeMapper : BaseMapper
     {
-        public MediaTypeMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public MediaTypeMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<MediaType, NodeDto>(nameof(MediaType.Id), nameof(NodeDto.NodeId));
             DefineMap<MediaType, NodeDto>(nameof(MediaType.CreateDate), nameof(NodeDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs
index 74fce23b45..f462c449b5 100644
--- a/src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs
@@ -9,8 +9,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof (MemberGroup))]
     public sealed class MemberGroupMapper : BaseMapper
     {
-        public MemberGroupMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public MemberGroupMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<MemberGroup, NodeDto>(nameof(MemberGroup.Id), nameof(NodeDto.NodeId));
             DefineMap<MemberGroup, NodeDto>(nameof(MemberGroup.CreateDate), nameof(NodeDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/MemberMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MemberMapper.cs
index 1a635fd38c..e0f29ce128 100644
--- a/src/Umbraco.Core/Persistence/Mappers/MemberMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/MemberMapper.cs
@@ -14,8 +14,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(Member))]
     public sealed class MemberMapper : BaseMapper
     {
-        public MemberMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public MemberMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Member, NodeDto>(nameof(Member.Id), nameof(NodeDto.NodeId));
             DefineMap<Member, NodeDto>(nameof(Member.CreateDate), nameof(NodeDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/MemberTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MemberTypeMapper.cs
index b25b0cc493..7a6d54c499 100644
--- a/src/Umbraco.Core/Persistence/Mappers/MemberTypeMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/MemberTypeMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof (IMemberType))]
     public sealed class MemberTypeMapper : BaseMapper
     {
-        public MemberTypeMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public MemberTypeMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<MemberType, NodeDto>(nameof(MemberType.Id), nameof(NodeDto.NodeId));
             DefineMap<MemberType, NodeDto>(nameof(MemberType.CreateDate), nameof(NodeDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs
index 02a4790b13..19b5859bcd 100644
--- a/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs
@@ -12,8 +12,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(PropertyGroup))]
     public sealed class PropertyGroupMapper : BaseMapper
     {
-        public PropertyGroupMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public PropertyGroupMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<PropertyGroup, PropertyTypeGroupDto>(nameof(PropertyGroup.Id), nameof(PropertyTypeGroupDto.Id));
             DefineMap<PropertyGroup, PropertyTypeGroupDto>(nameof(PropertyGroup.Key), nameof(PropertyTypeGroupDto.UniqueId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs
index 1c00060652..354f4a2622 100644
--- a/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs
@@ -8,8 +8,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(Property))]
     public sealed class PropertyMapper : BaseMapper
     {
-        public PropertyMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public PropertyMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Property, PropertyDataDto>(nameof(Property.Id), nameof(PropertyDataDto.Id));
             DefineMap<Property, PropertyDataDto>(nameof(Property.PropertyTypeId), nameof(PropertyDataDto.PropertyTypeId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs
index a095a661a8..ab1869a7f5 100644
--- a/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs
@@ -12,8 +12,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(PropertyType))]
     public sealed class PropertyTypeMapper : BaseMapper
     {
-        public PropertyTypeMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public PropertyTypeMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.Key), nameof(PropertyTypeDto.UniqueId));
             DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.Id), nameof(PropertyTypeDto.Id));
diff --git a/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs b/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs
index ab9317d987..c7af941d27 100644
--- a/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(Relation))]
     public sealed class RelationMapper : BaseMapper
     {
-        public RelationMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public RelationMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Relation, RelationDto>(nameof(Relation.Id), nameof(RelationDto.Id));
             DefineMap<Relation, RelationDto>(nameof(Relation.ChildId), nameof(RelationDto.ChildId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs
index e3da443ddf..366a804aa6 100644
--- a/src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IRelationType))]
     public sealed class RelationTypeMapper : BaseMapper
     {
-        public RelationTypeMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public RelationTypeMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<RelationType, RelationTypeDto>(nameof(RelationType.Id), nameof(RelationTypeDto.Id));
             DefineMap<RelationType, RelationTypeDto>(nameof(RelationType.Alias), nameof(RelationTypeDto.Alias));
diff --git a/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs
index eb61499f95..9f3d557e9c 100644
--- a/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs
@@ -9,8 +9,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(IServerRegistration))]
     internal sealed class ServerRegistrationMapper : BaseMapper
     {
-        public ServerRegistrationMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public ServerRegistrationMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<ServerRegistration, ServerRegistrationDto>(nameof(ServerRegistration.Id), nameof(ServerRegistrationDto.Id));
             DefineMap<ServerRegistration, ServerRegistrationDto>(nameof(ServerRegistration.IsActive), nameof(ServerRegistrationDto.IsActive));
diff --git a/src/Umbraco.Core/Persistence/Mappers/SimpleContentTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/SimpleContentTypeMapper.cs
index f4272dc25e..f98ff3b694 100644
--- a/src/Umbraco.Core/Persistence/Mappers/SimpleContentTypeMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/SimpleContentTypeMapper.cs
@@ -9,8 +9,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(SimpleContentType))]
     public sealed class SimpleContentTypeMapper : BaseMapper
     {
-        public SimpleContentTypeMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public SimpleContentTypeMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<ContentType, NodeDto>(nameof(ContentType.Id), nameof(NodeDto.NodeId));
             DefineMap<ContentType, NodeDto>(nameof(ContentType.CreateDate), nameof(NodeDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/TagMapper.cs b/src/Umbraco.Core/Persistence/Mappers/TagMapper.cs
index 3074377b8f..88849e0444 100644
--- a/src/Umbraco.Core/Persistence/Mappers/TagMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/TagMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(ITag))]
     public sealed class TagMapper : BaseMapper
     {
-        public TagMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public TagMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Tag, TagDto>(nameof(Tag.Id), nameof(TagDto.Id));
             DefineMap<Tag, TagDto>(nameof(Tag.Text), nameof(TagDto.Text));
diff --git a/src/Umbraco.Core/Persistence/Mappers/TemplateMapper.cs b/src/Umbraco.Core/Persistence/Mappers/TemplateMapper.cs
index 46ced0bba0..b9defdee6a 100644
--- a/src/Umbraco.Core/Persistence/Mappers/TemplateMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/TemplateMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(ITemplate))]
     public sealed class TemplateMapper : BaseMapper
     {
-        public TemplateMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public TemplateMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<Template, TemplateDto>(nameof(Template.Id), nameof(TemplateDto.NodeId));
             DefineMap<Template, NodeDto>(nameof(Template.MasterTemplateId), nameof(NodeDto.ParentId));
diff --git a/src/Umbraco.Core/Persistence/Mappers/UmbracoEntityMapper.cs b/src/Umbraco.Core/Persistence/Mappers/UmbracoEntityMapper.cs
index a442a52fb3..16e2e8bcd5 100644
--- a/src/Umbraco.Core/Persistence/Mappers/UmbracoEntityMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/UmbracoEntityMapper.cs
@@ -8,8 +8,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof (IUmbracoEntity))]
     public sealed class UmbracoEntityMapper : BaseMapper
     {
-        public UmbracoEntityMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public UmbracoEntityMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<IUmbracoEntity, NodeDto>(nameof(IUmbracoEntity.Id), nameof(NodeDto.NodeId));
             DefineMap<IUmbracoEntity, NodeDto>(nameof(IUmbracoEntity.CreateDate), nameof(NodeDto.CreateDate));
diff --git a/src/Umbraco.Core/Persistence/Mappers/UserGroupMapper.cs b/src/Umbraco.Core/Persistence/Mappers/UserGroupMapper.cs
index ad0938b911..75d34e4081 100644
--- a/src/Umbraco.Core/Persistence/Mappers/UserGroupMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/UserGroupMapper.cs
@@ -13,8 +13,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(UserGroup))]
     public sealed class UserGroupMapper : BaseMapper
     {
-        public UserGroupMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public UserGroupMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<UserGroup, UserGroupDto>(nameof(UserGroup.Id), nameof(UserGroupDto.Id));
             DefineMap<UserGroup, UserGroupDto>(nameof(UserGroup.Alias), nameof(UserGroupDto.Alias));
diff --git a/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs b/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs
index 47b95eb17a..4f92b5c224 100644
--- a/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs
@@ -9,8 +9,11 @@ namespace Umbraco.Core.Persistence.Mappers
     [MapperFor(typeof(User))]
     public sealed class UserMapper : BaseMapper
     {
-        public UserMapper(ISqlContext sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
+        public UserMapper(Lazy<ISqlContext> sqlContext, ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> maps)
             : base(sqlContext, maps)
+        { }
+
+        protected override void DefineMaps()
         {
             DefineMap<User, UserDto>(nameof(User.Id), nameof(UserDto.Id));
             DefineMap<User, UserDto>(nameof(User.Email), nameof(UserDto.Email));
diff --git a/src/Umbraco.Tests.Benchmarks/ModelToSqlExpressionHelperBenchmarks.cs b/src/Umbraco.Tests.Benchmarks/ModelToSqlExpressionHelperBenchmarks.cs
index 4cd7c964b0..bd36013c9f 100644
--- a/src/Umbraco.Tests.Benchmarks/ModelToSqlExpressionHelperBenchmarks.cs
+++ b/src/Umbraco.Tests.Benchmarks/ModelToSqlExpressionHelperBenchmarks.cs
@@ -15,12 +15,12 @@ namespace Umbraco.Tests.Benchmarks
     [MemoryDiagnoser]
     public class ModelToSqlExpressionHelperBenchmarks
     {
-        protected ISqlContext MockSqlContext()
+        protected Lazy<ISqlContext> MockSqlContext()
         {
             var sqlContext = Mock.Of<ISqlContext>();
             var syntax = new SqlCeSyntaxProvider();
             Mock.Get(sqlContext).Setup(x => x.SqlSyntax).Returns(syntax);
-            return sqlContext;
+            return new Lazy<ISqlContext>(() => sqlContext);
         }
 
         protected ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> CreateMaps()
diff --git a/src/Umbraco.Tests/Persistence/Mappers/MapperTestBase.cs b/src/Umbraco.Tests/Persistence/Mappers/MapperTestBase.cs
index f4d3eb3cdc..d4a61155a9 100644
--- a/src/Umbraco.Tests/Persistence/Mappers/MapperTestBase.cs
+++ b/src/Umbraco.Tests/Persistence/Mappers/MapperTestBase.cs
@@ -8,15 +8,15 @@ namespace Umbraco.Tests.Persistence.Mappers
 {
     public class MapperTestBase
     {
-        protected ISqlContext MockSqlContext()
+        protected Lazy<ISqlContext> MockSqlContext()
         {
             var sqlContext = Mock.Of<ISqlContext>();
             var syntax = new SqlCeSyntaxProvider();
             Mock.Get(sqlContext).Setup(x => x.SqlSyntax).Returns(syntax);
-            return sqlContext;
+            return new Lazy<ISqlContext>(() => sqlContext);
         }
 
         protected ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> CreateMaps()
             => new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>();
     }
-}
\ No newline at end of file
+}
diff --git a/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs b/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs
index efb6c5ac7a..a4c3078b8f 100644
--- a/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs
+++ b/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs
@@ -125,7 +125,7 @@ namespace Umbraco.Tests.Web.Controllers
 
             var mappers = new MapperCollection(new []
             {
-                new UserMapper(Current.SqlContext, new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>())
+                new UserMapper(new Lazy<ISqlContext>(() => Current.SqlContext), new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>())
             });
 
             Mock.Get(Current.SqlContext)