diff --git a/client/src/MapStore.ts b/client/src/MapStore.ts
index 02fa62e..b1f4df4 100644
--- a/client/src/MapStore.ts
+++ b/client/src/MapStore.ts
@@ -7,6 +7,7 @@ import {
   ColorFilters,
   Context,
   Dataset,
+  DisplayConfiguration,
   LayerCollection,
   NetCDFData,
   NetCDFLayer,
@@ -33,6 +34,10 @@ export default class MapStore {
 
   public static proModeButtonEnabled = ref(true);
 
+  public static displayConfiguration: Ref<DisplayConfiguration> = ref(
+    { default_displayed_layers: [], enabled_ui: ['Collections', 'Datasets', 'Metadata'], default_tab: 'Scenarios' },
+  );
+
   // Ability to toggle proMode so Staff users can see what other users see.
   public static proMode = computed(() => MapStore.userIsStaff.value && MapStore.proModeButtonEnabled.value);
 
@@ -103,10 +108,57 @@ export default class MapStore {
     MapStore.mapLayersByDataset[datasetId] = await UVdatApi.getDatasetLayers(datasetId);
   }
 
+  public static async getDisplayConfiguration(initial = false) {
+    MapStore.displayConfiguration.value = await UVdatApi.getDisplayConfiguration();
+    // Loading first time process default map layers
+    if (initial && MapStore.displayConfiguration.value.default_displayed_layers.length) {
+      const datasetIds = MapStore.displayConfiguration.value.default_displayed_layers.map((item) => item.dataset_id);
+      const datasetIdLayers = await UVdatApi.getDatasetsLayers(datasetIds);
+      const layerByDataset: Record<number, (VectorMapLayer | RasterMapLayer | NetCDFData)[]> = {};
+      const toggleLayers: (VectorMapLayer | RasterMapLayer | NetCDFLayer)[] = [];
+      const enabledLayers = MapStore.displayConfiguration.value.default_displayed_layers;
+      datasetIdLayers.forEach((item) => {
+        if (item.dataset_id !== undefined) {
+          if (layerByDataset[item.dataset_id] === undefined) {
+            layerByDataset[item.dataset_id] = [];
+          }
+          layerByDataset[item.dataset_id].push(item);
+        }
+        enabledLayers.forEach((enabledLayer) => {
+          if (item.type === 'netcdf') {
+            if (enabledLayer.dataset_id === item.dataset_id) {
+              const netCDFLayers = ((item as NetCDFData).layers);
+              for (let i = 0; i < netCDFLayers.length; i += 1) {
+                const layer = netCDFLayers[i];
+                if (layer.id === enabledLayer.id) {
+                  toggleLayers.push(layer);
+                }
+              }
+            }
+          } else if (
+            enabledLayer.type === item.type
+            && enabledLayer.id === item.id
+            && enabledLayer.dataset_id === item.dataset_id) {
+            toggleLayers.push(item);
+          }
+        });
+      });
+      Object.keys(layerByDataset).forEach((datasetIdKey) => {
+        const datasetId = parseInt(datasetIdKey, 10);
+        if (!Number.isNaN(datasetId)) {
+          MapStore.mapLayersByDataset[datasetId] = layerByDataset[datasetId];
+        }
+      });
+      // Now we enable these default layers
+      return toggleLayers;
+    }
+    return [];
+  }
+
   public static mapLayerFeatureGraphs = computed(() => {
     const foundMapLayerFeatureGraphs: { name: string, id: number; graphs: VectorFeatureTableGraph[] }[] = [];
     MapStore.selectedVectorMapLayers.value.forEach((item) => {
-      if (item.default_style.mapLayerFeatureTableGraphs && item.default_style.mapLayerFeatureTableGraphs.length) {
+      if (item.default_style?.mapLayerFeatureTableGraphs && item.default_style.mapLayerFeatureTableGraphs.length) {
         foundMapLayerFeatureGraphs.push({
           name: item.name,
           id: item.id,
@@ -133,7 +185,7 @@ export default class MapStore {
   public static mapLayerVectorSearchable = computed(() => {
     const foundMapLayerSearchable: { name: string, id: number; searchSettings: SearchableVectorData }[] = [];
     MapStore.selectedVectorMapLayers.value.forEach((item) => {
-      if (item.default_style.searchableVectorFeatureData) {
+      if (item.default_style?.searchableVectorFeatureData) {
         foundMapLayerSearchable.push({
           name: item.name,
           id: item.id,
diff --git a/client/src/api/UVDATApi.ts b/client/src/api/UVDATApi.ts
index b1797af..58143b7 100644
--- a/client/src/api/UVDATApi.ts
+++ b/client/src/api/UVDATApi.ts
@@ -3,11 +3,13 @@ import { ref } from 'vue';
 import OauthClient from '@girder/oauth-client/dist/oauth-client';
 import {
   AbstractMapLayer,
+  AbstractMapLayerListItem,
   Chart,
   Context,
   ContextWithIds,
   Dataset,
   DerivedRegion,
+  DisplayConfiguration,
   FeatureGraphData,
   FileItem,
   LayerCollection,
@@ -213,7 +215,7 @@ export default class UVdatApi {
     return (await UVdatApi.apiClient.delete(`/files/${fileItemId}/`)).data;
   }
 
-  public static async getGlobalDatasets(filter: { unconnected: boolean }): Promise<(Dataset & { contextCount: number })[]> {
+  public static async getGlobalDatasets(filter?: { unconnected: boolean }): Promise<(Dataset & { contextCount: number })[]> {
     return (await UVdatApi.apiClient.get('datasets', { params: { ...filter } })).data.results;
   }
 
@@ -450,6 +452,12 @@ export default class UVdatApi {
     return (await UVdatApi.apiClient.get(`/datasets/${datasetId}/map_layers`)).data;
   }
 
+  public static async getDatasetsLayers(datasetIds: number[]): Promise<(VectorMapLayer | RasterMapLayer | NetCDFData)[]> {
+    const params = new URLSearchParams();
+    datasetIds.forEach((item) => params.append('datasetIds', item.toString()));
+    return (await UVdatApi.apiClient.get('/datasets/map_layers', { params })).data;
+  }
+
   public static async getProcessingTasks(): Promise<ProcessingTask[]> {
     return (await UVdatApi.apiClient.get('/processing-tasks')).data;
   }
@@ -587,7 +595,32 @@ export default class UVdatApi {
     return (await UVdatApi.apiClient.get('/map-layers/', { params })).data;
   }
 
+  public static async getMapLayerAll(): Promise<AbstractMapLayerListItem[]> {
+    return (await UVdatApi.apiClient.get('/map-layers/all')).data;
+  }
+
   public static async searchVectorFeatures(requestData: SearchableVectorDataRequest): Promise<SearchableVectorFeatureResponse[]> {
     return (await UVdatApi.apiClient.post('/map-layers/search-features/', requestData)).data;
   }
+
+  public static async getDisplayConfiguration(): Promise<DisplayConfiguration> {
+    const response = await UVdatApi.apiClient.get('display-configuration/');
+    return response.data;
+  }
+
+  // Fully update the display configuration (PUT /display_configuration/)
+  public static async updateDisplayConfiguration(
+    config: DisplayConfiguration,
+  ): Promise<DisplayConfiguration> {
+    const response = await UVdatApi.apiClient.put('display-configuration/', config);
+    return response.data;
+  }
+
+  // Partially update the display configuration (PATCH /display_configuration/)
+  public static async partialUpdateDisplayConfiguration(
+    config: Partial<DisplayConfiguration>,
+  ): Promise<DisplayConfiguration> {
+    const response = await UVdatApi.apiClient.patch('display-configuration/', config);
+    return response.data;
+  }
 }
diff --git a/client/src/components/Admin/MapSelection.vue b/client/src/components/Admin/MapSelection.vue
new file mode 100644
index 0000000..34e6be5
--- /dev/null
+++ b/client/src/components/Admin/MapSelection.vue
@@ -0,0 +1,89 @@
+<script lang="ts">
+import {
+  PropType, Ref, defineComponent, onMounted, ref,
+} from 'vue';
+import maplibre, { Map } from 'maplibre-gl';
+
+export default defineComponent({
+  name: 'MapSelection',
+  props: {
+    defaultMapSettings: {
+      type: Object as PropType<{ location: {
+        center: [number, number];
+        zoom: number;
+      } }>,
+      required: true,
+    },
+  },
+  emits: ['update:settings'],
+  setup(props, { emit }) {
+    const mapContainer = ref<HTMLDivElement | null>(null);
+    const mapInstance: Ref<Map | null> = ref(null);
+
+    const mapMove = () => {
+      if (mapInstance.value) {
+        const center = mapInstance.value.getCenter();
+        const zoom = mapInstance.value.getZoom();
+        emit('update:settings', {
+          location: {
+            center: [center.lng, center.lat],
+            zoom,
+          },
+        });
+      }
+    };
+    // Initialize Map
+    onMounted(() => {
+      if (!mapContainer.value) return;
+      mapInstance.value = new maplibre.Map({
+        container: mapContainer.value,
+        style: {
+          version: 8,
+          sources: {
+            osm: {
+              type: 'raster',
+              tiles: [
+                'https://a.tile.openstreetmap.org/{z}/{x}/{y}.png',
+                'https://b.tile.openstreetmap.org/{z}/{x}/{y}.png',
+                'https://c.tile.openstreetmap.org/{z}/{x}/{y}.png',
+              ],
+              tileSize: 256,
+              attribution: '© OpenStreetMap contributors',
+            },
+          },
+          layers: [
+            {
+              id: 'osm-tiles',
+              type: 'raster',
+              source: 'osm',
+              maxzoom: 19,
+            },
+          ],
+        },
+        center: props.defaultMapSettings.location.center,
+        zoom: props.defaultMapSettings.location.zoom,
+      });
+      mapInstance.value.on('load', () => {
+        if (mapInstance.value) {
+          mapInstance.value.on('move', mapMove);
+        }
+      });
+    });
+
+    return {
+      mapContainer,
+    };
+  },
+});
+</script>
+
+<template>
+  <div ref="mapContainer" class="map-container" />
+</template>
+
+<style scoped>
+  .map-container {
+    width: 100%;
+    height: 400px;
+  }
+</style>
diff --git a/client/src/components/FeatureSelection/vectorFeatureGraphUtils.ts b/client/src/components/FeatureSelection/vectorFeatureGraphUtils.ts
index 8a391ed..4194b20 100644
--- a/client/src/components/FeatureSelection/vectorFeatureGraphUtils.ts
+++ b/client/src/components/FeatureSelection/vectorFeatureGraphUtils.ts
@@ -230,7 +230,7 @@ const renderVectorFeatureGraph = (
       g.append('path')
         .datum(graph.movingAverage)
         .attr('fill', 'none')
-        .attr('stroke', '#00FFFF')
+        .attr('stroke', '#FFFF00')
         .attr('stroke-width', 5)
         .attr('d', line)
         .attr('class', `moving-average moving-average-${key}`);
diff --git a/client/src/components/Map.vue b/client/src/components/Map.vue
index 880de32..128f887 100644
--- a/client/src/components/Map.vue
+++ b/client/src/components/Map.vue
@@ -66,6 +66,8 @@ export default defineComponent({
 
     const initializeMap = () => {
       if (mapContainer.value) {
+        const center = MapStore.displayConfiguration.value.default_map_settings?.location.center || [-86.1794, 34.8019];
+        const zoom = MapStore.displayConfiguration.value.default_map_settings?.location.zoom || 6;
         map.value = new maplibregl.Map({
           container: mapContainer.value,
           style: {
@@ -156,8 +158,8 @@ export default defineComponent({
             sprite: 'https://maputnik.github.io/osm-liberty/sprites/osm-liberty',
             glyphs: 'https://orangemug.github.io/font-glyphs/glyphs/{fontstack}/{range}.pbf',
           },
-          center: [-86.1794, 34.8019], // Coordinates for the relative center of the TVA
-          zoom: 6, // Initial zoom level
+          center,
+          zoom,
         });
         if (map.value) {
           setInternalMap(map as Ref<Map>);
@@ -237,7 +239,8 @@ export default defineComponent({
     watch(
       MapStore.hoveredFeatures,
       () => {
-        if (map.value && (MapStore.mapLayerFeatureGraphsVisible.value || MapStore.activeSideBarCard.value === 'searchableVectors')) {
+        if (map.value
+        && (MapStore.mapLayerFeatureGraphsVisible.value || MapStore.activeSideBarCard.value === 'searchableVectors')) {
           updateSelected(map.value);
         }
       },
diff --git a/client/src/components/MapLegends/ColorKey.vue b/client/src/components/MapLegends/ColorKey.vue
index 724448f..974f6d4 100644
--- a/client/src/components/MapLegends/ColorKey.vue
+++ b/client/src/components/MapLegends/ColorKey.vue
@@ -269,8 +269,11 @@ export default defineComponent({
         // D3 allows color strings but says it requires numbers for type definitions
         .range(colors);
       // Recalculate percentage of width for gradient
-      const max = domain[domain.length - 1];
-      const percent = domain.map((item) => (max === 0 ? 0 : item / max));
+      const min = Math.min(...domain);
+      const max = Math.max(...domain);
+      const range = max - min;
+
+      const percent = domain.map((item) => (range === 0 ? 0 : (item - min) / range));
       // Append multiple color stops using data/enter step
       linearGradient.selectAll('stop').remove();
       linearGradient
diff --git a/client/src/components/TabularData/MapLayerTableGraph.vue b/client/src/components/TabularData/MapLayerTableGraph.vue
index 24922a1..80b0268 100644
--- a/client/src/components/TabularData/MapLayerTableGraph.vue
+++ b/client/src/components/TabularData/MapLayerTableGraph.vue
@@ -35,9 +35,13 @@ export default defineComponent({
 
     const maxMovingAverage = computed(() => {
       if (graphData.value) {
-        if (graphData.value?.graphs && graphData.value.graphs.all) {
-          const dataLength = graphData.value.graphs.all.data.length;
-          return Math.floor(dataLength / 4);
+        if (graphData.value?.graphs) {
+          const values = Object.values(graphData.value.graphs);
+          let max = -Infinity;
+          for (let i = 0; i < values.length; i += 1) {
+            max = Math.max(max, Math.floor(values[i].data.length / 4));
+          }
+          return max;
         }
       }
       return 50;
diff --git a/client/src/components/VectorFeatureSearch/Editor/VectorFeatureSearchEditor.vue b/client/src/components/VectorFeatureSearch/Editor/VectorFeatureSearchEditor.vue
index 70dea2e..e401449 100644
--- a/client/src/components/VectorFeatureSearch/Editor/VectorFeatureSearchEditor.vue
+++ b/client/src/components/VectorFeatureSearch/Editor/VectorFeatureSearchEditor.vue
@@ -1,3 +1,4 @@
+<!-- eslint-disable vue/max-len -->
 <script lang="ts">
 import {
   Ref, computed, defineComponent, onMounted, ref,
@@ -75,7 +76,7 @@ export default defineComponent({
       value: key,
     })));
 
-    const availableTitleKeys = computed(() => Object.keys(availableProperties.value || {}).map((key) => (getDisplayName(key))));
+    const availableTitleKeys = computed(() => Object.keys(availableProperties.value || {}).map((key) => ({ title: getDisplayName(key), value: key })));
 
     const availableSubtitleKeys = computed(() => Object.keys(availableProperties.value || {}).map((key) => ({
       title: availableProperties.value?.[key]?.displayName || key,
@@ -269,7 +270,13 @@ export default defineComponent({
                     <strong>Title</strong>
                   </v-expansion-panel-title>
                   <v-expansion-panel-text>
-                    <v-select v-model="localData.display.titleKey" :items="availableTitleKeys" label="Title Key" />
+                    <v-select
+                      v-model="localData.display.titleKey"
+                      :items="availableTitleKeys"
+                      item-title="title"
+                      item-value="value"
+                      label="Title Key"
+                    />
                   </v-expansion-panel-text>
                 </v-expansion-panel>
                 <v-expansion-panel>
diff --git a/client/src/components/VectorFeatureSearch/VectorFeatureSearch.vue b/client/src/components/VectorFeatureSearch/VectorFeatureSearch.vue
index 7b8c8ee..aebac00 100644
--- a/client/src/components/VectorFeatureSearch/VectorFeatureSearch.vue
+++ b/client/src/components/VectorFeatureSearch/VectorFeatureSearch.vue
@@ -1,3 +1,4 @@
+<!-- eslint-disable vue/max-len -->
 <!-- eslint-disable vuejs-accessibility/mouse-events-have-key-events -->
 <!-- eslint-disable vuejs-accessibility/mouse-events-have-key-events -->
 <script lang="ts">
diff --git a/client/src/map/mapFilters.ts b/client/src/map/mapFilters.ts
index c04fd82..23733f7 100644
--- a/client/src/map/mapFilters.ts
+++ b/client/src/map/mapFilters.ts
@@ -18,7 +18,7 @@ import MapStore from '../MapStore';
 
 const getLayerDefaultFilter = (type: AnnotationTypes, layer?: VectorMapLayer) => {
   let drawPoints = false;
-  if (type === 'circle' && layer?.default_style.layers && layer.default_style.layers.line) {
+  if (type === 'circle' && layer?.default_style?.layers && layer.default_style.layers.line) {
     if (layer.default_style.layers.line !== true) {
       drawPoints = !!layer.default_style.layers.line.drawPoints;
     }
diff --git a/client/src/map/mapVectorLayers.ts b/client/src/map/mapVectorLayers.ts
index ad6720f..84eef78 100644
--- a/client/src/map/mapVectorLayers.ts
+++ b/client/src/map/mapVectorLayers.ts
@@ -293,7 +293,7 @@ const toggleVectorMapLayers = (map: maplibregl.Map) => {
     if (MapStore.visibleMapLayers.value.has(`${layer.type}_${layer.id}`)) {
       // eslint-disable-next-line @typescript-eslint/no-use-before-define
       updateVectorLayer(layer);
-      if (layer?.default_style.searchableVectorFeatureData) {
+      if (layer?.default_style?.searchableVectorFeatureData) {
         if (layer.default_style.searchableVectorFeatureData.display.autoOpenSideBar) {
           if (MapStore.activeSideBarCard.value !== 'searchableVectors') {
             MapStore.toggleContext('searchableVectors');
diff --git a/client/src/router/index.ts b/client/src/router/index.ts
index 0ed8bc9..e446a28 100644
--- a/client/src/router/index.ts
+++ b/client/src/router/index.ts
@@ -1,5 +1,6 @@
 import { RouterOptions, createWebHistory } from 'vue-router';
 import HomePage from '../views/HomePage.vue';
+import DisplayAdmin from '../views/Admin/DisplayAdmin.vue';
 
 function makeOptions(): RouterOptions {
   return {
@@ -10,6 +11,12 @@ function makeOptions(): RouterOptions {
         // component: HomePage,
         component: HomePage,
       },
+      {
+        path: '/admin',
+        // component: HomePage,
+        component: DisplayAdmin,
+      },
+
     ],
   };
 }
diff --git a/client/src/types.ts b/client/src/types.ts
index 8cfa31d..11fdf7d 100644
--- a/client/src/types.ts
+++ b/client/src/types.ts
@@ -901,3 +901,19 @@ export interface SearchableVectorFeatureResponse {
   details: { key: string; value: string }[];
   center: { lat: number, lon: number };
 }
+
+export interface DisplayConfiguration {
+  enabled_ui: ('Scenarios' | 'Collections' | 'Datasets' | 'Metadata')[];
+  default_tab: 'Scenarios' | 'Collections' | 'Datasets' | 'Metadata';
+  default_displayed_layers: Array<{ type: AbstractMapLayer['type']; id: number; dataset_id: number; name: string }>;
+  default_map_settings?: { location: { center: [number, number], zoom: number } };
+}
+
+export interface AbstractMapLayerListItem {
+  id: number;
+  name: string;
+  type: AbstractMapLayer['type'];
+  dataset_id: number;
+  file_item: { id: number, name: string }[];
+  processing_tasks?: null | ProcessingTask[]
+}
diff --git a/client/src/views/Admin/DisplayAdmin.vue b/client/src/views/Admin/DisplayAdmin.vue
new file mode 100644
index 0000000..b1efb2e
--- /dev/null
+++ b/client/src/views/Admin/DisplayAdmin.vue
@@ -0,0 +1,150 @@
+<script lang="ts">
+import {
+  Ref, computed, defineComponent, onMounted, ref, watch,
+} from 'vue';
+import {
+  AbstractMapLayerListItem, DisplayConfiguration,
+} from '../../types';
+import UVdatApi from '../../api/UVDATApi';
+import MapSelection from '../../components/Admin/MapSelection.vue';
+
+export default defineComponent({
+  name: 'DisplayConfigurationEditor',
+  components: {
+    MapSelection,
+  },
+  setup() {
+    const config: Ref<DisplayConfiguration | null> = ref(null);
+    const enabledUiOptions = ['Scenarios', 'Collections', 'Datasets', 'Metadata'];
+    const layerTypes = ['netcdf', 'vector', 'raster'];
+    const snackbar = ref({ show: false, text: '', color: '' });
+    const layers: Ref<AbstractMapLayerListItem[]> = ref([]);
+    const selectedLayers: Ref<string[]> = ref([]);
+    onMounted(async () => {
+      config.value = await UVdatApi.getDisplayConfiguration();
+      layers.value = await UVdatApi.getMapLayerAll();
+      selectedLayers.value = config.value.default_displayed_layers.map((item) => (`${item.type}_${item.id}_${item.dataset_id}`));
+    });
+
+    watch(() => config.value?.enabled_ui, (newVal) => {
+      if (config.value && newVal && !newVal?.includes(config.value.default_tab)) {
+        config.value.default_tab = newVal[0] || '';
+      }
+    });
+
+    const availableLayers = computed(() => {
+      if (layers.value) {
+        return layers.value.map((item) => ({
+          id: item.id,
+          name: item.name,
+          dataset_id: item.dataset_id,
+          type: item.type,
+          index: `${item.type}_${item.id}_${item.dataset_id}`,
+        }));
+      }
+      return [];
+    });
+
+    const saveConfig = async () => {
+      try {
+        if (config.value) {
+          config.value.default_displayed_layers = [];
+          selectedLayers.value.forEach((item) => {
+            const data = availableLayers.value.find((layer) => layer.index === item);
+            if (data) {
+              config.value?.default_displayed_layers.push({
+                id: data.id, name: data.name, dataset_id: data.dataset_id, type: data.type,
+              });
+            }
+          });
+          await UVdatApi.updateDisplayConfiguration(config.value);
+        }
+        snackbar.value = { show: true, text: 'Configuration updated successfully!', color: 'success' };
+      } catch (error) {
+        snackbar.value = { show: true, text: 'Failed to update configuration', color: 'error' };
+      }
+    };
+
+    const updateDefaultMapSettings = (settings: { location: { center: [number, number]; zoom: number; }; }) => {
+      if (config.value) {
+        config.value.default_map_settings = settings;
+      }
+    };
+
+    return {
+      config,
+      enabledUiOptions,
+      layerTypes,
+      saveConfig,
+      snackbar,
+      availableLayers,
+      selectedLayers,
+      updateDefaultMapSettings,
+    };
+  },
+});
+</script>
+<template>
+  <v-app-bar app>
+    <v-btn to="/">
+      <v-icon size="x-large" to="/">
+        mdi-arrow-left
+      </v-icon>
+    </v-btn>
+  </v-app-bar>
+  <v-container v-if="config">
+    <v-card>
+      <v-card-title>Display Configuration</v-card-title>
+      <v-card-text>
+        <v-select
+          v-model="config.enabled_ui"
+          :items="enabledUiOptions"
+          label="Enabled UI Features"
+          multiple
+          chips
+        />
+        <v-select
+          v-model="config.default_tab"
+          :items="config.enabled_ui"
+          label="Default Tab"
+        />
+        <v-select
+          v-model="selectedLayers"
+          :items="availableLayers"
+          item-title="name"
+          item-value="index"
+          label="Default Visible Layers"
+          multiple
+          clearable
+          closable-chips
+        >
+          <template #chip="{ props, item }">
+            <v-chip v-bind="props">
+              {{ item.raw.name }}:{{ item.raw.type }}
+            </v-chip>
+          </template>
+          <template #item="{ item, props }">
+            <v-list-item v-bind="props">
+              {{ item.raw.type }}
+            </v-list-item>
+          </template>
+        </v-select>
+        <map-selection
+          :default-map-settings="config?.default_map_settings || { location: { center: [-86.1794, 34.8019], zoom: 6 } }"
+          @update:settings="updateDefaultMapSettings($event)"
+        />
+      </v-card-text>
+      <v-card-actions>
+        <v-btn color="primary" @click="saveConfig">
+          Save
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+    <v-snackbar v-model="snackbar.show" :color="snackbar.color" timeout="3000">
+      {{ snackbar.text }}
+    </v-snackbar>
+  </v-container>
+</template>
+
+<style scoped>
+</style>
diff --git a/client/src/views/HomePage.vue b/client/src/views/HomePage.vue
index 012af9e..a304e5f 100644
--- a/client/src/views/HomePage.vue
+++ b/client/src/views/HomePage.vue
@@ -1,6 +1,6 @@
 <script lang="ts">
 import {
-  computed, defineComponent, inject, ref,
+  computed, defineComponent, inject, onMounted, ref,
   watch,
 } from 'vue';
 import OAuthClient from '@girder/oauth-client';
@@ -15,6 +15,8 @@ import Charts from '../components/Charts/Charts.vue';
 import MapLayerTableGraph from '../components/TabularData/MapLayerTableGraph.vue';
 import UVdatApi from '../api/UVDATApi';
 import VectorFeatureSearch from '../components/VectorFeatureSearch/VectorFeatureSearch.vue';
+// eslint-disable-next-line import/no-cycle
+import { toggleLayerSelection } from '../map/mapLayers';
 
 export default defineComponent({
   components: {
@@ -30,6 +32,7 @@ export default defineComponent({
   },
   setup() {
     const oauthClient = inject<OAuthClient>('oauthClient');
+    const loading = ref(false);
     const drawerOpen = ref(true);
     if (oauthClient === undefined) {
       throw new Error('Must provide "oauthClient" into component.');
@@ -46,6 +49,13 @@ export default defineComponent({
       }
     };
 
+    onMounted(async () => {
+      loading.value = true;
+      const layers = await MapStore.getDisplayConfiguration(true);
+      loading.value = false;
+      layers.forEach((layer) => toggleLayerSelection(layer));
+    });
+
     watch(MapStore.userIsStaff, () => {
       if (!MapStore.userIsStaff.value) {
         MapStore.proModeButtonEnabled.value = false;
@@ -142,6 +152,7 @@ export default defineComponent({
       activeSideBar: MapStore.activeSideBarCard,
       rightSideBarPadding,
       SideBarHasData,
+      loading,
     };
   },
 });
@@ -278,6 +289,9 @@ export default defineComponent({
       </template>
     </v-tooltip>
     <v-spacer />
+    <v-btn v-if="userIsStaff" to="/admin">
+      Admin
+    </v-btn>
     <v-btn @click="logInOrOut">
       {{ loginText }}
     </v-btn>
@@ -303,7 +317,7 @@ export default defineComponent({
     >
       <source-selection />
     </v-navigation-drawer>
-    <v-row dense class="fill-height">
+    <v-row v-if="!loading" dense class="fill-height">
       <v-col class="d-flex flex-column fill-height" style="min-height: 90vh">
         <MapVue />
         <MapLayerTableGraph v-if="mapLayerVectorGraphsVisible && mapLayerFeatureGraphs.length" />
diff --git a/client/src/views/SourceSelection.vue b/client/src/views/SourceSelection.vue
index d7a3b9a..ec07b26 100644
--- a/client/src/views/SourceSelection.vue
+++ b/client/src/views/SourceSelection.vue
@@ -1,6 +1,7 @@
 <script lang="ts">
 import {
   Ref, computed, defineComponent, onMounted, ref,
+  watch,
 } from 'vue';
 import Collection from '../components/DataSelection/Collection.vue';
 import Datasets from '../components/DataSelection/Datasets.vue';
@@ -19,12 +20,18 @@ export default defineComponent({
   },
   setup() {
     onMounted(() => MapStore.loadCollections()); // Load for tab display if collections exists
-    const tab: Ref<'Scenarios' | 'Datasets' | 'Collections' | 'Metadata Filters'> = ref('Scenarios');
+    const tab: Ref<'Scenarios' | 'Datasets' | 'Collections' | 'Metadata'> = ref('Scenarios');
     const selectedLayersCount = computed(() => MapStore.selectedMapLayers.value.length);
+    watch(MapStore.displayConfiguration, () => {
+      if (MapStore.displayConfiguration.value.default_tab) {
+        tab.value = MapStore.displayConfiguration.value.default_tab;
+      }
+    });
     return {
       tab,
       selectedLayersCount,
       collectionList: MapStore.availableCollections,
+      displayConfig: MapStore.displayConfiguration,
     };
   },
 });
@@ -38,13 +45,13 @@ export default defineComponent({
       <v-tab value="Scenarios" class="tab">
         Scenarios
       </v-tab>
-      <v-tab value="Datasets" class="tab">
+      <v-tab v-if="displayConfig.enabled_ui.includes('Datasets')" value="Datasets" class="tab">
         Datasets
       </v-tab>
-      <v-tab v-if="collectionList.length" value="Collections" class="tab">
+      <v-tab v-if="collectionList.length && displayConfig.enabled_ui.includes('Collections')" value="Collections" class="tab">
         Collections
       </v-tab>
-      <v-tab value="Metadata Filters" class="tab">
+      <v-tab v-if="displayConfig.enabled_ui.includes('Metadata')" value="Metadata" class="tab">
         Metadata <v-icon>mdi-filter</v-icon>
       </v-tab>
     </v-tabs>
@@ -55,7 +62,7 @@ export default defineComponent({
     <collection
       v-else-if="tab === 'Collections'"
     />
-    <MetadataLayerFilter v-else-if="tab === 'Metadata Filters'" />
+    <MetadataLayerFilter v-else-if="tab === 'Metadata'" />
   </div>
   <v-divider v-if="selectedLayersCount" />
   <selected />
diff --git a/docker-compose.override.yml b/docker-compose.override.yml
index 0c38a91..a13b5e3 100644
--- a/docker-compose.override.yml
+++ b/docker-compose.override.yml
@@ -43,15 +43,6 @@ services:
       - minio
     platform: linux/amd64
 
-  gen-vector-basemap:
-    build:
-      context: ./docker/tilemaker
-      dockerfile: Dockerfile
-    restart: no
-    volumes:
-      - vector-workdir:/work
-      - ./client/public/vectortiles:/data
-
   docs:
     image: minidocks/mkdocs
     working_dir: /docs
diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml
index 94665c7..a236dde 100644
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -63,15 +63,6 @@ services:
       - minio
     platform: linux/amd64
 
-  gen-vector-basemap:
-    build:
-      context: ./docker/tilemaker
-      dockerfile: Dockerfile
-    restart: no
-    volumes:
-      - vector-workdir:/work
-      - ./client/public/vectortiles:/data
-
   web:
     build:
       context: .
diff --git a/sample_data/google.json b/sample_data/google.json
new file mode 100644
index 0000000..495dbf5
--- /dev/null
+++ b/sample_data/google.json
@@ -0,0 +1,139 @@
+[
+    {
+        "type": "Context",
+        "name": "Google Neural Hydrology",
+        "default_map_center": [
+            34.8019,
+            -86.1794
+        ],
+        "default_map_zoom": 6,
+        "datasets": [
+            {
+                "name": "Google Neural Hydrology",
+                "description": "Google Neural Hydrology",
+                "category": "Google Neural Hydrology",
+                "metadata": {},
+                "files": [
+                    {
+                        "name": "Google Neural Hydrology Data",
+                        "path": "./data/GoogleNeuralHydrology/CAMEL_USGS_Stats.geojson",
+                        "url": "https://data.kitware.com/api/v1/file/67e579ae3e5f3e5e96b97cb5/download",
+                        "type": "geojson",
+                        "metadata": {
+                            "tabular": {
+                                "path": "./data/GoogleNeuralHydrology/combined.json",
+                                "name": "Google Neural Hydrology Tabular Data",
+                                "url": "https://data.kitware.com/api/v1/file/67e579d63e5f3e5e96b97cb8/download",
+                                "featurePropertyMatcher": "hru_id"
+                            },
+                            "default_style": {
+                                "layers": {
+                                    "fill": {
+                                        "color": "#888888",
+                                        "enabled": true,
+                                        "selectable": "singleSelect",
+                                        "selectColor": "#00FFFF"
+                                    },
+                                    "line": {
+                                        "size": 1,
+                                        "color": "#000000",
+                                        "enabled": true
+                                    },
+                                    "text": {
+                                        "color": "#888888",
+                                        "enabled": false
+                                    },
+                                    "circle": {
+                                        "size": 3,
+                                        "color": "#888888",
+                                        "enabled": false
+                                    },
+                                    "fill-extrusion": {
+                                        "color": "#888888",
+                                        "enabled": false
+                                    }
+                                },
+                                "vectorFeatureTableGraphs": [
+                                    {
+                                        "name": "QObs(mm/d)_obs",
+                                        "type": "GoogleNeuralHydrology",
+                                        "xAxis": "unix_time",
+                                        "yAxis": "QObs(mm/d)_obs",
+                                        "indexer": "hru_id",
+                                        "xAxisLabel": "Date",
+                                        "yAxisLabel": "QObs(mm/d)_obs"
+                                    },
+                                    {
+                                        "name": "QObs(mm/d)_sim",
+                                        "type": "GoogleNeuralHydrology",
+                                        "xAxis": "unix_time",
+                                        "yAxis": "QObs(mm/d)_sim",
+                                        "indexer": "hru_id",
+                                        "xAxisLabel": "Date",
+                                        "yAxisLabel": "QObs(mm/d)_sim"
+                                    },
+                                    {
+                                        "name": "Obs - Sim",
+                                        "type": "GoogleNeuralHydrology",
+                                        "xAxis": "unix_time",
+                                        "yAxis": "Obs - Sim",
+                                        "indexer": "hru_id",
+                                        "xAxisLabel": "Date",
+                                        "yAxisLabel": "Obs - Sim"
+                                    },
+                                    {
+                                        "name": "Percentage Off",
+                                        "type": "GoogleNeuralHydrology",
+                                        "xAxis": "unix_time",
+                                        "yAxis": "Percentage Off",
+                                        "indexer": "hru_id",
+                                        "xAxisLabel": "Date",
+                                        "yAxisLabel": "Percentage Off"
+                                    }
+                                ],
+                                "mapLayerFeatureTableGraphs": [
+                                    {
+                                        "name": "QObs(mm/d)_obs",
+                                        "type": "GoogleNeuralHydrology",
+                                        "xAxis": "unix_time",
+                                        "yAxis": "QObs(mm/d)_obs",
+                                        "indexer": "hru_id",
+                                        "xAxisLabel": "Date",
+                                        "yAxisLabel": "QObs(mm/d)_obs"
+                                    },
+                                    {
+                                        "name": "QObs(mm/d)_sim",
+                                        "type": "GoogleNeuralHydrology",
+                                        "xAxis": "unix_time",
+                                        "yAxis": "QObs(mm/d)_sim",
+                                        "indexer": "hru_id",
+                                        "xAxisLabel": "Date",
+                                        "yAxisLabel": "QObs(mm/d)_sim"
+                                    },
+                                    {
+                                        "name": "Obs - Sim",
+                                        "type": "GoogleNeuralHydrology",
+                                        "xAxis": "unix_time",
+                                        "yAxis": "Obs - Sim",
+                                        "indexer": "hru_id",
+                                        "xAxisLabel": "Date",
+                                        "yAxisLabel": "Obs - Sim"
+                                    },
+                                    {
+                                        "name": "Percentage Off",
+                                        "type": "GoogleNeuralHydrology",
+                                        "xAxis": "unix_time",
+                                        "yAxis": "Percentage Off",
+                                        "indexer": "hru_id",
+                                        "xAxisLabel": "Date",
+                                        "yAxisLabel": "Percentage Off"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    }
+]
\ No newline at end of file
diff --git a/sample_data/phase2_screenshots.json b/sample_data/phase2_screenshots.json
new file mode 100644
index 0000000..7fc4a8c
--- /dev/null
+++ b/sample_data/phase2_screenshots.json
@@ -0,0 +1,305 @@
+[
+  {
+    "type": "Context",
+    "name": "DIVERS-H",
+    "default_map_center": [34.8019, -86.1794],
+    "default_map_zoom": 6,
+    "datasets": [
+      {
+        "name": "DIVERS-H",
+        "description": "DIVERS-H PowerPlant data",
+        "category": "merged",
+        "metadata": {},
+        "files": [
+          {
+            "name": "PowerPlant_CNRM-CM6-1_ssp585_r4i1p1f2_tabular",
+            "path": "./data/DIVERS-H/PowerPlants/TVAPowerPlants.geojson",
+            "url": "https://data.kitware.com/api/v1/file/67c0deb5de1cd5c0d8ba66ce/download",
+            "type": "geojson",
+            "metadata": {
+              "tabular": {
+                "path": "./data/DIVERS-H/PowerPlants/PowerPlant_CNRM-CM6-1_ssp585_r4i1p1f2_tabular.json",
+                "name": "PowerPlant_CNRM-CM6-1_ssp585_r4i1p1f2_tabular_data",
+                "url": "https://data.kitware.com/api/v1/file/67c0deb5de1cd5c0d8ba66d1/download",
+                "featurePropertyMatcher": "Plant_Code"
+              },
+              "tags": {
+                "filters": {
+                  "Model": "CNRM-CM6-1",
+                  "Scenario": "ssp585",
+                  "Ensemble": "r4i1p1f2",
+                  "Input/Output": "Ouput"
+                }
+              },
+              "default_style": {
+                "layers": {
+                  "fill": {
+                    "color": "#888888",
+                    "enabled": false
+                  },
+                  "line": {
+                    "size": 1,
+                    "color": "#000000",
+                    "enabled": false
+                  },
+                  "text": {
+                    "size": {
+                      "type": "SizeZoom",
+                      "zoomLevels": [
+                        [10, 12],
+                        [12, 9],
+                        [16, 10]
+                      ]
+                    },
+                    "text": {
+                      "key": "Plant_Name"
+                    },
+                    "zoom": {
+                      "max": 24,
+                      "min": 7
+                    },
+                    "color": "#000000",
+                    "enabled": true
+                  },
+                  "circle": {
+                    "color": "#888888",
+                    "enabled": true,
+                    "selectable": "singleSelect",
+                    "selectColor": "#00FFFF"
+                  },
+                  "fill-extrusion": {
+                    "color": "#888888",
+                    "enabled": false
+                  }
+                },
+                "properties": {
+                  "selectionDisplay": true,
+                  "availableProperties": {
+                    "Total_MW": {
+                      "key": "Total_MW",
+                      "max": 3661.7,
+                      "min": 0.9,
+                      "type": "number",
+                      "display": true,
+                      "tooltip": false,
+                      "description": "",
+                      "displayName": "Total_MW"
+                    },
+                    "tech_desc": {
+                      "key": "tech_desc",
+                      "type": "string",
+                      "values": [
+                        "Batteries; Solar Photovoltaic;",
+                        "Conventional Hydroelectric",
+                        "Conventional Steam Coal",
+                        "Conventional Steam Coal; Natural Gas Fired Combustion Turbine;",
+                        "Hydroelectric Pumped Storage",
+                        "Hydroelectric Pumped Storage; Conventional Hydroelectric;",
+                        "Landfill Gas",
+                        "Natural Gas Fired Combined Cycle",
+                        "Natural Gas Fired Combined Cycle; Natural Gas Fired Combustion Turbine;",
+                        "Natural Gas Fired Combined Cycle; Petroleum Liquids;",
+                        "Natural Gas Fired Combustion Turbine",
+                        "Natural Gas Internal Combustion Engine; Petroleum Liquids;",
+                        "Nuclear",
+                        "Onshore Wind Turbine",
+                        "Other Gases",
+                        "Other Waste Biomass; Petroleum Liquids;",
+                        "Petroleum Liquids",
+                        "Solar Photovoltaic",
+                        "Wood/Wood Waste Biomass"
+                      ],
+                      "display": true,
+                      "tooltip": false,
+                      "description": "",
+                      "displayName": "tech_desc"
+                    },
+                    "Plant_Code": {
+                      "key": "Plant_Code",
+                      "max": 65642,
+                      "min": 20,
+                      "type": "number",
+                      "display": true,
+                      "tooltip": false,
+                      "description": "",
+                      "displayName": "Plant_Code"
+                    },
+                    "Plant_Name": {
+                      "key": "Plant_Name",
+                      "type": "string",
+                      "unique": 121,
+                      "display": true,
+                      "tooltip": false,
+                      "searchable": true,
+                      "description": "",
+                      "displayName": "Plant_Name"
+                    }
+                  }
+                },
+                "vectorFeatureTableGraphs": [
+                  {
+                    "name": "tas",
+                    "type": "tas_pr_evspsbl_P_minus_E",
+                    "xAxis": "unix_time",
+                    "yAxis": "tas",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": "tas"
+                  },
+                  {
+                    "name": "pr",
+                    "type": "tas_pr_evspsbl_P_minus_E",
+                    "xAxis": "unix_time",
+                    "yAxis": "pr",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": "pr"
+                  },
+                  {
+                    "name": "evspsbl",
+                    "type": "tas_pr_evspsbl_P_minus_E",
+                    "xAxis": "unix_time",
+                    "yAxis": "evspsbl",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": "evspsbl"
+                  },
+                  {
+                    "name": "P_minus_E",
+                    "type": "tas_pr_evspsbl_P_minus_E",
+                    "xAxis": "unix_time",
+                    "yAxis": "P_minus_E",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": "P_minus_E"
+                  }
+                ],
+                "mapLayerFeatureTableGraphs": [
+                  {
+                    "name": "tas",
+                    "type": "tas_pr_evspsbl_P_minus_E",
+                    "xAxis": "unix_time",
+                    "yAxis": "tas",
+                    "indexer": "Plant_Name",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": "tas"
+                  },
+                  {
+                    "name": "pr",
+                    "type": "tas_pr_evspsbl_P_minus_E",
+                    "xAxis": "unix_time",
+                    "yAxis": "pr",
+                    "indexer": "Plant_Name",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": "pr"
+                  },
+                  {
+                    "name": "evspsbl",
+                    "type": "tas_pr_evspsbl_P_minus_E",
+                    "xAxis": "unix_time",
+                    "yAxis": "evspsbl",
+                    "indexer": "Plant_Name",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": "evspsbl"
+                  },
+                  {
+                    "name": "P_minus_E",
+                    "type": "tas_pr_evspsbl_P_minus_E",
+                    "xAxis": "unix_time",
+                    "yAxis": "P_minus_E",
+                    "indexer": "Plant_Name",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": "P_minus_E"
+                  }
+                ]
+              }
+            }
+          },
+          {
+            "name": "PminusE_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_2015-2055",
+            "path": "./data/DIVERS-H/Output/PminusE_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_2015-2055.nc",
+            "url": "https://data.kitware.com/api/v1/file/67c0dea9de1cd5c0d8ba66a4/download",
+            "type": "netcdf",
+            "metadata": {
+              "generate": [
+                {
+                  "name": "PminusE_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_2015-2055",
+                  "x_variable": "lon",
+                  "y_variable": "lat",
+                  "variable": "P_minus_E",
+                  "sliding_variable": "time",
+                  "color_map": "turbo"
+                }
+              ],
+              "tags": {
+                "filters": {
+                  "Variable": "PminusE",
+                  "Model": "CNRM-CM6-1",
+                  "Scenario": "ssp585",
+                  "Ensemble": "r4i1p1f2",
+                  "Grid": null,
+                  "Time Range": "2015-2055",
+                  "Input/Output": "Output"
+                }
+              }
+            }
+          },
+          {
+            "name": "tas_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_gr_201501-210012",
+            "path": "./data/DIVERS-H/Input/tas_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_gr_201501-210012.nc",
+            "url": "https://data.kitware.com/api/v1/file/67c0dea0de1cd5c0d8ba667a/download",
+            "type": "netcdf",
+            "metadata": {
+              "generate": [
+                {
+                  "name": "tas_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_gr_201501-210012",
+                  "x_variable": "lon",
+                  "y_variable": "lat",
+                  "variable": "tas",
+                  "sliding_variable": "time",
+                  "color_map": "Reds"
+                }
+              ],
+              "tags": {
+                "filters": {
+                  "Variable": "tas",
+                  "Model": "CNRM-CM6-1",
+                  "Scenario": "ssp585",
+                  "Ensemble": "r4i1p1f2",
+                  "Grid": "gr",
+                  "Time Range": "201501-210012",
+                  "Input/Output": "Input"
+                }
+              }
+            }
+          },
+          {
+            "name": "evspsbl_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_gr_201501-210012",
+            "path": "./data/DIVERS-H/Input/evspsbl_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_gr_201501-210012.nc",
+            "url": "https://data.kitware.com/api/v1/file/67c0de9ede1cd5c0d8ba666e/download",
+            "type": "netcdf",
+            "metadata": {
+              "generate": [
+                {
+                  "name": "evspsbl_Amon_CNRM-CM6-1_ssp585_r4i1p1f2_gr_201501-210012",
+                  "x_variable": "lon",
+                  "y_variable": "lat",
+                  "variable": "evspsbl",
+                  "sliding_variable": "time",
+                  "color_map": "Blues"
+                }
+              ],
+              "tags": {
+                "filters": {
+                  "Variable": "evspsbl",
+                  "Model": "CNRM-CM6-1",
+                  "Scenario": "ssp585",
+                  "Ensemble": "r4i1p1f2",
+                  "Grid": "gr",
+                  "Time Range": "201501-210012",
+                  "Input/Output": "Input"
+                }
+              }
+            }
+          }
+        ]
+      }
+    ]
+  }
+]
diff --git a/scripts/googleneuralhydrology/README.md b/scripts/googleneuralhydrology/README.md
new file mode 100644
index 0000000..63ebac6
--- /dev/null
+++ b/scripts/googleneuralhydrology/README.md
@@ -0,0 +1,30 @@
+# Google Neural Hydrology Processing
+
+## extractHruIds.py
+
+This when given a geojson with properties.hru_id will extract all of the HRUIds from the geojson and make sure they are 8 digit codes and place them into a single list.
+This was used to create a small sample that could be used to run testing data on
+
+## runExperiment.py 
+
+`python runExperiment.py hru_ids.json`
+
+Requires the `run_demo.sh` script as well as properly downloading the docker and relevant data for running Google Neural Hydrology.
+This file will go through the hru_ids.json and will run the experiments on each one and then extract the resulting .nc file and name it to the hru_id for further processing
+
+# subSampleHruIds.py
+
+`python subSampleHruIds.py camelsData.geojson hru_ids.json`
+
+Takes the base camerlsData.geojson with all hru_ids and updates the hru_ids to be an 8 digit code with leading zeros.  I've also updated this to gather the USGS gauge data and add it as a point as well as transfer some information betwene the two Features in the geojson such as Name and other information.
+Outputs a new geojson file 'matching_hru_ids.geojson' as well as HRU_AREA_MAP.json.  The second file is used for converting USGS daily calculations from cuft/s to mm/d values.
+
+# nctoJson.py
+
+`python nsToJson.py ./folder`
+
+Takes all *.nc files from the runExperiment.py results and converts them into row data that can be used by DIVERS-H.  It als creates a nc_stat_mapping tool so that the stats can be added to the output geojson from subSampleHruIds.py.  Results by default in a ncToJSONOutput.json as well as a nc_stat_mapping.json file
+
+# addStatsToGeoJSON.py
+
+Takes the output from nctoJson.py (nc_stat_mapping.json) and adds this information to the output from subSampleHruIds.py so that way sample data can be 
\ No newline at end of file
diff --git a/scripts/googleneuralhydrology/addStatsToGeoJSON.py b/scripts/googleneuralhydrology/addStatsToGeoJSON.py
new file mode 100644
index 0000000..e3c137a
--- /dev/null
+++ b/scripts/googleneuralhydrology/addStatsToGeoJSON.py
@@ -0,0 +1,60 @@
+import click
+import json
+import geojson
+from collections import defaultdict
+
+def flatten_dict(d, parent_key='', sep='.', result=None):
+    """Flattens a nested dictionary."""
+    if result is None:
+        result = {}
+    for key, value in d.items():
+        new_key = f"{parent_key}{sep}{key}" if parent_key else key
+        if isinstance(value, dict):
+            flatten_dict(value, new_key, sep=sep, result=result)
+        else:
+            result[new_key] = value
+    return result
+
+def process_geojson(geojson_file, json_file, output_file):
+    """Process GeoJSON and JSON to combine data based on hru_id."""
+    
+    # Load the geojson file
+    with open(geojson_file, 'r') as f:
+        geo_data = geojson.load(f)
+    
+    # Load the JSON file with HRU stats
+    with open(json_file, 'r') as f:
+        stats_data = json.load(f)
+
+    # Iterate over the features in the GeoJSON file
+    for feature in geo_data['features']:
+        hru_id = feature['properties'].get('hru_id')
+        
+        if hru_id and str(hru_id) in stats_data:
+            stats = stats_data[str(hru_id)]
+            
+            # Flatten the statistics for 'Obs-Sim' and 'Percentage_Off'
+            flattened_stats = {}
+            for category in ['Obs-Sim', 'Percentage_Off']:
+                if category in stats:
+                    flattened_stats.update(flatten_dict(stats[category], parent_key=category))
+            
+            # Add the flattened stats to the GeoJSON feature properties
+            feature['properties'].update(flattened_stats)
+    
+    # Save the modified GeoJSON to the output file
+    with open(output_file, 'w') as f:
+        geojson.dump(geo_data, f, separators=(',', ':'))
+
+    click.echo(f"Processed GeoJSON saved to {output_file}")
+
+@click.command()
+@click.argument('geojson_file', default='matching_hru_ids.geojson', type=click.Path(exists=True))
+@click.argument('json_file', default='nc_stat_mapping.json', type=click.Path(exists=True))
+@click.argument('output_file', default='CAMEL_USGS_Stats.geojson', type=click.Path())
+def process_files(geojson_file, json_file, output_file):
+    """CLI tool to merge HRU stats from a JSON file into a GeoJSON file."""
+    process_geojson(geojson_file, json_file, output_file)
+
+if __name__ == "__main__":
+    process_files()
diff --git a/scripts/googleneuralhydrology/combineRowData.py b/scripts/googleneuralhydrology/combineRowData.py
new file mode 100644
index 0000000..4798681
--- /dev/null
+++ b/scripts/googleneuralhydrology/combineRowData.py
@@ -0,0 +1,43 @@
+import click
+import json
+
+@click.command()
+@click.argument("json_file1", type=click.Path(exists=True))
+@click.argument("json_file2", type=click.Path(exists=True))
+@click.argument("output", default="combined.json", type=click.Path())
+def combine_json(json_file1, json_file2, output):
+    """Combine two JSON files by concatenating arrays for matching keys."""
+    
+    # Load first JSON file
+    with open(json_file1, "r") as f:
+        data1 = json.load(f)
+    
+    # Load second JSON file
+    with open(json_file2, "r") as f:
+        data2 = json.load(f)
+    
+    # Merge data
+    combined_data = {}
+    all_keys = set(data1.keys()).union(data2.keys())
+    
+    for key in all_keys:
+        value1 = data1.get(key, None)
+        value2 = data2.get(key, None)
+        
+        if isinstance(value1, list) and isinstance(value2, list):
+            combined_data[key] = value1 + value2
+        elif isinstance(value1, list):
+            combined_data[key] = value1
+        elif isinstance(value2, list):
+            combined_data[key] = value2
+        else:
+            ValueError('Key is not valid in either data')
+    
+    # Save combined JSON
+    with open(output, "w") as f:
+        json.dump(combined_data, f, separators=(',', ':'))
+    
+    click.echo(f"Combined JSON saved to {output}")
+
+if __name__ == "__main__":
+    combine_json()
diff --git a/scripts/googleneuralhydrology/createAndUploadInputJSON.py b/scripts/googleneuralhydrology/createAndUploadInputJSON.py
new file mode 100644
index 0000000..f3da232
--- /dev/null
+++ b/scripts/googleneuralhydrology/createAndUploadInputJSON.py
@@ -0,0 +1,167 @@
+import os
+import json
+import re
+import click
+import xarray as xr
+from girder_client import GirderClient
+import matplotlib.pyplot as plt
+
+baseApiKey = 'GIRDER API KEY HERE'
+
+
+def authenticate(client: GirderClient):
+    client.authenticate(apiKey=baseApiKey)
+
+
+def create_folder(client, parent_id, name):
+    folder = client.createFolder(parent_id, name, reuseExisting=True)
+    return folder['_id']
+
+
+
+
+def get_public_folder(gc: GirderClient):
+    current_user = gc.sendRestRequest('GET', 'user/me')
+    userId = current_user['_id']
+    folders = gc.sendRestRequest('GET', f'folder?parentType=user&parentId={userId}&text=Public&limit=50&sort=lowerName&sortdir=1')
+    if len(folders) > 0:
+        uploadFolder = folders[0]
+    else:
+        print('No folder found for the user')
+    return uploadFolder
+
+
+
+
+def upload_data(client: GirderClient, remote_folder_id, base_geojson, base_tab_json, base_default_style):
+    file_metadata = []
+    existing_base_geojson = list(client.listItem(remote_folder_id, name=base_geojson))
+    existing_base_tab = list(client.listItem(remote_folder_id, name=base_tab_json))
+    powerplant_url = ''
+    base_default_style_dict= {}
+    with open(base_default_style, "r") as f:
+        base_default_style_dict = json.load(f)  # data is now a Python dictionary
+
+    if len(existing_base_geojson) > 0:
+        geojson_id = existing_base_geojson[0]['_id']
+        geojson_url = f'https://data.kitware.com/api/v1/file/{geojson_id}/download'
+    else:
+        item = client.uploadFileToFolder(remote_folder_id, base_geojson)
+        geojson_url = f'https://data.kitware.com/api/v1/file/{item["_id"]}/download'
+
+    if len(existing_base_tab) > 0:
+        tab_id = existing_base_tab[0]['_id']
+        tab_url = f'https://data.kitware.com/api/v1/file/{tab_id}/download'
+    else:
+        item = client.uploadFileToFolder(remote_folder_id, base_tab_json)
+        tab_url = f'https://data.kitware.com/api/v1/file/{item["_id"]}/download'
+
+
+    # now we open the file and check for the table name
+    with open(base_tab_json, "r") as f:
+        tabular_data = json.load(f)  # data is now a Python dictionary
+    table_name  = ''
+    headers = []
+    for key in tabular_data.keys():
+        tab_data_charts = tabular_data[key]
+        break
+    vectorFeatureTableGraphs = []
+    mapLayerFeatureTableGraphs = []
+    for tab_data in tab_data_charts:
+        headers = tab_data['header']
+        table_name = tab_data['type']
+        for item in headers:
+            if item in ['time', 'date_str', 'year_nu', 'month_nu', 'day_nu']:
+                continue
+            if item != 'unix_time':
+                vectorFeatureTableGraphs.append({
+                    "name": item,
+                    "type": table_name,
+                    "xAxis": "unix_time",
+                    "yAxis": item,
+                    "indexer": "hru_id",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": item
+                })
+                mapLayerFeatureTableGraphs.append({
+                    "name": item,
+                    "type": table_name,
+                    "xAxis": "unix_time",
+                    "yAxis": item,
+                    "indexer": "hru_id",
+                    "xAxisLabel": "Date",
+                    "yAxisLabel": item
+                })
+    default_style = base_default_style_dict.copy()
+    default_style['vectorFeatureTableGraphs'] = vectorFeatureTableGraphs
+    default_style['mapLayerFeatureTableGraphs'] = mapLayerFeatureTableGraphs
+    print(default_style['mapLayerFeatureTableGraphs'])
+    file_metadata.append({
+        'name': f'Google Neural Hydrology Data',
+        'path': f'./data/GoogleNeuralHydrology/{base_geojson}',
+        'url': geojson_url,
+        'type': 'geojson',
+        'metadata': {
+            "tabular": {
+                'path': f'./data/GoogleNeuralHydrology/{base_tab_json}',
+                'name': f'Google Neural Hydrology Tabular Data',
+                'url': tab_url,
+                'featurePropertyMatcher': 'hru_id'
+            },
+            'default_style': default_style,
+        }
+    })
+    return file_metadata
+
+
+@click.command()
+@click.argument('base_geojson', type=click.Path(exists=True))
+@click.argument('base_tabular', type=click.Path(exists=True))
+@click.argument('base_default_style', default='base_default_style.json', type=click.Path(exists=True))
+@click.option('--save-path', default='uploaded_file_context.json', help='Path to save the context JSON.')
+def main(base_geojson, base_tabular, base_default_style, save_path):
+    client = GirderClient(apiUrl='https://data.kitware.com/api/v1')
+    authenticate(client)
+
+    # Get the Public folder ID
+    public_folder = get_public_folder(client)
+    uvdat_folder = list(client.listFolder(public_folder['_id'], name='UVDAT'))[0]
+
+    # Create GoogleNeuralHydrology folder
+    google_hydrology_id = create_folder(client, uvdat_folder['_id'], 'GoogleNeuralHydrology')
+
+    # Create Input and Output folders
+
+    # Upload files
+
+    tabular_files = upload_data(client, google_hydrology_id, base_geojson, base_tabular, base_default_style)
+
+    # Save context JSON
+    context = {
+        "type": "Context",
+        "name": "Google Neural Hydrology",
+        "default_map_center": [
+            34.8019,
+            -86.1794
+        ],
+        "default_map_zoom": 6,
+        "datasets": []
+    }
+    google_dataset = {
+        "name": "Google Neural Hydrology",
+        "description": "Google Neural Hydrology",
+        "category": "Google Neural Hydrology",
+        "metadata": {},
+        "files": tabular_files
+    }
+
+
+    context['datasets'].append(google_dataset)
+    with open(save_path, 'w') as f:
+        json.dump([context], f, indent=4)
+
+    click.echo(f'Context with download URLs saved to {save_path}')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/googleneuralhydrology/extractHruIds.py b/scripts/googleneuralhydrology/extractHruIds.py
new file mode 100644
index 0000000..97e1fab
--- /dev/null
+++ b/scripts/googleneuralhydrology/extractHruIds.py
@@ -0,0 +1,27 @@
+import json
+import click
+
+@click.command()
+@click.argument("geojson_file", type=click.Path(exists=True))
+@click.argument("output_file", type=click.Path())
+def extract_hru_ids(geojson_file, output_file):
+    """Extracts hru_id from a GeoJSON file and saves them as a JSON array."""
+    
+    with open(geojson_file, "r") as f:
+        geojson_data = json.load(f)
+
+    # Extract hru_id from each feature and ensure it's 8 digits with leading zeros
+    hru_ids = [
+        f"{int(feature['properties']['hru_id']):08d}"
+        for feature in geojson_data.get("features", [])
+        if "hru_id" in feature.get("properties", {})
+    ]
+
+    # Save output JSON
+    with open(output_file, "w") as f:
+        json.dump(hru_ids, f, indent=4)
+
+    click.echo(f"Extracted {len(hru_ids)} HRU IDs to {output_file}")
+
+if __name__ == "__main__":
+    extract_hru_ids()
diff --git a/scripts/googleneuralhydrology/flatJsonToJson.py b/scripts/googleneuralhydrology/flatJsonToJson.py
new file mode 100644
index 0000000..a7f601f
--- /dev/null
+++ b/scripts/googleneuralhydrology/flatJsonToJson.py
@@ -0,0 +1,34 @@
+import json
+import click
+
+@click.command()
+@click.argument('input', required=True, type=click.Path(exists=True))
+@click.argument('output', required=True, type=click.Path())
+def convert_file(input, output):
+    """Convert a line-by-line JSON file to a single JSON object."""
+    result = {}
+
+    # Read the input file line by line
+    with open(input, 'r') as infile:
+        for line in infile:
+            try:
+                # Parse the JSON object from the line
+                data = json.loads(line.strip())
+                # Extract the 8-digit number from the "name" field
+                name = data.get("name", "")
+                site_number = name.split('_')[0] if name else None
+                
+                if site_number and len(site_number) == 8:  # Check if the site_number is valid (8 digits)
+                    # Add the data to the result dictionary with the 8-digit number as the key
+                    result[site_number] = {k: v for k, v in data.items() if k != "name"}  # Exclude "name" field
+            except json.JSONDecodeError:
+                print(f"Skipping invalid JSON line: {line.strip()}")
+
+    # Write the result to the output file in a dense JSON format (no indentation or newlines)
+    with open(output, 'w') as outfile:
+        json.dump(result, outfile, separators=(',', ':'))
+
+    print(f"Conversion complete. Output written to {output}")
+
+if __name__ == '__main__':
+    convert_file()
diff --git a/scripts/googleneuralhydrology/getDailyStats.py b/scripts/googleneuralhydrology/getDailyStats.py
new file mode 100644
index 0000000..0221338
--- /dev/null
+++ b/scripts/googleneuralhydrology/getDailyStats.py
@@ -0,0 +1,168 @@
+import click
+import json
+import pathlib
+import pandas as pd
+from dataretrieval import nwis
+import numpy as np
+import time
+import calendar
+import datetime
+import os
+
+def get_unix_time(row, year_index, month_index, day_index):
+    if year_index is not None:
+        year = int(row[year_index])
+    else:
+        year = 1970
+    if month_index is not None:
+        month = int(row[month_index])
+    else:
+        month = 1
+    if day_index is not None:
+        day = int(row[day_index])
+    else:
+        day = 1
+    if month < 1 or month > 12:
+        month = 1
+    if day < 1 or day > 31:
+        day = 1
+
+    return calendar.timegm(time.strptime(f"{year}-{month}-{day}", "%Y-%m-%d"))
+
+@click.command()
+@click.option('-p', '--param-codes', default=['00060'], multiple=True, required=True, help="List of parameter codes to query.")
+@click.option('--input', required=True, type=click.Path(exists=True), help="JSON file containing an array of site numbers.")
+@click.option('--start-date', default='1989-10-01', help="Start date for the data query.")
+@click.option('--end-date', default='1999-09-30', help="End date for the data query.")
+@click.option('--output', default='./dailyStats.json', help="Output JSON file where the results will be saved.")
+@click.option('--usgs-parameters', default='../nwis/USGSParameters.tsv', type=click.Path(exists=True), help="Path to the USGSParameters.tsv file.")
+@click.option('--area-mapping', default='./HRU_AREA_MAP.json', type=click.Path(exists=True), help="Path to the HRU area mapping file.")
+def fetch_data(param_codes, input, start_date, end_date, output, usgs_parameters, area_mapping):
+    """Fetch data from NWIS and save it in a JSON format with descriptions for each table."""
+    
+    # Load the USGS parameters file
+    usgs_df = pd.read_csv(usgs_parameters, sep='\t', comment='#')
+    param_desc = dict(zip(usgs_df['parm_cd'], usgs_df['parm_nm']))
+
+    with open(input, 'r') as f:
+        site_loaded = json.load(f)  # Expecting a JSON array of site numbers
+
+    with open(area_mapping, 'r') as f:
+        area_map = json.load(f)  # Expecting a JSON array of site numbers
+
+    site_numbers = [str(item) for item in site_loaded]
+
+    if os.path.exists(output):
+        with open(output, 'r') as f:
+            processed_sites = json.load(f)  # Expecting a JSON array of site numbers
+
+        loaded_sites = processed_sites.keys()
+        site_numbers = [site for site in site_numbers if site not in loaded_sites]
+    
+    # Split the site numbers into chunks of 10 (because NWIS allows a max of 10 sites per request)
+    def split_list(l):
+        n = 10
+        for i in range(0, len(l), n):
+            yield l[i:i + n]
+    
+    site_lists = list(split_list(site_numbers))
+
+    # Open output file in append mode
+    with open(output, 'a') as f:
+        # Fetch data for each site and each report type (daily)
+        report_types = ['daily']
+        for report_type in report_types:
+            for i, site_list in enumerate(site_lists):
+                try:
+                    response = nwis.get_dv(
+                        sites=site_list,
+                        start=start_date,
+                        end=end_date,
+                        parameterCd=",".join(param_codes),
+                    )
+                    df, meta = response
+                except Exception as e:
+                    print(f"Error fetching {report_type} data for sites {site_list}: {e}")
+                    continue
+
+                # Prepare data for writing
+                site_data = process_site_data(df, meta, area_map, site_list, param_codes, param_desc)
+
+                # Append processed data to file incrementally
+                with open(output, 'a') as f:
+                    for entry in site_data:
+                        json_str = json.dumps(entry, default=lambda x: None if isinstance(x, float) and np.isnan(x) else x, separators=(',', ':'))
+                        f.write(f"{json_str}\n")  # Write each object on a single line, each key on a new line
+
+                print(f"Fetched {report_type} data for {len(site_list)} sites.")
+                
+    print(f"Results saved to {output}.")
+
+def process_site_data(df, meta, area_map, site_list, param_codes, param_desc):
+    """Process the data for a single site list."""
+    valid_index_tuples = []
+    for site, dt in df.index:
+        try:
+            valid_dt = pd.to_datetime(dt, errors='raise')  # Raise an error for invalid dates
+            valid_index_tuples.append((site, valid_dt))
+        except Exception as e:
+            print(f"Skipping site {site} due to invalid date: {dt} ({e})")
+
+    if valid_index_tuples:
+        df.index = pd.MultiIndex.from_tuples(valid_index_tuples, names=['site_number', 'datetime'])
+    else:
+        print("No valid sites found due to date errors. Skipping further processing.")
+        return []
+
+    # Add additional columns and process data
+    datetime_index = df.index.get_level_values("datetime")
+    df["date_str"] = datetime_index.strftime("%Y-%m-%d")
+    df["year_nu"] = datetime_index.year
+    df["month_nu"] = datetime_index.month
+    df["day_nu"] = datetime_index.day
+    df["unix_time"] = datetime_index.astype(int) // 10**9
+    df["site_no"] = df.index.get_level_values("site_number")
+
+    # Prepare and append the data for each site
+    site_data = []
+    endsWith = ['date_str', 'year_nu', 'month_nu', 'day_nu', 'unix_time', '00060_Mean']
+    for site_number in site_list:
+        site_data_frame = df[df['site_no'] == site_number]
+        area = area_map.get(str(site_number))
+
+        if not site_data_frame.empty:
+            site_data_frame = site_data_frame.drop(columns=['site_no', 'loc_web_ds'], errors='ignore')
+            param_headers = [col for col in site_data_frame.columns if col.endswith('_Mean')]
+            columns = site_data_frame.columns.tolist()
+            for col in columns:
+                if col not in endsWith:
+                    site_data_frame = site_data_frame.drop(columns=[col])
+            param_names = [param_desc.get(code.replace('_Mean', ''), 'Unknown parameter') for code in param_headers]
+
+            site_data_frame = site_data_frame.where(pd.notna(site_data_frame), 0)
+
+            # Prepare table object for the site
+            table_object = {
+                "name": f"{site_number}_daily",
+                "description": "This is a table of mean daily values for USGS gauges converted to mm/d for the whole watershed",
+                "type": f'USGS_gauge_daily_{"_".join(param_codes)}',
+                "header": site_data_frame.columns.tolist(),
+                "summary": generate_summary(site_data_frame, param_desc, site_data_frame.columns.tolist()),
+                "rows": site_data_frame.values.tolist(),
+            }
+            site_data.append(table_object)
+    
+    return site_data
+
+def generate_summary(df, param_desc, rows):
+    """Generate a summary object for the table."""
+    summary = {}
+    for header in rows:
+        if header.endswith('00060_Mean'):
+            summary[header] = {'type': 'parameter_cd', 'parameter_name': 'USGS cuft/s converted to mm/d for CAMELS data'}
+        elif header.endswith('_Mean'):
+            summary[header] = {'type': 'parameter_cd', 'parameter_name': param_desc.get(header.replace('_Mean', ''), 'Unknown parameter')}
+    return summary
+
+if __name__ == '__main__':
+    fetch_data()
diff --git a/scripts/googleneuralhydrology/ncToJson.py b/scripts/googleneuralhydrology/ncToJson.py
new file mode 100644
index 0000000..480d401
--- /dev/null
+++ b/scripts/googleneuralhydrology/ncToJson.py
@@ -0,0 +1,181 @@
+import click
+import xarray as xr
+import json
+import numpy as np
+import os
+import pandas as pd
+
+def summarize_data(ds, diff_values, percentage_off):
+    """Generate a summary of the dataset with min/max values for numerical variables."""
+    summary = {}
+
+    for var in ds.data_vars:
+        data = ds[var].values.flatten()  # Convert to 1D array
+        if np.issubdtype(data.dtype, np.number):  # Check if it's numeric
+            summary[var] = {
+                "type": "number",
+                "min": np.nanmin(data).item() if np.any(~np.isnan(data)) else None,
+                "max": np.nanmax(data).item() if np.any(~np.isnan(data)) else None
+            }
+
+    # Add the new computed values to the summary
+    summary["Obs - Sim"] = {
+        "type": "number",
+        "min": np.nanmin(diff_values).item() if np.any(~np.isnan(diff_values)) else None,
+        "max": np.nanmax(diff_values).item() if np.any(~np.isnan(diff_values)) else None
+    }
+
+    summary["Percentage Off"] = {
+        "type": "number",
+        "min": np.nanmin(percentage_off).item() if np.any(~np.isnan(percentage_off)) else None,
+        "max": np.nanmax(percentage_off).item() if np.any(~np.isnan(percentage_off)) else None
+    }
+
+    summary["columns"] = list(ds.data_vars.keys()) + ["Obs - Sim", "Percentage Off"]
+
+    if 'date' in ds:
+        time_values = ds['date'].values
+        start_time = pd.to_datetime(time_values.min())
+        end_time = pd.to_datetime(time_values.max())
+        unique_dates = np.unique(time_values)
+
+        summary["time"] = {
+            "type": "string",
+            "start": start_time.strftime("%Y-%m-%d"),
+            "end": end_time.strftime("%Y-%m-%d"),
+            "value_count": len(unique_dates)
+        }
+        
+        # Convert to Unix time (seconds since the Unix epoch)
+        summary["unix_time"] = {
+            "type": "number",
+            "min": start_time.value // 10**9,  # Convert to seconds
+            "max": end_time.value // 10**9,     # Convert to seconds
+            "value_count": len(unique_dates)
+        }
+
+    return summary
+
+def calculate_stats_per_site(site_data):
+    """Calculate the statistics (min, max, mean, median) per site for 'Obs - Sim' and 'Percentage Off'."""
+    stats = {}
+    stats["Obs-Sim"] = {
+        "min": float(np.nanmin(site_data["Obs - Sim"])),
+        "max": float(np.nanmax(site_data["Obs - Sim"])),
+        "mean": float(np.nanmean(site_data["Obs - Sim"])),
+        "median": float(np.nanmedian(site_data["Obs - Sim"])),
+    }
+    stats["Percentage_Off"] = {
+        "min": float(np.nanmin(site_data["Percentage Off"])),
+        "max": float(np.nanmax(site_data["Percentage Off"])),
+        "mean": float(np.nanmean(site_data["Percentage Off"])),
+        "median": float(np.nanmedian(site_data["Percentage Off"])),
+    }
+    return stats
+
+def convert_netcdf_to_json(nc_file):
+    """Load NetCDF file and convert it to JSON format."""
+    ds = xr.open_dataset(nc_file, engine="netcdf4")  # Open NetCDF file
+
+    # Extract key variables
+    time = ds["date"].values  # Extract dates
+    obs_values = np.nan_to_num(ds["QObs(mm/d)_obs"].values.flatten(), nan=0.0)
+    sim_values = np.nan_to_num(ds["QObs(mm/d)_sim"].values.flatten(), nan=0.0)
+
+    # Compute differences and percentage differences
+    diff_values = obs_values - sim_values
+    percentage_off = np.where(obs_values != 0, (diff_values / obs_values) * 100, 0)  # Avoid division by zero
+
+    # Format time correctly and convert to UNIX time
+    if "units" in ds["date"].attrs and "since" in ds["date"].attrs["units"]:
+        time_origin = ds["date"].attrs["units"].split("since")[1].strip()
+        time = pd.to_datetime(time, origin=time_origin, unit="D")
+    else:
+        time = pd.to_datetime(time)
+
+    # Convert time to UNIX time
+    unix_time = time.astype(int) // 10**9  # Convert to seconds
+
+    # Format time as strings
+    time_str = time.strftime("%Y-%m-%d").tolist()
+
+    # Construct rows with the new columns
+    rows = [
+        [time_str[i], int(unix_time[i]), float(obs_values[i]), float(sim_values[i]), float(diff_values[i]), float(percentage_off[i])]
+        for i in range(len(time))
+    ]
+
+    # Generate summary including new values
+    summary = summarize_data(ds, diff_values, percentage_off)
+
+    # Construct final JSON output
+    output_json = {
+        "summary": summary,
+        "rows": rows
+    }
+
+    return output_json, diff_values, percentage_off
+
+def process_folder(folder_path):
+    """Process all .nc files in a folder and generate a combined JSON object."""
+    json_output = {}
+    nc_stat_mapping = {}
+
+    # Loop through all .nc files in the folder
+    for filename in os.listdir(folder_path):
+        if filename.endswith(".nc"):
+            base_filename = os.path.splitext(filename)[0]  # Get base filename without extension
+            nc_file = os.path.join(folder_path, filename)
+
+            # Convert NetCDF to JSON format
+            json_data, diff_values, percentage_off = convert_netcdf_to_json(nc_file)
+
+            # Create the structure for each file
+            json_output[base_filename] = [{
+                "name": f"{base_filename}_daily",
+                "description": "This is a table of the daily values",
+                "type": f"GoogleNeuralHydrology",
+                "summary": {
+                    "time": json_data["summary"].get("time", {}),
+                    "unix_time": json_data["summary"].get("unix_time", {}),
+                    "QObs(mm/d)_obs": json_data["summary"].get("QObs(mm/d)_obs", {}),
+                    "QObs(mm/d)_sim": json_data["summary"].get("QObs(mm/d)_sim", {}),
+                    "Obs - Sim": json_data["summary"].get("Obs - Sim", {}),
+                    "Percentage Off": json_data["summary"].get("Percentage Off", {}),
+                },
+                "header": ["time", "unix_time", "QObs(mm/d)_obs", "QObs(mm/d)_sim", "Obs - Sim", "Percentage Off"],
+                "rows": json_data["rows"]
+            }]
+
+            # Calculate site statistics
+            site_data = pd.DataFrame({
+                "Obs - Sim": diff_values,
+                "Percentage Off": percentage_off
+            })
+
+            site_stats = calculate_stats_per_site(site_data)
+            site_number = base_filename  # Assuming the site number is embedded in the file name (you can adjust this part)
+            nc_stat_mapping[site_number] = site_stats
+
+    return json_output, nc_stat_mapping
+
+@click.command()
+@click.argument("folder", type=click.Path(exists=True))
+@click.argument("output", default='ncToJSONOutput.json')
+@click.argument("stat_output", default='nc_stat_mapping.json')
+def convert_netcdf(folder, output, stat_output):
+    """CLI tool to convert a NetCDF (.nc) file to JSON format."""
+    json_data, nc_stat_mapping_data = process_folder(folder)
+
+    # Save the main JSON output
+    with open(output, "w") as json_file:
+        json.dump(json_data, json_file, separators=(',', ':'))
+
+    # Save the secondary JSON output for site statistics
+    with open(stat_output, "w") as stat_file:
+        json.dump(nc_stat_mapping_data, stat_file, separators=(',', ':'))
+
+    click.echo(f"Converted {folder} to {output} and {stat_output}")
+
+if __name__ == "__main__":
+    convert_netcdf()
diff --git a/scripts/googleneuralhydrology/runExperiment.py b/scripts/googleneuralhydrology/runExperiment.py
new file mode 100644
index 0000000..73a2751
--- /dev/null
+++ b/scripts/googleneuralhydrology/runExperiment.py
@@ -0,0 +1,100 @@
+import json
+import os
+import subprocess
+import shutil
+import time
+import logging
+import click
+
+# Define the shell script path
+SHELL_SCRIPT = "/media/bryon.lewis/Elements/DIVERSH/GoogleNeuralHydrology/run_demo1.sh"  # Adjust as necessary
+EXPERIMENTS_PATH="/media/bryon.lewis/Elements/DIVERSH/GoogleNeuralHydrology/Experiments"
+# Configure logging
+logging.basicConfig(
+    filename="hru_processing.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+@click.command()
+@click.argument("hru_ids_file", type=click.Path(exists=True))
+@click.option("--wait-time", default=60, help="Max seconds to wait for test_results.nc.")
+@click.option("--poll-interval", default=5, help="Time in seconds between file existence checks.")
+def run_hru_tasks(hru_ids_file, wait_time, poll_interval):
+    """Runs a shell script for each HRU ID, waits for output, and organizes NetCDF files."""
+
+    with open(hru_ids_file, "r") as f:
+        hru_ids = json.load(f)
+
+    total_ids = len(hru_ids)
+    results_dir = "netcdf_results"
+    os.makedirs(results_dir, exist_ok=True)
+
+    logging.info(f"Starting HRU processing for {total_ids} HRU IDs.")
+
+    for index, hru_id in enumerate(hru_ids, start=1):
+        click.echo(f"Processing HRU ID {hru_id} ({index}/{total_ids})...")
+        logging.info(f"Processing HRU ID: {hru_id} ({index}/{total_ids})")
+
+        # Check if the files already exist
+        existing_netcdf_file = os.path.join(results_dir, f"{hru_id}.nc")
+        existing_exp_dir = os.path.join(EXPERIMENTS_PATH, hru_id)
+
+        if os.path.exists(existing_netcdf_file):
+            click.echo(f"Skipping HRU ID {hru_id} because the data already exists.")
+            logging.info(f"Skipping HRU ID {hru_id} because the data already exists.")
+            continue  # Skip this HRU ID
+        if os.path.exists(existing_exp_dir):
+            for root, _, files in os.walk(existing_exp_dir):
+                if "test_results.nc" in files:
+                    test_results_path = os.path.join(root, "test_results.nc")
+                    break
+            
+            if test_results_path:
+                new_file_path = os.path.join(results_dir, f"{hru_id}.nc")
+                shutil.move(test_results_path, new_file_path)
+                click.echo(f"Moved {test_results_path} → {new_file_path} ({index}/{total_ids} complete)")
+                logging.info(f"Moved {test_results_path} → {new_file_path} ({index}/{total_ids} complete)")
+                continue
+
+        # Run shell script and wait for it to complete (suppress subprocess logging)
+        cmd = [SHELL_SCRIPT, "-b", hru_id]
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            logging.info(f"Successfully executed shell script for HRU ID: {hru_id}")
+        except subprocess.CalledProcessError as e:
+            logging.error(f"Shell script failed for HRU ID {hru_id}: {e}")
+            continue
+
+        # Wait and check for the test_results.nc file
+        exp_base = os.path.join(EXPERIMENTS_PATH, hru_id)
+        test_results_path = None
+        elapsed_time = 0
+
+        while elapsed_time < wait_time:
+            for root, _, files in os.walk(exp_base):
+                if "test_results.nc" in files:
+                    test_results_path = os.path.join(root, "test_results.nc")
+                    break
+            
+            if test_results_path:
+                break  # Exit loop once the file is found
+
+            time.sleep(poll_interval)
+            click.echo(f"Waiting for test_results.nc for HRU ID {hru_id}... ({elapsed_time}s elapsed)")
+            logging.info(f"Waiting for test_results.nc for HRU ID {hru_id}... ({elapsed_time}s elapsed)")
+            elapsed_time += poll_interval
+
+        if test_results_path:
+            new_file_path = os.path.join(results_dir, f"{hru_id}.nc")
+            shutil.move(test_results_path, new_file_path)
+            click.echo(f"Moved {test_results_path} → {new_file_path} ({index}/{total_ids} complete)")
+            logging.info(f"Moved {test_results_path} → {new_file_path} ({index}/{total_ids} complete)")
+        else:
+            click.echo(f"Warning: test_results.nc not found for {hru_id} after {wait_time} seconds.")
+            logging.warning(f"test_results.nc not found for HRU ID {hru_id} after {wait_time} seconds.")
+
+    logging.info(f"HRU processing completed. {index}/{total_ids} processed.")
+
+if __name__ == "__main__":
+    run_hru_tasks()
diff --git a/scripts/googleneuralhydrology/subSampleHruIds.py b/scripts/googleneuralhydrology/subSampleHruIds.py
new file mode 100644
index 0000000..335296f
--- /dev/null
+++ b/scripts/googleneuralhydrology/subSampleHruIds.py
@@ -0,0 +1,143 @@
+import json
+import click
+import dataretrieval.nwis as nwis
+import pandas as pd
+import geopandas as gpd
+import us
+
+COUNTY_SHP_URL = "https://www2.census.gov/geo/tiger/TIGER2022/COUNTY/tl_2022_us_county.zip"
+counties = gpd.read_file(COUNTY_SHP_URL)[["STATEFP", "COUNTYFP", "NAME"]]
+
+site_types_df = pd.read_csv('../nwis/SiteTypes.tsv', sep='\t')
+site_type_map = site_types_df.set_index('Name')['Long name'].to_dict()
+
+def split_list(l, n=10):
+    """Split a list into chunks of size n."""
+    for i in range(0, len(l), n):
+        yield l[i:i + n]
+
+def get_county_name(state_cd, county_cd):
+    """Convert state and county FIPS codes to a county name."""
+    state_cd = str(state_cd).zfill(2)  # Ensure it's two-digit
+    county_cd = str(county_cd).zfill(3)  # Ensure it's three-digit
+    match = counties[(counties["STATEFP"] == state_cd) & (counties["COUNTYFP"] == county_cd)]
+    
+    return match.iloc[0]["NAME"] if not match.empty else None
+
+def get_state_abbr(state_cd):
+    state = us.states.lookup(str(state_cd))
+    return state.abbr if state else None
+
+def get_usgs_gauge_data(hru_ids):
+    """Retrieve USGS gauge information for a list of HRU IDs in batches."""
+    usgs_data = {}
+    
+    for site_batch in split_list(hru_ids, 10):  # Process in batches of 10
+        try:
+            response = nwis.get_info(sites=site_batch)
+            sites, meta = response
+            if sites is None or "site_no" not in sites:
+                continue
+
+            # Convert all values to JSON-serializable types
+            sites = sites.map(lambda x: x.item() if isinstance(x, (pd.Int64Dtype, pd.Float64Dtype, pd.Timestamp)) else x)
+            
+            for _, row in sites.iterrows():
+                site_id = row.get("site_no")
+                elevation = row.get("alt_va")
+                
+                # Replace NaN elevation values with -1
+                if pd.isna(elevation):
+                    elevation = -1
+
+                usgs_data[site_id] = {
+                    "usgs_site_id": site_id,
+                    "name": row.get("station_nm"),
+                    "latitude": row.get("dec_lat_va"),
+                    "longitude": row.get("dec_long_va"),
+                    "site_type": site_type_map.get(row.get("site_tp_cd"), 'Unknown'),
+                    "agency": row.get("agency_cd"),
+                    "state": get_state_abbr(str(row.get("state_cd")).zfill(2)),
+                    "county": get_county_name(str(row.get("state_cd")).zfill(2), str(row.get("county_cd")).zfill(3)),
+                    "elevation": elevation,
+                }
+        except Exception as e:
+            click.echo(f"Error retrieving USGS gauge data: {e}")
+            continue
+    
+    return usgs_data
+
+@click.command()
+@click.argument('geojson_file', type=click.Path(exists=True))
+@click.argument('id_list_file', type=click.Path(exists=True))
+@click.option('--output', default='matching_hru_ids.geojson', help='Output GeoJSON filename')
+@click.option('--area_output', default='HRU_AREA_MAP.json', help='Output JSON filename for HRU area mapping')
+def filter_geojson(geojson_file, id_list_file, output, area_output):
+    """Filter features from a GEOJSON file based on matching HRU IDs and add USGS gauge data."""
+    
+    # Load the list of HRU IDs
+    with open(id_list_file, 'r') as f:
+        try:
+            hru_ids = {str(id).zfill(8) for id in json.load(f)}  # Ensure zero-padded strings
+        except (ValueError, TypeError) as e:
+            click.echo(f"Error reading ID list file: {e}")
+            return
+
+    # Load the GeoJSON file
+    with open(geojson_file, 'r') as f:
+        geojson_data = json.load(f)
+    
+    if 'features' not in geojson_data:
+        click.echo("Invalid GeoJSON file: No 'features' key found.")
+        return
+
+    # Fetch USGS data for all HRU IDs in batches
+    usgs_data = get_usgs_gauge_data(list(hru_ids))
+
+    # Filter features and merge USGS data
+    filtered_features = []
+    hru_area_map = {}  # Dictionary to store HRU ID -> AREA mapping
+
+    for feature in geojson_data['features']:
+        if 'properties' in feature and 'hru_id' in feature['properties']:
+            hru_id = str(feature['properties']['hru_id']).zfill(8)
+            if hru_id in hru_ids:
+                feature['properties']['hru_id'] = hru_id  # Ensure consistent formatting
+                
+                # Store AREA property in the HRU area map
+                if 'AREA' in feature['properties']:
+                    hru_area_map[hru_id] = feature['properties']['AREA']
+                
+                # Add a new point feature for USGS gauge data if available
+                if hru_id in usgs_data:
+                    gauge_info = usgs_data[hru_id]
+                    point_feature = {
+                        "type": "Feature",
+                        "geometry": {
+                            "type": "Point",
+                            "coordinates": [gauge_info["longitude"], gauge_info["latitude"]]
+                        },
+                        "properties": gauge_info
+                    }
+                    feature['properties']['Name'] = gauge_info['name']
+                    filtered_features.append(point_feature)
+                filtered_features.append(feature)  # Keep original polygon
+
+    # Create new GeoJSON structure
+    filtered_geojson = {
+        "type": "FeatureCollection",
+        "features": filtered_features
+    }
+
+    # Write the output files
+    with open(output, 'w') as f:
+        json.dump(filtered_geojson, f, indent=2)
+    
+    with open(area_output, 'w') as f:
+        json.dump(hru_area_map, f, indent=2)
+
+    click.echo(f"Filtered GeoJSON saved to {output}")
+    click.echo(f"HRU Area mapping saved to {area_output}")
+
+if __name__ == '__main__':
+    filter_geojson()
diff --git a/tox.ini b/tox.ini
index 6214ad0..232bd10 100644
--- a/tox.ini
+++ b/tox.ini
@@ -82,6 +82,8 @@ ignore =
     E203,
     # line break before binary operator
     W503,
+    # Line too long
+    E501,
     # Missing docstring in *
     D10,
 exclude =
diff --git a/uvdat/core/admin.py b/uvdat/core/admin.py
index b8aee59..9bea800 100644
--- a/uvdat/core/admin.py
+++ b/uvdat/core/admin.py
@@ -5,6 +5,7 @@
     Context,
     Dataset,
     DerivedRegion,
+    DisplayConfiguration,
     FileItem,
     LayerCollection,
     LayerRepresentation,
@@ -212,6 +213,15 @@ class VectorFeatureRowDataAdmin(admin.ModelAdmin):
     list_display = ['id', 'vector_feature_table', 'row_data']
 
 
+class DisplayConfigurationAdmin(admin.ModelAdmin):
+    list_display = [
+        'enabled_ui',
+        'default_tab',
+        'default_displayed_layers',
+        'default_map_settings',
+    ]
+
+
 admin.site.register(Context, ContextAdmin)
 admin.site.register(Dataset, DatasetAdmin)
 admin.site.register(FileItem, FileItemAdmin)
@@ -233,3 +243,4 @@ class VectorFeatureRowDataAdmin(admin.ModelAdmin):
 admin.site.register(ProcessingTask, ProcessingTaskAdmin)
 admin.site.register(VectorFeatureTableData, VectorFeatureTableDataAdmin)
 admin.site.register(VectorFeatureRowData, VectorFeatureRowDataAdmin)
+admin.site.register(DisplayConfiguration, DisplayConfigurationAdmin)
diff --git a/uvdat/core/migrations/0004_displayconfiguration.py b/uvdat/core/migrations/0004_displayconfiguration.py
new file mode 100644
index 0000000..15e8b5f
--- /dev/null
+++ b/uvdat/core/migrations/0004_displayconfiguration.py
@@ -0,0 +1,60 @@
+# Generated by Django 5.0.7 on 2025-04-09 13:07
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0003_netcdfdata_bounds_rastermaplayer_bounds_and_more'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='DisplayConfiguration',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name='ID'
+                    ),
+                ),
+                (
+                    'enabled_ui',
+                    models.JSONField(
+                        default=list,
+                        help_text="List of enabled UI elements: 'Collections', 'Datasets', 'Metadata', 'Scenarios'.",
+                    ),
+                ),
+                (
+                    'default_tab',
+                    models.CharField(
+                        choices=[
+                            ('Collections', 'Collections'),
+                            ('Datasets', 'Datasets'),
+                            ('Metadata', 'Metadata'),
+                            ('Scenarios', 'Scenarios'),
+                        ],
+                        help_text='The default tab must be one of the enabled features.',
+                        max_length=256,
+                    ),
+                ),
+                (
+                    'default_displayed_layers',
+                    models.JSONField(
+                        default=list,
+                        help_text="List of map_layers enabled: [{type: 'netcdf', id: 1}. {type: 'vector', id: 3}, {type: 'raster', id: 4}]",
+                    ),
+                ),
+                (
+                    'default_map_settings',
+                    models.JSONField(
+                        blank=True,
+                        default=None,
+                        help_text='{location: { center: [x, y], zoom: 5 }}',
+                        null=True,
+                    ),
+                ),
+            ],
+        ),
+    ]
diff --git a/uvdat/core/models/__init__.py b/uvdat/core/models/__init__.py
index ec9d257..b7d2f56 100644
--- a/uvdat/core/models/__init__.py
+++ b/uvdat/core/models/__init__.py
@@ -1,10 +1,11 @@
 from .chart import Chart
 from .context import Context
 from .dataset import Dataset
+from .display_configuration import DisplayConfiguration
 from .file_item import FileItem
 from .layer_collection import LayerCollection
 from .layer_representation import LayerRepresentation
-from .map_layers import RasterMapLayer, VectorFeature, VectorMapLayer
+from .map_layers import AbstractMapLayer, RasterMapLayer, VectorFeature, VectorMapLayer
 from .netcdf import NetCDFData, NetCDFImage, NetCDFLayer
 from .networks import Network, NetworkEdge, NetworkNode
 from .processing_task import ProcessingTask
@@ -13,6 +14,7 @@
 from .vector_feature_table_data import VectorFeatureRowData, VectorFeatureTableData
 
 __all__ = [
+    AbstractMapLayer,
     Chart,
     Context,
     Dataset,
@@ -34,4 +36,5 @@
     ProcessingTask,
     VectorFeatureTableData,
     VectorFeatureRowData,
+    DisplayConfiguration,
 ]
diff --git a/uvdat/core/models/display_configuration.py b/uvdat/core/models/display_configuration.py
new file mode 100644
index 0000000..928e314
--- /dev/null
+++ b/uvdat/core/models/display_configuration.py
@@ -0,0 +1,42 @@
+from django.db import models
+
+
+class DisplayConfiguration(models.Model):
+    ENABLED_FEATURES_CHOICES = [
+        ('Collections', 'Collections'),
+        ('Datasets', 'Datasets'),
+        ('Metadata', 'Metadata'),
+        ('Scenarios', 'Scenarios'),
+    ]
+
+    enabled_ui = models.JSONField(
+        default=list,
+        help_text="List of enabled UI elements: 'Collections', 'Datasets', 'Metadata', 'Scenarios'.",
+    )
+
+    default_tab = models.CharField(
+        max_length=256,
+        choices=ENABLED_FEATURES_CHOICES,
+        help_text='The default tab must be one of the enabled features.',
+    )
+
+    default_displayed_layers = models.JSONField(
+        default=list,
+        help_text="List of map_layers enabled: [{type: 'netcdf', id: 1}. {type: 'vector', id: 3}, {type: 'raster', id: 4}]",
+    )
+
+    default_map_settings = models.JSONField(
+        blank=True,
+        null=True,
+        default=None,
+        help_text='{location: { center: [x, y], zoom: 5 }}',
+    )
+
+    def clean(self):
+        """Ensure default_tab is within enabled_features."""
+        super().clean()
+        if self.default_tab not in self.enabled_ui:
+            raise ValueError('The default tab must be one of the enabled features.')
+
+    def __str__(self):
+        return f"Configuration ({', '.join(self.enabled_ui)})"
diff --git a/uvdat/core/rest/__init__.py b/uvdat/core/rest/__init__.py
index 8bed03e..81a524e 100644
--- a/uvdat/core/rest/__init__.py
+++ b/uvdat/core/rest/__init__.py
@@ -1,6 +1,7 @@
 from .chart import ChartViewSet
 from .context import ContextViewSet
 from .dataset import DatasetViewSet
+from .display_configuration import DisplayConfigurationViewSet
 from .file_item import FileItemViewSet
 from .filter_metadata import MetadataFilterViewSet
 from .layer_collection import LayerCollectionViewSet
@@ -38,4 +39,5 @@
     VectorFeatureTableDataViewSet,
     TasksAPIView,
     MetadataFilterViewSet,
+    DisplayConfigurationViewSet,
 ]
diff --git a/uvdat/core/rest/dataset.py b/uvdat/core/rest/dataset.py
index 2b99dcc..32fbcef 100644
--- a/uvdat/core/rest/dataset.py
+++ b/uvdat/core/rest/dataset.py
@@ -72,6 +72,34 @@ def map_layers(self, request, **kwargs):
         # Return response with combined data
         return Response(combined_layers, status=200)
 
+    @action(detail=False, methods=['get'], url_path='map_layers')
+    def map_layers_from_datasets(self, request, **kwargs):
+        dataset_ids = request.query_params.getlist('datasetIds', [])
+        datasets = Dataset.objects.filter(id__in=dataset_ids)
+        total_layers = []
+        for dataset in datasets:
+            map_layers = list(dataset.get_map_layers())
+
+            # Combine both Raster and Vector map layers in a single list
+            raster_layers = uvdat_serializers.RasterMapLayerSerializer(
+                [layer for layer in map_layers if isinstance(layer, RasterMapLayer)], many=True
+            ).data
+
+            vector_layers = uvdat_serializers.VectorMapLayerSerializer(
+                [layer for layer in map_layers if isinstance(layer, VectorMapLayer)], many=True
+            ).data
+
+            netcdf_data = uvdat_serializers.NetCDFDataSerializer(
+                [layer for layer in map_layers if isinstance(layer, NetCDFData)], many=True
+            ).data
+
+            # Combine both serialized data
+            combined_layers = raster_layers + vector_layers + netcdf_data
+            total_layers += combined_layers
+
+        # Return response with combined data
+        return Response(total_layers, status=200)
+
     @action(detail=True, methods=['get'])
     def convert(self, request, **kwargs):
         dataset = self.get_object()
diff --git a/uvdat/core/rest/display_configuration.py b/uvdat/core/rest/display_configuration.py
new file mode 100644
index 0000000..80561c0
--- /dev/null
+++ b/uvdat/core/rest/display_configuration.py
@@ -0,0 +1,84 @@
+from typing import Any, Dict
+
+from django.core.exceptions import ValidationError
+from rest_framework import serializers, status, viewsets
+from rest_framework.decorators import action
+from rest_framework.request import Request
+from rest_framework.response import Response
+
+from uvdat.core.models import DisplayConfiguration
+
+
+class LayerSerializer(serializers.Serializer):
+    id = serializers.IntegerField()
+    dataset_id = serializers.IntegerField()
+    type = serializers.CharField()
+    name = serializers.CharField()
+
+
+class DisplayConfigurationSerializer(serializers.ModelSerializer):
+    enabled_ui = serializers.ListField(
+        child=serializers.CharField(),
+        help_text='List of enabled features: "Collections", "Datasets", "Metadata", "Scenarios".',
+    )
+    default_tab = serializers.CharField(
+        help_text='Default tab, must be one of the enabled features.'
+    )
+    default_displayed_layers = serializers.ListField(child=LayerSerializer())
+    default_map_settings = serializers.JSONField(
+        help_text='Map settings, e.g., {"location": {"center": [x, y], "zoom": 5}}.'
+    )
+
+    class Meta:
+        model = DisplayConfiguration
+        fields = ['enabled_ui', 'default_tab', 'default_displayed_layers', 'default_map_settings']
+
+    def validate(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        enabled_ui = data.get('enabled_ui', [])
+        default_tab = data.get('default_tab')
+        default_displayed_layers = data.get('default_displayed_layers', [])
+
+        if default_tab not in enabled_ui:
+            raise ValidationError(
+                {'default_tab': 'The default tab must be one of the enabled features.'}
+            )
+
+        if not all(
+            isinstance(layer, dict) and 'type' in layer for layer in default_displayed_layers
+        ):
+            raise ValidationError(
+                {'default_displayed_layers': 'Each entry must be a dictionary with a "type" field.'}
+            )
+
+        return data
+
+
+class DisplayConfigurationViewSet(viewsets.GenericViewSet):
+
+    queryset = DisplayConfiguration.objects.all()
+    serializer_class = DisplayConfigurationSerializer
+
+    def get_object(self) -> DisplayConfiguration:
+        return DisplayConfiguration.objects.first() or DisplayConfiguration.objects.create()
+
+    @action(detail=False, methods=['get'], url_path='display-configuration')
+    def retrieve(self, request: Request, *args: Any, **kwargs: Any) -> Response:
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
+
+    @action(detail=False, methods=['put'], url_path='display-configuration')
+    def update(self, request: Request, *args: Any, **kwargs: Any) -> Response:
+        instance = self.get_object()
+        serializer = self.get_serializer(instance, data=request.data)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @action(detail=False, methods=['patch'], url_path='display-configuration')
+    def partial_update(self, request: Request, *args: Any, **kwargs: Any) -> Response:
+        instance = self.get_object()
+        serializer = self.get_serializer(instance, data=request.data, partial=True)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        return Response(serializer.data, status=status.HTTP_200_OK)
diff --git a/uvdat/core/rest/map_layers.py b/uvdat/core/rest/map_layers.py
index 92de921..d9a9eeb 100644
--- a/uvdat/core/rest/map_layers.py
+++ b/uvdat/core/rest/map_layers.py
@@ -23,6 +23,7 @@
     VectorMapLayer,
 )
 from uvdat.core.rest.serializers import (
+    AbstractMapLayerSerializer,
     NetCDFLayerSerializer,
     RasterMapLayerSerializer,
     VectorMapLayerDetailSerializer,
@@ -511,6 +512,47 @@ def create(self, request, *args, **kwargs):
         # Return the combined data
         return Response(response_data, status=status.HTTP_200_OK)
 
+    @action(
+        detail=False,
+        methods=['get'],
+        url_path='all',
+        url_name='all',
+    )
+    def list_all_map_layers(self, request, *args, **kwargs):
+        response_data = []
+
+        # Fetch all layers
+        raster_layers = RasterMapLayer.objects.all()
+        vector_layers = VectorMapLayer.objects.all()
+        netcdf_layers = NetCDFLayer.objects.all()
+
+        # Serialize layers
+        for map_layer, _serializer, layer_type in [
+            (raster_layers, RasterMapLayerSerializer, 'raster'),
+            (vector_layers, VectorMapLayerSerializer, 'vector'),
+            (netcdf_layers, NetCDFLayerSerializer, 'netcdf'),
+        ]:
+            for layer in map_layer:
+                serializer = AbstractMapLayerSerializer(layer)
+                layer_response = serializer.data
+                layer_response['type'] = layer_type
+
+                # Check for LayerRepresentation if applicable
+                if layer_type in ['raster', 'vector']:
+                    layer_representation = LayerRepresentation.objects.filter(
+                        object_id=layer.id, map_type=ContentType.objects.get_for_model(layer)
+                    ).first()
+                    if layer_representation:
+                        layer_response['default_style'] = (
+                            layer_representation.default_style
+                            or layer_response.get('default_style')
+                        )
+                        layer_response['layerRepresentationId'] = layer_representation.id
+
+                response_data.append(layer_response)
+
+        return Response(response_data, status=status.HTTP_200_OK)
+
     def list(self, request, *args, **kwargs):
         map_layer_ids = request.query_params.getlist('mapLayerIds', [])
         map_layer_types = request.query_params.getlist('mapLayerTypes', [])
diff --git a/uvdat/core/rest/serializers.py b/uvdat/core/rest/serializers.py
index d47c047..7ba9f73 100644
--- a/uvdat/core/rest/serializers.py
+++ b/uvdat/core/rest/serializers.py
@@ -82,7 +82,9 @@ class Meta:
         fields = '__all__'
 
 
-def get_file_item_ids(obj: VectorMapLayer | RasterMapLayer | NetCDFData):
+def get_file_item_ids(obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData):
+    if isinstance(obj, NetCDFLayer):
+        return [obj.netcdf_data.dataset.id]
     if obj.dataset is None:
         return []
     ids = []
@@ -97,8 +99,16 @@ class AbstractMapLayerSerializer(serializers.Serializer):
     dataset_id = serializers.SerializerMethodField('get_dataset_id')
     file_item = serializers.SerializerMethodField('get_file_item')
     processing_tasks = serializers.SerializerMethodField('get_processing_tasks')
+    id = serializers.SerializerMethodField('get_id')
 
-    def get_name(self, obj: VectorMapLayer | RasterMapLayer | NetCDFData):
+    def get_id(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData):
+        return obj.id
+
+    def get_name(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData):
+        if isinstance(obj, NetCDFLayer):
+            return obj.name
+        if isinstance(obj, NetCDFData):
+            return obj.name
         if obj.name:
             return obj.name
         if obj.dataset:
@@ -108,21 +118,39 @@ def get_name(self, obj: VectorMapLayer | RasterMapLayer | NetCDFData):
             return f'{obj.dataset.name} Layer {obj.index}'
         return None
 
-    def get_type(self, obj: VectorMapLayer | RasterMapLayer | NetCDFData):
+    def get_type(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData):
         if isinstance(obj, VectorMapLayer):
             return 'vector'
         if isinstance(obj, RasterMapLayer):
             return 'raster'
-        if isinstance(obj, NetCDFData):
+        if isinstance(obj, NetCDFLayer) or isinstance(obj, NetCDFData):
             return 'netcdf'
         return 'none'
 
-    def get_dataset_id(self, obj: VectorMapLayer | RasterMapLayer | NetCDFData):
+    def get_dataset_id(self, obj: VectorMapLayer | RasterMapLayer | NetCDFLayer | NetCDFData):
+        if isinstance(obj, NetCDFLayer):
+            return obj.netcdf_data.dataset.id
+        if isinstance(obj, NetCDFData):
+            return obj.dataset.id
         if obj.dataset:
             return obj.dataset.id
         return None
 
-    def get_file_item(self, obj: VectorMapLayer | RasterMapLayer | NetCDFData):
+    def get_file_item(self, obj: VectorMapLayer | RasterMapLayer | NetCDFData | NetCDFLayer):
+        if isinstance(obj, NetCDFLayer):
+            for file_item in obj.netcdf_data.dataset.source_files.all():
+                if file_item.index == obj.netcdf_data.index:
+                    return {
+                        'id': file_item.id,
+                        'name': file_item.name,
+                    }
+        if isinstance(obj, NetCDFData):
+            for file_item in obj.dataset.source_files.all():
+                if file_item.index == obj.index:
+                    return {
+                        'id': file_item.id,
+                        'name': file_item.name,
+                    }
         if obj.dataset is None:
             return None
         for file_item in obj.dataset.source_files.all():
diff --git a/uvdat/core/rest/vector_feature_table_data.py b/uvdat/core/rest/vector_feature_table_data.py
index 8739940..1dd83ef 100644
--- a/uvdat/core/rest/vector_feature_table_data.py
+++ b/uvdat/core/rest/vector_feature_table_data.py
@@ -106,7 +106,7 @@ def table_summary(self, request, *args, **kwargs):
             # Aggregate summary statistics per column
             for column, stats_col in table_summary.items():
                 if 'type' not in column_summaries[table_type][column]:
-                    column_summaries[table_type][column]['type'] = stats.get('type')
+                    column_summaries[table_type][column]['type'] = stats_col.get('type')
 
                 if stats_col.get('type') == 'number':
                     column_summaries[table_type][column]['min'] = min(
@@ -129,10 +129,10 @@ def table_summary(self, request, *args, **kwargs):
                     )
                     column_summaries[table_type][column]['value_count'] = column_summaries[
                         table_type
-                    ][column].get('value_count', 0) + stats.get('value_count', 0)
+                    ][column].get('value_count', 0) + stats_col.get('value_count', 0)
 
                 if stats_col.get('description', None):
-                    column_summaries[table_type][column]['description'] = stats.get(
+                    column_summaries[table_type][column]['description'] = stats_col.get(
                         'description', 'Unknown'
                     )
         # Construct the response
@@ -239,7 +239,7 @@ def get_graphs(
 
             if 'movingAverage' in data_types and moving_avg_val is not None and moving_avg_val > 1:
                 moving_avg = np.convolve(
-                    y_vals, np.ones(moving_avg_val) / moving_avg_val, mode='valid'
+                    y_vals, np.ones(moving_avg_val) / moving_avg_val, mode='same'
                 )
                 moving_avg_x = x_vals[moving_avg_val - 1 :]
                 result['movingAverage'] = list(zip(moving_avg_x, moving_avg))
diff --git a/uvdat/core/tasks/dataset.py b/uvdat/core/tasks/dataset.py
index d7e2e0f..d8e0c89 100644
--- a/uvdat/core/tasks/dataset.py
+++ b/uvdat/core/tasks/dataset.py
@@ -161,7 +161,7 @@ def process_file_item(self, file_item_id):
                 status=ProcessingTask.Status.ERROR, error=str(f'Unsupported file type: {file_name}')
             )
 
-        for item in raster_map_layer:
+        for item in raster_map_layers:
             item.set_bounds()
     except Exception as e:
         processing_task.update(status=ProcessingTask.Status.ERROR, error=str(e))
diff --git a/uvdat/core/tasks/map_layers.py b/uvdat/core/tasks/map_layers.py
index 701b584..fc8b0e2 100644
--- a/uvdat/core/tasks/map_layers.py
+++ b/uvdat/core/tasks/map_layers.py
@@ -646,7 +646,7 @@ def process_tabular_vector_feature_data(map_layer_id, json_data, matcher):
         # Ensure the matcher value exists in json_data
         if matcher_value not in json_data:
             logger.info(
-                f'Could not find a match for the property {matcher} in vectorFeature properties'
+                f'Could not find a match for the property {matcher} : {type(matcher)} in vectorFeature properties with match_value: {matcher_value}: {type(matcher_value)}'
             )
             logger.info(feature.properties)
             continue
diff --git a/uvdat/urls.py b/uvdat/urls.py
index a8052d9..ec37311 100644
--- a/uvdat/urls.py
+++ b/uvdat/urls.py
@@ -10,6 +10,7 @@
     ContextViewSet,
     DatasetViewSet,
     DerivedRegionViewSet,
+    DisplayConfigurationViewSet,
     FileItemViewSet,
     LayerCollectionViewSet,
     LayerRepresentationViewSet,
@@ -67,6 +68,12 @@
     path('accounts/', include('allauth.urls')),
     path('oauth/', include('oauth2_provider.urls')),
     path('admin/', admin.site.urls),
+    path(
+        'api/v1/display-configuration/',
+        DisplayConfigurationViewSet.as_view(
+            {'get': 'retrieve', 'put': 'update', 'patch': 'partial_update'}
+        ),
+    ),
     path('api/v1/s3-upload/', include('s3_file_field.urls')),
     path('api/v1/', include(router.urls)),
     path('api/docs/redoc/', schema_view.with_ui('redoc'), name='docs-redoc'),