diff --git a/assets/css/app.css b/assets/css/app.css
index 0635f7e4138..8f00beb6267 100644
--- a/assets/css/app.css
+++ b/assets/css/app.css
@@ -140,3 +140,7 @@ https://tailwindcss.com/docs/utility-first
   -ms-overflow-style: none; /* IE and Edge */
   scrollbar-width: none; /* Firefox */
 }
+
+.search-result em {
+  @apply not-italic bg-yellow-50;
+}
diff --git a/assets/src/hooks/scroller.ts b/assets/src/hooks/scroller.ts
index 1ad57576807..36944cb4642 100644
--- a/assets/src/hooks/scroller.ts
+++ b/assets/src/hooks/scroller.ts
@@ -6,7 +6,7 @@ export const Scroller = {
   // It is triggered from the backend as follows:
   //
   //    def handle_event(..., socket) do
-  //      {:no_reply, push_event(socket, "scroll-y-to-target", %{id: "element-id", offset: 50, scroll: true, scroll_delay: 500})
+  //      {:no_reply, push_event(socket, "scroll-y-to-target", %{id: "element-id", offset: 50, scroll: true, scroll_delay: 500})}
   //    end
   //
   // Expects the id of the element to scroll to, an optional offset
diff --git a/lib/oli/analytics/by_activity.ex b/lib/oli/analytics/by_activity.ex
index 711e3af5cbc..28d0557c82c 100644
--- a/lib/oli/analytics/by_activity.ex
+++ b/lib/oli/analytics/by_activity.ex
@@ -1,7 +1,8 @@
 defmodule Oli.Analytics.ByActivity do
   import Ecto.Query, warn: false
-  alias Oli.Delivery.Sections.SectionResource
+  alias Oli.Publishing.DeliveryResolver
   alias Oli.Repo
+  alias Oli.Resources.ResourceType
   alias Oli.Analytics.Common
   alias Oli.Publishing
 
@@ -11,17 +12,15 @@ defmodule Oli.Analytics.ByActivity do
   def query_against_project_slug(project_slug, filtered_sections) do
     project_slug
     |> get_base_query(filtered_sections)
-    |> get_query_with_join_filter(filtered_sections)
     |> Repo.all()
   end
 
   defp get_base_query(project_slug, filtered_sections) do
     subquery =
       if filtered_sections != [] do
-        Publishing.query_unpublished_revisions_by_type_and_section(
-          project_slug,
-          "activity",
-          filtered_sections
+        DeliveryResolver.revisions_filter_by_section_ids(
+          filtered_sections,
+          ResourceType.id_for_activity()
         )
       else
         Publishing.query_unpublished_revisions_by_type(
@@ -40,14 +39,7 @@ defmodule Oli.Analytics.ByActivity do
         number_of_attempts: analytics.number_of_attempts,
         relative_difficulty: analytics.relative_difficulty
       },
-      preload: [:resource_type]
-  end
-
-  defp get_query_with_join_filter(query, filter_list) do
-    from activity in query,
-      join: resource in assoc(activity, :resource),
-      left_join: section_resource in SectionResource,
-      on: resource.id == section_resource.resource_id,
-      where: section_resource.section_id in ^filter_list
+      preload: [:resource_type],
+      distinct: [activity]
   end
 end
diff --git a/lib/oli/analytics/by_objective.ex b/lib/oli/analytics/by_objective.ex
index 369b80d4da5..256ac807445 100644
--- a/lib/oli/analytics/by_objective.ex
+++ b/lib/oli/analytics/by_objective.ex
@@ -1,8 +1,8 @@
 defmodule Oli.Analytics.ByObjective do
   import Ecto.Query, warn: false
+  alias Oli.Publishing.DeliveryResolver
   alias Oli.Delivery.Snapshots.Snapshot
-  alias Oli.Delivery.Sections.SectionResource
-
+  alias Oli.Resources.ResourceType
   alias Oli.Repo
   alias Oli.Analytics.Common
   alias Oli.Publishing
@@ -14,17 +14,15 @@ defmodule Oli.Analytics.ByObjective do
   def query_against_project_slug(project_slug, filtered_sections) do
     project_slug
     |> get_base_query(get_activity_objectives(project_slug), filtered_sections)
-    |> get_query_with_join_filter(filtered_sections)
     |> Repo.all()
   end
 
   defp get_base_query(project_slug, activity_objectives, filtered_sections) do
     subquery =
       if filtered_sections != [] do
-        Publishing.query_unpublished_revisions_by_type_and_section(
-          project_slug,
-          "objective",
-          filtered_sections
+        DeliveryResolver.revisions_filter_by_section_ids(
+          filtered_sections,
+          ResourceType.id_for_objective()
         )
       else
         Publishing.query_unpublished_revisions_by_type(
@@ -50,14 +48,6 @@ defmodule Oli.Analytics.ByObjective do
     )
   end
 
-  defp get_query_with_join_filter(query, filter) do
-    from objective in query,
-      join: resource in assoc(objective, :resource),
-      left_join: section_resource in SectionResource,
-      on: resource.id == section_resource.resource_id,
-      where: section_resource.section_id in ^filter
-  end
-
   defp get_activity_objectives(project_slug) do
     from(project in Project,
       where: project.slug == ^project_slug,
diff --git a/lib/oli/analytics/by_page.ex b/lib/oli/analytics/by_page.ex
index 1912ce0e97a..18ffcace7cf 100644
--- a/lib/oli/analytics/by_page.ex
+++ b/lib/oli/analytics/by_page.ex
@@ -1,10 +1,11 @@
 defmodule Oli.Analytics.ByPage do
   import Ecto.Query, warn: false
-  alias Oli.Delivery.Sections.SectionResource
+  alias Oli.Publishing.DeliveryResolver
   alias Oli.Delivery.Snapshots.Snapshot
   alias Oli.Repo
   alias Oli.Analytics.Common
   alias Oli.Publishing
+  alias Oli.Resources.ResourceType
   alias Oli.Authoring.Course.Project
 
   def query_against_project_slug(project_slug, []),
@@ -15,25 +16,15 @@ defmodule Oli.Analytics.ByPage do
   def query_against_project_slug(project_slug, filtered_sections) do
     project_slug
     |> get_base_query(get_activity_pages(project_slug), filtered_sections)
-    |> get_query_with_join_filter(filtered_sections)
     |> Repo.all()
   end
 
-  defp get_query_with_join_filter(query, filter_list) do
-    from page in query,
-      join: resource in assoc(page, :resource),
-      left_join: section_resource in SectionResource,
-      on: resource.id == section_resource.resource_id,
-      where: section_resource.section_id in ^filter_list
-  end
-
   defp get_base_query(project_slug, activity_pages, filtered_sections) do
     subquery =
       if filtered_sections != [] do
-        Publishing.query_unpublished_revisions_by_type_and_section(
-          project_slug,
-          "page",
-          filtered_sections
+        DeliveryResolver.revisions_filter_by_section_ids(
+          filtered_sections,
+          ResourceType.id_for_page()
         )
       else
         Publishing.query_unpublished_revisions_by_type(
@@ -44,10 +35,9 @@ defmodule Oli.Analytics.ByPage do
 
     subquery_activity =
       if filtered_sections != [] do
-        Publishing.query_unpublished_revisions_by_type_and_section(
-          project_slug,
-          "activity",
-          filtered_sections
+        DeliveryResolver.revisions_filter_by_section_ids(
+          filtered_sections,
+          ResourceType.id_for_page()
         )
       else
         Publishing.query_unpublished_revisions_by_type(
@@ -72,7 +62,8 @@ defmodule Oli.Analytics.ByPage do
         number_of_attempts: analytics.number_of_attempts,
         relative_difficulty: analytics.relative_difficulty
       },
-      preload: [:resource_type]
+      preload: [:resource_type],
+      distinct: [activity]
     )
   end
 
diff --git a/lib/oli/publishing/delivery_resolver.ex b/lib/oli/publishing/delivery_resolver.ex
index 1d91c075414..c2b575626c9 100644
--- a/lib/oli/publishing/delivery_resolver.ex
+++ b/lib/oli/publishing/delivery_resolver.ex
@@ -263,6 +263,24 @@ defmodule Oli.Publishing.DeliveryResolver do
     |> emit([:oli, :resolvers, :delivery], :duration)
   end
 
+  def revisions_filter_by_section_ids(section_ids, resource_type_id) do
+    from(sr in SectionResource,
+      join: s in Section,
+      on: s.id == sr.section_id,
+      where: s.id in ^section_ids,
+      join: spp in SectionsProjectsPublications,
+      on: s.id == spp.section_id,
+      where: sr.project_id == spp.project_id,
+      join: pr in PublishedResource,
+      on: pr.publication_id == spp.publication_id,
+      where: pr.resource_id == sr.resource_id,
+      join: rev in Revision,
+      on: rev.id == pr.revision_id,
+      where: rev.resource_type_id == ^resource_type_id and rev.deleted == false,
+      select: rev
+    )
+  end
+
   @impl Resolver
   def revisions_of_type(section_slug, resource_type_id) do
     fn ->
diff --git a/lib/oli/resources/collaboration.ex b/lib/oli/resources/collaboration.ex
index 8613c2a80c1..ee570f32f62 100644
--- a/lib/oli/resources/collaboration.ex
+++ b/lib/oli/resources/collaboration.ex
@@ -1118,10 +1118,15 @@ defmodule Oli.Resources.Collaboration do
         point_block_id \\ nil
       ) do
     filter_by_point_block_id =
-      if is_nil(point_block_id) do
-        dynamic([p], is_nil(p.annotated_block_id))
-      else
-        dynamic([p], p.annotated_block_id == ^point_block_id)
+      case point_block_id do
+        nil ->
+          true
+
+        :page ->
+          dynamic([p], is_nil(p.annotated_block_id))
+
+        point_block_id ->
+          dynamic([p], p.annotated_block_id == ^point_block_id)
       end
 
     Repo.all(
@@ -1152,6 +1157,126 @@ defmodule Oli.Resources.Collaboration do
     |> summarize_reactions(user_id)
   end
 
+  @doc """
+  Returns the list of posts that a user can see which match a given search term.
+
+  ## Examples
+
+      iex> search_posts_for_user_in_point_block(1, 1, 1, :private, "1", "search term"))
+      [%Post{status: :archived}, ...]
+
+      iex> search_posts_for_user_in_point_block(2, 2, 2, :private, "2", "search term")
+      []
+  """
+  def search_posts_for_user_in_point_block(
+        section_id,
+        resource_id,
+        user_id,
+        visibility,
+        point_block_id,
+        search_term
+      ) do
+    filter_by_point_block_id =
+      case point_block_id do
+        nil ->
+          true
+
+        :page ->
+          dynamic([p], is_nil(p.annotated_block_id))
+
+        point_block_id ->
+          dynamic([p], p.annotated_block_id == ^point_block_id)
+      end
+
+    Repo.all(
+      from(
+        post in Post,
+        left_join: replies in subquery(replies_subquery()),
+        on: replies.thread_root_id == post.id,
+        left_join: read_replies in subquery(read_replies_subquery(user_id)),
+        on: read_replies.thread_root_id == post.id,
+        left_join: parent_post in assoc(post, :parent_post),
+        left_join: reactions in assoc(post, :reactions),
+        left_join: user in assoc(post, :user),
+        where:
+          post.section_id == ^section_id and post.resource_id == ^resource_id and
+            (post.status in [:approved, :archived] or
+               (post.status == :submitted and post.user_id == ^user_id)),
+        where: ^filter_by_point_block_id,
+        where:
+          fragment(
+            "to_tsvector('english', ?) @@ websearch_to_tsquery('english', ?)",
+            post.content,
+            ^search_term
+          ),
+        where: post.visibility == ^visibility,
+        order_by: [desc: :inserted_at],
+        preload: [
+          user: user,
+          reactions: reactions,
+          parent_post: parent_post
+        ],
+        select: %{
+          post
+          | replies_count: coalesce(replies.count, 0),
+            read_replies_count: coalesce(read_replies.count, 0),
+            headline:
+              fragment(
+                """
+                ts_headline(
+                  'english',
+                  ?,
+                  websearch_to_tsquery(?),
+                  'StartSel=<em>,StopSel=</em>,MinWords=25,MaxWords=75'
+                )
+                """,
+                post.content,
+                ^search_term
+              )
+        }
+      )
+    )
+    |> summarize_reactions(user_id)
+    |> group_by_parent_post()
+  end
+
+  defp group_by_parent_post(posts) do
+    by_parent_id = Enum.group_by(posts, &Map.get(&1, :parent_post_id))
+
+    # we want to preserve the order of the posts returned by the query
+    # so we need to reduce over the list of posts and place each post in the correct
+    # parent post's replies list
+    {results, _} =
+      posts
+      |> Enum.reduce({[], by_parent_id}, fn post, {acc, by_parent_id} ->
+        parent_post_id = post.parent_post_id
+
+        case parent_post_id do
+          nil ->
+            # this is a top-level post
+            {[post | acc], by_parent_id}
+
+          _ ->
+            # this is a reply post, so place parent post with it's replies we already groups
+            # in the list if it's not there yet
+            case by_parent_id[parent_post_id] do
+              nil ->
+                # parent post is already in the list, so skip it
+                {acc, by_parent_id}
+
+              replies ->
+                # parent post is not in the list yet, so add it and drop it from the by_parent_id map
+                # to track which parent posts we already processed
+                {[Map.put(post.parent_post, :replies, replies) | acc],
+                 Map.delete(by_parent_id, parent_post_id)}
+            end
+        end
+      end)
+
+    results
+    |> Enum.reverse()
+  end
+
   defp summarize_reactions(posts, current_user_id) do
     Enum.map(posts, fn post ->
       %{
diff --git a/lib/oli/resources/collaboration/post.ex b/lib/oli/resources/collaboration/post.ex
index d187c099fa4..0b505de607e 100644
--- a/lib/oli/resources/collaboration/post.ex
+++ b/lib/oli/resources/collaboration/post.ex
@@ -39,6 +39,8 @@ defmodule Oli.Resources.Collaboration.Post do
     has_many :reactions, Oli.Resources.Collaboration.UserReactionPost
 
     field :reaction_summaries, :map, virtual: true
+    field :headline, :string, virtual: true
+    field :replies, :any, virtual: true
 
     timestamps(type: :utc_datetime)
   end
diff --git a/lib/oli_web/components/delivery/instructor_dashboard.ex b/lib/oli_web/components/delivery/instructor_dashboard.ex
index b08ec108299..9e75fb3dab9 100644
--- a/lib/oli_web/components/delivery/instructor_dashboard.ex
+++ b/lib/oli_web/components/delivery/instructor_dashboard.ex
@@ -34,7 +34,9 @@ defmodule OliWeb.Components.Delivery.InstructorDashboard do
       <div class="relative flex-1 flex flex-col pt-4 pb-[60px]">
         <%= render_slot(@inner_block) %>
 
-        <%= Phoenix.View.render(OliWeb.LayoutView, "_delivery_footer.html", assigns) %>
+        <OliWeb.Components.Footer.delivery_footer license={
+          Map.get(assigns, :has_license) && assigns[:license]
+        } />
       </div>
     </div>
     """
@@ -273,7 +275,9 @@ defmodule OliWeb.Components.Delivery.InstructorDashboard do
 
   def footer(assigns) do
     ~H"""
-    <%= Phoenix.View.render(OliWeb.LayoutView, "_delivery_footer.html", assigns) %>
+    <OliWeb.Components.Footer.delivery_footer license={
+      Map.get(assigns, :has_license) && assigns[:license]
+    } />
     """
   end
 end
diff --git a/lib/oli_web/components/footer.ex b/lib/oli_web/components/footer.ex
new file mode 100644
index 00000000000..6932eea2ed8
--- /dev/null
+++ b/lib/oli_web/components/footer.ex
@@ -0,0 +1,118 @@
+defmodule OliWeb.Components.Footer do
+  use Phoenix.Component
+  use OliWeb, :verified_routes
+
+  def delivery_footer(assigns) do
+    ~H"""
+    <footer class={"#{if Map.get(assigns, :is_page), do: "", else: "absolute bottom-0 left-0 right-0"} pb-4 w-full md:container md:mx-auto lg:px-10 text-xs bg-delivery-footer dark:bg-delivery-footer-dark"}>
+      <div class="flex flex-col ">
+        <div class="flex flex-row gap-2">
+          <.cookie_preferences />
+          <.footer_part_1 />
+          <.footer_part_2 />
+        </div>
+        <%= if Map.get(assigns, :license) do %>
+          <%= OliWeb.LayoutView.render_license(@license) %>
+        <% end %>
+      </div>
+      <.retrieve_cookies />
+    </footer>
+    """
+  end
+
+  def global_footer(assigns) do
+    ~H"""
+    <footer class="absolute bottom-0 left-0 right-0 pb-4 w-full md:container md:mx-auto lg:px-10 text-xs bg-delivery-footer dark:bg-delivery-footer-dark">
+      <div class="flex flex-col w-full px-10">
+        <div class="flex flex-col sm:flex-row gap-2">
+          <.cookie_preferences />
+          <.footer_part_1 />
+          <.footer_part_2 />
+          <.version />
+        </div>
+      </div>
+      <.retrieve_cookies />
+    </footer>
+    """
+  end
+
+  defp footer_part_1(assigns) do
+    assigns =
+      assign(assigns,
+        footer_text: footer_text(),
+        footer_link_1_location: footer_link_1_location(),
+        footer_link_1_text: footer_link_1_text()
+      )
+
+    ~H"""
+    <div class="w-9/12 text-left sm:text-center">
+      <%= @footer_text %><a href={@footer_link_1_location} target="_blank"><%= @footer_link_1_text %></a>
+    </div>
+    """
+  end
+
+  defp footer_part_2(assigns) do
+    assigns =
+      assign(assigns,
+        footer_link_2_location: footer_link_2_location(),
+        footer_link_2_text: footer_link_2_text()
+      )
+
+    ~H"""
+    <div class="w-2/12 text-left sm:text-left">
+      <a href={@footer_link_2_location} target="_blank"><%= @footer_link_2_text %></a>
+    </div>
+    """
+  end
+
+  def version(assigns) do
+    assigns = assign(assigns, version: version(), sha: sha(), timestamp: timestamp())
+
+    ~H"""
+    <div class="text-left sm:text-right">
+      Version <%= @version %> (<%= @sha %>) <%= @timestamp %>
+    </div>
+    """
+  end
+
+  defp cookie_preferences(assigns) do
+    assigns = assign(assigns, privacy_policies_url: privacy_policies_url())
+
+    ~H"""
+    <div class="text-left w-3/12">
+      <a
+        href="javascript:;"
+        onclick={"OLI.selectCookiePreferences({privacyPoliciesUrl: '#{@privacy_policies_url}'})"}
+      >
+        Cookie Preferences
+      </a>
+    </div>
+    """
+  end
+
+  defp retrieve_cookies(assigns) do
+    assigns = assign(assigns, privacy_policies_url: privacy_policies_url())
+
+    ~H"""
+    <script>
+      OLI.onReady(() => OLI.retrieveCookies('<%= ~p"/consent/cookie" %>', {privacyPoliciesUrl: '<%= @privacy_policies_url %>'}));
+    </script>
+    """
+  end
+
+  defp footer(), do: Application.fetch_env!(:oli, :footer)
+  defp footer_text(), do: footer()[:text]
+  defp footer_link_1_location(), do: footer()[:link_1_location]
+  defp footer_link_1_text(), do: footer()[:link_1_text]
+  defp footer_link_2_location(), do: footer()[:link_2_location]
+  defp footer_link_2_text(), do: footer()[:link_2_text]
+
+  defp privacy_policies_url(), do: Application.fetch_env!(:oli, :privacy_policies)[:url]
+
+  defp timestamp(),
+    do: Application.fetch_env!(:oli, :build).date |> Timex.format!("%m/%d/%Y", :strftime)
+
+  defp version(), do: Application.fetch_env!(:oli, :build).version
+
+  defp sha(), do: Application.fetch_env!(:oli, :build).sha |> String.upcase()
+end
diff --git a/lib/oli_web/components/layouts/page.html.heex b/lib/oli_web/components/layouts/page.html.heex
index 8c3e0095756..3784d3a9d41 100644
--- a/lib/oli_web/components/layouts/page.html.heex
+++ b/lib/oli_web/components/layouts/page.html.heex
@@ -96,9 +96,11 @@
           resource_slug: @resource_slug,
           numbered_revisions: assigns[:numbered_revisions]
         ) %>
+        <OliWeb.Components.Footer.delivery_footer
+          license={Map.get(assigns, :has_license) && assigns[:license]}
+          is_page={true}
+        />
       </div>
-
-      <%= render(OliWeb.LayoutView, "_delivery_footer.html", assigns) %>
     </div>
   </main>
 </div>
diff --git a/lib/oli_web/controllers/delivery_controller.ex b/lib/oli_web/controllers/delivery_controller.ex
index 0279506bd15..77c86184c12 100644
--- a/lib/oli_web/controllers/delivery_controller.ex
+++ b/lib/oli_web/controllers/delivery_controller.ex
@@ -239,22 +239,29 @@ defmodule OliWeb.DeliveryController do
     |> render_create_and_link_form()
   end
 
+  @spec process_create_and_link_account_user(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def process_create_and_link_account_user(conn, %{"user" => user_params}) do
+    %{current_user: current_user} = conn.assigns
+
     conn
     |> use_pow_config(:author)
     |> Pow.Plug.create_user(user_params)
     |> case do
-      {:ok, user, conn} ->
+      {:ok, _user, conn} ->
         conn
-        |> PowPersistentSession.Plug.create(user)
         |> put_flash(
           :info,
           Pow.Phoenix.Controller.messages(conn, Pow.Phoenix.Messages).user_has_been_created(conn)
         )
-        |> redirect(
-          to:
-            Pow.Phoenix.Controller.routes(conn, Pow.Phoenix.Routes).after_registration_path(conn)
-        )
+
+        Pow.Phoenix.Controller.routes(conn, Pow.Phoenix.Routes).after_registration_path(conn)
+        conn = Pow.Plug.Session.do_delete(conn, get_pow_config(:author))
+
+        if current_user.independent_learner do
+          redirect(conn, to: Routes.live_path(conn, OliWeb.Delivery.OpenAndFreeIndex))
+        else
+          redirect(conn, to: Routes.delivery_path(conn, :index))
+        end
 
       {:error, changeset, conn} ->
         conn
diff --git a/lib/oli_web/live/delivery/open_and_free_index.ex b/lib/oli_web/live/delivery/open_and_free_index.ex
index 47c3c50b90b..7f61af42778 100644
--- a/lib/oli_web/live/delivery/open_and_free_index.ex
+++ b/lib/oli_web/live/delivery/open_and_free_index.ex
@@ -151,7 +151,9 @@ defmodule OliWeb.Delivery.OpenAndFreeIndex do
         </div>
       </div>
     </main>
-    <%= render(OliWeb.LayoutView, "_delivery_footer.html", assigns) %>
+    <OliWeb.Components.Footer.delivery_footer license={
+      Map.get(assigns, :has_license) && assigns[:license]
+    } />
     """
   end
 
diff --git a/lib/oli_web/live/delivery/student/lesson/annotations.ex b/lib/oli_web/live/delivery/student/lesson/annotations.ex
index 15603a6a371..cd8a6433417 100644
--- a/lib/oli_web/live/delivery/student/lesson/annotations.ex
+++ b/lib/oli_web/live/delivery/student/lesson/annotations.ex
@@ -7,8 +7,10 @@ defmodule OliWeb.Delivery.Student.Lesson.Annotations do
   attr :create_new_annotation, :boolean, default: false
   attr :annotations, :any, required: true
   attr :current_user, Oli.Accounts.User, required: true
+  attr :selected_point, :any, required: true
   attr :active_tab, :atom, default: :my_notes
-  attr :post_replies, :list, default: nil
+  attr :search_results, :any, default: nil
+  attr :search_term, :string, default: ""
 
   def panel(assigns) do
     ~H"""
@@ -27,36 +29,131 @@ defmodule OliWeb.Delivery.Student.Lesson.Annotations do
             <.users_icon class="mr-2" /> Class Notes
           </.tab>
         </.tab_group>
-        <.search_box class="mt-2" />
+        <.search_box class="mt-2" search_term={@search_term} />
         <hr class="m-6 border-b border-b-gray-200" />
-        <div class="flex-1 flex flex-col gap-3 overflow-y-auto pb-[80px]">
-          <.add_new_annotation_input
-            class="my-2"
-            active={@create_new_annotation}
-            disable_anonymous_option={@active_tab == :my_notes || is_guest(@current_user)}
-            save_label={if(@active_tab == :my_notes, do: "Save", else: "Post")}
-            placeholder={
-              if(@active_tab == :my_notes, do: "Add a new note...", else: "Post a new note...")
-            }
-          />
+        <%= case @search_results do %>
+          <% nil -> %>
+            <.annotations
+              annotations={@annotations}
+              current_user={@current_user}
+              create_new_annotation={@create_new_annotation}
+              selected_point={@selected_point}
+            />
+          <% _ -> %>
+            <.search_results
+              search_results={@search_results}
+              search_term={@search_term}
+              current_user={@current_user}
+              active_tab={@active_tab}
+            />
+        <% end %>
+      </div>
+    </div>
+    """
+  end
+
+  attr :create_new_annotation, :boolean, default: false
+  attr :annotations, :any, required: true
+  attr :current_user, Oli.Accounts.User, required: true
+  attr :selected_point, :any, required: true
+  attr :active_tab, :atom, default: :my_notes
+
+  defp annotations(assigns) do
+    ~H"""
+    <div class="flex-1 flex flex-col gap-3 overflow-y-auto pb-[80px]">
+      <.add_new_annotation_input
+        :if={@selected_point}
+        class="my-2"
+        active={@create_new_annotation}
+        disable_anonymous_option={@active_tab == :my_notes || is_guest(@current_user)}
+        save_label={if(@active_tab == :my_notes, do: "Save", else: "Post")}
+        placeholder={
+          if(@active_tab == :my_notes, do: "Add a new note...", else: "Post a new note...")
+        }
+      />
+
+      <%= case @annotations do %>
+        <% nil -> %>
+          <Common.loading_spinner />
+        <% [] -> %>
+          <div class="text-center p-4 text-gray-500"><%= empty_label(@active_tab) %></div>
+        <% annotations -> %>
+          <%= for annotation <- annotations do %>
+            <.post
+              post={annotation}
+              current_user={@current_user}
+              disable_anonymous_option={@active_tab == :my_notes || is_guest(@current_user)}
+            />
+          <% end %>
+      <% end %>
+    </div>
+    """
+  end
 
-          <%= case @annotations do %>
-            <% nil -> %>
-              <Common.loading_spinner />
-            <% [] -> %>
-              <div class="text-center p-4 text-gray-500"><%= empty_label(@active_tab) %></div>
-            <% annotations -> %>
-              <%= for annotation <- annotations do %>
-                <.post
-                  post={annotation}
-                  current_user={@current_user}
-                  post_replies={@post_replies}
-                  disable_anonymous_option={@active_tab == :my_notes || is_guest(@current_user)}
-                />
-              <% end %>
+  attr :current_user, Oli.Accounts.User, required: true
+  attr :active_tab, :atom, default: :my_notes
+  attr :search_results, :any, default: nil
+  attr :search_term, :string, default: ""
+
+  defp search_results(assigns) do
+    ~H"""
+    <div class="flex-1 flex flex-col gap-3 overflow-y-auto pb-[80px]">
+      <%= case @search_results do %>
+        <% :loading -> %>
+          <Common.loading_spinner />
+        <% [] -> %>
+          <div class="text-center p-4 text-gray-500">No results found</div>
+        <% annotations -> %>
+          <%= for annotation <- annotations do %>
+            <div
+              class="flex flex-col cursor-pointer"
+              phx-click="reveal_post"
+              phx-value-point-marker-id={annotation.annotated_block_id}
+              phx-value-post-id={annotation.id}
+            >
+              <.search_result post={annotation} current_user={@current_user} />
+            </div>
           <% end %>
+      <% end %>
+    </div>
+    """
+  end
+
+  attr :post, Oli.Resources.Collaboration.Post, required: true
+  attr :current_user, Oli.Accounts.User, required: true
+  attr :is_reply, :boolean, default: false
+
+  defp search_result(assigns) do
+    ~H"""
+    <div class={[
+      "search-result flex flex-col border-gray-200 dark:border-gray-800 rounded",
+      if(@is_reply, do: "my-2 pl-4 border-l-2", else: "p-4 border-2")
+    ]}>
+      <div class="flex flex-row justify-between mb-1">
+        <div class="font-semibold">
+          <%= post_creator(@post, @current_user) %>
+        </div>
+        <div class="text-sm text-gray-500">
+          <%= Timex.from_now(@post.inserted_at) %>
         </div>
       </div>
+      <p class="my-2">
+        <%= case @post.headline["message"] do %>
+          <% nil -> %>
+            <%= @post.content.message %>
+          <% message -> %>
+            <%= raw(message) %>
+        <% end %>
+      </p>
+      <%= case @post.replies do %>
+        <% nil -> %>
+        <% replies -> %>
+          <div class="flex flex-col gap-2 pl-4">
+            <%= for reply <- replies do %>
+              <.search_result post={reply} current_user={@current_user} is_reply={true} />
+            <% end %>
+          </div>
+      <% end %>
     </div>
     """
   end
@@ -216,20 +313,33 @@ defmodule OliWeb.Delivery.Student.Lesson.Annotations do
     """
   end
 
+  attr :search_term, :string, default: ""
   attr :rest, :global, include: ~w(class)
 
   defp search_box(assigns) do
     ~H"""
-    <div class={["flex flex-row", @rest[:class]]}>
+    <form class={["flex flex-row", @rest[:class]]} phx-submit="search_annotations">
       <div class="flex-1 relative">
         <i class="fa-solid fa-search absolute left-4 top-4 text-gray-400 pointer-events-none text-lg">
         </i>
         <input
           type="text"
-          class="w-full border border-gray-400 dark:border-gray-700 rounded-lg pl-12 pr-3 py-3"
+          name="search_term"
+          value={@search_term}
+          class="w-full border border-gray-400 dark:border-gray-700 rounded-lg px-12 py-3"
+          phx-change="search_annotations"
+          phx-debounce="500"
         />
+        <button
+          :if={@search_term != ""}
+          type="button"
+          class="absolute right-0 top-0 bottom-0 py-3 px-4"
+          phx-click="clear_search"
+        >
+          <i class="fa-solid fa-xmark text-lg"></i>
+        </button>
       </div>
-    </div>
+    </form>
     """
   end
 
@@ -293,7 +403,6 @@ defmodule OliWeb.Delivery.Student.Lesson.Annotations do
 
   attr :post, Oli.Resources.Collaboration.Post, required: true
   attr :current_user, Oli.Accounts.User, required: true
-  attr :post_replies, :any, required: true
   attr :disable_anonymous_option, :boolean, default: false
 
   defp post(assigns) do
@@ -317,7 +426,6 @@ defmodule OliWeb.Delivery.Student.Lesson.Annotations do
       />
       <.post_replies
         post={@post}
-        replies={@post_replies}
         current_user={@current_user}
         disable_anonymous_option={@disable_anonymous_option}
       />
@@ -371,6 +479,7 @@ defmodule OliWeb.Delivery.Student.Lesson.Annotations do
             phx-click={@on_toggle_reaction}
             phx-value-reaction={:like}
             phx-value-post-id={assigns.post.id}
+            phx-value-parent-post-id={assigns.post.parent_post_id}
           >
             <%= case Map.get(@post.reaction_summaries, :like) do %>
               <% nil -> %>
@@ -402,32 +511,29 @@ defmodule OliWeb.Delivery.Student.Lesson.Annotations do
 
   attr :post, Oli.Resources.Collaboration.Post, required: true
   attr :current_user, Oli.Accounts.User, required: true
-  attr :replies, :any, required: true
   attr :disable_anonymous_option, :boolean, default: false
 
   defp post_replies(assigns) do
     ~H"""
-    <%= if !is_nil(@replies) && elem(@replies, 0) == @post.id do %>
-      <%= case @replies do %>
-        <% {_, :loading} -> %>
-          <Common.loading_spinner />
-        <% {_, []} -> %>
-          <.add_new_reply_input
-            parent_post_id={@post.id}
-            disable_anonymous_option={@disable_anonymous_option}
-          />
-        <% {_, replies} -> %>
-          <div class="flex flex-col gap-2 pl-4">
-            <%= for reply <- replies do %>
-              <.reply post={reply} current_user={@current_user} />
-            <% end %>
-          </div>
-          <.add_new_reply_input
-            parent_post_id={@post.id}
-            disable_anonymous_option={@disable_anonymous_option}
-          />
-        <% _ -> %>
-      <% end %>
+    <%= case @post.replies do %>
+      <% nil -> %>
+      <% :loading -> %>
+        <Common.loading_spinner />
+      <% [] -> %>
+        <.add_new_reply_input
+          parent_post_id={@post.id}
+          disable_anonymous_option={@disable_anonymous_option}
+        />
+      <% replies -> %>
+        <div class="flex flex-col gap-2 pl-4">
+          <%= for reply <- replies do %>
+            <.reply post={reply} current_user={@current_user} />
+          <% end %>
+        </div>
+        <.add_new_reply_input
+          parent_post_id={@post.id}
+          disable_anonymous_option={@disable_anonymous_option}
+        />
     <% end %>
     """
   end
@@ -494,21 +600,32 @@ defmodule OliWeb.Delivery.Student.Lesson.Annotations do
       <p class="my-2">
         <%= @post.content.message %>
       </p>
-      <.post_actions post={@post} on_toggle_reaction="toggle_reply_reaction" />
+      <.post_actions post={@post} on_toggle_reaction="toggle_reaction" />
     </div>
     """
   end
 
-  attr :point_marker, :map, required: true
+  attr :point_marker, :any, required: true
   attr :selected, :boolean, default: false
   attr :count, :integer, default: nil
 
+  def annotation_bubble(%{point_marker: :page} = assigns) do
+    ~H"""
+    <button
+      class="absolute top-0 right-[-15px] cursor-pointer group"
+      phx-click="toggle_annotation_point"
+    >
+      <.chat_bubble selected={@selected} count={@count} />
+    </button>
+    """
+  end
+
   def annotation_bubble(assigns) do
     ~H"""
     <button
       class="absolute right-[-15px] cursor-pointer group"
       style={"top: #{@point_marker.top}px"}
-      phx-click="select_annotation_point"
+      phx-click="toggle_annotation_point"
       phx-value-point-marker-id={@point_marker.id}
     >
       <.chat_bubble selected={@selected} count={@count} />
diff --git a/lib/oli_web/live/delivery/student/lesson_live.ex b/lib/oli_web/live/delivery/student/lesson_live.ex
index 00a07b75250..ffd84af30b8 100644
--- a/lib/oli_web/live/delivery/student/lesson_live.ex
+++ b/lib/oli_web/live/delivery/student/lesson_live.ex
@@ -206,36 +206,46 @@ defmodule OliWeb.Delivery.Student.LessonLive do
      end)}
   end
 
-  def handle_event("select_annotation_point", %{"point-marker-id" => point_marker_id}, socket) do
-    async_load_annotations(
-      socket.assigns.section,
-      socket.assigns.page_context.page.resource_id,
-      socket.assigns.current_user,
-      socket.assigns.course_collab_space_config,
-      visibility_for_active_tab(socket.assigns.annotations.active_tab),
-      point_marker_id
-    )
+  def handle_event("toggle_annotation_point", params, socket) do
+    %{annotations: %{selected_point: selected_point}} = socket.assigns
 
-    {:noreply,
-     socket
-     |> assign_annotations(selected_point: point_marker_id, posts: nil)
-     |> push_event("highlight_point_marker", %{id: point_marker_id})}
-  end
+    point_marker_id =
+      case params do
+        %{"point-marker-id" => point_marker_id} -> point_marker_id
+        _ -> :page
+      end
 
-  def handle_event("select_annotation_point", _params, socket) do
-    async_load_annotations(
-      socket.assigns.section,
-      socket.assigns.page_context.page.resource_id,
-      socket.assigns.current_user,
-      socket.assigns.course_collab_space_config,
-      visibility_for_active_tab(socket.assigns.annotations.active_tab),
-      nil
-    )
+    if selected_point == point_marker_id do
+      # unselect the point marker and load all annotations
+      async_load_annotations(
+        socket.assigns.section,
+        socket.assigns.page_context.page.resource_id,
+        socket.assigns.current_user,
+        socket.assigns.course_collab_space_config,
+        visibility_for_active_tab(socket.assigns.annotations.active_tab),
+        nil
+      )
 
-    {:noreply,
-     socket
-     |> assign_annotations(selected_point: nil, posts: nil)
-     |> push_event("clear_highlighted_point_markers", %{})}
+      {:noreply,
+       socket
+       |> assign_annotations(selected_point: nil, posts: nil)
+       |> push_event("clear_highlighted_point_markers", %{})}
+    else
+      # select the point marker and load annotations for that point
+      async_load_annotations(
+        socket.assigns.section,
+        socket.assigns.page_context.page.resource_id,
+        socket.assigns.current_user,
+        socket.assigns.course_collab_space_config,
+        visibility_for_active_tab(socket.assigns.annotations.active_tab),
+        point_marker_id
+      )
+
+      {:noreply,
+       socket
+       |> assign_annotations(selected_point: point_marker_id, posts: nil)
+       |> push_event("highlight_point_marker", %{id: point_marker_id})}
+    end
   end
 
   def handle_event("begin_create_annotation", _, socket) do
@@ -262,6 +272,10 @@ defmodule OliWeb.Delivery.Student.LessonLive do
       }
     } = socket.assigns
 
+    # if the selected point is the page resource id, we treat it as nil
+    selected_point =
+      if(selected_point == :page, do: nil, else: selected_point)
+
     attrs = %{
       status: if(auto_approve_annotations, do: :approved, else: :submitted),
       user_id: current_user.id,
@@ -309,59 +323,66 @@ defmodule OliWeb.Delivery.Student.LessonLive do
 
   def handle_event("toggle_post_replies", %{"post-id" => post_id}, socket) do
     %{current_user: current_user} = socket.assigns
-    %{post_replies: post_replies} = socket.assigns.annotations
 
     post_id = String.to_integer(post_id)
+    post = get_post(socket, post_id)
 
-    case post_replies do
-      {^post_id, _} ->
-        {:noreply, assign_annotations(socket, post_replies: nil)}
-
-      _ ->
+    case post.replies do
+      nil ->
+        # load replies
         async_load_post_replies(current_user.id, post_id)
 
-        {:noreply, assign_annotations(socket, post_replies: {post_id, :loading})}
+        {:noreply, update_post_replies(socket, post_id, :loading, fn _ -> :loading end)}
+
+      _ ->
+        # unload replies
+        {:noreply, update_post_replies(socket, post_id, nil, fn _ -> nil end)}
     end
   end
 
-  def handle_event("toggle_reaction", %{"post-id" => post_id, "reaction" => reaction}, socket) do
-    %{current_user: current_user, annotations: %{posts: posts}} = socket.assigns
+  # handle toggle_reaction for reply posts
+  def handle_event(
+        "toggle_reaction",
+        %{"parent-post-id" => parent_post_id, "post-id" => post_id, "reaction" => reaction},
+        socket
+      ) do
+    %{current_user: current_user} = socket.assigns
 
+    parent_post_id = String.to_integer(parent_post_id)
     post_id = String.to_integer(post_id)
     reaction = String.to_existing_atom(reaction)
 
     case Collaboration.toggle_reaction(post_id, current_user.id, reaction) do
       {:ok, change} ->
         {:noreply,
-         assign_annotations(socket,
-           posts:
-             Enum.map(
-               posts,
-               fn post ->
-                 if post.id == post_id do
-                   %{
-                     post
-                     | reaction_summaries: update_reaction_summaries(post, reaction, change)
-                   }
-                 else
+         update_post_replies(socket, parent_post_id, nil, fn replies ->
+           Enum.map(
+             replies,
+             fn post ->
+               if post.id == post_id do
+                 %{
                    post
-                 end
+                   | reaction_summaries: update_reaction_summaries(post, reaction, change)
+                 }
+               else
+                 post
                end
-             )
-         )}
+             end
+           )
+         end)}
 
       {:error, _} ->
         {:noreply, put_flash(socket, :error, "Failed to update reaction for post")}
     end
   end
 
+  # handle toggle_reaction for root posts
   def handle_event(
-        "toggle_reply_reaction",
+        "toggle_reaction",
         %{"post-id" => post_id, "reaction" => reaction},
         socket
       ) do
-    %{current_user: current_user, annotations: %{post_replies: {parent_post_id, post_replies}}} =
-      socket.assigns
+    %{current_user: current_user, annotations: %{posts: posts}} = socket.assigns
 
     post_id = String.to_integer(post_id)
     reaction = String.to_existing_atom(reaction)
@@ -370,21 +391,20 @@ defmodule OliWeb.Delivery.Student.LessonLive do
       {:ok, change} ->
         {:noreply,
          assign_annotations(socket,
-           post_replies:
-             {parent_post_id,
-              Enum.map(
-                post_replies,
-                fn post ->
-                  if post.id == post_id do
-                    %{
-                      post
-                      | reaction_summaries: update_reaction_summaries(post, reaction, change)
-                    }
-                  else
-                    post
-                  end
-                end
-              )}
+           posts:
+             Enum.map(
+               posts,
+               fn post ->
+                 if post.id == post_id do
+                   %{
+                     post
+                     | reaction_summaries: update_reaction_summaries(post, reaction, change)
+                   }
+                 else
+                   post
+                 end
+               end
+             )
          )}
 
       {:error, _} ->
@@ -414,6 +434,10 @@ defmodule OliWeb.Delivery.Student.LessonLive do
       }
     } = socket.assigns
 
+    # if the selected point is the page, we treat it as nil
+    selected_point =
+      if(selected_point == :page, do: nil, else: selected_point)
+
     attrs = %{
       status: if(auto_approve_annotations, do: :approved, else: :submitted),
       user_id: current_user.id,
@@ -444,6 +468,78 @@ defmodule OliWeb.Delivery.Student.LessonLive do
     end
   end
 
+  def handle_event("search_annotations", %{"search_term" => ""}, socket) do
+    {:noreply, assign_annotations(socket, search_results: nil, search_term: "")}
+  end
+
+  def handle_event("search_annotations", %{"search_term" => search_term}, socket) do
+    %{
+      current_user: current_user,
+      section: section,
+      page_context: %{
+        page: %{resource_id: resource_id}
+      },
+      annotations: %{
+        selected_point: selected_point,
+        active_tab: active_tab
+      }
+    } = socket.assigns
+
+    async_search_annotations(
+      section,
+      resource_id,
+      current_user,
+      visibility_for_active_tab(active_tab),
+      selected_point,
+      search_term
+    )
+
+    {:noreply, assign_annotations(socket, search_results: :loading, search_term: search_term)}
+  end
+
+  def handle_event("clear_search", _, socket) do
+    {:noreply, assign_annotations(socket, search_results: nil, search_term: "")}
+  end
+
+  def handle_event(
+        "reveal_post",
+        %{"post-id" => post_id} = params,
+        socket
+      ) do
+    %{
+      section: section,
+      page_context: page_context,
+      current_user: current_user,
+      course_collab_space_config: course_collab_space_config,
+      annotations: %{
+        active_tab: active_tab
+      }
+    } = socket.assigns
+
+    point_marker_id =
+      case params do
+        %{"point-marker-id" => point_marker_id} -> point_marker_id
+        _ -> :page
+      end
+
+    async_load_annotations(
+      section,
+      page_context.page.resource_id,
+      current_user,
+      course_collab_space_config,
+      visibility_for_active_tab(active_tab),
+      point_marker_id,
+      String.to_integer(post_id)
+    )
+
+    {:noreply,
+     assign_annotations(socket,
+       selected_point: point_marker_id,
+       search_results: nil,
+       search_term: ""
+     )}
+  end
+
   # handle assigns directly from async tasks
   def handle_info({ref, result}, socket) do
     Process.demonitor(ref, [:flush])
@@ -452,6 +548,9 @@ defmodule OliWeb.Delivery.Student.LessonLive do
       {:assign_annotations, annotations} ->
         {:noreply, assign_annotations(socket, Enum.into(annotations, socket.assigns.annotations))}
 
+      {:assign_post_replies, {parent_post_id, replies}} ->
+        {:noreply, update_post_replies(socket, parent_post_id, replies, fn _ -> replies end)}
+
       {:error, _} ->
         {:noreply, put_flash(socket, :error, "Failed to load annotations")}
 
@@ -485,8 +584,8 @@ defmodule OliWeb.Delivery.Student.LessonLive do
 
       <:point_markers :if={@annotations.show_sidebar && @annotations.point_markers}>
         <Annotations.annotation_bubble
-          point_marker={%{id: nil, top: 0}}
-          selected={@annotations.selected_point == nil}
+          point_marker={:page}
+          selected={@annotations.selected_point == :page}
           count={@annotations.post_counts && @annotations.post_counts[nil]}
         />
         <Annotations.annotation_bubble
@@ -509,7 +608,9 @@ defmodule OliWeb.Delivery.Student.LessonLive do
           annotations={@annotations.posts}
           current_user={@current_user}
           active_tab={@annotations.active_tab}
-          post_replies={@annotations.post_replies}
+          search_results={@annotations.search_results}
+          search_term={@annotations.search_term}
+          selected_point={@annotations.selected_point}
         />
       </:sidebar>
     </.page_content_with_sidebar_layout>
@@ -1017,6 +1118,26 @@ defmodule OliWeb.Delivery.Student.LessonLive do
     })
   end
 
+  defp get_post(socket, post_id) do
+    Enum.find(socket.assigns.annotations.posts, fn post -> post.id == post_id end)
+  end
+
+  defp update_post_replies(socket, post_id, default, updater) do
+    %{posts: posts} = socket.assigns.annotations
+
+    socket
+    |> assign_annotations(
+      posts:
+        Enum.map(posts, fn post ->
+          if post.id == post_id do
+            Map.update(post, :replies, default, updater)
+          else
+            post
+          end
+        end)
+    )
+  end
+
   defp annotations_assigns(socket, course_collab_space_config) do
     case course_collab_space_config do
       %CollabSpaceConfig{status: :enabled} ->
@@ -1030,7 +1151,8 @@ defmodule OliWeb.Delivery.Student.LessonLive do
             active_tab: :my_notes,
             create_new_annotation: false,
             auto_approve_annotations: course_collab_space_config.auto_accept,
-            post_replies: nil
+            search_results: nil,
+            search_term: ""
           }
         )
 
@@ -1045,7 +1167,8 @@ defmodule OliWeb.Delivery.Student.LessonLive do
          current_user,
          course_collab_space_config,
          visibility,
-         point_block_id
+         point_block_id,
+         load_replies_for_post_id \\ nil
        ) do
     if current_user do
       Task.async(fn ->
@@ -1070,6 +1193,27 @@ defmodule OliWeb.Delivery.Student.LessonLive do
                 point_block_id
               )
 
+            # load_replies_for_post_id is an option that allows a specific post to be loaded with
+            # its replies, used for when a user click "View Original Post" in the search results
+            posts =
+              if load_replies_for_post_id do
+                post_replies =
+                  Collaboration.list_replies_for_post_in_point_block(
+                    current_user.id,
+                    load_replies_for_post_id
+                  )
+
+                Enum.map(posts, fn post ->
+                  if post.id == load_replies_for_post_id do
+                    %Collaboration.Post{post | replies: post_replies}
+                  else
+                    post
+                  end
+                end)
+              else
+                posts
+              end
+
             {:assign_annotations,
              %{
                post_counts: post_counts,
@@ -1089,7 +1233,30 @@ defmodule OliWeb.Delivery.Student.LessonLive do
     Task.async(fn ->
       post_replies = Collaboration.list_replies_for_post_in_point_block(user_id, post_id)
 
-      {:assign_annotations, %{post_replies: {post_id, post_replies}}}
+      {:assign_post_replies, {post_id, post_replies}}
+    end)
+  end
+
+  defp async_search_annotations(
+         section,
+         resource_id,
+         current_user,
+         visibility,
+         point_block_id,
+         search_term
+       ) do
+    Task.async(fn ->
+      search_results =
+        Collaboration.search_posts_for_user_in_point_block(
+          section.id,
+          resource_id,
+          current_user.id,
+          visibility,
+          point_block_id,
+          search_term
+        )
+
+      {:assign_annotations, %{search_results: search_results}}
     end)
   end
 
@@ -1113,7 +1280,7 @@ defmodule OliWeb.Delivery.Student.LessonLive do
   end
 
   defp optimistically_add_reply_post(socket, reply_post, parent_post_id) do
-    %{posts: posts, post_replies: {_, post_replies}} = socket.assigns.annotations
+    %{posts: posts} = socket.assigns.annotations
 
     socket
     |> assign_annotations(
@@ -1122,13 +1289,17 @@ defmodule OliWeb.Delivery.Student.LessonLive do
           if post.id == parent_post_id do
             %Collaboration.Post{
               post
-              | replies_count: post.replies_count + 1
+              | replies_count: post.replies_count + 1,
+                replies:
+                  case post.replies do
+                    nil -> [reply_post]
+                    replies -> replies ++ [reply_post]
+                  end
             }
           else
             post
           end
-        end),
-      post_replies: {parent_post_id, post_replies ++ [reply_post]}
+        end)
     )
   end
 
diff --git a/lib/oli_web/live/delivery/student_dashboard/components/helpers.ex b/lib/oli_web/live/delivery/student_dashboard/components/helpers.ex
index 1aa112f8888..cddbedbb873 100644
--- a/lib/oli_web/live/delivery/student_dashboard/components/helpers.ex
+++ b/lib/oli_web/live/delivery/student_dashboard/components/helpers.ex
@@ -27,7 +27,9 @@ defmodule OliWeb.Delivery.StudentDashboard.Components.Helpers do
       <div class="flex-1 flex flex-col">
         <div class="relative flex-1 flex flex-col pb-[60px]">
           <%= render_slot(@inner_block) %>
-          <%= Phoenix.View.render(OliWeb.LayoutView, "_delivery_footer.html", assigns) %>
+          <OliWeb.Components.Footer.delivery_footer license={
+            Map.get(assigns, :has_license) && assigns[:license]
+          } />
         </div>
       </div>
     </div>
diff --git a/lib/oli_web/live/insights/insights.ex b/lib/oli_web/live/insights/insights.ex
index 34627dc6f00..dc8b126d031 100644
--- a/lib/oli_web/live/insights/insights.ex
+++ b/lib/oli_web/live/insights/insights.ex
@@ -99,7 +99,8 @@ defmodule OliWeb.Insights do
          |> to_form(),
        section_ids: [],
        product_ids: [],
-       form_uid: ""
+       form_uid_for_product: "",
+       form_uid_for_section: ""
      )}
   end
 
@@ -189,7 +190,7 @@ defmodule OliWeb.Insights do
               options={@sections}
               form={@form_sections}
               label="Select a section"
-              uid={@form_uid}
+              uid={@form_uid_for_section}
             />
           </.form>
 
@@ -200,7 +201,7 @@ defmodule OliWeb.Insights do
               options={@products}
               form={@form_products}
               label="Select a product"
-              uid={@form_uid}
+              uid={@form_uid_for_product}
             />
           </.form>
         </div>
@@ -469,7 +470,7 @@ defmodule OliWeb.Insights do
 
   def handle_info(:init_by_page, socket) do
     by_page_rows =
-      get_by_page_row(socket)
+      get_by_page_row(socket, :by_page)
 
     active_rows =
       apply_filter_sort(
@@ -485,10 +486,7 @@ defmodule OliWeb.Insights do
 
   def handle_info(:init_by_objective, socket) do
     by_objective_rows =
-      Oli.Analytics.ByObjective.query_against_project_slug(
-        socket.assigns.project.slug,
-        socket.assigns.section_ids
-      )
+      get_by_page_row(socket, :by_objective)
       |> arrange_rows_into_objective_hierarchy()
 
     active_rows =
@@ -505,7 +503,7 @@ defmodule OliWeb.Insights do
 
   def handle_info(:init_by_activity, socket) do
     by_activity_rows =
-      get_by_page_row(socket)
+      get_by_page_row(socket, :by_activity)
 
     active_rows =
       apply_filter_sort(
@@ -519,7 +517,7 @@ defmodule OliWeb.Insights do
     {:noreply, assign(socket, by_activity_rows: by_activity_rows, active_rows: active_rows)}
   end
 
-  defp get_by_page_row(socket) do
+  defp get_by_page_row(socket, :by_activity) do
     if socket.assigns.is_product do
       Oli.Analytics.ByActivity.query_against_project_slug(
         socket.assigns.project.slug,
@@ -533,6 +531,34 @@ defmodule OliWeb.Insights do
     end
   end
 
+  defp get_by_page_row(socket, :by_objective) do
+    if socket.assigns.is_product do
+      Oli.Analytics.ByObjective.query_against_project_slug(
+        socket.assigns.project.slug,
+        socket.assigns.product_ids
+      )
+    else
+      Oli.Analytics.ByObjective.query_against_project_slug(
+        socket.assigns.project.slug,
+        socket.assigns.section_ids
+      )
+    end
+  end
+
+  defp get_by_page_row(socket, :by_page) do
+    if socket.assigns.is_product do
+      Oli.Analytics.ByPage.query_against_project_slug(
+        socket.assigns.project.slug,
+        socket.assigns.product_ids
+      )
+    else
+      Oli.Analytics.ByPage.query_against_project_slug(
+        socket.assigns.project.slug,
+        socket.assigns.section_ids
+      )
+    end
+  end
+
   defp generate_uuid do
     #
     :crypto.strong_rand_bytes(16)
@@ -548,7 +574,7 @@ defmodule OliWeb.Insights do
         socket.assigns.section_ids
       )
 
-    reset_form_section_values(socket.assigns.product_ids, section_ids_updated, socket)
+    reset_form_product_values(socket.assigns.product_ids, section_ids_updated, socket)
   end
 
   defp update_section_by_value("false", socket, target_value) do
@@ -570,7 +596,7 @@ defmodule OliWeb.Insights do
     {:noreply, socket}
   end
 
-  defp reset_form_section_values([], section_ids_updated, socket) do
+  defp reset_form_product_values([], section_ids_updated, socket) do
     socket =
       assign(socket,
         is_product: false,
@@ -581,12 +607,12 @@ defmodule OliWeb.Insights do
     {:noreply, socket}
   end
 
-  defp reset_form_section_values(_section_ids, section_ids_updated, socket) do
+  defp reset_form_product_values(_section_ids, section_ids_updated, socket) do
     socket =
       assign(socket,
         is_product: false,
         section_ids: section_ids_updated,
-        form_uid: generate_uuid(),
+        form_uid_for_product: generate_uuid(),
         product_ids: [],
         form_products: socket.assigns.initial_product_options
       )
@@ -604,7 +630,7 @@ defmodule OliWeb.Insights do
         socket.assigns.product_ids
       )
 
-    reset_form_products(socket.assigns.section_ids, product_ids_updated, socket)
+    reset_form_section_values(socket.assigns.section_ids, product_ids_updated, socket)
   end
 
   defp update_product_by_value("false", socket, target_value) do
@@ -626,10 +652,10 @@ defmodule OliWeb.Insights do
     {:noreply, socket}
   end
 
-  defp reset_form_products([], product_ids_updated, socket) do
+  defp reset_form_section_values([], product_ids_updated, socket) do
     socket =
       assign(socket,
-        is_product: false,
+        is_product: true,
         product_ids: product_ids_updated
       )
 
@@ -637,12 +663,12 @@ defmodule OliWeb.Insights do
     {:noreply, socket}
   end
 
-  defp reset_form_products(_section_ids, product_ids_updated, socket) do
+  defp reset_form_section_values(_product_ids, product_ids_updated, socket) do
     socket =
       assign(socket,
-        is_product: false,
+        is_product: true,
         product_ids: product_ids_updated,
-        form_uid: generate_uuid(),
+        form_uid_for_section: generate_uuid(),
         section_ids: [],
         form_sections: socket.assigns.initial_section_options
       )
diff --git a/lib/oli_web/templates/layout/_delivery_footer.html.eex b/lib/oli_web/templates/layout/_delivery_footer.html.eex
deleted file mode 100644
index a22b71de6e6..00000000000
--- a/lib/oli_web/templates/layout/_delivery_footer.html.eex
+++ /dev/null
@@ -1,28 +0,0 @@
-<%
-  privacy_policies_url = Application.fetch_env!(:oli, :privacy_policies)[:url]
-  footer =  Application.fetch_env!(:oli, :footer)
-%>
-
-<footer class="flex flex-row h-[90px] overflow-hidden absolute bottom-0 left-0 right-0 bg-delivery-footer dark:bg-delivery-footer-dark">
-<div class="container mx-auto flex flex-col px-3 justify-center items-center text-sm gap-2">
-  <div class="container mx-auto flex flex-col justify-between text-xs">
-    <div class="text-left flex gap-2">
-      <a href='javascript:;' onclick="OLI.selectCookiePreferences({privacyPoliciesUrl: '<%= privacy_policies_url %>'})">Cookie Preferences</a>
-    </div>
-    <div class="text-center">
-      <%= footer[:text] %><a href="<%= footer[:link_1_location] %>" target="_blank"><%= footer[:link_1_text] %></a>
-    </div>
-    <div class="text-center">
-      <a href="<%= footer[:link_2_location] %>" target="_blank"> <%= footer[:link_2_text] %></a>
-    </div>
-    <div class="text-right">
-    </div>
-    <%= if Map.get(assigns, :has_license) do %>
-      <%= render_license(assigns[:license]) %>
-    <% end %>
-  </div>
-
-  <script>
-    OLI.onReady(() => OLI.retrieveCookies('<%= Routes.cookie_consent_path(OliWeb.Endpoint, :retrieve) %>', {privacyPoliciesUrl: '<%= privacy_policies_url %>'}));
-  </script>
-</footer>
diff --git a/lib/oli_web/templates/layout/_footer.html.eex b/lib/oli_web/templates/layout/_footer.html.eex
deleted file mode 100644
index 8640751d938..00000000000
--- a/lib/oli_web/templates/layout/_footer.html.eex
+++ /dev/null
@@ -1,25 +0,0 @@
-<%
-  privacy_policies_url = Application.fetch_env!(:oli, :privacy_policies)[:url]
-  footer =  Application.fetch_env!(:oli, :footer)
-%>
-
-<footer class="flex flex-row h-[60px] overflow-hidden absolute bottom-0 left-0 right-0 bg-workspace-footer-bg dark:bg-workspace-footer-bg-dark">
-  <div class="container mx-auto flex flex-row px-10 items-center text-sm">
-    <div class="text-left">
-      <a href='javascript:;' onclick="OLI.selectCookiePreferences({privacyPoliciesUrl: '<%= privacy_policies_url %>'})">Cookie Preferences</a>
-    </div>
-    <div class="flex-1 text-center">
-      <%= footer[:text] %><a href="<%= footer[:link_1_location] %>" target="_blank"><%= footer[:link_1_text] %></a>
-    </div>
-    <div class="flex-1 text-center">
-      <a href="<%= footer[:link_2_location] %>" target="_blank"> <%= footer[:link_2_text] %></a>
-    </div>
-    <div class="text-right">
-      Version <%= Application.fetch_env!(:oli, :build).version %> (<%= Application.fetch_env!(:oli, :build).sha |> String.upcase %>) <%= Timex.format!(Application.fetch_env!(:oli, :build).date, "%m/%d/%Y", :strftime) %>
-    </div>
-  </div>
-
-  <script>
-    OLI.onReady(() => OLI.retrieveCookies('<%= Routes.cookie_consent_path(@conn, :retrieve) %>', {privacyPoliciesUrl: '<%= privacy_policies_url %>'}));
-  </script>
-</footer>
diff --git a/lib/oli_web/templates/layout/default.html.heex b/lib/oli_web/templates/layout/default.html.heex
index 5a1daacbab2..8b59dbca863 100644
--- a/lib/oli_web/templates/layout/default.html.heex
+++ b/lib/oli_web/templates/layout/default.html.heex
@@ -10,6 +10,8 @@
       <%= @inner_content %>
     </main>
 
-    <%= render(OliWeb.LayoutView, "_footer.html", assigns) %>
+    <OliWeb.Components.Footer.delivery_footer license={
+      Map.get(assigns, :has_license) && assigns[:license]
+    } />
   </div>
 <% end %>
diff --git a/lib/oli_web/templates/layout/email.html.eex b/lib/oli_web/templates/layout/email.html.eex
index f282772138e..12f1f45a5ee 100644
--- a/lib/oli_web/templates/layout/email.html.eex
+++ b/lib/oli_web/templates/layout/email.html.eex
@@ -238,7 +238,7 @@
 
         <!-- Email Footer : BEGIN -->
 
-        <%= render OliWeb.EmailView, "_footer.html" %>
+        <%= OliWeb.Components.Footer.global_footer(%{}) %>
 
         <!-- Email Footer : END -->
 
diff --git a/lib/oli_web/templates/layout/workspace.html.eex b/lib/oli_web/templates/layout/workspace.html.eex
index f842c5be7f6..4144173faa5 100644
--- a/lib/oli_web/templates/layout/workspace.html.eex
+++ b/lib/oli_web/templates/layout/workspace.html.eex
@@ -23,7 +23,7 @@
         <main role="main" id="main-content flex-1">
           <%= @inner_content %>
         </main>
-        <%= render OliWeb.LayoutView, "_footer.html", assigns %>
+        <%= OliWeb.Components.Footer.global_footer(%{}) %>
       </div>
     </div>
   </div>
diff --git a/lib/oli_web/templates/lti/register.html.eex b/lib/oli_web/templates/lti/register.html.eex
index 14dfebebe1f..2347651aeac 100644
--- a/lib/oli_web/templates/lti/register.html.eex
+++ b/lib/oli_web/templates/lti/register.html.eex
@@ -205,5 +205,6 @@
 
   <%= render OliWeb.SharedView, "_help.html", conn: @conn %>
 
-  <%= render OliWeb.LayoutView, "_delivery_footer.html", assigns %>
+  <%= OliWeb.Components.Footer.delivery_footer(%{license: Map.get(assigns, :has_license) && assigns[:license]}) %>
+
 </div>
diff --git a/lib/oli_web/templates/lti/registration_pending.html.eex b/lib/oli_web/templates/lti/registration_pending.html.eex
index c1fbe998b4b..9e184510641 100644
--- a/lib/oli_web/templates/lti/registration_pending.html.eex
+++ b/lib/oli_web/templates/lti/registration_pending.html.eex
@@ -1,4 +1,8 @@
-<%= render OliWeb.LayoutView, "_delivery_header.html", Map.merge(assigns, %{logo_link: "#", hide_user: true}) %>
+<%= render(
+  OliWeb.LayoutView,
+  "_delivery_header.html",
+  Map.merge(assigns, %{logo_link: "#", hide_user: true})
+) %>
 
 <div class="pb-[60px]">
   <div class="container box-form-container">
@@ -41,5 +45,6 @@
 
   <%= render OliWeb.SharedView, "_help.html", conn: @conn %>
 
-  <%= render OliWeb.LayoutView, "_delivery_footer.html", assigns %>
+  <%= OliWeb.Components.Footer.delivery_footer(%{license: Map.get(assigns, :has_license) && assigns[:license]}) %>
+  </div>
 </div>
diff --git a/test/oli/delivery/analytics/analytics_test.exs b/test/oli/delivery/analytics/analytics_test.exs
index 6e427752f34..4c72f49fd11 100644
--- a/test/oli/delivery/analytics/analytics_test.exs
+++ b/test/oli/delivery/analytics/analytics_test.exs
@@ -62,9 +62,9 @@ defmodule Oli.Delivery.Analytics.AnalyticsTest do
       activity_no_attempts = seeds.activity_no_attempts.revision
       activity_results = Enum.find(activity_query, &(&1.slice.id == activity_no_attempts.id))
       assert activity_results.number_of_attempts == nil
-
       page_no_attempts = seeds.revision1
       page_results = Enum.find(page_query, &(&1.slice.id == page_no_attempts.id))
+
       assert page_results.number_of_attempts == nil
 
       objective_no_attempts = seeds.obj_not_used.revision
@@ -99,7 +99,7 @@ defmodule Oli.Delivery.Analytics.AnalyticsTest do
     } do
       assert length(activity_query) == 4
       assert length(objective_query) == 2
-      assert length(page_query) == 5
+      assert length(page_query) == 4
     end
   end
 
@@ -309,7 +309,7 @@ defmodule Oli.Delivery.Analytics.AnalyticsTest do
       # Parent course should still have analytics after duplicating project
       assert Enum.count(objective_query) == 2
       assert Enum.count(activity_query) == 4
-      assert Enum.count(page_query) == 5
+      assert Enum.count(page_query) == 4
 
       # Duplicated course should not have analytics
 
@@ -340,7 +340,7 @@ defmodule Oli.Delivery.Analytics.AnalyticsTest do
 
       # 3 pages with no analytics
       page_insights = ByPage.query_against_project_slug(duplicated.slug, [])
-      assert Enum.count(page_insights) == 3
+      assert Enum.count(page_insights) == 1
 
       assert Enum.all?(page_insights, fn obj ->
                Enum.all?(insights_from_struct.(obj), &is_nil(&1))
diff --git a/test/oli/resources/collaboration_test.exs b/test/oli/resources/collaboration_test.exs
index 2ce6f85df36..a580fcc1bb5 100644
--- a/test/oli/resources/collaboration_test.exs
+++ b/test/oli/resources/collaboration_test.exs
@@ -2,7 +2,9 @@ defmodule Oli.Resources.CollaborationTest do
   use Oli.DataCase
 
   import Oli.Factory
+  import Oli.Utils.Seeder.Utils
 
+  alias Oli.Utils.Seeder
   alias Oli.Resources
   alias Oli.Resources.Collaboration
   alias Oli.Resources.Collaboration.{CollabSpaceConfig, Post}
@@ -669,4 +671,122 @@ defmodule Oli.Resources.CollaborationTest do
       assert %Post{status: :approved} = Collaboration.get_post_by(%{id: post.id})
     end
   end
+
+  describe "audience" do
+    setup do
+      %{}
+      |> Seeder.Project.create_author(author_tag: :author)
+      |> Seeder.Project.create_sample_project(
+        ref(:author),
+        project_tag: :proj,
+        publication_tag: :pub,
+        curriculum_revision_tag: :curriculum,
+        unscored_page1_tag: :page1
+      )
+      |> Seeder.Project.ensure_published(ref(:pub), publication_tag: :pub)
+      |> Seeder.Section.create_section(
+        ref(:proj),
+        ref(:pub),
+        nil,
+        %{},
+        section_tag: :section
+      )
+      |> Seeder.Section.create_and_enroll_learner(
+        ref(:section),
+        %{},
+        user_tag: :student1
+      )
+    end
+
+    test "search_posts_for_user_in_point_block/6 returns all posts with given search term", %{
+      section: section,
+      page1: page1,
+      student1: student1
+    } do
+      create_post(student1.id, section.id, page1.resource_id, "test")
+      create_post(student1.id, section.id, page1.resource_id, "another test")
+      create_post(student1.id, section.id, page1.resource_id, "no match")
+
+      create_post(student1.id, section.id, page1.resource_id, "private note",
+        visibility: :private
+      )
+
+      create_post(student1.id, section.id, page1.resource_id, "point block test",
+        annotation_type: :point,
+        annotated_block_id: "block1"
+      )
+
+      create_post(student1.id, section.id, page1.resource_id, "point block no match",
+        annotation_type: :point,
+        annotated_block_id: "block1"
+      )
+
+      create_post(student1.id, section.id, page1.resource_id, "my note",
+        visibility: :private,
+        annotation_type: :point,
+        annotated_block_id: "block1"
+      )
+
+      # get all public notes for a resource
+      results =
+        Collaboration.search_posts_for_user_in_point_block(
+          section.id,
+          page1.resource_id,
+          student1.id,
+          :public,
+          nil,
+          "test"
+        )
+
+      assert length(results) == 3
+      assert Enum.all?(results, &(&1.content.message =~ "test"))
+
+      refute Enum.any?(results, &(&1.content.message =~ "no match"))
+
+      # get all private notes for a resource
+      results =
+        Collaboration.search_posts_for_user_in_point_block(
+          section.id,
+          page1.resource_id,
+          student1.id,
+          :private,
+          nil,
+          "note"
+        )
+
+      assert length(results) == 2
+      assert Enum.all?(results, &(&1.content.message =~ "note"))
+
+      # get all public notes for a particular point block
+      results =
+        Collaboration.search_posts_for_user_in_point_block(
+          section.id,
+          page1.resource_id,
+          student1.id,
+          :public,
+          "block1",
+          "test"
+        )
+
+      assert length(results) == 1
+      assert Enum.all?(results, &(&1.content.message =~ "test"))
+    end
+  end
+
+  defp create_post(user_id, section_id, resource_id, message, attrs \\ []) do
+    attrs
+    |> Enum.into(%{
+      status: :approved,
+      user_id: user_id,
+      section_id: section_id,
+      resource_id: resource_id,
+      annotated_resource_id: resource_id,
+      annotated_block_id: nil,
+      annotation_type: :none,
+      anonymous: true,
+      visibility: :public,
+      content: %Collaboration.PostContent{message: message}
+    })
+    |> Collaboration.create_post()
+  end
 end