diff --git a/buffet/buffet_config.cc b/buffet/buffet_config.cc
index acbca00..dd63bb1 100644
--- a/buffet/buffet_config.cc
+++ b/buffet/buffet_config.cc
@@ -20,6 +20,7 @@
 #include <base/files/file_util.h>
 #include <base/files/important_file_writer.h>
 #include <base/logging.h>
+#include <base/message_loop/message_loop.h>
 #include <base/strings/string_number_conversions.h>
 #include <brillo/errors/error.h>
 #include <brillo/errors/error_codes.h>
@@ -166,31 +167,54 @@
   return true;
 }
 
-std::string BuffetConfig::LoadSettings() {
+std::string BuffetConfig::LoadSettings(const std::string& name) {
   std::string settings_blob;
-  if (!file_io_->ReadFile(options_.settings, &settings_blob)) {
-    LOG(WARNING) << "Failed to read settings, proceeding with empty settings.";
+  base::FilePath path = CreatePath(name);
+  if (!file_io_->ReadFile(path, &settings_blob)) {
+    LOG(WARNING) << "Failed to read \'" + path.value() +
+                        "\', proceeding with empty settings.";
     return std::string();
   }
   std::string json_string;
   if (!encryptor_->DecryptWithAuthentication(settings_blob, &json_string)) {
     LOG(WARNING)
         << "Failed to decrypt settings, proceeding with empty settings.";
-    SaveSettings(std::string());
+    SaveSettings(std::string(), name, {});
     return std::string();
   }
   return json_string;
 }
 
-void BuffetConfig::SaveSettings(const std::string& settings) {
+std::string BuffetConfig::LoadSettings() {
+  return LoadSettings("");
+}
+
+void BuffetConfig::SaveSettings(const std::string& name,
+                                const std::string& settings,
+                                const weave::DoneCallback& callback) {
   std::string encrypted_settings;
+  weave::ErrorPtr error;
+  base::FilePath path = CreatePath(name);
   if (!encryptor_->EncryptWithAuthentication(settings, &encrypted_settings)) {
-    LOG(ERROR) << "Failed to encrypt settings, writing empty settings.";
+    weave::Error::AddTo(&error, FROM_HERE, "file_write_error",
+                        "Failed to encrypt settings.");
     encrypted_settings.clear();
   }
-  if (!file_io_->WriteFile(options_.settings, encrypted_settings)) {
-    LOG(ERROR) << "Failed to write settings.";
+  if (!file_io_->WriteFile(path, encrypted_settings)) {
+    weave::Error::AddTo(&error, FROM_HERE, "file_write_error",
+                        "Failed to write \'" + path.value() +
+                            "\', proceeding with empty settings.");
   }
+  if (!callback.is_null()) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, base::Passed(&error)));
+  }
+}
+
+base::FilePath BuffetConfig::CreatePath(const std::string& name) const {
+  return name.empty() ? options_.settings
+                      : options_.settings.InsertBeforeExtension(
+                            base::FilePath::kExtensionSeparator + name);
 }
 
 bool BuffetConfig::LoadFile(const base::FilePath& file_path,
diff --git a/buffet/buffet_config.h b/buffet/buffet_config.h
index 7da9a8f..bf33db9 100644
--- a/buffet/buffet_config.h
+++ b/buffet/buffet_config.h
@@ -66,8 +66,11 @@
 
   // Config overrides.
   bool LoadDefaults(weave::Settings* settings) override;
+  std::string LoadSettings(const std::string& name) override;
   std::string LoadSettings() override;
-  void SaveSettings(const std::string& settings) override;
+  void SaveSettings(const std::string& name,
+                    const std::string& settings,
+                    const weave::DoneCallback& callback) override;
 
   bool LoadDefaults(const brillo::KeyValueStore& store,
                     weave::Settings* settings);
@@ -85,6 +88,7 @@
   }
 
  private:
+  base::FilePath CreatePath(const std::string& name) const;
   bool LoadFile(const base::FilePath& file_path,
                 std::string* data,
                 brillo::ErrorPtr* error);
diff --git a/buffet/buffet_config_unittest.cc b/buffet/buffet_config_unittest.cc
index bc4384e..a11ff4d 100644
--- a/buffet/buffet_config_unittest.cc
+++ b/buffet/buffet_config_unittest.cc
@@ -125,36 +125,36 @@
 };
 
 TEST_F(BuffetConfigTestWithFakes, EncryptionEnabled) {
-  config_->SaveSettings("test");
-  ASSERT_NE("test", fake_file_content_["settings_file"]);
-  ASSERT_EQ("test", config_->LoadSettings());
+  config_->SaveSettings("config", "test", {});
+  ASSERT_NE("test", fake_file_content_["settings_file.config"]);
+  ASSERT_EQ("test", config_->LoadSettings("config"));
 }
 
 TEST_F(BuffetConfigTestWithFakes, EncryptionFailure) {
-  config_->SaveSettings("test");
-  ASSERT_FALSE(fake_file_content_["settings_file"].empty());
+  config_->SaveSettings("config", "test", {});
+  ASSERT_FALSE(fake_file_content_["settings_file.config"].empty());
   encryptor_result_ = false;
-  config_->SaveSettings("test2");
+  config_->SaveSettings("config", "test2", {});
   // Encryption fails -> file cleared.
-  ASSERT_TRUE(fake_file_content_["settings_file"].empty());
+  ASSERT_TRUE(fake_file_content_["settings_file.config"].empty());
 }
 
 TEST_F(BuffetConfigTestWithFakes, DecryptionFailure) {
-  config_->SaveSettings("test");
-  ASSERT_FALSE(fake_file_content_["settings_file"].empty());
+  config_->SaveSettings("config", "test", {});
+  ASSERT_FALSE(fake_file_content_["settings_file.config"].empty());
   encryptor_result_ = false;
   // Decryption fails -> empty settings loaded.
-  ASSERT_TRUE(config_->LoadSettings().empty());
+  ASSERT_TRUE(config_->LoadSettings("config").empty());
 }
 
 TEST_F(BuffetConfigTestWithFakes, SettingsIOFailure) {
-  config_->SaveSettings("test");
-  std::string original = fake_file_content_["settings_file"];
+  config_->SaveSettings("config", "test", {});
+  std::string original = fake_file_content_["settings_file.config"];
   ASSERT_FALSE(original.empty());
   io_result_ = false;
-  ASSERT_TRUE(config_->LoadSettings().empty());
-  config_->SaveSettings("test2");
-  ASSERT_EQ(original, fake_file_content_["settings_file"]);
+  ASSERT_TRUE(config_->LoadSettings("config").empty());
+  config_->SaveSettings("config2", "test", {});
+  ASSERT_EQ(original, fake_file_content_["settings_file.config"]);
 }
 
 }  // namespace buffet