diff --git a/src/Umbraco.Core/Security/BackOfficeUserManager.cs b/src/Umbraco.Core/Security/BackOfficeUserManager.cs
index e48079c10b..69be7b60c2 100644
--- a/src/Umbraco.Core/Security/BackOfficeUserManager.cs
+++ b/src/Umbraco.Core/Security/BackOfficeUserManager.cs
@@ -32,25 +32,29 @@ namespace Umbraco.Core.Security
         }
 
         #region Static Create methods
+
         /// <summary>
         /// Creates a BackOfficeUserManager instance with all default options and the default BackOfficeUserManager 
         /// </summary>
         /// <param name="options"></param>
         /// <param name="userService"></param>
+        /// <param name="memberTypeService"></param>
         /// <param name="externalLoginService"></param>
         /// <param name="membershipProvider"></param>
         /// <returns></returns>
         public static BackOfficeUserManager Create(
             IdentityFactoryOptions<BackOfficeUserManager> options,
             IUserService userService,
+            IMemberTypeService memberTypeService,
             IExternalLoginService externalLoginService,
             MembershipProviderBase membershipProvider)
         {
             if (options == null) throw new ArgumentNullException("options");
             if (userService == null) throw new ArgumentNullException("userService");
+            if (memberTypeService == null) throw new ArgumentNullException("memberTypeService");
             if (externalLoginService == null) throw new ArgumentNullException("externalLoginService");
 
-            var manager = new BackOfficeUserManager(new BackOfficeUserStore(userService, externalLoginService, membershipProvider));
+            var manager = new BackOfficeUserManager(new BackOfficeUserStore(userService, memberTypeService, externalLoginService, membershipProvider));
             manager.InitUserManager(manager, membershipProvider, options);
             return manager;
         }
diff --git a/src/Umbraco.Core/Security/BackOfficeUserStore.cs b/src/Umbraco.Core/Security/BackOfficeUserStore.cs
index c6714e256a..40c532976e 100644
--- a/src/Umbraco.Core/Security/BackOfficeUserStore.cs
+++ b/src/Umbraco.Core/Security/BackOfficeUserStore.cs
@@ -30,12 +30,14 @@ namespace Umbraco.Core.Security
         //IQueryableUserStore<BackOfficeIdentityUser, int>
     {
         private readonly IUserService _userService;
+        private readonly IMemberTypeService _memberTypeService;
         private readonly IExternalLoginService _externalLoginService;
         private bool _disposed = false;
 
-        public BackOfficeUserStore(IUserService userService, IExternalLoginService externalLoginService, MembershipProviderBase usersMembershipProvider)
+        public BackOfficeUserStore(IUserService userService, IMemberTypeService memberTypeService, IExternalLoginService externalLoginService, MembershipProviderBase usersMembershipProvider)
         {
             _userService = userService;
+            _memberTypeService = memberTypeService;
             _externalLoginService = externalLoginService;
             if (userService == null) throw new ArgumentNullException("userService");
             if (usersMembershipProvider == null) throw new ArgumentNullException("usersMembershipProvider");
@@ -69,7 +71,7 @@ namespace Umbraco.Core.Security
             if (user == null) throw new ArgumentNullException("user");
 
             var userType = _userService.GetUserTypeByAlias(
-                user.UserTypeAlias.IsNullOrWhiteSpace() ? _userService.GetDefaultMemberType() : user.UserTypeAlias);
+                user.UserTypeAlias.IsNullOrWhiteSpace() ? _memberTypeService.GetDefault() : user.UserTypeAlias);
 
             var member = new User(userType)
             {
diff --git a/src/Umbraco.Core/Services/ContentService.cs b/src/Umbraco.Core/Services/ContentService.cs
index 63e9092402..2f5bd9ea75 100644
--- a/src/Umbraco.Core/Services/ContentService.cs
+++ b/src/Umbraco.Core/Services/ContentService.cs
@@ -22,7 +22,6 @@ namespace Umbraco.Core.Services
     /// </summary>
     public class ContentService : RepositoryService, IContentService, IContentServiceOperations
     {
-        private IContentTypeService _contentTypeService;
 
         #region Constructors
 
@@ -34,20 +33,6 @@ namespace Umbraco.Core.Services
         {
         }
 
-        // don't change or remove this, will need it later
-        private IContentTypeService ContentTypeService => _contentTypeService;
-        //// handle circular dependencies
-        //internal IContentTypeService ContentTypeService
-        //{
-        //    get
-        //    {
-        //        if (_contentTypeService == null)
-        //            throw new InvalidOperationException("ContentService.ContentTypeService has not been initialized.");
-        //        return _contentTypeService;
-        //    }
-        //    set { _contentTypeService = value; }
-        //}
-
         #endregion
 
         #region Count
@@ -332,6 +317,8 @@ namespace Umbraco.Core.Services
                 var repo = uow.CreateRepository<IContentRepository>();
                 repo.AddOrUpdate(content);
 
+                uow.Flush(); // need everything so we can serialize
+
                 Saved.RaiseEvent(new SaveEventArgs<IContent>(content, false), this);
                 TreeChanged.RaiseEvent(new TreeChange<IContent>(content, TreeChangeTypes.RefreshNode).ToEventArgs(), this);
             }
@@ -2545,7 +2532,7 @@ namespace Umbraco.Core.Services
 
             using (var uow = UowProvider.CreateUnitOfWork())
             {
-                uow.ReadLock(Constants.Locks.ContentTree);
+                uow.ReadLock(Constants.Locks.ContentTypes);
 
                 var repository = uow.CreateRepository<IContentTypeRepository>();
                 var query = repository.Query.Where(x => x.Alias == contentTypeAlias);
diff --git a/src/Umbraco.Core/Services/ContentTypeService.cs b/src/Umbraco.Core/Services/ContentTypeService.cs
index 1c0d38410f..430aadb083 100644
--- a/src/Umbraco.Core/Services/ContentTypeService.cs
+++ b/src/Umbraco.Core/Services/ContentTypeService.cs
@@ -13,33 +13,18 @@ namespace Umbraco.Core.Services
     /// </summary>
     internal class ContentTypeService : ContentTypeServiceBase<IContentTypeRepository, IContentType, IContentTypeService>, IContentTypeService
     {
-	    private IContentService _contentService;
-
         public ContentTypeService(IDatabaseUnitOfWorkProvider provider, ILogger logger, IEventMessagesFactory eventMessagesFactory, IContentService contentService)
             : base(provider, logger, eventMessagesFactory)
         {
-            _contentService = contentService;
+            ContentService = contentService;
         }
 
         protected override IContentTypeService Instance => this;
-
         // beware! order is important to avoid deadlocks
         protected override int[] ReadLockIds { get; } = { Constants.Locks.ContentTypes };
         protected override int[] WriteLockIds { get; } = { Constants.Locks.ContentTree, Constants.Locks.ContentTypes };
 
-        // don't change or remove this, will need it later
-        private IContentService ContentService => _contentService;
-        //// handle circular dependencies
-        //internal IContentService ContentService
-        //{
-        //    get
-        //    {
-        //        if (_contentService == null)
-        //            throw new InvalidOperationException("ContentTypeService.ContentService has not been initialized.");
-        //        return _contentService;
-        //    }
-        //    set { _contentService = value; }
-        //}
+        private IContentService ContentService { get; }
 
         protected override Guid ContainedObjectType => Constants.ObjectTypes.DocumentTypeGuid;
 
diff --git a/src/Umbraco.Core/Services/IMembershipMemberService.cs b/src/Umbraco.Core/Services/IMembershipMemberService.cs
index 4698ffd966..8a64198b9e 100644
--- a/src/Umbraco.Core/Services/IMembershipMemberService.cs
+++ b/src/Umbraco.Core/Services/IMembershipMemberService.cs
@@ -46,14 +46,6 @@ namespace Umbraco.Core.Services
         /// <returns><see cref="System.int"/> with number of Members or Users for passed in type</returns>
         int GetCount(MemberCountType countType);
 
-        /// <summary>
-        /// Gets the default MemberType alias
-        /// </summary>
-        /// <remarks>By default we'll return the 'writer', but we need to check it exists. If it doesn't we'll 
-        /// return the first type that is not an admin, otherwise if there's only one we will return that one.</remarks>
-        /// <returns>Alias of the default MemberType</returns>
-        string GetDefaultMemberType();
-
         /// <summary>
         /// Checks if a Member with the username exists
         /// </summary>
diff --git a/src/Umbraco.Core/Services/MediaService.cs b/src/Umbraco.Core/Services/MediaService.cs
index 8792c35852..74543e2cb7 100644
--- a/src/Umbraco.Core/Services/MediaService.cs
+++ b/src/Umbraco.Core/Services/MediaService.cs
@@ -19,7 +19,6 @@ namespace Umbraco.Core.Services
     /// </summary>
     public class MediaService : RepositoryService, IMediaService, IMediaServiceOperations
     {
-        private IMediaTypeService _mediaTypeService;
 
         #region Constructors
 
@@ -30,20 +29,6 @@ namespace Umbraco.Core.Services
             : base(provider, logger, eventMessagesFactory)
         { }
 
-        // don't change or remove this, will need it later
-        private IMediaTypeService MediaTypeService => _mediaTypeService;
-        //// handle circular dependencies
-        //internal IMediaTypeService MediaTypeService
-        //{
-        //    get
-        //    {
-        //        if (_mediaTypeService == null)
-        //            throw new InvalidOperationException("MediaService.MediaTypeService has not been initialized.");
-        //        return _mediaTypeService;
-        //    }
-        //    set { _mediaTypeService = value; }
-        //}
-
         #endregion
 
         #region Count
@@ -1363,7 +1348,7 @@ namespace Umbraco.Core.Services
 
             using (var uow = UowProvider.CreateUnitOfWork())
             {
-                uow.ReadLock(Constants.Locks.MediaTree);
+                uow.ReadLock(Constants.Locks.MediaTypes);
 
                 var repository = uow.CreateRepository<IMediaTypeRepository>();
                 var query = repository.Query.Where(x => x.Alias == mediaTypeAlias);
diff --git a/src/Umbraco.Core/Services/MediaTypeService.cs b/src/Umbraco.Core/Services/MediaTypeService.cs
index 0eeccb4f5b..ddc29a84c6 100644
--- a/src/Umbraco.Core/Services/MediaTypeService.cs
+++ b/src/Umbraco.Core/Services/MediaTypeService.cs
@@ -10,12 +10,10 @@ namespace Umbraco.Core.Services
 {
     internal class MediaTypeService : ContentTypeServiceBase<IMediaTypeRepository, IMediaType, IMediaTypeService>, IMediaTypeService
     {
-        private IMediaService _mediaService;
-
         public MediaTypeService(IDatabaseUnitOfWorkProvider provider, ILogger logger, IEventMessagesFactory eventMessagesFactory, IMediaService mediaService)
             : base(provider, logger, eventMessagesFactory)
         {
-            _mediaService = mediaService;
+            MediaService = mediaService;
         }
 
         protected override IMediaTypeService Instance => this;
@@ -24,19 +22,7 @@ namespace Umbraco.Core.Services
         protected override int[] ReadLockIds { get; } = { Constants.Locks.MediaTypes };
         protected override int[] WriteLockIds { get; } = { Constants.Locks.MediaTree, Constants.Locks.MediaTypes };
 
-        // don't remove, will need it later
-        private IMediaService MediaService => _mediaService;
-        //// handle circular dependencies
-        //internal IMediaService MediaService
-        //{
-        //    get
-        //    {
-        //        if (_mediaService == null)
-        //            throw new InvalidOperationException("MediaTypeService.MediaService has not been initialized.");
-        //        return _mediaService;
-        //    }
-        //    set { _mediaService = value; }
-        //}
+        private IMediaService MediaService { get; }
 
         protected override Guid ContainedObjectType => Constants.ObjectTypes.MediaTypeGuid;
 
diff --git a/src/Umbraco.Core/Services/MemberService.cs b/src/Umbraco.Core/Services/MemberService.cs
index 6b0ba8f33f..be33a956f9 100644
--- a/src/Umbraco.Core/Services/MemberService.cs
+++ b/src/Umbraco.Core/Services/MemberService.cs
@@ -22,7 +22,6 @@ namespace Umbraco.Core.Services
     public class MemberService : RepositoryService, IMemberService
     {
         private readonly IMemberGroupService _memberGroupService;
-        private IMemberTypeService _memberTypeService;
 
         #region Constructor
 
@@ -37,20 +36,6 @@ namespace Umbraco.Core.Services
             _memberGroupService = memberGroupService;
         }
 
-        // don't change or remove this, will need it later
-        private IMemberTypeService MemberTypeService => _memberTypeService;
-        //// handle circular dependencies
-        //internal IMemberTypeService MemberTypeService
-        //{
-        //    get
-        //    {
-        //        if (_memberTypeService == null)
-        //            throw new InvalidOperationException("MemberService.MemberTypeService has not been initialized.");
-        //        return _memberTypeService;
-        //    }
-        //    set { _memberTypeService = value; }
-        //}
-
         #endregion
 
         #region Count
@@ -1329,16 +1314,21 @@ namespace Umbraco.Core.Services
 
         private IMemberType GetMemberType(string memberTypeAlias)
         {
-            var memberType = MemberTypeService.Get(memberTypeAlias);
-            if (memberType == null)
-                throw new Exception(string.Format("No MemberType matching alias: \"{0}\".", memberTypeAlias));
-            return memberType;
-        }
+            Mandate.ParameterNotNullOrEmpty(memberTypeAlias, nameof(memberTypeAlias));
 
-        [Obsolete("use MemberTypeService.GetDefault()")] // fixme kill!
-        public string GetDefaultMemberType()
-        {
-            return MemberTypeService.GetDefault();
+            using (var uow = UowProvider.CreateUnitOfWork())
+            {
+                uow.ReadLock(Constants.Locks.MemberTypes);
+
+                var repository = uow.CreateRepository<IMemberTypeRepository>();
+                var memberType = repository.Get(memberTypeAlias);
+
+                if (memberType == null)
+                    throw new Exception($"No MemberType matching the passed in Alias: '{memberTypeAlias}' was found"); // causes rollback
+
+                uow.Complete();
+                return memberType;
+            }
         }
 
         #endregion
diff --git a/src/Umbraco.Core/Services/MemberTypeService.cs b/src/Umbraco.Core/Services/MemberTypeService.cs
index 2fbe8b1784..ff27fc1d3a 100644
--- a/src/Umbraco.Core/Services/MemberTypeService.cs
+++ b/src/Umbraco.Core/Services/MemberTypeService.cs
@@ -10,12 +10,10 @@ namespace Umbraco.Core.Services
 {
     internal class MemberTypeService : ContentTypeServiceBase<IMemberTypeRepository, IMemberType, IMemberTypeService>, IMemberTypeService
     {
-        private IMemberService _memberService;
-
         public MemberTypeService(IDatabaseUnitOfWorkProvider provider, ILogger logger, IEventMessagesFactory eventMessagesFactory, IMemberService memberService)
             : base(provider, logger, eventMessagesFactory)
         {
-            _memberService = memberService;
+            MemberService = memberService;
         }
 
         protected override IMemberTypeService Instance => this;
@@ -24,19 +22,7 @@ namespace Umbraco.Core.Services
         protected override int[] ReadLockIds { get; } = { Constants.Locks.MemberTypes };
         protected override int[] WriteLockIds { get; } = { Constants.Locks.MemberTree, Constants.Locks.MemberTypes };
 
-        // don't remove, will need it later
-        private IMemberService MemberService => _memberService;
-        //// handle circular dependencies
-        //internal IMemberService MemberService
-        //{
-        //    get
-        //    {
-        //        if (_memberService == null)
-        //            throw new InvalidOperationException("MemberTypeService.MemberService has not been initialized.");
-        //        return _memberService;
-        //    }
-        //    set { _memberService = value; }
-        //}
+        private IMemberService MemberService { get; }
 
         protected override Guid ContainedObjectType => Constants.ObjectTypes.MemberTypeGuid;
 
diff --git a/src/Umbraco.Tests/Membership/UmbracoServiceMembershipProviderTests.cs b/src/Umbraco.Tests/Membership/UmbracoServiceMembershipProviderTests.cs
index 72900351b2..f0525ff55b 100644
--- a/src/Umbraco.Tests/Membership/UmbracoServiceMembershipProviderTests.cs
+++ b/src/Umbraco.Tests/Membership/UmbracoServiceMembershipProviderTests.cs
@@ -18,20 +18,20 @@ namespace Umbraco.Tests.Membership
         [Test]
         public void Sets_Default_Member_Type_From_Service_On_Init()
         {
-            var mServiceMock = new Mock<IMembershipMemberService>();
-            var provider = new MembersMembershipProvider(mServiceMock.Object);
-            mServiceMock.Setup(service => service.GetDefaultMemberType()).Returns("Blah");
+            var memberTypeServiceMock = new Mock<IMemberTypeService>();
+            memberTypeServiceMock.Setup(x => x.GetDefault()).Returns("Blah");
+            var provider = new MembersMembershipProvider(Mock.Of<IMembershipMemberService>(), memberTypeServiceMock.Object);
             provider.Initialize("test", new NameValueCollection());
-            
+
             Assert.AreEqual("Blah", provider.DefaultMemberTypeAlias);
         }
 
         [Test]
         public void Sets_Default_Member_Type_From_Config_On_Init()
         {
-            var mServiceMock = new Mock<IMembershipMemberService>();
-            var provider = new MembersMembershipProvider(mServiceMock.Object);
-            mServiceMock.Setup(service => service.GetDefaultMemberType()).Returns("Blah");
+            var memberTypeServiceMock = new Mock<IMemberTypeService>();
+            memberTypeServiceMock.Setup(x => x.GetDefault()).Returns("Blah");
+            var provider = new MembersMembershipProvider(Mock.Of<IMembershipMemberService>(), memberTypeServiceMock.Object);
             provider.Initialize("test", new NameValueCollection { { "defaultMemberTypeAlias", "Hello" } });
 
             Assert.AreEqual("Hello", provider.DefaultMemberTypeAlias);
@@ -40,11 +40,12 @@ namespace Umbraco.Tests.Membership
         [Test]
         public void Create_User_Already_Exists()
         {
-            var mServiceMock = new Mock<IMembershipMemberService>();
-            mServiceMock.Setup(service => service.Exists("test")).Returns(true);
-            mServiceMock.Setup(service => service.GetDefaultMemberType()).Returns("Member");
+            var memberTypeServiceMock = new Mock<IMemberTypeService>();
+            memberTypeServiceMock.Setup(x => x.GetDefault()).Returns("Member");
+            var membershipServiceMock = new Mock<IMembershipMemberService>();
+            membershipServiceMock.Setup(service => service.Exists("test")).Returns(true);
 
-            var provider = new MembersMembershipProvider(mServiceMock.Object);
+            var provider = new MembersMembershipProvider(membershipServiceMock.Object, memberTypeServiceMock.Object);
             provider.Initialize("test", new NameValueCollection());
 
             MembershipCreateStatus status;
@@ -56,11 +57,12 @@ namespace Umbraco.Tests.Membership
         [Test]
         public void Create_User_Requires_Unique_Email()
         {
-            var mServiceMock = new Mock<IMembershipMemberService>();
-            mServiceMock.Setup(service => service.GetByEmail("test@test.com")).Returns(() => new Member("test", MockedContentTypes.CreateSimpleMemberType()));
-            mServiceMock.Setup(service => service.GetDefaultMemberType()).Returns("Member");
+            var memberTypeServiceMock = new Mock<IMemberTypeService>();
+            memberTypeServiceMock.Setup(x => x.GetDefault()).Returns("Member");
+            var membershipServiceMock = new Mock<IMembershipMemberService>();
+            membershipServiceMock.Setup(service => service.GetByEmail("test@test.com")).Returns(() => new Member("test", MockedContentTypes.CreateSimpleMemberType()));
 
-            var provider = new MembersMembershipProvider(mServiceMock.Object);
+            var provider = new MembersMembershipProvider(membershipServiceMock.Object, memberTypeServiceMock.Object);
             provider.Initialize("test", new NameValueCollection { { "requiresUniqueEmail", "true" } });
 
             MembershipCreateStatus status;
@@ -78,20 +80,21 @@ namespace Umbraco.Tests.Membership
             {
                 memberType.AddPropertyType(p.Value);
             }
-            var mServiceMock = new Mock<IMembershipMemberService>();
-            mServiceMock.Setup(service => service.Exists("test")).Returns(false);
-            mServiceMock.Setup(service => service.GetByEmail("test@test.com")).Returns(() => null);
-            mServiceMock.Setup(service => service.GetDefaultMemberType()).Returns("Member");
-            mServiceMock.Setup(
+            var memberTypeServiceMock = new Mock<IMemberTypeService>();
+            memberTypeServiceMock.Setup(x => x.GetDefault()).Returns("Member");
+            var membershipServiceMock = new Mock<IMembershipMemberService>();
+            membershipServiceMock.Setup(service => service.Exists("test")).Returns(false);
+            membershipServiceMock.Setup(service => service.GetByEmail("test@test.com")).Returns(() => null);
+            membershipServiceMock.Setup(
                 service => service.CreateWithIdentity(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
                         .Callback((string u, string e, string p, string m) =>
                             {
                                 createdMember = new Member("test", e, u, p, memberType);
                             })
                         .Returns(() => createdMember);
-            var provider = new MembersMembershipProvider(mServiceMock.Object);            
+            var provider = new MembersMembershipProvider(membershipServiceMock.Object, memberTypeServiceMock.Object);
             provider.Initialize("test", new NameValueCollection());
-            
+
 
             MembershipCreateStatus status;
             provider.CreateUser("test", "test", "testtest$1", "test@test.com", "test", "test", true, "test", out status);
@@ -109,11 +112,12 @@ namespace Umbraco.Tests.Membership
             {
                 memberType.AddPropertyType(p.Value);
             }
-            var mServiceMock = new Mock<IMembershipMemberService>();
-            mServiceMock.Setup(service => service.Exists("test")).Returns(false);
-            mServiceMock.Setup(service => service.GetByEmail("test@test.com")).Returns(() => null);
-            mServiceMock.Setup(service => service.GetDefaultMemberType()).Returns("Member");
-            mServiceMock.Setup(
+            var memberTypeServiceMock = new Mock<IMemberTypeService>();
+            memberTypeServiceMock.Setup(x => x.GetDefault()).Returns("Member");
+            var membershipServiceMock = new Mock<IMembershipMemberService>();
+            membershipServiceMock.Setup(service => service.Exists("test")).Returns(false);
+            membershipServiceMock.Setup(service => service.GetByEmail("test@test.com")).Returns(() => null);
+            membershipServiceMock.Setup(
                 service => service.CreateWithIdentity(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
                         .Callback((string u, string e, string p, string m) =>
                             {
@@ -121,9 +125,9 @@ namespace Umbraco.Tests.Membership
                             })
                         .Returns(() => createdMember);
 
-            var provider = new MembersMembershipProvider(mServiceMock.Object);
+            var provider = new MembersMembershipProvider(membershipServiceMock.Object, memberTypeServiceMock.Object);
             provider.Initialize("test", new NameValueCollection { { "passwordFormat", "Encrypted" } });
-            
+
 
             MembershipCreateStatus status;
             provider.CreateUser("test", "test", "testtest$1", "test@test.com", "test", "test", true, "test", out status);
@@ -142,11 +146,12 @@ namespace Umbraco.Tests.Membership
             {
                 memberType.AddPropertyType(p.Value);
             }
-            var mServiceMock = new Mock<IMembershipMemberService>();
-            mServiceMock.Setup(service => service.Exists("test")).Returns(false);
-            mServiceMock.Setup(service => service.GetByEmail("test@test.com")).Returns(() => null);
-            mServiceMock.Setup(service => service.GetDefaultMemberType()).Returns("Member");
-            mServiceMock.Setup(
+            var memberTypeServiceMock = new Mock<IMemberTypeService>();
+            memberTypeServiceMock.Setup(x => x.GetDefault()).Returns("Member");
+            var membershipServiceMock = new Mock<IMembershipMemberService>();
+            membershipServiceMock.Setup(service => service.Exists("test")).Returns(false);
+            membershipServiceMock.Setup(service => service.GetByEmail("test@test.com")).Returns(() => null);
+            membershipServiceMock.Setup(
                 service => service.CreateWithIdentity(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
                         .Callback((string u, string e, string p, string m) =>
                         {
@@ -154,20 +159,20 @@ namespace Umbraco.Tests.Membership
                         })
                         .Returns(() => createdMember);
 
-            var provider = new MembersMembershipProvider(mServiceMock.Object);
+            var provider = new MembersMembershipProvider(membershipServiceMock.Object, memberTypeServiceMock.Object);
             provider.Initialize("test", new NameValueCollection { { "passwordFormat", "Hashed" }, { "hashAlgorithmType", "HMACSHA256" } });
-            
+
 
             MembershipCreateStatus status;
             provider.CreateUser("test", "test", "testtest$1", "test@test.com", "test", "test", true, "test", out status);
 
             Assert.AreNotEqual("test", createdMember.RawPasswordValue);
-            
+
             string salt;
             var storedPassword = provider.StoredPassword(createdMember.RawPasswordValue, out salt);
             var hashedPassword = provider.EncryptOrHashPassword("testtest$1", salt);
             Assert.AreEqual(hashedPassword, storedPassword);
         }
-        
+
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web.UI/config/ClientDependency.config b/src/Umbraco.Web.UI/config/ClientDependency.config
index 9e2c84c52d..3fb38db592 100644
--- a/src/Umbraco.Web.UI/config/ClientDependency.config
+++ b/src/Umbraco.Web.UI/config/ClientDependency.config
@@ -10,7 +10,7 @@ NOTES:
 * Compression/Combination/Minification is not enabled unless debug="false" is specified on the 'compiliation' element in the web.config
 * A new version will invalidate both client and server cache and create new persisted files
 --> 
-<clientDependency version="1187893721" fileDependencyExtensions=".js,.css" loggerType="Umbraco.Web.UI.CdfLogger, umbraco">
+<clientDependency version="304117493" fileDependencyExtensions=".js,.css" loggerType="Umbraco.Web.UI.CdfLogger, umbraco">
 
   <!-- 
     This section is used for Web Forms only, the enableCompositeFiles="true" is optional and by default is set to true.
diff --git a/src/Umbraco.Web/Security/Identity/AppBuilderExtensions.cs b/src/Umbraco.Web/Security/Identity/AppBuilderExtensions.cs
index be4c8923d7..4e65d35ecc 100644
--- a/src/Umbraco.Web/Security/Identity/AppBuilderExtensions.cs
+++ b/src/Umbraco.Web/Security/Identity/AppBuilderExtensions.cs
@@ -72,6 +72,7 @@ namespace Umbraco.Web.Security.Identity
                 (options, owinContext) => BackOfficeUserManager.Create(
                     options,
                     appContext.Services.UserService,
+                    appContext.Services.MemberTypeService,
                     appContext.Services.ExternalLoginService,
                     userMembershipProvider));
 
diff --git a/src/Umbraco.Web/Security/Providers/MembersMembershipProvider.cs b/src/Umbraco.Web/Security/Providers/MembersMembershipProvider.cs
index 4576b36da9..c5ddf795e1 100644
--- a/src/Umbraco.Web/Security/Providers/MembersMembershipProvider.cs
+++ b/src/Umbraco.Web/Security/Providers/MembersMembershipProvider.cs
@@ -21,11 +21,11 @@ namespace Umbraco.Web.Security.Providers
     public class MembersMembershipProvider : UmbracoMembershipProvider<IMembershipMemberService, IMember>, IUmbracoMemberTypeMembershipProvider
     {
         public MembersMembershipProvider()
-            : this(ApplicationContext.Current.Services.MemberService)
+            : this(ApplicationContext.Current.Services.MemberService, ApplicationContext.Current.Services.MemberTypeService)
         {
         }
 
-        public MembersMembershipProvider(IMembershipMemberService<IMember> memberService)
+        public MembersMembershipProvider(IMembershipMemberService<IMember> memberService, IMemberTypeService memberTypeService)
             : base(memberService)
         {
             LockPropertyTypeAlias = Constants.Conventions.Member.IsLockedOut;
@@ -37,8 +37,10 @@ namespace Umbraco.Web.Security.Providers
             LastPasswordChangedPropertyTypeAlias = Constants.Conventions.Member.LastPasswordChangeDate;
             PasswordRetrievalQuestionPropertyTypeAlias = Constants.Conventions.Member.PasswordQuestion;
             PasswordRetrievalAnswerPropertyTypeAlias = Constants.Conventions.Member.PasswordAnswer;
+            _memberTypeService = memberTypeService;
         }
 
+        private readonly IMemberTypeService _memberTypeService;
         private string _defaultMemberTypeAlias = "Member";
         private volatile bool _hasDefaultMember = false;
         private static readonly object Locker = new object();
@@ -99,7 +101,7 @@ namespace Umbraco.Web.Security.Providers
                     {
                         if (_hasDefaultMember == false)
                         {
-                            _defaultMemberTypeAlias = MemberService.GetDefaultMemberType();
+                            _defaultMemberTypeAlias = _memberTypeService.GetDefault();
                             if (_defaultMemberTypeAlias.IsNullOrWhiteSpace())
                             {
                                 throw new ProviderException("No default user type alias is specified in the web.config string. Please add a 'defaultUserTypeAlias' to the add element in the provider declaration in web.config");
diff --git a/src/Umbraco.Web/Security/Providers/UsersMembershipProvider.cs b/src/Umbraco.Web/Security/Providers/UsersMembershipProvider.cs
index 267bc0b433..e7d8fa4d22 100644
--- a/src/Umbraco.Web/Security/Providers/UsersMembershipProvider.cs
+++ b/src/Umbraco.Web/Security/Providers/UsersMembershipProvider.cs
@@ -18,15 +18,17 @@ namespace Umbraco.Web.Security.Providers
     {
 
         public UsersMembershipProvider()
-            : this(ApplicationContext.Current.Services.UserService)
+            : this(ApplicationContext.Current.Services.UserService, ApplicationContext.Current.Services.MemberTypeService)
         {
         }
 
-        public UsersMembershipProvider(IMembershipMemberService<IUser> memberService)
+        public UsersMembershipProvider(IMembershipMemberService<IUser> memberService, IMemberTypeService memberTypeService)
             : base(memberService)
         {
+            _memberTypeService = memberTypeService;
         }
 
+        private readonly IMemberTypeService _memberTypeService;
         private string _defaultMemberTypeAlias = "writer";
         private volatile bool _hasDefaultMember = false;
         private static readonly object Locker = new object();
@@ -68,7 +70,7 @@ namespace Umbraco.Web.Security.Providers
                     {
                         if (_hasDefaultMember == false)
                         {
-                            _defaultMemberTypeAlias = MemberService.GetDefaultMemberType();
+                            _defaultMemberTypeAlias = _memberTypeService.GetDefault();
                             if (_defaultMemberTypeAlias.IsNullOrWhiteSpace())
                             {
                                 throw new ProviderException("No default user type alias is specified in the web.config string. Please add a 'defaultUserTypeAlias' to the add element in the provider declaration in web.config");