diff --git a/lib/arrow/trainsformer/export_upload.ex b/lib/arrow/trainsformer/export_upload.ex
index f2cebd5c6..0427750e1 100644
--- a/lib/arrow/trainsformer/export_upload.ex
+++ b/lib/arrow/trainsformer/export_upload.ex
@@ -10,22 +10,16 @@ defmodule Arrow.Trainsformer.ExportUpload do
 
   @type t :: %__MODULE__{
           zip_binary: binary(),
-          one_of_north_south_stations: :ok | :both | :neither,
           routes: [String.t()],
           services: [String.t()],
-          missing_routes: [String.t()],
-          invalid_routes: [String.t()],
-          trips_missing_transfers: MapSet.t()
+          warnings: list({:warning, {any(), {binary(), keyword()}}})
         }
 
   @enforce_keys [
     :zip_binary,
-    :one_of_north_south_stations,
     :routes,
     :services,
-    :missing_routes,
-    :invalid_routes,
-    :trips_missing_transfers
+    :warnings
   ]
   defstruct @enforce_keys
 
@@ -56,33 +50,19 @@ defmodule Arrow.Trainsformer.ExportUpload do
   @spec extract_data_from_upload(%{path: binary()}) ::
           {:ok,
            {:ok, t()}
-           | {:error, {:invalid_stop_times, any()}}}
-          | {:error, {:invalid_export_stops, [String.t()]}}
-          | {:error, {:existing_service_id, [String.t()]}}
+           | {:error, list({:error | :warning, {any(), {binary(), keyword()}}})}}
   def extract_data_from_upload(
         %{path: zip_path},
         unzip_module \\ Unzip,
         import_helper \\ Arrow.Gtfs.ImportHelper
       ) do
-    zip_bin = Unzip.LocalFile.open(zip_path)
-
-    with {:ok, unzip} <- Unzip.new(zip_bin),
+    with {:ok, unzip_handle} <- open_zip(zip_path),
+         {:ok, unzip} <- new_unzip(unzip_handle),
          {:ok, %{trips: trips, stop_times: stop_times, transfers: transfers}} <-
            validate_csvs(unzip, unzip_module, import_helper),
-         {:ok, stop_ids} <-
-           validate_stop_times_in_gtfs(stop_times),
-         :ok <- validate_stop_order(stop_times),
-         :ok <- validate_unique_service_ids(trips),
-         {:ok, zip_bin} <- File.read(zip_path) do
-      one_of_north_south_stations = validate_one_of_north_south_stations(stop_ids)
-      {missing_routes, invalid_routes} = validate_one_or_all_routes_from_one_side(trips)
-
-      trips_missing_transfers =
-        case validate_transfers(transfers, stop_times) do
-          :ok -> MapSet.new()
-          {:error, {:trips_missing_transfers, invalid_trips}} -> invalid_trips
-        end
-
+         {:ok, warnings} <-
+           validate_export_data(trips, stop_times, transfers),
+         {:ok, zip_bin} <- read_zip_binary(zip_path) do
       {routes, services} =
         trips
         |> Enum.reduce(
@@ -113,23 +93,103 @@ defmodule Arrow.Trainsformer.ExportUpload do
 
       export_data = %__MODULE__{
         zip_binary: zip_bin,
-        one_of_north_south_stations: one_of_north_south_stations,
-        missing_routes: missing_routes,
-        invalid_routes: invalid_routes,
         routes: route_maps,
         services: service_maps,
-        trips_missing_transfers: trips_missing_transfers
+        warnings: warnings
       }
 
       {:ok, {:ok, export_data}}
     else
-      errors ->
-        {:ok, errors}
+      # Must be wrapped in an ok tuple for caller, consume_uploaded_entry/3
+      errors when is_list(errors) ->
+        {:ok, {:error, errors}}
+
+      {:error, _} = error ->
+        {:ok, {:error, List.wrap(error)}}
     end
+  end
+
+  defp new_unzip(unzip_handle) do
+    case Unzip.new(unzip_handle) do
+      {:ok, _} = ok_result -> ok_result
+      {:error, error_message} -> new_error(:zip_file, error_message)
+    end
+  end
+
+  # NOTE: Consider moving to `Arrow.Gtfs.ImportHelper`?...
+  defp open_zip(zip_path) do
+    # `Unzip.LocalFile.open` is a very simple implementation and, (as of writing)
+    # simply expects that `:file.open` succeeds and pattern matches on that success.
+    # But due to the pattern match, the errors aren't very clear, helpful, or useful
+    # for users not familiar with Elixir/Erlang `:file` or this application.
+    #
+    # We could consider making our own `LocalFile` implementation, but really the
+    # only issue with it is it's error reporting, and we're unlikely to hit any
+    # of those issues.
+    #
+    # Per https://www.erlang.org/docs/28/apps/kernel/file.html#open/2
+    # These are the "typical" errors that `:file.open` could return, and why they
+    # may or may not apply:
+    #
+    # > `enoent` - The file does not exist.
+    # It'd be very strange if Phoenix gave us a file that didn't exist, not user actionable.
+    #
+    # > `eacces` - Missing permission for reading the file or searching one of the parent directories.
+    # It'd also be strange if Phoenix gave us a file that it wrote, but didn't have permissions for, not user actionable
+    #
+    # > `eisdir` - The named file is a directory.
+    # This would also be strange for Phoenix to give us a directory,
+    # _could_ be a security issue[^security-issue] if somehow we did receive a directory.
+    #
+    # [^security-issue]: (because that would mean that the "attacker" has gained control of Phoenix
+    # in a way we don't _currently_ expect)
+    #
+    # > `enospc` - There is no space left on the device (if write access was specified).
+    # This seems like the most likely error we'd get, but it's also not user actionable.
+    #
+    # Running out of space on our instance would likely mean we have bigger problems
+    # and not something we could "error handle" our way out of.
+    {:ok, Unzip.LocalFile.open(zip_path)}
   rescue
-    e ->
-      # Must be wrapped in an ok tuple for caller, consume_uploaded_entry/3
-      {:ok, {:error, "Could not parse zip, message=#{Exception.format(:error, e)}"}}
+    error ->
+      new_error(
+        :zip_file,
+        "Failed to open zip file, message=#{Exception.format(:error, error)}"
+      )
+  end
+
+  defp read_zip_binary(zip_path) do
+    case File.read(zip_path) do
+      {:ok, _} = result ->
+        result
+
+      {:error, posix} ->
+        new_error(:zip_file, "Failed to read zip file contents: %{error_message}",
+          error_message: :file.format_error(posix),
+          posix_error: posix
+        )
+    end
+  end
+
+  defp validate_export_data(trips, stop_times, transfers) do
+    stop_ids = get_stop_ids(stop_times)
+
+    errors_and_warnings =
+      [
+        validate_stop_ids_in_gtfs(stop_ids),
+        validate_stop_order(stop_times),
+        validate_unique_service_ids(trips),
+        validate_one_of_north_south_stations(stop_ids),
+        validate_one_or_all_routes_from_one_side(trips),
+        validate_transfers(transfers, stop_times)
+      ]
+      |> Enum.reject(&(&1 == :ok))
+
+    if Enum.any?(errors_and_warnings, &match?({:error, _}, &1)) do
+      errors_and_warnings
+    else
+      {:ok, errors_and_warnings}
+    end
   end
 
   defp validate_unique_service_ids(trips) do
@@ -145,43 +205,42 @@ defmodule Arrow.Trainsformer.ExportUpload do
           where: s.name in ^export_service_ids
       )
 
-    if Enum.empty?(existing_service_ids_intersection) do
-      :ok
+    if Enum.any?(existing_service_ids_intersection) do
+      new_error(:existing_service_ids, "Export contains previously used service_id's",
+        existing_service_ids: existing_service_ids_intersection
+      )
     else
-      {:error, {:existing_service_id, existing_service_ids_intersection}}
+      :ok
     end
   end
 
-  def validate_stop_times_in_gtfs(
-        stop_times,
+  def validate_stop_ids_in_gtfs(
+        stop_ids,
         repo \\ Arrow.Repo
       ) do
-    trainsformer_stop_ids =
-      stop_times
-      |> Enum.uniq_by(& &1.stop_id)
-      |> Enum.map(& &1.stop_id)
-
     gtfs_stop_ids =
       MapSet.new(
         repo.all(
           from s in Arrow.Gtfs.Stop,
-            where: s.id in ^trainsformer_stop_ids,
+            where: s.id in ^stop_ids,
             select: s.id
         )
       )
 
     stops_missing_from_gtfs =
-      Enum.filter(trainsformer_stop_ids, fn stop -> !MapSet.member?(gtfs_stop_ids, stop) end)
+      Enum.filter(stop_ids, fn stop -> !MapSet.member?(gtfs_stop_ids, stop) end)
 
     if Enum.any?(stops_missing_from_gtfs) do
-      {:error, {:invalid_export_stops, stops_missing_from_gtfs}}
+      new_error(:stop_id_not_in_gtfs, "Export has stops not present in GTFS",
+        stop_id_not_in_gtfs: stops_missing_from_gtfs
+      )
     else
-      {:ok, trainsformer_stop_ids}
+      :ok
     end
   end
 
   @spec validate_stop_order(any()) ::
-          :ok | {:error, {:invalid_stop_times, any()}} | {:ok, {:error, <<_::160>>}}
+          :ok | {:error, {:invalid_stop_times, {binary(), keyword()}}}
   def validate_stop_order(stop_times) do
     trainsformer_trips =
       Enum.group_by(stop_times, & &1.trip_id)
@@ -190,7 +249,9 @@ defmodule Arrow.Trainsformer.ExportUpload do
       Enum.flat_map(trainsformer_trips, &validate_trip(&1))
 
     if Enum.any?(invalid_stop_times) do
-      {:error, {:invalid_stop_times, invalid_stop_times}}
+      new_error(:invalid_stop_times, "Export contains trips with out-of-order stop times",
+        invalid_stop_times: invalid_stop_times
+      )
     else
       :ok
     end
@@ -288,10 +349,14 @@ defmodule Arrow.Trainsformer.ExportUpload do
     trips_needing_transfers_without_transfers =
       MapSet.difference(trips_needing_transfers, trips_with_transfers)
 
-    if Enum.empty?(trips_needing_transfers_without_transfers) do
-      :ok
+    if Enum.any?(trips_needing_transfers_without_transfers) do
+      new_warning(
+        :trips_missing_transfers,
+        "Some train trips that do not serve North Station, South Station, or Foxboro lack transfers",
+        trips_missing_transfers: trips_needing_transfers_without_transfers
+      )
     else
-      {:error, {:trips_missing_transfers, trips_needing_transfers_without_transfers}}
+      :ok
     end
   end
 
@@ -309,19 +374,23 @@ defmodule Arrow.Trainsformer.ExportUpload do
   end
 
   @spec validate_one_of_north_south_stations(any()) ::
-          :ok
-          | :both
-          | :neither
+          :ok | {:warning, {:invalid_sides, {binary(), keyword()}}}
   def validate_one_of_north_south_stations(trainsformer_stop_ids) do
     north_station_served = Enum.member?(trainsformer_stop_ids, "BNT-0000")
     south_station_served = Enum.member?(trainsformer_stop_ids, "NEC-2287")
 
     cond do
       north_station_served and south_station_served ->
-        :both
+        new_warning(
+          :invalid_sides,
+          "Export contains trips serving North and South Station"
+        )
 
       not north_station_served and not south_station_served ->
-        :neither
+        new_warning(
+          :invalid_sides,
+          "Export does not contain trips serving North or South Station"
+        )
 
       true ->
         :ok
@@ -343,9 +412,8 @@ defmodule Arrow.Trainsformer.ExportUpload do
 
   # We require all of the routes from one side to be present,
   # or a single route.
-  # Returns {missing_routes, invalid_routes}
   @spec validate_one_or_all_routes_from_one_side(any()) ::
-          {[String.t()], [String.t()]}
+          :ok | {:warning, {:missing_routes | :invalid_routes, {binary(), keyword()}}}
   def validate_one_or_all_routes_from_one_side(trips) do
     trainsformer_route_ids =
       trips
@@ -368,23 +436,35 @@ defmodule Arrow.Trainsformer.ExportUpload do
 
     cond do
       length(trainsformer_route_ids) == 1 ->
-        {[], []}
+        :ok
 
       num_southside_routes_missing == 0 ->
-        {[], []}
+        :ok
 
       num_northside_routes_missing == 0 ->
-        {[], []}
+        :ok
 
       num_southside_routes_missing < length(@southside_route_ids) ->
-        {southside_routes_missing, []}
+        new_warning(
+          :missing_routes,
+          "Not all southside routes are present",
+          missing_routes: southside_routes_missing
+        )
 
       num_northside_routes_missing < length(@northside_route_ids) ->
-        {northside_routes_missing, []}
+        new_warning(
+          :missing_routes,
+          "Not all northside routes are present",
+          missing_routes: northside_routes_missing
+        )
 
       # More than one route, and they all aren't in @northside_route_ids or @southside_route_ids
       true ->
-        {[], trainsformer_route_ids}
+        new_warning(
+          :invalid_routes,
+          "Multiple routes not north or southside",
+          invalid_routes: trainsformer_route_ids
+        )
     end
   end
 
@@ -552,10 +632,10 @@ defmodule Arrow.Trainsformer.ExportUpload do
     {errors, Map.put(result, data_type, rows)}
   rescue
     e ->
-      {[
-         {:error, entry.file_name, Exception.format(:error, e)}
-         | errors
-       ], result}
+      {
+        [new_error(entry.file_name, Exception.format(:error, e)) | errors],
+        result
+      }
   end
 
   @files_to_parse ["trips.txt", "transfers.txt", "stop_times.txt"]
@@ -619,4 +699,47 @@ defmodule Arrow.Trainsformer.ExportUpload do
       _ -> nil
     end
   end
+
+  defp get_stop_ids(stop_times) do
+    stop_times
+    |> Enum.uniq_by(& &1.stop_id)
+    |> Enum.map(& &1.stop_id)
+  end
+
+  defp new_error(key, message, metadata \\ []),
+    do: {:error, new_validation_message(key, message, metadata)}
+
+  defp new_warning(key, message, metadata \\ []),
+    do: {:warning, new_validation_message(key, message, metadata)}
+
+  # This function returns a data structure that follows similarly to how Ecto
+  # changesets encode errors
+  #
+  # Ecto changesets have a structure of
+  # ```
+  # {key, {message, keys}}
+  # ```
+  # where
+  # - `key` is the field the error is related to
+  # - `message` is the templated message that describes the error
+  # - `keys` is a keyword list of metadata that can be used to "hydrate" the `message`
+  #
+  # This structure is valuable for a few reasons:
+  # 1. `ArrowWeb.CoreComponents.translate_error/1` takes a `{msg, opts}`
+  #     structure by default, which was a decent place to build off of
+  #     due to how it mirrors/consumes Ecto `{message, keys}` data
+  #
+  # 2. Having the `message` and `keys` wrapped together means there's less
+  #     modifications that need to be done when grouping by `key`
+  #
+  # 3. Having this all be it's own tuple, rather than a 4 element tuple when
+  #     combined with an error, such as: `{:error, new_validation_message(...)}`
+  #     has similar value to #2, i.e., you don't need to write as
+  #     many match cases to extract values from the tuple if you're only dealing
+  #     with checking the "type" or "key" values
+  #
+  #     a downside is that it does complicate extracting a single element with the
+  #     `Kernel.elem/2` function.
+  defp new_validation_message(key, message, metadata),
+    do: {key, {message, metadata}}
 end
diff --git a/lib/arrow_web/components/disruption_components.ex b/lib/arrow_web/components/disruption_components.ex
index 11217d718..a0b0621a6 100644
--- a/lib/arrow_web/components/disruption_components.ex
+++ b/lib/arrow_web/components/disruption_components.ex
@@ -725,4 +725,24 @@ defmodule ArrowWeb.DisruptionComponents do
     </div>
     """
   end
+
+  attr :type, :atom, required: true, values: [:error, :warning]
+  slot :inner_block, required: true
+
+  def upload_alert(assigns) do
+    assigns =
+      assign(assigns,
+        alert_type:
+          case assigns[:type] do
+            :error -> "alert-danger"
+            :warning -> "alert-warning"
+          end
+      )
+
+    ~H"""
+    <ArrowWeb.CoreComponents.error class={"d-block alert #{@alert_type}"}>
+      {render_slot(@inner_block)}
+    </ArrowWeb.CoreComponents.error>
+    """
+  end
 end
diff --git a/lib/arrow_web/components/edit_trainsformer_export_form.ex b/lib/arrow_web/components/edit_trainsformer_export_form.ex
index fde05df77..c8c2a242f 100644
--- a/lib/arrow_web/components/edit_trainsformer_export_form.ex
+++ b/lib/arrow_web/components/edit_trainsformer_export_form.ex
@@ -42,37 +42,9 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
             add a new service schedule
           </h4>
           <h5>Upload a new Trainsformer export</h5>
-          <div :if={not is_nil(@error)} class="alert alert-danger">
-            {@error}
-          </div>
-          <div :if={not is_nil(@invalid_export_stops)} class="d-inline-block p-20 alert alert-danger">
-            Some stops are not present in GTFS!
-            <.button
-              type="button"
-              class="alert-info d-block"
-              phx-click="download_invalid_export_stops"
-              phx-target={@myself}
-            >
-              Download list of invalid stops
-            </.button>
-          </div>
-          <div :if={not is_nil(@invalid_stop_times)} class="d-inline-block p-20 alert alert-danger">
-            Some stop times are out of order!
-            <.button
-              type="button"
-              class="alert-info d-block"
-              phx-click="download_invalid_stop_times"
-              phx-target={@myself}
-            >
-              Download list of invalid stop times
-            </.button>
-          </div>
-          <div :if={not is_nil(@existing_service_ids)} class="d-inline-block p-20 alert alert-danger">
-            Export contains previously used service ids
-            <ul>
-              <li :for={service_id <- @existing_service_ids}>{service_id}</li>
-            </ul>
-          </div>
+
+          <.export_alert :for={error <- @errors} error={error} myself={@myself} />
+
           <div :for={entry <- @uploads.trainsformer_export.entries}>
             <progress value={entry.progress} max="100">
               {entry.progress}%
@@ -253,34 +225,7 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
             </div>
           </div>
 
-          <div :if={@one_of_north_south_stations == :both} class="text-warning mb-3">
-            Warning: export contains trips serving North and South Station.
-          </div>
-
-          <div :if={@one_of_north_south_stations == :neither} class="text-warning mb-3">
-            Warning: export does not contain trips serving North or South Station.
-          </div>
-
-          <div :if={not Enum.empty?(@missing_routes)} class="text-warning mb-3">
-            Warning: Not all northside or southside routes are present. Missing routes:
-            <ul>
-              <li :for={route_id <- @missing_routes}>{route_id}</li>
-            </ul>
-          </div>
-
-          <div :if={not Enum.empty?(@invalid_routes)} class="text-warning mb-3">
-            Warning: multiple routes not north or southside:
-            <ul>
-              <li :for={route_id <- @invalid_routes}>{route_id}</li>
-            </ul>
-          </div>
-
-          <div :if={not Enum.empty?(@trips_missing_transfers)} class="text-warning mb-3">
-            Warning: some train trips that do not serve North Station, South Station, or Foxboro lack transfers.
-            <ul>
-              <li :for={trip_id <- @trips_missing_transfers}>{trip_id}</li>
-            </ul>
-          </div>
+          <.export_alert :for={error <- @errors} error={error} myself={@myself} />
 
           <div class="row">
             <div class="col-lg-4">
@@ -311,22 +256,97 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
     """
   end
 
+  defp export_alert(%{error: {type, {key, {_, metadata} = error_contents}}} = assigns) do
+    assigns =
+      assigns
+      |> assign(
+        type: type,
+        key: key,
+        message: translate_error(error_contents),
+        # If there is a metadata element with the same name as the alert `key`
+        # try to use that as enumerable metadata to report alongside the message
+        enum_metadata:
+          if(is_atom(key) and Enumerable.impl_for(metadata[key]) != nil,
+            do: metadata[key],
+            else: nil
+          )
+      )
+      |> Map.drop([:error])
+
+    ~H"""
+    <ArrowWeb.DisruptionComponents.upload_alert type={@type}>
+      <.alert_message
+        key={@key}
+        message={@message}
+        enum_metadata={@enum_metadata}
+        myself={@myself}
+      />
+    </ArrowWeb.DisruptionComponents.upload_alert>
+    """
+  end
+
+  defp alert_message(%{key: :stop_id_not_in_gtfs} = assigns) do
+    ~H"""
+    Some stops are not present in GTFS!
+    <.button
+      type="button"
+      class="alert-info d-block"
+      phx-click="download_invalid_export_stops"
+      phx-target={@myself}
+    >
+      Download list of invalid stops
+    </.button>
+    """
+  end
+
+  defp alert_message(%{key: :invalid_stop_times} = assigns) do
+    ~H"""
+    Some stop times are out of order!
+    <.button
+      type="button"
+      class="alert-info d-block"
+      phx-click="download_invalid_stop_times"
+      phx-target={@myself}
+    >
+      Download list of invalid stop times
+    </.button>
+    """
+  end
+
+  defp alert_message(%{enum_metadata: enum_metadata} = assigns) when not is_nil(enum_metadata) do
+    ~H"""
+    {@message}
+    <ul>
+      <li :for={element <- @enum_metadata}>{element}</li>
+    </ul>
+    """
+  end
+
+  defp alert_message(assigns) do
+    assigns =
+      assign_new(assigns, :title, fn ->
+        if(is_binary(assigns[:key]), do: assigns[:key], else: nil)
+      end)
+
+    ~H"""
+    <%= if not is_nil(@title) do %>
+      <span :if={not is_nil(@title)} class="font-bold">{@title}</span>
+      <br />
+    <% end %>
+
+    {@message}
+    """
+  end
+
   @impl true
   def update(%{export: %{id: nil}} = assigns, socket) do
     socket =
       socket
       |> assign(assigns)
-      |> assign(:error, nil)
+      |> assign(:errors, [])
       |> assign(:show_upload_form, true)
       |> assign(:show_service_import_form, false)
       |> assign(:form, nil)
-      |> assign(:invalid_export_stops, nil)
-      |> assign(:invalid_stop_times, nil)
-      |> assign(:one_of_north_south_stations, :ok)
-      |> assign(:missing_routes, nil)
-      |> assign(:invalid_routes, nil)
-      |> assign(:trips_missing_transfers, nil)
-      |> assign(:existing_service_ids, nil)
       |> allow_upload(:trainsformer_export,
         accept: ~w(.zip),
         progress: &handle_progress/3,
@@ -345,16 +365,10 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
     socket =
       socket
       |> assign(assigns)
+      |> assign(:errors, [])
       |> assign(:show_upload_form, false)
       |> assign(:show_service_import_form, true)
       |> assign(:form, form)
-      |> assign(:invalid_export_stops, nil)
-      |> assign(:invalid_stop_times, nil)
-      |> assign(:one_of_north_south_stations, :ok)
-      |> assign(:missing_routes, [])
-      |> assign(:invalid_routes, [])
-      |> assign(:trips_missing_transfers, [])
-      |> assign(:error, nil)
       |> assign(:uploaded_file_name, nil)
       |> assign(:uploaded_file_routes, nil)
       |> allow_upload(:trainsformer_export,
@@ -392,8 +406,14 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
   def handle_event(
         "download_invalid_export_stops",
         _params,
-        %{assigns: %{invalid_export_stops: stops}} = socket
+        %{assigns: %{errors: errors}} = socket
       ) do
+    stops =
+      Enum.find_value(errors, fn
+        {_, {:stop_id_not_in_gtfs, {_, opts}}} -> opts[:stop_id_not_in_gtfs]
+        _ -> false
+      end)
+
     socket =
       send_download(
         socket,
@@ -408,8 +428,14 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
   def handle_event(
         "download_invalid_stop_times",
         _params,
-        %{assigns: %{invalid_stop_times: stop_times}} = socket
+        %{assigns: %{errors: errors}} = socket
       ) do
+    stop_times =
+      Enum.find_value(errors, fn
+        {_, {:invalid_stop_times, {_, opts}}} -> opts[:invalid_stop_times]
+        _ -> false
+      end)
+
     stop_times_lines =
       Enum.map(stop_times, fn stop_time ->
         "trip_id: #{stop_time[:trip_id]}, stop_id: #{stop_time[:stop_id]}, stop_sequence: #{stop_time[:stop_sequence]}, arrival_time: #{stop_time[:arrival_time]}, departure_time: #{stop_time[:departure_time]}"
@@ -489,7 +515,7 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
          %UploadEntry{client_name: client_name} = entry,
          socket
        ) do
-    socket = socket |> clear_flash() |> assign(error: nil)
+    socket = socket |> clear_flash() |> assign(errors: [])
 
     case consume_uploaded_entry(
            socket,
@@ -514,25 +540,13 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
            show_service_import_form: true,
            uploaded_file_name: client_name,
            uploaded_file_data: export_data.zip_binary,
-           one_of_north_south_stations: export_data.one_of_north_south_stations,
-           missing_routes: export_data.missing_routes,
-           invalid_routes: export_data.invalid_routes,
-           trips_missing_transfers: export_data.trips_missing_transfers,
            uploaded_file_routes: export_data.routes,
-           uploaded_file_services: export_data.services
+           uploaded_file_services: export_data.services,
+           errors: export_data.warnings
          )}
 
-      {:error, {:invalid_export_stops, stops}} ->
-        {:noreply, assign(socket, invalid_export_stops: stops)}
-
-      {:error, {:invalid_stop_times, stop_times}} ->
-        {:noreply, assign(socket, invalid_stop_times: stop_times)}
-
-      {:error, {:existing_service_id, existing_ids}} ->
-        {:noreply, assign(socket, existing_service_ids: existing_ids)}
-
-      {:error, error} ->
-        {:noreply, assign(socket, error: error)}
+      {:error, errors_and_warnings} ->
+        {:noreply, assign(socket, errors: errors_and_warnings)}
     end
   end
 
@@ -590,7 +604,12 @@ defmodule ArrowWeb.EditTrainsformerExportForm do
         {:noreply, assign(socket, form: to_form(changeset))}
 
       {:error, _} ->
-        {:noreply, assign(socket, error: "Failed to upload export to S3")}
+        {:noreply,
+         socket
+         |> update(
+           :errors,
+           &[{:error, {:s3_upload_failed, {"Failed to upload export to S3", []}}} | &1]
+         )}
     end
   end
 end
diff --git a/test/arrow/trainsformer/export_upload_test.exs b/test/arrow/trainsformer/export_upload_test.exs
index a0179cf36..0f0403a42 100644
--- a/test/arrow/trainsformer/export_upload_test.exs
+++ b/test/arrow/trainsformer/export_upload_test.exs
@@ -60,7 +60,14 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
       data =
         ExportUpload.extract_data_from_upload(%{path: "#{@export_dir}/#{export}"})
 
-      assert {:ok, {:error, {:existing_service_id, ["SPRING2025-SOUTHSS-Weekend-66"]}}} = data
+      assert {:ok,
+              {:error,
+               [
+                 {:error,
+                  {:existing_service_ids,
+                   {"Export contains previously used service_id's",
+                    [existing_service_ids: ["SPRING2025-SOUTHSS-Weekend-66"]]}}}
+               ]}} = data
     end
 
     @tag export: "invalid_csv.zip"
@@ -69,10 +76,15 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
         ExportUpload.extract_data_from_upload(%{path: "#{@export_dir}/#{export}"})
 
       assert {:ok,
-              [
-                {:error, "SPRING2025-SOUTHSS-Weekend-66/stop_times.txt",
-                 "** (CSV.RowLengthError) Row 2 has length 9 instead of expected length 11\n\nYou are seeing this error because :validate_row_length has been set to true\n"}
-              ]} = data
+              {:error,
+               [
+                 {:error,
+                  {"SPRING2025-SOUTHSS-Weekend-66/stop_times.txt",
+                   {
+                     "** (CSV.RowLengthError) Row 2 has length 9 instead of expected length 11\n\nYou are seeing this error because :validate_row_length has been set to true\n",
+                     []
+                   }}}
+               ]}} = data
     end
   end
 
@@ -108,7 +120,7 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
     end
   end
 
-  describe "validate_stop_times_in_gtfs/4" do
+  describe "validate_stop_ids_in_gtfs/4" do
     defmodule FakeRepo do
       def all(_) do
         ["WR-0329-02", "WR-0325-02", "WR-0264-02"]
@@ -116,73 +128,33 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
     end
 
     test "returns ok if all stops in gtfs" do
-      stop_times_with_stops_in_repo = [
-        %{
-          arrival_time: "10:26:00",
-          departure_time: "10:26:00",
-          stop_id: "WR-0329-02",
-          stop_sequence: "140",
-          timepoint: "1",
-          trip_id: "Base-772221-5208"
-        },
-        %{
-          arrival_time: "10:31:00",
-          departure_time: "10:31:00",
-          stop_id: "WR-0325-02",
-          stop_sequence: "150",
-          trip_id: "Base-772221-5208"
-        },
-        %{
-          arrival_time: "10:31:00",
-          departure_time: "10:31:00",
-          stop_id: "WR-0264-02",
-          stop_sequence: "150",
-          trip_id: "Base-772221-5208"
-        }
+      stop_ids = [
+        "WR-0329-02",
+        "WR-0325-02",
+        "WR-0264-02"
       ]
 
-      assert {:ok, ["WR-0329-02", "WR-0325-02", "WR-0264-02"]} =
-               ExportUpload.validate_stop_times_in_gtfs(
-                 stop_times_with_stops_in_repo,
+      assert :ok =
+               ExportUpload.validate_stop_ids_in_gtfs(
+                 stop_ids,
                  FakeRepo
                )
     end
 
     test "returns missing stop if some stops missing from GTFS" do
-      stop_times_without_stops_in_repo = [
-        %{
-          arrival_time: "10:26:00",
-          departure_time: "10:26:00",
-          stop_id: "morket-borket",
-          stop_sequence: "140",
-          trip_id: "ReadWKNDHeadsigns-754204-5530"
-        },
-        %{
-          arrival_time: "10:31:00",
-          departure_time: "10:31:00",
-          stop_id: "mcdongals",
-          stop_sequence: "150",
-          trip_id: "ReadWKNDHeadsigns-754204-5530"
-        },
-        %{
-          arrival_time: "10:31:00",
-          departure_time: "10:31:00",
-          stop_id: "sbubby",
-          stop_sequence: "150",
-          trip_id: "ReadWKNDHeadsigns-754204-5530"
-        },
-        %{
-          arrival_time: "10:31:00",
-          departure_time: "10:31:00",
-          stop_id: "WR-0329-02",
-          stop_sequence: "150",
-          trip_id: "ReadWKNDHeadsigns-754204-5530"
-        }
+      stop_ids = [
+        "morket-borket",
+        "mcdongals",
+        "sbubby",
+        "WR-0329-02"
       ]
 
-      assert {:error, {:invalid_export_stops, ["morket-borket", "mcdongals", "sbubby"]}} =
-               ExportUpload.validate_stop_times_in_gtfs(
-                 stop_times_without_stops_in_repo,
+      assert {:error,
+              {:stop_id_not_in_gtfs,
+               {"Export has stops not present in GTFS",
+                [stop_id_not_in_gtfs: ["morket-borket", "mcdongals", "sbubby"]]}}} =
+               ExportUpload.validate_stop_ids_in_gtfs(
+                 stop_ids,
                  FakeRepo
                )
     end
@@ -244,22 +216,25 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
 
       assert {:error,
               {:invalid_stop_times,
-               [
-                 %{
-                   stop_id: "NEC-2287",
-                   stop_sequence: "10",
-                   arrival_time: "10:30:00",
-                   departure_time: "10:30:00",
-                   trip_id: "October26November2-781218-9733"
-                 },
-                 %{
-                   stop_id: "NEC-2276-01",
-                   stop_sequence: "20",
-                   arrival_time: "11:01:00",
-                   departure_time: "11:00:00",
-                   trip_id: "October26November2-781218-9733"
-                 }
-               ]}} =
+               {"Export contains trips with out-of-order stop times",
+                [
+                  invalid_stop_times: [
+                    %{
+                      stop_id: "NEC-2287",
+                      stop_sequence: "10",
+                      trip_id: "October26November2-781218-9733",
+                      arrival_time: "10:30:00",
+                      departure_time: "10:30:00"
+                    },
+                    %{
+                      stop_id: "NEC-2276-01",
+                      stop_sequence: "20",
+                      trip_id: "October26November2-781218-9733",
+                      arrival_time: "11:01:00",
+                      departure_time: "11:00:00"
+                    }
+                  ]
+                ]}}} =
                ExportUpload.validate_stop_order(invalid_stop_times)
     end
   end
@@ -282,7 +257,8 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
     end
 
     test "returns error if North and South Stations are both served" do
-      assert :both =
+      assert {:warning,
+              {:invalid_sides, {"Export contains trips serving North and South Station", []}}} =
                ExportUpload.validate_one_of_north_south_stations([
                  "BNT-0000",
                  "WR-0045-S",
@@ -292,7 +268,9 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
     end
 
     test "returns error if neither North nor South Station is served" do
-      assert :neither =
+      assert {:warning,
+              {:invalid_sides,
+               {"Export does not contain trips serving North or South Station", _}}} =
                ExportUpload.validate_one_of_north_south_stations([
                  "WR-0045-S",
                  "WR-0053-S"
@@ -302,7 +280,7 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
 
   describe "validate_one_or_all_routes_from_one_side/3" do
     test "returns empty error route lists if all Northside routes have a trip" do
-      assert {[], []} =
+      assert :ok =
                ExportUpload.validate_one_or_all_routes_from_one_side([
                  %{
                    route_id: "CR-Newburyport",
@@ -328,7 +306,7 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
     end
 
     test "returns empty error route lists if exactly one Northside route has a trip" do
-      assert {[], []} =
+      assert :ok =
                ExportUpload.validate_one_or_all_routes_from_one_side([
                  %{
                    route_id: "CR-Newburyport",
@@ -354,7 +332,16 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
     end
 
     test "returns missing routes if more than one but not all Northside routes have a trip" do
-      assert {["CR-Fitchburg", "CR-Lowell"], []} =
+      assert {
+               :warning,
+               {
+                 :missing_routes,
+                 {
+                   "Not all northside routes are present",
+                   [missing_routes: ["CR-Fitchburg", "CR-Lowell"]]
+                 }
+               }
+             } =
                ExportUpload.validate_one_or_all_routes_from_one_side([
                  %{
                    route_id: "CR-Newburyport",
@@ -369,8 +356,42 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
                ])
     end
 
+    test "returns missing routes if more than one but not all Southside routes have a trip" do
+      assert {
+               :warning,
+               {
+                 :missing_routes,
+                 {
+                   "Not all southside routes are present",
+                   [
+                     missing_routes: [
+                       "CR-Greenbush",
+                       "CR-Kingston",
+                       "CR-Needham",
+                       "CR-NewBedford",
+                       "CR-Providence",
+                       "CR-Worcester"
+                     ]
+                   ]
+                 }
+               }
+             } =
+               ExportUpload.validate_one_or_all_routes_from_one_side([
+                 %{
+                   route_id: "CR-Fairmount",
+                   service_id: "FALL 2025-SOUTHWKD-Weekday-11A",
+                   trip_id: "Weekday-789267-102"
+                 },
+                 %{
+                   route_id: "CR-Franklin",
+                   service_id: "FALL 2025-SOUTHWKD-Weekday-11A",
+                   trip_id: "Weekday-789267-202"
+                 }
+               ])
+    end
+
     test "returns empty error route lists for a single route not in either side's required list" do
-      assert {[], []} =
+      assert :ok =
                ExportUpload.validate_one_or_all_routes_from_one_side([
                  %{
                    route_id: "CR-Foxboro",
@@ -386,7 +407,10 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
     end
 
     test "returns invalid routes for multiple routes not in either side's required list" do
-      assert {[], ["CR-Foxboro", "CR-Nowhere"]} =
+      assert {:warning,
+              {:invalid_routes,
+               {"Multiple routes not north or southside",
+                [invalid_routes: ["CR-Foxboro", "CR-Nowhere"]]}}} =
                ExportUpload.validate_one_or_all_routes_from_one_side([
                  %{
                    route_id: "CR-Foxboro",
@@ -466,7 +490,12 @@ defmodule Arrow.Trainsformer.ExportUploadTest do
     test "returns an error if any transfers are missing" do
       expected_trips_with_missing_transfers = MapSet.new(["5678"])
 
-      assert {:error, {:trips_missing_transfers, ^expected_trips_with_missing_transfers}} =
+      assert {:warning,
+              {:trips_missing_transfers,
+               {
+                 "Some train trips that do not serve North Station, South Station, or Foxboro lack transfers",
+                 [trips_missing_transfers: ^expected_trips_with_missing_transfers]
+               }}} =
                ExportUpload.validate_transfers(
                  [],
                  [
diff --git a/test/integration/disruptionsv2/trainsformer_export_section_test.exs b/test/integration/disruptionsv2/trainsformer_export_section_test.exs
index 48c9e4ac1..ba1f8922a 100644
--- a/test/integration/disruptionsv2/trainsformer_export_section_test.exs
+++ b/test/integration/disruptionsv2/trainsformer_export_section_test.exs
@@ -88,6 +88,19 @@ defmodule Arrow.Integration.Disruptionsv2.TrainsformerExportSectionTest do
     |> assert_text("Invalid zip file")
   end
 
+  feature "reports invalid CSV errors", %{session: session} do
+    disruption = disruption_v2_fixture(%{mode: :commuter_rail})
+
+    session
+    |> visit("/disruptions/#{disruption.id}")
+    |> click(text("Upload Trainsformer export"))
+    |> assert_text("Upload Trainsformer .zip")
+    |> attach_file(file_field("trainsformer_export", visible: false),
+      path: "test/support/fixtures/trainsformer/invalid_csv.zip"
+    )
+    |> assert_text("Row 2 has length 9 instead of expected length 11")
+  end
+
   feature "shows error for invalid gtfs stops in trainsformer export", %{session: session} do
     disruption = disruption_v2_fixture(%{mode: :commuter_rail})
 
@@ -123,7 +136,7 @@ defmodule Arrow.Integration.Disruptionsv2.TrainsformerExportSectionTest do
     |> attach_file(file_field("trainsformer_export", visible: false),
       path: "test/support/fixtures/trainsformer/valid_export.zip"
     )
-    |> assert_text("Export contains previously used service ids")
+    |> assert_text("Export contains previously used service_id's")
   end
 
   feature "shows error for invalid stop order in trainsformer export", %{session: session} do
@@ -151,7 +164,7 @@ defmodule Arrow.Integration.Disruptionsv2.TrainsformerExportSectionTest do
     |> attach_file(file_field("trainsformer_export", visible: false),
       path: "test/support/fixtures/trainsformer/invalid_export_north_and_south_station.zip"
     )
-    |> assert_text("Warning: export contains trips serving North and South Station.")
+    |> assert_text("Export contains trips serving North and South Station")
   end
 
   feature "shows warning for trainsformer export containing neither North nor South Station", %{
@@ -167,7 +180,7 @@ defmodule Arrow.Integration.Disruptionsv2.TrainsformerExportSectionTest do
       path:
         "test/support/fixtures/trainsformer/invalid_export_neither_north_nor_south_station.zip"
     )
-    |> assert_text("Warning: export does not contain trips serving North or South Station.")
+    |> assert_text("Export does not contain trips serving North or South Station")
   end
 
   feature "shows warning for trainsformer export containing some but not all routes for a side",
@@ -183,7 +196,8 @@ defmodule Arrow.Integration.Disruptionsv2.TrainsformerExportSectionTest do
     |> attach_file(file_field("trainsformer_export", visible: false),
       path: "test/support/fixtures/trainsformer/invalid_export_missing_south_side_routes.zip"
     )
-    |> assert_text("Warning: Not all northside or southside routes are present. Missing routes:")
+    |> assert_text("Not all southside routes are present")
+    |> assert_text("CR-Greenbush")
   end
 
   feature "shows warning for trainsformer export containing multiple routes that are neither north nor southside",
@@ -199,7 +213,9 @@ defmodule Arrow.Integration.Disruptionsv2.TrainsformerExportSectionTest do
     |> attach_file(file_field("trainsformer_export", visible: false),
       path: "test/support/fixtures/trainsformer/invalid_export_multiple_no_side_routes.zip"
     )
-    |> assert_text("Warning: multiple routes not north or southside:")
+    |> assert_text("Multiple routes not north or southside")
+    |> assert_text("CR-Nowhere")
+    |> assert_text("CR-Foxboro")
   end
 
   feature "shows warning for missing transfers in trainsformer export", %{session: session} do
@@ -213,8 +229,9 @@ defmodule Arrow.Integration.Disruptionsv2.TrainsformerExportSectionTest do
       path: "test/support/fixtures/trainsformer/invalid_export_missing_transfers.zip"
     )
     |> assert_text(
-      "Warning: some train trips that do not serve North Station, South Station, or Foxboro lack transfers."
+      "Some train trips that do not serve North Station, South Station, or Foxboro lack transfers"
     )
+    |> assert_text("Dec14PatsGame-781225-9731")
   end
 
   feature "can cancel uploading a Trainsformer export", %{session: session} do