diff --git a/src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancer.cs b/src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancer.cs
index fe4e5baf..100ee6f0 100644
--- a/src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancer.cs
+++ b/src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancer.cs
@@ -1,3 +1,4 @@
+using System;
 using Ocelot.Responses;
 using Ocelot.Values;
 
diff --git a/src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancerHouse.cs b/src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancerHouse.cs
new file mode 100644
index 00000000..065ae2ac
--- /dev/null
+++ b/src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancerHouse.cs
@@ -0,0 +1,10 @@
+using Ocelot.Responses;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public interface ILoadBalancerHouse
+    {
+        Response<ILoadBalancer> Get(string key);
+        Response Add(string key, ILoadBalancer loadBalancer);
+    }
+}
\ No newline at end of file
diff --git a/src/Ocelot/LoadBalancer/LoadBalancers/LoadBalancerHouse.cs b/src/Ocelot/LoadBalancer/LoadBalancers/LoadBalancerHouse.cs
new file mode 100644
index 00000000..2bb8b966
--- /dev/null
+++ b/src/Ocelot/LoadBalancer/LoadBalancers/LoadBalancerHouse.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Ocelot.Responses;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public class LoadBalancerHouse
+    {
+        private readonly Dictionary<string, ILoadBalancer> _loadBalancers;
+
+        public LoadBalancerHouse()
+        {
+            _loadBalancers = new Dictionary<string, ILoadBalancer>();
+        }
+
+        public Response<ILoadBalancer> Get(string key)
+        {
+            return new OkResponse<ILoadBalancer>(_loadBalancers[key]);
+        }
+
+        public Response Add(string key, ILoadBalancer loadBalancer)
+        {
+            _loadBalancers[key] = loadBalancer;
+            return new OkResponse();
+        }
+    }
+}
diff --git a/test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs b/test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs
new file mode 100644
index 00000000..2fd15ee7
--- /dev/null
+++ b/test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs
@@ -0,0 +1,121 @@
+using System;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.Responses;
+using Ocelot.Values;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    public class LoadBalancerHouseTests
+    {
+        private ILoadBalancer _loadBalancer;
+        private readonly LoadBalancerHouse _loadBalancerHouse;
+        private Response _addResult;
+        private Response<ILoadBalancer> _getResult;
+        private string _key;
+
+        public LoadBalancerHouseTests()
+        {
+            _loadBalancerHouse = new LoadBalancerHouse();
+        }
+
+        [Fact]
+        public void should_store_load_balancer()
+        {
+            var key = "test";
+
+            this.Given(x => x.GivenThereIsALoadBalancer(key, new FakeLoadBalancer()))
+                .When(x => x.WhenIAddTheLoadBalancer())
+                .Then(x => x.ThenItIsAdded())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_get_load_balancer()
+        {
+            var key = "test";
+
+            this.Given(x => x.GivenThereIsALoadBalancer(key, new FakeLoadBalancer()))
+                .When(x => x.WhenWeGetThatLoadBalancer(key))
+                .Then(x => x.ThenItIsReturned())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_store_load_balancers_by_key()
+        {
+            var key = "test";
+            var keyTwo = "testTwo";
+
+            this.Given(x => x.GivenThereIsALoadBalancer(key, new FakeLoadBalancer()))
+                .And(x => x.GivenThereIsALoadBalancer(keyTwo, new FakeRoundRobinLoadBalancer()))
+                .When(x => x.WhenWeGetThatLoadBalancer(key))
+                .Then(x => x.ThenTheLoadBalancerIs<FakeLoadBalancer>())
+                .When(x => x.WhenWeGetThatLoadBalancer(keyTwo))
+                .Then(x => x.ThenTheLoadBalancerIs<FakeRoundRobinLoadBalancer>())
+                .BDDfy();
+        }
+
+        private void ThenTheLoadBalancerIs<T>()
+        {
+            _getResult.Data.ShouldBeOfType<T>();
+        }
+
+        private void ThenItIsAdded()
+        {
+            _addResult.IsError.ShouldBe(false);
+            _addResult.ShouldBeOfType<OkResponse>();
+        }
+
+        private void WhenIAddTheLoadBalancer()
+        {
+            _addResult = _loadBalancerHouse.Add(_key, _loadBalancer);
+        }
+
+
+        private void GivenThereIsALoadBalancer(string key, ILoadBalancer loadBalancer)
+        {
+            _key = key;
+            _loadBalancer = loadBalancer;
+            WhenIAddTheLoadBalancer();
+        }
+
+        private void WhenWeGetThatLoadBalancer(string key)
+        {
+            _getResult = _loadBalancerHouse.Get(key);
+        }
+
+        private void ThenItIsReturned()
+        {
+            _getResult.Data.ShouldBe(_loadBalancer);
+        }
+
+        class FakeLoadBalancer : ILoadBalancer
+        {
+            public Response<HostAndPort> Lease()
+            {
+                throw new NotImplementedException();
+            }
+
+            public Response Release(HostAndPort hostAndPort)
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        class FakeRoundRobinLoadBalancer : ILoadBalancer
+        {
+            public Response<HostAndPort> Lease()
+            {
+                throw new NotImplementedException();
+            }
+
+            public Response Release(HostAndPort hostAndPort)
+            {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}