diff --git a/domain-server/src/DomainMetadata.cpp b/domain-server/src/DomainMetadata.cpp
index cfb48e6c49..f18aa8c71b 100644
--- a/domain-server/src/DomainMetadata.cpp
+++ b/domain-server/src/DomainMetadata.cpp
@@ -61,11 +61,12 @@ const QString DomainMetadata::Descriptors::Hours::CLOSE = "close";
 // it is meant to be sent to and consumed by an external API
 
 DomainMetadata::DomainMetadata(QObject* domainServer) : QObject(domainServer) {
+    // set up the structure necessary for casting during parsing (see parseHours, esp.)
     _metadata[USERS] = QVariantMap {};
     _metadata[DESCRIPTORS] = QVariantMap {
         { Descriptors::HOURS, QVariantMap {
-            { Descriptors::Hours::WEEKDAY, QVariantList() },
-            { Descriptors::Hours::WEEKEND, QVariantList() }
+            { Descriptors::Hours::WEEKDAY, QVariantList { QVariantMap{} } },
+            { Descriptors::Hours::WEEKEND, QVariantList { QVariantMap{} } }
         } }
     };
 
@@ -81,6 +82,7 @@ DomainMetadata::DomainMetadata(QObject* domainServer) : QObject(domainServer) {
         this, static_cast<void(DomainMetadata::*)()>(&DomainMetadata::securityChanged));
 
     // initialize the descriptors
+    securityChanged(false);
     descriptorsChanged();
 }
 
@@ -94,69 +96,65 @@ QJsonObject DomainMetadata::get(const QString& group) {
     return QJsonObject::fromVariantMap(_metadata[group].toMap());
 }
 
-QVariant parseHours(QVariant base, QVariant delta) {
+void parseHours(QVariant delta, QVariant& target) {
     using Hours = DomainMetadata::Descriptors::Hours;
 
-    auto& baseList = base.toList();
-    auto& deltaList = delta.toList();
-    if (baseList.isEmpty() || !baseList.length()) {
-        return delta;
-    } else if (deltaList.isEmpty() || !deltaList.length()) {
-        return base;
-    }
+    // hours should be of the form [ { open: Time, close: Time } ]
+    assert(target.canConvert<QVariantList>());
+    auto& targetList = *static_cast<QVariantList*>(target.data());
 
-    auto& baseMap = baseList[0].toMap();
-    auto& deltaMap = deltaList[0].toMap();
-    if (baseMap.isEmpty()) {
-        return delta;
-    } else if (deltaMap.isEmpty()) {
-        return base;
+    // if/when multiple ranges are allowed, this list will need to be iterated
+    assert(targetList[0].canConvert<QVariantMap>());
+    auto& targetMap = *static_cast<QVariantMap*>(targetList[0].data());
+
+    auto deltaMap = delta.toList()[0].toMap();
+    if (deltaMap.isEmpty()) {
+        return;
     }
 
     // merge delta into base
-    // hours should be of the form [ { open: Time, close: Time } ], so one level is sufficient
-    foreach(auto key, baseMap.keys()) {
-        deltaMap[key] = baseMap[key];
+    auto open = deltaMap.find(Hours::OPEN);
+    if (open != deltaMap.end()) {
+        targetMap[Hours::OPEN] = open.value();
     }
-
-    return base;
+    assert(targetMap[Hours::OPEN].canConvert<QString>());
+    auto close = deltaMap.find(Hours::CLOSE);
+    if (close != deltaMap.end()) {
+        targetMap[Hours::CLOSE] = close.value();
+    }
+    assert(targetMap[Hours::CLOSE].canConvert<QString>());
 }
 
 void DomainMetadata::descriptorsChanged() {
     // get descriptors
+    assert(_metadata[DESCRIPTORS].canConvert<QVariantMap>());
+    auto& state = *static_cast<QVariantMap*>(_metadata[DESCRIPTORS].data());
     auto settings = static_cast<DomainServer*>(parent())->_settingsManager.getSettingsMap();
-    auto& descriptors = settings[DESCRIPTORS].toMap();
+    auto descriptors = settings[DESCRIPTORS].toMap();
+
+    // copy simple descriptors (description/maturity)
+    state[Descriptors::DESCRIPTION] = descriptors[Descriptors::DESCRIPTION]; 
+    state[Descriptors::MATURITY] = descriptors[Descriptors::MATURITY];
+
+    // copy array descriptors (hosts/tags)
+    state[Descriptors::HOSTS] = descriptors[Descriptors::HOSTS].toList();
+    state[Descriptors::TAGS] = descriptors[Descriptors::TAGS].toList();
 
     // parse capacity
     const QString CAPACITY = "security.maximum_user_capacity";
     const QVariant* capacityVariant = valueForKeyPath(settings, CAPACITY);
     unsigned int capacity = capacityVariant ? capacityVariant->toUInt() : 0;
-    descriptors[Descriptors::CAPACITY] = capacity;
+    state[Descriptors::CAPACITY] = capacity;
 
     // parse operating hours
     const QString WEEKDAY_HOURS = "weekday_hours";
     const QString WEEKEND_HOURS = "weekend_hours";
     const QString UTC_OFFSET = "utc_offset";
-    auto& hours = _metadata[DESCRIPTORS].toMap()[Descriptors::HOURS].toMap();
-    assert(!hours.isEmpty());
-    auto weekdayHours = parseHours(hours[Descriptors::Hours::WEEKDAY], descriptors[WEEKDAY_HOURS]);
-    auto weekendHours = parseHours(hours[Descriptors::Hours::WEEKEND], descriptors[WEEKEND_HOURS]);
-    auto utcOffset = descriptors[UTC_OFFSET];
-    descriptors.remove(WEEKDAY_HOURS);
-    descriptors.remove(WEEKEND_HOURS);
-    descriptors.remove(UTC_OFFSET);
-    descriptors[Descriptors::HOURS] = QVariantMap {
-        { Descriptors::Hours::UTC_OFFSET, utcOffset },
-        { Descriptors::Hours::WEEKDAY, weekdayHours },
-        { Descriptors::Hours::WEEKEND, weekendHours }
-    };
-
-    // update metadata
-    _metadata[DESCRIPTORS] = descriptors;
-
-    // update overwritten fields
-    // this further overwrites metadata, so it must be done after commiting descriptors
-    securityChanged(false);
+    assert(state[Descriptors::HOURS].canConvert<QVariantMap>());
+    auto& hours = *static_cast<QVariantMap*>(state[Descriptors::HOURS].data());
+    parseHours(descriptors.take(WEEKDAY_HOURS), hours[Descriptors::Hours::WEEKDAY]);
+    parseHours(descriptors.take(WEEKEND_HOURS), hours[Descriptors::Hours::WEEKEND]);
+    hours[Descriptors::Hours::UTC_OFFSET] = descriptors.take(UTC_OFFSET);
 
 #if DEV_BUILD || PR_BUILD
     qDebug() << "Domain metadata descriptors set:" << QJsonObject::fromVariantMap(_metadata[DESCRIPTORS].toMap());
@@ -166,6 +164,10 @@ void DomainMetadata::descriptorsChanged() {
 }
 
 void DomainMetadata::securityChanged(bool send) {
+    // get descriptors
+    assert(_metadata[DESCRIPTORS].canConvert<QVariantMap>());
+    auto& state = *static_cast<QVariantMap*>(_metadata[DESCRIPTORS].data());
+
     const QString RESTRICTION_OPEN = "open";
     const QString RESTRICTION_ANON = "anon";
     const QString RESTRICTION_HIFI = "hifi";
@@ -186,8 +188,7 @@ void DomainMetadata::securityChanged(bool send) {
         restriction = RESTRICTION_ACL;
     }
 
-    auto& descriptors = _metadata[DESCRIPTORS].toMap();
-    descriptors[Descriptors::RESTRICTION] = restriction;
+    state[Descriptors::RESTRICTION] = restriction;
 
 #if DEV_BUILD || PR_BUILD
     qDebug() << "Domain metadata restriction set:" << restriction;
@@ -240,12 +241,11 @@ void DomainMetadata::maybeUpdateUsers() {
         }
     });
 
-    QVariantMap users = {
-        { Users::NUM_TOTAL, numConnected },
-        { Users::NUM_ANON, numConnectedAnonymously },
-        { Users::HOSTNAMES, userHostnames }};
-    _metadata[USERS] = users;
-    ++_tic;
+    assert(_metadata[USERS].canConvert<QVariantMap>());
+    auto& users = *static_cast<QVariantMap*>(_metadata[USERS].data());
+    users[Users::NUM_TOTAL] = numConnected;
+    users[Users::NUM_ANON] = numConnectedAnonymously;
+    users[Users::HOSTNAMES] = userHostnames;
 
 #if DEV_BUILD || PR_BUILD
     qDebug() << "Domain metadata users set:" << QJsonObject::fromVariantMap(_metadata[USERS].toMap());