diff --git a/contract-tests/client-contract-tests/src/entity_manager.cpp b/contract-tests/client-contract-tests/src/entity_manager.cpp
index 5a4d57c80..9993b932b 100644
--- a/contract-tests/client-contract-tests/src/entity_manager.cpp
+++ b/contract-tests/client-contract-tests/src/entity_manager.cpp
@@ -1,10 +1,11 @@
 #include "entity_manager.hpp"
-#include <boost/json/parse.hpp>
 
 #include <launchdarkly/config/client.hpp>
 #include <launchdarkly/context_builder.hpp>
 #include <launchdarkly/serialization/json_context.hpp>
 
+#include <boost/json.hpp>
+
 using launchdarkly::LogLevel;
 using namespace launchdarkly::client_side;
 
diff --git a/contract-tests/server-contract-tests/src/entity_manager.cpp b/contract-tests/server-contract-tests/src/entity_manager.cpp
index c7db150fb..fa9d2579c 100644
--- a/contract-tests/server-contract-tests/src/entity_manager.cpp
+++ b/contract-tests/server-contract-tests/src/entity_manager.cpp
@@ -1,10 +1,11 @@
 #include "entity_manager.hpp"
-#include <boost/json/parse.hpp>
 
 #include <launchdarkly/context_builder.hpp>
 #include <launchdarkly/serialization/json_context.hpp>
 #include <launchdarkly/server_side/config/config_builder.hpp>
 
+#include <boost/json.hpp>
+
 using launchdarkly::LogLevel;
 using namespace launchdarkly::server_side;
 
@@ -17,8 +18,16 @@ std::optional<std::string> EntityManager::create(ConfigParams const& in) {
 
     auto config_builder = ConfigBuilder(in.credential);
 
-    auto default_endpoints =
-        launchdarkly::server_side::Defaults::ServiceEndpoints();
+    // The contract test service sets endpoints in a way that is disallowed
+    // for users. Specifically, it may set just 1 of the 3 endpoints, whereas
+    // we require all 3 to be set.
+    //
+    // To avoid that error being detected, we must configure the Endpoints
+    // builder with the 3 default URLs, which we can fetch by just calling Build
+    // on a new builder. That way when the contract tests set just 1 URL,
+    // the others have already been "set" so no error occurs.
+    auto const default_endpoints =
+        *config::builders::EndpointsBuilder().Build();
 
     auto& endpoints =
         config_builder.ServiceEndpoints()
@@ -37,18 +46,17 @@ std::optional<std::string> EntityManager::create(ConfigParams const& in) {
             endpoints.EventsBaseUrl(*in.serviceEndpoints->events);
         }
     }
-
-    auto& datasource = config_builder.DataSource();
+    auto datasystem = config::builders::DataSystemBuilder::BackgroundSync();
 
     if (in.streaming) {
         if (in.streaming->baseUri) {
             endpoints.StreamingBaseUrl(*in.streaming->baseUri);
         }
         if (in.streaming->initialRetryDelayMs) {
-            auto streaming = DataSourceBuilder::Streaming();
+            auto streaming = decltype(datasystem)::Streaming();
             streaming.InitialReconnectDelay(
                 std::chrono::milliseconds(*in.streaming->initialRetryDelayMs));
-            datasource.Method(std::move(streaming));
+            datasystem.Synchronizer(std::move(streaming));
         }
     }
 
@@ -57,17 +65,19 @@ std::optional<std::string> EntityManager::create(ConfigParams const& in) {
             endpoints.PollingBaseUrl(*in.polling->baseUri);
         }
         if (!in.streaming) {
-            auto method = DataSourceBuilder::Polling();
+            auto method = decltype(datasystem)::Polling();
             if (in.polling->pollIntervalMs) {
                 method.PollInterval(
                     std::chrono::duration_cast<std::chrono::seconds>(
                         std::chrono::milliseconds(
                             *in.polling->pollIntervalMs)));
             }
-            datasource.Method(std::move(method));
+            datasystem.Synchronizer(std::move(method));
         }
     }
 
+    config_builder.DataSystem().Method(std::move(datasystem));
+
     auto& event_config = config_builder.Events();
 
     if (in.events) {
diff --git a/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp b/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp
index 2d3615041..a283fe669 100644
--- a/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp
+++ b/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp
@@ -25,6 +25,12 @@ struct StreamingConfig<ServerSDK> {
     std::string streaming_path;
 };
 
+inline bool operator==(StreamingConfig<ServerSDK> const& lhs,
+                       StreamingConfig<ServerSDK> const& rhs) {
+    return lhs.initial_reconnect_delay == rhs.initial_reconnect_delay &&
+           lhs.streaming_path == rhs.streaming_path;
+}
+
 template <typename SDK>
 struct PollingConfig;
 
diff --git a/libs/common/include/launchdarkly/error.hpp b/libs/common/include/launchdarkly/error.hpp
index a50afe433..baa35bfd4 100644
--- a/libs/common/include/launchdarkly/error.hpp
+++ b/libs/common/include/launchdarkly/error.hpp
@@ -23,7 +23,7 @@ enum class Error : std::uint32_t {
     kConfig_SDKKey_Empty = 400,
     /* Client-side errors: 10000-19999 */
     /* Server-side errors: 20000-29999 */
-
+    kConfig_DataSystem_LazyLoad_MissingSource = 20000,
     kMax = std::numeric_limits<std::uint32_t>::max()
 };
 
diff --git a/libs/common/src/error.cpp b/libs/common/src/error.cpp
index d584d0aa6..2f2eef527 100644
--- a/libs/common/src/error.cpp
+++ b/libs/common/src/error.cpp
@@ -30,6 +30,8 @@ char const* ErrorToString(Error err) {
             return "events: capacity must be non-zero";
         case Error::kConfig_SDKKey_Empty:
             return "sdk key: cannot be empty";
+        case Error::kConfig_DataSystem_LazyLoad_MissingSource:
+            return "data system: lazy load config requires a source";
         case Error::kMax:
             break;
     }
diff --git a/libs/server-sdk/include/launchdarkly/server_side/config/builders/data_system/lazy_load_builder.hpp b/libs/server-sdk/include/launchdarkly/server_side/config/builders/data_system/lazy_load_builder.hpp
index b6945a770..fbe224dd2 100644
--- a/libs/server-sdk/include/launchdarkly/server_side/config/builders/data_system/lazy_load_builder.hpp
+++ b/libs/server-sdk/include/launchdarkly/server_side/config/builders/data_system/lazy_load_builder.hpp
@@ -34,7 +34,7 @@ struct LazyLoadBuilder {
 
     /**
      * \brief Specify the source of the data.
-     * \param source Component implementing ISerializedDataReader.
+     * \param source Component implementing ISerializedDataPullSource.
      * \return Reference to this.
      */
     LazyLoadBuilder& Source(SourcePtr source);
@@ -45,7 +45,7 @@ struct LazyLoadBuilder {
      * before being refreshed from the database. The chosen \ref EvictionPolicy
      * affects usage of this TTL. \return Reference to this.
      */
-    LazyLoadBuilder& CacheTTL(std::chrono::milliseconds ttl);
+    LazyLoadBuilder& CacheRefresh(std::chrono::milliseconds ttl);
 
     /**
      * \brief Specify the eviction policy when a data item's TTL expires.
diff --git a/libs/server-sdk/include/launchdarkly/server_side/data_interfaces/sources/iserialized_data_reader.hpp b/libs/server-sdk/include/launchdarkly/server_side/data_interfaces/sources/iserialized_data_reader.hpp
index ad6f98197..88e0fd0f2 100644
--- a/libs/server-sdk/include/launchdarkly/server_side/data_interfaces/sources/iserialized_data_reader.hpp
+++ b/libs/server-sdk/include/launchdarkly/server_side/data_interfaces/sources/iserialized_data_reader.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-#include <launchdarkly/server_side/integrations/serialized_descriptors.hpp>
+#include <launchdarkly/server_side/integrations/iserialized_item_kind.hpp>
+#include <launchdarkly/server_side/integrations/serialized_item_descriptor.hpp>
 
 #include <tl/expected.hpp>
 
@@ -31,8 +32,7 @@ class ISerializedDataReader {
     virtual ~ISerializedDataReader() = default;
     ISerializedDataReader(ISerializedDataReader const& item) = delete;
     ISerializedDataReader(ISerializedDataReader&& item) = delete;
-    ISerializedDataReader& operator=(ISerializedDataReader const&) =
-        delete;
+    ISerializedDataReader& operator=(ISerializedDataReader const&) = delete;
     ISerializedDataReader& operator=(ISerializedDataReader&&) = delete;
 
     struct Error {
@@ -55,7 +55,7 @@ class ISerializedDataReader {
      * if the item did not exist, or an error. For a deleted item the serialized
      * item descriptor may contain a std::nullopt for the serializedItem.
      */
-    virtual GetResult Get(integrations::IPersistentKind const& kind,
+    virtual GetResult Get(integrations::ISerializedItemKind const& kind,
                           std::string const& itemKey) const = 0;
 
     /**
@@ -67,7 +67,8 @@ class ISerializedDataReader {
      * @return Either all of the items of the type, or an error. If there are
      * no items of the specified type, then return an empty collection.
      */
-    virtual AllResult All(integrations::IPersistentKind const& kind) const = 0;
+    virtual AllResult All(
+        integrations::ISerializedItemKind const& kind) const = 0;
 
     virtual std::string const& Identity() const = 0;
 
diff --git a/libs/server-sdk/src/CMakeLists.txt b/libs/server-sdk/src/CMakeLists.txt
index fbbb2c910..ae8b00dad 100644
--- a/libs/server-sdk/src/CMakeLists.txt
+++ b/libs/server-sdk/src/CMakeLists.txt
@@ -19,8 +19,14 @@ target_sources(${LIBNAME}
         boost.cpp
         client.cpp
         client_impl.cpp
+        data_source_status.cpp
         config/config.cpp
         config/config_builder.cpp
+        config/builders/data_system/background_sync_builder.cpp
+        config/builders/data_system/bootstrap_builder.cpp
+        config/builders/data_system/data_system_builder.cpp
+        config/builders/data_system/lazy_load_builder.cpp
+        config/builders/data_system/data_destination_builder.cpp
         all_flags_state/all_flags_state.cpp
         all_flags_state/json_all_flags_state.cpp
         all_flags_state/all_flags_state_builder.cpp
diff --git a/libs/server-sdk/src/bindings/c/builder.cpp b/libs/server-sdk/src/bindings/c/builder.cpp
index fe8037413..42e9a6a6d 100644
--- a/libs/server-sdk/src/bindings/c/builder.cpp
+++ b/libs/server-sdk/src/bindings/c/builder.cpp
@@ -7,18 +7,19 @@
 #include <launchdarkly/server_side/config/config_builder.hpp>
 
 using namespace launchdarkly::server_side;
+using namespace launchdarkly::server_side::config::builders;
 
 #define TO_BUILDER(ptr) (reinterpret_cast<ConfigBuilder*>(ptr))
 #define FROM_BUILDER(ptr) (reinterpret_cast<LDServerConfigBuilder>(ptr))
 
 #define TO_STREAM_BUILDER(ptr) \
-    (reinterpret_cast<DataSourceBuilder::Streaming*>(ptr))
+    (reinterpret_cast<DataSystemBuilder::BackgroundSync::Streaming*>(ptr))
 
 #define FROM_STREAM_BUILDER(ptr) \
     (reinterpret_cast<LDServerDataSourceStreamBuilder>(ptr))
 
 #define TO_POLL_BUILDER(ptr) \
-    (reinterpret_cast<DataSourceBuilder::Polling*>(ptr))
+    (reinterpret_cast<DataSystemBuilder::BackgroundSync::Polling*>(ptr))
 
 #define FROM_POLL_BUILDER(ptr) \
     (reinterpret_cast<LDServerDataSourcePollBuilder>(ptr))
@@ -121,7 +122,7 @@ LD_EXPORT(void)
 LDServerConfigBuilder_Offline(LDServerConfigBuilder b, bool offline) {
     LD_ASSERT_NOT_NULL(b);
 
-    TO_BUILDER(b)->Offline(offline);
+    // TO_BUILDER(b)->Offline(offline);
 }
 
 LD_EXPORT(void)
@@ -171,8 +172,9 @@ LDServerConfigBuilder_DataSource_MethodStream(
     LD_ASSERT_NOT_NULL(b);
     LD_ASSERT_NOT_NULL(stream_builder);
 
-    DataSourceBuilder::Streaming* sb = TO_STREAM_BUILDER(stream_builder);
-    TO_BUILDER(b)->DataSource().Method(*sb);
+    BackgroundSyncBuilder::Streaming* sb = TO_STREAM_BUILDER(stream_builder);
+    TO_BUILDER(b)->DataSystem().Method(
+        BackgroundSyncBuilder().Synchronizer(*sb));
     LDServerDataSourceStreamBuilder_Free(stream_builder);
 }
 
@@ -183,14 +185,15 @@ LDServerConfigBuilder_DataSource_MethodPoll(
     LD_ASSERT_NOT_NULL(b);
     LD_ASSERT_NOT_NULL(poll_builder);
 
-    DataSourceBuilder::Polling* pb = TO_POLL_BUILDER(poll_builder);
-    TO_BUILDER(b)->DataSource().Method(*pb);
+    BackgroundSyncBuilder::Polling* pb = TO_POLL_BUILDER(poll_builder);
+    TO_BUILDER(b)->DataSystem().Method(
+        BackgroundSyncBuilder().Synchronizer(*pb));
     LDServerDataSourcePollBuilder_Free(poll_builder);
 }
 
 LD_EXPORT(LDServerDataSourceStreamBuilder)
 LDServerDataSourceStreamBuilder_New() {
-    return FROM_STREAM_BUILDER(new DataSourceBuilder::Streaming());
+    return FROM_STREAM_BUILDER(new BackgroundSyncBuilder::Streaming());
 }
 
 LD_EXPORT(void)
@@ -209,7 +212,7 @@ LDServerDataSourceStreamBuilder_Free(LDServerDataSourceStreamBuilder b) {
 }
 
 LD_EXPORT(LDServerDataSourcePollBuilder) LDServerDataSourcePollBuilder_New() {
-    return FROM_POLL_BUILDER(new DataSourceBuilder::Polling());
+    return FROM_POLL_BUILDER(new BackgroundSyncBuilder::Polling());
 }
 
 LD_EXPORT(void)
diff --git a/libs/server-sdk/src/bindings/c/sdk.cpp b/libs/server-sdk/src/bindings/c/sdk.cpp
index 78d13f0f8..3cb6159a3 100644
--- a/libs/server-sdk/src/bindings/c/sdk.cpp
+++ b/libs/server-sdk/src/bindings/c/sdk.cpp
@@ -27,8 +27,8 @@ struct Detail;
 #define FROM_DETAIL(ptr) (reinterpret_cast<LDEvalDetail>(ptr))
 
 #define TO_DATASOURCESTATUS(ptr) \
-    (reinterpret_cast<           \
-        launchdarkly::server_side::data_sources::DataSourceStatus*>(ptr))
+    (reinterpret_cast<launchdarkly::server_side::DataSourceStatus*>(ptr))
+
 #define FROM_DATASOURCESTATUS(ptr) \
     (reinterpret_cast<LDServerDataSourceStatus>(ptr))
 
@@ -356,10 +356,8 @@ LDServerDataSourceStatus_GetLastError(LDServerDataSourceStatus status) {
     if (!error) {
         return nullptr;
     }
-    return FROM_DATASOURCESTATUS_ERRORINFO(
-        new data_sources::DataSourceStatus::ErrorInfo(
-            error->Kind(), error->StatusCode(), error->Message(),
-            error->Time()));
+    return FROM_DATASOURCESTATUS_ERRORINFO(new DataSourceStatus::ErrorInfo(
+        error->Kind(), error->StatusCode(), error->Message(), error->Time()));
 }
 
 LD_EXPORT(time_t)
@@ -387,7 +385,7 @@ LDServerSDK_DataSourceStatus_OnStatusChange(
     if (listener.StatusChanged) {
         auto connection =
             TO_SDK(sdk)->DataSourceStatus().OnDataSourceStatusChange(
-                [listener](data_sources::DataSourceStatus status) {
+                [listener](DataSourceStatus status) {
                     listener.StatusChanged(FROM_DATASOURCESTATUS(&status),
                                            listener.UserData);
                 });
@@ -402,8 +400,8 @@ LD_EXPORT(LDServerDataSourceStatus)
 LDServerSDK_DataSourceStatus_Status(LDServerSDK sdk) {
     LD_ASSERT_NOT_NULL(sdk);
 
-    return FROM_DATASOURCESTATUS(new data_sources::DataSourceStatus(
-        TO_SDK(sdk)->DataSourceStatus().Status()));
+    return FROM_DATASOURCESTATUS(
+        new DataSourceStatus(TO_SDK(sdk)->DataSourceStatus().Status()));
 }
 
 LD_EXPORT(void) LDServerDataSourceStatus_Free(LDServerDataSourceStatus status) {
diff --git a/libs/server-sdk/src/config/builders/data_system/background_sync_builder.cpp b/libs/server-sdk/src/config/builders/data_system/background_sync_builder.cpp
index c05d7622b..7e573455b 100644
--- a/libs/server-sdk/src/config/builders/data_system/background_sync_builder.cpp
+++ b/libs/server-sdk/src/config/builders/data_system/background_sync_builder.cpp
@@ -1,21 +1,23 @@
 #include <launchdarkly/server_side/config/builders/data_system/background_sync_builder.hpp>
 
+#include "defaults.hpp"
+
 namespace launchdarkly::server_side::config::builders {
 
 BackgroundSyncBuilder::BackgroundSyncBuilder()
-    : bootstrap_builder_(), config_() {}
+    : bootstrap_builder_(), config_(Defaults::BackgroundSyncConfig()) {}
 
 BootstrapBuilder& BackgroundSyncBuilder::Bootstrapper() {
     return bootstrap_builder_;
 }
 
 BackgroundSyncBuilder& BackgroundSyncBuilder::Synchronizer(Streaming source) {
-    config_.source_.method = source.Build();
+    config_.synchronizer_ = source.Build();
     return *this;
 }
 
 BackgroundSyncBuilder& BackgroundSyncBuilder::Synchronizer(Polling source) {
-    config_.source_.method = source.Build();
+    config_.synchronizer_ = source.Build();
     return *this;
 }
 
diff --git a/libs/server-sdk/src/config/builders/data_system/defaults.hpp b/libs/server-sdk/src/config/builders/data_system/defaults.hpp
index 43c6f734f..ad74843a0 100644
--- a/libs/server-sdk/src/config/builders/data_system/defaults.hpp
+++ b/libs/server-sdk/src/config/builders/data_system/defaults.hpp
@@ -19,8 +19,13 @@ struct Defaults {
         return std::nullopt;
     }
 
+    static auto SynchronizerConfig()
+       -> built::BackgroundSyncConfig::StreamingConfig {
+        return {std::chrono::seconds(1), "/all"};
+    }
+
     static auto BackgroundSyncConfig() -> built::BackgroundSyncConfig {
-        return {BootstrapConfig(), DataSourceConfig(), DataDestinationConfig()};
+        return {BootstrapConfig(), SynchronizerConfig(), DataDestinationConfig()};
     }
 
     static auto LazyLoadConfig() -> built::LazyLoadConfig {
diff --git a/libs/server-sdk/src/config/builders/data_system/lazy_load_builder.cpp b/libs/server-sdk/src/config/builders/data_system/lazy_load_builder.cpp
index 06cef97f2..7fe2ed2c5 100644
--- a/libs/server-sdk/src/config/builders/data_system/lazy_load_builder.cpp
+++ b/libs/server-sdk/src/config/builders/data_system/lazy_load_builder.cpp
@@ -6,7 +6,7 @@ namespace launchdarkly::server_side::config::builders {
 
 LazyLoadBuilder::LazyLoadBuilder() : config_(Defaults::LazyLoadConfig()) {}
 
-LazyLoadBuilder& LazyLoadBuilder::CacheTTL(
+LazyLoadBuilder& LazyLoadBuilder::CacheRefresh(
     std::chrono::milliseconds const ttl) {
     config_.eviction_ttl = ttl;
     return *this;
diff --git a/libs/server-sdk/src/data_components/kinds/kinds.hpp b/libs/server-sdk/src/data_components/kinds/kinds.hpp
index 21f07212e..bb2a0d22e 100644
--- a/libs/server-sdk/src/data_components/kinds/kinds.hpp
+++ b/libs/server-sdk/src/data_components/kinds/kinds.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
-#include <launchdarkly/server_side/integrations/serialized_descriptors.hpp>
+#include <launchdarkly/server_side/integrations/iserialized_item_kind.hpp>
 
 namespace launchdarkly::server_side::data_components {
 
-class SegmentKind final : public integrations::IPersistentKind {
+class SegmentKind final : public integrations::ISerializedItemKind {
    public:
     std::string const& Namespace() const override;
     std::uint64_t Version(std::string const& data) const override;
@@ -15,7 +15,7 @@ class SegmentKind final : public integrations::IPersistentKind {
     static inline std::string const namespace_ = "segments";
 };
 
-class FlagKind final : public integrations::IPersistentKind {
+class FlagKind final : public integrations::ISerializedItemKind {
    public:
     std::string const& Namespace() const override;
     std::uint64_t Version(std::string const& data) const override;
diff --git a/libs/server-sdk/src/data_components/serialization_adapters/json_data_reader.cpp b/libs/server-sdk/src/data_components/serialization_adapters/json_data_reader.cpp
index 4c14a1672..c373af311 100644
--- a/libs/server-sdk/src/data_components/serialization_adapters/json_data_reader.cpp
+++ b/libs/server-sdk/src/data_components/serialization_adapters/json_data_reader.cpp
@@ -25,11 +25,13 @@ JsonDataReader::GetSegment(std::string const& key) const {
 data_interfaces::IDataReader::Collection<data_model::FlagDescriptor>
 JsonDataReader::AllFlags() const {
     // TODO: deserialize then return
+    return tl::make_unexpected("Not implemented");
 }
 
 data_interfaces::IDataReader::Collection<data_model::SegmentDescriptor>
 JsonDataReader::AllSegments() const {
     // TODO: deserialize then return
+    return tl::make_unexpected("Not implemented");
 }
 
 std::string const& JsonDataReader::Identity() const {
diff --git a/libs/server-sdk/src/data_systems/background_sync/sources/streaming/streaming_data_source.cpp b/libs/server-sdk/src/data_systems/background_sync/sources/streaming/streaming_data_source.cpp
index efe93b7cc..7749135ba 100644
--- a/libs/server-sdk/src/data_systems/background_sync/sources/streaming/streaming_data_source.cpp
+++ b/libs/server-sdk/src/data_systems/background_sync/sources/streaming/streaming_data_source.cpp
@@ -34,10 +34,10 @@ std::string const& StreamingDataSource::Identity() const {
 }
 
 StreamingDataSource::StreamingDataSource(
-    config::shared::built::ServiceEndpoints const& endpoints,
-    config::shared::built::StreamingConfig<config::shared::ServerSDK> const&
+    config::built::ServiceEndpoints const& endpoints,
+    config::built::BackgroundSyncConfig::StreamingConfig const&
         data_source_config,
-    config::shared::built::HttpProperties http_properties,
+    config::built::HttpProperties http_properties,
     boost::asio::any_io_executor ioc,
     data_interfaces::IDestination& handler,
     data_components::DataSourceStatusManager& status_manager,
diff --git a/libs/server-sdk/src/data_systems/background_sync/sources/streaming/streaming_data_source.hpp b/libs/server-sdk/src/data_systems/background_sync/sources/streaming/streaming_data_source.hpp
index 1a455b66e..9c868fce0 100644
--- a/libs/server-sdk/src/data_systems/background_sync/sources/streaming/streaming_data_source.hpp
+++ b/libs/server-sdk/src/data_systems/background_sync/sources/streaming/streaming_data_source.hpp
@@ -6,12 +6,8 @@
 #include "../../../../data_interfaces/destination/idestination.hpp"
 #include "../../../../data_interfaces/source/idata_synchronizer.hpp"
 
-#include <launchdarkly/config/shared/built/data_source_config.hpp>
-#include <launchdarkly/config/shared/built/http_properties.hpp>
-#include <launchdarkly/config/shared/built/service_endpoints.hpp>
-#include <launchdarkly/config/shared/sdks.hpp>
-#include <launchdarkly/context.hpp>
-#include <launchdarkly/data/evaluation_result.hpp>
+#include <launchdarkly/server_side/config/built/all_built.hpp>
+
 #include <launchdarkly/logging/logger.hpp>
 #include <launchdarkly/sse/client.hpp>
 
@@ -28,10 +24,10 @@ class StreamingDataSource final
       public std::enable_shared_from_this<StreamingDataSource> {
    public:
     StreamingDataSource(
-        config::shared::built::ServiceEndpoints const& endpoints,
-        config::shared::built::StreamingConfig<config::shared::ServerSDK> const&
+        config::built::ServiceEndpoints const& endpoints,
+        config::built::BackgroundSyncConfig::StreamingConfig const&
             data_source_config,
-        config::shared::built::HttpProperties http_properties,
+        config::built::HttpProperties http_properties,
         boost::asio::any_io_executor ioc,
         data_interfaces::IDestination& handler,
         data_components::DataSourceStatusManager& status_manager,
@@ -49,10 +45,9 @@ class StreamingDataSource final
     DataSourceEventHandler data_source_handler_;
     std::string streaming_endpoint_;
 
-    config::shared::built::StreamingConfig<config::shared::ServerSDK>
-        streaming_config_;
+    config::built::BackgroundSyncConfig::StreamingConfig streaming_config_;
 
-    config::shared::built::HttpProperties http_config_;
+    config::built::HttpProperties http_config_;
 
     Logger const& logger_;
     std::shared_ptr<sse::Client> client_;
diff --git a/libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.cpp b/libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.cpp
index 89afdebd9..c9c833fde 100644
--- a/libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.cpp
+++ b/libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.cpp
@@ -3,8 +3,6 @@
 #include <launchdarkly/serialization/json_flag.hpp>
 #include <launchdarkly/serialization/json_segment.hpp>
 
-#include <launchdarkly/server_side/integrations/redis/redis_source.hpp>
-
 namespace launchdarkly::server_side::data_systems {
 
 using namespace config::shared::built;
diff --git a/libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.hpp b/libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.hpp
index 697b77b8e..98177eb29 100644
--- a/libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.hpp
+++ b/libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.hpp
@@ -3,7 +3,7 @@
 #include "../../data_components/expiration_tracker/expiration_tracker.hpp"
 #include "../../data_components/kinds/kinds.hpp"
 #include "../../data_components/memory_store/memory_store.hpp"
-#include "../../data_components/serialization_adapters/json_pull_source.hpp"
+#include "../../data_components/serialization_adapters/json_data_reader.hpp"
 #include "../../data_components/status_notifications/data_source_status_manager.hpp"
 #include "../../data_interfaces/system/idata_system.hpp"
 
@@ -11,8 +11,9 @@
 #include <launchdarkly/config/shared/built/http_properties.hpp>
 #include <launchdarkly/config/shared/built/service_endpoints.hpp>
 #include <launchdarkly/data_model/descriptors.hpp>
+#include <launchdarkly/detail/unreachable.hpp>
 #include <launchdarkly/logging/logger.hpp>
-#include <launchdarkly/server_side/integrations/serialized_descriptors.hpp>
+#include <launchdarkly/server_side/integrations/serialized_item_descriptor.hpp>
 
 #include <boost/asio/any_io_executor.hpp>
 
@@ -77,6 +78,7 @@ class LazyLoad : public data_interfaces::IDataSystem {
             case data_components::ExpirationTracker::TrackState::kFresh:
                 return get();
         }
+        detail::unreachable();
     }
 
     mutable data_components::MemoryStore cache_;
diff --git a/libs/server-sdk/tests/config_builder_test.cpp b/libs/server-sdk/tests/config_builder_test.cpp
index 5bee70e50..7df180139 100644
--- a/libs/server-sdk/tests/config_builder_test.cpp
+++ b/libs/server-sdk/tests/config_builder_test.cpp
@@ -3,8 +3,8 @@
 #include <launchdarkly/logging/null_logger.hpp>
 #include <launchdarkly/server_side/client.hpp>
 #include <launchdarkly/server_side/config/config_builder.hpp>
-#include <launchdarkly/server_side/integrations/redis/redis_source.hpp>
 
+#include "config/builders/data_system/defaults.hpp"
 #include "data_systems/background_sync/sources/streaming/streaming_data_source.hpp"
 
 using namespace launchdarkly;
@@ -41,19 +41,15 @@ TEST_F(ConfigBuilderTest, DefaultConstruction_StreamingDefaultsAreUsed) {
     auto const bg_sync_config =
         std::get<built::BackgroundSyncConfig>(cfg->DataSystemConfig().system_);
 
-    ASSERT_TRUE(std::holds_alternative<
-                ::launchdarkly::config::shared::built::StreamingConfig<
-                    launchdarkly::config::shared::ServerSDK>>(
-        bg_sync_config.synchronizer_));
+    ASSERT_TRUE(
+        std::holds_alternative<built::BackgroundSyncConfig::StreamingConfig>(
+            bg_sync_config.synchronizer_));
 
     auto const streaming_config =
-        std::get<::launchdarkly::config::shared::built::StreamingConfig<
-            launchdarkly::config::shared::ServerSDK>>(
+        std::get<built::BackgroundSyncConfig::StreamingConfig>(
             bg_sync_config.synchronizer_);
 
-    EXPECT_EQ(streaming_config,
-              ::launchdarkly::config::shared::Defaults<
-                  launchdarkly::config::shared::ServerSDK>::StreamingConfig());
+    EXPECT_EQ(streaming_config, Defaults::SynchronizerConfig());
 }
 
 TEST_F(ConfigBuilderTest, DefaultConstruction_HttpPropertyDefaultsAreUsed) {
diff --git a/libs/server-sdk/tests/server_c_bindings_test.cpp b/libs/server-sdk/tests/server_c_bindings_test.cpp
index 893956cb8..5a684fdf3 100644
--- a/libs/server-sdk/tests/server_c_bindings_test.cpp
+++ b/libs/server-sdk/tests/server_c_bindings_test.cpp
@@ -10,8 +10,6 @@
 
 #include <chrono>
 
-using launchdarkly::server_side::data_sources::DataSourceStatus;
-
 TEST(ClientBindings, MinimalInstantiation) {
     LDServerConfigBuilder cfg_builder = LDServerConfigBuilder_New("sdk-123");
 
@@ -97,6 +95,8 @@ TEST(ClientBindings, GetStatusOfOfflineClient) {
 }
 
 TEST(ClientBindings, ComplexDataSourceStatus) {
+    using namespace launchdarkly::server_side;
+
     DataSourceStatus status(
         DataSourceStatus::DataSourceState::kValid,
         std::chrono::time_point<std::chrono::system_clock>{