diff --git a/lib/dotcom/trip_plan/itinerary_group.ex b/lib/dotcom/trip_plan/itinerary_group.ex
new file mode 100644
index 0000000000..a357005d66
--- /dev/null
+++ b/lib/dotcom/trip_plan/itinerary_group.ex
@@ -0,0 +1,74 @@
+defmodule Dotcom.TripPlan.ItineraryGroup do
+  @moduledoc """
+  A single group of related itineraries
+  """
+
+  alias Dotcom.TripPlan.Itinerary
+
+  defstruct [:itineraries, :representative_index, :representative_time, :summary]
+
+  @type summarized_leg :: %{
+          routes: [Routes.Route.t()],
+          walk_minutes: non_neg_integer()
+        }
+
+  @type summary :: %{
+          accessible?: boolean() | nil,
+          duration: non_neg_integer(),
+          start: DateTime.t(),
+          stop: DateTime.t(),
+          summarized_legs: [summarized_leg()],
+          tag: String.t(),
+          total_cost: non_neg_integer(),
+          walk_distance: float()
+        }
+
+  @type t :: %__MODULE__{
+          itineraries: [Itinerary.t()],
+          representative_index: non_neg_integer(),
+          representative_time: :start | :stop,
+          summary: summary()
+        }
+
+  @doc """
+  List of either start times or stop times for this group
+  """
+  @spec options_text(t()) :: String.t() | nil
+  def options_text(%__MODULE__{itineraries: []}), do: nil
+  def options_text(%__MODULE__{itineraries: [_single]}), do: nil
+
+  def options_text(
+        %__MODULE__{
+          representative_index: representative_index,
+          representative_time: start_or_stop
+        } =
+          group
+      ) do
+    {_, other_times} =
+      group
+      |> all_times()
+      |> List.pop_at(representative_index)
+
+    phrase = options_phrase(start_or_stop == :stop, Enum.count(other_times))
+
+    formatted_times =
+      other_times
+      |> Enum.map(&Timex.format!(&1, "%-I:%M", :strftime))
+      |> Enum.join(", ")
+
+    "Similar #{phrase} #{formatted_times}"
+  end
+
+  defp options_phrase(true, 1), do: "trip arrives by"
+  defp options_phrase(true, _), do: "trips arrive by"
+  defp options_phrase(false, 1), do: "trip departs at"
+  defp options_phrase(_, _), do: "trips depart at"
+
+  @doc """
+  List of either start times or stop times for this group
+  """
+  @spec all_times(t()) :: [DateTime.t()]
+  def all_times(%__MODULE__{itineraries: itineraries, representative_time: start_or_stop}) do
+    Enum.map(itineraries, &Map.get(&1, start_or_stop))
+  end
+end
diff --git a/lib/dotcom/trip_plan/itinerary_groups.ex b/lib/dotcom/trip_plan/itinerary_groups.ex
index b1fb9d3f32..927f0876af 100644
--- a/lib/dotcom/trip_plan/itinerary_groups.ex
+++ b/lib/dotcom/trip_plan/itinerary_groups.ex
@@ -8,48 +8,34 @@ defmodule Dotcom.TripPlan.ItineraryGroups do
 
   import DotcomWeb.TripPlanView, only: [get_one_way_total_by_type: 2]
 
-  alias Dotcom.TripPlan.{Itinerary, Leg, PersonalDetail, TransitDetail}
+  alias Dotcom.TripPlan.{Itinerary, ItineraryGroup, Leg, PersonalDetail, TransitDetail}
   alias OpenTripPlannerClient.ItineraryTag
 
   @short_walk_threshold_minutes 5
-  @max_per_group 5
-
-  @type summarized_leg :: %{
-          routes: [Routes.Route.t()],
-          walk_minutes: non_neg_integer()
-        }
-  @type summary :: %{
-          accessible?: boolean() | nil,
-          duration: non_neg_integer(),
-          first_start: DateTime.t(),
-          first_stop: DateTime.t(),
-          next_starts: [DateTime.t()],
-          summarized_legs: [summarized_leg()],
-          tag: String.t(),
-          total_cost: non_neg_integer(),
-          walk_distance: float()
-        }
-
-  @spec from_itineraries([Itinerary.t()]) :: [
-          %{itineraries: [Itinerary.t()], summary: summary()}
-        ]
-  def from_itineraries(itineraries) do
+  @max_per_group 4
+
+  @doc """
+  From a large list of itineraries, collect them into 5 groups of at most
+  #{@max_per_group} itineraries each, sorting the groups in favor of tagged
+  groups first
+  """
+  @spec from_itineraries([Itinerary.t()], boolean()) :: [ItineraryGroup.t()]
+  def from_itineraries(itineraries, take_from_end? \\ false) do
     itineraries
     |> Enum.group_by(&unique_legs_to_hash/1)
     |> Enum.map(&drop_hash/1)
     |> Enum.reject(&Enum.empty?/1)
-    |> Enum.take(5)
-    |> Enum.map(&limit_itinerary_count/1)
-    |> Enum.map(&to_summarized_group/1)
+    |> Enum.map(&limit_itinerary_count(&1, take_from_end?))
+    |> Enum.map(&to_group(&1, take_from_end?))
     |> Enum.sort_by(fn
-      %{itineraries: [%{tag: tag} | _] = _} ->
+      %ItineraryGroup{summary: %{tag: tag}} ->
         Enum.find_index(ItineraryTag.tag_priority_order(), &(&1 == tag))
-
-      _ ->
-        -1
     end)
+    |> Enum.take(5)
   end
 
+  def max_per_group, do: @max_per_group
+
   defp unique_legs_to_hash(%Itinerary{legs: legs}) do
     legs
     |> Enum.reject(&short_walking_leg?/1)
@@ -69,22 +55,44 @@ defmodule Dotcom.TripPlan.ItineraryGroups do
     grouped_itineraries
   end
 
-  defp to_summarized_group(grouped_itineraries) do
-    %{
-      itineraries: ItineraryTag.sort_tagged(grouped_itineraries),
-      summary: summary(grouped_itineraries)
-    }
+  defp limit_itinerary_count(itineraries, take_from_end?) do
+    if take_from_end? do
+      Enum.take(itineraries, -@max_per_group)
+    else
+      Enum.take(itineraries, @max_per_group)
+    end
   end
 
-  defp limit_itinerary_count(itineraries) do
-    Enum.take(itineraries, @max_per_group)
+  # Summarize a group of chronologically-sorted itineraries, noting the
+  # - representative_index: Which itinerary should represent the group? It will
+  #   be either the first or final one.
+  # - representative_time: An itinerary departs at the :start time and arrives
+  #   by the :stop time. This denotes which of those is relevant to the group.
+  defp to_group(grouped_itineraries, take_from_end?) do
+    representative_index = if(take_from_end?, do: Enum.count(grouped_itineraries) - 1, else: 0)
+
+    summary =
+      grouped_itineraries
+      |> Enum.at(representative_index)
+      |> to_summary(grouped_itineraries)
+
+    %ItineraryGroup{
+      # TODO: use second arg to sort by end time instead of start time
+      itineraries: ItineraryTag.sort_tagged(grouped_itineraries),
+      representative_index: representative_index,
+      representative_time: if(take_from_end?, do: :stop, else: :start),
+      summary: summary
+    }
   end
 
-  defp summary(itineraries) do
-    itineraries
-    |> Enum.map(&to_map_with_fare/1)
-    |> to_summary()
-    |> Map.put(:summarized_legs, to_summarized_legs(itineraries))
+  @doc """
+  The itinerary summary additionally includes a fare and summarized legs
+  """
+  @spec to_summary(Itinerary.t(), [Itinerary.t()]) :: map()
+  def to_summary(representative_itinerary, grouped_itineraries) do
+    representative_itinerary
+    |> to_map_with_fare()
+    |> Map.put(:summarized_legs, to_summarized_legs(grouped_itineraries))
   end
 
   defp to_summarized_legs(itineraries) do
@@ -109,7 +117,7 @@ defmodule Dotcom.TripPlan.ItineraryGroups do
 
   defp to_map_with_fare(itinerary) do
     itinerary
-    |> Map.take([:start, :stop, :tag, :duration, :accessible?, :walk_distance])
+    |> Map.take([:accessible?, :duration, :start, :stop, :tag, :walk_distance])
     |> Map.put(
       :total_cost,
       get_one_way_total_by_type(itinerary, :highest_one_way_fare)
@@ -126,34 +134,6 @@ defmodule Dotcom.TripPlan.ItineraryGroups do
     |> Enum.map(fn {leg, _} -> leg end)
   end
 
-  defp to_summary(itinerary_maps) do
-    # for most of the summary we can reflect the first itinerary
-    [
-      %{
-        tag: tag,
-        accessible?: accessible,
-        total_cost: total_cost,
-        duration: duration,
-        walk_distance: walk_distance,
-        stop: first_stop
-      }
-      | _
-    ] = itinerary_maps
-
-    [first_start | next_starts] = Enum.map(itinerary_maps, & &1.start)
-
-    %{
-      first_start: first_start,
-      first_stop: first_stop,
-      next_starts: next_starts,
-      tag: if(tag, do: Atom.to_string(tag) |> String.replace("_", " ")),
-      duration: duration,
-      accessible?: accessible,
-      walk_distance: walk_distance,
-      total_cost: total_cost
-    }
-  end
-
   defp summarize_legs(%{walk_minutes: new}, %{walk_minutes: old} = summary) do
     %{summary | walk_minutes: new + old}
   end
diff --git a/lib/dotcom_web/components/trip_planner/itinerary_detail.ex b/lib/dotcom_web/components/trip_planner/itinerary_detail.ex
index 82e8d9b17d..9254f00c70 100644
--- a/lib/dotcom_web/components/trip_planner/itinerary_detail.ex
+++ b/lib/dotcom_web/components/trip_planner/itinerary_detail.ex
@@ -14,48 +14,6 @@ defmodule DotcomWeb.Components.TripPlanner.ItineraryDetail do
   alias Dotcom.TripPlan.Alerts
 
   def itinerary_detail(assigns) do
-    itinerary_group =
-      Enum.at(assigns.results.itinerary_groups, assigns.results.itinerary_group_selection || 0)
-
-    itinerary = Enum.at(itinerary_group.itineraries, assigns.results.itinerary_selection || 0)
-
-    assigns = %{
-      itinerary: itinerary,
-      itinerary_selection: assigns.results.itinerary_selection,
-      itineraries: itinerary_group.itineraries
-    }
-
-    ~H"""
-    <div>
-      <.depart_at_buttons itineraries={@itineraries} itinerary_selection={@itinerary_selection} />
-      <.specific_itinerary_detail itinerary={@itinerary} />
-    </div>
-    """
-  end
-
-  defp depart_at_buttons(assigns) do
-    ~H"""
-    <div :if={Enum.count(@itineraries) > 1}>
-      <hr class="border-gray-lighter" />
-      <p class="text-sm mb-2 mt-3">Depart at</p>
-      <div id="itinerary-detail-departure-times" class="flex flex-wrap gap-2">
-        <.button
-          :for={{itinerary, index} <- Enum.with_index(@itineraries)}
-          type="button"
-          class={if(@itinerary_selection == index, do: "bg-brand-primary-lightest")}
-          size="small"
-          variant="secondary"
-          phx-click="select_itinerary"
-          phx-value-index={index}
-        >
-          {Timex.format!(itinerary.start, "%-I:%M%p", :strftime) |> String.downcase()}
-        </.button>
-      </div>
-    </div>
-    """
-  end
-
-  defp specific_itinerary_detail(assigns) do
     assigns =
       assigns
       |> assign_new(:alerts, fn -> Alerts.from_itinerary(assigns.itinerary) end)
diff --git a/lib/dotcom_web/components/trip_planner/itinerary_summary.ex b/lib/dotcom_web/components/trip_planner/itinerary_summary.ex
index 4a115dd877..065e90f024 100644
--- a/lib/dotcom_web/components/trip_planner/itinerary_summary.ex
+++ b/lib/dotcom_web/components/trip_planner/itinerary_summary.ex
@@ -5,12 +5,14 @@ defmodule DotcomWeb.Components.TripPlanner.ItinerarySummary do
 
   use DotcomWeb, :component
 
+  attr :summary, :map, required: true
+
   def itinerary_summary(assigns) do
     ~H"""
     <div>
       <div class="flex flex-row mb-3 font-bold text-lg justify-between">
         <div>
-          {format_datetime_full(@summary.first_start)} - {format_datetime_full(@summary.first_stop)}
+          {format_datetime_full(@summary.start)} - {format_datetime_full(@summary.stop)}
         </div>
         <div>
           {@summary.duration} min
diff --git a/lib/dotcom_web/components/trip_planner/results.ex b/lib/dotcom_web/components/trip_planner/results.ex
index 6b13ea783e..30cb6f25e7 100644
--- a/lib/dotcom_web/components/trip_planner/results.ex
+++ b/lib/dotcom_web/components/trip_planner/results.ex
@@ -8,6 +8,8 @@ defmodule DotcomWeb.Components.TripPlanner.Results do
 
   import DotcomWeb.Components.TripPlanner.{ItineraryDetail, ItinerarySummary}
 
+  alias Dotcom.TripPlan.{ItineraryGroup, ItineraryGroups}
+
   def results(assigns) do
     ~H"""
     <section
@@ -43,32 +45,27 @@ defmodule DotcomWeb.Components.TripPlanner.Results do
     """
   end
 
+  # When an itinerary group is selected, show a list of group summaries, each
+  # optionally displaying a tag and description of alternate times
   defp itinerary_panel(%{results: %{itinerary_group_selection: nil}} = assigns) do
     ~H"""
     <div class="flex flex-col gap-4">
       <div
-        :for={{%{summary: summary}, index} <- Enum.with_index(@results.itinerary_groups)}
+        :for={{group, index} <- Enum.with_index(@results.itinerary_groups)}
         class="border border-solid border-gray-lighter p-4"
         phx-click="select_itinerary_group"
         phx-value-index={index}
       >
         <div
-          :if={summary.tag}
+          :if={group.summary.tag}
           class="whitespace-nowrap leading-none font-bold font-heading text-sm uppercase bg-brand-primary-darkest text-white px-3 py-2 mb-3 -ml-4 -mt-4 rounded-br-lg w-min"
         >
-          {summary.tag}
+          {Phoenix.Naming.humanize(group.summary.tag)}
         </div>
-        <.itinerary_summary summary={summary} />
+        <.itinerary_summary summary={group.summary} />
         <div class="flex justify-end items-center">
-          <div :if={Enum.count(summary.next_starts) > 0} class="grow text-sm text-grey-dark">
-            Similar {if(Enum.count(summary.next_starts) == 1,
-              do: "trip departs",
-              else: "trips depart"
-            )} at {Enum.map(
-              summary.next_starts,
-              &Timex.format!(&1, "%-I:%M", :strftime)
-            )
-            |> Enum.join(", ")}
+          <div :if={ItineraryGroup.options_text(group)} class="grow text-sm text-grey-dark">
+            {ItineraryGroup.options_text(group)}
           </div>
           <button
             class="btn-link font-semibold underline"
@@ -83,20 +80,60 @@ defmodule DotcomWeb.Components.TripPlanner.Results do
     """
   end
 
-  defp itinerary_panel(assigns) do
-    itinerary_group =
-      Enum.at(assigns.results.itinerary_groups, assigns.results.itinerary_group_selection)
+  # When an itinerary group is selected, show a summary & details for the
+  # default selected itinerary from that group, along with buttons for selecting
+  # from all available times in the group
+  defp itinerary_panel(%{
+         results: %{
+           itinerary_groups: itinerary_groups,
+           itinerary_group_selection: itinerary_group_selection,
+           itinerary_selection: itinerary_selection
+         }
+       }) do
+    itinerary_group = Enum.at(itinerary_groups, itinerary_group_selection)
+
+    itinerary =
+      itinerary_group
+      |> Map.get(:itineraries)
+      |> Enum.at(itinerary_selection)
 
     assigns = %{
-      summary: itinerary_group.summary,
-      results: assigns.results
+      all_times: ItineraryGroup.all_times(itinerary_group),
+      itinerary: itinerary,
+      itinerary_selection: itinerary_selection,
+      summary: ItineraryGroups.to_summary(itinerary, [itinerary]),
+      time_label:
+        if(itinerary_group.representative_time == :stop, do: "Arrive by", else: "Depart at")
     }
 
     ~H"""
     <div>
       <.itinerary_summary summary={@summary} />
-      <.itinerary_detail results={@results} />
+      <div :if={Enum.count(@all_times) > 1}>
+        <hr class="border-gray-lighter" />
+        <p class="text-sm mb-2 mt-3">{@time_label}</p>
+        <div id="itinerary-detail-departure-times" class="flex flex-wrap gap-2">
+          <.button
+            :for={{time, index} <- Enum.with_index(@all_times)}
+            type="button"
+            class={if(@itinerary_selection == index, do: "bg-brand-primary-lightest")}
+            size="small"
+            variant="secondary"
+            phx-click="select_itinerary"
+            phx-value-index={index}
+          >
+            {formatted_time(time)}
+          </.button>
+        </div>
+      </div>
+      <.itinerary_detail itinerary={@itinerary} />
     </div>
     """
   end
+
+  defp formatted_time(time) do
+    time
+    |> Timex.format!("%-I:%M%p", :strftime)
+    |> String.downcase()
+  end
 end
diff --git a/lib/dotcom_web/live/trip_planner.ex b/lib/dotcom_web/live/trip_planner.ex
index 8679dd1fb0..458e9dff58 100644
--- a/lib/dotcom_web/live/trip_planner.ex
+++ b/lib/dotcom_web/live/trip_planner.ex
@@ -10,7 +10,7 @@ defmodule DotcomWeb.Live.TripPlanner do
   import DotcomWeb.Components.TripPlanner.{InputForm, Results, ResultsSummary}
 
   alias Dotcom.TripPlan
-  alias Dotcom.TripPlan.{AntiCorruptionLayer, InputForm, ItineraryGroups}
+  alias Dotcom.TripPlan.{AntiCorruptionLayer, InputForm, ItineraryGroup, ItineraryGroups}
 
   @state %{
     input_form: %{
@@ -239,15 +239,39 @@ defmodule DotcomWeb.Live.TripPlanner do
   #
   # - Update the itinerary group selection
   # - Update the map state with the new lines and points
-  def handle_event("select_itinerary_group", %{"index" => index}, socket) do
-    index = String.to_integer(index)
+  def handle_event(
+        "select_itinerary_group",
+        %{"index" => group_index},
+        %{
+          assigns: %{
+            results: %{itinerary_groups: itinerary_groups}
+          }
+        } = socket
+      ) do
+    group_index = String.to_integer(group_index)
+
+    %ItineraryGroup{representative_index: representative_index} =
+      Enum.at(itinerary_groups, group_index)
 
     new_map = %{
-      lines: itinerary_groups_to_lines(socket.assigns.results.itinerary_groups, index, 0),
-      points: itinerary_groups_to_points(socket.assigns.results.itinerary_groups, index, 0)
+      lines:
+        itinerary_groups_to_lines(
+          itinerary_groups,
+          group_index,
+          representative_index
+        ),
+      points:
+        itinerary_groups_to_points(
+          itinerary_groups,
+          group_index,
+          representative_index
+        )
     }
 
-    new_results = %{itinerary_group_selection: index, itinerary_selection: 0}
+    new_results = %{
+      itinerary_group_selection: group_index,
+      itinerary_selection: representative_index
+    }
 
     new_socket =
       socket
@@ -309,7 +333,7 @@ defmodule DotcomWeb.Live.TripPlanner do
 
     case Dotcom.TripPlan.OpenTripPlanner.plan(data) do
       {:ok, itineraries} ->
-        ItineraryGroups.from_itineraries(itineraries)
+        ItineraryGroups.from_itineraries(itineraries, data.datetime_type == "arrive_by")
 
       error ->
         error
@@ -339,7 +363,6 @@ defmodule DotcomWeb.Live.TripPlanner do
   defp input_form_to_pins(_), do: []
 
   # Get the itinerary group at the given index and convert it to a map.
-  # Selects a random itinerary from the group as they will all be the same.
   defp itinerary_groups_to_itinerary_map(itinerary_groups, group_index, index) do
     itinerary_groups
     |> Enum.at(group_index)
diff --git a/test/dotcom/trip_plan/itinerary_group_test.exs b/test/dotcom/trip_plan/itinerary_group_test.exs
new file mode 100644
index 0000000000..ce88b28e72
--- /dev/null
+++ b/test/dotcom/trip_plan/itinerary_group_test.exs
@@ -0,0 +1,88 @@
+defmodule Dotcom.TripPlan.ItineraryGroupTest do
+  @moduledoc false
+
+  use ExUnit.Case, async: true
+
+  import Mox
+
+  alias Dotcom.TripPlan.ItineraryGroup
+  alias Test.Support.Factories.{Stops.Stop, TripPlanner.TripPlanner}
+
+  setup :verify_on_exit!
+
+  setup do
+    stub(Stops.Repo.Mock, :get, &Stop.build(:stop, id: &1))
+    :ok
+  end
+
+  describe "options_text/1" do
+    test "does nothing if no alternate times" do
+      refute ItineraryGroup.options_text(%ItineraryGroup{itineraries: []})
+
+      refute ItineraryGroup.options_text(%ItineraryGroup{
+               itineraries: [TripPlanner.build(:itinerary)]
+             })
+    end
+
+    test "describes alternate times for the group" do
+      # SETUP
+      itineraries = TripPlanner.build_list(Faker.Util.pick(2..4), :itinerary)
+      representative_index = Faker.Util.pick(0..(length(itineraries) - 1))
+      start_or_stop = Faker.Util.pick([:start, :stop])
+
+      group = %ItineraryGroup{
+        itineraries: itineraries,
+        representative_index: representative_index,
+        representative_time: start_or_stop
+      }
+
+      # EXERCISE
+      text = ItineraryGroup.options_text(group)
+
+      # VERIFY
+      if Enum.count(itineraries) == 2 do
+        # only one alternate trip
+        assert text =~ "trip "
+
+        if group.representative_time == :start do
+          assert text =~ "departs at"
+        else
+          assert text =~ "arrives by"
+        end
+      else
+        assert text =~ "trips "
+
+        if group.representative_time == :start do
+          assert text =~ "depart at"
+        else
+          assert text =~ "arrive by"
+        end
+      end
+    end
+  end
+
+  describe "all_times/1" do
+    test "uses representative_time to map to chosen times" do
+      # SETUP
+      itineraries = TripPlanner.build_list(4, :itinerary)
+
+      # EXERCISE
+      start_times =
+        %ItineraryGroup{
+          itineraries: itineraries,
+          representative_time: :start
+        }
+        |> ItineraryGroup.all_times()
+
+      stop_times =
+        %ItineraryGroup{
+          itineraries: itineraries,
+          representative_time: :stop
+        }
+        |> ItineraryGroup.all_times()
+
+      # VERIFY
+      assert start_times != stop_times
+    end
+  end
+end
diff --git a/test/dotcom/trip_plan/itinerary_groups_test.exs b/test/dotcom/trip_plan/itinerary_groups_test.exs
index d5661419f8..8aa9255446 100644
--- a/test/dotcom/trip_plan/itinerary_groups_test.exs
+++ b/test/dotcom/trip_plan/itinerary_groups_test.exs
@@ -8,6 +8,8 @@ defmodule Dotcom.TripPlan.ItineraryGroupsTest do
   alias Dotcom.TripPlan.ItineraryGroups
   alias Test.Support.Factories.{Stops.Stop, TripPlanner.TripPlanner}
 
+  setup :verify_on_exit!
+
   setup do
     stub(Stops.Repo.Mock, :get, fn _ ->
       Stop.build(:stop)
@@ -18,7 +20,7 @@ defmodule Dotcom.TripPlan.ItineraryGroupsTest do
     {:ok, stops: stops}
   end
 
-  describe "from_itineraries/1" do
+  describe "from_itineraries/2" do
     test "groups itineraries with the same mode, from, and to", %{stops: [a, b, c]} do
       # SETUP
       bus_a_b_leg = TripPlanner.build(:bus_leg, from: a, to: b)
@@ -34,7 +36,7 @@ defmodule Dotcom.TripPlan.ItineraryGroupsTest do
       assert Kernel.length(grouped_itineraries) == 1
     end
 
-    test "only includes the first five itineraries in a group", %{stops: [a, b, c]} do
+    test "only includes the first few itineraries in a group", %{stops: [a, b, c]} do
       # SETUP
       bus_a_b_leg = TripPlanner.build(:bus_leg, from: a, to: b)
       subway_b_c_leg = TripPlanner.build(:subway_leg, from: b, to: c)
@@ -46,7 +48,7 @@ defmodule Dotcom.TripPlan.ItineraryGroupsTest do
       [group] = ItineraryGroups.from_itineraries(itineraries)
 
       # VERIFY
-      assert Kernel.length(group.itineraries) == 5
+      assert Kernel.length(group.itineraries) == ItineraryGroups.max_per_group()
     end
 
     test "does not group itineraries with different modes", %{stops: [a, b, c]} do
@@ -138,4 +140,53 @@ defmodule Dotcom.TripPlan.ItineraryGroupsTest do
 
     assert [_, %{walk_minutes: 6}, _] = legs
   end
+
+  test "caps itineraries at certain number each group" do
+    base_itinerary = TripPlanner.build(:itinerary)
+
+    itineraries =
+      Faker.Util.list(10, fn n ->
+        t = base_itinerary.start
+        base_itinerary |> Map.put(:start, Timex.shift(t, minutes: 10 * n))
+      end)
+
+    counts =
+      itineraries
+      |> ItineraryGroups.from_itineraries()
+      |> Enum.map(&Enum.count(&1.itineraries))
+
+    refute Enum.any?(counts, &(&1 > ItineraryGroups.max_per_group()))
+  end
+
+  test "uses second argument to pick last N itineraries per group instead of first" do
+    base_start_time = Faker.DateTime.forward(1)
+
+    base_itinerary =
+      TripPlanner.build(:itinerary,
+        start: base_start_time,
+        stop: Timex.shift(base_start_time, minutes: 30)
+      )
+
+    # list of itineraries sorted by time, that's otherwise identical such that
+    # they'll get grouped together
+    sorted_itineraries =
+      Faker.Util.list(15, fn n ->
+        base_itinerary
+        |> Map.put(:start, Timex.shift(base_itinerary.start, minutes: 10 * n))
+        |> Map.put(:stop, Timex.shift(base_itinerary.stop, minutes: 10 * n))
+      end)
+
+    first_n_itineraries = Enum.take(sorted_itineraries, ItineraryGroups.max_per_group())
+    last_n_itineraries = Enum.take(sorted_itineraries, -ItineraryGroups.max_per_group())
+
+    assert sorted_itineraries
+           |> ItineraryGroups.from_itineraries()
+           |> List.first()
+           |> Map.get(:itineraries) == first_n_itineraries
+
+    assert sorted_itineraries
+           |> ItineraryGroups.from_itineraries(true)
+           |> List.first()
+           |> Map.get(:itineraries) == last_n_itineraries
+  end
 end