diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
index a6d9b2b58b..fca0f02811 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
@@ -87,7 +87,30 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             return Database.Fetch<string>("SELECT DISTINCT Alias FROM cmsPropertyType ORDER BY Alias");
         }
-        
+
+        /// <summary>
+        /// Gets all content type aliases
+        /// </summary>
+        /// <param name="objectTypes">
+        /// If this list is empty, it will return all content type aliases for media, members and content, otherwise
+        /// it will only return content type aliases for the object types specified
+        /// </param>
+        /// <returns></returns>
+        public IEnumerable<string> GetAllContentTypeAliases(params Guid[] objectTypes)
+        {
+            var sql = new Sql().Select("cmsContentType.alias")
+                .From<ContentTypeDto>(SqlSyntax)
+                .InnerJoin<NodeDto>(SqlSyntax)
+                .On<ContentTypeDto, NodeDto>(SqlSyntax, dto => dto.NodeId, dto => dto.NodeId);
+
+            if (objectTypes.Any())
+            {
+                sql = sql.Where("umbracoNode.nodeObjectType IN (@objectTypes)", objectTypes);
+            }
+
+            return Database.Fetch<string>(sql);
+        }
+
         protected override Sql GetBaseQuery(bool isCount)
         {
             var sql = new Sql();
diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs
index 625023fd9e..df2af380d1 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs
@@ -22,5 +22,15 @@ namespace Umbraco.Core.Persistence.Repositories
         IEnumerable<string> GetAllPropertyTypeAliases();
 
         IEnumerable<MoveEventInfo<IContentType>> Move(IContentType toMove, EntityContainer container);
+
+        /// <summary>
+        /// Gets all content type aliases
+        /// </summary>
+        /// <param name="objectTypes">
+        /// If this list is empty, it will return all content type aliases for media, members and content, otherwise
+        /// it will only return content type aliases for the object types specified
+        /// </param>
+        /// <returns></returns>
+        IEnumerable<string> GetAllContentTypeAliases(params Guid[] objectTypes);
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Services/ContentTypeService.cs b/src/Umbraco.Core/Services/ContentTypeService.cs
index 92a2d6516e..4df866957d 100644
--- a/src/Umbraco.Core/Services/ContentTypeService.cs
+++ b/src/Umbraco.Core/Services/ContentTypeService.cs
@@ -224,6 +224,22 @@ namespace Umbraco.Core.Services
             }
         }
 
+        /// <summary>
+        /// Gets all content type aliases
+        /// </summary>
+        /// <param name="objectTypes">
+        /// If this list is empty, it will return all content type aliases for media, members and content, otherwise
+        /// it will only return content type aliases for the object types specified
+        /// </param>
+        /// <returns></returns>
+        public IEnumerable<string> GetAllContentTypeAliases(params Guid[] objectTypes)
+        {
+            using (var repository = RepositoryFactory.CreateContentTypeRepository(UowProvider.GetUnitOfWork()))
+            {
+                return repository.GetAllContentTypeAliases(objectTypes);
+            }
+        }
+
         /// <summary>
         /// Copies a content type as a child under the specified parent if specified (otherwise to the root)
         /// </summary>
diff --git a/src/Umbraco.Core/Services/IContentTypeService.cs b/src/Umbraco.Core/Services/IContentTypeService.cs
index 5fdadb6208..600f230f50 100644
--- a/src/Umbraco.Core/Services/IContentTypeService.cs
+++ b/src/Umbraco.Core/Services/IContentTypeService.cs
@@ -40,6 +40,16 @@ namespace Umbraco.Core.Services
         /// <returns></returns>
         IEnumerable<string> GetAllPropertyTypeAliases();
 
+        /// <summary>
+        /// Gets all content type aliases
+        /// </summary>
+        /// <param name="objectTypes">
+        /// If this list is empty, it will return all content type aliases for media, members and content, otherwise
+        /// it will only return content type aliases for the object types specified
+        /// </param>
+        /// <returns></returns>
+        IEnumerable<string> GetAllContentTypeAliases(params Guid[] objectTypes);
+
         /// <summary>
         /// Copies a content type as a child under the specified parent if specified (otherwise to the root)
         /// </summary>
diff --git a/src/Umbraco.Web.UI.Client/src/common/services/contenttypehelper.service.js b/src/Umbraco.Web.UI.Client/src/common/services/contenttypehelper.service.js
index 047d18c35c..61cb0a7317 100644
--- a/src/Umbraco.Web.UI.Client/src/common/services/contenttypehelper.service.js
+++ b/src/Umbraco.Web.UI.Client/src/common/services/contenttypehelper.service.js
@@ -49,7 +49,7 @@ function contentTypeHelper(contentTypeResource, dataTypeResource, $filter, $inje
         checkModelsBuilderStatus: function () {
             var deferred = $q.defer();
             var modelsResource = $injector.has("modelsBuilderResource") ? $injector.get("modelsBuilderResource") : null;
-            var modelsBuilderEnabled = Umbraco.Sys.ServerVariables.umbracoPlugins.modelsBuilder.enabled;
+            var modelsBuilderEnabled = (Umbraco && Umbraco.Sys && Umbraco.Sys.ServerVariables && Umbraco.Sys.ServerVariables.umbracoPlugins && Umbraco.Sys.ServerVariables.umbracoPlugins.modelsBuilder && Umbraco.Sys.ServerVariables.umbracoPlugins.modelsBuilder.enabled === true);            
             
             if (modelsBuilderEnabled && modelsResource) {
                 modelsResource.getModelsOutOfDateStatus().then(function(result) {
diff --git a/src/Umbraco.Web.UI/config/ClientDependency.config b/src/Umbraco.Web.UI/config/ClientDependency.config
index 99e72e8216..18916550bf 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="1365410531" fileDependencyExtensions=".js,.css" loggerType="Umbraco.Web.UI.CdfLogger, umbraco">
+<clientDependency version="602323772" 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/Editors/ContentTypeController.cs b/src/Umbraco.Web/Editors/ContentTypeController.cs
index 961dcd609f..f9efb4e366 100644
--- a/src/Umbraco.Web/Editors/ContentTypeController.cs
+++ b/src/Umbraco.Web/Editors/ContentTypeController.cs
@@ -178,11 +178,10 @@ namespace Umbraco.Web.Editors
         public ContentTypeDisplay PostSave(ContentTypeSave contentTypeSave)
         {
             var savedCt = PerformPostSave<IContentType, ContentTypeDisplay>(
-                contentTypeSave: contentTypeSave,
-                getContentType: i => Services.ContentTypeService.GetContentType(i),
-                getContentTypeByAlias: alias => Services.ContentTypeService.GetContentType(alias),
-                saveContentType: type => Services.ContentTypeService.Save(type),
-                beforeCreateNew: ctSave =>
+                contentTypeSave:    contentTypeSave,
+                getContentType:     i => Services.ContentTypeService.GetContentType(i),
+                saveContentType:    type => Services.ContentTypeService.Save(type),
+                beforeCreateNew:    ctSave =>
                 {
                     //create a default template if it doesnt exist -but only if default template is == to the content type
                     if (ctSave.DefaultTemplate.IsNullOrWhiteSpace() == false && ctSave.DefaultTemplate == ctSave.Alias)
diff --git a/src/Umbraco.Web/Editors/ContentTypeControllerBase.cs b/src/Umbraco.Web/Editors/ContentTypeControllerBase.cs
index ac58241b4d..b5caf08dfb 100644
--- a/src/Umbraco.Web/Editors/ContentTypeControllerBase.cs
+++ b/src/Umbraco.Web/Editors/ContentTypeControllerBase.cs
@@ -184,29 +184,43 @@ namespace Umbraco.Web.Editors
         protected TContentType PerformPostSave<TContentType, TContentTypeDisplay>(
             ContentTypeSave contentTypeSave,
             Func<int, TContentType> getContentType,
-            Func<string, TContentType> getContentTypeByAlias,
             Action<TContentType> saveContentType,
             bool validateComposition = true,
             Action<ContentTypeSave> beforeCreateNew = null)
-            where TContentType : IContentTypeComposition
+            where TContentType : class, IContentTypeComposition
             where TContentTypeDisplay : ContentTypeCompositionDisplay
         {
             var ctId = Convert.ToInt32(contentTypeSave.Id);
-            
-            //Validate that there's no other ct with the same name
-            var exists = getContentTypeByAlias(contentTypeSave.Alias);
-            if (exists != null && exists.Id.ToInvariantString() != contentTypeSave.Id.ToString())
+            var ct = ctId > 0 ? getContentType(ctId) : null;
+            if (ctId > 0 && ct == null) throw new HttpResponseException(HttpStatusCode.NotFound);
+
+            //Validate that there's no other ct with the same alias
+            // it in fact cannot be the same as any content type alias (member, content or media) because
+            // this would interfere with how ModelsBuilder works and also how many of the published caches
+            // works since that is based on aliases.
+            var allAliases = Services.ContentTypeService.GetAllContentTypeAliases();
+            var exists = allAliases.InvariantContains(contentTypeSave.Alias);
+            if ((exists) && (ctId == 0 || ct.Alias != contentTypeSave.Alias))
             {
-                ModelState.AddModelError("Alias", "A content type with this alias already exists");
+                ModelState.AddModelError("Alias", "A content type, media type or member type with this alias already exists");
             }
 
             if (ModelState.IsValid == false)
             {
-                var ct = getContentType(ctId);
-                //Required data is invalid so we cannot continue
-                var forDisplay = Mapper.Map<TContentTypeDisplay>(ct);
-                //map the 'save' data on top
-                forDisplay = Mapper.Map(contentTypeSave, forDisplay);
+                TContentTypeDisplay forDisplay;
+                if (ctId > 0)
+                {
+                    //Required data is invalid so we cannot continue
+                    forDisplay = Mapper.Map<TContentTypeDisplay>(ct);
+                    //map the 'save' data on top
+                    forDisplay = Mapper.Map(contentTypeSave, forDisplay);
+                }
+                else
+                {
+                    //map the 'save' data to display
+                    forDisplay = Mapper.Map<TContentTypeDisplay>(contentTypeSave);
+                }
+                
                 forDisplay.Errors = ModelState.ToErrorDictionary();
                 throw new HttpResponseException(Request.CreateValidationErrorResponse(forDisplay));
             }
@@ -220,22 +234,19 @@ namespace Umbraco.Web.Editors
             
             if (ctId > 0)
             {
-                //its an update to an existing
-                var found = getContentType(ctId);
-                if (found == null)
-                    throw new HttpResponseException(HttpStatusCode.NotFound);
+                //its an update to an existing                
 
-                Mapper.Map(contentTypeSave, found);
+                Mapper.Map(contentTypeSave, ct);
 
                 if (validateComposition)
                 {
                     //NOTE: this throws an error response if it is not valid
-                    ValidateComposition(contentTypeSave, found);
+                    ValidateComposition(contentTypeSave, ct);
                 }
 
-                saveContentType(found);
+                saveContentType(ct);
 
-                return found;
+                return ct;
             }
             else
             {
diff --git a/src/Umbraco.Web/Editors/MediaTypeController.cs b/src/Umbraco.Web/Editors/MediaTypeController.cs
index 540c95edc1..611c92e5a3 100644
--- a/src/Umbraco.Web/Editors/MediaTypeController.cs
+++ b/src/Umbraco.Web/Editors/MediaTypeController.cs
@@ -162,7 +162,6 @@ namespace Umbraco.Web.Editors
             var savedCt = PerformPostSave<IMediaType, ContentTypeCompositionDisplay>(
                 contentTypeSave:        contentTypeSave,
                 getContentType:         i => Services.ContentTypeService.GetMediaType(i),
-                getContentTypeByAlias:  alias => Services.ContentTypeService.GetMediaType(alias),
                 saveContentType:        type => Services.ContentTypeService.Save(type));
 
             var display = Mapper.Map<ContentTypeCompositionDisplay>(savedCt);
diff --git a/src/Umbraco.Web/Editors/MemberTypeController.cs b/src/Umbraco.Web/Editors/MemberTypeController.cs
index 924ecb3e05..5b95318dc1 100644
--- a/src/Umbraco.Web/Editors/MemberTypeController.cs
+++ b/src/Umbraco.Web/Editors/MemberTypeController.cs
@@ -134,7 +134,6 @@ namespace Umbraco.Web.Editors
             var savedCt = PerformPostSave<IMemberType, ContentTypeCompositionDisplay>(
                 contentTypeSave:            contentTypeSave,
                 getContentType:             i => Services.MemberTypeService.Get(i),
-                getContentTypeByAlias:      alias => Services.MemberTypeService.Get(alias),
                 saveContentType:            type => Services.MemberTypeService.Save(type),
                 validateComposition:        false);
 
diff --git a/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs b/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs
index c4f2d96f79..6ade23b6d5 100644
--- a/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs
+++ b/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs
@@ -185,7 +185,10 @@ namespace Umbraco.Web.Models.Mapping
                     if (destAllowedTemplateAliases.SequenceEqual(source.AllowedTemplates) == false)
                     {
                         var templates = applicationContext.Services.FileService.GetTemplates(source.AllowedTemplates.ToArray());
-                        dest.AllowedTemplates = source.AllowedTemplates.Select(x => Mapper.Map<EntityBasic>(templates.Single(t => t.Alias == x))).ToArray();
+                        dest.AllowedTemplates = source.AllowedTemplates
+                            .Select(x => Mapper.Map<EntityBasic>(templates.SingleOrDefault(t => t.Alias == x)))
+                            .WhereNotNull()
+                            .ToArray();
                     }
 
                     if (source.DefaultTemplate.IsNullOrWhiteSpace() == false)