diff --git a/.editorconfig b/.editorconfig
index 20fe9082..86bad1fa 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -13,7 +13,7 @@ tab_width = 4
 
 # New line preferences
 end_of_line = crlf
-insert_final_newline = false
+insert_final_newline = true
 
 #### .NET Coding Conventions ####
 
diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
new file mode 100644
index 00000000..a1443956
--- /dev/null
+++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs
@@ -0,0 +1,213 @@
+/* 
+ * Copyright 2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using NUnit.Framework;
+using OptimizelySDK.Odp;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+namespace OptimizelySDK.Tests.OdpTests
+{
+    public class LruCacheTest
+    {
+        private List<string> _segments1And2;
+        private List<string> _segments3And4;
+        private List<string> _segments5And6;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _segments1And2 = new List<string>
+            {
+                "segment1",
+                "segment2",
+            };
+            _segments3And4 = new List<string>
+            {
+                "segment3",
+                "segment4",
+            };
+            _segments5And6 = new List<string>
+            {
+                "segment5",
+                "segment6",
+            };
+        }
+
+        [Test]
+        public void ShouldCreateSaveAndLookupOneItem()
+        {
+            var cache = new LruCache<string>();
+            Assert.IsNull(cache.Lookup("key1"));
+
+            cache.Save("key1", "value1");
+            Assert.AreEqual("value1", cache.Lookup("key1"));
+        }
+
+        [Test]
+        public void ShouldSaveAndLookupMultipleItems()
+        {
+            var cache = new LruCache<List<string>>();
+
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            var cacheKeys = cache._readCurrentCacheKeys();
+
+            Assert.AreEqual("user3", cacheKeys[0]);
+            Assert.AreEqual("user2", cacheKeys[1]);
+            Assert.AreEqual("user1", cacheKeys[2]);
+
+            // Lookup should move user1 to top of the list and push down others.
+            Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
+
+            cacheKeys = cache._readCurrentCacheKeys();
+            Assert.AreEqual("user1", cacheKeys[0]);
+            Assert.AreEqual("user3", cacheKeys[1]);
+            Assert.AreEqual("user2", cacheKeys[2]);
+
+            // Lookup should move user2 to the beginning of the list and push others.
+            Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
+
+            cacheKeys = cache._readCurrentCacheKeys();
+            Assert.AreEqual("user2", cacheKeys[0]);
+            Assert.AreEqual("user1", cacheKeys[1]);
+            Assert.AreEqual("user3", cacheKeys[2]);
+
+            // Lookup moves user3 to top and pushes others down.
+            Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
+
+            cacheKeys = cache._readCurrentCacheKeys();
+            Assert.AreEqual("user3", cacheKeys[0]);
+            Assert.AreEqual("user2", cacheKeys[1]);
+            Assert.AreEqual("user1", cacheKeys[2]);
+        }
+
+        [Test]
+        public void ShouldReorderListOnSave()
+        {
+            var cache = new LruCache<List<string>>();
+
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            var cacheKeys = cache._readCurrentCacheKeys();
+            
+            // last added should be at the top of the list
+            Assert.AreEqual("user3",cacheKeys[0]);
+            Assert.AreEqual("user2",cacheKeys[1]);
+            Assert.AreEqual("user1" ,cacheKeys[2]);
+
+            // save should move user1 to the top of the list and push down others.
+            cache.Save("user1", _segments1And2);
+            
+            cacheKeys = cache._readCurrentCacheKeys();
+            Assert.AreEqual("user1",cacheKeys[0]);
+            Assert.AreEqual("user3",cacheKeys[1]);
+            Assert.AreEqual("user2",cacheKeys[2]);
+
+            // save user2 should bring it to the top and push down others.
+            cache.Save("user2", _segments3And4);
+            
+            cacheKeys = cache._readCurrentCacheKeys();
+            Assert.AreEqual("user2",cacheKeys[0]);
+            Assert.AreEqual("user1",cacheKeys[1]);
+            Assert.AreEqual("user3",cacheKeys[2]);
+
+            // saving user3 again should return to the original insertion order.
+            cache.Save("user3", _segments5And6);
+            
+            cacheKeys = cache._readCurrentCacheKeys();
+            Assert.AreEqual("user3",cacheKeys[0]);
+            Assert.AreEqual("user2",cacheKeys[1]);
+            Assert.AreEqual("user1" ,cacheKeys[2]);
+        }
+
+        [Test]
+        public void ShouldHandleWhenCacheIsDisabled()
+        {
+            var cache = new LruCache<List<string>>(maxSize: 0);
+
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            Assert.IsNull(cache.Lookup("user1"));
+            Assert.IsNull(cache.Lookup("user2"));
+            Assert.IsNull(cache.Lookup("user3"));
+        }
+
+        [Test]
+        public void ShouldHandleWhenItemsExpire()
+        {
+            var cache = new LruCache<List<string>>(itemTimeout: TimeSpan.FromSeconds(1));
+
+            cache.Save("user1", _segments1And2);
+
+            Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
+            Assert.AreEqual(1, cache._readCurrentCacheKeys().Length);
+
+            Thread.Sleep(1200);
+
+            Assert.IsNull(cache.Lookup("user1"));
+            Assert.AreEqual(0, cache._readCurrentCacheKeys().Length);
+        }
+
+        [Test]
+        public void ShouldHandleWhenCacheReachesMaxSize()
+        {
+            var cache = new LruCache<List<string>>(maxSize: 2);
+
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            Assert.AreEqual(2, cache._readCurrentCacheKeys().Length);
+
+            Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
+            Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
+            Assert.IsNull(cache.Lookup("user1"));
+        }
+
+        [Test]
+        public void ShouldHandleWhenCacheIsReset()
+        {
+            var cache = new LruCache<List<string>>();
+
+            cache.Save("user1", _segments1And2);
+            cache.Save("user2", _segments3And4);
+            cache.Save("user3", _segments5And6);
+
+            Assert.AreEqual(_segments1And2, cache.Lookup("user1"));
+            Assert.AreEqual(_segments3And4, cache.Lookup("user2"));
+            Assert.AreEqual(_segments5And6, cache.Lookup("user3"));
+
+            Assert.AreEqual(3, cache._readCurrentCacheKeys().Length);
+
+            cache.Reset();
+
+            Assert.IsNull(cache.Lookup("user1"));
+            Assert.IsNull(cache.Lookup("user2"));
+            Assert.IsNull(cache.Lookup("user3"));
+
+            Assert.AreEqual(0, cache._readCurrentCacheKeys().Length);
+        }
+    }
+}
diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index d0a2d2ae..c563d781 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -80,6 +80,7 @@
     <Compile Include="DefaultErrorHandlerTest.cs" />
     <Compile Include="EntityTests\IntegrationTest.cs" />
     <Compile Include="EventTests\EventProcessorProps.cs" />
+    <Compile Include="OdpTests\LruCacheTest.cs" />
     <Compile Include="OptimizelyConfigTests\OptimizelyConfigTest.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecisionTest.cs" />
     <Compile Include="OptimizelyJSONTest.cs" />
@@ -150,7 +151,6 @@
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/OptimizelySDK/Odp/ICache.cs b/OptimizelySDK/Odp/ICache.cs
new file mode 100644
index 00000000..92a76fd6
--- /dev/null
+++ b/OptimizelySDK/Odp/ICache.cs
@@ -0,0 +1,26 @@
+/* 
+ * Copyright 2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OptimizelySDK.Odp
+{
+    public interface ICache<T> 
+        where T : class
+    {
+        void Save(string key, T value);
+        T Lookup(string key);
+        void Reset();
+    }
+}
diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs
new file mode 100644
index 00000000..c7b04d86
--- /dev/null
+++ b/OptimizelySDK/Odp/LruCache.cs
@@ -0,0 +1,235 @@
+/* 
+ * Copyright 2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using OptimizelySDK.Logger;
+using OptimizelySDK.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OptimizelySDK.Odp
+{
+    public class LruCache<T> : ICache<T>
+        where T : class
+    {
+        /// <summary>
+        /// Default maximum number of elements to store
+        /// </summary>
+        private const int DEFAULT_MAX_SIZE = 10000;
+
+        /// <summary>
+        /// The maximum number of elements that should be stored
+        /// </summary>
+        private readonly int _maxSize;
+
+        /// <summary>
+        /// An object for obtaining a mutually exclusive lock for thread safety
+        /// </summary>
+        private readonly object _mutex;
+
+        /// <summary>
+        /// The maximum age of an object in the cache
+        /// </summary>
+        private readonly TimeSpan _timeout;
+
+        /// <summary>
+        /// Implementation used for recording LRU events or errors 
+        /// </summary>
+        private readonly ILogger _logger;
+
+        /// <summary>
+        /// Indexed data held in the cache 
+        /// </summary>
+        private readonly Dictionary<string, ItemWrapper> _cache;
+
+        /// <summary>
+        /// Ordered list of objects being held in the cache 
+        /// </summary>
+        private readonly LinkedList<ItemWrapper> _list;
+
+        /// <summary>
+        /// A Least Recently Used in-memory cache
+        /// </summary>
+        /// <param name="maxSize">Maximum number of elements to allow in the cache</param>
+        /// <param name="itemTimeout">Timeout or time to live for each item</param>
+        /// <param name="logger">Implementation used for recording LRU events or errors</param>
+        public LruCache(int maxSize = DEFAULT_MAX_SIZE, TimeSpan? itemTimeout = default,
+            ILogger logger = null
+        )
+        {
+            _mutex = new object();
+
+            _maxSize = Math.Max(0, maxSize);
+
+            _logger = logger ?? new DefaultLogger();
+
+            _timeout = itemTimeout ?? TimeSpan.FromMinutes(10);
+            if (_timeout < TimeSpan.Zero)
+            {
+                _logger.Log(LogLevel.WARN,
+                    "Negative item timeout provided. Items will not expire in cache.");
+                _timeout = TimeSpan.Zero;
+            }
+
+            _cache = new Dictionary<string, ItemWrapper>(_maxSize);
+
+            _list = new LinkedList<ItemWrapper>();
+        }
+
+        /// <summary>
+        /// Saves a new element into the cache
+        /// </summary>
+        /// <param name="key">Key of the element used for future retrieval</param>
+        /// <param name="value">Strongly-typed value to store against the key</param>
+        public void Save(string key, T value)
+        {
+            if (_maxSize == 0)
+            {
+                _logger.Log(LogLevel.WARN,
+                    "Unable to Save(). LRU Cache is disabled. Set maxSize > 0 to enable.");
+                return;
+            }
+
+            lock (_mutex)
+            {
+                if (_cache.ContainsKey(key))
+                {
+                    var item = _cache[key];
+                    _list.Remove(item);
+                    _list.AddFirst(item);
+                    _cache[key] = item;
+                }
+                else
+                {
+                    if (_cache.Count >= _maxSize)
+                    {
+                        var leastRecentlyUsedItem = _list.Last;
+
+                        var leastRecentlyUsedItemKey = (from cacheItem in _cache
+                            where cacheItem.Value == leastRecentlyUsedItem.Value
+                            select cacheItem.Key).FirstOrDefault();
+
+                        if (leastRecentlyUsedItemKey != null)
+                        {
+                            _cache.Remove(leastRecentlyUsedItemKey);
+                        }
+
+                        _list.Remove(leastRecentlyUsedItem);
+                    }
+
+                    var item = new ItemWrapper(value);
+                    _list.AddFirst(item);
+                    _cache.Add(key, item);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Retrieves an element from the cache, reordering the elements
+        /// </summary>
+        /// <param name="key">Key of element to find and retrieve</param>
+        /// <returns>Strongly-typed value from the cache</returns>
+        public T Lookup(string key)
+        {
+            if (_maxSize == 0)
+            {
+                _logger.Log(LogLevel.WARN,
+                    "Unable to Lookup(). LRU Cache is disabled. Set maxSize > 0 to enable.");
+                return default;
+            }
+
+            lock (_mutex)
+            {
+                if (!_cache.ContainsKey(key))
+                {
+                    return default;
+                }
+
+                ItemWrapper item = _cache[key];
+
+                var currentTimestamp = DateTime.Now.MillisecondsSince1970();
+
+                var itemReturn = default(T);
+                if (_timeout == TimeSpan.Zero ||
+                    (currentTimestamp - item.CreationTimestamp < _timeout.TotalMilliseconds))
+                {
+                    _list.Remove(item);
+                    _list.AddFirst(item);
+
+                    itemReturn = item.Value;
+                }
+                else
+                {
+                    _cache.Remove(key);
+                    _list.Remove(item);
+                }
+
+                return itemReturn;
+            }
+        }
+
+        /// <summary>
+        /// Clears all the elements from the cache 
+        /// </summary>
+        public void Reset()
+        {
+            lock (_mutex)
+            {
+                _cache.Clear();
+                _list.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Wrapping class around a generic value stored in the cache
+        /// </summary>
+        public class ItemWrapper
+        {
+            /// <summary>
+            /// Value of the item
+            /// </summary>
+            public readonly T Value;
+
+            /// <summary>
+            /// Unix timestamp of when the item was added  
+            /// </summary>
+            public readonly long CreationTimestamp;
+
+            /// <summary>
+            /// Initialize the wrapper
+            /// </summary>
+            /// <param name="value">Item to be stored</param>
+            public ItemWrapper(T value)
+            {
+                Value = value;
+                CreationTimestamp = DateTime.Now.MillisecondsSince1970();
+            }
+        }
+
+        /// <summary>
+        /// Read the current cache index/linked list for unit testing
+        /// </summary>
+        /// <returns></returns>
+        public string[] _readCurrentCacheKeys()
+        {
+            _logger.Log(LogLevel.WARN, "_readCurrentCacheKeys used for non-testing purpose");
+
+            return (from listItem in _list
+                join cacheItem in _cache on listItem equals cacheItem.Value
+                select cacheItem.Key).ToArray();
+        }
+    }
+}
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index 2db6cd33..4d08ff70 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -88,6 +88,8 @@
     <Compile Include="Entity\IdKeyEntity.cs" />
     <Compile Include="Entity\Integration.cs" />
     <Compile Include="Event\Entity\DecisionMetadata.cs" />
+    <Compile Include="Odp\ICache.cs" />
+    <Compile Include="Odp\LruCache.cs" />
     <Compile Include="OptimizelyDecisions\DecisionMessage.cs" />
     <Compile Include="OptimizelyDecisions\DecisionReasons.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecideOption.cs" />
@@ -176,7 +178,6 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup />
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.