diff --git a/cypress/e2e/map.cy.ts b/cypress/e2e/map.cy.ts
index 54b0ab7..f99d36c 100644
--- a/cypress/e2e/map.cy.ts
+++ b/cypress/e2e/map.cy.ts
@@ -74,12 +74,41 @@ describe("Map", () => {
     cy.url().should("not.contain", "lng=-82.401078");
   });
 
+  it("Map contents are redisplayed whenever returning to the page from another", () => {
+    loadMap("/?maps=adult-day-care");
+
+    cy.get(".leaflet-marker-icon").its("length").as("initialNumberOfMarkers");
+
+    // Go to the About page...
+    cy.contains("About").click();
+    // ... and then back to the map page.
+    cy.get("nav > a:nth-child(1)").click();
+
+    // Check that the markers are all still there
+    cy.get("@initialNumberOfMarkers").then((initialCount) => {
+      cy.get(".leaflet-marker-icon")
+        .its("length")
+        .then((newCount) => {
+          expect(initialCount).to.eq(newCount);
+        });
+    });
+
+    cy.url().should("contain", "maps=adult-day-care");
+
+    // Check that the layer checkbox is still checked
+    cy.get("[title='Layers']").trigger("mouseover");
+    cy.get(".leaflet-control-layers-overlays label input[checked]").should(
+      "have.length",
+      1,
+    );
+  });
+
   describe("Attribution Control", () => {
     it("Attribution control displays the proper message", () => {
       loadMap("/");
 
       cy.get(".leaflet-control-attribution").contains(
-        "Brought to you by HackGreenville Labs.",
+        "Brought to you by HackGreenville Labs",
       );
     });
   });
diff --git a/src/components/MainMap.vue b/src/components/MainMap.vue
index f9f567e..7daaa51 100644
--- a/src/components/MainMap.vue
+++ b/src/components/MainMap.vue
@@ -2,10 +2,11 @@
 import "leaflet/dist/leaflet.css";
 import L, { LatLng } from "leaflet";
 import type { Map, GeoJSON, LayersControlEvent } from "leaflet";
+import { createMarker, setTooltips } from "@/utils/map";
 </script>
 
 <script setup lang="ts">
-import { ref } from "vue";
+import { ref, onBeforeUnmount } from "vue";
 import {
   LMap,
   LTileLayer,
@@ -48,6 +49,18 @@ async function initializeMap(map: Map) {
 
   for (const mapTitle in await mapStore.fetchAvailableMaps()) {
     const mapData = mapStore.availableMaps[mapTitle];
+    const layerData = mapStore.loadedMaps[mapData.mapSlug];
+
+    // If the layerData is already present, then it is leftover from a previous
+    // visit to this page.
+    if (layerData) {
+      addLayerToOverlay(
+        layersControl,
+        layerData.layer,
+        mapData.mapTitle,
+        mapData.color,
+      );
+    }
 
     await addMapLayer(
       map,
@@ -55,6 +68,7 @@ async function initializeMap(map: Map) {
       mapData,
       // Enable a map layer right away if it is listed in the query params
       mapsToEnable.has(mapData.mapSlug),
+      true,
     );
   }
 
@@ -69,17 +83,59 @@ async function initializeMap(map: Map) {
 
   map.on("overlayadd", async function (e: LayersControlEvent) {
     const mapName = e.name.toString().replace(/ \(.+\)$/, "");
-    addMapLayer(map, layersControl, mapStore.availableMaps[mapName], true);
+    addMapLayer(
+      map,
+      layersControl,
+      mapStore.availableMaps[mapName],
+      true,
+      false,
+    );
   });
 
   map.on("overlayremove", async function (e: LayersControlEvent) {
     const mapName = e.name.toString().replace(/ \(.+\)$/, "");
-    addMapLayer(map, layersControl, mapStore.availableMaps[mapName], false);
+    addMapLayer(
+      map,
+      layersControl,
+      mapStore.availableMaps[mapName],
+      false,
+      false,
+    );
   });
 
   mapInitialized.value = true;
 }
 
+async function addLayerToOverlay(
+  layersControl: L.Control.Layers,
+  layer: L.GeoJSON,
+  mapTitle: string,
+  color: string,
+) {
+  layersControl.addOverlay(layer, `${mapTitle} (${color})`);
+}
+
+/*
+ * Ensures layers are populated with GeoJSON data and added to the map
+ */
+function initializeLayerData(map: Map, mapData: MapData, layerData: LayerData) {
+  const featureCollection = mapStore.availableMaps[mapData.mapTitle]?.geoJson;
+
+  // If the data isn't already available then perform an external request to
+  // obtain it.
+  if (featureCollection) {
+    layerData.layer.addData(featureCollection);
+  } else {
+    mapStore.fetchGeoJson(mapData).then((response) => {
+      if (response) {
+        layerData.layer.addData(response);
+      }
+    });
+  }
+
+  layerData.layer.addTo(map);
+}
+
 /*
  * This method will either add a temporary empty layer that will be lazy-loaded
  * later, or go ahead with loading depending on the `visible` argument
@@ -89,6 +145,7 @@ async function addMapLayer(
   control: L.Control.Layers,
   mapData: MapData,
   visible: boolean,
+  initializingMap: boolean,
 ) {
   // if layer is already fully loaded, just update the visibility in the store
   const layerData = mapStore.loadedMaps[mapData.mapSlug];
@@ -102,6 +159,15 @@ async function addMapLayer(
     layerData.visible = visible;
     mapStore.addMapLayer(mapData.mapSlug, layerData, maintainerData);
     setUrl();
+
+    // If the map is being reloaded, but the store hasn't been cleared
+    // (ex: user went to the About page and then came back)
+    // then we need to reinitialize the layer by adding back in the
+    // GeoJSON feature collection to it and then adding the layer to the map.
+    if (initializingMap) {
+      initializeLayerData(map, mapData, layerData);
+    }
+
     return;
   }
 
@@ -117,58 +183,10 @@ async function addMapLayer(
           color: mapData.color,
         };
       },
-      pointToLayer: function (_feature: Feature, latlng: LatLng) {
-        const markerHtmlStyles = `
-          background-color: ${mapData.color};
-          width: 2rem;
-          height: 2rem;
-          display: block;
-          left: -1rem;
-          top: -1rem;
-          position: relative;
-          border-radius: 2rem 2rem 0;
-          transform: rotate(45deg);
-          border: 1px solid #FFFFFFAA`;
-
-        const markerIcon = L.divIcon({
-          className: "",
-          iconAnchor: [0, 24],
-          popupAnchor: [0, -36],
-          html: `<span style="${markerHtmlStyles}" />`,
-        });
-
-        return L.marker(latlng, { icon: markerIcon });
-      },
-      onEachFeature: function (feature: Feature, layer: GeoJSON) {
-        if (feature && feature.properties) {
-          const properties = feature.properties;
-
-          const tooltipString =
-            `<div>Map: ${mapData.mapTitle}</div>` +
-            Object.keys(properties)
-              .filter((key) => key != "OBJECTID" && properties[key])
-              .map((key) => {
-                const propertyName = toTitleCase(key.toString()).replace(
-                  /_/g,
-                  " ",
-                );
-                let propertyValue;
-                if (
-                  properties[key]?.toString().startsWith("http") ||
-                  properties[key]?.toString().startsWith("tel")
-                ) {
-                  propertyValue = `<a href="${properties[key]}" target="_blank" rel="noreferrer">${properties[key]}</a>`;
-                } else {
-                  propertyValue = properties[key];
-                }
-
-                return `<div>${propertyName}: ${propertyValue}</div>`;
-              })
-              .join("");
-
-          layer.bindPopup(tooltipString, {});
-        }
-      },
+      pointToLayer: (_feature: Feature, latlng: LatLng) =>
+        createMarker(mapData.color, latlng),
+      onEachFeature: (feature: Feature, layer: GeoJSON) =>
+        setTooltips(mapData.mapTitle, feature, layer),
     };
 
     layer = L.geoJSON([], options);
@@ -179,12 +197,7 @@ async function addMapLayer(
   mapStore.addMapLayer(mapData.mapSlug, newLayerData, maintainerData);
 
   if (visible) {
-    mapStore.fetchGeoJson(mapData).then((response) => {
-      if (response) {
-        layer.addData(response);
-      }
-    });
-    layer.addTo(map);
+    initializeLayerData(map, mapData, newLayerData);
   }
 
   setUrl();
@@ -207,11 +220,7 @@ function setUrl() {
   });
 }
 
-function toTitleCase(string: string) {
-  return string.replace(/\w\S*/g, function (txt) {
-    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
-  });
-}
+onBeforeUnmount(() => mapStore.clearLayerData());
 </script>
 
 <template>
@@ -229,7 +238,7 @@ function toTitleCase(string: string) {
     >
       <l-control-attribution
         position="bottomright"
-        prefix="Brought to you by <a href='https://hackgreenville.com/' target='_blank'>HackGreenville Labs</a>."
+        prefix="Brought to you by <a href='https://hackgreenville.com/' target='_blank'>HackGreenville Labs</a>"
       />
       <l-tile-layer
         url="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
diff --git a/src/stores/map.ts b/src/stores/map.ts
index 242eb92..82cb9e4 100644
--- a/src/stores/map.ts
+++ b/src/stores/map.ts
@@ -7,7 +7,7 @@ import type {
   LayerData,
   MaintainerData,
 } from "../types";
-import type { LatLng } from "leaflet";
+import L, { type LatLng } from "leaflet";
 
 export const useMapStore = defineStore("map", {
   state: () => ({
@@ -101,6 +101,18 @@ export const useMapStore = defineStore("map", {
 
       return this.availableMaps;
     },
+    /*
+     * Resets the layer feature collection, while retaining options
+     * (for things like the styling of the marker and the pointToLayer
+     *  and onEachFeature callbacks) to prevent memory leaks from occurring.
+     */
+    async clearLayerData() {
+      for (const key in this.loadedMaps) {
+        this.loadedMaps[key].layer = new L.GeoJSON(undefined, {
+          ...this.loadedMaps[key].layer.options,
+        });
+      }
+    },
   },
 });
 
diff --git a/src/tests/stores/map.spec.ts b/src/tests/stores/map.spec.ts
index 03b9b74..a865610 100644
--- a/src/tests/stores/map.spec.ts
+++ b/src/tests/stores/map.spec.ts
@@ -146,4 +146,59 @@ describe("mapStore", () => {
     mapStore.removeMapLayer(fakeMapSlug);
     expect(mapStore.loadedMaps).toStrictEqual({});
   });
+
+  describe("clearLayerData", () => {
+    it("clears feature collection and retains options from previous copy of layer", async () => {
+      const featureCollection: GeoJSON.FeatureCollection<any> = {
+        type: "FeatureCollection",
+        features: [
+          {
+            type: "Feature",
+            geometry: {
+              type: "Point",
+              coordinates: [0, 0],
+            },
+            properties: {},
+          },
+        ],
+      };
+
+      const mapStore = useMapStore();
+      const layerData: LayerData = {
+        layer: L.geoJSON(featureCollection, {
+          style: () => ({
+            fillColor: "test",
+            color: "test",
+          }),
+        }),
+        loaded: false,
+        visible: false,
+      };
+
+      mapStore.addMapLayer(fakeMapSlug, layerData, sampleMaintainerData);
+
+      const beforeKeyCount = Object.keys(
+        mapStore.loadedMaps[fakeMapSlug].layer,
+      ).length;
+
+      await mapStore.clearLayerData();
+
+      const afterKeyCount = Object.keys(
+        mapStore.loadedMaps[fakeMapSlug].layer,
+      ).length;
+
+      expect(beforeKeyCount).toBeGreaterThan(afterKeyCount);
+
+      expect(typeof layerData.layer.options.style).toEqual("function");
+
+      if (typeof layerData.layer.options.style == "function") {
+        expect(JSON.stringify(layerData.layer.options.style())).toEqual(
+          JSON.stringify({
+            fillColor: "test",
+            color: "test",
+          }),
+        );
+      }
+    });
+  });
 });
diff --git a/src/utils/map.ts b/src/utils/map.ts
new file mode 100644
index 0000000..121dad1
--- /dev/null
+++ b/src/utils/map.ts
@@ -0,0 +1,63 @@
+import L, { LatLng } from "leaflet";
+import type { Feature } from "geojson";
+import type { GeoJSON } from "leaflet";
+
+export function createMarker(color: string, latlng: LatLng) {
+  const markerHtmlStyles = `
+    background-color: ${color};
+    width: 2rem;
+    height: 2rem;
+    display: block;
+    left: -1rem;
+    top: -1rem;
+    position: relative;
+    border-radius: 2rem 2rem 0;
+    transform: rotate(45deg);
+    border: 1px solid #FFFFFFAA`;
+
+  const markerIcon = L.divIcon({
+    className: "",
+    iconAnchor: [0, 24],
+    popupAnchor: [0, -36],
+    html: `<span style="${markerHtmlStyles}" />`,
+  });
+
+  return L.marker(latlng, { icon: markerIcon });
+}
+
+export function setTooltips(
+  mapTitle: string,
+  feature: Feature,
+  layer: GeoJSON,
+) {
+  if (feature && feature.properties) {
+    const properties = feature.properties;
+
+    const tooltipString =
+      `<div>Map: ${mapTitle}</div>` +
+      Object.keys(properties)
+        .filter((key) => key != "OBJECTID" && properties[key])
+        .map((key) => {
+          const propertyName = toTitleCase(key.toString()).replace(/_/g, " ");
+          let propertyValue;
+          if (
+            properties[key]?.toString().startsWith("http") ||
+            properties[key]?.toString().startsWith("tel")
+          ) {
+            propertyValue = `<a href="${properties[key]}" target="_blank" rel="noreferrer">${properties[key]}</a>`;
+          } else {
+            propertyValue = properties[key];
+          }
+
+          return `<div>${propertyName}: ${propertyValue}</div>`;
+        })
+        .join("");
+    layer.bindPopup(tooltipString, {});
+  }
+}
+
+function toTitleCase(string: string) {
+  return string.replace(/\w\S*/g, function (txt) {
+    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+  });
+}