diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 6bc09a1..aeeb4aa 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -29,6 +29,7 @@
 #include <libfiemap/image_manager.h>
 #include <liblp/builder.h>
 #include <liblp/liblp.h>
+#include <update_engine/update_metadata.pb.h>
 
 #ifndef FRIEND_TEST
 #define FRIEND_TEST(test_set_name, individual_test) \
@@ -89,6 +90,7 @@
     using IPartitionOpener = android::fs_mgr::IPartitionOpener;
     using LpMetadata = android::fs_mgr::LpMetadata;
     using MetadataBuilder = android::fs_mgr::MetadataBuilder;
+    using DeltaArchiveManifest = chromeos_update_engine::DeltaArchiveManifest;
 
   public:
     // Dependency injection for testing.
@@ -98,6 +100,7 @@
         virtual std::string GetGsidDir() const = 0;
         virtual std::string GetMetadataDir() const = 0;
         virtual std::string GetSlotSuffix() const = 0;
+        virtual std::string GetOtherSlotSuffix() const = 0;
         virtual std::string GetSuperDevice(uint32_t slot) const = 0;
         virtual const IPartitionOpener& GetPartitionOpener() const = 0;
         virtual bool IsOverlayfsSetup() const = 0;
@@ -169,9 +172,7 @@
     // Create necessary COW device / files for OTA clients. New logical partitions will be added to
     // group "cow" in target_metadata. Regions of partitions of current_metadata will be
     // "write-protected" and snapshotted.
-    bool CreateUpdateSnapshots(MetadataBuilder* target_metadata, const std::string& target_suffix,
-                               MetadataBuilder* current_metadata, const std::string& current_suffix,
-                               const std::map<std::string, uint64_t>& cow_sizes);
+    bool CreateUpdateSnapshots(const DeltaArchiveManifest& manifest);
 
     // Map a snapshotted partition for OTA clients to write to. Write-protected regions are
     // determined previously in CreateSnapshots.
diff --git a/fs_mgr/libsnapshot/partition_cow_creator.cpp b/fs_mgr/libsnapshot/partition_cow_creator.cpp
index 3163e61..4250d23 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator.cpp
@@ -25,6 +25,9 @@
 using android::fs_mgr::Interval;
 using android::fs_mgr::kDefaultBlockSize;
 using android::fs_mgr::Partition;
+using chromeos_update_engine::InstallOperation;
+template <typename T>
+using RepeatedPtrField = google::protobuf::RepeatedPtrField<T>;
 
 namespace android {
 namespace snapshot {
@@ -117,9 +120,15 @@
     return snapshot_size;
 }
 
-std::optional<PartitionCowCreator::Return> PartitionCowCreator::Run() {
+std::optional<uint64_t> PartitionCowCreator::GetCowSize(uint64_t snapshot_size) {
+    // TODO: Use |operations|. to determine a minimum COW size.
+    // kCowEstimateFactor is good for prototyping but we can't use that in production.
     static constexpr double kCowEstimateFactor = 1.05;
+    auto cow_size = RoundUp(snapshot_size * kCowEstimateFactor, kDefaultBlockSize);
+    return cow_size;
+}
 
+std::optional<PartitionCowCreator::Return> PartitionCowCreator::Run() {
     CHECK(current_metadata->GetBlockDevicePartitionName(0) == LP_METADATA_DEFAULT_PARTITION_NAME &&
           target_metadata->GetBlockDevicePartitionName(0) == LP_METADATA_DEFAULT_PARTITION_NAME);
 
@@ -135,13 +144,8 @@
 
     ret.snapshot_status.snapshot_size = *snapshot_size;
 
-    // TODO: always read from cow_size when the COW size is written in
-    // update package. kCowEstimateFactor is good for prototyping but
-    // we can't use that in production.
-    if (!cow_size.has_value()) {
-        cow_size =
-                RoundUp(ret.snapshot_status.snapshot_size * kCowEstimateFactor, kDefaultBlockSize);
-    }
+    auto cow_size = GetCowSize(*snapshot_size);
+    if (!cow_size.has_value()) return std::nullopt;
 
     // Compute regions that are free in both current and target metadata. These are the regions
     // we can use for COW partition.
diff --git a/fs_mgr/libsnapshot/partition_cow_creator.h b/fs_mgr/libsnapshot/partition_cow_creator.h
index a235914..7c81418 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.h
+++ b/fs_mgr/libsnapshot/partition_cow_creator.h
@@ -32,20 +32,23 @@
     using Interval = android::fs_mgr::Interval;
     using MetadataBuilder = android::fs_mgr::MetadataBuilder;
     using Partition = android::fs_mgr::Partition;
+    using InstallOperation = chromeos_update_engine::InstallOperation;
+    template <typename T>
+    using RepeatedPtrField = google::protobuf::RepeatedPtrField<T>;
 
     // The metadata that will be written to target metadata slot.
-    MetadataBuilder* target_metadata;
+    MetadataBuilder* target_metadata = nullptr;
     // The suffix of the target slot.
     std::string target_suffix;
     // The partition in target_metadata that needs to be snapshotted.
-    Partition* target_partition;
+    Partition* target_partition = nullptr;
     // The metadata at the current slot (that would be used if the device boots
     // normally). This is used to determine which extents are being used.
-    MetadataBuilder* current_metadata;
+    MetadataBuilder* current_metadata = nullptr;
     // The suffix of the current slot.
     std::string current_suffix;
-    // The COW size given by client code.
-    std::optional<uint64_t> cow_size;
+    // List of operations to be applied on the partition.
+    const RepeatedPtrField<InstallOperation>* operations = nullptr;
 
     struct Return {
         SnapshotManager::SnapshotStatus snapshot_status;
@@ -57,6 +60,7 @@
   private:
     bool HasExtent(Partition* p, Extent* e);
     std::optional<uint64_t> GetSnapshotSize();
+    std::optional<uint64_t> GetCowSize(uint64_t snapshot_size);
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
index e308943..29d15af 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
@@ -76,14 +76,11 @@
                                 .target_suffix = "_b",
                                 .target_partition = system_b,
                                 .current_metadata = builder_a.get(),
-                                .current_suffix = "_a",
-                                .cow_size = 20 * 1024};
+                                .current_suffix = "_a"};
     auto ret = creator.Run();
     ASSERT_TRUE(ret.has_value());
     ASSERT_EQ(40 * 1024, ret->snapshot_status.device_size);
     ASSERT_EQ(40 * 1024, ret->snapshot_status.snapshot_size);
-    ASSERT_EQ(20 * 1024,
-              ret->snapshot_status.cow_file_size + ret->snapshot_status.cow_partition_size);
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 15d52f1..b5b3af3 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -39,6 +39,7 @@
 #include <liblp/liblp.h>
 
 #include "partition_cow_creator.h"
+#include "snapshot_metadata_updater.h"
 #include "utility.h"
 
 namespace android {
@@ -61,6 +62,10 @@
 using android::fs_mgr::LpMetadata;
 using android::fs_mgr::MetadataBuilder;
 using android::fs_mgr::SlotNumberForSlotSuffix;
+using chromeos_update_engine::DeltaArchiveManifest;
+using chromeos_update_engine::InstallOperation;
+template <typename T>
+using RepeatedPtrField = google::protobuf::RepeatedPtrField<T>;
 using std::chrono::duration_cast;
 using namespace std::chrono_literals;
 using namespace std::string_literals;
@@ -74,6 +79,7 @@
     std::string GetGsidDir() const override { return "ota"s; }
     std::string GetMetadataDir() const override { return "/metadata/ota"s; }
     std::string GetSlotSuffix() const override { return fs_mgr_get_slot_suffix(); }
+    std::string GetOtherSlotSuffix() const override { return fs_mgr_get_other_slot_suffix(); }
     const android::fs_mgr::IPartitionOpener& GetPartitionOpener() const { return opener_; }
     std::string GetSuperDevice(uint32_t slot) const override {
         return fs_mgr_get_super_partition_name(slot);
@@ -1713,26 +1719,44 @@
     return true;
 }
 
-bool SnapshotManager::CreateUpdateSnapshots(MetadataBuilder* target_metadata,
-                                            const std::string& target_suffix,
-                                            MetadataBuilder* current_metadata,
-                                            const std::string& current_suffix,
-                                            const std::map<std::string, uint64_t>& cow_sizes) {
+bool SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manifest) {
     auto lock = LockExclusive();
     if (!lock) return false;
 
-    // Add _{target_suffix} to COW size map.
-    std::map<std::string, uint64_t> suffixed_cow_sizes;
-    for (const auto& [name, size] : cow_sizes) {
-        suffixed_cow_sizes[name + target_suffix] = size;
+    const auto& opener = device_->GetPartitionOpener();
+    auto current_suffix = device_->GetSlotSuffix();
+    uint32_t current_slot = SlotNumberForSlotSuffix(current_suffix);
+    auto target_suffix = device_->GetOtherSlotSuffix();
+    uint32_t target_slot = SlotNumberForSlotSuffix(target_suffix);
+    auto current_super = device_->GetSuperDevice(current_slot);
+
+    auto current_metadata = MetadataBuilder::New(opener, current_super, current_slot);
+    auto target_metadata =
+            MetadataBuilder::NewForUpdate(opener, current_super, current_slot, target_slot);
+
+    SnapshotMetadataUpdater metadata_updater(target_metadata.get(), target_slot, manifest);
+    if (!metadata_updater.Update()) {
+        LOG(ERROR) << "Cannot calculate new metadata.";
+        return false;
     }
 
-    target_metadata->RemoveGroupAndPartitions(kCowGroupName);
     if (!target_metadata->AddGroup(kCowGroupName, 0)) {
         LOG(ERROR) << "Cannot add group " << kCowGroupName;
         return false;
     }
 
+    std::map<std::string, const RepeatedPtrField<InstallOperation>*> install_operation_map;
+    for (const auto& partition_update : manifest.partitions()) {
+        auto suffixed_name = partition_update.partition_name() + target_suffix;
+        auto&& [it, inserted] = install_operation_map.emplace(std::move(suffixed_name),
+                                                              &partition_update.operations());
+        if (!inserted) {
+            LOG(ERROR) << "Duplicated partition " << partition_update.partition_name()
+                       << " in update manifest.";
+            return false;
+        }
+    }
+
     // TODO(b/134949511): remove this check. Right now, with overlayfs mounted, the scratch
     // partition takes up a big chunk of space in super, causing COW images to be created on
     // retrofit Virtual A/B devices.
@@ -1757,18 +1781,16 @@
     // these devices.
     AutoDeviceList created_devices;
 
-    for (auto* target_partition : ListPartitionsWithSuffix(target_metadata, target_suffix)) {
-        std::optional<uint64_t> cow_size = std::nullopt;
-        auto it = suffixed_cow_sizes.find(target_partition->name());
-        if (it != suffixed_cow_sizes.end()) {
-            cow_size = it->second;
-            LOG(INFO) << "Using provided COW size " << *cow_size << " for partition "
-                      << target_partition->name();
+    for (auto* target_partition : ListPartitionsWithSuffix(target_metadata.get(), target_suffix)) {
+        const RepeatedPtrField<InstallOperation>* operations = nullptr;
+        auto operations_it = install_operation_map.find(target_partition->name());
+        if (operations_it != install_operation_map.end()) {
+            operations = operations_it->second;
         }
 
         // Compute the device sizes for the partition.
-        PartitionCowCreator cow_creator{target_metadata,  target_suffix,  target_partition,
-                                        current_metadata, current_suffix, cow_size};
+        PartitionCowCreator cow_creator{target_metadata.get(),  target_suffix,  target_partition,
+                                        current_metadata.get(), current_suffix, operations};
         auto cow_creator_ret = cow_creator.Run();
         if (!cow_creator_ret.has_value()) {
             return false;
@@ -1846,13 +1868,17 @@
 
     auto& dm = DeviceMapper::Instance();
     auto exported_target_metadata = target_metadata->Export();
+    if (exported_target_metadata == nullptr) {
+        LOG(ERROR) << "Cannot export target metadata";
+        return false;
+    }
     CreateLogicalPartitionParams cow_params{
             .block_device = LP_METADATA_DEFAULT_PARTITION_NAME,
             .metadata = exported_target_metadata.get(),
             .timeout_ms = std::chrono::milliseconds::max(),
             .partition_opener = &device_->GetPartitionOpener(),
     };
-    for (auto* target_partition : ListPartitionsWithSuffix(target_metadata, target_suffix)) {
+    for (auto* target_partition : ListPartitionsWithSuffix(target_metadata.get(), target_suffix)) {
         AutoDeviceList created_devices_for_cow;
 
         if (!UnmapPartitionWithSnapshot(lock.get(), target_partition->name())) {
@@ -1884,6 +1910,12 @@
         // Let destructor of created_devices_for_cow to unmap the COW devices.
     };
 
+    if (!UpdatePartitionTable(opener, device_->GetSuperDevice(target_slot),
+                              *exported_target_metadata, target_slot)) {
+        LOG(ERROR) << "Cannot write target metadata";
+        return false;
+    }
+
     created_devices.Release();
     LOG(INFO) << "Successfully created all snapshots for target slot " << target_suffix;
 
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index e9835d0..36982a9 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -50,6 +50,8 @@
 using android::fs_mgr::GetPartitionGroupName;
 using android::fs_mgr::GetPartitionName;
 using android::fs_mgr::MetadataBuilder;
+using chromeos_update_engine::DeltaArchiveManifest;
+using chromeos_update_engine::PartitionUpdate;
 using namespace ::testing;
 using namespace android::fs_mgr::testing;
 using namespace android::storage_literals;
@@ -62,7 +64,8 @@
 TestDeviceInfo* test_device = nullptr;
 std::string fake_super;
 
-static constexpr uint64_t kSuperSize = 16_MiB;
+static constexpr uint64_t kSuperSize = 16_MiB + 4_KiB;
+static constexpr uint64_t kGroupSize = 16_MiB;
 
 class SnapshotTest : public ::testing::Test {
   public:
@@ -636,28 +639,39 @@
         ON_CALL(*GetMockedPropertyFetcher(), GetBoolProperty("ro.virtual_ab.enabled", _))
                 .WillByDefault(Return(true));
 
-        opener = std::make_unique<TestPartitionOpener>(fake_super);
+        opener_ = std::make_unique<TestPartitionOpener>(fake_super);
 
-        // Initialize source partition metadata. sys_b is similar to system_other.
+        // Create a fake update package metadata.
         // Not using full name "system", "vendor", "product" because these names collide with the
         // mapped partitions on the running device.
-        src = MetadataBuilder::New(*opener, "super", 0);
-        ASSERT_NE(nullptr, src);
-        auto partition = src->AddPartition("sys_a", 0);
+        // Each test modifies manifest_ slightly to indicate changes to the partition layout.
+        auto group = manifest_.mutable_dynamic_partition_metadata()->add_groups();
+        group->set_name("group");
+        group->set_size(kGroupSize);
+        group->add_partition_names("sys");
+        group->add_partition_names("vnd");
+        group->add_partition_names("prd");
+        sys_ = manifest_.add_partitions();
+        sys_->set_partition_name("sys");
+        SetSize(sys_, 3_MiB);
+        vnd_ = manifest_.add_partitions();
+        vnd_->set_partition_name("vnd");
+        SetSize(vnd_, 3_MiB);
+        prd_ = manifest_.add_partitions();
+        prd_->set_partition_name("prd");
+        SetSize(prd_, 3_MiB);
+
+        // Initialize source partition metadata using |manifest_|.
+        src_ = MetadataBuilder::New(*opener_, "super", 0);
+        ASSERT_TRUE(FillFakeMetadata(src_.get(), manifest_, "_a"));
+        ASSERT_NE(nullptr, src_);
+        // Add sys_b which is like system_other.
+        auto partition = src_->AddPartition("sys_b", 0);
         ASSERT_NE(nullptr, partition);
-        ASSERT_TRUE(src->ResizePartition(partition, 3_MiB));
-        partition = src->AddPartition("vnd_a", 0);
-        ASSERT_NE(nullptr, partition);
-        ASSERT_TRUE(src->ResizePartition(partition, 3_MiB));
-        partition = src->AddPartition("prd_a", 0);
-        ASSERT_NE(nullptr, partition);
-        ASSERT_TRUE(src->ResizePartition(partition, 3_MiB));
-        partition = src->AddPartition("sys_b", 0);
-        ASSERT_NE(nullptr, partition);
-        ASSERT_TRUE(src->ResizePartition(partition, 1_MiB));
-        auto metadata = src->Export();
+        ASSERT_TRUE(src_->ResizePartition(partition, 1_MiB));
+        auto metadata = src_->Export();
         ASSERT_NE(nullptr, metadata);
-        ASSERT_TRUE(UpdatePartitionTable(*opener, "super", *metadata.get(), 0));
+        ASSERT_TRUE(UpdatePartitionTable(*opener_, "super", *metadata.get(), 0));
 
         // Map source partitions. Additionally, map sys_b to simulate system_other after flashing.
         std::string path;
@@ -668,7 +682,7 @@
                             .metadata_slot = 0,
                             .partition_name = name,
                             .timeout_ms = 1s,
-                            .partition_opener = opener.get(),
+                            .partition_opener = opener_.get(),
                     },
                     &path));
             ASSERT_TRUE(WriteRandomData(path));
@@ -692,22 +706,6 @@
         EXPECT_TRUE(UnmapAll());
     }
 
-    static AssertionResult ResizePartitions(
-            MetadataBuilder* builder,
-            const std::vector<std::pair<std::string, uint64_t>>& partition_sizes) {
-        for (auto&& [name, size] : partition_sizes) {
-            auto partition = builder->FindPartition(name);
-            if (!partition) {
-                return AssertionFailure() << "Cannot find partition in metadata " << name;
-            }
-            if (!builder->ResizePartition(partition, size)) {
-                return AssertionFailure()
-                       << "Cannot resize partition " << name << " to " << size << " bytes";
-            }
-        }
-        return AssertionSuccess();
-    }
-
     AssertionResult IsPartitionUnchanged(const std::string& name) {
         std::string path;
         if (!dm_.GetDmDevicePathByName(name, &path)) {
@@ -748,9 +746,14 @@
         return AssertionSuccess();
     }
 
-    std::unique_ptr<TestPartitionOpener> opener;
-    std::unique_ptr<MetadataBuilder> src;
+    std::unique_ptr<TestPartitionOpener> opener_;
+    DeltaArchiveManifest manifest_;
+    std::unique_ptr<MetadataBuilder> src_;
     std::map<std::string, std::string> hashes_;
+
+    PartitionUpdate* sys_ = nullptr;
+    PartitionUpdate* vnd_ = nullptr;
+    PartitionUpdate* prd_ = nullptr;
 };
 
 // Test full update flow executed by update_engine. Some partitions uses super empty space,
@@ -767,29 +770,19 @@
         ASSERT_TRUE(sm->UnmapUpdateSnapshot(name));
     }
 
-    // OTA client adjusts the partition sizes before giving it to CreateUpdateSnapshots.
-    auto tgt = MetadataBuilder::NewForUpdate(*opener, "super", 0, 1);
-    ASSERT_NE(nullptr, tgt);
-    // clang-format off
-    ASSERT_TRUE(ResizePartitions(tgt.get(), {
-            {"sys_b", 4_MiB}, // grows
-            {"vnd_b", 4_MiB}, // grows
-            {"prd_b", 4_MiB}, // grows
-    }));
-    // clang-format on
+    // Grow all partitions.
+    SetSize(sys_, 4_MiB);
+    SetSize(vnd_, 4_MiB);
+    SetSize(prd_, 4_MiB);
 
-    ASSERT_TRUE(sm->CreateUpdateSnapshots(tgt.get(), "_b", src.get(), "_a", {}));
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
 
     // Test that partitions prioritize using space in super.
+    auto tgt = MetadataBuilder::New(*opener_, "super", 1);
     ASSERT_NE(nullptr, tgt->FindPartition("sys_b-cow"));
     ASSERT_NE(nullptr, tgt->FindPartition("vnd_b-cow"));
     ASSERT_EQ(nullptr, tgt->FindPartition("prd_b-cow"));
 
-    // The metadata slot 1 is now updated.
-    auto metadata = tgt->Export();
-    ASSERT_NE(nullptr, metadata);
-    ASSERT_TRUE(UpdatePartitionTable(*opener, "super", *metadata.get(), 1));
-
     // Write some data to target partitions.
     for (const auto& name : {"sys_b", "vnd_b", "prd_b"}) {
         std::string path;
@@ -799,7 +792,7 @@
                         .metadata_slot = 1,
                         .partition_name = name,
                         .timeout_ms = 10s,
-                        .partition_opener = opener.get(),
+                        .partition_opener = opener_.get(),
                 },
                 &path))
                 << name;
@@ -845,49 +838,31 @@
 
 // Test that if new system partitions uses empty space in super, that region is not snapshotted.
 TEST_F(SnapshotUpdateTest, DirectWriteEmptySpace) {
-    auto tgt = MetadataBuilder::NewForUpdate(*opener, "super", 0, 1);
-    ASSERT_NE(nullptr, tgt);
-    // clang-format off
-    ASSERT_TRUE(ResizePartitions(tgt.get(), {
-            {"sys_b", 4_MiB}, // grows
-            // vnd_b and prd_b are unchanged
-    }));
-    // clang-format on
-    ASSERT_TRUE(sm->CreateUpdateSnapshots(tgt.get(), "_b", src.get(), "_a", {}));
-
+    SetSize(sys_, 4_MiB);
+    // vnd_b and prd_b are unchanged.
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
     ASSERT_EQ(3_MiB, GetSnapshotSize("sys_b").value_or(0));
 }
 
 // Test that if new system partitions uses space of old vendor partition, that region is
 // snapshotted.
 TEST_F(SnapshotUpdateTest, SnapshotOldPartitions) {
-    auto tgt = MetadataBuilder::NewForUpdate(*opener, "super", 0, 1);
-    ASSERT_NE(nullptr, tgt);
-    // clang-format off
-    ASSERT_TRUE(ResizePartitions(tgt.get(), {
-            {"vnd_b", 2_MiB}, // shrinks
-            {"sys_b", 4_MiB}, // grows
-            // prd_b is unchanged
-    }));
-    // clang-format on
-    ASSERT_TRUE(sm->CreateUpdateSnapshots(tgt.get(), "_b", src.get(), "_a", {}));
-
+    SetSize(sys_, 4_MiB);  // grows
+    SetSize(vnd_, 2_MiB);  // shrinks
+    // prd_b is unchanged
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
     ASSERT_EQ(4_MiB, GetSnapshotSize("sys_b").value_or(0));
 }
 
 // Test that even if there seem to be empty space in target metadata, COW partition won't take
 // it because they are used by old partitions.
 TEST_F(SnapshotUpdateTest, CowPartitionDoNotTakeOldPartitions) {
-    auto tgt = MetadataBuilder::NewForUpdate(*opener, "super", 0, 1);
-    ASSERT_NE(nullptr, tgt);
-    // clang-format off
-    ASSERT_TRUE(ResizePartitions(tgt.get(), {
-            {"sys_b", 2_MiB}, // shrinks
-            // vnd_b and prd_b are unchanged
-    }));
-    // clang-format on
-    ASSERT_TRUE(sm->CreateUpdateSnapshots(tgt.get(), "_b", src.get(), "_a", {}));
+    SetSize(sys_, 2_MiB);  // shrinks
+    // vnd_b and prd_b are unchanged.
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
 
+    auto tgt = MetadataBuilder::New(*opener_, "super", 1);
+    ASSERT_NE(nullptr, tgt);
     auto metadata = tgt->Export();
     ASSERT_NE(nullptr, metadata);
     std::vector<std::string> written;
@@ -903,7 +878,7 @@
                         .metadata = metadata.get(),
                         .partition = &p,
                         .timeout_ms = 1s,
-                        .partition_opener = opener.get(),
+                        .partition_opener = opener_.get(),
                 },
                 &path));
         ASSERT_TRUE(WriteRandomData(path));
@@ -934,14 +909,8 @@
     // Redo the update.
     ASSERT_TRUE(sm->BeginUpdate());
     ASSERT_TRUE(sm->UnmapUpdateSnapshot("sys_b"));
-    auto tgt = MetadataBuilder::NewForUpdate(*opener, "super", 0, 1);
-    ASSERT_NE(nullptr, tgt);
-    ASSERT_TRUE(sm->CreateUpdateSnapshots(tgt.get(), "_b", src.get(), "_a", {}));
 
-    // The metadata slot 1 is now updated.
-    auto metadata = tgt->Export();
-    ASSERT_NE(nullptr, metadata);
-    ASSERT_TRUE(UpdatePartitionTable(*opener, "super", *metadata.get(), 1));
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
 
     // Check that target partitions can be mapped.
     for (const auto& name : {"sys_b", "vnd_b", "prd_b"}) {
@@ -952,7 +921,7 @@
                         .metadata_slot = 1,
                         .partition_name = name,
                         .timeout_ms = 10s,
-                        .partition_opener = opener.get(),
+                        .partition_opener = opener_.get(),
                 },
                 &path))
                 << name;
@@ -964,14 +933,8 @@
     // Execute the update.
     ASSERT_TRUE(sm->BeginUpdate());
     ASSERT_TRUE(sm->UnmapUpdateSnapshot("sys_b"));
-    auto tgt = MetadataBuilder::NewForUpdate(*opener, "super", 0, 1);
-    ASSERT_NE(nullptr, tgt);
-    ASSERT_TRUE(sm->CreateUpdateSnapshots(tgt.get(), "_b", src.get(), "_a", {}));
 
-    // The metadata slot 1 is now updated.
-    auto metadata = tgt->Export();
-    ASSERT_NE(nullptr, metadata);
-    ASSERT_TRUE(UpdatePartitionTable(*opener, "super", *metadata.get(), 1));
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
 
     // Write some data to target partitions.
     for (const auto& name : {"sys_b", "vnd_b", "prd_b"}) {
@@ -982,7 +945,7 @@
                         .metadata_slot = 1,
                         .partition_name = name,
                         .timeout_ms = 10s,
-                        .partition_opener = opener.get(),
+                        .partition_opener = opener_.get(),
                 },
                 &path))
                 << name;
diff --git a/fs_mgr/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/test_helpers.h
index 9d8c7b0..0303a14 100644
--- a/fs_mgr/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/test_helpers.h
@@ -55,6 +55,7 @@
     std::string GetGsidDir() const override { return "ota/test"s; }
     std::string GetMetadataDir() const override { return "/metadata/ota/test"s; }
     std::string GetSlotSuffix() const override { return slot_suffix_; }
+    std::string GetOtherSlotSuffix() const override { return slot_suffix_ == "_a" ? "_b" : "_a"; }
     std::string GetSuperDevice([[maybe_unused]] uint32_t slot) const override { return "super"; }
     const android::fs_mgr::IPartitionOpener& GetPartitionOpener() const override {
         return *opener_.get();