diff --git a/dags/here_dynamic_binning_agg.py b/dags/here_dynamic_binning_agg.py
new file mode 100644
index 000000000..166031952
--- /dev/null
+++ b/dags/here_dynamic_binning_agg.py
@@ -0,0 +1,87 @@
+'''
+To trigger for past date (range) use CLI:
+for i in {0..5}; do 
+    end_date=$(date -I -d "2023-11-02 +$i days")
+    airflow dags trigger -e "${end_date}" here_dynamic_binning_agg
+done
+
+or trigger just one day: airflow dags trigger -e 2023-11-02 here_dynamic_binning_agg
+`airflow dags backfill ...` doesn't work because there are no scheduled run dates in that range.
+'''
+
+import sys
+import os
+import logging
+from pendulum import duration, datetime
+
+from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator
+from airflow.models import Variable
+from airflow.decorators import dag, task
+
+try:
+    repo_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+    sys.path.insert(0, repo_path)
+    from dags.dag_functions import task_fail_slack_alert
+    from dags.custom_operators import SQLCheckOperatorWithReturnValue
+except:
+    raise ImportError("Cannot import slack alert functions")
+    
+LOGGER = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+doc_md = "This DAG is running off the `1132-here-aggregation-proposal` branch to test dynamic binning aggregation."
+DAG_NAME = 'here_dynamic_binning_agg'
+DAG_OWNERS = Variable.get('dag_owners', deserialize_json=True).get(DAG_NAME, ["Unknown"]) 
+
+default_args = {
+    'owner': ','.join(DAG_OWNERS),
+    'depends_on_past':False,
+    'start_date': datetime(2019, 1, 1, tz="America/Toronto"),
+    'email_on_failure': False,
+    'email_on_success': False,
+    'retries': 1,
+    'retry_delay': duration(minutes=5),
+    #'on_failure_callback': task_fail_slack_alert
+}
+
+@dag(
+    DAG_NAME, 
+    default_args=default_args, 
+    schedule=None, # triggered by `pull_here_path` DAG
+    doc_md = doc_md,
+    tags=["HERE", "aggregation"],
+    max_active_runs=1,
+    catchup=False
+)
+
+#to add: catchup, one task at a time, depends on past.
+
+def here_dynamic_binning_agg():
+    check_not_empty = SQLCheckOperatorWithReturnValue(
+        task_id="check_not_empty",
+        sql="SELECT COUNT(*), COUNT(*) FROM here.ta_path WHERE dt = '{{ ds }}'",
+        conn_id="congestion_bot",
+        retries=1,
+        retry_delay=duration(days=1)
+    )
+    
+    delete_daily = SQLExecuteQueryOperator(
+        sql="DELETE FROM gwolofs.congestion_raw_segments WHERE dt = '{{ ds }}'",
+        task_id='delete_daily',
+        conn_id='congestion_bot',
+        autocommit=True,
+        retries = 2
+    )
+    
+    aggregate_daily = SQLExecuteQueryOperator(
+        sql="SELECT gwolofs.congestion_network_segment_agg('{{ ds }}'::date);",
+        task_id='aggregate_daily',
+        conn_id='congestion_bot',
+        autocommit=True,
+        retries = 2,
+        hook_params={"options": "-c statement_timeout=10800000ms"} #3 hours
+    )
+    
+    check_not_empty >> delete_daily >> aggregate_daily
+
+here_dynamic_binning_agg()
\ No newline at end of file
diff --git a/dags/here_dynamic_binning_monthly_agg.py b/dags/here_dynamic_binning_monthly_agg.py
new file mode 100644
index 000000000..75d7e9a29
--- /dev/null
+++ b/dags/here_dynamic_binning_monthly_agg.py
@@ -0,0 +1,110 @@
+import os
+import sys
+import logging
+from pendulum import duration, datetime
+
+from airflow.models import Variable
+from airflow.decorators import dag, task
+from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator
+from airflow.providers.postgres.hooks.postgres import PostgresHook
+
+try:
+    repo_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+    sys.path.insert(0, repo_path)
+    from dags.dag_functions import task_fail_slack_alert
+    from dags.custom_operators import SQLCheckOperatorWithReturnValue
+except:
+    raise ImportError("Cannot import slack alert functions")
+    
+LOGGER = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+doc_md = "This DAG is running off the `1132-here-aggregation-proposal` branch to test dynamic binning aggregation."
+DAG_NAME = 'here_dynamic_binning_monthly_agg'
+DAG_OWNERS = Variable.get('dag_owners', deserialize_json=True).get(DAG_NAME, ["Unknown"]) 
+
+default_args = {
+    'owner': ','.join(DAG_OWNERS),
+    'depends_on_past':False,
+    'start_date': datetime(2019, 1, 1, tz="America/Toronto"),
+    'retries': 1,
+    'retry_delay': duration(hours=1)
+    #'on_failure_callback': task_fail_slack_alert
+}
+
+@dag(
+    DAG_NAME,
+    default_args=default_args,
+    schedule='0 16 1 * *', # 4pm, first day of month
+    template_searchpath=os.path.join(repo_path,'here/traffic/sql/dynamic_bins'),
+    doc_md = doc_md,
+    tags=["HERE", "aggregation"],
+    max_active_runs=1,
+    catchup=True
+)
+
+#to add: catchup, one task at a time, depends on past.
+
+def here_dynamic_binning_monthly_agg():
+    
+    check_missing_dates = SQLCheckOperatorWithReturnValue(
+        sql="select-check_missing_days.sql",
+        task_id="check_missing_dates",
+        conn_id='congestion_bot',
+        retries = 0
+    )
+    
+    aggregate_monthly = SQLExecuteQueryOperator(
+        sql=[
+            "DELETE FROM gwolofs.congestion_segments_monthy_summary WHERE mnth = '{{ ds }}'",
+            "SELECT gwolofs.congestion_segment_monthly_agg('{{ ds }}')"
+        ],
+        task_id='aggregate_monthly',
+        conn_id='congestion_bot',
+        autocommit=True,
+        retries = 1
+    )
+    
+    create_groups = SQLExecuteQueryOperator(
+        sql="segment_grouping.sql",
+        task_id="create_segment_groups",
+        conn_id='congestion_bot',
+        retries = 0,
+        params={"max_group_size": 100}
+    )
+    
+    delete_data = SQLExecuteQueryOperator(
+        sql="DELETE FROM gwolofs.congestion_segments_monthly_bootstrap WHERE mnth = '{{ ds }}' AND n_resamples = 300",
+        task_id="delete_bootstrap_results",
+        conn_id='congestion_bot',
+        retries=0
+    )
+    
+    @task
+    def expand_groups(**context):
+        return context["ti"].xcom_pull(task_ids="create_segment_groups")[0][0]
+    
+    @task(retries=0, max_active_tis_per_dag=1)
+    def bootstrap_agg(segments, ds):
+        print(f"segments: {segments}")
+        postgres_cred = PostgresHook("congestion_bot")
+        query="""SELECT *
+            FROM UNNEST(%s::bigint[]) AS unnested(segment_id),
+            LATERAL (
+                SELECT gwolofs.congestion_segment_bootstrap(
+                                mnth := %s::date,
+                                segment_id := segment_id,
+                                n_resamples := 300)
+            ) AS lat"""
+        with postgres_cred.get_conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(query, (segments, ds))
+                conn.commit()
+    
+    expand = expand_groups()
+    
+    check_missing_dates >> aggregate_monthly >> create_groups >> delete_data
+    delete_data >> expand
+    bootstrap_agg.expand(segments=expand)
+
+here_dynamic_binning_monthly_agg()
\ No newline at end of file
diff --git a/dags/pull_here_path.py b/dags/pull_here_path.py
index aeaa4d8de..421c82987 100644
--- a/dags/pull_here_path.py
+++ b/dags/pull_here_path.py
@@ -3,10 +3,11 @@
 import pendulum
 from datetime import timedelta
 
-from airflow.decorators import task, dag
+from airflow.decorators import task, dag, task_group
 from airflow.hooks.base import BaseHook
 from airflow.models import Variable 
 from airflow.macros import ds_add, ds_format
+from airflow.operators.trigger_dagrun import TriggerDagRunOperator
 
 try:
     repo_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
@@ -45,7 +46,7 @@
 
 @dag(dag_id = dag_name,
      default_args=default_args,
-     schedule='30 10 * * *' ,
+     schedule='0 17 * * * ',
      catchup=False,
      doc_md = doc_md,
      tags=["HERE", "data_pull"]
@@ -85,6 +86,21 @@ def get_download_link(request_id: str, access_token: str):
     def load_data()->str:
         return '''curl $DOWNLOAD_URL | gunzip | psql -h $HOST -U $LOGIN -d bigdata -c "\\COPY here.ta_path_view FROM STDIN WITH (FORMAT csv, HEADER TRUE);" '''
 
-    load_data()
+    # Create a task group for triggering the DAGs
+    @task_group
+    def trigger_dags_tasks():
+        # Define TriggerDagRunOperator for each DAG to trigger
+        trigger_operators = []
+        DAGS_TO_TRIGGER = Variable.get('here_path_dag_triggers', deserialize_json=True)
+        for dag_id in DAGS_TO_TRIGGER:
+            trigger_operator = TriggerDagRunOperator(
+                task_id=f'trigger_{dag_id}',
+                trigger_dag_id=dag_id,
+                logical_date='{{macros.ds_add(ds, -1)}}',
+                reset_dag_run=True # Clear existing dag if already exists (for backfilling), old runs will not be in the logs
+            )
+            trigger_operators.append(trigger_operator)
+
+    load_data() >> trigger_dags_tasks()
 
 pull_here_path()
\ No newline at end of file
diff --git a/here/traffic/here_dynamic_binning_explore.ipynb b/here/traffic/here_dynamic_binning_explore.ipynb
new file mode 100644
index 000000000..5acc7016c
--- /dev/null
+++ b/here/traffic/here_dynamic_binning_explore.ipynb
@@ -0,0 +1,557 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8c6f35d7-fbd6-4336-91e3-4ab18b4009e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/data/jupyterhub/.venv/lib/python3.10/site-packages/geopandas/io/sql.py:170: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n",
+      "  df = pd.read_sql(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "import configparser\n",
+    "from psycopg2 import connect\n",
+    "import struct\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from datetime import datetime\n",
+    "import matplotlib as mpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.dates as mdates\n",
+    "import seaborn as sns\n",
+    "import geopandas as gpd\n",
+    "\n",
+    "CONFIG = configparser.ConfigParser()\n",
+    "CONFIG.read(str(Path.home().joinpath('db.cfg'))) #Creates a path to your db.cfg file\n",
+    "dbset = CONFIG['SQLALCHEMY']\n",
+    "\n",
+    "with connect(**dbset) as con:\n",
+    "    basemap_query = '''select gis.geopandas_transform(ST_union(geom)) as geom from gis.neighbourhood'''\n",
+    "    basemap = gpd.GeoDataFrame.from_postgis(basemap_query, con, geom_col='geom')\n",
+    "    basemap = basemap.to_crs('epsg:26917')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "def42f51-59b0-42bd-b300-5d1f3e3dee15",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_2029777/423225491.py:6: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n",
+      "  df = pd.read_sql(sql, con)\n"
+     ]
+    }
+   ],
+   "source": [
+    "sql = '''SELECT hr, bin_length, count, legend\n",
+    "FROM gwolofs.congestion_bin_length_explore'''\n",
+    "\n",
+    "try:\n",
+    "    with connect(**dbset) as con:\n",
+    "        df = pd.read_sql(sql, con)\n",
+    "except Exception as e:\n",
+    "    print(\"Error connecting to the database:\", e)\n",
+    "    exit()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a1a4f215-4fc4-4b0b-8223-870934a9c7f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Convert bin_length to string for categorical x-axis\n",
+    "df['bin_length'] = df['bin_length'].astype(str)\n",
+    "\n",
+    "# Compute proportions within each bin_size group\n",
+    "df['proportion'] = df.groupby('hr')['count'].transform(lambda x: x / x.sum())\n",
+    "\n",
+    "# Plot multi-bar chart\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "sns.barplot(x=df['bin_length'], y=df['proportion'], hue=df['hr'], palette='viridis')\n",
+    "plt.xlabel('Bin Size')\n",
+    "plt.ylabel('Proportion')\n",
+    "plt.title('Proportions of bins by duration and time of day')\n",
+    "plt.yticks([i * 0.01 for i in range(0, 100, 5)])\n",
+    "plt.xticks(rotation=45)\n",
+    "plt.legend(title='Hour of the Day')\n",
+    "plt.grid(axis='y', linestyle='--', alpha=0.7)\n",
+    "plt.show()\n",
+    "#note, higher proportion of longer bins before ~8am"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3e9c7d6d-6e1f-4214-b9cf-dd0b8e16daf5",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_1286164/1604576776.py:15: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n",
+      "  df = pd.read_sql(sql, con)\n"
+     ]
+    }
+   ],
+   "source": [
+    "sql = '''SELECT\n",
+    "    CASE\n",
+    "        WHEN time_grp = '[00:00:00,24:00:00)' THEN '24hr'\n",
+    "        WHEN (upper(time_grp) - lower(time_grp)) = '01:00:00'::interval THEN '1hr'\n",
+    "        ELSE 'Periods'\n",
+    "    END AS legend,\n",
+    "    lower(bin_range)::time AS bin_start,\n",
+    "    upper(bin_range)::time AS bin_end\n",
+    "FROM gwolofs.congestion_raw_segments\n",
+    "WHERE dt >= '2024-12-01' AND dt < '2024-12-02' AND segment_id = 2511\n",
+    "ORDER BY 1, 2'''\n",
+    "\n",
+    "try:\n",
+    "    with connect(**dbset) as con:\n",
+    "        df = pd.read_sql(sql, con)\n",
+    "        # Convert time columns to datetime\n",
+    "except Exception as e:\n",
+    "    print(\"Error connecting to the database:\", e)\n",
+    "    exit()\n",
+    "\n",
+    "# Convert time columns to seconds since midnight\n",
+    "def time_to_seconds(t):\n",
+    "    return t.hour * 3600 + t.minute * 60 + t.second\n",
+    "\n",
+    "df['bin_start'] = df['bin_start'].apply(time_to_seconds)\n",
+    "df['bin_end'] = df['bin_end'].apply(time_to_seconds)\n",
+    "df['duration'] = df['bin_end'] - df['bin_start']\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8d2ba18c-dc79-4a04-8da6-8139f5772b18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Assign numeric values for y-axis based on legend\n",
+    "y_labels = df['legend'].unique()\n",
+    "y_mapping = {label: i for i, label in enumerate(y_labels)}\n",
+    "df['y_pos'] = df['legend'].map(y_mapping)\n",
+    "\n",
+    "# Define color mapping\n",
+    "palette = sns.color_palette('viridis', n_colors=len(y_labels))\n",
+    "legend_colors = {label: palette[i] for i, label in enumerate(y_labels)}\n",
+    "\n",
+    "# Plot timeline graph using broken_barh\n",
+    "fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "for i, row in df.iterrows():\n",
+    "    ax.broken_barh([(row['bin_start'], row['duration'])], (row['y_pos'] - 0.4, 0.8),\n",
+    "                   color=legend_colors[row['legend']], edgecolor='white')\n",
+    "\n",
+    "ax.set_xlabel('Time of Day')\n",
+    "ax.set_ylabel('Legend')\n",
+    "ax.set_title('Timeline of Bin Ranges by time_grp')\n",
+    "ax.set_yticks(range(len(y_labels)))\n",
+    "ax.set_yticklabels(y_labels)\n",
+    "ax.grid(axis='x', linestyle='--', alpha=0.7)\n",
+    "\n",
+    "# Adjust x-ticks to every 3600 seconds (1 hour)\n",
+    "ax.set_xticks(range(0, 86400, 3600))\n",
+    "ax.set_xticklabels([f\"{h:02d}:00\" for h in range(24)])\n",
+    "plt.xticks(rotation=45)\n",
+    "\n",
+    "# Create legend\n",
+    "handles = [plt.Rectangle((0, 0), 1, 1, color=legend_colors[label]) for label in y_labels]\n",
+    "ax.legend(handles, y_labels, title='Legend')\n",
+    "\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d31bbf9c-f2f6-42c2-a0c6-9c43c8a5aeb9",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_2029777/1721737923.py:11: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n",
+      "  df = pd.read_sql(sql, con)\n"
+     ]
+    }
+   ],
+   "source": [
+    "sql = '''SELECT\n",
+    "    max_bin AS legend,\n",
+    "    lower(bin_range)::time AS bin_start,\n",
+    "    upper(bin_range)::time AS bin_end\n",
+    "FROM gwolofs.congestion_raw_segments_max_bin_analysis\n",
+    "WHERE dt >= '2024-12-01' AND dt < '2024-12-02' AND segment_id = 2511\n",
+    "ORDER BY 1, 2'''\n",
+    "\n",
+    "try:\n",
+    "    with connect(**dbset) as con:\n",
+    "        df = pd.read_sql(sql, con)\n",
+    "        # Convert time columns to datetime\n",
+    "except Exception as e:\n",
+    "    print(\"Error connecting to the database:\", e)\n",
+    "    exit()\n",
+    "\n",
+    "# Convert time columns to seconds since midnight\n",
+    "def time_to_seconds(t):\n",
+    "    return t.hour * 3600 + t.minute * 60 + t.second\n",
+    "\n",
+    "df['bin_start'] = df['bin_start'].apply(time_to_seconds)\n",
+    "df['bin_end'] = df['bin_end'].apply(time_to_seconds)\n",
+    "df['duration'] = df['bin_end'] - df['bin_start']\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3d5d92eb-711d-4b91-b2fd-4a26769b7538",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Assign numeric values for y-axis based on legend\n",
+    "y_labels = df['legend'].unique()\n",
+    "y_mapping = {label: i for i, label in enumerate(y_labels)}\n",
+    "df['y_pos'] = df['legend'].map(y_mapping)\n",
+    "\n",
+    "# Define color mapping\n",
+    "palette = sns.color_palette('viridis', n_colors=len(y_labels))\n",
+    "legend_colors = {label: palette[i] for i, label in enumerate(y_labels)}\n",
+    "\n",
+    "# Plot timeline graph using broken_barh\n",
+    "fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "for i, row in df.iterrows():\n",
+    "    ax.broken_barh([(row['bin_start'], row['duration'])], (row['y_pos'] - 0.4, 0.8),\n",
+    "                   color=legend_colors[row['legend']], edgecolor='white')\n",
+    "\n",
+    "ax.set_xlabel('Time of Day')\n",
+    "ax.set_ylabel('Legend')\n",
+    "ax.set_title('Timeline of Bin Ranges for Different Max Bin Lengths')\n",
+    "ax.set_yticks(range(len(y_labels)))\n",
+    "ax.set_yticklabels(y_labels)\n",
+    "ax.grid(axis='x', linestyle='--', alpha=0.7)\n",
+    "\n",
+    "# Adjust x-ticks to every 3600 seconds (1 hour)\n",
+    "ax.set_xticks(range(0, 86400, 3600))\n",
+    "ax.set_xticklabels([f\"{h:02d}:00\" for h in range(24)])\n",
+    "plt.xticks(rotation=45)\n",
+    "\n",
+    "# Create legend\n",
+    "handles = [plt.Rectangle((0, 0), 1, 1, color=legend_colors[label]) for label in y_labels]\n",
+    "ax.legend(handles, y_labels, title='Legend')\n",
+    "\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14483f0e-2cdf-46df-8284-a4662e7c4780",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#show the 95% context..\n",
+    "#raph's idea: cut off at 15 minutes, use the starting bin hour."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6d709c8a-1a4d-4aed-b402-f2eada4b3861",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_1286164/271536835.py:14: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n",
+      "  df = pd.read_sql(sql, con)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "          max_bin    count  percent_of_original\n",
+      "0 0 days 00:05:00  5647506             1.000000\n",
+      "1 0 days 00:10:00  5776554             1.022850\n",
+      "2 0 days 00:15:00  5793370             1.025828\n",
+      "3 0 days 00:20:00  5801453             1.027259\n",
+      "4 0 days 01:00:00  5813682             1.029425\n"
+     ]
+    }
+   ],
+   "source": [
+    "sql = '''WITH count_5min_bins AS (\n",
+    "SELECT COUNT(*)\n",
+    "FROM gwolofs.congestion_raw_segments_max_bin_analysis\n",
+    "WHERE max_bin = '00:05:00'::interval\n",
+    ")\n",
+    "\n",
+    "SELECT max_bin, COUNT(*), COUNT(*) / (SELECT count::numeric FROM count_5min_bins) AS percent_of_original\n",
+    "FROM gwolofs.congestion_raw_segments_max_bin_analysis\n",
+    "GROUP BY max_bin\n",
+    "ORDER BY 1\n",
+    "'''\n",
+    "try:\n",
+    "    with connect(**dbset) as con:\n",
+    "        df = pd.read_sql(sql, con)\n",
+    "        print(df)\n",
+    "except Exception as e:\n",
+    "    print(\"Error connecting to the database:\", e)\n",
+    "    exit()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "94d6d78f-f20a-4f95-aede-315e058361ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "This shows 15 minutes -> 1 hour max bin only results in 0.3% more observations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "697474c7-e0ba-49d0-9dcb-65e4538e9c06",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_1286164/2162353716.py:42: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n",
+      "  df = pd.read_sql(sql, con)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#query to identify which segments have a big discrepency.\n",
+    "sql = '''WITH bins AS (\n",
+    "    SELECT\n",
+    "        CASE\n",
+    "            WHEN time_grp = '[00:00:00,24:00:00)' THEN '24hr'\n",
+    "            WHEN (upper(time_grp) - lower(time_grp)) = '01:00:00'::interval THEN '1hr'\n",
+    "            ELSE 'Periods'\n",
+    "        END AS legend,\n",
+    "        bin_range,\n",
+    "        segment_id,\n",
+    "        dt,\n",
+    "        lower(bin_range) AS bin_start,\n",
+    "        upper(bin_range) AS bin_end\n",
+    "    FROM gwolofs.congestion_raw_segments\n",
+    "    WHERE dt >= '2024-12-01' AND dt < '2024-12-02'\n",
+    "    ORDER BY 1, 2\n",
+    "),\n",
+    "\n",
+    "overlap AS (\n",
+    "    SELECT\n",
+    "        segment_id,\n",
+    "        bin_range,\n",
+    "        dt,\n",
+    "        COUNT(*) FILTER (WHERE legend = '24hr') AS count_24hr,\n",
+    "        COUNT(*) FILTER (WHERE legend = '1hr') AS count_1hr,\n",
+    "        COUNT(*) FILTER (WHERE legend = 'Periods') AS count_period\n",
+    "    FROM bins\n",
+    "    GROUP BY 1, 2, 3\n",
+    ")\n",
+    "\n",
+    "SELECT\n",
+    "    segment_id,\n",
+    "    dt,\n",
+    "    COUNT(*) FILTER (WHERE count_24hr = 1 AND count_1hr = 1) / SUM(count_24hr) AS overlap_24hr_1_hr,\n",
+    "    COUNT(*) FILTER (WHERE count_24hr = 1 AND count_period = 1) / SUM(count_24hr) AS overlap_24hr_period\n",
+    "FROM overlap\n",
+    "GROUP BY segment_id, dt\n",
+    "ORDER BY 3'''\n",
+    "\n",
+    "try:\n",
+    "    with connect(**dbset) as con:\n",
+    "        df = pd.read_sql(sql, con)\n",
+    "        df.head\n",
+    "except Exception as e:\n",
+    "    print(\"Error connecting to the database:\", e)\n",
+    "    exit()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "4966c18a-7678-4913-8d1d-9df2035afe35",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_2029777/1152226507.py:11: UserWarning: pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.\n",
+      "  df = pd.read_sql(sql, con)\n"
+     ]
+    }
+   ],
+   "source": [
+    "sql = '''\n",
+    "SELECT ROUND(tt, 0) AS tt, COUNT(*)\n",
+    "FROM gwolofs.congestion_raw_segments_max_bin_analysis\n",
+    "WHERE max_bin = '00:15:00'::interval\n",
+    "GROUP BY 1\n",
+    "ORDER BY 1\n",
+    "'''\n",
+    "\n",
+    "try:\n",
+    "    with connect(**dbset) as con:\n",
+    "        df = pd.read_sql(sql, con)\n",
+    "except Exception as e:\n",
+    "    print(\"Error connecting to the database:\", e)\n",
+    "    exit()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6781e1d7-012a-4b43-bbe0-7608008ced36",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Compute cumulative distribution\n",
+    "df = df.sort_values(by='tt')\n",
+    "df['cumulative'] = df['count'].cumsum() / df['count'].sum()\n",
+    "\n",
+    "# Plot cumulative distribution\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "sns.lineplot(x=df['tt'], y=df['cumulative'], color='royalblue')\n",
+    "\n",
+    "plt.xlabel('Travel time (s)')\n",
+    "plt.ylabel('Cumulative Distribution')\n",
+    "plt.title('Cumulative Distribution of Congestion network travel times (for max_bin = ''00:15:00'')')\n",
+    "plt.xticks(np.arange(0, 241, 20))  # X-axis limits from 0 to 240\n",
+    "plt.yticks(np.arange(0, 1.05, 0.05), [f'{int(y*100)}%' for y in np.arange(0, 1.05, 0.05)])  # Y-axis every 5%\n",
+    "plt.xlim(0, 240)\n",
+    "plt.ylim(0, 1)\n",
+    "plt.grid(axis='both', linestyle='--', alpha=0.7)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "5a4f97c3-b3c3-4474-9925-fc908de6e09a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_map(data, basemap_b, centreline_b, highway_b, color, title):\n",
+    "    f, ax = plt.subplots(figsize=(20,20))\n",
+    "    if basemap_b == True:\n",
+    "        basemap.plot(ax=ax, color = 'grey', alpha=0.2)\n",
+    "    if centreline_b == True:\n",
+    "        centreline.plot(ax=ax, color = 'white', alpha=0.2)\n",
+    "    if highway_b == True:\n",
+    "        highway.plot(ax=ax, color = 'white', alpha=0.2)    \n",
+    "    \n",
+    "    data.plot(column = 'id', ax=ax, cmap=color)\n",
+    "    NUM_COLORS = len(data.col.unique())\n",
+    "    cm = plt.get_cmap(color)\n",
+    "    colors = [cm(1.*i/NUM_COLORS) for i in range(NUM_COLORS)]\n",
+    "    handles, labels = [], []\n",
+    "\n",
+    "    legend_id = data.col.unique()\n",
+    "    for i in range(0, NUM_COLORS):\n",
+    "        label_name = legend_id[i]\n",
+    "        handles.append(mpl.patches.Patch(color=colors[i],label=label_name))\n",
+    "    ax.legend(handles=handles,loc='lower right', ncol=1, title = title)    \n",
+    "    ax.set_axis_off()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/here/traffic/sql/dynamic_bins/corridor_agg.sql b/here/traffic/sql/dynamic_bins/corridor_agg.sql
new file mode 100644
index 000000000..b1cb9e9b8
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/corridor_agg.sql
@@ -0,0 +1,22 @@
+--test: 35 projects, 1 day = 47s
+SELECT
+    gwolofs.congestion_cache_tt_results_daily(
+        node_start := congestion_corridors.node_start,
+        node_end := congestion_corridors.node_end,
+        start_date := dates.dt::date
+    )
+FROM gwolofs.congestion_corridors
+JOIN gwolofs.congestion_projects USING (project_id),
+    generate_series('2025-01-01', '2025-02-28', '1 day'::interval) AS dates (dt)
+WHERE
+    congestion_projects.description IN (
+        'Avenue Road cycleway installation',
+        'bluetooth_corridors',
+        'scrutinized-cycleway-corridors'
+    )
+    AND corridor_id NOT IN (
+        SELECT DISTINCT corridor_id
+        FROM gwolofs.congestion_raw_corridors
+        WHERE dt >= '2025-01-01' AND dt < '2025-02-28'
+    )
+    AND map_version = '23_4';
\ No newline at end of file
diff --git a/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql
new file mode 100644
index 000000000..d95e82638
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/create-function-congestion_segment_bootstrap.sql
@@ -0,0 +1,91 @@
+--DROP FUNCTION gwolofs.congestion_segment_bootstrap(date,bigint,integer);
+
+CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_bootstrap(
+    mnth date,
+    segment_id bigint,
+    n_resamples int
+)
+RETURNS void
+LANGUAGE SQL
+COST 100
+VOLATILE PARALLEL SAFE
+AS $BODY$
+
+    SELECT setseed(('0.'||replace(mnth::text, '-', ''))::numeric);
+    
+    WITH raw_obs AS (
+        SELECT
+            --segment_id and mnth don't need to be in group by until end
+            EXTRACT('isodow' FROM dt) IN (1, 2, 3, 4, 5) AS is_wkdy,
+            hr,
+            ARRAY_AGG(tt::real) AS tt_array,
+            AVG(tt::real) AS avg_tt,
+            COUNT(*) AS n
+        FROM gwolofs.congestion_raw_segments
+        WHERE -- same params as the above aggregation
+            dt >= congestion_segment_bootstrap.mnth
+            AND dt < congestion_segment_bootstrap.mnth + interval '1 month'
+            AND segment_id = congestion_segment_bootstrap.segment_id
+        GROUP BY
+            segment_id,
+            is_wkdy,
+            hr
+    ),
+    
+    random_selections AS (
+        SELECT
+            raw_obs.is_wkdy,
+            raw_obs.hr,
+            raw_obs.avg_tt,
+            raw_obs.n,
+            sample_group.group_id,
+            --get a random observation from the array of tts
+            AVG(raw_obs.tt_array[ceiling(random() * raw_obs.n)]) AS rnd_avg_tt
+        FROM raw_obs
+        CROSS JOIN generate_series(1, n)
+        -- 200 resamples (could be any number)
+        CROSS JOIN generate_series(1, congestion_segment_bootstrap.n_resamples) AS sample_group(group_id)
+        GROUP BY
+            raw_obs.is_wkdy,
+            raw_obs.hr,
+            raw_obs.avg_tt,
+            raw_obs.n,
+            sample_group.group_id
+    )
+    
+    INSERT INTO gwolofs.congestion_segments_monthly_bootstrap (
+        segment_id, mnth, is_wkdy, hr, avg_tt, n, n_resamples, ci_lower, ci_upper
+    )
+    SELECT
+        congestion_segment_bootstrap.segment_id,
+        congestion_segment_bootstrap.mnth,
+        is_wkdy,
+        hr,
+        avg_tt::real,
+        n,
+        n_resamples,
+        percentile_disc(0.025) WITHIN GROUP (ORDER BY rnd_avg_tt)::real AS ci_lower,
+        percentile_disc(0.975) WITHIN GROUP (ORDER BY rnd_avg_tt)::real AS ci_upper
+    FROM random_selections
+    GROUP BY
+        is_wkdy,
+        hr,
+        avg_tt,
+        n;
+
+    $BODY$;
+
+GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_bootstrap(
+    date, bigint, integer
+) TO congestion_bot;
+
+/*Usage example: (works best one segment at a time with Lateral)
+SELECT *
+FROM UNNEST('{1,2,3,4,5,6,7,8,9}'::bigint[]) AS unnested(segment_id)
+LATERAL (
+    SELECT gwolofs.congestion_segment_bootstrap(
+                    mnth := '2025-06-01'::date,
+                    segment_ids := segment_id,
+                    n_resamples := 300)
+)
+*/
\ No newline at end of file
diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql
new file mode 100644
index 000000000..7c09a0628
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/create-table-congestion_corridors.sql
@@ -0,0 +1,40 @@
+-- Table: gwolofs.congestion_corridors
+
+-- DROP TABLE IF EXISTS gwolofs.congestion_corridors;
+
+CREATE TABLE IF NOT EXISTS gwolofs.congestion_corridors
+(
+    link_dirs text [] COLLATE pg_catalog."default",
+    lengths numeric [],
+    geom geometry,
+    total_length numeric,
+    corridor_id smallint NOT NULL DEFAULT nextval('congestion_corridors_uid_seq'::regclass),
+    node_start bigint NOT NULL,
+    node_end bigint NOT NULL,
+    map_version text COLLATE pg_catalog."default" NOT NULL,
+    corridor_streets text COLLATE pg_catalog."default",
+    corridor_start text COLLATE pg_catalog."default",
+    corridor_end text COLLATE pg_catalog."default",
+    project_id integer,
+    CONSTRAINT congestion_corridors_pkey PRIMARY KEY (node_start, node_end, map_version),
+    CONSTRAINT corridor_pkey UNIQUE NULLS NOT DISTINCT (corridor_id),
+    CONSTRAINT project_id_fk FOREIGN KEY (project_id)
+    REFERENCES gwolofs.congestion_projects (project_id) MATCH SIMPLE
+    ON UPDATE NO ACTION
+    ON DELETE NO ACTION
+    NOT VALID
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS gwolofs.congestion_corridors
+OWNER TO gwolofs;
+
+REVOKE ALL ON TABLE gwolofs.congestion_corridors FROM bdit_humans;
+
+GRANT SELECT ON TABLE gwolofs.congestion_corridors TO bdit_humans;
+
+GRANT ALL ON TABLE gwolofs.congestion_corridors TO gwolofs;
+
+COMMENT ON TABLE gwolofs.congestion_corridors IS
+'Stores cached travel time corridors to reduce routing time.';
diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_projects.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_projects.sql
new file mode 100644
index 000000000..67ae3a2bc
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/create-table-congestion_projects.sql
@@ -0,0 +1,22 @@
+-- Table: gwolofs.congestion_projects
+
+-- DROP TABLE IF EXISTS gwolofs.congestion_projects;
+
+CREATE TABLE IF NOT EXISTS gwolofs.congestion_projects
+(
+    project_id integer NOT NULL DEFAULT nextval('congestion_projects_project_id_seq'::regclass),
+    description text COLLATE pg_catalog."default" NOT NULL,
+    CONSTRAINT congestion_projects_pkey PRIMARY KEY (project_id),
+    CONSTRAINT unique_prj_description UNIQUE NULLS NOT DISTINCT (description)
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS gwolofs.congestion_projects
+OWNER TO gwolofs;
+
+REVOKE ALL ON TABLE gwolofs.congestion_projects FROM bdit_humans;
+
+GRANT SELECT ON TABLE gwolofs.congestion_projects TO bdit_humans;
+
+GRANT ALL ON TABLE gwolofs.congestion_projects TO gwolofs;
diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql
new file mode 100644
index 000000000..2d6f294ca
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_corridors.sql
@@ -0,0 +1,80 @@
+-- Table: gwolofs.congestion_raw_corridors
+
+-- DROP TABLE IF EXISTS gwolofs.congestion_raw_corridors;
+
+CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_corridors
+(
+    corridor_id smallint,
+    time_grp timerange NOT NULL,
+    bin_range tsrange NOT NULL,
+    tt real,
+    num_obs integer,
+    uri_string text COLLATE pg_catalog."default",
+    dt date,
+    hr smallint,
+    CONSTRAINT congestion_raw_corridors_pkey PRIMARY KEY (corridor_id, bin_range, time_grp),
+    CONSTRAINT corridor_fkey FOREIGN KEY (corridor_id)
+    REFERENCES gwolofs.congestion_corridors (corridor_id) MATCH SIMPLE
+    ON UPDATE NO ACTION
+    ON DELETE CASCADE
+    NOT VALID
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS gwolofs.congestion_raw_corridors
+OWNER TO gwolofs;
+
+REVOKE ALL ON TABLE gwolofs.congestion_raw_corridors FROM bdit_humans;
+
+GRANT SELECT ON TABLE gwolofs.congestion_raw_corridors TO bdit_humans;
+
+GRANT ALL ON TABLE gwolofs.congestion_raw_corridors TO gwolofs;
+
+-- Index: congestion_raw_corridors_dt_idx
+
+-- DROP INDEX IF EXISTS gwolofs.congestion_raw_corridors_dt_idx;
+
+CREATE INDEX IF NOT EXISTS congestion_raw_corridors_dt_idx
+ON gwolofs.congestion_raw_corridors USING brin
+(dt)
+TABLESPACE pg_default;
+-- Index: congestion_raw_corridors_uri_string
+
+-- DROP INDEX IF EXISTS gwolofs.congestion_raw_corridors_uri_string;
+
+CREATE INDEX IF NOT EXISTS congestion_raw_corridors_uri_string
+ON gwolofs.congestion_raw_corridors USING btree
+(uri_string COLLATE pg_catalog."default" ASC NULLS LAST)
+WITH (deduplicate_items = TRUE)
+TABLESPACE pg_default;
+-- Index: dynamic_binning_results_time_grp_corridor_id_idx
+
+-- DROP INDEX IF EXISTS gwolofs.dynamic_binning_results_time_grp_corridor_id_idx;
+
+CREATE INDEX IF NOT EXISTS dynamic_binning_results_time_grp_corridor_id_idx
+ON gwolofs.congestion_raw_corridors USING btree
+(time_grp ASC NULLS LAST, corridor_id ASC NULLS LAST, dt ASC NULLS LAST)
+WITH (deduplicate_items = TRUE)
+TABLESPACE pg_default;
+
+COMMENT ON TABLE gwolofs.congestion_raw_corridors IS
+'Stores dynamic binning results for custom corridor based travel time requests.';
+
+COMMENT ON TABLE gwolofs.congestion_raw_corridors
+IS 'Stores dynamic binning results from standard HERE congestion network travel time aggregations.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_corridors.bin_range
+IS 'Bin range. An exclusion constraint on a temp table prevents overlapping ranges during insert.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_corridors.tt
+IS 'Travel time in seconds.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_corridors.num_obs
+IS 'The sum of the sample size from here.ta_path.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_corridors.dt
+IS 'The date of aggregation for the record. Records may not overlap dates.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_corridors.hr
+IS 'The hour the majority of the record occured in. Ties are rounded up.';
diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql
new file mode 100644
index 000000000..cfcc515bb
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/create-table-congestion_raw_segments.sql
@@ -0,0 +1,79 @@
+-- Table: gwolofs.congestion_raw_segments
+
+-- DROP TABLE IF EXISTS gwolofs.congestion_raw_segments;
+
+CREATE TABLE IF NOT EXISTS gwolofs.congestion_raw_segments
+(
+    segment_id integer NOT NULL,
+    dt date NOT NULL,
+    bin_start timestamp without time zone NOT NULL,
+    bin_range tsrange NOT NULL,
+    tt real,
+    num_obs integer,
+    hr smallint,
+    CONSTRAINT congestion_raw_segments_pkey PRIMARY KEY (segment_id, dt, bin_start)
+) PARTITION BY RANGE (dt);
+
+ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments
+OWNER TO gwolofs;
+
+REVOKE ALL ON TABLE gwolofs.congestion_raw_segments FROM bdit_humans;
+
+GRANT SELECT ON TABLE gwolofs.congestion_raw_segments TO bdit_humans;
+
+GRANT ALL ON TABLE gwolofs.congestion_raw_segments TO gwolofs;
+-- Index: congestion_raw_segments_dt_idx
+
+-- DROP INDEX IF EXISTS gwolofs.congestion_raw_segments_dt_idx;
+
+CREATE INDEX IF NOT EXISTS congestion_raw_segments_dt_idx
+ON gwolofs.congestion_raw_segments USING brin
+(dt);
+-- Index: congestion_raw_segments_segment_dt_idx
+
+-- DROP INDEX IF EXISTS gwolofs.congestion_raw_segments_segment_dt_idx;
+
+CREATE INDEX IF NOT EXISTS congestion_raw_segments_segment_dt_idx
+ON gwolofs.congestion_raw_segments USING btree
+(segment_id ASC NULLS LAST, bin_start ASC NULLS LAST);
+
+-- Partitions SQL
+
+CREATE TABLE gwolofs.congestion_raw_segments_2023 PARTITION OF gwolofs.congestion_raw_segments
+FOR VALUES FROM ('2023-01-01') TO ('2024-01-01')
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments_2023
+OWNER TO gwolofs;
+
+CREATE TABLE gwolofs.congestion_raw_segments_2024 PARTITION OF gwolofs.congestion_raw_segments
+FOR VALUES FROM ('2024-01-01') TO ('2025-01-01')
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments_2024
+OWNER TO gwolofs;
+
+CREATE TABLE gwolofs.congestion_raw_segments_2025 PARTITION OF gwolofs.congestion_raw_segments
+FOR VALUES FROM ('2025-01-01') TO ('2026-01-01')
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS gwolofs.congestion_raw_segments_2025
+OWNER TO gwolofs;
+
+COMMENT ON COLUMN gwolofs.congestion_raw_segments.dt
+IS 'The date of aggregation for the record. Records may not overlap dates.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_segments.bin_start
+IS 'The start of the observation. It is recommended to use `hr` to group the bin instead. This column is used in the primary key, although the main constraint occurs during insert (non overlapping ranges).';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_segments.bin_range
+IS 'Bin range. An exclusion constraint on a temp table prevents overlapping ranges during insert.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_segments.tt
+IS 'Travel time in seconds.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_segments.num_obs
+IS 'The sum of the sample size from here.ta_path.';
+
+COMMENT ON COLUMN gwolofs.congestion_raw_segments.hr
+IS 'The hour the majority of the record occured in. Ties are rounded up.';
diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql
new file mode 100644
index 000000000..52d71097d
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthly_bootstrap.sql
@@ -0,0 +1,33 @@
+-- Table: gwolofs.congestion_segments_monthly_bootstrap
+
+-- DROP TABLE IF EXISTS gwolofs.congestion_segments_monthly_bootstrap;
+
+CREATE TABLE IF NOT EXISTS gwolofs.congestion_segments_monthly_bootstrap
+(
+    segment_id integer NOT NULL,
+    mnth date NOT NULL,
+    is_wkdy boolean NOT NULL,
+    hr smallint NOT NULL,
+    avg_tt real,
+    n smallint,
+    ci_lower real,
+    ci_upper real,
+    n_resamples smallint NOT NULL,
+    CONSTRAINT congestion_segments_monthly_bootstrap_pkey PRIMARY KEY (segment_id, mnth, is_wkdy, hr, n_resamples)
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS gwolofs.congestion_segments_monthly_bootstrap
+OWNER TO gwolofs;
+
+REVOKE ALL ON TABLE gwolofs.congestion_segments_monthly_bootstrap FROM bdit_humans;
+REVOKE ALL ON TABLE gwolofs.congestion_segments_monthly_bootstrap FROM congestion_bot;
+
+GRANT SELECT, TRIGGER, REFERENCES ON TABLE gwolofs.congestion_segments_monthly_bootstrap TO bdit_humans WITH GRANT OPTION;
+
+GRANT INSERT, SELECT, DELETE ON TABLE gwolofs.congestion_segments_monthly_bootstrap TO congestion_bot;
+
+GRANT ALL ON TABLE gwolofs.congestion_segments_monthly_bootstrap TO dbadmin;
+
+GRANT ALL ON TABLE gwolofs.congestion_segments_monthly_bootstrap TO rds_superuser WITH GRANT OPTION;
diff --git a/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql
new file mode 100644
index 000000000..09e2c0733
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/create-table-congestion_segments_monthy_summary.sql
@@ -0,0 +1,30 @@
+-- Table: gwolofs.congestion_segments_monthy_summary
+
+-- DROP TABLE IF EXISTS gwolofs.congestion_segments_monthy_summary;
+
+CREATE TABLE IF NOT EXISTS gwolofs.congestion_segments_monthy_summary
+(
+    segment_id integer,
+    mnth date,
+    is_wkdy boolean,
+    hr smallint,
+    avg_tt real,
+    stdev real,
+    percentile_05 real,
+    percentile_15 real,
+    percentile_50 real,
+    percentile_85 real,
+    percentile_95 real,
+    num_quasi_obs smallint
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS gwolofs.congestion_segments_monthy_summary
+OWNER TO gwolofs;
+
+REVOKE ALL ON TABLE gwolofs.congestion_segments_monthy_summary FROM bdit_humans;
+
+GRANT SELECT ON TABLE gwolofs.congestion_segments_monthy_summary TO bdit_humans;
+
+GRANT ALL ON TABLE gwolofs.congestion_segments_monthy_summary TO gwolofs;
diff --git a/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql b/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql
new file mode 100644
index 000000000..98d828139
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/create-view-congestion_time_grps.sql
@@ -0,0 +1,35 @@
+--these time periods should be scrutinized more.
+--structure may also need changes if we want different weekday and weekend time periods.
+
+CREATE VIEW gwolofs.congestion_time_grps AS
+
+SELECT
+    start_tod,
+    end_tod,
+    1 AS table_order
+FROM (
+    VALUES
+    ('00:00:00'::time, '06:00:00'::time),
+    ('06:00:00'::time, '10:00:00'::time),
+    ('10:00:00'::time, '15:00:00'::time),
+    ('15:00:00'::time, '19:00:00'::time),
+    ('19:00:00'::time, '24:00:00'::time)
+) AS times (start_tod, end_tod)
+UNION
+SELECT
+    (start_hour || ':00')::time AS start_tod,
+    (start_hour + 1 || ':00')::time AS end_tod,
+    2 AS table_order
+FROM generate_series(0, 23, 1) AS start_hour
+ORDER BY
+    table_order,
+    start_tod,
+    end_tod;
+
+COMMENT ON VIEW gwolofs.congestion_time_grps
+IS 'Hours and time periods for congestion aggregation.';
+
+ALTER VIEW gwolofs.congestion_time_grps OWNER TO gwolofs;
+
+GRANT SELECT ON TABLE gwolofs.congestion_time_grps TO bdit_humans;
+GRANT ALL ON TABLE gwolofs.congestion_time_grps TO gwolofs;
diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql
new file mode 100644
index 000000000..ef95b0de5
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_corridor.sql
@@ -0,0 +1,103 @@
+-- FUNCTION: gwolofs.congestion_cache_corridor(bigint, bigint, text)
+
+-- DROP FUNCTION IF EXISTS gwolofs.congestion_cache_corridor(bigint, bigint, text);
+
+CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_corridor(
+    node_start bigint,
+    node_end bigint,
+    map_version text,
+    OUT corridor_id smallint,
+    OUT link_dirs text [],
+    OUT lengths numeric [],
+    OUT total_length numeric
+)
+RETURNS record
+LANGUAGE plpgsql
+COST 100
+VOLATILE PARALLEL SAFE
+AS $BODY$
+
+DECLARE
+    routing_function text := 'get_links_btwn_nodes_' || map_version;
+    street_geoms_table text := 'routing_streets_' || map_version;
+    traffic_streets_table text := 'traffic_streets_' || map_version;
+
+BEGIN
+
+    --check if the node pair and map_version have already been routed
+    --and if so, return values, saving routing time
+    SELECT
+        tt.corridor_id,
+        tt.link_dirs,
+        tt.lengths,
+        tt.total_length
+        INTO corridor_id, link_dirs, lengths, total_length
+    FROM gwolofs.congestion_corridors AS tt
+    WHERE
+        tt.node_start = congestion_cache_corridor.node_start
+        AND tt.node_end = congestion_cache_corridor.node_end
+        AND tt.map_version = congestion_cache_corridor.map_version;
+    IF FOUND THEN
+        RETURN;
+    END IF;
+    
+EXECUTE format (
+    $$
+        WITH routed_links AS (
+            SELECT link_dir, seq
+            FROM here_gis.%1$I(%2$L, %3$L),
+            UNNEST (links) WITH ORDINALITY AS unnested (link_dir, seq)
+        )
+        
+        INSERT INTO gwolofs.congestion_corridors (
+            node_start, node_end, map_version, link_dirs, lengths, geom,
+            total_length, corridor_streets, corridor_start, corridor_end
+        )
+        SELECT
+            %2$L AS node_start,
+            %3$L AS node_end,
+            %4$L AS map_version,
+            ARRAY_AGG(rl.link_dir ORDER BY rl.seq) AS link_dirs,
+            --lengths in m
+            ARRAY_AGG(st_length(st_transform(streets.geom, 2952)) ORDER BY rl.seq) AS lengths,
+            st_union(st_linemerge(streets.geom)) AS geom,
+            SUM(ST_Length(ST_Transform(streets.geom, 2952))) AS total_length,
+            string_agg(DISTINCT initcap(traffic_streets.st_name),
+                ' / ' ORDER BY initcap(traffic_streets.st_name)) AS corridor_streets,
+            gwolofs.identify_node_streets(%2$L, %4$L,
+                array_agg(DISTINCT initcap(traffic_streets.st_name))) AS corridor_start,
+            gwolofs.identify_node_streets(%3$L, %4$L,
+                array_agg(DISTINCT initcap(traffic_streets.st_name))) AS corridor_end
+        FROM routed_links AS rl
+        JOIN here.%5$I AS streets USING (link_dir)
+        LEFT JOIN here_gis.%6$I AS traffic_streets USING (link_id)
+        --conflict would occur because of null values
+        ON CONFLICT (node_start, node_end, map_version)
+        DO UPDATE
+        SET
+            link_dirs = excluded.link_dirs,
+            lengths = excluded.lengths,
+            total_length = excluded.total_length,
+            corridor_streets = excluded.corridor_streets,
+            corridor_start = excluded.corridor_start,
+            corridor_end = excluded.corridor_end
+        --returned values are used by fn congestion_cache_tt_results
+        RETURNING corridor_id, link_dirs, lengths, total_length
+    $$,
+    routing_function, node_start, node_end, -- For routed_links
+    map_version,      -- For INSERT / SELECT values
+    street_geoms_table,       -- For JOIN here.%5$I AS streets
+    traffic_streets_table     -- For LEFT JOIN here_gis.%6$I AS traffic_streets
+) INTO corridor_id, link_dirs, lengths, total_length;
+RETURN;
+END;
+$BODY$;
+
+ALTER FUNCTION gwolofs.congestion_cache_corridor(bigint, bigint, text)
+OWNER TO gwolofs;
+
+COMMENT ON FUNCTION gwolofs.congestion_cache_corridor IS
+'Returns definition of a HERE corridor, given input nodes and map_version.
+First checks if corridor has already been cached and if so retrieves the
+cached values. If not, a new entry is added to gwolofs.congestion_corridors
+table and returned.';
\ No newline at end of file
diff --git a/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql
new file mode 100644
index 000000000..1c486eada
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/function-congestion_cache_tt_results.sql
@@ -0,0 +1,77 @@
+-- FUNCTION: gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --noqa: LT05
+
+-- DROP FUNCTION IF EXISTS gwolofs.congestion_cache_tt_results(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); --noqa: LT05
+
+CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_tt_results(
+    uri_string text,
+    start_date date,
+    end_date date,
+    start_tod time without time zone,
+    end_tod time without time zone,
+    dow_list integer [],
+    node_start bigint,
+    node_end bigint,
+    holidays boolean
+)
+RETURNS void
+LANGUAGE SQL
+COST 100
+VOLATILE PARALLEL UNSAFE
+AS $BODY$
+
+    --insert into the final table
+    INSERT INTO gwolofs.congestion_raw_corridors (
+        uri_string, dt, time_grp, corridor_id,  bin_range, tt, num_obs, hr
+    )
+    SELECT
+        congestion_cache_tt_results.uri_string,
+        dt, time_grp, corridor_id, bin_range, tt, num_obs, hr
+    FROM gwolofs.congestion_return_dynamic_bins(
+        congestion_cache_tt_results.start_date,
+        congestion_cache_tt_results.end_date,
+        congestion_cache_tt_results.start_tod,
+        congestion_cache_tt_results.end_tod,
+        congestion_cache_tt_results.dow_list,
+        congestion_cache_tt_results.node_start,
+        congestion_cache_tt_results.node_end,
+        congestion_cache_tt_results.holidays
+    )
+    ON CONFLICT DO NOTHING;
+    
+$BODY$;
+
+ALTER FUNCTION gwolofs.congestion_cache_tt_results(
+    text, date, date, time without time zone,
+    time without time zone, integer [], bigint, bigint, boolean
+)
+OWNER TO gwolofs;
+
+COMMENT ON FUNCTION gwolofs.congestion_cache_tt_results IS
+'Caches the dynamic binning results for a request.';
+
+-- overload the function for more straightforward situation of daily corridor agg
+CREATE OR REPLACE FUNCTION gwolofs.congestion_cache_tt_results_daily(
+    start_date date,
+    node_start bigint,
+    node_end bigint
+)
+RETURNS void
+LANGUAGE sql
+COST 100
+VOLATILE PARALLEL UNSAFE
+AS
+$BODY$
+SELECT gwolofs.congestion_cache_tt_results(
+    uri_string := NULL::text,
+    start_date := congestion_cache_tt_results_daily.start_date,
+    end_date := congestion_cache_tt_results_daily.start_date + 1,
+    start_tod := '00:00'::time without time zone,
+    end_tod := '24:00'::time without time zone,
+    dow_list := ARRAY[extract('isodow' from congestion_cache_tt_results_daily.start_date)]::int[],
+    node_start := congestion_cache_tt_results_daily.node_start,
+    node_end := congestion_cache_tt_results_daily.node_end,
+    holidays := True)
+$BODY$;
+
+COMMENT ON FUNCTION gwolofs.congestion_cache_tt_results_daily
+IS 'A simplified version of `congestion_cache_tt_results` for aggregating entire days of data.';
diff --git a/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql b/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql
new file mode 100644
index 000000000..338076d44
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/function-congestion_dynamic_bin_avg.sql
@@ -0,0 +1,73 @@
+-- FUNCTION: gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --noqa: LT05
+
+-- DROP FUNCTION IF EXISTS gwolofs.congestion_dynamic_bin_avg(date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); --noqa: LT05
+
+CREATE OR REPLACE FUNCTION gwolofs.congestion_dynamic_bin_avg(
+    start_date date,
+    end_date date,
+    start_tod time without time zone,
+    end_tod time without time zone,
+    dow_list integer [],
+    node_start bigint,
+    node_end bigint,
+    holidays boolean
+)
+RETURNS numeric
+LANGUAGE plpgsql
+COST 100
+VOLATILE PARALLEL UNSAFE
+AS $BODY$
+
+DECLARE uri_string_func text :=
+    congestion_dynamic_bin_avg.node_start::text || '/' ||
+    congestion_dynamic_bin_avg.node_end::text  || '/' ||
+    congestion_dynamic_bin_avg.start_tod::text || '/' ||
+    congestion_dynamic_bin_avg.end_tod::text || '/' ||
+    congestion_dynamic_bin_avg.start_date::text || '/' ||
+    congestion_dynamic_bin_avg.end_date::text || '/' ||
+    congestion_dynamic_bin_avg.holidays::text || '/' ||
+    congestion_dynamic_bin_avg.dow_list::text;
+    res numeric;
+
+BEGIN
+
+--caches the dynamic binning results for this query
+PERFORM gwolofs.congestion_cache_tt_results(
+    uri_string := uri_string_func,
+    start_date := congestion_dynamic_bin_avg.start_date,
+    end_date := congestion_dynamic_bin_avg.end_date,
+    start_tod := congestion_dynamic_bin_avg.start_tod,
+    end_tod := congestion_dynamic_bin_avg.end_tod,
+    dow_list := congestion_dynamic_bin_avg.dow_list,
+    node_start := congestion_dynamic_bin_avg.node_start,
+    node_end := congestion_dynamic_bin_avg.node_end,
+    holidays := congestion_dynamic_bin_avg.holidays
+);
+
+--the way we currently do it; find daily averages and then average.
+WITH daily_means AS (
+    SELECT
+        dt_start::date,
+        AVG(tt) AS daily_mean
+    FROM gwolofs.congestion_raw_corridors
+    WHERE uri_string = uri_string_func
+    GROUP BY dt_start::date
+)
+
+SELECT AVG(daily_mean) INTO res
+FROM daily_means;
+
+RETURN res;
+
+END;
+
+$BODY$;
+
+ALTER FUNCTION gwolofs.congestion_dynamic_bin_avg(
+    date, date, time without time zone, time without time zone, integer [], bigint, bigint, boolean
+)
+OWNER TO gwolofs;
+
+COMMENT ON FUNCTION gwolofs.congestion_dynamic_bin_avg IS
+'Meant to mimic the TT app process; caches results for a specific request and 
+then returns average TT.';
diff --git a/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql
new file mode 100644
index 000000000..f5905d600
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/function-congestion_network_segment_agg.sql
@@ -0,0 +1,201 @@
+-- FUNCTION: gwolofs.congestion_network_segment_agg(date)
+
+-- DROP FUNCTION IF EXISTS gwolofs.congestion_network_segment_agg(date);
+
+CREATE OR REPLACE FUNCTION gwolofs.congestion_network_segment_agg(
+    start_date date
+)
+RETURNS void
+LANGUAGE plpgsql
+COST 100
+VOLATILE PARALLEL UNSAFE
+AS $BODY$
+
+DECLARE
+    map_version text := gwolofs.congestion_select_map_version(start_date, start_date + 1, 'path');
+    congestion_network_table text := 'network_links_' || map_version
+    || CASE map_version WHEN '23_4' THEN '_geom' ELSE '' END; --temp fix version
+
+BEGIN
+
+--using a temp table to aply the exclusion constraint should prevent the
+--insert from getting bogged down by large constraint on main table over time
+DROP TABLE IF EXISTS congestion_raw_segments_temp;
+CREATE TEMPORARY TABLE congestion_raw_segments_temp (
+    segment_id integer NOT NULL,
+    bin_start timestamp without time zone NOT NULL,
+    bin_range tsrange NOT NULL,
+    tt numeric,
+    num_obs integer,
+    CONSTRAINT congestion_raw_segments_exclude_temp EXCLUDE USING gist (
+        bin_range WITH &&,
+        segment_id WITH =
+    )
+) ON COMMIT DROP;
+
+EXECUTE FORMAT(
+    $$
+        DROP TABLE IF EXISTS segment_5min_bins;
+        CREATE TEMP TABLE segment_5min_bins ON COMMIT DROP AS
+        SELECT
+            seg.segment_id,
+            ta.tx,
+            seg.segment_length AS total_length,
+            ROW_NUMBER() OVER w AS bin_rank,
+            SUM(seg.length) / seg.segment_length AS sum_length,
+            SUM(seg.length) AS length_w_data,
+            SUM(seg.length / ta.mean * 3.6) AS unadjusted_tt,
+            SUM(sample_size) AS num_obs,
+            ARRAY_AGG(ta.link_dir ORDER BY ta.link_dir) AS link_dirs,
+            ARRAY_AGG(lat.tt ORDER BY ta.link_dir) AS tts,
+            ARRAY_AGG(seg.length ORDER BY ta.link_dir) AS lengths
+        FROM here.ta_path AS ta
+        JOIN congestion.%1$I AS seg USING (link_dir),
+        LATERAL (
+            SELECT seg.length / ta.mean * 3.6 AS tt
+        ) AS lat
+        WHERE
+            ta.dt >= %2$L::date
+            AND ta.dt < %2$L::date + interval '1 day'
+        GROUP BY
+            seg.segment_id,
+            ta.tx,
+            seg.segment_length
+        WINDOW w AS (
+            PARTITION BY seg.segment_id
+            ORDER BY ta.tx
+        );
+    $$, congestion_network_table, start_date);
+
+    CREATE INDEX idx_s5b_segment_rank ON segment_5min_bins(segment_id, bin_rank);
+    CREATE INDEX idx_s5b_segment_tx ON segment_5min_bins(segment_id, tx);
+    ANALYZE segment_5min_bins;
+    
+    --within each segment/hour, generate all possible forward looking bin combinations
+    --don't generate options for bins with sufficient length
+    --also don't generate options past the next bin with 80% length
+    DROP TABLE IF EXISTS dynamic_bin_options;
+    CREATE TEMP TABLE dynamic_bin_options ON COMMIT DROP AS
+    SELECT
+            tx,
+            segment_id,
+            bin_rank AS start_bin,
+            --generate all the options for the end bin within the group.
+            generate_series(
+                CASE
+                    WHEN sum_length >= 0.8 THEN bin_rank
+                    --if length is insufficient, need at least 1 more bin
+                    ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w)
+                END,
+                CASE
+                    --dont need to generate options when start segment is already sufficient
+                    WHEN sum_length >= 0.8 THEN bin_rank
+                    --generate options until 1 bin has sufficient length, otherwise until last bin in group
+                    ELSE COALESCE(
+                        MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w,
+                        MAX(bin_rank) OVER w
+                    )
+                END,
+                1
+            ) AS end_bin
+        FROM segment_5min_bins
+        WINDOW w AS (
+            PARTITION BY segment_id
+            ORDER BY tx
+            --look only forward for end_bin options
+            ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
+        );
+    
+    CREATE INDEX idx_dbo_composite ON dynamic_bin_options(segment_id, start_bin, end_bin);
+    CREATE INDEX idx_dbo_segment_tx ON dynamic_bin_options(segment_id, tx);
+    ANALYZE dynamic_bin_options;
+    
+    WITH unnested_db_options AS (
+        SELECT
+            dbo.segment_id,
+            s5b.total_length,
+            dbo.tx AS dt_start,
+            --exclusive end bin
+            s5b_end.tx + interval '5 minutes' AS dt_end,
+            unnested.link_dir,
+            unnested.len,
+            AVG(unnested.tt) AS tt, --avg TT for each link_dir
+            SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir
+        FROM dynamic_bin_options AS dbo
+        LEFT JOIN segment_5min_bins AS s5b
+            ON s5b.segment_id = dbo.segment_id
+            AND s5b.bin_rank >= dbo.start_bin
+            AND s5b.bin_rank <= dbo.end_bin
+        --this join is used to get the tx info about the last bin only
+        LEFT JOIN segment_5min_bins AS s5b_end
+            ON s5b_end.segment_id = dbo.segment_id
+            AND s5b_end.bin_rank = dbo.end_bin,
+        --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin
+        UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt)
+        --dynamic bins should not exceed 15 minutes (dt_end <= dt_start + 15 min)
+        WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '15 minutes'
+        GROUP BY
+            dbo.segment_id,
+            s5b.total_length,
+            dbo.tx, --stard_bin
+            s5b_end.tx, --end_bin
+            unnested.link_dir,
+            unnested.len
+    )
+
+    --this query contains overlapping values which get eliminated
+    --via on conflict with the exclusion constraint on congestion_raw_segments table.
+    INSERT INTO congestion_raw_segments_temp AS inserted (
+        bin_start, segment_id, bin_range, tt, num_obs
+    )
+    --distinct on ensures only the shortest option gets proposed for insert
+    SELECT DISTINCT ON (segment_id, dt_start)
+        dt_start AS bin_start,
+        segment_id,
+        tsrange(dt_start, dt_end, '[)') AS bin_range,
+        total_length / SUM(len) * SUM(tt) AS tt,
+        SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment
+    FROM unnested_db_options
+    GROUP BY
+        segment_id,
+        dt_start,
+        dt_end,
+        total_length
+    HAVING SUM(len) >= 0.8 * total_length
+    ORDER BY
+        segment_id,
+        dt_start,
+        dt_end --uses the option that ends first
+    --exclusion constraint + ordered insert to prevent overlapping bins
+    ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude_temp
+    DO NOTHING;
+    
+    ANALYZE congestion_raw_segments_temp;
+    
+    INSERT INTO gwolofs.congestion_raw_segments (
+        dt, bin_start, segment_id, bin_range, tt, num_obs, hr
+    )
+    SELECT
+        bin_start::date AS dt,
+        bin_start,
+        segment_id,
+        bin_range,
+        tt::real,
+        num_obs,
+        date_part('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2) AS hr
+    FROM congestion_raw_segments_temp
+    ON CONFLICT DO NOTHING;
+
+    DROP TABLE congestion_raw_segments_temp;
+
+END;
+$BODY$;
+
+ALTER FUNCTION gwolofs.congestion_network_segment_agg(date)
+OWNER TO gwolofs;
+
+GRANT EXECUTE ON FUNCTION gwolofs.congestion_network_segment_agg(date) TO congestion_bot;
+
+COMMENT ON FUNCTION gwolofs.congestion_network_segment_agg(date)
+IS 'Dynamic bin aggregation of the congestion network by hour and time periods. 
+Takes around 10 minutes to run for one day (hourly and period based aggregation)';
diff --git a/here/traffic/sql/dynamic_bins/function-congestion_return_dynamic_bins.sql b/here/traffic/sql/dynamic_bins/function-congestion_return_dynamic_bins.sql
new file mode 100644
index 000000000..38ccbc8a8
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/function-congestion_return_dynamic_bins.sql
@@ -0,0 +1,256 @@
+-- FUNCTION: gwolofs.congestion_return_dynamic_bins(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean) --noqa: LT05
+
+-- DROP FUNCTION IF EXISTS gwolofs.congestion_return_dynamic_bins(text, date, date, time without time zone, time without time zone, integer[], bigint, bigint, boolean); --noqa: LT05
+
+CREATE OR REPLACE FUNCTION gwolofs.congestion_return_dynamic_bins(
+    start_date date,
+    end_date date,
+    start_tod time without time zone,
+    end_tod time without time zone,
+    dow_list integer [],
+    node_start bigint,
+    node_end bigint,
+    holidays boolean
+)
+RETURNS TABLE (
+    dt date,
+    time_grp timerange,
+    corridor_id smallint,
+    bin_range tsrange,
+    tt real,
+    num_obs integer,
+    hr smallint
+)
+LANGUAGE plpgsql
+COST 100
+VOLATILE PARALLEL RESTRICTED
+AS $BODY$
+
+DECLARE
+map_version text;
+
+BEGIN
+
+--using a temp table to aply the exclusion constraint should prevent the
+--insert from getting bogged down by large constraint on main table over time
+DROP TABLE IF EXISTS congestion_raw_corridors_temp;
+CREATE TEMPORARY TABLE congestion_raw_corridors_temp (
+    dt date GENERATED ALWAYS AS (lower(bin_range)) STORED,
+    corridor_id smallint,
+    time_grp timerange NOT NULL,
+    bin_range tsrange NOT NULL,
+    tt real,
+    num_obs integer,
+    hr smallint GENERATED ALWAYS AS (date_part('hour', lower(bin_range) + (upper(bin_range) - lower(bin_range))/2)) STORED,
+    CONSTRAINT congestion_raw_corridors_exclude_temp EXCLUDE USING gist (
+        bin_range WITH &&,
+        corridor_id WITH =,
+        time_grp WITH =
+    )
+);
+
+SELECT gwolofs.congestion_select_map_version(
+    congestion_return_dynamic_bins.start_date,
+    congestion_return_dynamic_bins.end_date,
+    'path'
+) INTO map_version;
+
+RETURN QUERY EXECUTE FORMAT(
+    $$
+    WITH corridor AS (
+        SELECT
+            ccc.corridor_id,
+            unnested.link_dir,
+            unnested.length,
+            ccc.total_length
+        FROM gwolofs.congestion_cache_corridor(%1$L, %2$L, %3$L) AS ccc,
+        UNNEST(
+            ccc.link_dirs,
+            ccc.lengths
+        ) AS unnested(link_dir, length)
+    ),
+    
+    segment_5min_bins AS (
+        SELECT
+            seg.corridor_id,
+            ta.tx,
+            seg.total_length,
+            tsrange(
+                ta.dt + %4$L::time,
+                ta.dt + %5$L::time, '[)') AS time_grp,
+            RANK() OVER w AS bin_rank,
+            SUM(seg.length) / seg.total_length AS sum_length,
+            SUM(seg.length) AS length_w_data,
+            SUM(seg.length / ta.mean * 3.6) AS unadjusted_tt,
+            SUM(sample_size) AS num_obs,
+            ARRAY_AGG(ta.link_dir ORDER BY ta.link_dir) AS link_dirs,
+            ARRAY_AGG(seg.length / ta.mean * 3.6 ORDER BY ta.link_dir) AS tts,
+            ARRAY_AGG(seg.length ORDER BY ta.link_dir) AS lengths
+        FROM here.ta_path AS ta
+        JOIN corridor AS seg USING (link_dir)
+        LEFT JOIN ref.holiday USING (dt)
+        WHERE
+            (
+                ta.tod >= %4$L
+                AND --{ToD_and_or}
+                ta.tod < %5$L
+            )
+            AND date_part('isodow', ta.dt) = ANY(%6$L::int[])
+            AND ta.dt >= %7$L
+            AND ta.dt < %8$L
+            AND (%9$L OR holiday.dt IS NULL) --holiday clause
+        GROUP BY
+            seg.corridor_id,
+            ta.tx,
+            ta.dt,
+            seg.total_length
+       WINDOW w AS (
+            PARTITION BY seg.corridor_id, ta.dt
+            ORDER BY ta.tx
+       )
+    ),
+    
+    dynamic_bin_options AS (
+        --within each corridor/hour, generate all possible forward looking bin combinations
+        --don't generate options for bins with sufficient length
+        --also don't generate options past the next bin with 80%% length
+        SELECT
+            tx,
+            corridor_id,
+            time_grp,
+            bin_rank AS start_bin,
+            --generate all the options for the end bin within the group.
+            generate_series(
+                CASE
+                    WHEN sum_length >= 0.8 THEN bin_rank
+                    --if length is insufficient, need at least 1 more bin
+                    ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w)
+                END,
+                CASE
+                    --dont need to generate options when start segment is already sufficient
+                    WHEN sum_length >= 0.8 THEN bin_rank
+                    --generate options until 1 bin has sufficient length, otherwise until last bin in group
+                    ELSE COALESCE(
+                        MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w,
+                        MAX(bin_rank) OVER w
+                    )
+                END,
+                1
+            ) AS end_bin
+        FROM segment_5min_bins
+        WINDOW w AS (
+            PARTITION BY corridor_id, time_grp
+            ORDER BY tx
+            --look only forward for end_bin options
+            RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
+        )
+    ),
+    
+    unnested_db_options AS (
+        SELECT
+            s5b.corridor_id,
+            dbo.time_grp,
+            s5b.total_length,
+            dbo.tx AS dt_start,
+            --exclusive end bin
+            s5b_end.tx + interval '5 minutes' AS dt_end,
+            unnested.link_dir,
+            unnested.len,
+            AVG(unnested.tt) AS tt, --avg TT for each link_dir
+            SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir
+        FROM dynamic_bin_options AS dbo
+        LEFT JOIN segment_5min_bins AS s5b
+            ON s5b.time_grp = dbo.time_grp
+            AND s5b.bin_rank >= dbo.start_bin
+            AND s5b.bin_rank <= dbo.end_bin
+        --this join is used to get the tx info about the last bin only
+        LEFT JOIN segment_5min_bins AS s5b_end
+            ON s5b_end.time_grp = dbo.time_grp
+            AND s5b_end.bin_rank = dbo.end_bin,
+        --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin
+        UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt)
+        --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr)
+        WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '30 minutes'
+        GROUP BY
+            s5b.corridor_id,
+            dbo.time_grp,
+            s5b.total_length,
+            dbo.tx, --stard_bin
+            s5b_end.tx, --end_bin
+            unnested.link_dir,
+            unnested.len
+    )
+    
+    --this query contains overlapping values which get eliminated
+    --via on conflict with the exclusion constraint on congestion_raw_segments table.
+    INSERT INTO congestion_raw_corridors_temp AS inserted (
+        time_grp, corridor_id, bin_range, tt, num_obs
+    )
+    --distinct on ensures only the shortest option gets proposed for insert
+    SELECT DISTINCT ON (dt_start)
+        timerange(lower(time_grp)::time, upper(time_grp)::time, '[)') AS time_grp,
+        corridor_id,
+        tsrange(dt_start, dt_end, '[)') AS bin_range,
+        total_length / SUM(len) * SUM(tt) AS tt,
+        SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment
+    FROM unnested_db_options
+    GROUP BY
+        time_grp,
+        corridor_id,
+        dt_start,
+        dt_end,
+        total_length
+    HAVING SUM(len) >= 0.8 * total_length
+    ORDER BY
+        dt_start,
+        dt_end
+    --exclusion constraint + ordered insert to prevent overlapping bins
+    ON CONFLICT ON CONSTRAINT congestion_raw_corridors_exclude_temp
+    DO NOTHING
+    RETURNING
+        inserted.dt, inserted.time_grp, inserted.corridor_id,
+        inserted.bin_range, inserted.tt, inserted.num_obs, inserted.hr;
+            
+    $$,
+    node_start, node_end, map_version, --segment CTE
+    start_tod, end_tod, --segment_5min_bins CTE SELECT
+    dow_list, start_date, end_date, holidays --segment_5min_bins CTE WHERE
+);
+
+END;
+$BODY$;
+
+ALTER FUNCTION gwolofs.congestion_return_dynamic_bins(
+    date, date, time without time zone,
+    time without time zone, integer [], bigint, bigint, boolean
+)
+OWNER TO gwolofs;
+
+COMMENT ON FUNCTION gwolofs.congestion_return_dynamic_bins IS
+'Returns the dynamic binning results for a request.';
+
+-- overload the function for more straightforward situation of daily corridor agg
+CREATE OR REPLACE FUNCTION gwolofs.congestion_return_dynamic_bins_daily(
+    start_date date,
+    node_start bigint,
+    node_end bigint
+)
+RETURNS void
+LANGUAGE sql
+COST 100
+VOLATILE PARALLEL UNSAFE
+AS
+$BODY$
+SELECT gwolofs.congestion_return_dynamic_bins(
+    start_date := congestion_return_dynamic_bins_daily.start_date,
+    end_date := congestion_return_dynamic_bins_daily.start_date + 1,
+    start_tod := '00:00'::time without time zone,
+    end_tod := '24:00'::time without time zone,
+    dow_list := ARRAY[extract('isodow' from congestion_return_dynamic_bins_daily.start_date)]::int[],
+    node_start := congestion_return_dynamic_bins_daily.node_start,
+    node_end := congestion_return_dynamic_bins_daily.node_end,
+    holidays := True)
+$BODY$;
+
+COMMENT ON FUNCTION gwolofs.congestion_return_dynamic_bins_daily
+IS 'A simplified version of `congestion_return_dynamic_bins` for aggregating entire days of data.'
diff --git a/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql
new file mode 100644
index 000000000..ab2e7602a
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/function-congestion_segment_monthly_agg.sql
@@ -0,0 +1,52 @@
+-- FUNCTION: gwolofs.congestion_segment_monthly_agg(date)
+
+-- DROP FUNCTION IF EXISTS gwolofs.congestion_segment_monthly_agg(date);
+
+CREATE OR REPLACE FUNCTION gwolofs.congestion_segment_monthly_agg(
+    mon date
+)
+RETURNS void
+LANGUAGE SQL
+COST 100
+VOLATILE PARALLEL UNSAFE
+AS $BODY$
+
+INSERT INTO gwolofs.congestion_segments_monthy_summary (
+    segment_id, mnth, is_wkdy, hr, avg_tt, stdev, percentile_05, percentile_15,
+    percentile_50, percentile_85, percentile_95, num_quasi_obs
+)
+SELECT
+    segment_id,
+    congestion_segment_monthly_agg.mon AS mnth,
+    date_part('isodow', dt) <= 5 AS is_wkdy,
+    hr,
+    AVG(tt) AS avg_tt,
+    stddev(tt) AS stdev,
+    PERCENTILE_CONT(0.05) WITHIN GROUP (ORDER BY tt) AS percentile_05,
+    PERCENTILE_CONT(0.15) WITHIN GROUP (ORDER BY tt) AS percentile_15,
+    PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY tt) AS percentile_50,
+    PERCENTILE_CONT(0.85) WITHIN GROUP (ORDER BY tt) AS percentile_85,
+    PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY tt) AS percentile_95,
+    COUNT(*) AS num_quasi_obs
+FROM gwolofs.congestion_raw_segments
+LEFT JOIN ref.holiday USING (dt)
+WHERE
+    dt >= congestion_segment_monthly_agg.mon
+    AND dt < congestion_segment_monthly_agg.mon + interval '1 month'
+    AND holiday.holiday IS NULL
+GROUP BY
+    segment_id,
+    hr,
+    is_wkdy;
+
+$BODY$;
+
+ALTER FUNCTION gwolofs.congestion_segment_monthly_agg(date)
+OWNER TO gwolofs;
+
+GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO PUBLIC;
+
+GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO CONGESTION_BOT;
+
+GRANT EXECUTE ON FUNCTION gwolofs.congestion_segment_monthly_agg(date) TO GWOLOFS;
+
diff --git a/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql
new file mode 100644
index 000000000..cd5371ef0
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/function-congestion_select_map_version.sql
@@ -0,0 +1,46 @@
+-- FUNCTION: gwolofs.congestion_select_map_version(date, date)
+
+-- DROP FUNCTION IF EXISTS gwolofs.congestion_select_map_version(date, date);
+
+CREATE OR REPLACE FUNCTION gwolofs.congestion_select_map_version(
+    start_date date,
+    end_date date,
+    agg_type text DEFAULT NULL, --null or 'path'
+    OUT selected_version text
+)
+RETURNS text
+LANGUAGE plpgsql
+COST 100
+STABLE PARALLEL SAFE
+AS $BODY$
+
+DECLARE
+    svr text := 'street_valid_range' || CASE agg_type WHEN 'path' THEN '_path' ELSE '' END;
+
+BEGIN
+EXECUTE FORMAT(
+    $$
+    SELECT street_version
+    FROM here.%I AS svr,
+    LATERAL (
+        SELECT svr.valid_range * daterange(%L, %L, '[)') AS overlap
+    ) AS lat
+    WHERE UPPER(lat.overlap) - LOWER(lat.overlap) IS NOT NULL
+    ORDER BY UPPER(lat.overlap) - LOWER(lat.overlap) DESC NULLS LAST
+    LIMIT 1;
+    $$, svr, congestion_select_map_version.start_date, congestion_select_map_version.end_date
+) INTO selected_version;
+END;
+$BODY$;
+
+ALTER FUNCTION gwolofs.congestion_select_map_version(date, date, text)
+OWNER TO gwolofs;
+
+GRANT EXECUTE ON FUNCTION gwolofs.congestion_select_map_version(date, date, text) TO congestion_bot;
+
+COMMENT ON FUNCTION gwolofs.congestion_select_map_version IS
+'Implement TT App selectMapVersion.py';
+
+--test cases
+SELECT * FROM gwolofs.congestion_select_map_version('2022-01-01', '2023-01-01');
+SELECT * FROM gwolofs.congestion_select_map_version('2022-01-01', '2023-01-01', 'path');
\ No newline at end of file
diff --git a/here/traffic/sql/dynamic_bins/function-identify_node_streets.sql b/here/traffic/sql/dynamic_bins/function-identify_node_streets.sql
new file mode 100644
index 000000000..2793e3f9f
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/function-identify_node_streets.sql
@@ -0,0 +1,43 @@
+CREATE OR REPLACE FUNCTION gwolofs.identify_node_streets(
+    node bigint,
+    map_version text,
+    exclude_streets text [],
+    OUT streets text
+)
+RETURNS text
+LANGUAGE plpgsql
+COST 100
+VOLATILE PARALLEL SAFE
+AS $BODY$
+
+DECLARE
+    routing_nodes_table text := 'routing_nodes_' || map_version;
+    traffic_streets_table text := 'traffic_streets_' || map_version;
+
+BEGIN
+EXECUTE format (
+    $$
+    SELECT string_agg(DISTINCT initcap(streets.st_name), ' / ' ORDER BY initcap(streets.st_name))
+    FROM here.%1$I AS node
+    LEFT JOIN here_gis.%2$I AS streets
+        ON node.link_id = streets.link_id
+        AND NOT(initcap(streets.st_name) = ANY(%3$L))
+        AND streets.st_name IS NOT NULL
+    WHERE node.node_id = %4$L
+    $$,
+    routing_nodes_table,
+    traffic_streets_table,
+    identify_node_streets.exclude_streets,
+    identify_node_streets.node
+) INTO streets;
+
+RETURN;
+END;
+$BODY$;
+
+ALTER FUNCTION gwolofs.identify_node_streets(bigint, text, text [])
+OWNER TO gwolofs;
+
+COMMENT ON FUNCTION gwolofs.identify_node_streets IS
+'Identifies the streets intersecting with a HERE node_id, given a node, map_version,
+and a list of streets to exclude (generally those which form the corridor).';
diff --git a/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql b/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql
new file mode 100644
index 000000000..cbde86da4
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/insert_projects_and_corridors.sql
@@ -0,0 +1,48 @@
+--for naming corridor_streets.
+--need help with corridor_start and corridor_end locations - not sure how to turn here nodes into names. Intersection conflation?
+WITH named_corridors AS (
+    SELECT
+        corridor_id,
+        string_agg(DISTINCT initcap(st_name), ' / ') AS corridor_streets
+    FROM gwolofs.congestion_corridors,
+        UNNEST(congestion_corridors.link_dirs) AS unnested (link_dir)
+    LEFT JOIN here_gis.traffic_streets_24_4 ON link_id = trim(TRAILING 'T|F' FROM link_dir)::int
+    WHERE map_version = '24_4'
+    GROUP BY corridor_id
+    ORDER BY corridor_id DESC
+)
+
+UPDATE gwolofs.congestion_corridors AS cc
+SET corridor_streets = nc.corridor_streets
+FROM named_corridors AS nc
+WHERE nc.corridor_id = cc.corridor_id;
+
+--look at bluetooth corridors
+REFRESH MATERIALIZED VIEW bluetooth.here_cn_23_4_lookup;
+
+--cache project
+WITH project AS (
+    INSERT INTO gwolofs.congestion_projects (description)
+    VALUES ('bluetooth_corridors')
+    RETURNING project_id
+),
+
+--cache corridors, repeat with multiple map versions
+corridors AS (
+    SELECT corridor_id
+    FROM bluetooth.here_cn_23_4_lookup AS bt,
+        gwolofs.congestion_cache_corridor(bt.here_fnode, bt.here_tnode, '24_4')
+)
+
+--add project_id to corridors
+UPDATE gwolofs.congestion_corridors
+SET project_id = (SELECT project_id FROM project)
+WHERE corridor_id IN (SELECT corridor_id FROM corridors)
+RETURNING corridor_id;
+
+--examine the projects
+SELECT congestion_corridors.*
+FROM gwolofs.congestion_corridors
+JOIN gwolofs.congestion_projects USING (project_id)
+WHERE congestion_projects.description IN ('bluetooth_corridors', 'scrutinized-cycleway-corridors')
+
diff --git a/here/traffic/sql/dynamic_bins/segment_grouping.sql b/here/traffic/sql/dynamic_bins/segment_grouping.sql
new file mode 100644
index 000000000..93303ca43
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/segment_grouping.sql
@@ -0,0 +1,40 @@
+WITH segments AS (
+    --segments active in relevant month
+    SELECT DISTINCT segment_id
+    FROM gwolofs.congestion_raw_segments
+    WHERE
+        dt >= '{{ ds }}'::date --noqa: TMP
+        AND dt < '{{ ds }}'::date + '1 month'::interval --noqa: TMP
+),
+
+group_size AS (
+    --find the number of groups required to have no more than `max_group_size` per group
+    SELECT
+        FLOOR(
+            COUNT(*)
+            / CEIL((COUNT(*)) / {{ params.max_group_size }}::numeric) --noqa: TMP
+        ) AS num_per_group
+    FROM segments
+),
+
+groups AS (
+    SELECT
+        --assign group_ids using row number
+        CEIL(ROW_NUMBER() OVER (ORDER BY segment_id) / group_size.num_per_group) AS group_id,
+        segment_id
+    FROM segments, group_size
+),
+
+groups_summarized AS (
+    SELECT
+        group_id,
+        array_agg(segment_id) AS segment_ids,
+        COUNT(*)
+    FROM groups
+    GROUP BY group_id
+    ORDER BY group_id
+)
+
+--return list of lists for xcom
+SELECT array_agg(segment_ids::text)
+FROM groups_summarized
\ No newline at end of file
diff --git a/here/traffic/sql/dynamic_bins/select-check_missing_days.sql b/here/traffic/sql/dynamic_bins/select-check_missing_days.sql
new file mode 100644
index 000000000..0b09c3673
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/select-check_missing_days.sql
@@ -0,0 +1,21 @@
+WITH distinct_days AS (
+    SELECT DISTINCT dt
+    FROM gwolofs.congestion_raw_segments
+    WHERE
+        dt >= '{{ ds }}'::date --noqa: TMP
+        AND dt < '{{ ds }}'::date + interval '1 month' --noqa: TMP
+)
+
+SELECT
+    COUNT(*) = 0 AS _check,
+    'The following days are missing from `congestion_raw_segments`: '
+    || string_agg(dates.dt::date::text, ', ') AS _summary
+FROM
+    generate_series(
+        '{{ ds }}'::date,
+        --one day before start of next month
+        ('{{ ds }}'::date + interval '1 month')::date - 1,
+        '1 day'
+    ) AS dates (dt)
+LEFT JOIN distinct_days USING (dt)
+WHERE distinct_days.dt IS NULL;
\ No newline at end of file
diff --git a/here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md b/here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md
new file mode 100644
index 000000000..48370aeee
--- /dev/null
+++ b/here/traffic/sql/dynamic_bins/select-congestion_raw_segments.md
@@ -0,0 +1,259 @@
+This is a readme to describe the complex query [here](./function-congestion_network_segment_agg.sql).  
+Samples from each of the CTEs are shown for one segment/time_grp. Not all columns are shown from each CTE result.  
+
+### segments
+
+Identifies the links that make up each segment, along with total segment length from `congestion.network_links_*` table.
+
+```sql
+WITH segments AS (
+    SELECT
+        segment_id,
+        link_dir,
+        length,
+        SUM(length) OVER (PARTITION BY segment_id) AS total_length
+    FROM congestion.%2$I --eg. congestion.network_links_23_4_geom
+)
+```
+
+### segment_5min_bins
+In this step we pull the relevant data from `here.ta_path` for each segment / time_grp (gwolofs.congestion_time_grps). We save the disaggregate travel time data by link in 3 arrays (link_dirs, tts, lengths), so that in future steps we can reaggregate average segment travel time and distinct length over different ranges without referring back to the here.ta_path table. The time bins (`tx`) are also ranked to make it easier to enumerate possible bin extents using `generate_series` in the next step. 
+
+```sql
+segment_5min_bins AS (
+    SELECT
+        links.segment_id,
+        timerange(tg.start_tod, tg.end_tod, '[)') AS time_grp,
+        ta.tx,
+        RANK() OVER w AS bin_rank,
+        links.total_length,
+        SUM(links.length) / links.total_length AS sum_length,
+        SUM(links.length) AS length_w_data,
+        SUM(links.length / ta.mean * 3.6) AS unadjusted_tt,
+        SUM(sample_size) AS num_obs,
+        ARRAY_AGG(ta.link_dir ORDER BY link_dir) AS link_dirs,
+        ARRAY_AGG(links.length / ta.mean * 3.6 ORDER BY link_dir) AS tts,
+        ARRAY_AGG(links.length ORDER BY link_dir) AS lengths
+    FROM here.ta_path AS ta
+    JOIN gwolofs.congestion_time_grps AS tg ON
+        ta.tx >= %1$L::date + tg.start_tod
+        AND ta.tx < %1$L::date + tg.end_tod
+    JOIN segments AS links USING (link_dir)
+    WHERE
+        ta.dt >= %1$L::date
+        AND ta.dt < %1$L::date + interval '1 day'
+    GROUP BY
+        links.segment_id,
+        tg.start_tod,
+        tg.end_tod,
+        ta.tx,
+        links.total_length
+    WINDOW w AS (
+        PARTITION BY links.segment_id, tg.start_tod, tg.end_tod
+        ORDER BY ta.tx
+    )
+),
+```
+
+`SELECT * FROM gwolofs.congestion_raw_segments WHERE segment_id = 1 AND dt = '2025-01-10' AND time_grp = '[00:00:00,01:00:00)';`
+
+| segment_id | time_grp            | tx                      | bin_rank | total_length | sum_length             | length_w_data | unadjusted_tt            | num_obs | link_dirs                                                     | tts                                                                                           | lengths                        |
+|------------|---------------------|-------------------------|----------|--------------|------------------------|---------------|--------------------------|---------|---------------------------------------------------------------|-----------------------------------------------------------------------------------------------|--------------------------------|
+|          1 | [00:00:00,06:00:00) | 2025-01-10 00:20:00.000 |        1 |       374.22 | 1.00000000000000000000 |        374.22 | 29.200422445479049559580 |       5 | {1328374158F,1328374159F,1328374160F,1328374165F,1328374166F} | {3.739245283018868,4.845056603773585,1.8298867924528301,3.109090909090909,15.677142857142858} | {55.05,71.33,26.94,38.0,182.9} |
+|          1 | [00:00:00,06:00:00) | 2025-01-10 00:25:00.000 |        2 |       374.22 | 0.48874993319437763882 |        182.90 |    131.68800000000000000 |       1 | {1328374166F}                                                 | {131.688}                                                                                     | {182.9}                        |
+|          1 | [00:00:00,06:00:00) | 2025-01-10 00:35:00.000 |        3 |       374.22 | 1.00000000000000000000 |        374.22 | 76.657011086474501198040 |       5 | {1328374158F,1328374159F,1328374160F,1328374165F,1328374166F} | {4.833658536585366,6.263121951219512,2.365463414634146,3.3365853658536584,59.85818181818182}  | {55.05,71.33,26.94,38.0,182.9} |
+|          1 | [00:00:00,06:00:00) | 2025-01-10 05:00:00.000 |        4 |       374.22 | 0.19060980172091283202 |         71.33 |      6.26312195121951216 |       1 | {1328374159F}                                                 | {6.263121951219512}                                                                           | {71.33}                        |
+|          1 | [00:00:00,06:00:00) | 2025-01-10 05:05:00.000 |        5 |       374.22 | 1.00000000000000000000 |        374.22 | 35.452421052631578833688 |       5 | {1328374158F,1328374159F,1328374160F,1328374165F,1328374166F} | {5.215263157894737,6.757578947368421,2.5522105263157893,3.6,17.327368421052633}               | {55.05,71.33,26.94,38.0,182.9} |
+|          1 | [00:00:00,06:00:00) | 2025-01-10 05:15:00.000 |        6 |       374.22 | 1.00000000000000000000 |        374.22 | 48.013722580645161104508 |       5 | {1328374158F,1328374159F,1328374160F,1328374165F,1328374166F} | {6.392903225806451,12.8394,3.128516129032258,4.412903225806452,21.24}                         | {55.05,71.33,26.94,38.0,182.9} |
+|          1 | [00:00:00,06:00:00) | 2025-01-10 05:20:00.000 |        7 |       374.22 | 0.48874993319437763882 |        182.90 |     13.16880000000000000 |       1 | {1328374166F}                                                 | {13.1688}                                                                                     | {182.9}                        |
+
+### dynamic_bin_options
+Here we enumerate all the possible dynamic bin options for each starting point. The number of combinations are cut down significantly with the `CASE` statements inside the `generate_series`: 
+- Don't enumerate options for 5min bins with sufficient length.
+- Only look forward until the next 5min bin with sufficient lenght.
+
+```sql
+dynamic_bin_options AS (
+    --within each segment/hour, generate all possible forward looking bin combinations
+    --don't generate options for bins with sufficient length
+    --also don't generate options past the next bin with 80%% length
+    SELECT
+        tx,
+        time_grp,
+        segment_id,
+        bin_rank AS start_bin,
+        --generate all the options for the end bin within the group.
+        generate_series(
+            CASE
+                WHEN sum_length >= 0.8 THEN bin_rank
+                --if length is insufficient, need at least 1 more bin
+                ELSE LEAST(bin_rank + 1, MAX(bin_rank) OVER w)
+            END,
+            CASE
+                --dont need to generate options when start segment is already sufficient
+                WHEN sum_length >= 0.8 THEN bin_rank
+                --generate options until 1 bin has sufficient length, otherwise until last bin in group
+                ELSE COALESCE(MIN(bin_rank) FILTER (WHERE sum_length >= 0.8) OVER w, MAX(bin_rank) OVER w)
+            END,
+            1
+        ) AS end_bin
+    FROM segment_5min_bins
+    WINDOW w AS (
+        PARTITION BY time_grp, segment_id
+        ORDER BY tx
+        --look only forward for end_bin options
+        RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
+    )
+),
+```
+
+In this case we find 13 dynamic bin options with the pruning conditions, down from max of 10+9+8+7+6+5+4+3+2+1 = 55.
+
+| tx                      | time_grp            | segment_id | start_bin | end_bin |
+|-------------------------|---------------------|------------|-----------|---------|
+| 2025-01-10 00:20:00.000 | [00:00:00,06:00:00) |          1 |         1 |       1 |
+| 2025-01-10 00:25:00.000 | [00:00:00,06:00:00) |          1 |         2 |       3 |
+| 2025-01-10 00:35:00.000 | [00:00:00,06:00:00) |          1 |         3 |       3 |
+| 2025-01-10 05:00:00.000 | [00:00:00,06:00:00) |          1 |         4 |       5 |
+| 2025-01-10 05:05:00.000 | [00:00:00,06:00:00) |          1 |         5 |       5 |
+| 2025-01-10 05:15:00.000 | [00:00:00,06:00:00) |          1 |         6 |       6 |
+| 2025-01-10 05:20:00.000 | [00:00:00,06:00:00) |          1 |         7 |       8 |
+| 2025-01-10 05:20:00.000 | [00:00:00,06:00:00) |          1 |         7 |       9 |
+| 2025-01-10 05:20:00.000 | [00:00:00,06:00:00) |          1 |         7 |      10 |
+| 2025-01-10 05:25:00.000 | [00:00:00,06:00:00) |          1 |         8 |       9 |
+| 2025-01-10 05:25:00.000 | [00:00:00,06:00:00) |          1 |         8 |      10 |
+| 2025-01-10 05:50:00.000 | [00:00:00,06:00:00) |          1 |         9 |      10 |
+| 2025-01-10 05:55:00.000 | [00:00:00,06:00:00) |          1 |        10 |      10 |
+
+### unnested_db_options
+Combining the previous two steps, we have enumerated all the possible bin start/end ranges (`dynamic_bin_options`), now we can unnest the disaggregate data (`segment_5min_bins`) and evaluate them. 
+Note the multiple arrays unnested at once into rows, see `unnest ( anyarray, anyarray [, ... ] ) ` [here](https://www.postgresql.org/docs/current/functions-array.html#id-1.5.8.25.6.2.2.19.1.1.1). 
+We then group the results by bin / link_dir so we only have the unique length within each bin. 
+
+```sql
+unnested_db_options AS (
+    SELECT
+        dbo.time_grp,
+        dbo.segment_id,
+        s5b.total_length,
+        dbo.tx AS dt_start,
+        --exclusive end bin
+        s5b_end.tx + interval '5 minutes' AS dt_end,
+        unnested.link_dir,
+        unnested.len,
+        AVG(unnested.tt) AS tt, --avg TT for each link_dir
+        SUM(s5b.num_obs) AS num_obs --sum of here.ta_path sample_size for each link_dir
+    FROM dynamic_bin_options AS dbo
+    LEFT JOIN segment_5min_bins AS s5b
+        ON s5b.time_grp = dbo.time_grp
+        AND s5b.segment_id = dbo.segment_id
+        AND s5b.bin_rank >= dbo.start_bin
+        AND s5b.bin_rank <= dbo.end_bin
+    --this join is used to get the tx info about the last bin only
+    LEFT JOIN segment_5min_bins AS s5b_end
+        ON s5b_end.time_grp = dbo.time_grp
+        AND s5b_end.segment_id = dbo.segment_id
+        AND s5b_end.bin_rank = dbo.end_bin,
+    --unnest all the observations from individual link_dirs to reaggregate them within new dynamic bin
+    UNNEST(s5b.link_dirs, s5b.lengths, s5b.tts) AS unnested(link_dir, len, tt)
+    --dynamic bins should not exceed one hour (dt_end <= dt_start + 1 hr)
+    WHERE s5b_end.tx + interval '5 minutes' <= dbo.tx + interval '1 hour'
+    GROUP BY
+        dbo.time_grp,
+        dbo.segment_id,
+        s5b.total_length,
+        dbo.tx, --stard_bin
+        s5b_end.tx, --end_bin
+        unnested.link_dir,
+        unnested.len
+)
+```
+
+`SELECT * FROM unnested_db_options WHERE time_grp = '[00:00:00,06:00:00)' LIMIT 10`
+
+| time_grp            | segment_id | total_length | dt_start                | dt_end                  | link_dir    | len    | tt                      | num_obs |
+|---------------------|------------|--------------|-------------------------|-------------------------|-------------|--------|-------------------------|---------|
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374158F |  55.05 |     3.739 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374159F |  71.33 |     4.845 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374160F |  26.94 | 1.829 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374165F |  38.00 | 3.109 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:20:00.000 | 2025-01-10 00:25:00.000 | 1328374166F | 182.90 |    15.677 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374158F |  55.05 |     4.833 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374159F |  71.33 |     6.263 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374160F |  26.94 | 2.365 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374165F |  38.00 | 3.336 |       5 |
+| [00:00:00,06:00:00) |          1 |       374.22 | 2025-01-10 00:25:00.000 | 2025-01-10 00:40:00.000 | 1328374166F | 182.90 |    95.773 |       6 |
+
+### Insert statement
+Here we find bins with sufficient length, for the two cases: 
+- Multiple 5min bins assembled: need to check sufficient length from last step. 
+- An original 5min bin, no group by needed to check length. 
+
+```sql
+    --this query contains overlapping values which get eliminated
+    --via on conflict with the exclusion constraint on congestion_raw_segments table.
+    INSERT INTO gwolofs.congestion_raw_segments (
+        dt, time_grp, segment_id, bin_range, tt, num_obs
+    )
+    --distinct on ensures only the shortest option gets proposed for insert
+    SELECT DISTINCT ON (time_grp, segment_id, dt_start)
+        dt_start::date AS dt,
+        time_grp,
+        segment_id,
+        tsrange(dt_start, dt_end, '[)') AS bin_range,
+        total_length / SUM(len) * SUM(tt) AS tt,
+        SUM(num_obs) AS num_obs --sum of here.ta_path sample_size for each segment
+    FROM unnested_db_options
+    GROUP BY
+        time_grp,
+        segment_id,
+        dt_start,
+        dt_end,
+        total_length
+    HAVING SUM(len) >= 0.8 * total_length
+    ORDER BY
+        time_grp,
+        segment_id,
+        dt_start,
+        dt_end --uses the option that ends first
+    --exclusion constraint + ordered insert to prevent overlapping bins
+    ON CONFLICT ON CONSTRAINT congestion_raw_segments_exclude
+    DO NOTHING;
+```
+
+`SELECT dt, time_grp, segment_id, bin_range, round(tt, 2), num_obs FROM inserted WHERE time_grp = '[00:00:00,06:00:00)';` 
+
+| dt         | time_grp            | segment_id | bin_range                                     | round  | num_obs |
+|------------|---------------------|------------|-----------------------------------------------|--------|---------|
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 00:20:00","2025-01-10 00:25:00") |  29.20 |      25 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 00:25:00","2025-01-10 00:40:00") | 112.57 |      26 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 00:35:00","2025-01-10 00:40:00") |  76.66 |      25 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 05:00:00","2025-01-10 05:10:00") |  35.21 |      26 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 05:05:00","2025-01-10 05:10:00") |  35.45 |      25 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 05:15:00","2025-01-10 05:20:00") |  48.01 |      25 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 05:20:00","2025-01-10 05:55:00") |  51.34 |      14 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 05:25:00","2025-01-10 05:55:00") |  69.59 |      13 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 05:50:00","2025-01-10 06:00:00") |  53.28 |      62 |
+| 2025-01-10 | [00:00:00,06:00:00) |          1 | ["2025-01-10 05:55:00","2025-01-10 06:00:00") |  39.36 |      50 |
+
+After insert against exclusion constraint, only 6 remain (of 10 above), since rows #3,5,8,9 overlap other records. 
+`SELECT segment_id, bin_range, round(tt, 2) AS tt, total_length, length_w_data FROM gwolofs.congestion_raw_segments WHERE segment_id = 29 AND time_grp = '["2025-01-04 00:00:00","2025-01-04 06:00:00")'::tsrange`
+
+Constraint: 
+```sql
+    CONSTRAINT congestion_raw_segments_exclude EXCLUDE USING gist (
+        bin_range WITH &&,
+        segment_id WITH =,
+        time_grp WITH =,
+        dt WITH =
+    )
+```
+
+| segment_id | bin_range                                     | tt                | num_obs | dt         | time_grp            |
+|------------|-----------------------------------------------|-------------------|---------|------------|---------------------|
+|          1 | ["2025-01-10 00:20:00","2025-01-10 00:25:00") |  29.2004224454790 |      25 | 2025-01-10 | [00:00:00,06:00:00) |
+|          1 | ["2025-01-10 00:25:00","2025-01-10 00:40:00") | 112.5719201773835 |      26 | 2025-01-10 | [00:00:00,06:00:00) |
+|          1 | ["2025-01-10 05:00:00","2025-01-10 05:10:00") |  35.2051925545571 |      26 | 2025-01-10 | [00:00:00,06:00:00) |
+|          1 | ["2025-01-10 05:15:00","2025-01-10 05:20:00") |  48.0137225806451 |      25 | 2025-01-10 | [00:00:00,06:00:00) |
+|          1 | ["2025-01-10 05:20:00","2025-01-10 05:55:00") |          51.34214 |      14 | 2025-01-10 | [00:00:00,06:00:00) |
+|          1 | ["2025-01-10 05:55:00","2025-01-10 06:00:00") |  39.3552705888070 |      50 | 2025-01-10 | [00:00:00,06:00:00) |
\ No newline at end of file
diff --git a/test/integration/test_dags.py b/test/integration/test_dags.py
index ce574db40..b41571003 100644
--- a/test/integration/test_dags.py
+++ b/test/integration/test_dags.py
@@ -27,6 +27,7 @@
     'AIRFLOW_VAR_COLLISIONS_TABLES': "["+",".join([f'["src_schema.table_{i}", "dst_schema.table_{i}"]' for i in range(0, 2)])+"]",
     'AIRFLOW_VAR_COUNTS_TABLES': "["+",".join([f'["src_schema.table_{i}", "dst_schema.table_{i}"]' for i in range(0, 3)])+"]",
     'AIRFLOW_VAR_HERE_DAG_TRIGGERS': "["+",".join([f'"dag_{i}"' for i in range(0, 3)])+"]",
+    'AIRFLOW_VAR_HERE_PATH_DAG_TRIGGERS': "["+",".join([f'"dag_{i}"' for i in range(0, 3)])+"]",
     'AIRFLOW_VAR_REPLICATORS': '{"dag": {"dag_name": "value", "tables": "value", "conn": "value"}}',
     'AIRFLOW_VAR_TEST_DAG_TRIGGERS': "["+",".join([f'"dag_{i}"' for i in range(0, 3)])+"]",
     'AIRFLOW_VAR_GCC_DAGS': '{"dag": {"conn": "value", "deployments": ["value"]}}',