diff --git a/system/ulib/blobfs/blobfs.cpp b/system/ulib/blobfs/blobfs.cpp
index 8676905..ed8ed13 100644
--- a/system/ulib/blobfs/blobfs.cpp
+++ b/system/ulib/blobfs/blobfs.cpp
@@ -16,6 +16,7 @@
 #include <blobfs/extent-reserver.h>
 #include <blobfs/lz4.h>
 #include <blobfs/node-reserver.h>
+#include <blobfs/writeback.h>
 #include <cobalt-client/cpp/collector.h>
 #include <digest/digest.h>
 #include <digest/merkle-tree.h>
diff --git a/system/ulib/blobfs/include/blobfs/blob.h b/system/ulib/blobfs/include/blobfs/blob.h
index 83c0765..c1f60ac 100644
--- a/system/ulib/blobfs/include/blobfs/blob.h
+++ b/system/ulib/blobfs/include/blobfs/blob.h
@@ -22,6 +22,7 @@
 #include <fs/vfs.h>
 #include <fs/vnode.h>
 #include <fuchsia/io/c/fidl.h>
+#include <lib/async/cpp/wait.h>
 #include <lib/fzl/owned-vmo-mapper.h>
 #include <lib/zx/event.h>
 
diff --git a/system/ulib/blobfs/include/blobfs/blobfs.h b/system/ulib/blobfs/include/blobfs/blobfs.h
index f90879a..5246c08 100644
--- a/system/ulib/blobfs/include/blobfs/blobfs.h
+++ b/system/ulib/blobfs/include/blobfs/blobfs.h
@@ -58,19 +58,8 @@
 
 namespace blobfs {
 
-class Blobfs;
-class Journal;
-class Blob;
-class WritebackQueue;
-class WritebackWork;
-
 using digest::Digest;
 
-enum class EnqueueType {
-    kJournal,
-    kData,
-};
-
 // Toggles that may be set on blobfs during initialization.
 struct MountOptions {
     bool readonly = false;
@@ -81,8 +70,7 @@
 
 class Blobfs : public fs::ManagedVfs,
                public fbl::RefCounted<Blobfs>,
-               public fs::TransactionHandler,
-               public SpaceManager {
+               public TransactionManager {
 public:
     DISALLOW_COPY_ASSIGN_AND_MOVE(Blobfs);
 
@@ -92,7 +80,9 @@
     void Shutdown(fs::Vfs::ShutdownCallback closure) final;
 
     ////////////////
-    // fs::TransactionHandler interface.
+    // TransactionManager's fs::TransactionHandler interface.
+    //
+    // Allows transmitting read and write transactions directly to the underlying storage.
 
     uint32_t FsBlockSize() const final { return kBlobfsBlockSize; }
 
@@ -110,14 +100,29 @@
     }
 
     ////////////////
-    // SpaceManager interface.
+    // TransactionManager's SpaceManager interface.
+    //
+    // Allows viewing and controlling the size of the underlying volume.
 
+    const Superblock& Info() const final { return info_; }
     zx_status_t AttachVmo(const zx::vmo& vmo, vmoid_t* out) final;
     zx_status_t DetachVmo(vmoid_t vmoid) final;
     zx_status_t AddInodes(fzl::ResizeableVmoMapper* node_map) final;
     zx_status_t AddBlocks(size_t nblocks, RawBitmap* block_map) final;
 
     ////////////////
+    // TransactionManager interface.
+    //
+    // Allows attaching VMOs, controlling the underlying volume, and sending transactions to the
+    // underlying storage (optionally through the journal).
+
+    BlobfsMetrics& LocalMetrics() final {
+        return metrics_;
+    }
+    zx_status_t CreateWork(fbl::unique_ptr<WritebackWork>* out, Blob* vnode) final;
+    zx_status_t EnqueueWork(fbl::unique_ptr<WritebackWork> work, EnqueueType type) final;
+
+    ////////////////
     // Other methods.
 
     uint64_t DataStart() const { return DataStartBlock(info_); }
@@ -143,10 +148,6 @@
     static zx_status_t Create(fbl::unique_fd blockfd, const MountOptions& options,
                               const Superblock* info, fbl::unique_ptr<Blobfs>* out);
 
-    BlobfsMetrics& LocalMetrics() {
-        return metrics_;
-    }
-
     void CollectMetrics() {
         collecting_metrics_ = true;
         cobalt_metrics_.EnableMetrics(true);
@@ -186,22 +187,12 @@
 
     int Fd() const { return blockfd_.get(); }
 
-    const Superblock& Info() const { return info_; }
-
     // Returns an unique identifier for this instance.
     uint64_t GetFsId() const { return fs_id_; }
 
     using SyncCallback = fs::Vnode::SyncCallback;
     void Sync(SyncCallback closure);
 
-    zx_status_t CreateWork(fbl::unique_ptr<WritebackWork>* out, Blob* vnode);
-
-    // Enqueues |work| to the appropriate buffer. If |journal| is true and the journal is enabled,
-    // the transaction(s) will first be written to the journal. Otherwise, they will be sent
-    // straight to the writeback buffer.
-    zx_status_t EnqueueWork(fbl::unique_ptr<WritebackWork> work,
-                            EnqueueType type) __WARN_UNUSED_RESULT;
-
     // Frees an inode, from both the reserved map and the inode table. If the
     // inode was allocated in the inode table, write the deleted inode out to
     // disk.
diff --git a/system/ulib/blobfs/include/blobfs/journal.h b/system/ulib/blobfs/include/blobfs/journal.h
index 68d5a25..021fe6e 100644
--- a/system/ulib/blobfs/include/blobfs/journal.h
+++ b/system/ulib/blobfs/include/blobfs/journal.h
@@ -8,17 +8,22 @@
 static_assert(false, "Fuchsia only header");
 #endif
 
-#include <zircon/types.h>
-
-#include <stdint.h>
-
-#include <blobfs/format.h>
-#include <blobfs/writeback.h>
-
 #include <atomic>
 #include <utility>
 
+#include <stdint.h>
+
+#include <blobfs/blob.h>
+#include <blobfs/format.h>
+#include <blobfs/transaction-manager.h>
+#include <blobfs/writeback.h>
+#include <fbl/intrusive_single_list.h>
+#include <fbl/mutex.h>
+#include <fbl/unique_ptr.h>
+#include <zircon/types.h>
+
 namespace blobfs {
+
 class JournalBase;
 class JournalProcessor;
 
@@ -209,8 +214,8 @@
     DISALLOW_COPY_ASSIGN_AND_MOVE(Journal);
 
     // Calls constructor, return an error if anything goes wrong.
-    static zx_status_t Create(Blobfs* bs, uint64_t block_count, uint64_t start_block,
-                              fbl::unique_ptr<Journal>* out);
+    static zx_status_t Create(TransactionManager* transaction_manager, uint64_t block_count,
+                              uint64_t start_block, fbl::unique_ptr<Journal>* out);
 
     ~Journal();
 
@@ -270,9 +275,9 @@
     struct Waiter : public fbl::SinglyLinkedListable<Waiter*> {};
     using ProducerQueue = fs::Queue<Waiter*>;
 
-    Journal(Blobfs* blobfs, fbl::unique_ptr<Buffer> info, fbl::unique_ptr<Buffer> entries,
-            uint64_t start_block)
-        : blobfs_(blobfs), start_block_(start_block),
+    Journal(TransactionManager* transaction_manager, fbl::unique_ptr<Buffer> info,
+            fbl::unique_ptr<Buffer> entries, uint64_t start_block)
+        : transaction_manager_(transaction_manager), start_block_(start_block),
           info_(std::move(info)), entries_(std::move(entries)) {}
 
     bool IsRunning() const __TA_REQUIRES(lock_);
@@ -344,7 +349,7 @@
     // Processes entries in the work queue and the processor queues.
     void ProcessQueues(JournalProcessor* processor) __TA_EXCLUDES(lock_);
 
-    Blobfs* blobfs_;
+    TransactionManager* transaction_manager_;
 
     // The absolute start block of the journal on disk. Used for transactions.
     uint64_t start_block_;
diff --git a/system/ulib/blobfs/include/blobfs/transaction-manager.h b/system/ulib/blobfs/include/blobfs/transaction-manager.h
new file mode 100644
index 0000000..0dc61cf
--- /dev/null
+++ b/system/ulib/blobfs/include/blobfs/transaction-manager.h
@@ -0,0 +1,46 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#ifndef __Fuchsia__
+#error Fuchsia-only Header
+#endif
+
+#include <blobfs/allocator.h>
+#include <blobfs/blob.h>
+#include <blobfs/metrics.h>
+#include <fbl/unique_ptr.h>
+#include <fs/block-txn.h>
+#include <fs/vnode.h>
+
+namespace blobfs {
+
+class WritebackWork;
+
+// EnqueueType describes the classes of data which may be enqueued to the
+// underlying storage medium.
+enum class EnqueueType {
+    kJournal,
+    kData,
+};
+
+// An interface which controls access to the underlying storage.
+class TransactionManager : public fs::TransactionHandler,
+                           public SpaceManager {
+public:
+    virtual ~TransactionManager() = default;
+    virtual BlobfsMetrics& LocalMetrics() = 0;
+
+    virtual zx_status_t CreateWork(fbl::unique_ptr<WritebackWork>* out, Blob* vnode) = 0;
+
+    // Enqueues |work| to the appropriate buffer.
+    // If the data is journaled, |work| will be transmitted to the journal, where it will be
+    // persisted only after consistency is ensured.
+    // If the data is not journaled, |work| will be transmitted directly to the writeback buffer /
+    // persistent storage.
+    virtual zx_status_t EnqueueWork(fbl::unique_ptr<WritebackWork> work, EnqueueType type) = 0;
+};
+
+} // namespace blobfs
diff --git a/system/ulib/blobfs/include/blobfs/writeback.h b/system/ulib/blobfs/include/blobfs/writeback.h
index d1f1feb..c0bef26 100644
--- a/system/ulib/blobfs/include/blobfs/writeback.h
+++ b/system/ulib/blobfs/include/blobfs/writeback.h
@@ -8,6 +8,13 @@
 #error Fuchsia-only Header
 #endif
 
+#include <utility>
+
+#include <blobfs/allocator.h>
+#include <blobfs/blob.h>
+#include <blobfs/format.h>
+#include <blobfs/metrics.h>
+#include <blobfs/transaction-manager.h>
 #include <fbl/algorithm.h>
 #include <fbl/auto_lock.h>
 #include <fbl/intrusive_hash_table.h>
@@ -17,26 +24,16 @@
 #include <fbl/ref_ptr.h>
 #include <fbl/unique_ptr.h>
 #include <fbl/vector.h>
-
 #include <fs/block-txn.h>
 #include <fs/queue.h>
 #include <fs/vfs.h>
-
+#include <fs/vnode.h>
 #include <lib/sync/completion.h>
-
 #include <lib/fzl/owned-vmo-mapper.h>
 #include <lib/zx/vmo.h>
 
-#include <blobfs/blobfs.h>
-#include <blobfs/format.h>
-
-#include <utility>
-
 namespace blobfs {
 
-class Blobfs;
-class Blob;
-
 struct WriteRequest {
     zx_handle_t vmo;
     size_t vmo_offset;
@@ -58,7 +55,8 @@
 public:
     DISALLOW_COPY_ASSIGN_AND_MOVE(WriteTxn);
 
-    explicit WriteTxn(Blobfs* bs) : bs_(bs), vmoid_(VMOID_INVALID), block_count_(0) {}
+    explicit WriteTxn(TransactionManager* transaction_manager)
+        : transaction_manager_(transaction_manager), vmoid_(VMOID_INVALID), block_count_(0) {}
 
     virtual ~WriteTxn();
 
@@ -101,13 +99,12 @@
     zx_status_t Flush();
 
 private:
-    Blobfs* bs_;
+    TransactionManager* transaction_manager_;
     vmoid_t vmoid_;
     fbl::Vector<WriteRequest> requests_;
     size_t block_count_;
 };
 
-
 // A wrapper around a WriteTxn, holding references to the underlying Vnodes
 // corresponding to the txn, so their Vnodes (and VMOs) are not released
 // while being written out to disk.
@@ -122,7 +119,7 @@
 
     // Create a WritebackWork given a vnode (which may be null)
     // Vnode is stored for duration of txn so that it isn't destroyed during the write process
-    WritebackWork(Blobfs* bs, fbl::RefPtr<Blob> vnode);
+    WritebackWork(TransactionManager* transaction_manager, fbl::RefPtr<Blob> vnode);
     ~WritebackWork() = default;
 
     // Sets the WritebackWork to a completed state. |status| should indicate whether the work was
@@ -178,8 +175,8 @@
     ~Buffer();
 
     // Initializes the buffer VMO with |blocks| blocks of size kBlobfsBlockSize.
-    static zx_status_t Create(Blobfs* blobfs, const size_t blocks, const char* label,
-                              fbl::unique_ptr<Buffer>* out);
+    static zx_status_t Create(TransactionManager* transaction_manager, const size_t blocks,
+                              const char* label, fbl::unique_ptr<Buffer>* out);
 
     // Adds a transaction to |txn| which reads all data into buffer
     // starting from |disk_start| on disk.
@@ -233,11 +230,11 @@
         return reinterpret_cast<char*>(mapper_.start()) + (index * kBlobfsBlockSize);
     }
 private:
-    Buffer(Blobfs* blobfs, fzl::OwnedVmoMapper mapper)
-        : blobfs_(blobfs), mapper_(std::move(mapper)), start_(0), length_(0),
-          capacity_(mapper_.size() / kBlobfsBlockSize) {}
+    Buffer(TransactionManager* transaction_manager, fzl::OwnedVmoMapper mapper)
+        : transaction_manager_(transaction_manager), mapper_(std::move(mapper)), start_(0),
+          length_(0), capacity_(mapper_.size() / kBlobfsBlockSize) {}
 
-    Blobfs* blobfs_;
+    TransactionManager* transaction_manager_;
     fzl::OwnedVmoMapper mapper_;
     vmoid_t vmoid_ = VMOID_INVALID;
 
@@ -257,7 +254,7 @@
 
     // Initializes the WritebackBuffer at |out|
     // with a buffer of |buffer_blocks| blocks of size kBlobfsBlockSize.
-    static zx_status_t Create(Blobfs* bs, const size_t buffer_blocks,
+    static zx_status_t Create(TransactionManager* transaction_manager, const size_t buffer_blocks,
                               fbl::unique_ptr<WritebackQueue>* out);
 
     // Copies all transaction data referenced from |work| into the writeback buffer.
diff --git a/system/ulib/blobfs/journal.cpp b/system/ulib/blobfs/journal.cpp
index 6f63568..6b99c8a 100644
--- a/system/ulib/blobfs/journal.cpp
+++ b/system/ulib/blobfs/journal.cpp
@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include <blobfs/journal.h>
-
 #include <fbl/unique_ptr.h>
 #include <lib/cksum.h>
 #include <zircon/types.h>
@@ -99,19 +98,20 @@
     commit_block_.checksum = checksum;
 }
 
-zx_status_t Journal::Create(Blobfs* blobfs, uint64_t journal_blocks, uint64_t start_block,
-                            fbl::unique_ptr<Journal>* out) {
+zx_status_t Journal::Create(TransactionManager* transaction_manager, uint64_t journal_blocks,
+                            uint64_t start_block, fbl::unique_ptr<Journal>* out) {
     // Create the buffer with 1 less than total journal blocks.
     // (1 block must be reserved for journal info).
     zx_status_t status;
     fbl::unique_ptr<Buffer> buffer;
-    if ((status = Buffer::Create(blobfs, journal_blocks - 1, "blobfs-journal", &buffer)) != ZX_OK) {
+    if ((status = Buffer::Create(transaction_manager, journal_blocks - 1, "blobfs-journal",
+                                 &buffer)) != ZX_OK) {
         return status;
     }
 
     // Create another buffer for the journal info block.
     fbl::unique_ptr<Buffer> info;
-    if ((status = Buffer::Create(blobfs, 1, "blobfs-journal-info", &info)) != ZX_OK) {
+    if ((status = Buffer::Create(transaction_manager, 1, "blobfs-journal-info", &info)) != ZX_OK) {
         return status;
     }
 
@@ -119,8 +119,8 @@
     info->ReserveIndex();
 
     // Create the Journal with the newly created vmos.
-    fbl::unique_ptr<Journal> journal(new Journal(blobfs, std::move(info), std::move(buffer),
-                                                 start_block));
+    fbl::unique_ptr<Journal> journal(new Journal(transaction_manager, std::move(info),
+                                                 std::move(buffer), start_block));
 
     // Load contents of journal from disk.
     if ((status = journal->Load()) != ZX_OK) {
@@ -171,7 +171,7 @@
     ZX_DEBUG_ASSERT(state_ == WritebackState::kInit);
 
     // Load info block and journal entries into their respective buffers.
-    fs::ReadTxn txn(blobfs_);
+    fs::ReadTxn txn(transaction_manager_);
     info_->Load(&txn, start_block_);
     entries_->Load(&txn, start_block_ + 1);
     zx_status_t status = txn.Transact();
@@ -490,14 +490,14 @@
 
 fbl::unique_ptr<WritebackWork> Journal::CreateWork() {
     fbl::unique_ptr<WritebackWork> work;
-    blobfs_->CreateWork(&work, nullptr);
+    transaction_manager_->CreateWork(&work, nullptr);
     ZX_DEBUG_ASSERT(work != nullptr);
     return work;
 }
 
 zx_status_t Journal::EnqueueEntryWork(fbl::unique_ptr<WritebackWork> work) {
     entries_->ValidateTransaction(work.get());
-    return blobfs_->EnqueueWork(std::move(work), EnqueueType::kData);
+    return transaction_manager_->EnqueueWork(std::move(work), EnqueueType::kData);
 }
 
 bool Journal::VerifyEntryMetadata(size_t header_index, uint64_t last_timestamp, bool expect_valid) {
@@ -631,7 +631,7 @@
     }
 
     fbl::unique_ptr<WritebackWork> work;
-    blobfs_->CreateWork(&work, nullptr);
+    transaction_manager_->CreateWork(&work, nullptr);
 
     info->start_block = start;
     info->num_blocks = length;
@@ -644,7 +644,7 @@
 
     info_->AddTransaction(0, start_block_, 1, work.get());
     info_->ValidateTransaction(work.get());
-    return blobfs_->EnqueueWork(std::move(work), EnqueueType::kData);
+    return transaction_manager_->EnqueueWork(std::move(work), EnqueueType::kData);
 }
 
 void Journal::EnsureSpaceLocked(size_t blocks) {
diff --git a/system/ulib/blobfs/writeback.cpp b/system/ulib/blobfs/writeback.cpp
index 4e3d450..a361520 100644
--- a/system/ulib/blobfs/writeback.cpp
+++ b/system/ulib/blobfs/writeback.cpp
@@ -66,13 +66,14 @@
 
 zx_status_t WriteTxn::Flush() {
     ZX_ASSERT(IsBuffered());
-    fs::Ticker ticker(bs_->LocalMetrics().Collecting());
+    fs::Ticker ticker(transaction_manager_->LocalMetrics().Collecting());
 
     // Update all the outgoing transactions to be in disk blocks
     block_fifo_request_t blk_reqs[requests_.size()];
-    const uint32_t kDiskBlocksPerBlobfsBlock = kBlobfsBlockSize / bs_->DeviceBlockSize();
+    const uint32_t kDiskBlocksPerBlobfsBlock =
+            kBlobfsBlockSize / transaction_manager_->DeviceBlockSize();
     for (size_t i = 0; i < requests_.size(); i++) {
-        blk_reqs[i].group = bs_->BlockGroupID();
+        blk_reqs[i].group = transaction_manager_->BlockGroupID();
         blk_reqs[i].vmoid = vmoid_;
         blk_reqs[i].opcode = BLOCKIO_WRITE;
         blk_reqs[i].vmo_offset = requests_[i].vmo_offset * kDiskBlocksPerBlobfsBlock;
@@ -85,14 +86,14 @@
     }
 
     // Actually send the operations to the underlying block device.
-    zx_status_t status = bs_->Transaction(blk_reqs, requests_.size());
+    zx_status_t status = transaction_manager_->Transaction(blk_reqs, requests_.size());
 
-    if (bs_->LocalMetrics().Collecting()) {
+    if (transaction_manager_->LocalMetrics().Collecting()) {
         uint64_t sum = 0;
         for (const auto& blk_req : blk_reqs) {
             sum += blk_req.length * kBlobfsBlockSize;
         }
-        bs_->LocalMetrics().UpdateWriteback(sum, ticker.End());
+        transaction_manager_->LocalMetrics().UpdateWriteback(sum, ticker.End());
     }
 
     requests_.reset();
@@ -148,8 +149,9 @@
     return status;
 }
 
-WritebackWork::WritebackWork(Blobfs* bs, fbl::RefPtr<Blob> vn) :
-    WriteTxn(bs), ready_cb_(nullptr), sync_cb_(nullptr), sync_(false), vn_(std::move(vn)) {}
+WritebackWork::WritebackWork(TransactionManager* transaction_manager, fbl::RefPtr<Blob> vn)
+    : WriteTxn(transaction_manager), ready_cb_(nullptr), sync_cb_(nullptr), sync_(false),
+      vn_(std::move(vn)) {}
 
 void WritebackWork::InvokeSyncCallback(zx_status_t status) {
     if (sync_cb_) {
@@ -167,14 +169,14 @@
     if (vmoid_ != VMOID_INVALID) {
         // Close the buffer vmo.
         block_fifo_request_t request;
-        request.group = blobfs_->BlockGroupID();
+        request.group = transaction_manager_->BlockGroupID();
         request.vmoid = vmoid_;
         request.opcode = BLOCKIO_CLOSE_VMO;
-        blobfs_->Transaction(&request, 1);
+        transaction_manager_->Transaction(&request, 1);
     }
 }
 
-zx_status_t Buffer::Create(Blobfs* blobfs, size_t blocks, const char* label,
+zx_status_t Buffer::Create(TransactionManager* blobfs, size_t blocks, const char* label,
                            fbl::unique_ptr<Buffer>* out) {
 
     fzl::OwnedVmoMapper mapper;
@@ -185,7 +187,7 @@
     }
 
     fbl::unique_ptr<Buffer> buffer(new Buffer(blobfs, std::move(mapper)));
-    if ((status = buffer->blobfs_->AttachVmo(buffer->mapper_.vmo(), &buffer->vmoid_))
+    if ((status = buffer->transaction_manager_->AttachVmo(buffer->mapper_.vmo(), &buffer->vmoid_))
         != ZX_OK) {
         FS_TRACE_ERROR("Buffer: Failed to attach vmo\n");
         return status;
@@ -366,11 +368,13 @@
     return status;
 }
 
-zx_status_t WritebackQueue::Create(Blobfs* blobfs, const size_t buffer_blocks,
+zx_status_t WritebackQueue::Create(TransactionManager* transaction_manager,
+                                   const size_t buffer_blocks,
                                    fbl::unique_ptr<WritebackQueue>* out) {
     zx_status_t status;
     fbl::unique_ptr<Buffer> buffer;
-    if ((status = Buffer::Create(blobfs, buffer_blocks, "blobfs-writeback", &buffer)) != ZX_OK) {
+    if ((status = Buffer::Create(transaction_manager, buffer_blocks, "blobfs-writeback", &buffer))
+        != ZX_OK) {
         return status;
     }