diff --git a/src/aws-cpp-sdk-core/include/smithy/client/schema/Schema.h b/src/aws-cpp-sdk-core/include/smithy/client/schema/Schema.h
index 83c392dfa6d2..3df44acda3ea 100644
--- a/src/aws-cpp-sdk-core/include/smithy/client/schema/Schema.h
+++ b/src/aws-cpp-sdk-core/include/smithy/client/schema/Schema.h
@@ -1,14 +1,18 @@
 #pragma once
 
 #include <aws/core/utils/memory/stl/AWSString.h>
+#include <smithy/Smithy_EXPORTS.h>
 #include <smithy/client/schema/TraitMap.h>
 
 #include <cstdint>
+#include <initializer_list>
 #include <memory>
 
 namespace smithy {
 namespace schema {
 
+class SchemaBuilder;
+
 enum class ShapeType : uint8_t {
   Boolean,
   Byte,
@@ -34,21 +38,34 @@ enum class ShapeType : uint8_t {
   Service
 };
 
-class Schema {
+// A single trait supplied at construction time. Schemas are immutable once
+// built, so traits are attached through the factories and SchemaBuilder rather
+// than mutated afterwards.
+struct TraitEntry {
+  const TraitKeyBase& key;
+  std::shared_ptr<const Trait> value;
+};
+using TraitList = std::initializer_list<TraitEntry>;
+
+// Abstract, immutable description of a shape. Concrete variants (scalar, member,
+// structure/list/map/union root) live in the translation unit and are reached
+// only through the factories below and SchemaBuilder. Serializers and
+// deserializers hold a Schema only by const reference.
+class SMITHY_API Schema {
  public:
-  Schema() = default;
-  Schema(const Aws::String& memberName, ShapeType type) : m_type(type), m_memberName(memberName) {}
+  virtual ~Schema() = default;
 
-  ShapeType GetType() const { return m_type; }
-  const char* GetId() const { return m_id; }
-  Aws::String GetMemberName() const { return m_memberName; }
-  int GetMemberIndex() const { return m_memberIndex; }
-  bool IsMember() const { return !m_memberName.empty(); }
+  virtual ShapeType GetType() const = 0;
+  virtual const char* GetId() const = 0;
 
-  const Schema* GetMember(const char* name) const;
-  const Schema* GetMember(int index) const;
+  virtual bool IsMember() const { return false; }
+  virtual Aws::String GetMemberName() const { return {}; }
+  virtual int GetMemberIndex() const { return 0; }
+  virtual const Schema* GetMemberTarget() const { return nullptr; }
 
-  uint16_t GetMemberCount() const { return m_memberCount; }
+  virtual const Schema* GetMember(const char* /*name*/) const { return nullptr; }
+  virtual const Schema* GetMember(int /*index*/) const { return nullptr; }
+  virtual uint16_t GetMemberCount() const { return 0; }
 
   template <typename T>
   std::shared_ptr<const T> GetTrait(const TraitKey<T>& key) const {
@@ -57,19 +74,43 @@ class Schema {
 
   bool HasTrait(const TraitKeyBase& key) const { return m_traits.Has(key); }
 
-  Schema& SetTrait(const TraitKeyBase& key, std::shared_ptr<const Trait> trait) {
-    m_traits.Set(key, std::move(trait));
-    return *this;
-  }
+  // Scalar factories. No members, so no builder is needed.
+  static std::shared_ptr<const Schema> CreateBoolean(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateByte(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateShort(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateInteger(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateLong(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateFloat(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateDouble(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateBigInteger(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateBigDecimal(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateString(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateEnum(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateIntEnum(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateBlob(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateTimestamp(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateDocument(const char* id, TraitList traits = {});
+
+  // Standalone member node targeting an (otherwise empty) shape of targetType.
+  // Convenience for the positional serializer/deserializer API, where a caller
+  // hands members one at a time rather than driving them off a parent shape.
+  static std::shared_ptr<const Schema> CreateMember(const char* name, ShapeType targetType, TraitList traits = {});
+
+  // Aggregate builders. Shapes that carry members are assembled incrementally.
+  static SchemaBuilder StructureBuilder(const char* id, TraitList traits = {});
+  static SchemaBuilder UnionBuilder(const char* id, TraitList traits = {});
+  static SchemaBuilder ListBuilder(const char* id, TraitList traits = {});
+  static SchemaBuilder MapBuilder(const char* id, TraitList traits = {});
+
+ protected:
+  Schema() = default;
+  explicit Schema(TraitList traits);
 
- private:
-  const char* m_id = nullptr;
-  ShapeType m_type = ShapeType::Structure;
-  Aws::String m_memberName;
-  int m_memberIndex = 0;
-  const Schema* m_members = nullptr;
-  uint16_t m_memberCount = 0;
   TraitMap m_traits;
+
+ private:
+  Schema(const Schema&) = delete;
+  Schema& operator=(const Schema&) = delete;
 };
 
 }  // namespace schema
diff --git a/src/aws-cpp-sdk-core/include/smithy/client/schema/SchemaBuilder.h b/src/aws-cpp-sdk-core/include/smithy/client/schema/SchemaBuilder.h
new file mode 100644
index 000000000000..f986359cacfa
--- /dev/null
+++ b/src/aws-cpp-sdk-core/include/smithy/client/schema/SchemaBuilder.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <aws/core/utils/memory/AWSMemory.h>
+#include <smithy/Smithy_EXPORTS.h>
+#include <smithy/client/schema/Schema.h>
+
+#include <memory>
+
+namespace smithy {
+namespace schema {
+
+// Assembles a shape that carries members (structure, union, list, map). Members
+// may target shapes that are already built, or other builders that are not yet
+// built to describe recursive shapes. Once Build() is called the builder is
+// spent. Move-only; obtained from Schema::StructureBuilder and friends.
+class SMITHY_API SchemaBuilder {
+ public:
+  ~SchemaBuilder();
+  SchemaBuilder(SchemaBuilder&&) noexcept;
+  SchemaBuilder& operator=(SchemaBuilder&&) noexcept;
+
+  SchemaBuilder& PutMember(const char* name, std::shared_ptr<const Schema> target, TraitList traits = {});
+  SchemaBuilder& PutMember(const char* name, SchemaBuilder& target, TraitList traits = {});
+
+  std::shared_ptr<const Schema> Build();
+
+ private:
+  friend class Schema;
+  class SchemaBuilderImpl;
+
+  explicit SchemaBuilder(Aws::UniquePtr<SchemaBuilderImpl> impl);
+
+  Aws::UniquePtr<SchemaBuilderImpl> m_impl;
+
+  SchemaBuilder(const SchemaBuilder&) = delete;
+  SchemaBuilder& operator=(const SchemaBuilder&) = delete;
+};
+
+}  // namespace schema
+}  // namespace smithy
diff --git a/src/aws-cpp-sdk-core/source/smithy/client/schema/Schema.cpp b/src/aws-cpp-sdk-core/source/smithy/client/schema/Schema.cpp
new file mode 100644
index 000000000000..98b3a3bcf615
--- /dev/null
+++ b/src/aws-cpp-sdk-core/source/smithy/client/schema/Schema.cpp
@@ -0,0 +1,297 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <smithy/client/schema/Schema.h>
+#include <smithy/client/schema/SchemaBuilder.h>
+
+#include <utility>
+
+namespace smithy {
+namespace schema {
+
+namespace {
+
+const char SCHEMA_ALLOC_TAG[] = "SmithySchema";
+
+TraitMap ToTraitMap(TraitList traits) {
+  TraitMap map;
+  for (const auto& entry : traits) {
+    map.Set(entry.key, entry.value);
+  }
+  return map;
+}
+
+// Compose a member id from its containing shape id and member name, e.g.
+// "com.example#Foo$bar". Purely informational; used for GetId().
+Aws::String MakeMemberId(const Aws::String& shapeId, const Aws::String& memberName) {
+  Aws::String id = shapeId;
+  id += "$";
+  id += memberName;
+  return id;
+}
+
+// A leaf shape with no members.
+class ScalarSchema final : public Schema {
+ public:
+  ScalarSchema(ShapeType type, const char* id, TraitList traits)
+      : Schema(traits), m_type(type), m_id(id) {}
+
+  ShapeType GetType() const override { return m_type; }
+  const char* GetId() const override { return m_id.c_str(); }
+
+ private:
+  ShapeType m_type;
+  Aws::String m_id;
+};
+
+// A named member of an aggregate shape. Delegates its type to the shape it
+// targets. A member normally owns its target; the non-owning overload is used
+// only for recursive members, where the target is kept alive by the definition
+// site so the graph does not form a reference cycle.
+class MemberSchema final : public Schema {
+ public:
+  MemberSchema(const Aws::String& name, const Aws::String& id, int index, std::shared_ptr<const Schema> target,
+               TraitMap traits)
+      : m_memberName(name), m_id(id), m_memberIndex(index), m_ownedTarget(std::move(target)),
+        m_target(m_ownedTarget.get()) {
+    m_traits = std::move(traits);
+  }
+
+  MemberSchema(const Aws::String& name, const Aws::String& id, int index, const Schema* target, TraitMap traits)
+      : m_memberName(name), m_id(id), m_memberIndex(index), m_target(target) {
+    m_traits = std::move(traits);
+  }
+
+  ShapeType GetType() const override { return m_target ? m_target->GetType() : ShapeType::Structure; }
+  const char* GetId() const override { return m_id.c_str(); }
+  bool IsMember() const override { return true; }
+  Aws::String GetMemberName() const override { return m_memberName; }
+  int GetMemberIndex() const override { return m_memberIndex; }
+  const Schema* GetMemberTarget() const override { return m_target; }
+
+ private:
+  Aws::String m_memberName;
+  Aws::String m_id;
+  int m_memberIndex;
+  std::shared_ptr<const Schema> m_ownedTarget;
+  const Schema* m_target;
+};
+
+// A shape that carries members (structure, union, list, map). Owns its member
+// nodes and any eagerly-built target shapes; recursively referenced targets are
+// kept alive by the definition site, not by this shape.
+class RootSchema final : public Schema {
+ public:
+  RootSchema(ShapeType type, const Aws::String& id, TraitMap traits) : m_type(type), m_id(id) {
+    m_traits = std::move(traits);
+  }
+
+  ShapeType GetType() const override { return m_type; }
+  const char* GetId() const override { return m_id.c_str(); }
+
+  const Schema* GetMember(const char* name) const override {
+    auto it = m_nameToIndex.find(name);
+    if (it == m_nameToIndex.end()) {
+      return nullptr;
+    }
+    return m_members[it->second].get();
+  }
+
+  const Schema* GetMember(int index) const override {
+    if (index < 0 || static_cast<size_t>(index) >= m_members.size()) {
+      return nullptr;
+    }
+    return m_members[index].get();
+  }
+
+  uint16_t GetMemberCount() const override { return static_cast<uint16_t>(m_members.size()); }
+
+  // Used only by SchemaBuilder while assembling the shape.
+  void AddMember(const std::shared_ptr<const Schema>& member) {
+    m_nameToIndex[member->GetMemberName()] = static_cast<int>(m_members.size());
+    m_members.push_back(member);
+  }
+
+ private:
+  ShapeType m_type;
+  Aws::String m_id;
+  Aws::Vector<std::shared_ptr<const Schema>> m_members;
+  Aws::Map<Aws::String, int> m_nameToIndex;
+};
+
+std::shared_ptr<const Schema> MakeScalar(ShapeType type, const char* id, TraitList traits) {
+  return Aws::MakeShared<ScalarSchema>(SCHEMA_ALLOC_TAG, type, id, traits);
+}
+
+// An empty shape of the given type, used as the target of a standalone member.
+std::shared_ptr<const Schema> MakeEmptyShape(ShapeType type, const char* id) {
+  switch (type) {
+    case ShapeType::Structure:
+    case ShapeType::Union:
+    case ShapeType::List:
+    case ShapeType::Map:
+      return Aws::MakeShared<RootSchema>(SCHEMA_ALLOC_TAG, type, Aws::String(id), TraitMap());
+    default:
+      return Aws::MakeShared<ScalarSchema>(SCHEMA_ALLOC_TAG, type, id, TraitList{});
+  }
+}
+
+}  // namespace
+
+Schema::Schema(TraitList traits) : m_traits(ToTraitMap(traits)) {}
+
+std::shared_ptr<const Schema> Schema::CreateBoolean(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Boolean, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateByte(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Byte, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateShort(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Short, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateInteger(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Integer, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateLong(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Long, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateFloat(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Float, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateDouble(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Double, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateBigInteger(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::BigInteger, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateBigDecimal(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::BigDecimal, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateString(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::String, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateEnum(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Enum, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateIntEnum(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::IntEnum, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateBlob(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Blob, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateTimestamp(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Timestamp, id, traits);
+}
+std::shared_ptr<const Schema> Schema::CreateDocument(const char* id, TraitList traits) {
+  return MakeScalar(ShapeType::Document, id, traits);
+}
+
+std::shared_ptr<const Schema> Schema::CreateMember(const char* name, ShapeType targetType, TraitList traits) {
+  return Aws::MakeShared<MemberSchema>(SCHEMA_ALLOC_TAG, Aws::String(name), Aws::String(name), 0,
+                                       MakeEmptyShape(targetType, name), ToTraitMap(traits));
+}
+
+// A pending member captured before Build(). Exactly one of eagerTarget /
+// deferredTarget is set.
+class SchemaBuilder::SchemaBuilderImpl {
+ public:
+  SchemaBuilderImpl(ShapeType type, const char* id, TraitList traits)
+      : m_type(type), m_id(id), m_traits(ToTraitMap(traits)) {}
+
+  struct PendingMember {
+    Aws::String name;
+    TraitMap traits;
+    std::shared_ptr<const Schema> eagerTarget;
+    SchemaBuilderImpl* deferredTarget = nullptr;
+  };
+
+  void AddMember(const char* name, std::shared_ptr<const Schema> target, TraitList traits) {
+    PendingMember member;
+    member.name = name;
+    member.traits = ToTraitMap(traits);
+    member.eagerTarget = std::move(target);
+    m_members.push_back(std::move(member));
+  }
+
+  void AddMember(const char* name, SchemaBuilderImpl* target, TraitList traits) {
+    PendingMember member;
+    member.name = name;
+    member.traits = ToTraitMap(traits);
+    member.deferredTarget = target;
+    m_members.push_back(std::move(member));
+  }
+
+  std::shared_ptr<const Schema> Build() {
+    if (m_builtShape) {
+      return m_builtShape;
+    }
+
+    // Publish the shell before resolving members so a member that targets this
+    // same shape (directly or transitively) sees the in-progress shape rather
+    // than recursing forever.
+    auto shell = Aws::MakeShared<RootSchema>(SCHEMA_ALLOC_TAG, m_type, m_id, m_traits);
+    m_builtShape = shell;
+
+    int index = 0;
+    for (auto& pending : m_members) {
+      std::shared_ptr<const Schema> member;
+      if (pending.eagerTarget) {
+        // Non-recursive member owns its target directly.
+        member = Aws::MakeShared<MemberSchema>(SCHEMA_ALLOC_TAG, pending.name, MakeMemberId(m_id, pending.name), index,
+                                               pending.eagerTarget, pending.traits);
+      } else if (pending.deferredTarget != nullptr) {
+        // Recursive member references a target kept alive by the definition site.
+        auto target = pending.deferredTarget->Build();
+        member = Aws::MakeShared<MemberSchema>(SCHEMA_ALLOC_TAG, pending.name, MakeMemberId(m_id, pending.name), index,
+                                               target.get(), pending.traits);
+      }
+      shell->AddMember(member);
+      ++index;
+    }
+
+    return m_builtShape;
+  }
+
+ private:
+  ShapeType m_type;
+  Aws::String m_id;
+  TraitMap m_traits;
+  Aws::Vector<PendingMember> m_members;
+  std::shared_ptr<const Schema> m_builtShape;
+};
+
+SchemaBuilder Schema::StructureBuilder(const char* id, TraitList traits) {
+  return SchemaBuilder(Aws::MakeUnique<SchemaBuilder::SchemaBuilderImpl>(SCHEMA_ALLOC_TAG, ShapeType::Structure, id, traits));
+}
+SchemaBuilder Schema::UnionBuilder(const char* id, TraitList traits) {
+  return SchemaBuilder(Aws::MakeUnique<SchemaBuilder::SchemaBuilderImpl>(SCHEMA_ALLOC_TAG, ShapeType::Union, id, traits));
+}
+SchemaBuilder Schema::ListBuilder(const char* id, TraitList traits) {
+  return SchemaBuilder(Aws::MakeUnique<SchemaBuilder::SchemaBuilderImpl>(SCHEMA_ALLOC_TAG, ShapeType::List, id, traits));
+}
+SchemaBuilder Schema::MapBuilder(const char* id, TraitList traits) {
+  return SchemaBuilder(Aws::MakeUnique<SchemaBuilder::SchemaBuilderImpl>(SCHEMA_ALLOC_TAG, ShapeType::Map, id, traits));
+}
+
+SchemaBuilder::SchemaBuilder(Aws::UniquePtr<SchemaBuilderImpl> impl) : m_impl(std::move(impl)) {}
+SchemaBuilder::~SchemaBuilder() = default;
+SchemaBuilder::SchemaBuilder(SchemaBuilder&&) noexcept = default;
+SchemaBuilder& SchemaBuilder::operator=(SchemaBuilder&&) noexcept = default;
+
+SchemaBuilder& SchemaBuilder::PutMember(const char* name, std::shared_ptr<const Schema> target, TraitList traits) {
+  m_impl->AddMember(name, std::move(target), traits);
+  return *this;
+}
+
+SchemaBuilder& SchemaBuilder::PutMember(const char* name, SchemaBuilder& target, TraitList traits) {
+  m_impl->AddMember(name, target.m_impl.get(), traits);
+  return *this;
+}
+
+std::shared_ptr<const Schema> SchemaBuilder::Build() { return m_impl->Build(); }
+
+}  // namespace schema
+}  // namespace smithy
diff --git a/tests/aws-cpp-sdk-core-tests/smithy/client/schema/CborShapeDeserializerTest.cpp b/tests/aws-cpp-sdk-core-tests/smithy/client/schema/CborShapeDeserializerTest.cpp
index a08539687eaa..cdd1a391eb4e 100644
--- a/tests/aws-cpp-sdk-core-tests/smithy/client/schema/CborShapeDeserializerTest.cpp
+++ b/tests/aws-cpp-sdk-core-tests/smithy/client/schema/CborShapeDeserializerTest.cpp
@@ -7,6 +7,7 @@
 #include <smithy/client/schema/CborShapeDeserializer.h>
 #include <smithy/client/schema/CborShapeSerializer.h>
 #include <smithy/client/schema/Schema.h>
+#include <smithy/client/schema/SchemaBuilder.h>
 
 using namespace smithy::schema;
 
@@ -16,10 +17,10 @@ class CborShapeDeserializerTest : public Aws::Testing::AwsCppSdkGTestSuite {};
 
 TEST_F(CborShapeDeserializerTest, BooleanTrue) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("enabled");
-  s.WriteBoolean(root, true);
+  s.WriteBoolean(*root, true);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -38,10 +39,10 @@ TEST_F(CborShapeDeserializerTest, BooleanTrue) {
 
 TEST_F(CborShapeDeserializerTest, BooleanFalse) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("ok");
-  s.WriteBoolean(root, false);
+  s.WriteBoolean(*root, false);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -59,10 +60,10 @@ TEST_F(CborShapeDeserializerTest, BooleanFalse) {
 
 TEST_F(CborShapeDeserializerTest, IntegerSmall) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(root, 7);
+  s.WriteInteger(*root, 7);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -80,10 +81,10 @@ TEST_F(CborShapeDeserializerTest, IntegerSmall) {
 
 TEST_F(CborShapeDeserializerTest, IntegerNegative) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(root, -42);
+  s.WriteInteger(*root, -42);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -101,10 +102,10 @@ TEST_F(CborShapeDeserializerTest, IntegerNegative) {
 
 TEST_F(CborShapeDeserializerTest, LongValue) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("big");
-  s.WriteLong(root, 5000000000LL);
+  s.WriteLong(*root, 5000000000LL);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -122,10 +123,10 @@ TEST_F(CborShapeDeserializerTest, LongValue) {
 
 TEST_F(CborShapeDeserializerTest, DoubleValue) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("d");
-  s.WriteDouble(root, 3.14);
+  s.WriteDouble(*root, 3.14);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -144,10 +145,10 @@ TEST_F(CborShapeDeserializerTest, DoubleValue) {
 TEST_F(CborShapeDeserializerTest, DoubleWholeNumber) {
   // CRT encodes 5.0 as integer 5 — deserializer must handle this
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("d");
-  s.WriteDouble(root, 5.0);
+  s.WriteDouble(*root, 5.0);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -165,10 +166,10 @@ TEST_F(CborShapeDeserializerTest, DoubleWholeNumber) {
 
 TEST_F(CborShapeDeserializerTest, FloatValue) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("f");
-  s.WriteFloat(root, 1.5f);
+  s.WriteFloat(*root, 1.5f);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -186,10 +187,10 @@ TEST_F(CborShapeDeserializerTest, FloatValue) {
 
 TEST_F(CborShapeDeserializerTest, StringValue) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("name");
-  s.WriteString(root, "hello");
+  s.WriteString(*root, "hello");
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -207,15 +208,15 @@ TEST_F(CborShapeDeserializerTest, StringValue) {
 
 TEST_F(CborShapeDeserializerTest, BlobValue) {
   CborShapeSerializer s;
-  Schema root;
+  auto root = Schema::StructureBuilder("Root").Build();
   Aws::Utils::ByteBuffer blob(4);
   blob[0] = 0xDE;
   blob[1] = 0xAD;
   blob[2] = 0xBE;
   blob[3] = 0xEF;
-  s.BeginStructure(root);
+  s.BeginStructure(*root);
   s.WriteMapKey("data");
-  s.WriteBlob(root, blob);
+  s.WriteBlob(*root, blob);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -237,11 +238,11 @@ TEST_F(CborShapeDeserializerTest, BlobValue) {
 
 TEST_F(CborShapeDeserializerTest, TimestampValue) {
   CborShapeSerializer s;
-  Schema root;
+  auto root = Schema::StructureBuilder("Root").Build();
   Aws::Utils::DateTime dt(1234567890.0);  // seconds since epoch
-  s.BeginStructure(root);
+  s.BeginStructure(*root);
   s.WriteMapKey("ts");
-  s.WriteTimestamp(root, dt);
+  s.WriteTimestamp(*root, dt);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -259,10 +260,10 @@ TEST_F(CborShapeDeserializerTest, TimestampValue) {
 
 TEST_F(CborShapeDeserializerTest, NullValue) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("item");
-  s.WriteNull(root);
+  s.WriteNull(*root);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -281,13 +282,13 @@ TEST_F(CborShapeDeserializerTest, NullValue) {
 
 TEST_F(CborShapeDeserializerTest, ListOfIntegers) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("nums");
-  s.BeginList(root, 3);
-  s.WriteInteger(root, 10);
-  s.WriteInteger(root, 20);
-  s.WriteInteger(root, 30);
+  s.BeginList(*root, 3);
+  s.WriteInteger(*root, 10);
+  s.WriteInteger(*root, 20);
+  s.WriteInteger(*root, 30);
   s.EndList();
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
@@ -315,14 +316,14 @@ TEST_F(CborShapeDeserializerTest, ListOfIntegers) {
 
 TEST_F(CborShapeDeserializerTest, MapOfStrings) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("headers");
-  s.BeginMap(root, 2);
+  s.BeginMap(*root, 2);
   s.WriteMapKey("foo");
-  s.WriteString(root, "bar");
+  s.WriteString(*root, "bar");
   s.WriteMapKey("baz");
-  s.WriteString(root, "qux");
+  s.WriteString(*root, "qux");
   s.EndMap();
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
@@ -353,12 +354,12 @@ TEST_F(CborShapeDeserializerTest, MapOfStrings) {
 
 TEST_F(CborShapeDeserializerTest, NestedStructure) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("meta");
-  s.BeginNestedStructure(root);
+  s.BeginNestedStructure(*root);
   s.WriteMapKey("key");
-  s.WriteString(root, "val");
+  s.WriteString(*root, "val");
   s.EndNestedStructure();
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
@@ -385,14 +386,14 @@ TEST_F(CborShapeDeserializerTest, NestedStructure) {
 
 TEST_F(CborShapeDeserializerTest, SkipUnknownField) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("known");
-  s.WriteInteger(root, 1);
+  s.WriteInteger(*root, 1);
   s.WriteMapKey("unknown");
-  s.WriteString(root, "skip me");
+  s.WriteString(*root, "skip me");
   s.WriteMapKey("also_known");
-  s.WriteInteger(root, 2);
+  s.WriteInteger(*root, 2);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -420,17 +421,17 @@ TEST_F(CborShapeDeserializerTest, SkipUnknownField) {
 
 TEST_F(CborShapeDeserializerTest, SkipNestedUnknown) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("unknown_struct");
-  s.BeginNestedStructure(root);
+  s.BeginNestedStructure(*root);
   s.WriteMapKey("a");
-  s.WriteInteger(root, 1);
+  s.WriteInteger(*root, 1);
   s.WriteMapKey("b");
-  s.WriteString(root, "nested");
+  s.WriteString(*root, "nested");
   s.EndNestedStructure();
   s.WriteMapKey("known");
-  s.WriteInteger(root, 42);
+  s.WriteInteger(*root, 42);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -454,14 +455,14 @@ TEST_F(CborShapeDeserializerTest, SkipNestedUnknown) {
 
 TEST_F(CborShapeDeserializerTest, MultipleScalars) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("a");
-  s.WriteBoolean(root, true);
+  s.WriteBoolean(*root, true);
   s.WriteMapKey("b");
-  s.WriteInteger(root, 7);
+  s.WriteInteger(*root, 7);
   s.WriteMapKey("c");
-  s.WriteString(root, "x");
+  s.WriteString(*root, "x");
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -500,10 +501,10 @@ TEST_F(CborShapeDeserializerTest, EmptyOptionalOnEmptyPayload) {
 
 TEST_F(CborShapeDeserializerTest, EmptyOptionalOnTypeMismatch) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("val");
-  s.WriteString(root, "hello");
+  s.WriteString(*root, "hello");
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -518,10 +519,10 @@ TEST_F(CborShapeDeserializerTest, EmptyOptionalOnTypeMismatch) {
 
 TEST_F(CborShapeDeserializerTest, ValidOptionalOnSuccess) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(root, 42);
+  s.WriteInteger(*root, 42);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
@@ -565,10 +566,10 @@ TEST_F(CborShapeDeserializerTest, BeginStructDefiniteLengthMap) {
 
 TEST_F(CborShapeDeserializerTest, BeginStructIndefiniteLengthMap) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.WriteMapKey("x");
-  s.WriteInteger(root, 99);
+  s.WriteInteger(*root, 99);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
 
diff --git a/tests/aws-cpp-sdk-core-tests/smithy/client/schema/CborShapeSerializerTest.cpp b/tests/aws-cpp-sdk-core-tests/smithy/client/schema/CborShapeSerializerTest.cpp
index a1f936d70887..bbf6d0fd2591 100644
--- a/tests/aws-cpp-sdk-core-tests/smithy/client/schema/CborShapeSerializerTest.cpp
+++ b/tests/aws-cpp-sdk-core-tests/smithy/client/schema/CborShapeSerializerTest.cpp
@@ -6,6 +6,7 @@
 #include <aws/testing/AwsCppSdkGTestSuite.h>
 #include <smithy/client/schema/CborShapeSerializer.h>
 #include <smithy/client/schema/Schema.h>
+#include <smithy/client/schema/SchemaBuilder.h>
 
 #include <cstring>
 
@@ -21,8 +22,8 @@ Aws::String Bytes(const char* data, size_t len) { return Aws::String(data, len);
 
 TEST_F(CborShapeSerializerTest, EmptyStructure) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -32,11 +33,11 @@ TEST_F(CborShapeSerializerTest, EmptyStructure) {
 
 TEST_F(CborShapeSerializerTest, BooleanTrue) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("enabled", ShapeType::Boolean);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("enabled", ShapeType::Boolean);
+  s.BeginStructure(*root);
   s.WriteMapKey("enabled");
-  s.WriteBoolean(member, true);
+  s.WriteBoolean(*member, true);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -54,11 +55,11 @@ TEST_F(CborShapeSerializerTest, BooleanTrue) {
 
 TEST_F(CborShapeSerializerTest, BooleanFalse) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("ok", ShapeType::Boolean);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("ok", ShapeType::Boolean);
+  s.BeginStructure(*root);
   s.WriteMapKey("ok");
-  s.WriteBoolean(member, false);
+  s.WriteBoolean(*member, false);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -74,11 +75,11 @@ TEST_F(CborShapeSerializerTest, BooleanFalse) {
 
 TEST_F(CborShapeSerializerTest, IntegerSmall) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("n", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("n", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(member, 1);
+  s.WriteInteger(*member, 1);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -94,11 +95,11 @@ TEST_F(CborShapeSerializerTest, IntegerSmall) {
 
 TEST_F(CborShapeSerializerTest, IntegerOneByte) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("n", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("n", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(member, 42);
+  s.WriteInteger(*member, 42);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -115,11 +116,11 @@ TEST_F(CborShapeSerializerTest, IntegerOneByte) {
 
 TEST_F(CborShapeSerializerTest, IntegerNegative) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("n", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("n", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(member, -1);
+  s.WriteInteger(*member, -1);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -135,11 +136,11 @@ TEST_F(CborShapeSerializerTest, IntegerNegative) {
 
 TEST_F(CborShapeSerializerTest, IntegerNegativeLarge) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("n", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("n", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(member, -100);
+  s.WriteInteger(*member, -100);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -156,11 +157,11 @@ TEST_F(CborShapeSerializerTest, IntegerNegativeLarge) {
 
 TEST_F(CborShapeSerializerTest, LongValue) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("big", ShapeType::Long);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("big", ShapeType::Long);
+  s.BeginStructure(*root);
   s.WriteMapKey("big");
-  s.WriteLong(member, 1000000LL);
+  s.WriteLong(*member, 1000000LL);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -181,11 +182,11 @@ TEST_F(CborShapeSerializerTest, LongValue) {
 
 TEST_F(CborShapeSerializerTest, DoubleValue) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("d", ShapeType::Double);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("d", ShapeType::Double);
+  s.BeginStructure(*root);
   s.WriteMapKey("d");
-  s.WriteDouble(member, 3.14);
+  s.WriteDouble(*member, 3.14);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -211,11 +212,11 @@ TEST_F(CborShapeSerializerTest, DoubleValue) {
 
 TEST_F(CborShapeSerializerTest, StringValue) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("name", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("name", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("name");
-  s.WriteString(member, "hello");
+  s.WriteString(*member, "hello");
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -232,11 +233,11 @@ TEST_F(CborShapeSerializerTest, StringValue) {
 
 TEST_F(CborShapeSerializerTest, EmptyString) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("s", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("s", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("s");
-  s.WriteString(member, "");
+  s.WriteString(*member, "");
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -252,13 +253,13 @@ TEST_F(CborShapeSerializerTest, EmptyString) {
 
 TEST_F(CborShapeSerializerTest, BlobValue) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("data", ShapeType::Blob);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("data", ShapeType::Blob);
+  s.BeginStructure(*root);
   s.WriteMapKey("data");
   unsigned char raw[] = {0xDE, 0xAD, 0xBE, 0xEF};
   Aws::Utils::ByteBuffer buf(raw, 4);
-  s.WriteBlob(member, buf);
+  s.WriteBlob(*member, buf);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -278,11 +279,11 @@ TEST_F(CborShapeSerializerTest, BlobValue) {
 
 TEST_F(CborShapeSerializerTest, NullValue) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("item", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("item", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("item");
-  s.WriteNull(member);
+  s.WriteNull(*member);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -298,13 +299,13 @@ TEST_F(CborShapeSerializerTest, NullValue) {
 
 TEST_F(CborShapeSerializerTest, TimestampIntegerSeconds) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("ts", ShapeType::Timestamp);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("ts", ShapeType::Timestamp);
+  s.BeginStructure(*root);
   s.WriteMapKey("ts");
   // DateTime(int64_t) takes milliseconds; 1234567000ms = 1234567 seconds (no fractional part)
   Aws::Utils::DateTime dt(static_cast<int64_t>(1234567000));
-  s.WriteTimestamp(member, dt);
+  s.WriteTimestamp(*member, dt);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -327,12 +328,12 @@ TEST_F(CborShapeSerializerTest, TimestampIntegerSeconds) {
 TEST_F(CborShapeSerializerTest, TimestampFractionalSeconds) {
   // Fractional seconds are truncated to integer per rpcv2Cbor protocol
   CborShapeSerializer s;
-  Schema root;
-  Schema member("ts", ShapeType::Timestamp);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("ts", ShapeType::Timestamp);
+  s.BeginStructure(*root);
   s.WriteMapKey("ts");
   Aws::Utils::DateTime dt(1234567890.5);
-  s.WriteTimestamp(member, dt);
+  s.WriteTimestamp(*member, dt);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -352,17 +353,17 @@ TEST_F(CborShapeSerializerTest, TimestampFractionalSeconds) {
 
 TEST_F(CborShapeSerializerTest, MultipleScalars) {
   CborShapeSerializer s;
-  Schema root;
-  Schema m1("a", ShapeType::Boolean);
-  Schema m2("b", ShapeType::Integer);
-  Schema m3("c", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto m1 = Schema::CreateMember("a", ShapeType::Boolean);
+  auto m2 = Schema::CreateMember("b", ShapeType::Integer);
+  auto m3 = Schema::CreateMember("c", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("a");
-  s.WriteBoolean(m1, true);
+  s.WriteBoolean(*m1, true);
   s.WriteMapKey("b");
-  s.WriteInteger(m2, 7);
+  s.WriteInteger(*m2, 7);
   s.WriteMapKey("c");
-  s.WriteString(m3, "x");
+  s.WriteString(*m3, "x");
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -387,14 +388,14 @@ TEST_F(CborShapeSerializerTest, MultipleScalars) {
 
 TEST_F(CborShapeSerializerTest, NestedStructure) {
   CborShapeSerializer s;
-  Schema root;
-  Schema nested("meta", ShapeType::Structure);
-  Schema inner("key", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto nested = Schema::CreateMember("meta", ShapeType::Structure);
+  auto inner = Schema::CreateMember("key", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("meta");
-  s.BeginNestedStructure(nested);
+  s.BeginNestedStructure(*nested);
   s.WriteMapKey("key");
-  s.WriteString(inner, "val");
+  s.WriteString(*inner, "val");
   s.EndNestedStructure();
   s.EndStructure();
   auto outcome = s.GetPayload();
@@ -416,17 +417,17 @@ TEST_F(CborShapeSerializerTest, NestedStructure) {
 
 TEST_F(CborShapeSerializerTest, DeeplyNestedStructure) {
   CborShapeSerializer s;
-  Schema root;
-  Schema l1("l1", ShapeType::Structure);
-  Schema l2("l2", ShapeType::Structure);
-  Schema leaf("v", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto l1 = Schema::CreateMember("l1", ShapeType::Structure);
+  auto l2 = Schema::CreateMember("l2", ShapeType::Structure);
+  auto leaf = Schema::CreateMember("v", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("l1");
-  s.BeginNestedStructure(l1);
+  s.BeginNestedStructure(*l1);
   s.WriteMapKey("l2");
-  s.BeginNestedStructure(l2);
+  s.BeginNestedStructure(*l2);
   s.WriteMapKey("v");
-  s.WriteInteger(leaf, 99);
+  s.WriteInteger(*leaf, 99);
   s.EndNestedStructure();
   s.EndNestedStructure();
   s.EndStructure();
@@ -455,15 +456,15 @@ TEST_F(CborShapeSerializerTest, DeeplyNestedStructure) {
 
 TEST_F(CborShapeSerializerTest, ListOfIntegers) {
   CborShapeSerializer s;
-  Schema root;
-  Schema listMember("nums", ShapeType::List);
-  Schema elem("member", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("nums", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("nums");
-  s.BeginList(listMember, 3);
-  s.WriteInteger(elem, 1);
-  s.WriteInteger(elem, 2);
-  s.WriteInteger(elem, 3);
+  s.BeginList(*listMember, 3);
+  s.WriteInteger(*elem, 1);
+  s.WriteInteger(*elem, 2);
+  s.WriteInteger(*elem, 3);
   s.EndList();
   s.EndStructure();
   auto outcome = s.GetPayload();
@@ -483,11 +484,11 @@ TEST_F(CborShapeSerializerTest, ListOfIntegers) {
 
 TEST_F(CborShapeSerializerTest, EmptyList) {
   CborShapeSerializer s;
-  Schema root;
-  Schema listMember("items", ShapeType::List);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List);
+  s.BeginStructure(*root);
   s.WriteMapKey("items");
-  s.BeginList(listMember, 0);
+  s.BeginList(*listMember, 0);
   s.EndList();
   s.EndStructure();
   auto outcome = s.GetPayload();
@@ -504,14 +505,14 @@ TEST_F(CborShapeSerializerTest, EmptyList) {
 
 TEST_F(CborShapeSerializerTest, ListOfStrings) {
   CborShapeSerializer s;
-  Schema root;
-  Schema listMember("tags", ShapeType::List);
-  Schema elem("member", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("tags", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("tags");
-  s.BeginList(listMember, 2);
-  s.WriteString(elem, "ab");
-  s.WriteString(elem, "cd");
+  s.BeginList(*listMember, 2);
+  s.WriteString(*elem, "ab");
+  s.WriteString(*elem, "cd");
   s.EndList();
   s.EndStructure();
   auto outcome = s.GetPayload();
@@ -532,20 +533,20 @@ TEST_F(CborShapeSerializerTest, ListOfStrings) {
 
 TEST_F(CborShapeSerializerTest, ListOfStructures) {
   CborShapeSerializer s;
-  Schema root;
-  Schema listMember("items", ShapeType::List);
-  Schema structElem("member", ShapeType::Structure);
-  Schema field("id", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List);
+  auto structElem = Schema::CreateMember("member", ShapeType::Structure);
+  auto field = Schema::CreateMember("id", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("items");
-  s.BeginList(listMember, 2);
-  s.BeginNestedStructure(structElem);
+  s.BeginList(*listMember, 2);
+  s.BeginNestedStructure(*structElem);
   s.WriteMapKey("id");
-  s.WriteInteger(field, 1);
+  s.WriteInteger(*field, 1);
   s.EndNestedStructure();
-  s.BeginNestedStructure(structElem);
+  s.BeginNestedStructure(*structElem);
   s.WriteMapKey("id");
-  s.WriteInteger(field, 2);
+  s.WriteInteger(*field, 2);
   s.EndNestedStructure();
   s.EndList();
   s.EndStructure();
@@ -575,16 +576,16 @@ TEST_F(CborShapeSerializerTest, ListOfStructures) {
 
 TEST_F(CborShapeSerializerTest, MapOfStrings) {
   CborShapeSerializer s;
-  Schema root;
-  Schema mapMember("headers", ShapeType::Map);
-  Schema valSchema("value", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("headers", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("headers");
-  s.BeginMap(mapMember, 2);
+  s.BeginMap(*mapMember, 2);
   s.WriteMapKey("foo");
-  s.WriteString(valSchema, "bar");
+  s.WriteString(*valSchema, "bar");
   s.WriteMapKey("baz");
-  s.WriteString(valSchema, "qux");
+  s.WriteString(*valSchema, "qux");
   s.EndMap();
   s.EndStructure();
   auto outcome = s.GetPayload();
@@ -609,11 +610,11 @@ TEST_F(CborShapeSerializerTest, MapOfStrings) {
 
 TEST_F(CborShapeSerializerTest, EmptyMap) {
   CborShapeSerializer s;
-  Schema root;
-  Schema mapMember("tags", ShapeType::Map);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("tags", ShapeType::Map);
+  s.BeginStructure(*root);
   s.WriteMapKey("tags");
-  s.BeginMap(mapMember, 0);
+  s.BeginMap(*mapMember, 0);
   s.EndMap();
   s.EndStructure();
   auto outcome = s.GetPayload();
@@ -630,17 +631,17 @@ TEST_F(CborShapeSerializerTest, EmptyMap) {
 
 TEST_F(CborShapeSerializerTest, MapOfStructures) {
   CborShapeSerializer s;
-  Schema root;
-  Schema mapMember("nodes", ShapeType::Map);
-  Schema valSchema("value", ShapeType::Structure);
-  Schema field("val", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("nodes", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::Structure);
+  auto field = Schema::CreateMember("val", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("nodes");
-  s.BeginMap(mapMember, 1);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("a");
-  s.BeginNestedStructure(valSchema);
+  s.BeginNestedStructure(*valSchema);
   s.WriteMapKey("val");
-  s.WriteInteger(field, 1);
+  s.WriteInteger(*field, 1);
   s.EndNestedStructure();
   s.EndMap();
   s.EndStructure();
@@ -669,8 +670,8 @@ TEST_F(CborShapeSerializerTest, MapOfStructures) {
 
 TEST_F(CborShapeSerializerTest, GetPayloadCalledTwice) {
   CborShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.EndStructure();
   auto outcome1 = s.GetPayload();
   ASSERT_TRUE(outcome1.IsSuccess());
@@ -683,11 +684,11 @@ TEST_F(CborShapeSerializerTest, GetPayloadCalledTwice) {
 
 TEST_F(CborShapeSerializerTest, EnumValue) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("status", ShapeType::Enum);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("status", ShapeType::Enum);
+  s.BeginStructure(*root);
   s.WriteMapKey("status");
-  s.WriteEnum(member, 3);
+  s.WriteEnum(*member, 3);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -705,24 +706,24 @@ TEST_F(CborShapeSerializerTest, EnumValue) {
 
 TEST_F(CborShapeSerializerTest, StructureWithListAndMap) {
   CborShapeSerializer s;
-  Schema root;
-  Schema strMember("name", ShapeType::String);
-  Schema listMember("tags", ShapeType::List);
-  Schema listElem("member", ShapeType::String);
-  Schema mapMember("meta", ShapeType::Map);
-  Schema mapVal("value", ShapeType::Integer);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto strMember = Schema::CreateMember("name", ShapeType::String);
+  auto listMember = Schema::CreateMember("tags", ShapeType::List);
+  auto listElem = Schema::CreateMember("member", ShapeType::String);
+  auto mapMember = Schema::CreateMember("meta", ShapeType::Map);
+  auto mapVal = Schema::CreateMember("value", ShapeType::Integer);
 
-  s.BeginStructure(root);
+  s.BeginStructure(*root);
   s.WriteMapKey("name");
-  s.WriteString(strMember, "hi");
+  s.WriteString(*strMember, "hi");
   s.WriteMapKey("tags");
-  s.BeginList(listMember, 1);
-  s.WriteString(listElem, "t1");
+  s.BeginList(*listMember, 1);
+  s.WriteString(*listElem, "t1");
   s.EndList();
   s.WriteMapKey("meta");
-  s.BeginMap(mapMember, 1);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("k");
-  s.WriteInteger(mapVal, 5);
+  s.WriteInteger(*mapVal, 5);
   s.EndMap();
   s.EndStructure();
 
@@ -752,11 +753,11 @@ TEST_F(CborShapeSerializerTest, StructureWithListAndMap) {
 
 TEST_F(CborShapeSerializerTest, IntegerZero) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("z", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("z", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("z");
-  s.WriteInteger(member, 0);
+  s.WriteInteger(*member, 0);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -772,11 +773,11 @@ TEST_F(CborShapeSerializerTest, IntegerZero) {
 
 TEST_F(CborShapeSerializerTest, IntegerTwoByte) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("n", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("n", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(member, 1000);
+  s.WriteInteger(*member, 1000);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -795,15 +796,15 @@ TEST_F(CborShapeSerializerTest, IntegerTwoByte) {
 
 TEST_F(CborShapeSerializerTest, SparseList) {
   CborShapeSerializer s;
-  Schema root;
-  Schema listMember("items", ShapeType::List);
-  Schema elem("member", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("items");
-  s.BeginList(listMember, 3);
-  s.WriteString(elem, "a");
-  s.WriteNull(elem);
-  s.WriteString(elem, "b");
+  s.BeginList(*listMember, 3);
+  s.WriteString(*elem, "a");
+  s.WriteNull(*elem);
+  s.WriteString(*elem, "b");
   s.EndList();
   s.EndStructure();
   auto outcome = s.GetPayload();
@@ -827,11 +828,11 @@ TEST_F(CborShapeSerializerTest, SparseList) {
 
 TEST_F(CborShapeSerializerTest, IntegerFourByte) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("n", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("n", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteInteger(member, 70000);
+  s.WriteInteger(*member, 70000);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -851,11 +852,11 @@ TEST_F(CborShapeSerializerTest, IntegerFourByte) {
 
 TEST_F(CborShapeSerializerTest, LongEightByte) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("n", ShapeType::Long);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("n", ShapeType::Long);
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteLong(member, 5000000000LL);
+  s.WriteLong(*member, 5000000000LL);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -879,11 +880,11 @@ TEST_F(CborShapeSerializerTest, LongEightByte) {
 
 TEST_F(CborShapeSerializerTest, LargeNegativeInteger) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("n", ShapeType::Long);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("n", ShapeType::Long);
+  s.BeginStructure(*root);
   s.WriteMapKey("n");
-  s.WriteLong(member, -1000000LL);
+  s.WriteLong(*member, -1000000LL);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -904,11 +905,11 @@ TEST_F(CborShapeSerializerTest, LargeNegativeInteger) {
 TEST_F(CborShapeSerializerTest, DoubleWholeNumberEncodedAsInt) {
   // CRT encoder uses "smallest possible" — a double like 5.0 encodes as integer 5
   CborShapeSerializer s;
-  Schema root;
-  Schema member("d", ShapeType::Double);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("d", ShapeType::Double);
+  s.BeginStructure(*root);
   s.WriteMapKey("d");
-  s.WriteDouble(member, 5.0);
+  s.WriteDouble(*member, 5.0);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -926,11 +927,11 @@ TEST_F(CborShapeSerializerTest, DoubleWholeNumberEncodedAsInt) {
 TEST_F(CborShapeSerializerTest, DoubleNegativeWholeNumberEncodedAsNegInt) {
   // CRT encoder: -3.0 encodes as negint 2 (meaning -(2+1) = -3)
   CborShapeSerializer s;
-  Schema root;
-  Schema member("d", ShapeType::Double);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("d", ShapeType::Double);
+  s.BeginStructure(*root);
   s.WriteMapKey("d");
-  s.WriteDouble(member, -3.0);
+  s.WriteDouble(*member, -3.0);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -946,11 +947,11 @@ TEST_F(CborShapeSerializerTest, DoubleNegativeWholeNumberEncodedAsNegInt) {
 
 TEST_F(CborShapeSerializerTest, UnicodeString) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("s", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("s", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("s");
-  s.WriteString(member, "\xC3\xA9\xC3\xA8");  // "éè" in UTF-8 (4 bytes)
+  s.WriteString(*member, "\xC3\xA9\xC3\xA8");  // "éè" in UTF-8 (4 bytes)
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -967,19 +968,19 @@ TEST_F(CborShapeSerializerTest, UnicodeString) {
 
 TEST_F(CborShapeSerializerTest, NestedListInList) {
   CborShapeSerializer s;
-  Schema root;
-  Schema outerList("data", ShapeType::List);
-  Schema innerList("member", ShapeType::List);
-  Schema elem("member", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto outerList = Schema::CreateMember("data", ShapeType::List);
+  auto innerList = Schema::CreateMember("member", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("data");
-  s.BeginList(outerList, 2);
-  s.BeginList(innerList, 2);
-  s.WriteInteger(elem, 1);
-  s.WriteInteger(elem, 2);
+  s.BeginList(*outerList, 2);
+  s.BeginList(*innerList, 2);
+  s.WriteInteger(*elem, 1);
+  s.WriteInteger(*elem, 2);
   s.EndList();
-  s.BeginList(innerList, 1);
-  s.WriteInteger(elem, 3);
+  s.BeginList(*innerList, 1);
+  s.WriteInteger(*elem, 3);
   s.EndList();
   s.EndList();
   s.EndStructure();
@@ -1002,18 +1003,18 @@ TEST_F(CborShapeSerializerTest, NestedListInList) {
 
 TEST_F(CborShapeSerializerTest, MapWithMultipleEntries) {
   CborShapeSerializer s;
-  Schema root;
-  Schema mapMember("m", ShapeType::Map);
-  Schema valSchema("value", ShapeType::Integer);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("m", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::Integer);
+  s.BeginStructure(*root);
   s.WriteMapKey("m");
-  s.BeginMap(mapMember, 3);
+  s.BeginMap(*mapMember, 3);
   s.WriteMapKey("x");
-  s.WriteInteger(valSchema, 1);
+  s.WriteInteger(*valSchema, 1);
   s.WriteMapKey("y");
-  s.WriteInteger(valSchema, 2);
+  s.WriteInteger(*valSchema, 2);
   s.WriteMapKey("z");
-  s.WriteInteger(valSchema, 3);
+  s.WriteInteger(*valSchema, 3);
   s.EndMap();
   s.EndStructure();
   auto outcome = s.GetPayload();
@@ -1039,11 +1040,11 @@ TEST_F(CborShapeSerializerTest, MapWithMultipleEntries) {
 
 TEST_F(CborShapeSerializerTest, FloatValue) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("f", ShapeType::Float);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("f", ShapeType::Float);
+  s.BeginStructure(*root);
   s.WriteMapKey("f");
-  s.WriteFloat(member, 1.5f);
+  s.WriteFloat(*member, 1.5f);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -1065,11 +1066,11 @@ TEST_F(CborShapeSerializerTest, FloatValue) {
 TEST_F(CborShapeSerializerTest, FloatWholeNumberEncodedAsInt) {
   // CRT "smallest possible": 7.0f encodes as integer 7
   CborShapeSerializer s;
-  Schema root;
-  Schema member("f", ShapeType::Float);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("f", ShapeType::Float);
+  s.BeginStructure(*root);
   s.WriteMapKey("f");
-  s.WriteFloat(member, 7.0f);
+  s.WriteFloat(*member, 7.0f);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -1085,12 +1086,12 @@ TEST_F(CborShapeSerializerTest, FloatWholeNumberEncodedAsInt) {
 
 TEST_F(CborShapeSerializerTest, TimestampEpochZero) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("ts", ShapeType::Timestamp);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("ts", ShapeType::Timestamp);
+  s.BeginStructure(*root);
   s.WriteMapKey("ts");
   Aws::Utils::DateTime dt(0.0);
-  s.WriteTimestamp(member, dt);
+  s.WriteTimestamp(*member, dt);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -1108,15 +1109,15 @@ TEST_F(CborShapeSerializerTest, TimestampEpochZero) {
 
 TEST_F(CborShapeSerializerTest, LargeBlob) {
   CborShapeSerializer s;
-  Schema root;
-  Schema member("b", ShapeType::Blob);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("b", ShapeType::Blob);
+  s.BeginStructure(*root);
   s.WriteMapKey("b");
   Aws::Utils::ByteBuffer blob(300);
   for (size_t i = 0; i < 300; i++) {
     blob[i] = static_cast<unsigned char>(i % 256);
   }
-  s.WriteBlob(member, blob);
+  s.WriteBlob(*member, blob);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -1136,14 +1137,14 @@ TEST_F(CborShapeSerializerTest, LargeBlob) {
 TEST_F(CborShapeSerializerTest, UnionAsStructure) {
   // Unions serialize like a structure with exactly one field
   CborShapeSerializer s;
-  Schema root;
-  Schema unionMember("result", ShapeType::Union);
-  Schema field("message", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto unionMember = Schema::CreateMember("result", ShapeType::Union);
+  auto field = Schema::CreateMember("message", ShapeType::String);
+  s.BeginStructure(*root);
   s.WriteMapKey("result");
-  s.BeginNestedStructure(unionMember);
+  s.BeginNestedStructure(*unionMember);
   s.WriteMapKey("message");
-  s.WriteString(field, "ok");
+  s.WriteString(*field, "ok");
   s.EndNestedStructure();
   s.EndStructure();
   auto outcome = s.GetPayload();
diff --git a/tests/aws-cpp-sdk-core-tests/smithy/client/schema/JsonShapeSerializerTest.cpp b/tests/aws-cpp-sdk-core-tests/smithy/client/schema/JsonShapeSerializerTest.cpp
index 7ca1e8ffd894..22876355adff 100644
--- a/tests/aws-cpp-sdk-core-tests/smithy/client/schema/JsonShapeSerializerTest.cpp
+++ b/tests/aws-cpp-sdk-core-tests/smithy/client/schema/JsonShapeSerializerTest.cpp
@@ -6,6 +6,8 @@
 #include <aws/testing/AwsCppSdkGTestSuite.h>
 #include <smithy/client/schema/JsonShapeSerializer.h>
 #include <smithy/client/schema/JsonTraits.h>
+#include <smithy/client/schema/Schema.h>
+#include <smithy/client/schema/SchemaBuilder.h>
 
 using namespace smithy::schema;
 
@@ -15,8 +17,8 @@ class JsonShapeSerializerTest : public Aws::Testing::AwsCppSdkGTestSuite {};
 
 TEST_F(JsonShapeSerializerTest, EmptyStructure) {
   JsonShapeSerializer s;
-  Schema root;
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  s.BeginStructure(*root);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -25,117 +27,117 @@ TEST_F(JsonShapeSerializerTest, EmptyStructure) {
 
 TEST_F(JsonShapeSerializerTest, BooleanTrue) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("enabled", ShapeType::Boolean);
-  s.BeginStructure(root);
-  s.WriteBoolean(member, true);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("enabled", ShapeType::Boolean);
+  s.BeginStructure(*root);
+  s.WriteBoolean(*member, true);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"enabled\":true"), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, BooleanFalse) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("enabled", ShapeType::Boolean);
-  s.BeginStructure(root);
-  s.WriteBoolean(member, false);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("enabled", ShapeType::Boolean);
+  s.BeginStructure(*root);
+  s.WriteBoolean(*member, false);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"enabled\":false"), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, Integer) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("count", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.WriteInteger(member, 42);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("count", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.WriteInteger(*member, 42);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"count\":42"), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, Long) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("bigNum", ShapeType::Long);
-  s.BeginStructure(root);
-  s.WriteLong(member, 9876543210LL);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("bigNum", ShapeType::Long);
+  s.BeginStructure(*root);
+  s.WriteLong(*member, 9876543210LL);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"bigNum\":9876543210"), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, Double) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("ratio", ShapeType::Double);
-  s.BeginStructure(root);
-  s.WriteDouble(member, 3.14);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("ratio", ShapeType::Double);
+  s.BeginStructure(*root);
+  s.WriteDouble(*member, 3.14);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"ratio\":3.14"), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, String) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("name", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "hello");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("name", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "hello");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"name\":\"hello\""), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, EmptyString) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("name", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("name", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"name\":\"\""), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, Timestamp) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("created", ShapeType::Timestamp);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("created", ShapeType::Timestamp);
+  s.BeginStructure(*root);
   Aws::Utils::DateTime dt(1234567890.0);
-  s.WriteTimestamp(member, dt);
+  s.WriteTimestamp(*member, dt);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"created\":"), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, Blob) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("data", ShapeType::Blob);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("data", ShapeType::Blob);
+  s.BeginStructure(*root);
   unsigned char raw[] = {0x66, 0x6f, 0x6f};
   Aws::Utils::ByteBuffer buf(raw, 3);
-  s.WriteBlob(member, buf);
+  s.WriteBlob(*member, buf);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"data\":\"Zm9v\""), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, NullValue) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("item", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteNull(member);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("item", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteNull(*member);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"item\":null"), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, MultipleScalars) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema m1("a", ShapeType::Boolean);
-  Schema m2("b", ShapeType::Integer);
-  Schema m3("c", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteBoolean(m1, true);
-  s.WriteInteger(m2, 7);
-  s.WriteString(m3, "x");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto m1 = Schema::CreateMember("a", ShapeType::Boolean);
+  auto m2 = Schema::CreateMember("b", ShapeType::Integer);
+  auto m3 = Schema::CreateMember("c", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteBoolean(*m1, true);
+  s.WriteInteger(*m2, 7);
+  s.WriteString(*m3, "x");
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
   EXPECT_NE(payload.find("\"a\":true"), Aws::String::npos);
@@ -147,12 +149,12 @@ TEST_F(JsonShapeSerializerTest, MultipleScalars) {
 
 TEST_F(JsonShapeSerializerTest, NestedStructure) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema nested("metadata", ShapeType::Structure);
-  Schema inner("key", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginNestedStructure(nested);
-  s.WriteString(inner, "val");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto nested = Schema::CreateMember("metadata", ShapeType::Structure);
+  auto inner = Schema::CreateMember("key", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginNestedStructure(*nested);
+  s.WriteString(*inner, "val");
   s.EndNestedStructure();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"metadata\":{\"key\":\"val\"}"), Aws::String::npos);
@@ -160,14 +162,14 @@ TEST_F(JsonShapeSerializerTest, NestedStructure) {
 
 TEST_F(JsonShapeSerializerTest, DeeplyNestedStructure) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema level1("l1", ShapeType::Structure);
-  Schema level2("l2", ShapeType::Structure);
-  Schema leaf("val", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.BeginNestedStructure(level1);
-  s.BeginNestedStructure(level2);
-  s.WriteInteger(leaf, 99);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto level1 = Schema::CreateMember("l1", ShapeType::Structure);
+  auto level2 = Schema::CreateMember("l2", ShapeType::Structure);
+  auto leaf = Schema::CreateMember("val", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.BeginNestedStructure(*level1);
+  s.BeginNestedStructure(*level2);
+  s.WriteInteger(*leaf, 99);
   s.EndNestedStructure();
   s.EndNestedStructure();
   s.EndStructure();
@@ -178,14 +180,14 @@ TEST_F(JsonShapeSerializerTest, DeeplyNestedStructure) {
 
 TEST_F(JsonShapeSerializerTest, ListOfStrings) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema listMember("tags", ShapeType::List);
-  Schema elem("member", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 3);
-  s.WriteString(elem, "a");
-  s.WriteString(elem, "b");
-  s.WriteString(elem, "c");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("tags", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 3);
+  s.WriteString(*elem, "a");
+  s.WriteString(*elem, "b");
+  s.WriteString(*elem, "c");
   s.EndList();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"tags\":[\"a\",\"b\",\"c\"]"), Aws::String::npos);
@@ -193,14 +195,14 @@ TEST_F(JsonShapeSerializerTest, ListOfStrings) {
 
 TEST_F(JsonShapeSerializerTest, ListOfIntegers) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema listMember("nums", ShapeType::List);
-  Schema elem("member", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 3);
-  s.WriteInteger(elem, 1);
-  s.WriteInteger(elem, 2);
-  s.WriteInteger(elem, 3);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("nums", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 3);
+  s.WriteInteger(*elem, 1);
+  s.WriteInteger(*elem, 2);
+  s.WriteInteger(*elem, 3);
   s.EndList();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"nums\":[1,2,3]"), Aws::String::npos);
@@ -208,10 +210,10 @@ TEST_F(JsonShapeSerializerTest, ListOfIntegers) {
 
 TEST_F(JsonShapeSerializerTest, EmptyList) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema listMember("items", ShapeType::List);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 0);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 0);
   s.EndList();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"items\":[]"), Aws::String::npos);
@@ -219,17 +221,17 @@ TEST_F(JsonShapeSerializerTest, EmptyList) {
 
 TEST_F(JsonShapeSerializerTest, ListOfStructures) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema listMember("items", ShapeType::List);
-  Schema structElem("member", ShapeType::Structure);
-  Schema field("id", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 2);
-  s.BeginNestedStructure(structElem);
-  s.WriteInteger(field, 1);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List);
+  auto structElem = Schema::CreateMember("member", ShapeType::Structure);
+  auto field = Schema::CreateMember("id", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 2);
+  s.BeginNestedStructure(*structElem);
+  s.WriteInteger(*field, 1);
   s.EndNestedStructure();
-  s.BeginNestedStructure(structElem);
-  s.WriteInteger(field, 2);
+  s.BeginNestedStructure(*structElem);
+  s.WriteInteger(*field, 2);
   s.EndNestedStructure();
   s.EndList();
   s.EndStructure();
@@ -238,14 +240,14 @@ TEST_F(JsonShapeSerializerTest, ListOfStructures) {
 
 TEST_F(JsonShapeSerializerTest, SparseList) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema listMember("items", ShapeType::List);
-  Schema elem("member", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 3);
-  s.WriteString(elem, "a");
-  s.WriteNull(elem);
-  s.WriteString(elem, "b");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 3);
+  s.WriteString(*elem, "a");
+  s.WriteNull(*elem);
+  s.WriteString(*elem, "b");
   s.EndList();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"items\":[\"a\",null,\"b\"]"), Aws::String::npos);
@@ -255,15 +257,15 @@ TEST_F(JsonShapeSerializerTest, SparseList) {
 
 TEST_F(JsonShapeSerializerTest, MapOfStrings) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema mapMember("headers", ShapeType::Map);
-  Schema valSchema("value", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 2);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("headers", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 2);
   s.WriteMapKey("x-foo");
-  s.WriteString(valSchema, "bar");
+  s.WriteString(*valSchema, "bar");
   s.WriteMapKey("x-baz");
-  s.WriteString(valSchema, "qux");
+  s.WriteString(*valSchema, "qux");
   s.EndMap();
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
@@ -273,10 +275,10 @@ TEST_F(JsonShapeSerializerTest, MapOfStrings) {
 
 TEST_F(JsonShapeSerializerTest, EmptyMap) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema mapMember("tags", ShapeType::Map);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 0);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("tags", ShapeType::Map);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 0);
   s.EndMap();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"tags\":{}"), Aws::String::npos);
@@ -284,15 +286,15 @@ TEST_F(JsonShapeSerializerTest, EmptyMap) {
 
 TEST_F(JsonShapeSerializerTest, MapOfStructures) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema mapMember("nodes", ShapeType::Map);
-  Schema valSchema("value", ShapeType::Structure);
-  Schema field("val", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 1);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("nodes", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::Structure);
+  auto field = Schema::CreateMember("val", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("a");
-  s.BeginNestedStructure(valSchema);
-  s.WriteInteger(field, 1);
+  s.BeginNestedStructure(*valSchema);
+  s.WriteInteger(*field, 1);
   s.EndNestedStructure();
   s.EndMap();
   s.EndStructure();
@@ -301,15 +303,15 @@ TEST_F(JsonShapeSerializerTest, MapOfStructures) {
 
 TEST_F(JsonShapeSerializerTest, SparseMap) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema mapMember("data", ShapeType::Map);
-  Schema valSchema("value", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 2);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("data", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 2);
   s.WriteMapKey("present");
-  s.WriteString(valSchema, "yes");
+  s.WriteString(*valSchema, "yes");
   s.WriteMapKey("absent");
-  s.WriteNull(valSchema);
+  s.WriteNull(*valSchema);
   s.EndMap();
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
@@ -321,22 +323,22 @@ TEST_F(JsonShapeSerializerTest, SparseMap) {
 
 TEST_F(JsonShapeSerializerTest, StructureWithListAndMap) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema strMember("name", ShapeType::String);
-  Schema listMember("tags", ShapeType::List);
-  Schema listElem("member", ShapeType::String);
-  Schema mapMember("meta", ShapeType::Map);
-  Schema mapVal("value", ShapeType::String);
-
-  s.BeginStructure(root);
-  s.WriteString(strMember, "test");
-  s.BeginList(listMember, 2);
-  s.WriteString(listElem, "t1");
-  s.WriteString(listElem, "t2");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto strMember = Schema::CreateMember("name", ShapeType::String);
+  auto listMember = Schema::CreateMember("tags", ShapeType::List);
+  auto listElem = Schema::CreateMember("member", ShapeType::String);
+  auto mapMember = Schema::CreateMember("meta", ShapeType::Map);
+  auto mapVal = Schema::CreateMember("value", ShapeType::String);
+
+  s.BeginStructure(*root);
+  s.WriteString(*strMember, "test");
+  s.BeginList(*listMember, 2);
+  s.WriteString(*listElem, "t1");
+  s.WriteString(*listElem, "t2");
   s.EndList();
-  s.BeginMap(mapMember, 1);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("k");
-  s.WriteString(mapVal, "v");
+  s.WriteString(*mapVal, "v");
   s.EndMap();
   s.EndStructure();
 
@@ -348,17 +350,17 @@ TEST_F(JsonShapeSerializerTest, StructureWithListAndMap) {
 
 TEST_F(JsonShapeSerializerTest, MapContainingList) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema mapMember("data", ShapeType::Map);
-  Schema listSchema("value", ShapeType::List);
-  Schema elem("member", ShapeType::Integer);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("data", ShapeType::Map);
+  auto listSchema = Schema::CreateMember("value", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::Integer);
 
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 1);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("nums");
-  s.BeginList(listSchema, 2);
-  s.WriteInteger(elem, 1);
-  s.WriteInteger(elem, 2);
+  s.BeginList(*listSchema, 2);
+  s.WriteInteger(*elem, 1);
+  s.WriteInteger(*elem, 2);
   s.EndList();
   s.EndMap();
   s.EndStructure();
@@ -370,56 +372,56 @@ TEST_F(JsonShapeSerializerTest, MapContainingList) {
 
 TEST_F(JsonShapeSerializerTest, EscapesQuotesInString) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("msg", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "say \"hello\"");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("msg", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "say \"hello\"");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"msg\":\"say \\\"hello\\\"\""), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, EscapesBackslash) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("path", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "C:\\Users\\test");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("path", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "C:\\Users\\test");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"path\":\"C:\\\\Users\\\\test\""), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, EscapesControlCharacters) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("text", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "line1\nline2\ttab");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("text", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "line1\nline2\ttab");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"text\":\"line1\\nline2\\ttab\""), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, EscapesNullByte) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("data", ShapeType::String);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("data", ShapeType::String);
+  s.BeginStructure(*root);
   Aws::String val("ab");
   val += '\0';
   val += "cd";
-  s.WriteString(member, val);
+  s.WriteString(*member, val);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"data\":\"ab\\u0000cd\""), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, EscapesInMapKey) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema mapMember("m", ShapeType::Map);
-  Schema valSchema("value", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 1);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto mapMember = Schema::CreateMember("m", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("key\"with\"quotes");
-  s.WriteString(valSchema, "v");
+  s.WriteString(*valSchema, "v");
   s.EndMap();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"key\\\"with\\\"quotes\":\"v\""), Aws::String::npos);
@@ -429,12 +431,12 @@ TEST_F(JsonShapeSerializerTest, EscapesInMapKey) {
 
 TEST_F(JsonShapeSerializerTest, MaxDepthEnforcement) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema nested("n", ShapeType::Structure);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto nested = Schema::CreateMember("n", ShapeType::Structure);
+  s.BeginStructure(*root);
   // Nest 1000+ times to exceed MAX_DEPTH
   for (int i = 0; i < 1000; i++) {
-    s.BeginNestedStructure(nested);
+    s.BeginNestedStructure(*nested);
   }
   auto outcome = s.GetPayload();
   ASSERT_FALSE(outcome.IsSuccess());
@@ -445,11 +447,10 @@ TEST_F(JsonShapeSerializerTest, MaxDepthEnforcement) {
 
 TEST_F(JsonShapeSerializerTest, JsonNameOverridesMemberName) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("internalName", ShapeType::String);
-  member.SetTrait(JsonNameTrait::KEY(), Aws::MakeShared<JsonNameTrait>("Schema", "ExternalName"));
-  s.BeginStructure(root);
-  s.WriteString(member, "hello");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("internalName", ShapeType::String, {{JsonNameTrait::KEY(), Aws::MakeShared<JsonNameTrait>("Schema", "ExternalName")}});
+  s.BeginStructure(*root);
+  s.WriteString(*member, "hello");
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
   EXPECT_NE(payload.find("\"ExternalName\":\"hello\""), Aws::String::npos);
@@ -458,20 +459,20 @@ TEST_F(JsonShapeSerializerTest, JsonNameOverridesMemberName) {
 
 TEST_F(JsonShapeSerializerTest, NoJsonNameUsesGetMemberName) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("fieldName", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "value");
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("fieldName", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "value");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("\"fieldName\":\"value\""), Aws::String::npos);
 }
 
 TEST_F(JsonShapeSerializerTest, FloatValue) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("f", ShapeType::Float);
-  s.BeginStructure(root);
-  s.WriteFloat(member, 1.5f);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("f", ShapeType::Float);
+  s.BeginStructure(*root);
+  s.WriteFloat(*member, 1.5f);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
@@ -480,10 +481,10 @@ TEST_F(JsonShapeSerializerTest, FloatValue) {
 
 TEST_F(JsonShapeSerializerTest, FloatNegativeValue) {
   JsonShapeSerializer s;
-  Schema root;
-  Schema member("f", ShapeType::Float);
-  s.BeginStructure(root);
-  s.WriteFloat(member, -2.25f);
+  auto root = Schema::StructureBuilder("Root").Build();
+  auto member = Schema::CreateMember("f", ShapeType::Float);
+  s.BeginStructure(*root);
+  s.WriteFloat(*member, -2.25f);
   s.EndStructure();
   auto outcome = s.GetPayload();
   ASSERT_TRUE(outcome.IsSuccess());
diff --git a/tests/aws-cpp-sdk-core-tests/smithy/client/schema/XmlShapeSerializerTest.cpp b/tests/aws-cpp-sdk-core-tests/smithy/client/schema/XmlShapeSerializerTest.cpp
index 0918cc9f5037..75cdf7c90679 100644
--- a/tests/aws-cpp-sdk-core-tests/smithy/client/schema/XmlShapeSerializerTest.cpp
+++ b/tests/aws-cpp-sdk-core-tests/smithy/client/schema/XmlShapeSerializerTest.cpp
@@ -4,6 +4,8 @@
  */
 #include <aws/core/utils/DateTime.h>
 #include <aws/testing/AwsCppSdkGTestSuite.h>
+#include <smithy/client/schema/Schema.h>
+#include <smithy/client/schema/SchemaBuilder.h>
 #include <smithy/client/schema/XmlShapeSerializer.h>
 #include <smithy/client/schema/XmlTraits.h>
 
@@ -15,111 +17,111 @@ class XmlShapeSerializerTest : public Aws::Testing::AwsCppSdkGTestSuite {};
 
 TEST_F(XmlShapeSerializerTest, EmptyStructure) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  s.BeginStructure(*root);
   s.EndStructure();
   EXPECT_EQ(s.GetPayload().GetResult(), "<Root></Root>");
 }
 
 TEST_F(XmlShapeSerializerTest, BooleanTrue) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("enabled", ShapeType::Boolean);
-  s.BeginStructure(root);
-  s.WriteBoolean(member, true);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("enabled", ShapeType::Boolean);
+  s.BeginStructure(*root);
+  s.WriteBoolean(*member, true);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<enabled>true</enabled>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, BooleanFalse) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("enabled", ShapeType::Boolean);
-  s.BeginStructure(root);
-  s.WriteBoolean(member, false);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("enabled", ShapeType::Boolean);
+  s.BeginStructure(*root);
+  s.WriteBoolean(*member, false);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<enabled>false</enabled>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, Integer) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("count", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.WriteInteger(member, 42);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("count", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.WriteInteger(*member, 42);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<count>42</count>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, Long) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("bigNum", ShapeType::Long);
-  s.BeginStructure(root);
-  s.WriteLong(member, 9876543210LL);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("bigNum", ShapeType::Long);
+  s.BeginStructure(*root);
+  s.WriteLong(*member, 9876543210LL);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<bigNum>9876543210</bigNum>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, Double) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("ratio", ShapeType::Double);
-  s.BeginStructure(root);
-  s.WriteDouble(member, 3.14);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("ratio", ShapeType::Double);
+  s.BeginStructure(*root);
+  s.WriteDouble(*member, 3.14);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<ratio>3.14</ratio>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, String) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("name", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "hello");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("name", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "hello");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<name>hello</name>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, EmptyString) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("name", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("name", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<name></name>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, Timestamp) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("created", ShapeType::Timestamp);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("created", ShapeType::Timestamp);
+  s.BeginStructure(*root);
   Aws::Utils::DateTime dt(1234567890.0);
-  s.WriteTimestamp(member, dt);
+  s.WriteTimestamp(*member, dt);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<created>2009-02-13T23:31:30Z</created>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, Blob) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("data", ShapeType::Blob);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("data", ShapeType::Blob);
+  s.BeginStructure(*root);
   unsigned char raw[] = {0x66, 0x6f, 0x6f};
   Aws::Utils::ByteBuffer buf(raw, 3);
-  s.WriteBlob(member, buf);
+  s.WriteBlob(*member, buf);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<data>Zm9v</data>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, NullValueOmitted) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("item", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteNull(member);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("item", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteNull(*member);
   s.EndStructure();
   // Null values are omitted in XML
   EXPECT_EQ(s.GetPayload().GetResult(), "<Root></Root>");
@@ -127,14 +129,14 @@ TEST_F(XmlShapeSerializerTest, NullValueOmitted) {
 
 TEST_F(XmlShapeSerializerTest, MultipleScalars) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema m1("a", ShapeType::Boolean);
-  Schema m2("b", ShapeType::Integer);
-  Schema m3("c", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteBoolean(m1, true);
-  s.WriteInteger(m2, 7);
-  s.WriteString(m3, "x");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto m1 = Schema::CreateMember("a", ShapeType::Boolean);
+  auto m2 = Schema::CreateMember("b", ShapeType::Integer);
+  auto m3 = Schema::CreateMember("c", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteBoolean(*m1, true);
+  s.WriteInteger(*m2, 7);
+  s.WriteString(*m3, "x");
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
   EXPECT_NE(payload.find("<a>true</a>"), Aws::String::npos);
@@ -146,12 +148,12 @@ TEST_F(XmlShapeSerializerTest, MultipleScalars) {
 
 TEST_F(XmlShapeSerializerTest, NestedStructure) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema nested("metadata", ShapeType::Structure);
-  Schema inner("key", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginNestedStructure(nested);
-  s.WriteString(inner, "val");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto nested = Schema::CreateMember("metadata", ShapeType::Structure);
+  auto inner = Schema::CreateMember("key", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginNestedStructure(*nested);
+  s.WriteString(*inner, "val");
   s.EndNestedStructure();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<metadata><key>val</key></metadata>"), Aws::String::npos);
@@ -159,14 +161,14 @@ TEST_F(XmlShapeSerializerTest, NestedStructure) {
 
 TEST_F(XmlShapeSerializerTest, DeeplyNestedStructure) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema level1("l1", ShapeType::Structure);
-  Schema level2("l2", ShapeType::Structure);
-  Schema leaf("val", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.BeginNestedStructure(level1);
-  s.BeginNestedStructure(level2);
-  s.WriteInteger(leaf, 99);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto level1 = Schema::CreateMember("l1", ShapeType::Structure);
+  auto level2 = Schema::CreateMember("l2", ShapeType::Structure);
+  auto leaf = Schema::CreateMember("val", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.BeginNestedStructure(*level1);
+  s.BeginNestedStructure(*level2);
+  s.WriteInteger(*leaf, 99);
   s.EndNestedStructure();
   s.EndNestedStructure();
   s.EndStructure();
@@ -177,14 +179,14 @@ TEST_F(XmlShapeSerializerTest, DeeplyNestedStructure) {
 
 TEST_F(XmlShapeSerializerTest, ListOfStrings) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema listMember("tags", ShapeType::List);
-  Schema elem("member", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 3);
-  s.WriteString(elem, "a");
-  s.WriteString(elem, "b");
-  s.WriteString(elem, "c");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto listMember = Schema::CreateMember("tags", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 3);
+  s.WriteString(*elem, "a");
+  s.WriteString(*elem, "b");
+  s.WriteString(*elem, "c");
   s.EndList();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<tags><member>a</member><member>b</member><member>c</member></tags>"), Aws::String::npos);
@@ -192,14 +194,14 @@ TEST_F(XmlShapeSerializerTest, ListOfStrings) {
 
 TEST_F(XmlShapeSerializerTest, ListOfIntegers) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema listMember("nums", ShapeType::List);
-  Schema elem("member", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 3);
-  s.WriteInteger(elem, 1);
-  s.WriteInteger(elem, 2);
-  s.WriteInteger(elem, 3);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto listMember = Schema::CreateMember("nums", ShapeType::List);
+  auto elem = Schema::CreateMember("member", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 3);
+  s.WriteInteger(*elem, 1);
+  s.WriteInteger(*elem, 2);
+  s.WriteInteger(*elem, 3);
   s.EndList();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<nums><member>1</member><member>2</member><member>3</member></nums>"), Aws::String::npos);
@@ -207,10 +209,10 @@ TEST_F(XmlShapeSerializerTest, ListOfIntegers) {
 
 TEST_F(XmlShapeSerializerTest, EmptyList) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema listMember("items", ShapeType::List);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 0);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 0);
   s.EndList();
   s.EndStructure();
   // Empty list still produces the wrapper element
@@ -219,17 +221,17 @@ TEST_F(XmlShapeSerializerTest, EmptyList) {
 
 TEST_F(XmlShapeSerializerTest, ListOfStructures) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema listMember("items", ShapeType::List);
-  Schema structElem("member", ShapeType::Structure);
-  Schema field("id", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 2);
-  s.BeginNestedStructure(structElem);
-  s.WriteInteger(field, 1);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List);
+  auto structElem = Schema::CreateMember("member", ShapeType::Structure);
+  auto field = Schema::CreateMember("id", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 2);
+  s.BeginNestedStructure(*structElem);
+  s.WriteInteger(*field, 1);
   s.EndNestedStructure();
-  s.BeginNestedStructure(structElem);
-  s.WriteInteger(field, 2);
+  s.BeginNestedStructure(*structElem);
+  s.WriteInteger(*field, 2);
   s.EndNestedStructure();
   s.EndList();
   s.EndStructure();
@@ -240,15 +242,15 @@ TEST_F(XmlShapeSerializerTest, ListOfStructures) {
 
 TEST_F(XmlShapeSerializerTest, MapOfStrings) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema mapMember("headers", ShapeType::Map);
-  Schema valSchema("value", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 2);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto mapMember = Schema::CreateMember("headers", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 2);
   s.WriteMapKey("foo");
-  s.WriteString(valSchema, "bar");
+  s.WriteString(*valSchema, "bar");
   s.WriteMapKey("baz");
-  s.WriteString(valSchema, "qux");
+  s.WriteString(*valSchema, "qux");
   s.EndMap();
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
@@ -260,10 +262,10 @@ TEST_F(XmlShapeSerializerTest, MapOfStrings) {
 
 TEST_F(XmlShapeSerializerTest, EmptyMap) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema mapMember("tags", ShapeType::Map);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 0);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto mapMember = Schema::CreateMember("tags", ShapeType::Map);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 0);
   s.EndMap();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<tags></tags>"), Aws::String::npos);
@@ -271,15 +273,15 @@ TEST_F(XmlShapeSerializerTest, EmptyMap) {
 
 TEST_F(XmlShapeSerializerTest, MapOfStructures) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema mapMember("nodes", ShapeType::Map);
-  Schema valSchema("value", ShapeType::Structure);
-  Schema field("val", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 1);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto mapMember = Schema::CreateMember("nodes", ShapeType::Map);
+  auto valSchema = Schema::CreateMember("value", ShapeType::Structure);
+  auto field = Schema::CreateMember("val", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("a");
-  s.BeginNestedStructure(valSchema);
-  s.WriteInteger(field, 1);
+  s.BeginNestedStructure(*valSchema);
+  s.WriteInteger(*field, 1);
   s.EndNestedStructure();
   s.EndMap();
   s.EndStructure();
@@ -290,22 +292,22 @@ TEST_F(XmlShapeSerializerTest, MapOfStructures) {
 
 TEST_F(XmlShapeSerializerTest, StructureWithListAndMap) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema strMember("name", ShapeType::String);
-  Schema listMember("tags", ShapeType::List);
-  Schema listElem("member", ShapeType::String);
-  Schema mapMember("meta", ShapeType::Map);
-  Schema mapVal("value", ShapeType::String);
-
-  s.BeginStructure(root);
-  s.WriteString(strMember, "test");
-  s.BeginList(listMember, 2);
-  s.WriteString(listElem, "t1");
-  s.WriteString(listElem, "t2");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto strMember = Schema::CreateMember("name", ShapeType::String);
+  auto listMember = Schema::CreateMember("tags", ShapeType::List);
+  auto listElem = Schema::CreateMember("member", ShapeType::String);
+  auto mapMember = Schema::CreateMember("meta", ShapeType::Map);
+  auto mapVal = Schema::CreateMember("value", ShapeType::String);
+
+  s.BeginStructure(*root);
+  s.WriteString(*strMember, "test");
+  s.BeginList(*listMember, 2);
+  s.WriteString(*listElem, "t1");
+  s.WriteString(*listElem, "t2");
   s.EndList();
-  s.BeginMap(mapMember, 1);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("k");
-  s.WriteString(mapVal, "v");
+  s.WriteString(*mapVal, "v");
   s.EndMap();
   s.EndStructure();
 
@@ -319,50 +321,50 @@ TEST_F(XmlShapeSerializerTest, StructureWithListAndMap) {
 
 TEST_F(XmlShapeSerializerTest, EscapesAmpersand) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("msg", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "a&b");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("msg", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "a&b");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<msg>a&amp;b</msg>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, EscapesLessThan) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("msg", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "a<b");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("msg", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "a<b");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<msg>a&lt;b</msg>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, EscapesGreaterThan) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("msg", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "a>b");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("msg", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "a>b");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<msg>a&gt;b</msg>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, EscapesQuotes) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("msg", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "say \"hello\"");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("msg", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "say \"hello\"");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<msg>say &quot;hello&quot;</msg>"), Aws::String::npos);
 }
 
 TEST_F(XmlShapeSerializerTest, EscapesMultipleSpecialChars) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("expr", ShapeType::String);
-  s.BeginStructure(root);
-  s.WriteString(member, "x < 5 & y > 3");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("expr", ShapeType::String);
+  s.BeginStructure(*root);
+  s.WriteString(*member, "x < 5 & y > 3");
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<expr>x &lt; 5 &amp; y &gt; 3</expr>"), Aws::String::npos);
 }
@@ -371,12 +373,12 @@ TEST_F(XmlShapeSerializerTest, EscapesMultipleSpecialChars) {
 
 TEST_F(XmlShapeSerializerTest, MaxDepthEnforcement) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema nested("n", ShapeType::Structure);
-  s.BeginStructure(root);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto nested = Schema::CreateMember("n", ShapeType::Structure);
+  s.BeginStructure(*root);
   bool hitLimit = false;
   for (int i = 0; i < 1000; i++) {
-    if (!s.BeginNestedStructure(nested)) {
+    if (!s.BeginNestedStructure(*nested)) {
       hitLimit = true;
       break;
     }
@@ -388,11 +390,10 @@ TEST_F(XmlShapeSerializerTest, MaxDepthEnforcement) {
 
 TEST_F(XmlShapeSerializerTest, XmlNameOverridesMemberName) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("internalName", ShapeType::String);
-  member.SetTrait(XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "ExternalName"));
-  s.BeginStructure(root);
-  s.WriteString(member, "hello");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("internalName", ShapeType::String, {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "ExternalName")}});
+  s.BeginStructure(*root);
+  s.WriteString(*member, "hello");
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
   EXPECT_NE(payload.find("<ExternalName>hello</ExternalName>"), Aws::String::npos);
@@ -401,11 +402,10 @@ TEST_F(XmlShapeSerializerTest, XmlNameOverridesMemberName) {
 
 TEST_F(XmlShapeSerializerTest, XmlNameOnStructure) {
   XmlShapeSerializer s;
-  Schema root("MyStruct", ShapeType::Structure);
-  root.SetTrait(XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "CustomRoot"));
-  Schema field("val", ShapeType::Integer);
-  s.BeginStructure(root);
-  s.WriteInteger(field, 42);
+  auto root = Schema::StructureBuilder("MyStruct", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "CustomRoot")}}).Build();
+  auto field = Schema::CreateMember("val", ShapeType::Integer);
+  s.BeginStructure(*root);
+  s.WriteInteger(*field, 42);
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<CustomRoot><val>42</val></CustomRoot>"), Aws::String::npos);
 }
@@ -414,15 +414,14 @@ TEST_F(XmlShapeSerializerTest, XmlNameOnStructure) {
 
 TEST_F(XmlShapeSerializerTest, FlattenedListOfStrings) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema listMember("item", ShapeType::List);
-  listMember.SetTrait(XmlFlattenedTrait::KEY(), Aws::MakeShared<XmlFlattenedTrait>("Schema"));
-  Schema elem("member", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 3);
-  s.WriteString(elem, "a");
-  s.WriteString(elem, "b");
-  s.WriteString(elem, "c");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto listMember = Schema::CreateMember("item", ShapeType::List, {{XmlFlattenedTrait::KEY(), Aws::MakeShared<XmlFlattenedTrait>("Schema")}});
+  auto elem = Schema::CreateMember("member", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 3);
+  s.WriteString(*elem, "a");
+  s.WriteString(*elem, "b");
+  s.WriteString(*elem, "c");
   s.EndList();
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
@@ -434,15 +433,13 @@ TEST_F(XmlShapeSerializerTest, FlattenedListOfStrings) {
 
 TEST_F(XmlShapeSerializerTest, FlattenedListWithXmlName) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema listMember("items", ShapeType::List);
-  listMember.SetTrait(XmlFlattenedTrait::KEY(), Aws::MakeShared<XmlFlattenedTrait>("Schema"));
-  listMember.SetTrait(XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Tag"));
-  Schema elem("member", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 2);
-  s.WriteString(elem, "x");
-  s.WriteString(elem, "y");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto listMember = Schema::CreateMember("items", ShapeType::List, {{XmlFlattenedTrait::KEY(), Aws::MakeShared<XmlFlattenedTrait>("Schema")}, {XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Tag")}});
+  auto elem = Schema::CreateMember("member", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 2);
+  s.WriteString(*elem, "x");
+  s.WriteString(*elem, "y");
   s.EndList();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<Tag>x</Tag><Tag>y</Tag>"), Aws::String::npos);
@@ -452,14 +449,13 @@ TEST_F(XmlShapeSerializerTest, FlattenedListWithXmlName) {
 
 TEST_F(XmlShapeSerializerTest, CustomListItemName) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema listMember("things", ShapeType::List);
-  listMember.SetTrait(XmlListItemNameTrait::KEY(), Aws::MakeShared<XmlListItemNameTrait>("Schema", "item"));
-  Schema elem("member", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginList(listMember, 2);
-  s.WriteString(elem, "a");
-  s.WriteString(elem, "b");
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto listMember = Schema::CreateMember("things", ShapeType::List, {{XmlListItemNameTrait::KEY(), Aws::MakeShared<XmlListItemNameTrait>("Schema", "item")}});
+  auto elem = Schema::CreateMember("member", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginList(*listMember, 2);
+  s.WriteString(*elem, "a");
+  s.WriteString(*elem, "b");
   s.EndList();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<things><item>a</item><item>b</item></things>"), Aws::String::npos);
@@ -469,16 +465,13 @@ TEST_F(XmlShapeSerializerTest, CustomListItemName) {
 
 TEST_F(XmlShapeSerializerTest, CustomMapNames) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema mapMember("tags", ShapeType::Map);
-  mapMember.SetTrait(XmlMapEntryNameTrait::KEY(), Aws::MakeShared<XmlMapEntryNameTrait>("Schema", "item"));
-  mapMember.SetTrait(XmlMapKeyNameTrait::KEY(), Aws::MakeShared<XmlMapKeyNameTrait>("Schema", "tagKey"));
-  mapMember.SetTrait(XmlMapValueNameTrait::KEY(), Aws::MakeShared<XmlMapValueNameTrait>("Schema", "tagValue"));
-  Schema valSchema("value", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 1);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto mapMember = Schema::CreateMember("tags", ShapeType::Map, {{XmlMapEntryNameTrait::KEY(), Aws::MakeShared<XmlMapEntryNameTrait>("Schema", "item")}, {XmlMapKeyNameTrait::KEY(), Aws::MakeShared<XmlMapKeyNameTrait>("Schema", "tagKey")}, {XmlMapValueNameTrait::KEY(), Aws::MakeShared<XmlMapValueNameTrait>("Schema", "tagValue")}});
+  auto valSchema = Schema::CreateMember("value", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 1);
   s.WriteMapKey("color");
-  s.WriteString(valSchema, "red");
+  s.WriteString(*valSchema, "red");
   s.EndMap();
   s.EndStructure();
   EXPECT_NE(s.GetPayload().GetResult().find("<tags><item><tagKey>color</tagKey><tagValue>red</tagValue></item></tags>"), Aws::String::npos);
@@ -486,16 +479,15 @@ TEST_F(XmlShapeSerializerTest, CustomMapNames) {
 
 TEST_F(XmlShapeSerializerTest, FlattenedMap) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema mapMember("tag", ShapeType::Map);
-  mapMember.SetTrait(XmlFlattenedTrait::KEY(), Aws::MakeShared<XmlFlattenedTrait>("Schema"));
-  Schema valSchema("value", ShapeType::String);
-  s.BeginStructure(root);
-  s.BeginMap(mapMember, 2);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto mapMember = Schema::CreateMember("tag", ShapeType::Map, {{XmlFlattenedTrait::KEY(), Aws::MakeShared<XmlFlattenedTrait>("Schema")}});
+  auto valSchema = Schema::CreateMember("value", ShapeType::String);
+  s.BeginStructure(*root);
+  s.BeginMap(*mapMember, 2);
   s.WriteMapKey("k1");
-  s.WriteString(valSchema, "v1");
+  s.WriteString(*valSchema, "v1");
   s.WriteMapKey("k2");
-  s.WriteString(valSchema, "v2");
+  s.WriteString(*valSchema, "v2");
   s.EndMap();
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
@@ -506,10 +498,10 @@ TEST_F(XmlShapeSerializerTest, FlattenedMap) {
 
 TEST_F(XmlShapeSerializerTest, FloatValue) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("temp", ShapeType::Float);
-  s.BeginStructure(root);
-  s.WriteFloat(member, 1.5f);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("temp", ShapeType::Float);
+  s.BeginStructure(*root);
+  s.WriteFloat(*member, 1.5f);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
   EXPECT_NE(payload.find("<temp>1.5</temp>"), Aws::String::npos);
@@ -517,10 +509,10 @@ TEST_F(XmlShapeSerializerTest, FloatValue) {
 
 TEST_F(XmlShapeSerializerTest, FloatNegativeValue) {
   XmlShapeSerializer s;
-  Schema root("Root", ShapeType::Structure);
-  Schema member("val", ShapeType::Float);
-  s.BeginStructure(root);
-  s.WriteFloat(member, -2.25f);
+  auto root = Schema::StructureBuilder("Root", {{XmlNameTrait::KEY(), Aws::MakeShared<XmlNameTrait>("Schema", "Root")}}).Build();
+  auto member = Schema::CreateMember("val", ShapeType::Float);
+  s.BeginStructure(*root);
+  s.WriteFloat(*member, -2.25f);
   s.EndStructure();
   auto payload = s.GetPayload().GetResult();
   EXPECT_NE(payload.find("<val>-2.25</val>"), Aws::String::npos);