diff --git a/zero.Core/Api/AppIdService.cs b/zero.Core/Api/AppId.cs
similarity index 100%
rename from zero.Core/Api/AppIdService.cs
rename to zero.Core/Api/AppId.cs
diff --git a/zero.Core/Api/ApplicationContext.cs b/zero.Core/Api/ApplicationContext.cs
new file mode 100644
index 00000000..d3126f0c
--- /dev/null
+++ b/zero.Core/Api/ApplicationContext.cs
@@ -0,0 +1,283 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.Identity;
+using Raven.Client.Documents;
+using Raven.Client.Documents.Session;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using zero.Core.Entities;
+using zero.Core.Extensions;
+using zero.Core.Identity;
+using zero.Core.Options;
+
+namespace zero.Core.Api
+{
+  public class ApplicationContext : IApplicationContext
+  {
+    /// <inheritdoc />
+    public IApplication App { get; protected set; }
+
+    /// <inheritdoc />
+    public string AppId { get; protected set; }
+
+    protected IDocumentStore Raven { get; private set; }
+
+    protected IZeroOptions Options { get; private set; }
+
+    protected UserManager<User> UserManager { get; private set; }
+
+
+
+    public ApplicationContext(IDocumentStore raven, IZeroOptions options, UserManager<User> userManager)
+    {
+      Raven = raven;
+      Options = options;
+      UserManager = userManager;
+    }
+
+
+    /// <inheritdoc />
+    public async Task<IApplication> Resolve(HttpContext context)
+    {
+      if (context?.Request == null)
+      {
+        return null;
+      }
+
+      IApplication app;
+
+      if (IsBackofficeRequest(context))
+      {
+        app = await ResolveFromUser(context.User);
+      }
+      else
+      {
+        app = await ResolveFromRequest(context);
+      }
+
+      App = app;
+      AppId = app?.Id;
+
+      return app;
+    }
+
+
+    /// <inheritdoc />
+    public async Task<bool> TrySwitchForUser(User user, string appId)
+    {
+      if (user == null || appId.IsNullOrEmpty())
+      {
+        return false;
+      }
+
+      string[] allowedAppIds = GetAllowedAppIdsForUser(user);
+
+      bool isMainId = appId.Equals(user.AppId, StringComparison.InvariantCultureIgnoreCase);
+      bool isAllowedId = allowedAppIds.Contains(appId, StringComparer.InvariantCultureIgnoreCase);
+
+      if (user.IsSuper || isMainId || isAllowedId)
+      {
+        user.CurrentAppId = appId;
+
+        IdentityResult updateResult = await UserManager.UpdateAsync(user);
+        return updateResult.Succeeded;
+      }
+
+      return false;
+    }
+       
+
+    /// <inheritdoc />
+    public async Task<IApplication> ResolveFromUser(ClaimsPrincipal user)
+    {
+      User userEntity = await UserManager.GetUserAsync(user);
+      return await ResolveFromUser(userEntity);
+    }
+
+
+    /// <inheritdoc />
+    public async Task<IApplication> ResolveFromUser(User user)
+    {
+      if (user == null)
+      {
+        return null;
+      }
+
+      string appId = null;
+      string[] allowedAppIds = GetAllowedAppIdsForUser(user);
+
+      if (!user.CurrentAppId.IsNullOrEmpty())
+      {
+        if (user.IsSuper || allowedAppIds.Contains(user.CurrentAppId, StringComparer.InvariantCultureIgnoreCase))
+        {
+          appId = user.CurrentAppId;
+        }
+        else
+        {
+          appId = user.AppId;
+        }
+      }
+      else
+      {
+        appId = user.AppId;
+      }
+
+      if (appId.IsNullOrEmpty())
+      {
+        throw new Exception($"User entity ${user.Id} needs a valid AppId");
+      }
+
+      using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
+      {
+        return await session.LoadAsync<Application>(appId);
+      }
+    }
+
+
+    /// <inheritdoc />
+    public async Task<IApplication> ResolveFromRequest(HttpContext context)
+    {
+      return await ResolveFromUri(context.Request.GetEncodedUrl());
+    }
+
+
+    /// <inheritdoc />
+    public async Task<IApplication> ResolveFromUri(string uriString)
+    {
+      return ResolveFromUriInternal(new Uri(uriString, UriKind.Absolute), await GetApplications());
+    }
+
+
+    /// <inheritdoc />
+    public async Task<IApplication> ResolveFromUri(Uri uri)
+    {
+      return ResolveFromUriInternal(uri, await GetApplications());
+    }
+
+
+    /// <summary>
+    /// Get matching application from an URI
+    /// </summary>
+    IApplication ResolveFromUriInternal(Uri uri, IList<Application> apps)
+    {
+      IApplication currentApp = null;
+
+      foreach (Application app in apps)
+      {
+        if (app.Domains?.Length < 1)
+        {
+          continue;
+        }
+
+        foreach (string domain in app.Domains)
+        {
+          Uri domainUri = new Uri(domain, UriKind.Absolute);
+
+          int compareResult = Uri.Compare(uri, domainUri, UriComponents.HostAndPort, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase);
+
+          if (compareResult == 0)
+          {
+            currentApp = app;
+            break;
+          }
+        }
+      }
+
+      return currentApp;
+    }
+
+
+    /// <summary>
+    /// Get all applications to choose from
+    /// </summary>
+    async Task<IList<Application>> GetApplications()
+    {
+      using (IAsyncDocumentSession session = Raven.OpenAsyncSession())
+      {
+        return await session.Query<Application>().ToListAsync();
+      }
+    }
+
+
+    /// <summary>
+    /// Get applications the user has access to
+    /// </summary>
+    string[] GetAllowedAppIdsForUser(User user)
+    {
+      IEnumerable<Permission> permissions = user.Claims
+        .Where(claim => claim.Type == Constants.Auth.Claims.Permission && claim.Value.StartsWith(Permissions.Applications))
+        .Select(x => Permission.FromClaim(x.ToClaim(), Permissions.Applications));
+
+      string[] appIds = permissions.Where(x => x.IsTrue).Select(x => x.NormalizedKey).ToArray();
+
+      return appIds;
+    }
+
+
+    /// <summary>
+    /// Whether the current request is a backoffice request
+    /// </summary>
+    bool IsBackofficeRequest(HttpContext context)
+    {
+      string path = Options.BackofficePath.EnsureStartsWith('/').TrimEnd('/');
+      return context.Request.Path.ToString().StartsWith(path);
+    }
+  }
+
+
+
+  public interface IApplicationContext
+  {
+    /// <summary>
+    /// Currently loaded application
+    /// </summary>
+    IApplication App { get; }
+
+    /// <summary>
+    /// Current loaded application Id
+    /// </summary>
+    string AppId { get; }
+
+    /// <summary>
+    /// Resolves the current application from either the backoffice user (in case it is backoffice request)
+    /// or the domain (in case it is frontend request).
+    /// The resolved data is stored in the App + AppId properties.
+    /// </summary>
+    Task<IApplication> Resolve(HttpContext context);
+
+    /// <summary>
+    /// Try to switch the current application for a user
+    /// </summary>
+    Task<bool> TrySwitchForUser(User user, string appId);
+
+    /// <summary>
+    /// Resolves the current application from the request path
+    /// </summary>
+    Task<IApplication> ResolveFromRequest(HttpContext context);
+
+    /// <summary>
+    /// Get matching application from an URI string
+    /// </summary>
+    Task<IApplication> ResolveFromUri(string uriString);
+
+    /// <summary>
+    /// Get matching application from an URI
+    /// </summary>
+    Task<IApplication> ResolveFromUri(Uri uri);
+
+    /// <summary>
+    /// Resolves the current application from the logged-in backoffice user.
+    /// This method won't return apps the user has no access to.
+    /// </summary>
+    Task<IApplication> ResolveFromUser(ClaimsPrincipal user);
+
+    /// <summary>
+    /// Resolves the current application from a user.
+    /// This method won't return apps the user has no access to.
+    /// </summary>
+    Task<IApplication> ResolveFromUser(User user);
+  }
+}
diff --git a/zero.Core/Api/BackofficeStore.cs b/zero.Core/Api/BackofficeStore.cs
index a480ba2e..bb235e78 100644
--- a/zero.Core/Api/BackofficeStore.cs
+++ b/zero.Core/Api/BackofficeStore.cs
@@ -1,13 +1,11 @@
 using FluentValidation;
 using FluentValidation.Results;
-using Microsoft.AspNetCore.Http;
 using Raven.Client.Documents;
 using Raven.Client.Documents.Linq;
 using Raven.Client.Documents.Session;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Security.Claims;
 using System.Threading.Tasks;
 using zero.Core.Attributes;
 using zero.Core.Entities;
@@ -239,10 +237,9 @@ namespace zero.Core.Api
 
   public class AppAwareBackofficeStore : BackofficeStore, IAppAwareBackofficeStore
   {
-    public AppAwareBackofficeStore(IDocumentStore raven, IMediaUpload media, IHttpContextAccessor httpContextAccessor) : base(raven, media)
+    public AppAwareBackofficeStore(IDocumentStore raven, IMediaUpload media, IApplicationContext context) : base(raven, media)
     {
-      Claim appIdClaim = httpContextAccessor.HttpContext?.User.Claims.FirstOrDefault(x => x.Type == Constants.Auth.Claims.CurrentAppId);
-      AppId = appIdClaim?.Value;
+      AppId = context.AppId;
     }
   }
 }
diff --git a/zero.Core/Entities/Applications/Application.cs b/zero.Core/Entities/Applications/Application.cs
index e3d433e3..552fe397 100644
--- a/zero.Core/Entities/Applications/Application.cs
+++ b/zero.Core/Entities/Applications/Application.cs
@@ -5,37 +5,59 @@ namespace zero.Core.Entities
   /// <summary>
   /// An application is a website. zero can host multiple websites at once which share common assets
   /// </summary>
-  public class Application : ZeroEntity, IZeroDbConventions
+  public class Application : ZeroEntity, IApplication
+  {
+    /// <inheritdoc />
+    public string FullName { get; set; }
+
+    /// <inheritdoc />
+    public string Email { get; set; }
+
+    /// <inheritdoc />
+    public string ImageId { get; set; }
+
+    /// <inheritdoc />
+    public string IconId { get; set; }
+
+    /// <inheritdoc />
+    public string[] Domains { get; set; } = new string[] { };
+
+    /// <inheritdoc />
+    public List<string> Features { get; set; } = new List<string>();
+  }
+
+
+  public interface IApplication : IZeroEntity, IZeroDbConventions
   {
     /// <summary>
     /// Full company or product name
     /// </summary>
-    public string FullName { get; set; }
+    string FullName { get; set; }
 
     /// <summary>
     /// Generic contact email. Can be used in various locations
     /// </summary>
-    public string Email { get; set; }
+    string Email { get; set; }
 
     /// <summary>
     /// Image of the application
     /// </summary>
-    public string ImageId { get; set; }
+    string ImageId { get; set; }
 
     /// <summary>
     /// Simple image of the application (used as favicon)
     /// </summary>
-    public string IconId { get; set; }
+    string IconId { get; set; }
 
     /// <summary>
     /// All assigned domains for this application
     /// </summary>
-    public string[] Domains { get; set; } = new string[] { };
+    string[] Domains { get; set; }
 
     /// <summary>
     /// Features which are enabled for this application.
     /// Can be user-defined and affect both backoffice and frontend
     /// </summary>
-    public List<string> Features { get; set; } = new List<string>();
+    List<string> Features { get; set; }
   }
 }
\ No newline at end of file
diff --git a/zero.Core/Middlewares/ApplicationContextMiddleware.cs b/zero.Core/Middlewares/ApplicationContextMiddleware.cs
new file mode 100644
index 00000000..5c5e4da9
--- /dev/null
+++ b/zero.Core/Middlewares/ApplicationContextMiddleware.cs
@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Http;
+using System.Threading.Tasks;
+using zero.Core.Api;
+
+namespace zero.Core.Middlewares
+{
+  public class ApplicationContextMiddleware
+  {
+    RequestDelegate Next;
+
+
+    public ApplicationContextMiddleware(RequestDelegate next)
+    {
+      Next = next;
+    }
+
+
+    public async Task Invoke(HttpContext httpContext, IApplicationContext appContext)
+    {
+      await appContext.Resolve(httpContext);
+      await Next(httpContext);
+    }
+  }
+}
diff --git a/zero.Web.UI/App/navigation.vue b/zero.Web.UI/App/navigation.vue
index d77948df..ab32f9e3 100644
--- a/zero.Web.UI/App/navigation.vue
+++ b/zero.Web.UI/App/navigation.vue
@@ -5,7 +5,7 @@
 
     <ui-dropdown v-if="applications.length > 0" class="app-nav-switch">
       <template v-slot:button>
-        <ui-button type="action block" :label="applications[0].name" caret="down" />
+        <ui-button type="action block" :label="currentApplication.name" caret="down" />
       </template>
       <ui-dropdown-list v-model="applicationItems" :action="applicationChanged" />
     </ui-dropdown>
@@ -46,7 +46,7 @@
 
 
 <script>
-  import { map as _map } from 'underscore';
+  import { map as _map, find as _find } from 'underscore';
   import AuthApi from 'zero/services/auth.js'
 
   export default {
@@ -60,6 +60,15 @@
       userActions: []
     }),
 
+
+    computed: {
+      currentApplication()
+      {
+        return _find(this.applications, x => x.id === zero.appId);
+      }
+    },
+
+
     created()
     {
       this.user = AuthApi.user;
@@ -105,8 +114,21 @@
       {
         return {
           application: item,
-          active: item.name === "Brothers", // TODO correct active application
-          name: item.name
+          active: item.id === zero.appId,
+          name: item.name,
+          action: (_, opts) =>
+          {
+            opts.loading(true);
+
+            AuthApi.switchApp(item.id).then(success =>
+            {
+              opts.loading(false);
+              if (success)
+              {
+                location.reload();
+              }
+            });
+          }
         };
       });
 
diff --git a/zero.Web.UI/App/services/auth.js b/zero.Web.UI/App/services/auth.js
index 5b99113a..86c156bc 100644
--- a/zero.Web.UI/App/services/auth.js
+++ b/zero.Web.UI/App/services/auth.js
@@ -91,6 +91,12 @@ export default new Vue({
       return promise;
     },
 
+    // try to switch selected application for user
+    switchApp(appId)
+    {
+      return Axios.post('authentication/switchApp', null, { params: { appId } }).then(res => Promise.resolve(res.data.success));
+    },
+
     // open overlay to update password
     openPasswordOverlay()
     {
diff --git a/zero.Web/Controllers/ApplicationsController.cs b/zero.Web/Controllers/ApplicationsController.cs
index 5faca92c..72725f51 100644
--- a/zero.Web/Controllers/ApplicationsController.cs
+++ b/zero.Web/Controllers/ApplicationsController.cs
@@ -79,5 +79,14 @@ namespace zero.Web.Controllers
     {
       return await As<Application, ApplicationEditModel>(await Api.Delete(id));
     }
+
+
+    /// <summary>
+    /// Save translation
+    /// </summary>
+    //public async Task<IActionResult> Switch([FromQuery] string id)
+    //{
+    //  return await As<Application, ApplicationEditModel>(await Api.Save(entity));
+    //}
   }
 }
diff --git a/zero.Web/Controllers/AuthenticationController.cs b/zero.Web/Controllers/AuthenticationController.cs
index 85cd71a4..198ad26b 100644
--- a/zero.Web/Controllers/AuthenticationController.cs
+++ b/zero.Web/Controllers/AuthenticationController.cs
@@ -11,10 +11,13 @@ namespace zero.Web.Controllers
   public class AuthenticationController : BackofficeController
   {
     IAuthenticationApi Api;
+    IApplicationContext AppContext;
 
-    public AuthenticationController(IAuthenticationApi api)
+
+    public AuthenticationController(IAuthenticationApi api, IApplicationContext appContext)
     {
       Api = api;
+      AppContext = appContext;
     }
 
 
@@ -56,5 +59,21 @@ namespace zero.Web.Controllers
       await Api.Logout();
       return Json(EntityResult.Success());
     }
+
+
+    /// <summary>
+    /// Try to switch selected application for user
+    /// </summary>
+    [HttpPost, ZeroAuthorize]
+    public async Task<IActionResult> SwitchApp(string appId)
+    {
+      User user = await Api.GetUser();
+      bool isSuccess = await AppContext.TrySwitchForUser(user, appId);
+
+      return Json(new EntityResult() 
+      { 
+        IsSuccess = isSuccess 
+      });
+    }
   }
 }
diff --git a/zero.Web/ZeroApplicationBuilderExtensions.cs b/zero.Web/ZeroApplicationBuilderExtensions.cs
index 54dab5c1..c3dc4f02 100644
--- a/zero.Web/ZeroApplicationBuilderExtensions.cs
+++ b/zero.Web/ZeroApplicationBuilderExtensions.cs
@@ -6,6 +6,7 @@ using System;
 using System.IO;
 using zero.Core;
 using zero.Core.Extensions;
+using zero.Core.Middlewares;
 using zero.Core.Options;
 
 namespace zero.Web
@@ -20,6 +21,8 @@ namespace zero.Web
 
       app.UseStaticFiles();
 
+      app.UseMiddleware<ApplicationContextMiddleware>();
+
       // map backoffice
       app.UseWhen(ctx => ctx.Request.Path.ToString().StartsWith(path), builder =>
       {
diff --git a/zero.Web/ZeroBuilder.cs b/zero.Web/ZeroBuilder.cs
index 55171617..94f12d4d 100644
--- a/zero.Web/ZeroBuilder.cs
+++ b/zero.Web/ZeroBuilder.cs
@@ -92,6 +92,8 @@ namespace zero.Web
 
       Services.AddMapper();
 
+      Services.AddScoped<IApplicationContext, ApplicationContext>();
+
       Services.AddTransient<IBackofficeStore, BackofficeStore>();
       Services.AddTransient<IAppAwareBackofficeStore, AppAwareBackofficeStore>();
 
diff --git a/zero.Web/ZeroVue.cs b/zero.Web/ZeroVue.cs
index ce5ce7b2..5abbc50d 100644
--- a/zero.Web/ZeroVue.cs
+++ b/zero.Web/ZeroVue.cs
@@ -35,8 +35,10 @@ namespace zero.Web
 
     protected IEnumerable<IZeroPlugin> Plugins { get; private set; }
 
+    protected IApplicationContext AppContext { get; private set; }
 
-    public ZeroVue(IZeroOptions options, IWebHostEnvironment env, IApplicationsApi applicationsApi, IAuthenticationApi authenticationApi, IMapper mapper, IEnumerable<IZeroPlugin> plugins)
+
+    public ZeroVue(IZeroOptions options, IWebHostEnvironment env, IApplicationsApi applicationsApi, IAuthenticationApi authenticationApi, IMapper mapper, IEnumerable<IZeroPlugin> plugins, IApplicationContext appContext)
     {
       Environment = env;
       Options = options;
@@ -44,6 +46,7 @@ namespace zero.Web
       AuthenticationApi = authenticationApi;
       Mapper = mapper;
       Plugins = plugins;
+      AppContext = appContext;
       //zero.path = "@Model.BackofficePath.EnsureEndsWith('/')";
       //zero.translations = @Html.Raw(text);
     }
@@ -65,6 +68,7 @@ namespace zero.Web
       config.Applications = await CreateApplications();
       config.Alias = CreateAliases();
       config.SettingsAreas = CreateSettingsAreas();
+      config.AppId = AppContext.AppId;
 
       config.User = await Mapper.Map<User, UserEditModel>(await AuthenticationApi.GetUser());
 
@@ -277,6 +281,8 @@ namespace zero.Web
 
     public string ErrorFieldNone { get; set; }
 
+    public string AppId { get; set; }
+
     public UserEditModel User { get; set; }
 
     public IList<ZeroVueSection> Sections { get; set; } = new List<ZeroVueSection>();