diff --git a/frontend/index.html b/frontend/index.html
index ee2ef31..393e05e 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -344,6 +344,7 @@
       const end_year = date.getFullYear();
       var current_month = start_month;
       var current_year = start_year;
+
       dates.push([current_month, current_year]);
       while (!(current_month == end_month && current_year == end_year)) {
         current_month += 1;
@@ -356,6 +357,28 @@
       };
       return dates;
     };
+
+    function getDictionaryList(form_list) {
+      var quest_dict = {};
+        return new Promise(async (resolve) => {
+          for (i in form_list) {
+            response = await fetch(form_list[i]);
+            text = await response.text();
+            const parser = new DOMParser();
+            const doc = parser.parseFromString(text, "text/xml");
+            labels = doc.getElementsByTagName("label");
+              for (i in labels) {
+                try {
+                  if ((labels[i].parentNode.getAttribute("appearance") !== "label" && labels[i].parentNode.nodeName != "input")) //label type questions don't ever have answers
+                  {
+                    quest_dict[labels[i].parentNode.getAttribute("ref").split('/').slice(-1)] = labels[i].firstChild.data;
+                  }
+                } catch (e) { }
+              } 
+            }
+          resolve(quest_dict);
+        })
+    };
   </script>
 
   <script type="text/javascript">
@@ -407,7 +430,40 @@
           mode_studied = data.intro.mode_studied
           // Load list of plots corresponding to study/program
           dynamic_labels = data.label_options
-          if (data.intro.program_or_study == 'program') {
+          surveys = data.survey_info.surveys 
+          console.log(data.survey_info['trip-labels'])
+          if (data.survey_info['trip-labels'] === 'ENKETO') { //CASE: SURVEYS
+            survey_list = Object.keys(surveys)
+            survey_list = survey_list.filter(name => name !== 'UserProfileSurvey')
+
+            sheet_list = []
+            for (name in survey_list) {
+              form_path = data.survey_info.surveys[survey_list[name]].formPath;
+              //THIS ASSUMES THE FILENAME IS THE SAME AS THE FORM PATH BUT WITH xml FILE TYPE
+              l_path = form_path.split('.')
+              l_path.splice(l_path.length -1, 1, 'xml');
+              console.log(l_path);
+              sheet_path = l_path.join('.')
+              sheet_list.push(sheet_path)
+            }
+
+            getDictionaryList(sheet_list).then((quest_dict) => {
+              console.log(quest_dict);
+              load_file = "metrics_study_surveys.html"
+              $.get(load_file, function (file) {
+                Object.entries(quest_dict).forEach(([key, value]) => {
+                  var text = '<option ' + 'value="' + key + '" data-sizex="10" data-sizey="4">' + value + '</option>';
+                  file = file.concat('\n', text);
+                });
+                console.log("configuring units");
+                const unitConfigured = file.replaceAll("${data.display_config.use_imperial}", dist_units);
+                $('#metric').append(unitConfigured);
+                addPreconfiguredMetrics(Object.keys(quest_dict).slice(0, 5)); //only adding the first 6 elements
+              });
+            });         
+          
+          }
+          else if (data.intro.program_or_study == 'program') { //CASE: PROGRAM
             // Note: We're disabling energy metrics on public dashboard when dynamic labels are available.
             // TODO: Remove the if (data.label_options) in future when energy computation is handled properly.
             if (dynamic_labels) {
@@ -515,7 +571,7 @@
         }
       }).data('gridster');
 
-      $('.js-add-new').on('click', function () {
+      $('.js-add-new').on('click', async function () {
         const metric = $("#metric").val();
         const dateVal = $("#date").val();
         const program = $("#program").val();
@@ -533,10 +589,11 @@
         const htmlFile = "plots/" + metric + "_" + dateVal + program + ".html";
         const altTextFile = "plots/" + metric + "_" + dateVal + program + ".txt";
         const altText = loadFile(altTextFile);
-        const isStackedMetric = ['ntrips_total', 'ntrips_purpose', 'ntrips_under80', 'ntrips_commute_mode_confirm',
-                                 'total_trip_length', 'total_trip_length_land',`ntrips_${mode_studied}_total`,
-                                 `ntrips_${mode_studied}_purpose`,`total_trip_length_${mode_studied}_replaced_mode`]
-                                 .includes(metric);
+        const quest_dict = await getDictionaryList(sheet_list);
+        const stackedMetrics = ['ntrips_total', 'ntrips_total_survey', 'ntrips_purpose', 'ntrips_under80', 'ntrips_under80_survey', 'ntrips_commute_mode_confirm',
+                                 'total_trip_length', 'total_trip_length_land', 'total_trip_length_land_survey',`ntrips_${mode_studied}_total`,
+                                 `ntrips_${mode_studied}_purpose`,`total_trip_length_${mode_studied}_replaced_mode`].concat(Object.keys(quest_dict));
+        const isStackedMetric = stackedMetrics.includes(metric);
         const jsonData = { metric, dateVal, program, metricLabel, dateLabel, programLabel, sizex, sizey };
 
         if (isStackedMetric){
diff --git a/frontend/metrics_study_surveys.html b/frontend/metrics_study_surveys.html
new file mode 100644
index 0000000..8c9bd26
--- /dev/null
+++ b/frontend/metrics_study_surveys.html
@@ -0,0 +1,10 @@
+<!-- htmnl options should be 1 per chart question -->
+<!-- <option value="question key" data-sizex="4" data-sizey="4">translated question</option> -->
+
+<option value="ntrips_total_survey" data-sizex="10" data-sizey="4">Number of trips</option>
+<option value="ntrips_under80_survey" data-sizex="10" data-sizey="4">Number of trips (under 80th percentile of total trips)</option>
+<option value="total_trip_length_land_survey" data-sizex="10" data-sizey="4">Total trip length (${data.display_config.use_imperial}) covered by mode in land</option>
+<option value="average_miles_sensed_mode" data-sizex="6" data-sizey="4">Average trip length (${data.display_config.use_imperial}) (sensed)</option>
+<option value="ntrips_sensed_per_day" data-sizex="6" data-sizey="4">Trip frequency (sensed)</option>
+<option value="ntrips_sensed_per_weekday" data-sizex="6" data-sizey="4">Trip frequency (weekday, sensed)</option>
+<option value="ts_users" data-sizex="8" data-sizey="2">Timeseries of active users</option>
\ No newline at end of file
diff --git a/viz_scripts/Dockerfile b/viz_scripts/Dockerfile
index d1edd03..96c97bf 100644
--- a/viz_scripts/Dockerfile
+++ b/viz_scripts/Dockerfile
@@ -1,5 +1,5 @@
 # python 3
-FROM shankari/e-mission-server:master_2024-04-15--53-23
+FROM shankari/e-mission-server:master_2024-05-06--36-33
 
 VOLUME /plots
 
diff --git a/viz_scripts/bin/generate_plots.py b/viz_scripts/bin/generate_plots.py
index 0bec985..4facaf5 100644
--- a/viz_scripts/bin/generate_plots.py
+++ b/viz_scripts/bin/generate_plots.py
@@ -90,7 +90,8 @@ def compute_for_date(month, year):
         include_test_users=dynamic_config.get('metrics', {}).get('include_test_users', False),
         dynamic_labels = dynamic_labels,
         use_imperial = dynamic_config.get('display_config', {}).get('use_imperial', True),
-        sensed_algo_prefix=dynamic_config.get('metrics', {}).get('sensed_algo_prefix', "cleaned"))
+        sensed_algo_prefix=dynamic_config.get('metrics', {}).get('sensed_algo_prefix', "cleaned"),
+        survey_info = dynamic_config.get('survey_info', {}))
 
     print(f"Running at {arrow.get()} with params {params}")
 
diff --git a/viz_scripts/docker/Dockerfile.dev b/viz_scripts/docker/Dockerfile.dev
index 4c1c6c9..7d22ece 100644
--- a/viz_scripts/docker/Dockerfile.dev
+++ b/viz_scripts/docker/Dockerfile.dev
@@ -1,5 +1,5 @@
 # python 3
-FROM shankari/e-mission-server:master_2024-04-15--53-23
+FROM shankari/e-mission-server:master_2024-05-06--36-33
 
 VOLUME /plots
 
diff --git a/viz_scripts/docker/crontab b/viz_scripts/docker/crontab
index 6e7cc55..ca37fe5 100644
--- a/viz_scripts/docker/crontab
+++ b/viz_scripts/docker/crontab
@@ -5,5 +5,7 @@
 0 8 * * * python bin/generate_plots.py mode_specific_metrics.ipynb default >> /var/log/intake.stdinout 2>&1
 0 8 * * * python bin/generate_plots.py mode_specific_timeseries.ipynb default >> /var/log/intake.stdinout 2>&1
 0 8 * * * python bin/generate_plots.py energy_calculations.ipynb default >> /var/log/intake.stdinout 2>&1
+0 8 * * * python bin/generate_plots.py survey_responses.ipynb default >> /var/log/intake.stdinout 2>&1
+0 8 * * * python bin/generate_plots.py survey_metrics.ipynb default >> /var/log/intake.stdinout 2>&1
 # For testing only
 # */5 * * * * python bin/generate_plots.py mode_purpose_share.ipynb default >> /var/log/intake.stdinout 2>&1
diff --git a/viz_scripts/plots.py b/viz_scripts/plots.py
index 83ed1e0..1eaa2cb 100644
--- a/viz_scripts/plots.py
+++ b/viz_scripts/plots.py
@@ -48,13 +48,15 @@ def merge_small_entries(labels, values):
     # We could have already had a non-zero other, and it could be small or large
     if "Other" not in v2l_df.index:
         # zero other will end up with misc_count
-        v2l_df.loc["Other"] = misc_count
+        if misc_count.vals > 0:
+            v2l_df.loc["Other"] = misc_count
     elif "Other" in small_chunk.index:
         # non-zero small other will already be in misc_count
         v2l_df.loc["Other"] = misc_count
     else:
         # non-zero large other, will not already be in misc_count
         v2l_df.loc["Other"] = v2l_df.loc["Other"] + misc_count
+    
     disp.display(v2l_df)
 
     return (v2l_df.index.to_list(),v2l_df.vals.to_list(), v2l_df.pct.to_list())
@@ -128,8 +130,13 @@ def plot_and_text_stacked_bar_chart(df, bar_label, ax, text_result, colors, debu
         ax.tick_params(axis='y', labelsize=18)
         ax.tick_params(axis='x', labelsize=18, rotation=90)
         ncols = len(df_only_small)//5 if len(df_only_small) % 5 == 0 else len(df_only_small)//5 + 1
-        ax.legend(bbox_to_anchor=(1, 0), loc='lower left', fancybox=True, shadow=True, fontsize=15)
-        # ax.legend(bbox_to_anchor=(1, 1), loc='upper left', fancybox=True, shadow=True, fontsize=15, ncols=ncols)
+        
+        if len(pd.unique(df_only_small['Label'])[0]) > 15:
+            ax.legend(bbox_to_anchor=(0.5, -0.5), loc='upper center', fancybox=True, shadow=True, fontsize=15)
+        else:
+            ax.legend(bbox_to_anchor=(1, 0), loc='lower left', fancybox=True, shadow=True, fontsize=15)
+            # ax.legend(bbox_to_anchor=(1, 1), loc='upper left', fancybox=True, shadow=True, fontsize=15, ncols=ncols)
+            
         # Fix for the error: RuntimeError("Unknown return type"), adding the below line to address as mentioned here https://github.com/matplotlib/matplotlib/issues/25625/
         ax.set_xlim(right=ax.get_xlim()[1] + 1.0, auto=True)
         text_result[0], text_result[1] = store_alt_text_and_html_stacked_bar_chart(df_all_entries, bar_label)
diff --git a/viz_scripts/scaffolding.py b/viz_scripts/scaffolding.py
index fa32948..7acfdf4 100644
--- a/viz_scripts/scaffolding.py
+++ b/viz_scripts/scaffolding.py
@@ -69,6 +69,16 @@ def load_all_participant_trips(program, tq, load_test_users):
     disp.display(participant_ct_df.head())
     return participant_ct_df
 
+def filter_composite_trips(all_comp_trips, program, load_test_users):
+    participant_list = get_participant_uuids(program, load_test_users)
+    # CASE 1 of https://github.com/e-mission/em-public-dashboard/issues/69#issuecomment-1256835867
+    if len(all_comp_trips) == 0:
+        return all_comp_trips
+    participant_ct_df = all_comp_trips[all_comp_trips.user_id.isin(participant_list)]
+    print("After filtering, found %s participant trips " % len(participant_ct_df))
+    disp.display(participant_ct_df.head())
+    return participant_ct_df
+
 def filter_labeled_trips(mixed_trip_df):
     # CASE 1 of https://github.com/e-mission/em-public-dashboard/issues/69#issuecomment-1256835867
     if len(mixed_trip_df) == 0:
@@ -214,6 +224,20 @@ def mapping_color_labels(dynamic_labels, dic_re, dic_pur):
 
     return colors_mode, colors_purpose, colors_sensed
 
+# Function: Maps survey answers to colors.
+# Input: dictionary of raw and translated survey answers
+# Output: Map for color with survey answers
+def mapping_color_surveys(dic_options):
+    dictionary_values = (list(OrderedDict.fromkeys(dic_options.values())))
+    
+    colors = {}
+    for i in range(len(dictionary_values)):
+        colors[dictionary_values[i]] = plt.cm.tab10.colors[i%10]
+    
+    colors['Other'] = plt.cm.tab10.colors[(i+1)%10]
+
+    return colors
+
 def load_viz_notebook_sensor_inference_data(year, month, program, include_test_users=False, sensed_algo_prefix="cleaned"):
     """ Inputs:
     year/month/program = parameters from the visualization notebook
diff --git a/viz_scripts/survey_metrics.ipynb b/viz_scripts/survey_metrics.ipynb
new file mode 100644
index 0000000..60886ca
--- /dev/null
+++ b/viz_scripts/survey_metrics.ipynb
@@ -0,0 +1,277 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ed6ab331",
+   "metadata": {},
+   "source": [
+    "## Generate Static Graphs -- Metrics for Survey Deployments"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3506947",
+   "metadata": {},
+   "source": [
+    "These are the input parameters for the notebook. They will be automatically changed when the scripts to generate monthly statistics are run. You can modify them manually to generate multiple plots locally as well.\n",
+    "\n",
+    "Pass in `None` to remove the filters and plot all data. This is not recommended for production settings, but might be useful for reports based on data snapshots."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4fb04713",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "year = 2024\n",
+    "month = 11\n",
+    "program = \"default\"\n",
+    "study_type = \"study\"\n",
+    "include_test_users = False\n",
+    "dynamic_labels = {}\n",
+    "use_imperial = True\n",
+    "sensed_algo_prefix = \"cleaned\"\n",
+    "bluetooth_only = True #current proxy for fleet status\n",
+    "survey_info = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "764463bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from plots import *\n",
+    "import scaffolding\n",
+    "\n",
+    "sns.set_style(\"whitegrid\")\n",
+    "sns.set()\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# get metric vs imperial vars\n",
+    "label_units, short_label, label_units_lower, distance_col, weight_unit = scaffolding.get_units(use_imperial)\n",
+    "\n",
+    "# get color mappings\n",
+    "colors_mode, colors_purpose, colors_sensed = scaffolding.mapping_color_labels({}, {}, {}) #just need sensed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "083483be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Do not run this notebook at all unless it is for a survey configuration; nbclient will run up through this cell\n",
+    "if not survey_info.get('trip-labels', None) == 'ENKETO':\n",
+    "    ipython = get_ipython()\n",
+    "    ipython._showtraceback = scaffolding.no_traceback_handler\n",
+    "    raise Exception(\"The plots in this notebook are only relevant to deployments with trip-level surveys\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed44bc42",
+   "metadata": {},
+   "source": [
+    "## Collect Data From Database"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6805564",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "expanded_ct_sensed, file_suffix_sensed, quality_text_sensed, debug_df_sensed = scaffolding.load_viz_notebook_sensor_inference_data(year,\n",
+    "                                                                            month,\n",
+    "                                                                            program,\n",
+    "                                                                            include_test_users,\n",
+    "                                                                            sensed_algo_prefix)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b9b54e16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#if fleet, replace primary_mode with primary_ble_sensed mode\n",
+    "#RESTORE WHEN BLUETOOTH MODE IS RELIABLE\n",
+    "# if bluetooth_only:\n",
+    "#     expanded_ct_sensed = expanded_ct_sensed[expanded_ct_sensed['ble_sensed_summary'].notna()]\n",
+    "#     expanded_ct_sensed[\"primary_mode\"] = expanded_ct_sensed.ble_sensed_summary.apply(lambda md: max(md[\"distance\"], key=md[\"distance\"].get))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "731c35e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "sensed_match = re.match(r'Based on ([0-9]+) trips from ([0-9]+) (users|testers and participants)', quality_text_sensed)\n",
+    "stacked_bar_quality_text_sensed = f\"{sensed_match.group(1)} trips (100%)\\n from {sensed_match.group(2)} {sensed_match.group(3)}\"\n",
+    "stacked_bar_quality_text_sensed"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa72afe9",
+   "metadata": {},
+   "source": [
+    "## Trips - count and distance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3be240e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "file_name = f'ntrips_total_survey{file_suffix_sensed}'\n",
+    "plot_title_no_quality= \"Number of trips for each mode (selected by users)\"\n",
+    "\n",
+    "try:\n",
+    "    fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(15,2*2), sharex=True)\n",
+    "    # We will have text results corresponding to the axes for simplicity and consistency\n",
+    "    text_results = [[\"Unmodified Alt Text\", \"Unmodified HTML\"], [\"Unmodified Alt Text\", \"Unmodified HTML\"]]\n",
+    "    plot_and_text_stacked_bar_chart(expanded_ct_sensed.groupby(\"primary_mode\").agg({distance_col: 'count'}), \"Count of Trips\\n\"+stacked_bar_quality_text_sensed, ax[0], text_results[0], colors_sensed, debug_df_sensed)\n",
+    "    plot_and_text_stacked_bar_chart(expanded_ct_sensed.groupby(\"primary_mode\").agg({distance_col: 'sum'}), \"Distance of Trips\\n\"+stacked_bar_quality_text_sensed, ax[1], text_results[1], colors_sensed, debug_df_sensed)\n",
+    "    set_title_and_save(fig, text_results, plot_title_no_quality, file_name)\n",
+    "except (AttributeError, KeyError, pd.errors.UndefinedVariableError) as e:\n",
+    "    plt.clf()\n",
+    "    generate_missing_plot(plot_title_no_quality, debug_df_sensed, file_name)\n",
+    "    alt_text = store_alt_text_missing(debug_df_sensed, file_name, plot_title_no_quality)        \n",
+    "    alt_html = store_alt_html_missing(debug_df_sensed, file_name, plot_title_no_quality)\n",
+    "except Exception as e:\n",
+    "    # TODO: Future cleanup can pass in just the figure and have the function choose the last axis\n",
+    "    fig, ax = plt.subplots()\n",
+    "    plot_and_text_error(e, ax, file_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a28891cc",
+   "metadata": {},
+   "source": [
+    "## Trips under 80%"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1beae73e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "file_name = f'ntrips_under80_survey{file_suffix_sensed}'\n",
+    "\n",
+    "try:\n",
+    "    # Preprocess to find cutoff and filter below cutoff\n",
+    "    # For simplicity, and to aid in comparison, we have a single cutoff based on the total number of trips\n",
+    "    cutoff = expanded_ct_sensed.distance.quantile(0.8)\n",
+    "    if pd.isna(cutoff):\n",
+    "        cutoff = 0\n",
+    "    dist_threshold = expanded_ct_sensed[distance_col].quantile(0.8).round(1)\n",
+    "    dist_threshold = str(dist_threshold) \n",
+    "\n",
+    "    plot_title_no_quality=\"Number of trips per travel model under \" + dist_threshold + \" \" + label_units_lower\n",
+    "    plot_title_no_quality=plot_title_no_quality+\"\\n[\"+dist_threshold + \" \" + label_units_lower+\" represents 80th percentile of trip length]\"\n",
+    "\n",
+    "    expanded_ct_sensed_u80 = expanded_ct_sensed.loc[(expanded_ct_sensed['distance'] <= cutoff)]\n",
+    "    sensed_u80_quality_text = f\"{len(expanded_ct_sensed_u80)} trips ({round(len(expanded_ct_sensed_u80)/len(expanded_ct_sensed)*100)}% of all trips)\\nfrom {scaffolding.unique_users(expanded_ct_sensed_u80)} {sensed_match.group(3)}\"\n",
+    "\n",
+    "    # Plot entries\n",
+    "    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(15,2*1), sharex=True)\n",
+    "    text_results = [\"Unmodified Alt Text\", \"Unmodified HTML\"]\n",
+    "    plot_and_text_stacked_bar_chart(expanded_ct_sensed_u80.groupby(\"primary_mode\").agg({distance_col: 'count'}), \"Sensed by OpenPATH\\n\"+sensed_u80_quality_text, ax, text_results, colors_sensed, debug_df_sensed)\n",
+    "    set_title_and_save(fig, text_results, plot_title_no_quality, file_name)\n",
+    "except (AttributeError, KeyError, pd.errors.UndefinedVariableError) as e:\n",
+    "    # we can have an missing attribute error during the pre-procssing, in which case we should show the missing plot\n",
+    "    # here, our pre-processing only relies on sensed data, so we use the debug_df_sensed\n",
+    "    plt.clf()\n",
+    "    plot_title_default = \"Number of trips below 80th percentile in each mode\"\n",
+    "    generate_missing_plot(plot_title_default, debug_df_sensed, file_name)\n",
+    "    alt_text = store_alt_text_missing(debug_df_sensed, file_name, plot_title_default)\n",
+    "    alt_html = store_alt_html_missing(debug_df_sensed, file_name, plot_title_no_quality)\n",
+    "except Exception as e:\n",
+    "    fig, ax = plt.subplots()\n",
+    "    plot_and_text_error(e, ax, file_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5454e0f",
+   "metadata": {},
+   "source": [
+    "## Land mode distances"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39da6b85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_title_no_quality= \"Total trip length (\" + label_units_lower + \") covered by each mode by land\"\n",
+    "file_name =f\"total_trip_length_land_survey{file_suffix_sensed}\"\n",
+    "\n",
+    "try:\n",
+    "    ## We do an existence check for the labeled df because we want to display the sensed value even if we don't have the labeled value\n",
+    "    ## but we don't need to have an existence check for sensed because in that case we will have no data to display\n",
+    "    sensed_land_trips_df = expanded_ct_sensed[expanded_ct_sensed['primary_mode'] != \"AIR_OR_HSR\"]\n",
+    "    \n",
+    "    sensed_land_quality_text = f\"{len(sensed_land_trips_df)} trips ({round(len(sensed_land_trips_df)/len(expanded_ct_sensed)*100)}% of all trips)\\nfrom {scaffolding.unique_users(sensed_land_trips_df)} {sensed_match.group(3)}\"\n",
+    "\n",
+    "    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(15,2*1), sharex=True)\n",
+    "    text_results = [\"Unmodified Alt Text\", \"Unmodified HTML\"]\n",
+    "    plot_and_text_stacked_bar_chart(sensed_land_trips_df.groupby(\"primary_mode\").agg({distance_col: 'sum'}), \"Sensed by OpenPATH\\n\"+sensed_land_quality_text, ax, text_results, colors_sensed, debug_df_sensed)\n",
+    "    set_title_and_save(fig, text_results, plot_title_no_quality, file_name)    \n",
+    "except (AttributeError, KeyError, pd.errors.UndefinedVariableError) as e:\n",
+    "    plt.clf()\n",
+    "    generate_missing_plot(plot_title_no_quality, debug_df_sensed, file_name)\n",
+    "    alt_text = store_alt_text_missing(debug_df_sensed, file_name, plot_title_no_quality)        \n",
+    "    alt_html = store_alt_html_missing(debug_df_sensed, file_name, plot_title_no_quality)\n",
+    "except Exception as e:\n",
+    "    fig, ax = plt.subplots()\n",
+    "    plot_and_text_error(e, ax, file_name)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/viz_scripts/survey_responses.ipynb b/viz_scripts/survey_responses.ipynb
new file mode 100644
index 0000000..28d7c3f
--- /dev/null
+++ b/viz_scripts/survey_responses.ipynb
@@ -0,0 +1,407 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce0dcc9f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "year = 2024\n",
+    "month = 11\n",
+    "program = \"default\"\n",
+    "study_type = \"study\"\n",
+    "mode_of_interest = None\n",
+    "include_test_users = True\n",
+    "dynamic_labels = {}\n",
+    "use_imperial = True\n",
+    "survey_info = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "585410e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import collections\n",
+    "import urllib.request\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import xml.dom.minidom as minidom\n",
+    "\n",
+    "import emcommon.survey.conditional_surveys as conditional_surveys\n",
+    "\n",
+    "from plots import *\n",
+    "import scaffolding\n",
+    "import re\n",
+    "\n",
+    "sns.set_style(\"whitegrid\")\n",
+    "sns.set()\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# get metric vs imperial vars\n",
+    "label_units, short_label, label_units_lower, distance_col, weight_unit = scaffolding.get_units(use_imperial)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f85d2a9e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Do not run this notebook at all unless it is for a survey configuration; nbclient will run up through this cell\n",
+    "if not survey_info.get('trip-labels', None) == 'ENKETO':\n",
+    "    ipython = get_ipython()\n",
+    "    ipython._showtraceback = scaffolding.no_traceback_handler\n",
+    "    raise Exception(\"The plots in this notebook are only relevant to deployments with trip-level surveys\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c739be2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#input: list of survey names from the config\n",
+    "#output: list of links to the sheets where questions/answers are\n",
+    "#will run n surveys times\n",
+    "def get_sheet_links(survey_list):\n",
+    "    sheet_list = {}\n",
+    "    for name in survey_list:\n",
+    "        form_path = survey_info['surveys'][name]['formPath']\n",
+    "        #THIS ASSUMES THE FILENAME IS THE SAME AS THE FORM PATH BUT WITH xml FILE TYPE\n",
+    "        l_path = form_path.split('.')\n",
+    "        l_path[-1] = 'xml'\n",
+    "        s = '.'\n",
+    "        sheet_path = s.join(l_path)\n",
+    "        sheet_list[name] = sheet_path\n",
+    "\n",
+    "    return sheet_list\n",
+    "\n",
+    "#input: list of urls for the survey xlsx files\n",
+    "#output: two dictionaries to translate the ?s/ans (?s dict is nested per survey)\n",
+    "#will run n surveys times\n",
+    "def build_dictionaries(sheet_list):\n",
+    "    opt_dict = {}\n",
+    "    quest_dict = {}\n",
+    "    \n",
+    "    for survey_name in sheet_list:\n",
+    "        url = sheet_list[survey_name]\n",
+    "        result = urllib.request.urlopen(url)\n",
+    "        doc = minidom.parse(result) \n",
+    "        \n",
+    "        #nested dictionaries to keep surveys grouped\n",
+    "        survey_questions = {}\n",
+    "\n",
+    "        labels = doc.getElementsByTagName(\"label\") \n",
+    "        for label in labels:\n",
+    "            if(bool(label.parentNode.getAttribute(\"ref\"))):\n",
+    "                #label appearance = not a question?\n",
+    "                #nodeName input -- to word cloud as a later addition?\n",
+    "                if label.parentNode.getAttribute(\"appearance\") != \"label\" and label.parentNode.nodeName != \"input\": \n",
+    "                    survey_questions[str(label.parentNode.getAttribute(\"ref\").split('/')[-1])] = label.firstChild.data\n",
+    "            \n",
+    "            if label.parentNode.nodeName == 'item':\n",
+    "                if label.parentNode.parentNode.getAttribute(\"appearance\") == \"likert\":\n",
+    "                    if label.parentNode.getElementsByTagName(\"value\")[0].firstChild.data not in opt_dict.keys():\n",
+    "                        opt_dict[label.parentNode.getElementsByTagName(\"value\")[0].firstChild.data] = label.parentNode.getElementsByTagName(\"value\")[0].firstChild.data\n",
+    "                elif label.parentNode.getElementsByTagName(\"value\"):\n",
+    "                    if label.parentNode.getElementsByTagName(\"value\")[0].firstChild.data not in opt_dict.keys():\n",
+    "                        opt_dict[label.parentNode.getElementsByTagName(\"value\")[0].firstChild.data] = label.firstChild.data  \n",
+    "                elif label.parentNode.getElementsByTagName(\"name\"):\n",
+    "                    if label.parentNode.getElementsByTagName(\"name\")[0].firstChild.data not in opt_dict.keys():\n",
+    "                        opt_dict[label.parentNode.getElementsByTagName(\"name\")[0].firstChild.data] = label.firstChild.data  \n",
+    "        \n",
+    "        quest_dict[survey_name] = survey_questions\n",
+    "        \n",
+    "    return opt_dict, quest_dict\n",
+    "\n",
+    "\n",
+    "def get_response_to_normalize(row):\n",
+    "    data_key = list(row.user_input['trip_user_input']['data']['jsonDocResponse'].keys())[0]\n",
+    "    response = row.user_input['trip_user_input']['data']['jsonDocResponse'][data_key]\n",
+    "\n",
+    "    return response \n",
+    "\n",
+    "#input: dataframe containing all trips that have non-blank user_input\n",
+    "#output: dataframe with questions in the columns and answers in the rows\n",
+    "#for loop will run n survey responses times (this could get big!)\n",
+    "def create_dataframe(df_trips_w_surveys):\n",
+    "    df = df_trips_w_surveys.reset_index()\n",
+    "    \n",
+    "    #normalize the survey responses\n",
+    "    normalized_responses = pd.json_normalize(df.apply(get_response_to_normalize, axis=1))\n",
+    "    normalized_responses['survey_name'] = df['survey_name']\n",
+    "    normalized_responses['user_id'] = df['user_id']\n",
+    "\n",
+    "    #update the column names\n",
+    "    rename_nests = {}\n",
+    "    for col in normalized_responses.columns:\n",
+    "        rename_nests[col] = col.split('.')[-1]\n",
+    "\n",
+    "    normalized_responses = normalized_responses.rename(columns=rename_nests)\n",
+    "\n",
+    "    return normalized_responses\n",
+    "\n",
+    "#input: list of labels that will end up on the chart\n",
+    "#output: translated to readable list, with multiples handled\n",
+    "#the for loop will run n times, where num_options <= n < all possible combinations of options\n",
+    "#if people are selecting many different combinations, could be large\n",
+    "def traslate_options(label, opt_dict):\n",
+    "    try:\n",
+    "        l_labels = str(label).split(\" \")\n",
+    "        for k in range(len(l_labels)):\n",
+    "            try:\n",
+    "                #workaround for the case wher we had \"5.0\" and need \"5\"\n",
+    "                l_labels[k] = opt_dict[str(int(float(l_labels[k])))]\n",
+    "            except:\n",
+    "                l_labels[k] = opt_dict[l_labels[k]]\n",
+    "        sep = \"\\n\"\n",
+    "        \n",
+    "        final = sep.join(l_labels)\n",
+    "        \n",
+    "        return final\n",
+    "    except:\n",
+    "        return label #probably a row without an answer\n",
+    "\n",
+    "#create a debug dataframe\n",
+    "def generate_debug_df(program, include_test_users, full_df, labeled_df):\n",
+    "    debug_df = pd.DataFrame.from_dict({\n",
+    "            \"year\": year,\n",
+    "            \"month\": month,\n",
+    "            \"Registered_participants\": len(scaffolding.get_participant_uuids(program, include_test_users)),\n",
+    "            \"Participants_with_at_least_one_trip\": scaffolding.unique_users(full_df),\n",
+    "            \"Participant_with_at_least_one_labeled_trip\": scaffolding.unique_users(labeled_df),\n",
+    "            \"Trips_with_at_least_one_label\": len(labeled_df)\n",
+    "            },\n",
+    "        orient='index', columns=[\"value\"])\n",
+    "    \n",
+    "    return debug_df\n",
+    "\n",
+    "#color dictionary\n",
+    "def mapping_color_surveys(dic_options):\n",
+    "    dictionary_values = (list(collections.OrderedDict.fromkeys(dic_options.values())))\n",
+    "    \n",
+    "    colors = {}\n",
+    "    for i in range(len(dictionary_values)):\n",
+    "        colors[dictionary_values[i]] = plt.cm.tab10.colors[i%10]\n",
+    "    \n",
+    "    return colors\n",
+    "\n",
+    "#workaround missing colors\n",
+    "def get_survey_colors(labels, existing_map):\n",
+    "    color_map = {}\n",
+    "    for label in labels:\n",
+    "        l_labels = label.split(\"\\n\")\n",
+    "        color = (0,0,0)\n",
+    "        n = 0\n",
+    "        for i in range(len(l_labels)):\n",
+    "            try:\n",
+    "                color = tuple(map(lambda i, j: i + j, color, existing_map[l_labels[i]]))\n",
+    "            except:\n",
+    "                print(\"missing color\")\n",
+    "                color = tuple(map(lambda i, j: i + j, color, (0.1, 0.2, 0.5)))\n",
+    "            \n",
+    "            n += 1\n",
+    "            \n",
+    "        print(color, n)\n",
+    "        color = [x/n for x in color]\n",
+    "        \n",
+    "        color_map[label] = color\n",
+    "    \n",
+    "    color_map['Other'] = existing_map['Other']\n",
+    "    \n",
+    "    return color_map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5319980e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#list of all surveys that are not a \"UserProfileSurvey\"\n",
+    "survey_list = list(survey_info['surveys'].keys())\n",
+    "survey_list.remove('UserProfileSurvey')\n",
+    "sheet_list = get_sheet_links(survey_list)\n",
+    "\n",
+    "print('survey sheets: ', sheet_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b355efd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tq = scaffolding.get_time_query(year, month)\n",
+    "all_confirmed_trips = scaffolding.load_all_confirmed_trips(tq)\n",
+    "#we need to filter out trips (based on if including test users)\n",
+    "all_confirmed_trips = scaffolding.filter_composite_trips(all_confirmed_trips, program, include_test_users)\n",
+    "\n",
+    "try:\n",
+    "    #remove blank inputs\n",
+    "    survey_trips = all_confirmed_trips[all_confirmed_trips['user_input'] != {}]\n",
+    "\n",
+    "    #survey counts df\n",
+    "    survey_trips = survey_trips.reset_index()\n",
+    "    survey_trips['survey_name'] = survey_trips.user_input.apply(lambda sr: sr['trip_user_input']['data']['name'])\n",
+    "\n",
+    "    #gather the cols needed for charts and text\n",
+    "    survey_trips = survey_trips[['survey_name', 'user_id', 'user_input']]\n",
+    "    survey_trips.groupby('survey_name').count()\n",
+    "    \n",
+    "except:\n",
+    "    survey_trips = pd.DataFrame()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c751b118",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#create translation dictionaries\n",
+    "opt_dict, quest_dict = build_dictionaries(sheet_list)\n",
+    "print(\"Questions dictionary:\\n\",quest_dict)\n",
+    "print(\"Options dictionary:\\n\", opt_dict)\n",
+    "\n",
+    "color_map = mapping_color_surveys(opt_dict)\n",
+    "\n",
+    "#format survey trips into responses dataframe\n",
+    "if len(survey_trips) > 0:\n",
+    "    df_responses = create_dataframe(survey_trips)\n",
+    "else:\n",
+    "    df_responses = survey_trips.copy()\n",
+    "    \n",
+    "    \n",
+    "file_suffix = scaffolding.get_file_suffix(year, month, program)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "93dbaa5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# #create the total dfs\n",
+    "# total_dfs = {}\n",
+    "# #for conditional surveys!\n",
+    "# wrapped_config = {'survey_info': survey_info}\n",
+    "# if 'buttons' in survey_info.keys():\n",
+    "#     all_confirmed_trips = all_confirmed_trips[all_confirmed_trips['ble_sensed_summary'].notna()]\n",
+    "#     all_confirmed_trips[\"confirmedMode_baseMode\"] = all_confirmed_trips.ble_sensed_summary.apply(lambda md: max(md[\"distance\"], key=md[\"distance\"].get))\n",
+    "#     all_confirmed_trips['survey_name_prompted'] = all_confirmed_trips.apply(lambda row: conditional_surveys.survey_prompted_for_trip(row.to_dict(), wrapped_config), axis=1)\n",
+    "    \n",
+    "#     for survey_name in list(sheet_list.keys()):\n",
+    "#         if survey_name in all_confirmed_trips['survey_name_prompted'].unique():\n",
+    "#             total_dfs[survey_name] = all_confirmed_trips[all_confirmed_trips['survey_name_prompted'] == survey_name]\n",
+    "#         else:\n",
+    "#             #never prompted\n",
+    "#             total_dfs[survey_name] = pd.DataFrame()\n",
+    "# else:\n",
+    "#     survey_name = list(sheet_list.keys())[0] #there is only one if non-conditional\n",
+    "#     total_dfs[survey_name] = all_confirmed_trips\n",
+    "\n",
+    "# for key in total_dfs.keys():\n",
+    "#     if len(total_dfs[key]) > 0:\n",
+    "#         print(key, \":\", len(total_dfs[key]), \"trips\", total_dfs[key].user_id.nunique(), \"users\")\n",
+    "#     else:\n",
+    "#         print(key, \":\", len(total_dfs[key]), \"trips\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5732576d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#merge any cols with the same name into 1 col -- should have different values in their survey_name col\n",
+    "#https://stackoverflow.com/questions/24390645/python-pandas-merge-samed-name-columns-in-a-dataframe\n",
+    "def sjoin(x): return ';'.join(x[x.notnull()].astype(str))\n",
+    "df_responses = df_responses.groupby(level=0, axis=1).apply(lambda x: x.apply(sjoin, axis=1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7bcebeef",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#create one plot per question in the survey\n",
+    "for survey_name in quest_dict.keys():\n",
+    "    print(\"Charts for:\", survey_name)\n",
+    "#     debug_df = generate_debug_df(program, include_test_users, total_dfs[survey_name], total_dfs[survey_name][total_dfs[survey_name]['user_input'] != {} if len(total_dfs[survey_name]) > 0 else pd.DataFrame()])\n",
+    "    debug_df = generate_debug_df(program, include_test_users, all_confirmed_trips, df_responses) #survey filtering still buggy, omitting all features of \"num trips survey presented\"\n",
+    "    \n",
+    "    for col in quest_dict[survey_name].keys():\n",
+    "        filename = col + file_suffix\n",
+    "        plot_title_no_quality = survey_name + \"\\n\" + quest_dict[survey_name][col]\n",
+    "\n",
+    "        try:\n",
+    "            quest_frame = df_responses.copy()\n",
+    "            quest_frame = quest_frame[quest_frame['survey_name'] == survey_name]\n",
+    "            quest_frame[col].replace('', np.nan, inplace=True)\n",
+    "            quest_frame.dropna(subset=[col], inplace=True)\n",
+    "            \n",
+    "#             qual_text = scaffolding.get_quality_text(total_dfs[survey_name], quest_frame, mode_of_interest, include_test_users)\n",
+    "#             plot_title = plot_title_no_quality+'\\n'+qual_text\n",
+    "            plot_title = plot_title_no_quality\n",
+    "            \n",
+    "            fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(15,2*1), sharex=True)\n",
+    "\n",
+    "            quest_frame[col] = quest_frame[col].apply(lambda x: traslate_options(x, opt_dict))\n",
+    "            text_results = [\"Unmodified Alt Text\", \"Unmodified HTML\"]  \n",
+    "\n",
+    "            plot_df = quest_frame.groupby(['survey_name', col]).count().reset_index()\n",
+    "            plot_df = plot_df[plot_df['survey_name'] == survey_name]\n",
+    "            plot_df = plot_df.set_index(col)[['start']]\n",
+    "            \n",
+    "            plot_and_text_stacked_bar_chart(plot_df, \"Responses\", ax, text_results, get_survey_colors(list(plot_df.index.values) ,color_map), debug_df)\n",
+    "            set_title_and_save(fig, text_results, plot_title, filename)\n",
+    "        except (AttributeError, KeyError, pd.errors.UndefinedVariableError) as e:\n",
+    "            plt.clf()\n",
+    "            generate_missing_plot(plot_title_no_quality, debug_df, filename)\n",
+    "            alt_text = store_alt_text_missing(debug_df, filename, plot_title_no_quality)        \n",
+    "            alt_html = store_alt_html_missing(debug_df, filename, plot_title_no_quality)\n",
+    "        except Exception as e:\n",
+    "            fig, ax = plt.subplots()\n",
+    "            plot_and_text_error(e, ax, filename)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}