diff --git a/sdk/src/Services/DynamoDBv2/Custom/DataModel/Context.cs b/sdk/src/Services/DynamoDBv2/Custom/DataModel/Context.cs
index 4101648ecd2d..f87807db6755 100644
--- a/sdk/src/Services/DynamoDBv2/Custom/DataModel/Context.cs
+++ b/sdk/src/Services/DynamoDBv2/Custom/DataModel/Context.cs
@@ -53,6 +53,61 @@ public partial class DynamoDBContext : IDynamoDBContext
 
         #endregion
 
+        #region Public methods
+        /// <summary>
+        /// Adds a <see cref="Table"/> to this context's internal cache, which
+        /// will avoid the need to fetch table metadata automatically from DynamoDB.
+        /// This may be used in conjunction with an <see cref="ITableBuilder"/>.
+        /// </summary>
+        /// <remarks>
+        /// Using this method can avoid latency and potential deadlocks due to the internal 
+        /// <see cref="IAmazonDynamoDB.DescribeTable(string)"/> call that is used to populate 
+        /// the SDK's cache of table metadata. It requires that the table's index schema described accurately, 
+        /// otherwise exceptions may be thrown and/or the results of certain DynamoDB operations may change. 
+        /// It is recommended to test your application prior to using this in production code.
+        /// </remarks>
+        /// <param name="table">Table to add to the internal cache</param>
+        public void RegisterTableDefinition(Table table)
+        {
+            try
+            {
+                _readerWriterLockSlim.EnterReadLock();
+
+                if (tablesMap.ContainsKey(table.TableName))
+                {
+                    return;
+                }
+            }
+            finally
+            {
+                if (_readerWriterLockSlim.IsReadLockHeld)
+                {
+                    _readerWriterLockSlim.ExitReadLock();
+                }
+            }
+
+            try
+            {
+                _readerWriterLockSlim.EnterWriteLock();
+
+                // Check to see if another thread go the write lock before this thread and filled the cache.
+                if (tablesMap.ContainsKey(table.TableName))
+                {
+                    return;
+                }
+
+                tablesMap[table.TableName] = table;
+            }
+            finally
+            {
+                if (_readerWriterLockSlim.IsWriteLockHeld)
+                {
+                    _readerWriterLockSlim.ExitWriteLock();
+                }
+            }
+        }
+        #endregion
+
         #region Constructors
 
 #if !NETSTANDARD
diff --git a/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/ITableBuilder.cs b/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/ITableBuilder.cs
new file mode 100644
index 000000000000..8b1cb615930e
--- /dev/null
+++ b/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/ITableBuilder.cs
@@ -0,0 +1,61 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ * 
+ *  http://aws.amazon.com/apache2.0
+ * 
+ * or in the "license" file accompanying this file. This file 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 Amazon.DynamoDBv2.DocumentModel
+{
+    /// <summary>
+    /// Interface for a builder that constructs a <see cref="Table"/>
+    /// </summary>
+    public interface ITableBuilder
+    {
+        /// <summary>
+        /// Call at the end to retrieve the new <see cref="Table"/>
+        /// </summary>
+        /// <returns>Built table</returns>
+        Table Build();
+
+        /// <summary>
+        /// Adds the primary key definition to the table
+        /// </summary>
+        /// <param name="hashKeyAttribute">Name of the attribute used as the partition key</param>
+        /// <param name="type">Type of that attribute</param>
+        ITableBuilder AddHashKey(string hashKeyAttribute, DynamoDBEntryType type);
+
+        /// <summary>
+        /// Adds a sort key definition to the table
+        /// </summary>
+        /// <param name="rangeKeyAttribute">Name of the attribute used as the sort key</param>
+        /// <param name="type">Type of that attribute </param>
+        ITableBuilder AddRangeKey(string rangeKeyAttribute, DynamoDBEntryType type);
+
+        /// <summary>
+        /// Adds a local secondary index definition to the table
+        /// </summary>
+        /// <param name="indexName">Name of the local secondary index</param>
+        /// <param name="rangeKeyAttribute">Name of the attribute used as the sort key in the local secondary index</param>
+        /// <param name="type">Type of that attribute</param>
+        ITableBuilder AddLocalSecondaryIndex(string indexName, string rangeKeyAttribute, DynamoDBEntryType type);
+
+        /// <summary>
+        /// Adds a global secondary index definition to the table
+        /// </summary>
+        /// <param name="indexName">Name of the global secondary index</param>
+        /// <param name="hashkeyAttribute">Name of the attribute used as the partition key in the GSI</param>
+        /// <param name="hashKeyType">Type of the hash key attribute</param>
+        /// <param name="rangeKeyAttribute">Name of the attribute used as the sort key in the GSI</param>
+        /// <param name="rangeKeyType">Type of the sort key attribute</param>
+        ITableBuilder AddGlobalSecondaryIndex(string indexName, string hashkeyAttribute, DynamoDBEntryType hashKeyType, string rangeKeyAttribute, DynamoDBEntryType rangeKeyType);
+    }
+}
diff --git a/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/Table.cs b/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/Table.cs
index 72125f8bc4f2..af6da4768dfb 100644
--- a/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/Table.cs
+++ b/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/Table.cs
@@ -340,7 +340,7 @@ private static void ValidateConditional(IConditionalOperationConfig config)
                 throw new InvalidOperationException("Only one of the conditonal properties Expected, ExpectedState and ConditionalExpression can be set.");
         }
 
-        private void ClearTableData()
+        internal void ClearTableData()
         {
             Keys = new Dictionary<string, KeyDescription>();
             HashKeys = new List<string>();
@@ -399,7 +399,7 @@ internal Dictionary<string, AttributeValue> ToAttributeMap(Document doc, DynamoD
 
         #region Constructor/factory
 
-        private Table(IAmazonDynamoDB ddbClient, TableConfig config)
+        internal Table(IAmazonDynamoDB ddbClient, TableConfig config)
         {
             if (config == null)
                 throw new ArgumentNullException("config");
diff --git a/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/TableBuilder.cs b/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/TableBuilder.cs
new file mode 100644
index 000000000000..a94dd76bca1a
--- /dev/null
+++ b/sdk/src/Services/DynamoDBv2/Custom/DocumentModel/TableBuilder.cs
@@ -0,0 +1,260 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ * 
+ *  http://aws.amazon.com/apache2.0
+ * 
+ * or in the "license" file accompanying this file. This file 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 Amazon.DynamoDBv2.Model;
+using System;
+using System.Collections.Generic;
+
+namespace Amazon.DynamoDBv2.DocumentModel
+{
+    /// <summary>
+    /// Builder that constructs a <see cref="Table"/>
+    /// </summary>
+    public class TableBuilder : ITableBuilder
+    {
+        /// <summary>
+        /// The <see cref="Table"/> object that is built and then returned from <see cref="Build"/>
+        /// </summary>
+        private Table _table;
+
+        /// <summary>
+        /// Keeps track internally of attributes that have already been saved in <see cref="Table.Attributes"/>,
+        /// since they can be shared by different indices.
+        /// </summary>
+        private HashSet<string> _attributesAlreadyProcessed; 
+
+        /// <summary>
+        /// Creates a builder object to construct a <see cref="Table"/>
+        /// </summary>
+        /// <param name="ddbClient">Client to use to access DynamoDB.</param>
+        /// <param name="tableName">Table name</param>
+        public TableBuilder(IAmazonDynamoDB ddbClient, string tableName) :
+             this(ddbClient, tableName, DynamoDBEntryConversion.CurrentConversion, false, null)
+        {
+        }
+
+        /// <summary>
+        /// Creates a builder object to construct a <see cref="Table"/>
+        /// </summary>
+        /// <param name="ddbClient">Client to use to access DynamoDB.</param>
+        /// <param name="tableName">Table name</param>
+        /// <param name="conversion">Conversion to use for converting .NET values to DynamoDB values.</param>
+        /// <param name="isEmptyStringValueEnabled">If the property is false, empty string values will be interpreted as null values.</param>
+        /// <param name="metadataCachingMode">The document API relies on an internal cache of the DynamoDB table's metadata to construct and validate 
+        /// requests. This controls how the cache key is derived, which influences when the SDK will call 
+        /// <see cref="IAmazonDynamoDB.DescribeTable(string)"/> internally to populate the cache.</param>
+        public TableBuilder(IAmazonDynamoDB ddbClient, string tableName, DynamoDBEntryConversion conversion, bool isEmptyStringValueEnabled, MetadataCachingMode? metadataCachingMode)
+            : this (ddbClient, new TableConfig(tableName, conversion, Table.DynamoDBConsumer.DocumentModel, null, isEmptyStringValueEnabled, metadataCachingMode))
+        {
+        }
+
+        /// <summary>
+        /// Creates a builder object to construct a <see cref="Table"/>
+        /// </summary>
+        /// <param name="ddbClient">Client to use to access DynamoDB.</param>
+        /// <param name="config">Configuration to use for the table.</param>
+        public TableBuilder(IAmazonDynamoDB ddbClient, TableConfig config)
+        {
+            _table = new Table(ddbClient, config);
+            _table.ClearTableData(); // initializes internal collections
+            _attributesAlreadyProcessed = new HashSet<string>();
+        }
+
+        /// <inheritdoc/>
+        public Table Build()
+        {
+            if (_table.HashKeys.Count == 0)
+            {
+                throw new ArgumentOutOfRangeException("A partition key definition is required, call AddHashKey before Build.");
+            }
+
+            return _table;
+        }
+
+        /// <inheritdoc/>
+        public ITableBuilder AddHashKey(string hashKeyAttribute, DynamoDBEntryType type)
+        {
+            if (string.IsNullOrEmpty(hashKeyAttribute))
+            {
+                throw new ArgumentNullException(nameof(hashKeyAttribute), "The name of the partition key attribute is required.");
+            }
+            
+            if (_table.HashKeys.Count != 0)
+            {
+                throw new ArgumentOutOfRangeException("Only a single partition key is supported, and one has already been added.");
+            }
+
+            _table.HashKeys.Add(hashKeyAttribute);
+
+            _table.Keys.Add(hashKeyAttribute, new KeyDescription
+            {
+                IsHash = true,
+                Type = type
+            });
+
+            if (!_attributesAlreadyProcessed.Contains(hashKeyAttribute))
+            {
+                _table.Attributes.Add(new AttributeDefinition(hashKeyAttribute, dynamoDBEntryTypeToScalarAttributeType(type)));
+                _attributesAlreadyProcessed.Add(hashKeyAttribute);
+            }
+
+            return this;
+        }
+
+        /// <inheritdoc/>
+        public ITableBuilder AddRangeKey(string rangeKeyAttribute, DynamoDBEntryType type)
+        {
+            if (string.IsNullOrEmpty(rangeKeyAttribute))
+            {
+                throw new ArgumentNullException(nameof(rangeKeyAttribute), "The name of the sort key attribute is required.");
+            }
+
+            if (_table.RangeKeys.Count != 0)
+            {
+                throw new ArgumentOutOfRangeException("Only a single sort key is supported, and one has already been added.");
+            }
+
+            _table.RangeKeys.Add(rangeKeyAttribute);
+
+            _table.Keys.Add(rangeKeyAttribute, new KeyDescription
+            {
+                IsHash = false,
+                Type = type
+            });
+
+            if (!_attributesAlreadyProcessed.Contains(rangeKeyAttribute))
+            {
+                _table.Attributes.Add(new AttributeDefinition(rangeKeyAttribute, dynamoDBEntryTypeToScalarAttributeType(type)));
+                _attributesAlreadyProcessed.Add(rangeKeyAttribute);
+            }
+
+            return this;
+        }
+
+        /// <inheritdoc/>
+        public ITableBuilder AddLocalSecondaryIndex(string indexName, string rangeKeyAttribute, DynamoDBEntryType type)
+        {
+            if (string.IsNullOrEmpty(indexName))
+            {
+                throw new ArgumentNullException(nameof(indexName), "The name of the local secondary index is required");
+            }
+
+            if (_table.LocalSecondaryIndexes.ContainsKey(indexName))
+            {
+                throw new ArgumentException($"An local secondary index with name {indexName} has already been defined.");
+            }
+
+            if (string.IsNullOrEmpty(rangeKeyAttribute))
+            {
+                throw new ArgumentNullException(nameof(rangeKeyAttribute), "The attribute name of the range key within the local secondary index is required.");
+            }
+
+            if (_table.HashKeys.Count == 0)
+            {
+                throw new ArgumentException("A local secondary index uses the table's partition key, which was not provided. Call AddHashKey prior to AddLocalSecondaryIndex.");
+
+            }            
+
+            _table.LocalSecondaryIndexNames.Add(indexName);
+
+            _table.LocalSecondaryIndexes.Add(indexName, new LocalSecondaryIndexDescription
+            {
+                IndexName = indexName,
+                KeySchema = new List<KeySchemaElement>()
+                {
+                    new KeySchemaElement { AttributeName = _table.HashKeys[0], KeyType = KeyType.HASH },
+                    new KeySchemaElement { AttributeName = rangeKeyAttribute, KeyType = KeyType.RANGE }
+                }
+            });
+
+            if (!_attributesAlreadyProcessed.Contains(rangeKeyAttribute))
+            {
+                _table.Attributes.Add(new AttributeDefinition(rangeKeyAttribute, dynamoDBEntryTypeToScalarAttributeType(type)));
+                _attributesAlreadyProcessed.Add(rangeKeyAttribute);
+            }
+
+            return this;
+        }
+
+        /// <inheritdoc/>
+        public ITableBuilder AddGlobalSecondaryIndex(string indexName, string hashkeyAttribute, DynamoDBEntryType hashKeyType, string rangeKeyAttribute, DynamoDBEntryType rangeKeyType)
+        {
+            if (string.IsNullOrEmpty(indexName))
+            {
+                throw new ArgumentNullException(nameof(indexName), "The name of the global secondary index is required");
+            }
+
+            if (_table.GlobalSecondaryIndexes.ContainsKey(indexName))
+            {
+                throw new ArgumentException($"An global secondary index with name {indexName} has already been defined.");
+            }
+
+            if (string.IsNullOrEmpty(hashkeyAttribute))
+            {
+                throw new ArgumentNullException(nameof(hashkeyAttribute), "The attribute name of the partition key within the global secondary index is required.");
+            }
+
+            if (string.IsNullOrEmpty(rangeKeyAttribute))
+            {
+                throw new ArgumentNullException(nameof(rangeKeyAttribute), "The attribute name of the range key within the global secondary index is required.");
+            }
+
+            _table.GlobalSecondaryIndexNames.Add(indexName);
+
+            _table.GlobalSecondaryIndexes.Add(indexName, new GlobalSecondaryIndexDescription
+            {
+                IndexName = indexName,
+                KeySchema = new List<KeySchemaElement>()
+                {
+                    new KeySchemaElement { AttributeName = hashkeyAttribute, KeyType = KeyType.HASH },
+                    new KeySchemaElement { AttributeName = rangeKeyAttribute, KeyType = KeyType.RANGE }
+                }
+            });
+
+            if (!_attributesAlreadyProcessed.Contains(hashkeyAttribute))
+            {
+                _table.Attributes.Add(new AttributeDefinition(hashkeyAttribute, dynamoDBEntryTypeToScalarAttributeType(hashKeyType)));
+                _attributesAlreadyProcessed.Add(hashkeyAttribute);
+            }
+
+            if (!_attributesAlreadyProcessed.Contains(rangeKeyAttribute))
+            {
+                _table.Attributes.Add(new AttributeDefinition(rangeKeyAttribute, dynamoDBEntryTypeToScalarAttributeType(rangeKeyType)));
+                _attributesAlreadyProcessed.Add(rangeKeyAttribute);
+            }
+
+            return this;
+        }
+
+        /// <summary>
+        /// Maps the document model's <see cref="DynamoDBEntryType"/> to the corresponding, low-level <see cref="ScalarAttributeType"/>
+        /// </summary>
+        /// <param name="entryType">Document model attribute type</param>
+        /// <returns>Corresponding low-level attribute type</returns>
+        private static ScalarAttributeType dynamoDBEntryTypeToScalarAttributeType(DynamoDBEntryType entryType)
+        {
+            switch (entryType)
+            {
+                case DynamoDBEntryType.String:
+                    return ScalarAttributeType.S;
+                case DynamoDBEntryType.Numeric:
+                    return ScalarAttributeType.N;
+                case DynamoDBEntryType.Binary:
+                    return ScalarAttributeType.B;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(entryType), "Not a valid ScalarAttributeType");
+            }
+        }
+    }
+}
diff --git a/sdk/test/Services/DynamoDBv2/IntegrationTests/DataModelTests.cs b/sdk/test/Services/DynamoDBv2/IntegrationTests/DataModelTests.cs
index f4f2c0c17411..c0e792e82b24 100644
--- a/sdk/test/Services/DynamoDBv2/IntegrationTests/DataModelTests.cs
+++ b/sdk/test/Services/DynamoDBv2/IntegrationTests/DataModelTests.cs
@@ -159,6 +159,66 @@ public void TestContext_DisableFetchingTableMetadata_DateTimeAsHashKey()
         }
 
 
+        /// <summary>
+        /// Runs the same object-mapper integration tests as <see cref="TestContextWithEmptyStringEnabled"/>,
+        /// but using table definitions created by <see cref="TableBuilder"/> instead of the internal <see cref="IAmazonDynamoDB.DescribeTable"/> call
+        /// </summary>
+        [TestMethod]
+        [TestCategory("DynamoDBv2")]
+        public void TestWithBuilderTables()
+        {
+            foreach (var conversion in new DynamoDBEntryConversion[] { DynamoDBEntryConversion.V1, DynamoDBEntryConversion.V2 })
+            {
+                // Cleanup existing data in the tables
+                CleanupTables();
+
+                // Clear existing SDK-wide cache
+                TableCache.Clear();
+
+                // Redeclare Context, which will start with empty caches
+                Context = new DynamoDBContext(Client, new DynamoDBContextConfig
+                {
+                    IsEmptyStringValueEnabled = true,
+                    Conversion = conversion
+                });
+
+                Context.RegisterTableDefinition(new TableBuilder(Client, "DotNetTests-HashRangeTable")
+                                                    .AddHashKey("Name", DynamoDBEntryType.String)
+                                                    .AddRangeKey("Age", DynamoDBEntryType.Numeric)
+                                                    .AddGlobalSecondaryIndex("GlobalIndex", "Company", DynamoDBEntryType.String, "Score", DynamoDBEntryType.Numeric)
+                                                    .AddLocalSecondaryIndex("LocalIndex", "Manager", DynamoDBEntryType.String)
+                                                    .Build());
+
+                Context.RegisterTableDefinition(new TableBuilder(Client, "DotNetTests-HashTable")
+                                                    .AddHashKey("Id", DynamoDBEntryType.Numeric)
+                                                    .AddGlobalSecondaryIndex("GlobalIndex", "Company", DynamoDBEntryType.String, "Price", DynamoDBEntryType.Numeric)
+                                                    .Build());
+
+                Context.RegisterTableDefinition(new TableBuilder(Client, "DotNetTests-NumericHashRangeTable")
+                                                    .AddHashKey("CreationTime", DynamoDBEntryType.Numeric)
+                                                    .AddRangeKey("Name", DynamoDBEntryType.String)
+                                                    .Build());
+
+                TestEmptyStringsWithFeatureEnabled();
+
+                TestEnumHashKeyObjects();
+
+                TestEmptyCollections(conversion);
+
+                TestUnsupportedTypes();
+                TestEnums(conversion);
+
+                TestHashObjects();
+                TestHashRangeObjects();
+                TestOtherContextOperations();
+                TestBatchOperations();
+                TestTransactionOperations();
+                TestMultiTableTransactionOperations();
+
+                TestStoreAsEpoch();
+            }
+        }
+
         private static void TestEmptyStringsWithFeatureEnabled()
         {
             var product = new Product
diff --git a/sdk/test/Services/DynamoDBv2/IntegrationTests/DocumentTests.cs b/sdk/test/Services/DynamoDBv2/IntegrationTests/DocumentTests.cs
index ed0e2cd52ab9..a7173f61ca13 100644
--- a/sdk/test/Services/DynamoDBv2/IntegrationTests/DocumentTests.cs
+++ b/sdk/test/Services/DynamoDBv2/IntegrationTests/DocumentTests.cs
@@ -81,6 +81,82 @@ public void TestTableOperations()
             }
         }
 
+        /// <summary>
+        /// Runs the same tests as <see cref="TestTableOperations"/>, but with 
+        /// static table definitions that avoid the internal <see cref="IAmazonDynamoDB.DescribeTable(string)" /> call to populate the cache
+        /// </summary>
+        [TestMethod]
+        public void TestTableOperationsViaBuilder()
+        {
+            foreach (var conversion in new DynamoDBEntryConversion[] { DynamoDBEntryConversion.V1, DynamoDBEntryConversion.V2 })
+            {
+                // Clear tables
+                CleanupTables();
+
+                var hashTable = new TableBuilder(Client, "DotNetTests-HashTable", conversion, true, null)
+                    .AddHashKey("Id", DynamoDBEntryType.Numeric)
+                    .AddGlobalSecondaryIndex("GlobalIndex", "Company", DynamoDBEntryType.String, "Price", DynamoDBEntryType.Numeric)
+                    .Build();
+
+
+                var hashRangeTable = new TableBuilder(Client, "DotNetTests-HashRangeTable", conversion, true, null)
+                    .AddHashKey("Name", DynamoDBEntryType.String)
+                    .AddRangeKey("Age", DynamoDBEntryType.Numeric)
+                    .AddGlobalSecondaryIndex("GlobalIndex", "Company", DynamoDBEntryType.String, "Score", DynamoDBEntryType.Numeric)
+                    .AddLocalSecondaryIndex("LocalIndex", "Manager", DynamoDBEntryType.String)
+                    .Build();
+                
+                var numericHashRangeTable = new TableBuilder(Client, "DotNetTests-NumericHashRangeTable", conversion, true, null)
+                    .AddHashKey("CreationTime", DynamoDBEntryType.Numeric)
+                    .AddRangeKey("Name", DynamoDBEntryType.String)
+                    .Build();
+
+                TestEmptyString(hashTable);
+
+                // Test saving and loading empty lists and maps
+                TestEmptyCollections(hashTable);
+
+                // Test operations on hash-key table
+                TestHashTable(hashTable, conversion);
+
+                // Test operations on hash-and-range-key table
+                TestHashRangeTable(hashRangeTable, conversion);
+
+                // Test using multiple test batch writer
+                TestMultiTableDocumentBatchWrite(hashTable, hashRangeTable);
+
+                // Test multi-table transactional operations
+                TestMultiTableDocumentTransactWrite(hashTable, hashRangeTable, conversion);
+
+                // Test large batch writes and gets
+                TestLargeBatchOperations(hashTable);
+
+                // Test expressions for update
+                TestExpressionUpdate(hashTable);
+
+                // Test expressions for put
+                TestExpressionPut(hashTable);
+
+                // Test expressions for delete
+                TestExpressionsOnDelete(hashTable);
+
+                // Test expressions for transactional operations
+                TestExpressionsOnTransactWrite(hashTable, conversion);
+
+                // Test expressions for query
+                TestExpressionsOnQuery(hashRangeTable);
+
+                // Test expressions for scan
+                TestExpressionsOnScan(hashRangeTable);
+
+                // Test Query and Scan manual pagination
+                TestPagination(hashRangeTable);
+
+                // Test storing some attributes as epoch seconds
+                TestStoreAsEpoch(hashRangeTable, numericHashRangeTable);
+            }
+        }
+
         private void TestEmptyString(Table hashTable)
         {
             var companyInfo = new DynamoDBList();
diff --git a/sdk/test/Services/DynamoDBv2/UnitTests/Custom/TableBuilderTests.cs b/sdk/test/Services/DynamoDBv2/UnitTests/Custom/TableBuilderTests.cs
new file mode 100644
index 000000000000..0ecb0a19b154
--- /dev/null
+++ b/sdk/test/Services/DynamoDBv2/UnitTests/Custom/TableBuilderTests.cs
@@ -0,0 +1,189 @@
+using Amazon.DynamoDBv2;
+using Amazon.DynamoDBv2.DocumentModel;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace AWSSDK_DotNet35.UnitTests
+{
+    /// <summary>
+    /// Tests for <see cref="TableBuilder"/>
+    /// </summary>
+    [TestClass]
+    public class TableBuilderTests
+    {
+        private IAmazonDynamoDB _amazonDynamoDBClient = new AmazonDynamoDBClient();
+
+        /// <summary>
+        /// Asserts that the table requires a partition key definition
+        /// </summary>
+        [TestMethod]
+        public void MissingPrimaryKey_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+
+            Assert.ThrowsException<ArgumentOutOfRangeException>(() => builder.Build());
+        }
+
+        /// <summary>
+        /// Asserts that the partition key requires a non-null attribute
+        /// </summary>
+        [TestMethod]
+        public void NullPrimaryKey_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+
+            Assert.ThrowsException<ArgumentNullException>(() => builder.AddHashKey("", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder throws an exception when more that one partition key is defined
+        /// </summary>
+        [TestMethod]
+        public void MoreThanOnePrimaryKey_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+            builder.AddHashKey("Id", DynamoDBEntryType.String);
+
+            Assert.ThrowsException<ArgumentOutOfRangeException>(() => builder.AddHashKey("Id2", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the partition key requires a non-null attribute
+        /// </summary>
+        [TestMethod]
+        public void NullRangeKey_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+
+            Assert.ThrowsException<ArgumentNullException>(() => builder.AddRangeKey("", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder throws an exception when more that one sort key is defined
+        /// </summary>
+        [TestMethod]
+        public void MoreThanOneRangeKey_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+            builder.AddRangeKey("Date", DynamoDBEntryType.String);
+
+            Assert.ThrowsException<ArgumentOutOfRangeException>(() => builder.AddRangeKey("Date2", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder throws an exception when a LSI is defined before the partition key is,
+        /// since the LSI reuses the partition key
+        /// </summary>
+        [TestMethod]
+        public void LSIWithoutPrimaryKey_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+
+            Assert.ThrowsException<ArgumentException>(() => builder.AddLocalSecondaryIndex("LSI", "Date", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder throws an exception when a LSI is defined without an index name
+        /// </summary>
+        [TestMethod]
+        public void MissingLSIIndexName_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+            builder.AddHashKey("Id", DynamoDBEntryType.String);
+
+            Assert.ThrowsException<ArgumentNullException>(() => builder.AddLocalSecondaryIndex("", "Date", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder throws an exception when a LSI is defined without an attribute name
+        /// </summary>
+        [TestMethod]
+        public void MissingLSIAttribute_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+            builder.AddHashKey("Id", DynamoDBEntryType.String);
+
+            Assert.ThrowsException<ArgumentNullException>(() => builder.AddLocalSecondaryIndex("LSI", "", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder throws an exception when a duplicate LSI is defined
+        /// </summary>
+        [TestMethod]
+        public void DuplicateLSIName_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+            builder.AddHashKey("Id", DynamoDBEntryType.String);
+            builder.AddLocalSecondaryIndex("LSI", "Date", DynamoDBEntryType.String);
+
+            Assert.ThrowsException<ArgumentException>(() => builder.AddLocalSecondaryIndex("LSI", "Date2", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder only stores key attributes once when reused in an LSI
+        /// </summary>
+        [TestMethod]
+        public void AttributeReusedViaLSI_OnlyStoredOnce()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+            builder.AddHashKey("Id", DynamoDBEntryType.String);
+
+            // Add a GSI with two new attributes
+            builder.AddGlobalSecondaryIndex("GSI", "Date", DynamoDBEntryType.String, "OrderNumber", DynamoDBEntryType.Numeric);
+
+            // Add a LSI that reuses one of those, which shouldn't be stored in table.Attributes again
+            builder.AddLocalSecondaryIndex("LSI", "OrderNumber", DynamoDBEntryType.Numeric);
+
+            var table = builder.Build();
+
+            Assert.AreEqual(3, table.Attributes.Count);
+        }
+
+        /// <summary>
+        /// Asserts that the builder throws an exception when any of the required GSI identifiers are null
+        /// </summary>
+        public void GSINullNames_ThrowException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+
+            // Null GSI index name
+            Assert.ThrowsException<ArgumentNullException>(() => builder.AddGlobalSecondaryIndex("", "Id", DynamoDBEntryType.String, "Date", DynamoDBEntryType.String));
+
+            // Null partition key
+            Assert.ThrowsException<ArgumentException>(() => builder.AddGlobalSecondaryIndex("GSI", "", DynamoDBEntryType.String, "Date", DynamoDBEntryType.String));
+
+            // Null sort key
+            Assert.ThrowsException<ArgumentException>(() => builder.AddGlobalSecondaryIndex("GSI", "Id", DynamoDBEntryType.String, "", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder throws an exception when a duplicate GSI is defined
+        /// </summary>
+        [TestMethod]
+        public void DuplicateGSIName_ThrowsException()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+            builder.AddGlobalSecondaryIndex("GSI", "Id", DynamoDBEntryType.String, "Date", DynamoDBEntryType.String);
+
+            Assert.ThrowsException<ArgumentException>(() => builder.AddGlobalSecondaryIndex("GSI", "Id", DynamoDBEntryType.String, "Date", DynamoDBEntryType.String));
+        }
+
+        /// <summary>
+        /// Asserts that the builder only stores key attributes once when they are reused in a GSI
+        /// </summary>
+        [TestMethod]
+        public void AttributesResuedViaGSI_OnlyStoredOnce()
+        {
+            var builder = new TableBuilder(_amazonDynamoDBClient, "TestTable");
+            builder.AddHashKey("Id", DynamoDBEntryType.String);
+            builder.AddRangeKey("Date", DynamoDBEntryType.String);
+
+            // Add a GSI that uses those same two attributes
+            builder.AddGlobalSecondaryIndex("GSI", "Date", DynamoDBEntryType.String, "Id", DynamoDBEntryType.String);
+
+            var table = builder.Build();
+
+            Assert.AreEqual(2, table.Attributes.Count);
+        }
+    }
+}