diff --git a/zero.Core/Api/ApplicationsApi.cs b/zero.Core/Api/ApplicationsApi.cs
index 8242c4c2..81f06daf 100644
--- a/zero.Core/Api/ApplicationsApi.cs
+++ b/zero.Core/Api/ApplicationsApi.cs
@@ -8,31 +8,31 @@ using zero.Core.Extensions;
 
 namespace zero.Core.Api
 {
-  public class ApplicationsApi<T> : BackofficeApi, IApplicationsApi<T> where T : IApplication
+  public class ApplicationsApi : BackofficeApi, IApplicationsApi
   {
-    IValidator<T> Validator;
+    IValidator<IApplication> Validator;
 
 
-    public ApplicationsApi(IBackofficeStore store, IValidator<T> validator) : base(store)
+    public ApplicationsApi(IBackofficeStore store) : base(store)
     {
-      Validator = validator;
+      Validator = null;
     }
 
 
     /// <inheritdoc />
-    public async Task<T> GetById(string id)
+    public async Task<IApplication> GetById(string id)
     {
-      return await GetById<T>(id);
+      return await GetById<IApplication>(id);
     }
 
 
     /// <inheritdoc />
-    public async Task<IList<T>> GetAll()
+    public async Task<IList<IApplication>> GetAll()
     {
       using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
       {
         return await session
-          .Query<T>()
+          .Query<IApplication>()
           .OrderByDescending(x => x.CreatedDate)
           .ToListAsync();
       }
@@ -40,58 +40,58 @@ namespace zero.Core.Api
 
 
     /// <inheritdoc />
-    public async Task<ListResult<T>> GetByQuery(ListQuery<T> query)
+    public async Task<ListResult<IApplication>> GetByQuery(ListQuery<IApplication> query)
     {
       query.SearchFor(entity => entity.Name);
 
       using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
       {
-        return await session.Query<T>()
+        return await session.Query<IApplication>()
           .ToQueriedListAsync(query);
       }
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Save(T model)
+    public async Task<EntityResult<IApplication>> Save(IApplication model)
     {
       return await SaveModel(model, Validator);
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Delete(string id)
+    public async Task<EntityResult<IApplication>> Delete(string id)
     {
-      return await DeleteById<T>(id);
+      return await DeleteById<IApplication>(id);
     }
   }
 
 
-  public interface IApplicationsApi<T> where T : IApplication
+  public interface IApplicationsApi
   {
     /// <summary>
     /// Get application by Id
     /// </summary>
-    Task<T> GetById(string id);
+    Task<IApplication> GetById(string id);
 
     /// <summary>
     /// Get all available zero applications
     /// </summary>
-    Task<IList<T>> GetAll();
+    Task<IList<IApplication>> GetAll();
 
     /// <summary>
     /// Get all available applications (with query)
     /// </summary>
-    Task<ListResult<T>> GetByQuery(ListQuery<T> query);
+    Task<ListResult<IApplication>> GetByQuery(ListQuery<IApplication> query);
 
     /// <summary>
     /// Creates or updates a application
     /// </summary>
-    Task<EntityResult<T>> Save(T model);
+    Task<EntityResult<IApplication>> Save(IApplication model);
 
     /// <summary>
     /// Deletes a application by Id
     /// </summary>
-    Task<EntityResult<T>> Delete(string id);
+    Task<EntityResult<IApplication>> Delete(string id);
   }
 }
diff --git a/zero.Core/Api/CountriesApi.cs b/zero.Core/Api/CountriesApi.cs
index 81445c0c..3f7bcead 100644
--- a/zero.Core/Api/CountriesApi.cs
+++ b/zero.Core/Api/CountriesApi.cs
@@ -11,38 +11,38 @@ using zero.Core.Extensions;
 
 namespace zero.Core.Api
 {
-  public class CountriesApi<T> : AppAwareBackofficeApi, ICountriesApi<T> where T : ICountry
+  public class CountriesApi : AppAwareBackofficeApi, ICountriesApi
   {
-    IValidator<T> Validator;
+    IValidator<ICountry> Validator;
 
 
-    public CountriesApi(IBackofficeStore store, IValidator<T> validator) : base(store)
+    public CountriesApi(IBackofficeStore store) : base(store)
     {
       Scope.IncludeShared = true;
-      Validator = validator;
+      Validator = null;
     }
 
 
     /// <inheritdoc />
-    public async Task<T> GetById(string id)
+    public async Task<ICountry> GetById(string id)
     {
-      return await GetById<T>(id);
+      return await GetById<ICountry>(id);
     }
 
 
     /// <inheritdoc />
-    public async Task<Dictionary<string, T>> GetByIds(params string[] ids)
+    public async Task<Dictionary<string, ICountry>> GetByIds(params string[] ids)
     {
-      return await GetByIds<T>(ids);
+      return await GetByIds<ICountry>(ids);
     }
 
 
     /// <inheritdoc />
-    public async Task<IList<T>> GetAll(string languageId)
+    public async Task<IList<ICountry>> GetAll(string languageId)
     {
       using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
       {
-        return await session.Query<T>()
+        return await session.Query<ICountry>()
           .Scope(Scope)
           .Where(x => x.LanguageId == languageId)
           .OrderByDescending(x => x.IsPreferred)
@@ -53,13 +53,13 @@ namespace zero.Core.Api
 
 
     /// <inheritdoc />
-    public async Task<ListResult<T>> GetByQuery(string languageId, ListQuery<T> query)
+    public async Task<ListResult<ICountry>> GetByQuery(string languageId, ListQuery<ICountry> query)
     {
       query.SearchSelector = country => country.Name;
 
       using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
       {
-        return await session.Query<T>()
+        return await session.Query<ICountry>()
           .Scope(Scope)
           .Where(x => x.LanguageId == languageId)
           .OrderByDescending(x => x.IsPreferred)
@@ -70,50 +70,50 @@ namespace zero.Core.Api
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Save(T model)
+    public async Task<EntityResult<ICountry>> Save(ICountry model)
     {
       return await SaveModel(model, Validator);
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Delete(string id)
+    public async Task<EntityResult<ICountry>> Delete(string id)
     {
-      return await DeleteById<T>(id);
+      return await DeleteById<ICountry>(id);
     }
   }
 
 
-  public interface ICountriesApi<T> where T : ICountry
+  public interface ICountriesApi
   {
     /// <summary>
     /// Get country by Id
     /// </summary>
-    Task<T> GetById(string id);
+    Task<ICountry> GetById(string id);
 
     /// <summary>
     /// Get countries by ids
     /// </summary>
-    Task<Dictionary<string, T>> GetByIds(params string[] ids);
+    Task<Dictionary<string, ICountry>> GetByIds(params string[] ids);
 
     /// <summary>
     /// Get all available countries
     /// </summary>
-    Task<IList<T>> GetAll(string languageId);
+    Task<IList<ICountry>> GetAll(string languageId);
 
     /// <summary>
     /// Get all available countries (with query)
     /// </summary>
-    Task<ListResult<T>> GetByQuery(string languageId, ListQuery<T> query);
+    Task<ListResult<ICountry>> GetByQuery(string languageId, ListQuery<ICountry> query);
 
     /// <summary>
     /// Creates or updates a country
     /// </summary>
-    Task<EntityResult<T>> Save(T model);
+    Task<EntityResult<ICountry>> Save(ICountry model);
 
     /// <summary>
     /// Deletes a country by Id
     /// </summary>
-    Task<EntityResult<T>> Delete(string id);
+    Task<EntityResult<ICountry>> Delete(string id);
   }
 }
diff --git a/zero.Core/Api/LanguagesApi.cs b/zero.Core/Api/LanguagesApi.cs
index 6a050d7e..017cdc92 100644
--- a/zero.Core/Api/LanguagesApi.cs
+++ b/zero.Core/Api/LanguagesApi.cs
@@ -12,38 +12,38 @@ using zero.Core.Extensions;
 
 namespace zero.Core.Api
 {
-  public class LanguagesApi<T> : AppAwareBackofficeApi, ILanguagesApi<T> where T : ILanguage
+  public class LanguagesApi : AppAwareBackofficeApi, ILanguagesApi
   {
-    protected IValidator<T> Validator { get; private set; }
+    protected IValidator<ILanguage> Validator { get; private set; }
 
 
-    public LanguagesApi(IBackofficeStore store, IValidator<T> validator = null) : base(store)
+    public LanguagesApi(IBackofficeStore store) : base(store)
     {
       Scope.IncludeShared = true;
-      Validator = validator;
+      Validator = null;
     }
 
 
     /// <inheritdoc />
-    public async Task<T> GetById(string id)
+    public async Task<ILanguage> GetById(string id)
     {
-      return await GetById<T>(id);
+      return await GetById<ILanguage>(id);
     }
 
 
     /// <inheritdoc />
-    public async Task<Dictionary<string, T>> GetByIds(params string[] ids)
+    public async Task<Dictionary<string, ILanguage>> GetByIds(params string[] ids)
     {
-      return await GetByIds<T>(ids);
+      return await GetByIds<ILanguage>(ids);
     }
 
 
     /// <inheritdoc />
-    public async Task<IList<T>> GetAll()
+    public async Task<IList<ILanguage>> GetAll()
     {
       using IAsyncDocumentSession session = Raven.OpenAsyncSession();
 
-      return await session.Query<T>()
+      return await session.Query<ILanguage>()
         .Scope(Scope)
         .OrderByDescending(x => x.CreatedDate)
         .ToListAsync();
@@ -68,47 +68,47 @@ namespace zero.Core.Api
 
 
     /// <inheritdoc />
-    public async Task<ListResult<T>> GetByQuery(ListQuery<T> query)
+    public async Task<ListResult<ILanguage>> GetByQuery(ListQuery<ILanguage> query)
     {
       query.SearchFor(entity => entity.Name);
 
       using IAsyncDocumentSession session = Raven.OpenAsyncSession();
 
-      return await session.Query<T>().Scope(Scope).ToQueriedListAsync(query);
+      return await session.Query<ILanguage>().Scope(Scope).ToQueriedListAsync(query);
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Save(T model)
+    public async Task<EntityResult<ILanguage>> Save(ILanguage model)
     {
       return await SaveModel(model, Validator);
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Delete(string id)
+    public async Task<EntityResult<ILanguage>> Delete(string id)
     {
-      return await DeleteById<T>(id);
+      return await DeleteById<ILanguage>(id);
     }
   }
 
 
-  public interface ILanguagesApi<T> where T : ILanguage
+  public interface ILanguagesApi
   {
     /// <summary>
     /// Get language by Id
     /// </summary>
-    Task<T> GetById(string id);
+    Task<ILanguage> GetById(string id);
 
     /// <summary>
     /// Get countries by ids
     /// </summary>
-    Task<Dictionary<string, T>> GetByIds(params string[] ids);
+    Task<Dictionary<string, ILanguage>> GetByIds(params string[] ids);
 
     /// <summary>
     /// Get all available languages
     /// </summary>
-    Task<IList<T>> GetAll();
+    Task<IList<ILanguage>> GetAll();
 
     /// <summary>
     /// Get all available cultures
@@ -118,16 +118,16 @@ namespace zero.Core.Api
     /// <summary>
     /// Get all available languages (with query)
     /// </summary>
-    Task<ListResult<T>> GetByQuery(ListQuery<T> query);
+    Task<ListResult<ILanguage>> GetByQuery(ListQuery<ILanguage> query);
 
     /// <summary>
     /// Creates or updates a language
     /// </summary>
-    Task<EntityResult<T>> Save(T model);
+    Task<EntityResult<ILanguage>> Save(ILanguage model);
 
     /// <summary>
     /// Deletes a language by Id
     /// </summary>
-    Task<EntityResult<T>> Delete(string id);
+    Task<EntityResult<ILanguage>> Delete(string id);
   }
 }
diff --git a/zero.Core/Api/TranslationsApi.cs b/zero.Core/Api/TranslationsApi.cs
index 1cf72a01..eec3f3ae 100644
--- a/zero.Core/Api/TranslationsApi.cs
+++ b/zero.Core/Api/TranslationsApi.cs
@@ -10,37 +10,9 @@ using zero.Core.Extensions;
 
 namespace zero.Core.Api
 {
-  public class TranslationsApiFacade : ITranslationsApiFacade
+  public class TranslationsApi : AppAwareBackofficeApi, ITranslationsApi
   {
-    IServiceProvider Services;
-
-    public TranslationsApiFacade(IServiceProvider services)
-    {
-      Services = services;
-    }
-
-    public ITranslationsApi<T> As<T>() where T : ITranslation
-    {
-      return Services.GetService(typeof(ITranslationsApi<T>)) as ITranslationsApi<T>;
-    }
-  }
-
-
-  public interface ITranslationsApiFacade
-  {
-    ITranslationsApi<T> As<T>() where T : ITranslation;
-  }
-
-
-  public class TranslationsApi : TranslationsApi<ITranslation>, ITranslationsApi
-  {
-    public TranslationsApi(IBackofficeStore store) : base(store) { }
-  }
-
-
-  public class TranslationsApi<T> : AppAwareBackofficeApi, ITranslationsApi<T> where T : ITranslation
-  {
-    //IValidator<T> Validator;
+    //IValidator<ITranslation> Validator;
 
 
     public TranslationsApi(IBackofficeStore store) : base(store)
@@ -52,23 +24,23 @@ namespace zero.Core.Api
     /// <inheritdoc />
     public async Task<string> GetStringById(string id)
     {
-      return (await GetById<T>(id))?.Value;
+      return (await GetById<ITranslation>(id))?.Value;
     }
 
 
     /// <inheritdoc />
-    public async Task<T> GetById(string id)
+    public async Task<ITranslation> GetById(string id)
     {
-      return await GetById<T>(id);
+      return await GetById<ITranslation>(id);
     }
 
 
     /// <inheritdoc />
-    public async Task<IList<T>> GetAll()
+    public async Task<IList<ITranslation>> GetAll()
     {
       using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
       {
-        return await session.Query<T>()
+        return await session.Query<ITranslation>()
           .OrderByDescending(x => x.CreatedDate)
           .Scope(Scope)
           .ToListAsync();
@@ -77,38 +49,38 @@ namespace zero.Core.Api
 
 
     /// <inheritdoc />
-    public async Task<ListResult<T>> GetByQuery(ListQuery<T> query)
+    public async Task<ListResult<ITranslation>> GetByQuery(ListQuery<ITranslation> query)
     {
       query.SearchFor(entity => entity.Key, entity => entity.Value);
 
       using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
       {
-        return await session.Query<T>().Scope(Scope).ToQueriedListAsync(query);
+        return await session.Query<ITranslation>().Scope(Scope).ToQueriedListAsync(query);
       }
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Save(T model)
+    public async Task<EntityResult<ITranslation>> Save(ITranslation model)
     {
       return await SaveModel(model, null);
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Delete(string id)
+    public async Task<EntityResult<ITranslation>> Delete(string id)
     {
-      return await DeleteById<T>(id);
+      return await DeleteById<ITranslation>(id);
     }
   }
 
 
-  public interface ITranslationsApi<T> where T : ITranslation
+  public interface ITranslationsApi
   {
     /// <summary>
     /// Get translation by id
     /// </summary>
-    Task<T> GetById(string id);
+    Task<ITranslation> GetById(string id);
 
     /// <summary>
     /// Get a translated string by id
@@ -118,27 +90,21 @@ namespace zero.Core.Api
     /// <summary>
     /// Get all available translations
     /// </summary>
-    Task<IList<T>> GetAll();
+    Task<IList<ITranslation>> GetAll();
 
     /// <summary>
     /// Get all available translations (with query)
     /// </summary>
-    Task<ListResult<T>> GetByQuery(ListQuery<T> query);
+    Task<ListResult<ITranslation>> GetByQuery(ListQuery<ITranslation> query);
 
     /// <summary>
     /// Creates or updates a translation
     /// </summary>
-    Task<EntityResult<T>> Save(T model);
+    Task<EntityResult<ITranslation>> Save(ITranslation model);
 
     /// <summary>
     /// Deletes a translation by id
     /// </summary>
-    Task<EntityResult<T>> Delete(string id);
-  }
-
-
-  public interface ITranslationsApi : ITranslationsApi<ITranslation>
-  {
-
+    Task<EntityResult<ITranslation>> Delete(string id);
   }
 }
diff --git a/zero.Core/Api/UserApi.cs b/zero.Core/Api/UserApi.cs
index aeba05f6..a582c251 100644
--- a/zero.Core/Api/UserApi.cs
+++ b/zero.Core/Api/UserApi.cs
@@ -9,38 +9,38 @@ using zero.Core.Extensions;
 
 namespace zero.Core.Api
 {
-  public class UserApi<T> : AppAwareBackofficeApi, IUserApi<T> where T : class, IUser
+  public class UserApi : AppAwareBackofficeApi, IUserApi
   {
-    protected UserManager<T> UserManager { get; private set; }
+    protected UserManager<User> UserManager { get; private set; }
 
-    public UserApi(IBackofficeStore store, UserManager<T> userManager) : base(store)
+    public UserApi(IBackofficeStore store, UserManager<User> userManager) : base(store)
     {
       UserManager = userManager;
     }
 
 
     /// <inheritdoc />
-    public async Task<T> GetUserById(string id)
+    public async Task<IUser> GetUserById(string id)
     {
-      T user = await UserManager.FindByIdAsync(id);
+      IUser user = await UserManager.FindByIdAsync(id);
       return user;
     }
 
 
     /// <inheritdoc />
-    public async Task<T> GetUserByEmail(string email)
+    public async Task<IUser> GetUserByEmail(string email)
     {
-      T user = await UserManager.FindByEmailAsync(email);
+      IUser user = await UserManager.FindByEmailAsync(email);
       return user;
     }
 
 
     /// <inheritdoc />
-    public async Task<IList<T>> GetAll(string appId = null)
+    public async Task<IList<IUser>> GetAll(string appId = null)
     {
       using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
       {
-        return await session.Query<T>()
+        return await session.Query<IUser>()
           .Scope(appId)
           .OrderByDescending(x => x.CreatedDate)
           .ToListAsync();
@@ -49,13 +49,13 @@ namespace zero.Core.Api
 
 
     /// <inheritdoc />
-    public async Task<ListResult<T>> GetByQuery(ListQuery<T> query, string appId = null)
+    public async Task<ListResult<IUser>> GetByQuery(ListQuery<IUser> query, string appId = null)
     {
       query.SearchSelector = user => user.Name;
 
       using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
       {
-        return await session.Query<T>()
+        return await session.Query<IUser>()
           .Scope(appId)
           .ToQueriedListAsync(query);
       }
@@ -63,37 +63,37 @@ namespace zero.Core.Api
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Save(T model)
+    public async Task<EntityResult<IUser>> Save(IUser model)
     {
       return await SaveModel(model); //, new UserValidator<User>());
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Delete(string id)
+    public async Task<EntityResult<IUser>> Delete(string id)
     {
-      return await DeleteById<T>(id);
+      return await DeleteById<IUser>(id);
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> UpdatePassword(T user, string currentPassword, string newPassword)
+    public async Task<EntityResult<IUser>> UpdatePassword(IUser user, string currentPassword, string newPassword)
     {
       if (currentPassword.IsNullOrWhiteSpace() || newPassword.IsNullOrWhiteSpace())
       {
-        return EntityResult<T>.Fail(nameof(currentPassword), "@errors.changepassword.emptyfields");
+        return EntityResult<IUser>.Fail(nameof(currentPassword), "@errors.changepassword.emptyfields");
       }
 
       if (user == null)
       {
-        return EntityResult<T>.Fail("@errors.changepassword.nouser");
+        return EntityResult<IUser>.Fail("@errors.changepassword.nouser");
       }
 
-      IdentityResult identityResult = await UserManager.ChangePasswordAsync(user, currentPassword, newPassword);
+      IdentityResult identityResult = await UserManager.ChangePasswordAsync(user as User, currentPassword, newPassword);
 
       if (!identityResult.Succeeded)
       {
-        EntityResult<T> result = EntityResult<T>.Fail();
+        EntityResult<IUser> result = EntityResult<IUser>.Fail();
         
         foreach (IdentityError error in identityResult.Errors)
         {
@@ -103,19 +103,19 @@ namespace zero.Core.Api
         return result;
       }
 
-      return EntityResult<T>.Success(user);
+      return EntityResult<IUser>.Success(user);
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Enable(T user)
+    public async Task<EntityResult<IUser>> Enable(IUser user)
     {
       return await UpdateActiveState(user, true);
     }
 
 
     /// <inheritdoc />
-    public async Task<EntityResult<T>> Disable(T user)
+    public async Task<EntityResult<IUser>> Disable(IUser user)
     {
       return await UpdateActiveState(user, false);
     }
@@ -125,15 +125,15 @@ namespace zero.Core.Api
     /// Updates the active state of user.
     /// If IsActive=false, the user cannot login anymore
     /// </summary>
-    async Task<EntityResult<T>> UpdateActiveState(T user, bool isActive)
+    async Task<EntityResult<IUser>> UpdateActiveState(IUser user, bool isActive)
     {
       user.IsActive = isActive;
 
-      IdentityResult identityResult = await UserManager.UpdateAsync(user);
+      IdentityResult identityResult = await UserManager.UpdateAsync(user as User);
 
       if (!identityResult.Succeeded)
       {
-        EntityResult<T> result = EntityResult<T>.Fail();
+        EntityResult<IUser> result = EntityResult<IUser>.Fail();
 
         foreach (IdentityError error in identityResult.Errors)
         {
@@ -143,59 +143,59 @@ namespace zero.Core.Api
         return result;
       }
 
-      await UserManager.UpdateSecurityStampAsync(user);
+      await UserManager.UpdateSecurityStampAsync(user as User);
 
-      return EntityResult<T>.Success(user);
+      return EntityResult<IUser>.Success(user);
     }
   }
 
 
-  public interface IUserApi<T> : IAppAwareBackofficeApi where T : class, IUser
+  public interface IUserApi : IAppAwareBackofficeApi
   {
     /// <summary>
     /// Find user by id
     /// </summary>
-    Task<T> GetUserById(string id);
+    Task<IUser> GetUserById(string id);
 
     /// <summary>
     /// Find user by email
     /// </summary>
-    Task<T> GetUserByEmail(string email);  
+    Task<IUser> GetUserByEmail(string email);  
 
     /// <summary>
     /// Get all users for the selected application
     /// </summary>
-    Task<IList<T>> GetAll(string appId = null);
+    Task<IList<IUser>> GetAll(string appId = null);
 
     /// <summary>
     /// Get all available users (with query)
     /// </summary>
-    Task<ListResult<T>> GetByQuery(ListQuery<T> query, string appId = null);
+    Task<ListResult<IUser>> GetByQuery(ListQuery<IUser> query, string appId = null);
 
     /// <summary>
     /// Creates or updates a user
     /// </summary>
-    Task<EntityResult<T>> Save(T model);
+    Task<EntityResult<IUser>> Save(IUser model);
 
     /// <summary>
     /// Deletes a user
     /// </summary>
-    Task<EntityResult<T>> Delete(string id);
+    Task<EntityResult<IUser>> Delete(string id);
 
     /// <summary>
     /// Changes the password of the current user.
     /// User is logged out if this operation succeeds.
     /// </summary>
-    Task<EntityResult<T>> UpdatePassword(T user, string currentPassword, string newPassword);
+    Task<EntityResult<IUser>> UpdatePassword(IUser user, string currentPassword, string newPassword);
 
     /// <summary>
     /// Enables a user
     /// </summary>
-    Task<EntityResult<T>> Enable(T user);
+    Task<EntityResult<IUser>> Enable(IUser user);
 
     /// <summary>
     /// Disables a user
     /// </summary>
-    Task<EntityResult<T>> Disable(T user);
+    Task<EntityResult<IUser>> Disable(IUser user);
   }
 }
diff --git a/zero.Core/Entities/Country.cs b/zero.Core/Entities/Country.cs
index d06a21f9..49866f2b 100644
--- a/zero.Core/Entities/Country.cs
+++ b/zero.Core/Entities/Country.cs
@@ -1,4 +1,6 @@
-namespace zero.Core.Entities
+using zero.Core.Attributes;
+
+namespace zero.Core.Entities
 {
   public class Country : ZeroEntity, ICountry
   {
@@ -16,6 +18,7 @@
   }
 
 
+  [Collection("Countries")]
   public interface ICountry : IZeroEntity, IAppAwareShareableEntity, ILanguageAwareEntity, IZeroDbConventions
   {
     /// <summary>
diff --git a/zero.Core/Extensions/ServiceCollectionExtensions.cs b/zero.Core/Extensions/ServiceCollectionExtensions.cs
index e5cd4fba..826b7fce 100644
--- a/zero.Core/Extensions/ServiceCollectionExtensions.cs
+++ b/zero.Core/Extensions/ServiceCollectionExtensions.cs
@@ -31,7 +31,12 @@ namespace zero.Core.Extensions
       {
         IEnumerable<(Type, TypeInfo)> matches = AssemblyDiscovery.Current.GetAllClassTypes().SelectMany(type =>
         {
-          IEnumerable<Type> genericTypes = type.GetInterfaces().Select(x => x.GetTypeInfo()).Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == serviceType);
+          var interfaces = type.GetInterfaces().Select(x => x.GetTypeInfo());
+          IEnumerable<Type> genericTypes = interfaces.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == serviceType);
+          if (genericTypes.Any())
+          {
+            var genericTypeDefinitions = genericTypes.First();
+          }
           return genericTypes.Select(x => (x, type));
         });
 
diff --git a/zero.Core/Validation/ApplicationValidator.cs b/zero.Core/Validation/ApplicationValidator.cs
index ab8d7558..55ef4208 100644
--- a/zero.Core/Validation/ApplicationValidator.cs
+++ b/zero.Core/Validation/ApplicationValidator.cs
@@ -5,7 +5,7 @@ using zero.Core.Extensions;
 
 namespace zero.Core.Validation
 {
-  public class ApplicationValidator : AbstractValidator<Application>
+  public class ApplicationValidator : AbstractValidator<IApplication>
   {
     public ApplicationValidator()
     {
diff --git a/zero.Web/ApiControllerFeatureProvider.cs b/zero.Web/ApiControllerFeatureProvider.cs
deleted file mode 100644
index a1cbaa0f..00000000
--- a/zero.Web/ApiControllerFeatureProvider.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-using Microsoft.AspNetCore.Mvc.ApplicationParts;
-using Microsoft.AspNetCore.Mvc.Controllers;
-using Microsoft.Extensions.DependencyInjection;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using zero.Core;
-using zero.Core.Assemblies;
-using zero.Core.Entities;
-using zero.Web.Controllers;
-using zero.Web.Filters;
-
-namespace zero.Web
-{
-  public class ApiControllerFeatureProvider : IApplicationFeatureProvider<ControllerFeature>
-  {
-    IServiceCollection ServiceCollection;
-
-    public ApiControllerFeatureProvider(IServiceCollection serviceCollection)
-    {
-      ServiceCollection = serviceCollection;
-    }
-
-
-    public void PopulateFeature(IEnumerable<ApplicationPart> parts, ControllerFeature feature)
-    {
-      var pagetype = typeof(IPage);
-      var page = ServiceCollection.FirstOrDefault(x => x.ServiceType.Equals(pagetype));
-      IEnumerable<TypeInfo> candidates = AssemblyDiscovery.Current.GetTypes<ISupportsGenericsController>(parts, true).Where(x => x.ContainsGenericParameters);
-
-      foreach (TypeInfo candidate in candidates)
-      {
-        Type genericType = candidate.GetGenericTypeDefinition();
-        Type[] genericArguments = genericType.GetGenericArguments();
-
-        List<Type> concreteArguments = new List<Type>();
-
-        bool isValid = true;
-
-        foreach (Type arg in genericArguments)
-        {
-          Type requiredService = arg.GetInterfaces().FirstOrDefault();
-
-          if (requiredService == null)
-          {
-            isValid = false;
-            break;
-          }
-
-          TypeInfo concreteArgument = null;
-
-          ServiceDescriptor descriptor = ServiceCollection.FirstOrDefault(x => x.ServiceType.Equals(requiredService));
-
-          if (descriptor != null)
-          {
-            concreteArgument = descriptor.ImplementationType?.GetTypeInfo();
-          }
-
-          if (concreteArgument == null)
-          {
-            IEnumerable<TypeInfo> concreteArgumentCandidates = AssemblyDiscovery.Current.GetTypes(requiredService, parts);
-            concreteArgument = concreteArgumentCandidates.FirstOrDefault();
-
-            if (concreteArgument == null)
-            {
-              isValid = false;
-              break;
-            }
-          }
-
-          concreteArguments.Add(concreteArgument);
-        }
-
-        if (!isValid)
-        {
-          continue;
-        }
-
-        TypeInfo type = candidate.MakeGenericType(concreteArguments.ToArray()).GetTypeInfo();
-        feature.Controllers.Add(type);
-      }
-    }
-  }
-}
diff --git a/zero.Web/Controllers/ApplicationsController.cs b/zero.Web/Controllers/ApplicationsController.cs
index 97c5e3eb..e25bee81 100644
--- a/zero.Web/Controllers/ApplicationsController.cs
+++ b/zero.Web/Controllers/ApplicationsController.cs
@@ -2,25 +2,28 @@
 using System.Threading.Tasks;
 using zero.Core.Api;
 using zero.Core.Entities;
+using zero.Core.Extensions;
 using zero.Core.Identity;
 
 namespace zero.Web.Controllers
 {
   [ZeroAuthorize(Permissions.Settings.Applications, PermissionsValue.Read)]
-  public class ApplicationsController<T> : BackofficeController where T : IApplication, new()
+  public class ApplicationsController : BackofficeController
   {
-    IApplicationsApi<T> Api;
+    IApplicationsApi Api;
+    IApplication Blueprint;
 
-    public ApplicationsController(IApplicationsApi<T> api)
+    public ApplicationsController(IApplicationsApi api, IApplication blueprint)
     {
       Api = api;
+      Blueprint = blueprint;
     }
 
 
     /// <summary>
     /// Get translation by id
     /// </summary>  
-    public IActionResult GetEmpty() => Edit(new T());
+    public IActionResult GetEmpty() => Edit(Blueprint.Clone());
 
 
     /// <summary>
@@ -32,7 +35,7 @@ namespace zero.Web.Controllers
     /// <summary>
     /// Get all translations
     /// </summary>    
-    public async Task<IActionResult> GetAll([FromQuery] ListQuery<T> query = null)
+    public async Task<IActionResult> GetAll([FromQuery] ListQuery<IApplication> query = null)
     {
       if (query == null)
       {
@@ -53,7 +56,7 @@ namespace zero.Web.Controllers
     /// Save translation
     /// </summary>
     [ZeroAuthorize(Permissions.Settings.Applications, PermissionsValue.Update)]
-    public async Task<IActionResult> Save([FromBody] T model) => Json(await Api.Save(model));
+    public async Task<IActionResult> Save([FromBody] IApplication model) => Json(await Api.Save(model));
 
 
     /// <summary>
diff --git a/zero.Web/Controllers/BackofficeController.cs b/zero.Web/Controllers/BackofficeController.cs
index ebeda02f..7c0ed325 100644
--- a/zero.Web/Controllers/BackofficeController.cs
+++ b/zero.Web/Controllers/BackofficeController.cs
@@ -16,9 +16,8 @@ using zero.Web.Models;
 namespace zero.Web.Controllers
 {
   [ZeroAuthorize]
-  [BackofficeGenericController]
   [ServiceFilter(typeof(ModelStateValidationFilterAttribute))]
-  public abstract class BackofficeController : Controller, ISupportsGenericsController
+  public abstract class BackofficeController : Controller
   {
     IMapper _mapper;
     IZeroOptions _options;
diff --git a/zero.Web/Controllers/CountriesController.cs b/zero.Web/Controllers/CountriesController.cs
index d142c0be..a0241c3d 100644
--- a/zero.Web/Controllers/CountriesController.cs
+++ b/zero.Web/Controllers/CountriesController.cs
@@ -5,28 +5,31 @@ using System.Threading.Tasks;
 using zero.Core;
 using zero.Core.Api;
 using zero.Core.Entities;
+using zero.Core.Extensions;
 using zero.Core.Identity;
 
 namespace zero.Web.Controllers
 {
   [ZeroAuthorize(Permissions.Settings.Countries, PermissionsValue.Read)]
-  public class CountriesController<T> : BackofficeController where T : ICountry, new()
+  public class CountriesController : BackofficeController
   {
-    ICountriesApi<T> Api;
+    ICountriesApi Api;
+    ICountry Blueprint;
 
-    public CountriesController(ICountriesApi<T> api)
+    public CountriesController(ICountriesApi api, ICountry blueprint)
     {
       Api = api;
+      Blueprint = blueprint;
     }
 
 
     public async Task<IActionResult> GetById([FromQuery] string id) => Edit(await Api.GetById(id));
 
 
-    public IActionResult GetEmpty() => Edit(new T());
+    public IActionResult GetEmpty() => Edit(Blueprint.Clone());
 
 
-    public async Task<IActionResult> GetAll([FromQuery] ListQuery<T> query) => Json(await Api.GetByQuery("languages.1-A", query)); // TODO correct language
+    public async Task<IActionResult> GetAll([FromQuery] ListQuery<ICountry> query) => Json(await Api.GetByQuery("languages.1-A", query)); // TODO correct language
 
 
     public async Task<IActionResult> GetForPicker() => Json((await Api.GetAll("languages.1-A")).Select(x => new SelectModel()
@@ -49,7 +52,7 @@ namespace zero.Web.Controllers
 
 
     [ZeroAuthorize(Permissions.Settings.Countries, PermissionsValue.Update)]
-    public async Task<IActionResult> Save([FromBody] T model) => Json(await Api.Save(model));
+    public async Task<IActionResult> Save([FromBody] ICountry model) => Json(await Api.Save(model));
 
 
     [ZeroAuthorize(Permissions.Settings.Countries, PermissionsValue.Update)]
diff --git a/zero.Web/Controllers/ISupportsGenericsController.cs b/zero.Web/Controllers/ISupportsGenericsController.cs
deleted file mode 100644
index c1397269..00000000
--- a/zero.Web/Controllers/ISupportsGenericsController.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace zero.Web.Controllers
-{
-  public interface ISupportsGenericsController
-  {
-  }
-}
diff --git a/zero.Web/Controllers/LanguagesController.cs b/zero.Web/Controllers/LanguagesController.cs
index 7f831f08..87800db2 100644
--- a/zero.Web/Controllers/LanguagesController.cs
+++ b/zero.Web/Controllers/LanguagesController.cs
@@ -4,27 +4,28 @@ using System.Linq;
 using System.Threading.Tasks;
 using zero.Core.Api;
 using zero.Core.Entities;
+using zero.Core.Extensions;
 using zero.Core.Identity;
-using zero.Web.Filters;
 
 namespace zero.Web.Controllers
 {
   [ZeroAuthorize(Permissions.Settings.Languages, PermissionsValue.Read)]
-  public class LanguagesController<T> : BackofficeController where T : ILanguage, new()
+  public class LanguagesController : BackofficeController
   {
-    ILanguagesApi<T> Api;
+    ILanguagesApi Api;
+    ILanguage Blueprint;
 
-
-    public LanguagesController(ILanguagesApi<T> api)
+    public LanguagesController(ILanguagesApi api, ILanguage blueprint)
     {
       Api = api;
+      Blueprint = blueprint;
     }
 
 
     /// <summary>
     /// Get empty language model
     /// </summary>  
-    public IActionResult GetEmpty() => Edit(new T());
+    public IActionResult GetEmpty() => Edit(Blueprint.Clone());
 
 
     /// <summary>
@@ -36,7 +37,7 @@ namespace zero.Web.Controllers
     /// <summary>
     /// Get all languages
     /// </summary>    
-    public async Task<IActionResult> GetAll([FromQuery] ListQuery<T> query) => Json(await Api.GetByQuery(query));
+    public async Task<IActionResult> GetAll([FromQuery] ListQuery<ILanguage> query) => Json(await Api.GetByQuery(query));
 
 
     /// <summary>
@@ -74,7 +75,7 @@ namespace zero.Web.Controllers
     /// Save language
     /// </summary>
     [ZeroAuthorize(Permissions.Settings.Languages, PermissionsValue.Update)]
-    public async Task<IActionResult> Save([FromBody] T model) => Json(await Api.Save(model));
+    public async Task<IActionResult> Save([FromBody] ILanguage model) => Json(await Api.Save(model));
 
 
     /// <summary>
diff --git a/zero.Web/Controllers/PagesController.cs b/zero.Web/Controllers/PagesController.cs
index e21d7c71..dee5053f 100644
--- a/zero.Web/Controllers/PagesController.cs
+++ b/zero.Web/Controllers/PagesController.cs
@@ -40,6 +40,7 @@ namespace zero.Web.Controllers
 
     public IActionResult GetEmpty(string type, string parent = null)
     {
+      // TODO this will return an instance of Page, but the subclass with type=$type is needed
       IPage entity = Blueprint.Clone();
       entity.PageTypeAlias = type;
       entity.ParentId = parent;
diff --git a/zero.Web/Controllers/SettingsController.cs b/zero.Web/Controllers/SettingsController.cs
index 59d4bbaa..6de72a5d 100644
--- a/zero.Web/Controllers/SettingsController.cs
+++ b/zero.Web/Controllers/SettingsController.cs
@@ -14,10 +14,10 @@ namespace zero.Web.Controllers
   {
     IAuthenticationApi AuthApi;
 
-    IApplicationsApi<Application> ApplicationsApi;
+    IApplicationsApi ApplicationsApi;
 
 
-    public SettingsController(IAuthenticationApi authApi, IApplicationsApi<Application> applicationsApi)
+    public SettingsController(IAuthenticationApi authApi, IApplicationsApi applicationsApi)
     {
       AuthApi = authApi;
       ApplicationsApi = applicationsApi;
@@ -68,7 +68,7 @@ namespace zero.Web.Controllers
         }
       }
 
-      IList<Application> applications = new List<Application>();
+      IList<IApplication> applications = new List<IApplication>();
 
       if (Permission.CanReadKey(permissions, Permissions.Settings.Applications, false))
       {
diff --git a/zero.Web/Controllers/TranslationsController.cs b/zero.Web/Controllers/TranslationsController.cs
index 1e73a2dc..be06922c 100644
--- a/zero.Web/Controllers/TranslationsController.cs
+++ b/zero.Web/Controllers/TranslationsController.cs
@@ -2,26 +2,28 @@
 using System.Threading.Tasks;
 using zero.Core.Api;
 using zero.Core.Entities;
+using zero.Core.Extensions;
 using zero.Core.Identity;
-using zero.Web.Models;
 
 namespace zero.Web.Controllers
 {
   [ZeroAuthorize(Permissions.Settings.Translations, PermissionsValue.Read)]
-  public class TranslationsController<T> : BackofficeController where T : ITranslation, new()
+  public class TranslationsController : BackofficeController
   {
-    ITranslationsApi<T> Api;
+    ITranslationsApi Api;
+    ITranslation Blueprint;
 
-    public TranslationsController(ITranslationsApi<T> api)
+    public TranslationsController(ITranslationsApi api, ITranslation blueprint)
     {
       Api = api;
+      Blueprint = blueprint;
     }
 
 
     /// <summary>
     /// Get translation by id
     /// </summary>  
-    public IActionResult GetEmpty() => Edit(new T());
+    public IActionResult GetEmpty() => Edit(Blueprint.Clone());
 
 
     /// <summary>
@@ -33,14 +35,14 @@ namespace zero.Web.Controllers
     /// <summary>
     /// Get all translations
     /// </summary>    
-    public async Task<IActionResult> GetAll([FromQuery] ListQuery<T> query) => Json(await Api.GetByQuery(query));
+    public async Task<IActionResult> GetAll([FromQuery] ListQuery<ITranslation> query) => Json(await Api.GetByQuery(query));
 
 
     /// <summary>
     /// Save translation
     /// </summary>
     [ZeroAuthorize(Permissions.Settings.Translations, PermissionsValue.Update)]
-    public async Task<IActionResult> Save([FromBody] T model) => Json(await Api.Save(model));
+    public async Task<IActionResult> Save([FromBody] ITranslation model) => Json(await Api.Save(model));
 
 
     /// <summary>
diff --git a/zero.Web/Controllers/UsersController.cs b/zero.Web/Controllers/UsersController.cs
index d87c68f4..0b785344 100644
--- a/zero.Web/Controllers/UsersController.cs
+++ b/zero.Web/Controllers/UsersController.cs
@@ -8,18 +8,16 @@ using zero.Web.Models;
 namespace zero.Web.Controllers
 {
   [ZeroAuthorize(Permissions.Settings.Users, PermissionsValue.Read)]
-  public class UsersController<T, TLanguage> : BackofficeController 
-    where T : class, IUser
-    where TLanguage : ILanguage
+  public class UsersController : BackofficeController 
   {
-    IUserApi<T> Api;
+    IUserApi Api;
     IAuthenticationApi AuthenticationApi;
     IUserRolesApi RolesApi;
-    ILanguagesApi<TLanguage> LanguagesApi;
+    ILanguagesApi LanguagesApi;
     IPermissionsApi PermissionsApi;
 
 
-    public UsersController(IUserApi<T> api, IAuthenticationApi authenticationApi, IUserRolesApi rolesApi, ILanguagesApi<TLanguage> languagesApi, IPermissionsApi permissionsApi)
+    public UsersController(IUserApi api, IAuthenticationApi authenticationApi, IUserRolesApi rolesApi, ILanguagesApi languagesApi, IPermissionsApi permissionsApi)
     {
       Api = api;
       AuthenticationApi = authenticationApi;
@@ -35,7 +33,7 @@ namespace zero.Web.Controllers
     public IActionResult GetSupportedCultures() => Json(LanguagesApi.GetAllCultures(Options.SupportedLanguages));
 
 
-    public async Task<IActionResult> GetAll([FromQuery] ListQuery<T> query) => Json(await Api.GetByQuery(query));
+    public async Task<IActionResult> GetAll([FromQuery] ListQuery<IUser> query) => Json(await Api.GetByQuery(query));
 
 
     public IActionResult GetAllPermissions() => Json(PermissionsApi.GetAll());
@@ -44,16 +42,16 @@ namespace zero.Web.Controllers
     [ZeroAuthorize]
     public async Task<IActionResult> UpdatePassword([FromBody] UserPasswordEditModel model)
     {
-      EntityResult<T> result;
+      EntityResult<IUser> result;
 
       if (model.NewPassword != model.ConfirmNewPassword)
       {
-        result = EntityResult<T>.Fail(nameof(model.NewPassword), "@errors.changepassword.newpasswordsnotmatching");
+        result = EntityResult<IUser>.Fail(nameof(model.NewPassword), "@errors.changepassword.newpasswordsnotmatching");
       }
       else
       {
         User user = await AuthenticationApi.GetUser();
-        result = await Api.UpdatePassword(user as T, model.CurrentPassword, model.NewPassword);
+        result = await Api.UpdatePassword(user as IUser, model.CurrentPassword, model.NewPassword);
 
         if (result.IsSuccess)
         {
@@ -66,28 +64,28 @@ namespace zero.Web.Controllers
 
 
     [ZeroAuthorize(Permissions.Settings.Users, PermissionsValue.Update)]
-    public async Task<IActionResult> Disable([FromBody] T model)
+    public async Task<IActionResult> Disable([FromBody] IUser model)
     {
-      T entity = await Api.GetUserById(model.Id);
+      IUser entity = await Api.GetUserById(model.Id);
       return Json(await Api.Disable(entity));
     }
 
 
     [ZeroAuthorize(Permissions.Settings.Users, PermissionsValue.Update)]
-    public async Task<IActionResult> Enable([FromBody] T model)
+    public async Task<IActionResult> Enable([FromBody] IUser model)
     {
-      T entity = await Api.GetUserById(model.Id);
+      IUser entity = await Api.GetUserById(model.Id);
       return Json(await Api.Enable(entity));
     }
 
 
     [ZeroAuthorize(Permissions.Settings.Users, PermissionsValue.Update)]
-    public async Task<IActionResult> Save([FromBody] T model) => Json(await Api.Save(model));
+    public async Task<IActionResult> Save([FromBody] IUser model) => Json(await Api.Save(model));
 
 
     [ZeroAuthorize(Permissions.Settings.Users, PermissionsValue.Update)]
     // TODO do not need settings.users authorization for editing current user profiles
-    public async Task<IActionResult> SaveCurrent([FromBody] T model) => Json(await Api.Save(model));
+    public async Task<IActionResult> SaveCurrent([FromBody] IUser model) => Json(await Api.Save(model));
 
 
     [ZeroAuthorize(Permissions.Settings.Users, PermissionsValue.Update)]
diff --git a/zero.Web/Defaults/ZeroBackofficePlugin.cs b/zero.Web/Defaults/ZeroBackofficePlugin.cs
index 9b63b8a7..8992ec9f 100644
--- a/zero.Web/Defaults/ZeroBackofficePlugin.cs
+++ b/zero.Web/Defaults/ZeroBackofficePlugin.cs
@@ -7,6 +7,7 @@ using zero.Core.Entities;
 using zero.Core.Extensions;
 using zero.Core.Options;
 using zero.Core.Plugins;
+using zero.Core.Validation;
 using zero.Web.Mapper;
 using zero.Web.Sections;
 
@@ -20,24 +21,19 @@ namespace zero.Web.Defaults
       services.AddAll(typeof(IValidator), ServiceLifetime.Scoped);
 
       services.AddTransient<IApplication, Application>();
+      //services.AddTransient<IValidator<IApplication>, ApplicationValidator>();
       services.AddTransient<ICountry, Country>();
       services.AddTransient<ILanguage, Language>();
       services.AddTransient<ITranslation, Translation>();
       services.AddTransient<IPage, Page>();
       services.AddTransient<IRecycledEntity, RecycledEntity>();
 
-      services.AddTransient(typeof(IApplicationsApi<>), typeof(ApplicationsApi<>));
-      services.AddTransient(typeof(ICountriesApi<>), typeof(CountriesApi<>));
-      services.AddTransient(typeof(ILanguagesApi<>), typeof(LanguagesApi<>));
-      services.AddTransient(typeof(ITranslationsApi), typeof(TranslationsApi));
-      services.AddTransient(typeof(ITranslationsApi<>), typeof(TranslationsApi<>));
-      services.AddTransient(typeof(ITranslationsApiFacade), typeof(TranslationsApiFacade));
-      //services.AddTransient(typeof(IPagesApi<>), typeof(PagesApi<>));
-      //services.AddTransient(typeof(IPageTreeApi<>), typeof(PageTreeApi<>));
-      services.AddTransient(typeof(IUserApi<>), typeof(UserApi<>));
-      services.AddTransient(typeof(IRecycleBinApi), typeof(RecycleBinApi));
-      // services.AddTransient(typeof(IRecycleBinApi), typeof(RecycleBinApi<RecycledEntity>));
 
+      services.AddTransient<IApplicationsApi, ApplicationsApi>();
+      services.AddTransient<ICountriesApi, CountriesApi>();
+      services.AddTransient<ILanguagesApi, LanguagesApi>();
+      services.AddTransient<ITranslationsApi, TranslationsApi>();
+      services.AddTransient<IUserApi, UserApi>();
       services.AddTransient<IPagesApi, PagesApi>();
       services.AddTransient<IPageTreeApi, PageTreeApi>();
 
@@ -54,6 +50,7 @@ namespace zero.Web.Defaults
       services.AddTransient<IMediaFolderApi, MediaFolderApi>();
       services.AddTransient<IMediaUploadApi, MediaUploadApi>();
       services.AddTransient<IModulesApi, ModulesApi>();
+      services.AddTransient<IRecycleBinApi, RecycleBinApi>();
     }
     
     public void Configure(IZeroPluginOptions plugin, IZeroOptions zero)
diff --git a/zero.Web/Filters/BackofficeGenericControllerAttribute.cs b/zero.Web/Filters/BackofficeGenericControllerAttribute.cs
deleted file mode 100644
index 9697ca2d..00000000
--- a/zero.Web/Filters/BackofficeGenericControllerAttribute.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using Microsoft.AspNetCore.Mvc.ApplicationModels;
-using System;
-using zero.Core.Extensions;
-
-namespace zero.Web.Filters
-{
-  public class BackofficeGenericControllerAttribute : Attribute, IControllerModelConvention
-  {
-    const char BACKTICK = '`';
-
-    const string CONTROLLER = "Controller";
-
-
-    public void Apply(ControllerModel controller)
-    {
-      if (controller.ControllerName.Contains(BACKTICK))
-      {
-        controller.ControllerName = controller.ControllerName.Split(BACKTICK)[0].TrimEnd(CONTROLLER);   
-      }
-    }
-  }
-}
diff --git a/zero.Web/ZeroBuilder.cs b/zero.Web/ZeroBuilder.cs
index aab3c978..8121d574 100644
--- a/zero.Web/ZeroBuilder.cs
+++ b/zero.Web/ZeroBuilder.cs
@@ -93,7 +93,6 @@ namespace zero.Web
       {
         Mvc.AddRazorRuntimeCompilation();
       }
-      Mvc.PartManager.FeatureProviders.Add(new ApiControllerFeatureProvider(Services));
 
 
       // configure Raven + Identity
diff --git a/zero.Web/ZeroVue.cs b/zero.Web/ZeroVue.cs
index c1cef1d4..521dd25e 100644
--- a/zero.Web/ZeroVue.cs
+++ b/zero.Web/ZeroVue.cs
@@ -27,7 +27,7 @@ namespace zero.Web
 
     protected IWebHostEnvironment Environment { get; private set; }
 
-    protected IApplicationsApi<Application> ApplicationsApi { get; private set; }
+    protected IApplicationsApi ApplicationsApi { get; private set; }
 
     protected IAuthenticationApi AuthenticationApi { get; private set; }
 
@@ -38,7 +38,7 @@ namespace zero.Web
     protected IApplicationContext AppContext { get; private set; }
 
 
-    public ZeroVue(IZeroOptions options, IWebHostEnvironment env, IApplicationsApi<Application> applicationsApi, IAuthenticationApi authenticationApi, IMapper mapper, IEnumerable<IZeroPlugin> plugins, IApplicationContext appContext)
+    public ZeroVue(IZeroOptions options, IWebHostEnvironment env, IApplicationsApi applicationsApi, IAuthenticationApi authenticationApi, IMapper mapper, IEnumerable<IZeroPlugin> plugins, IApplicationContext appContext)
     {
       Environment = env;
       Options = options;
@@ -219,7 +219,7 @@ namespace zero.Web
     /// </summary>
     async Task<List<ZeroVueApplication>> CreateApplications()
     {
-      IList<Application> applications = await ApplicationsApi.GetAll();
+      IList<IApplication> applications = await ApplicationsApi.GetAll();
 
       return applications.OrderBy(app => app.Sort).Select(app => new ZeroVueApplication()
       {