diff --git a/src/modules/site-v2/base/views/api/trait.py b/src/modules/site-v2/base/views/api/trait.py
index ccc3080eb..55a789b2c 100644
--- a/src/modules/site-v2/base/views/api/trait.py
+++ b/src/modules/site-v2/base/views/api/trait.py
@@ -1,9 +1,20 @@
-from flask import request, Blueprint, abort
+import bleach
+from enum import Enum
+from functools import wraps
+import json
+
+from flask import request, Blueprint, abort, jsonify
 from caendr.services.logger import logger
-from extensions import cache
+from extensions import cache, compress
+
+from base.utils.auth import jwt_required, get_current_user, user_is_admin
 
-from caendr.models.datastore import TraitFile, Species
+from caendr.api.phenotype import query_phenotype_metadata, get_trait, filter_trait_query, get_trait_categories
+from caendr.services.cloud.postgresql import rollback_on_error_handler
+
+from caendr.models.datastore import Entity, TraitFile, Species, User
 from caendr.models.error     import NotFoundError
+from caendr.models.sql       import PhenotypeMetadata
 from caendr.utils.json       import jsonify_request
 
 
@@ -13,27 +24,340 @@
 
 
 
+#
+# Helper Classes
+#
+
+
+class EndpointType(Enum):
+  '''
+    Enum class for trait API endpoint types.
+    Requires endpoints to have the format "{ prefix }_{ value }", where `value` is one of the enum values.
+  '''
+
+  PUBLIC  = 'public'
+  PRIVATE = 'private'
+  ALL     = 'all'
+
+  @classmethod
+  def full(cls, endpoint_prefix, endpoint_type):
+    return f'{ api_trait_bp.name }.{ endpoint_prefix }_{ endpoint_type.value }'
+
+  @classmethod
+  def matches(cls, endpoint, endpoint_type):
+    return endpoint.split('_')[-1] == endpoint_type.value
+
+  @classmethod
+  def matches_any(cls, endpoint, endpoint_type_set):
+    return any( cls.matches(endpoint, endpoint_type) for endpoint_type in endpoint_type_set )
+
+
+
+#
+# Helper Functions
+#
+
+
 def filter_trait_files(tf):
   return tf.is_public and not tf.is_bulk_file
 
 
-@api_trait_bp.route('/all', methods=['GET'])
+def get_clean(source, key, value=None, _type=None):
+  v = source.get(key, value)
+
+  # Clean value
+  if   isinstance(v, str):   v = bleach.clean(v)
+  elif isinstance(v, list):  v = [ bleach.clean(x) for x in v ]
+
+  # Optional typecasting
+  if _type and v is not None:
+    if issubclass(_type, Entity):
+      v_entity = _type.get_ds(v)
+      if v_entity is None:
+        raise NotFoundError(_type, {'name': v})
+      v = v_entity
+    else:
+      v = _type(v)
+
+  return v
+
+
+def query_traits_error_handler(err_msg):
+  '''
+    Wrapper for trait query endpoints.
+
+    If the wrapped function aborts with an error code, that code will be used
+    by the response. Otherwise, based on the error type, either a `404` or a
+    `500` will be returned.
+  '''
+
+  def decorator(f):
+    @wraps(f)
+    def inner(*args, **kwargs):
+      try:
+        return f(*args, **kwargs)
+
+      # Error handling
+      except Exception as ex:
+
+        # Choose error code based on error type
+        if hasattr(ex, 'code'):
+          err_code = ex.code
+        elif isinstance(ex, NotFoundError):
+          err_code = 404
+        else:
+          err_code = 500
+
+        # Log the full error, and return the response with an abridged message
+        logger.error(f'{err_msg}: {ex}')
+        return {'message': f'{err_msg}'}, err_code
+
+    return inner
+  return decorator
+
+
+def validate_user():
+  '''
+    Validate that the requesting user can access the current endpoint.
+    Requires endpoint to be formatted according to `EndpointType` Enum.
+  '''
+
+  # On the "public" endpoint, no user validation required
+  if EndpointType.matches( request.endpoint, EndpointType.PUBLIC ):
+    return True
+
+  # On the "private" endpoint, user must be logged in
+  elif EndpointType.matches( request.endpoint, EndpointType.PRIVATE ):
+    return get_current_user() is not None
+
+  # On the "all" endpoint, user must be an admin
+  elif EndpointType.matches( request.endpoint, EndpointType.ALL ):
+    return user_is_admin()
+
+  # If some other endpoint is being requested here somehow, abort
+  abort(404)
+
+
+def validate_endpoint_type(endpoint_prefix):
+  '''
+    Validate that the user has permission to access this endpoint, based on the `EndpointType` schema.
+
+    See `validate_user` for details.
+  '''
+
+  def decorator(f):
+    @wraps(f)
+    def inner(*args, **kwargs):
+
+      # Validate that the current user has access to the specific endpoint they're requesting
+      if not validate_user():
+        abort(403)
+
+      return f(*args, **kwargs)
+
+    return inner
+  return decorator
+
+
+
+#
+# Query Endpoints: List Traits
+#
+
+
+@api_trait_bp.route('/list/sql/public',  endpoint='query_list_sql_public',  methods=['POST'])
+@api_trait_bp.route('/list/sql/private', endpoint='query_list_sql_private', methods=['POST'])
+@api_trait_bp.route('/list/sql/all',     endpoint='query_list_sql_all',     methods=['POST'])
 @cache.memoize(60*60)
+@jwt_required(optional=True)
+@validate_endpoint_type('query_list_sql')
+@query_traits_error_handler('Failed to retrieve the list of traits')
 @jsonify_request
-def query_all():
+def query_list_sql():
   '''
-    Query all trait files, optionally split into different lists based on species.
+    Query the trait database using SQL-style pagination.
+
+    Defines three separate endpoints:
+      - `public`:  Queries traits that have been submitted to the public phenotype database.
+      - `private`: Queries all traits that belong to the requesting user. Log-in required.
+      - `all`:     Queries all traits that have been uploaded. Admin users only.
+
+    Accepts the following URL variables to filter the request:
+      - `dataset`: The phenotype dataset.
+      - `species`: The species for the trait.
+      - `user`:    The user that submitted the trait.
+
+    Note that on the `private` endpoint, filtering the `user` parameter by anything other than
+    the current user will return no results, since the two user filters are exclusive.
+    This is still a syntactically valid request, but it is semantically invalid.
+  '''
+
+  # On the "private" endpoint, only consider traits belonging to the current user
+  if EndpointType.matches( request.endpoint, EndpointType.PRIVATE ):
+    current_user_filter = get_current_user()
+  else:
+    current_user_filter = None
+
+  # On the "private" and "all" endpoints, include private (unpublished) traits in the query
+  include_private_traits = EndpointType.matches_any( request.endpoint, { EndpointType.PRIVATE, EndpointType.ALL } )
+
+  # Get search parameters
+  selected_tags  = get_clean(request.json, 'selected_tags', [])
+  search_val     = get_clean(request.json, 'search_val',    '').lower()
+
+  # Get other query filters
+  try:
+    filter_dataset = get_clean(request.args, 'dataset')
+    filter_species = get_clean(request.args, 'species', _type=Species)
+    filter_user    = get_clean(request.args, 'user',    _type=User)
+  except NotFoundError as ex:
+    abort(422, description=ex.description)
+
+  # Get query pagination values
+  page           = get_clean(request.json, 'page',         1, _type=int)
+  current_page   = get_clean(request.json, 'current_page', 1, _type=int)
+  per_page       = 10
+
+  # Create the initial query
+  # The filters here determine which traits are part of the "full" query,
+  # based on the request endpoint
+  query = query_phenotype_metadata(
+    include_private=include_private_traits,
+    dataset=filter_dataset, user=current_user_filter,
+  )
+
+  # Filter by search values, if provided
+  query = filter_trait_query(
+    query, search_val=search_val, tags=selected_tags, species=filter_species, user=filter_user,
+  )
+
+  # Paginate the query, rolling back on error
+  with rollback_on_error_handler():
+    pagination = query.paginate(page=page, per_page=per_page)
+
+  # Format return data
+  return {
+    'data': [
+      tr.to_json() for tr in pagination.items
+    ],
+    'pagination': {
+      'has_next':     pagination.has_next,
+      'has_prev':     pagination.has_prev,
+      'prev_num':     pagination.prev_num,
+      'next_num':     pagination.next_num,
+      'total_pages':  pagination.pages,
+      'current_page': current_page
+    },
+  }
+
+
+
+@api_trait_bp.route('/list/datatable/public',  endpoint='query_list_datatable_public',  methods=['GET'])
+@api_trait_bp.route('/list/datatable/private', endpoint='query_list_datatable_private', methods=['GET'])
+@api_trait_bp.route('/list/datatable/all',     endpoint='query_list_datatable_all',     methods=['GET'])
+@cache.memoize(60*60)
+@jwt_required(optional=True)
+@validate_endpoint_type('query_list_datatable')
+@query_traits_error_handler('Failed to retrieve the list of traits')
+@jsonify_request
+def query_list_datatable():
   '''
+    Query the trait database using DataTable-style pagination.
+
+    Defines three separate endpoints:
+      - `public`:  Queries traits that have been submitted to the public phenotype database.
+      - `private`: Queries all traits that belong to the requesting user. Log-in required.
+      - `all`:     Queries all traits that have been uploaded. Admin users only.
+
+    Accepts the following URL variables to filter the request:
+      - `dataset`: The phenotype dataset.
+      - `species`: The species for the trait.
+      - `user`:    The user that submitted the trait.
+
+    Note that on the `private` endpoint, filtering the `user` parameter by anything other than
+    the current user will return no results, since the two user filters are exclusive.
+    This is still a syntactically valid request, but it is semantically invalid.
+  '''
+
+  # On the private endpoint, only consider traits belonging to the current user
+  if EndpointType.matches( request.endpoint, EndpointType.PRIVATE ):
+    current_user_filter = get_current_user()
+  else:
+    current_user_filter = None
+
+  # On the "private" and "all" endpoints, include private (unpublished) traits in the query
+  include_private_traits = EndpointType.matches_any( request.endpoint, { EndpointType.PRIVATE, EndpointType.ALL } )
+
+  # Load full search object from request
+  search_raw = get_clean(request.args, 'search[value]', '')
+  if search_raw:
+    try:
+      search_full = json.loads(search_raw)
+    except:
+      abort(422, description="Invalid search")
+
+    # Treat non-dict values as search strings
+    # Use the original raw string here so JSON casting doesn't change the value
+    # (e.g. JSON "true" becoming Python "True")
+    if not isinstance(search_full, dict):
+      search_full = { 'search_val': search_raw }
+
+  else:
+    search_full = {}
 
-  # Optionally split into an object w species names for keys
-  if request.args.get('split_by_species', False):
-    return {
-      species: [ tf.serialize() for tf in tf_list ]
-        for species, tf_list in TraitFile.query_ds_split_species(filter=filter_trait_files).items()
-    }
+  # Get search parameters from search object
+  search_value  = get_clean(search_full, 'search_val', '').lower()
+  selected_tags = get_clean(search_full, 'selected_tags', [])
+
+  # Get other query filters
+  try:
+    filter_dataset = get_clean(request.args, 'dataset')
+    filter_species = get_clean(request.args, 'species', _type=Species)
+    filter_user    = get_clean(request.args, 'user',    _type=User)
+  except NotFoundError as ex:
+    abort(422, description=ex.description)
+
+  # Get query pagination values
+  draw   = get_clean(request.args, 'draw',   _type=int)
+  start  = get_clean(request.args, 'start',  _type=int)
+  length = get_clean(request.args, 'length', _type=int)
+
+  # Create the initial query
+  # The filters here determine which traits are part of the "full" query,
+  # based on the request endpoint
+  query = query_phenotype_metadata(
+    include_private=include_private_traits,
+    dataset=filter_dataset, user=current_user_filter,
+  )
+
+  # Count the full size of the query
+  # Any rows filtered out before this line aren't available in this request at all,
+  # and any rows filtered out after this line are considered filtered rows in the full request
+  total_records = query.count()
+
+  # Filter by search values, if provided
+  query = filter_trait_query(
+    query, search_val=search_value, tags=selected_tags, species=filter_species, user=filter_user,
+  )
+
+  # Query PhenotypeMetadata (include phenotype values for each trait)
+  with rollback_on_error_handler():
+    data = query.offset(start).limit(length).from_self().\
+      join(PhenotypeMetadata.phenotype_values).all()
+
+  # Count how many rows matched the filters
+  filtered_records = query.count()
+
+  # Format return data
+  return {
+    'data': [
+      trait.to_json_with_values() for trait in data
+    ],
+    'draw':            draw,
+    'recordsTotal':    total_records,
+    'recordsFiltered': filtered_records,
+  }
 
-  # Otherwise, return all trait files in one list
-  return [ tf.serialize() for tf in TraitFile.query_ds(ignore_errs=True) if filter_trait_files(tf) ]
 
 
 @api_trait_bp.route('/<species_name>', methods=['GET'])
@@ -56,3 +380,51 @@ def query_species(species_name):
       for tf in TraitFile.query_ds(ignore_errs=True, filters=['species', '=', species.name])
       if filter_trait_files(tf)
   ]
+
+
+
+#
+# Query Endpoints: Single Trait
+#
+
+
+@api_trait_bp.route('/metadata', methods=['POST'])
+@cache.memoize(60*60)
+@compress.compressed()
+@query_traits_error_handler('Failed to retrieve trait metadata')
+@jsonify_request
+def query_trait_metadata():
+  """
+    Get traits data for non-bulk files in JSON format (include phenotype values)
+  """
+
+  # Get the trait name from the request
+  trait_id = get_clean(request.json, 'trait_id')
+  if not trait_id:
+    abort(400, description='No trait ID provided.')
+
+  # Try getting the trait from the database
+  trait = get_trait(trait_id)
+  if trait is None:
+    abort(404, description=f'Invalid trait ID {trait_id}')
+
+  # Return the full trait metadata
+  return trait.to_json_with_values()
+
+
+
+#
+# Query Endpoint: Trait Categories
+#
+
+
+@api_trait_bp.route('/categories', methods=['GET'])
+@cache.memoize(60*60)
+@compress.compressed()
+@query_traits_error_handler('Failed to retrieve trait categories')
+@jsonify_request
+def query_trait_categories():
+  """
+    Get list of trait categories.
+  """
+  return get_trait_categories()
diff --git a/src/modules/site-v2/base/views/tools/phenotype_database.py b/src/modules/site-v2/base/views/tools/phenotype_database.py
index e7b523d1f..66ac16073 100644
--- a/src/modules/site-v2/base/views/tools/phenotype_database.py
+++ b/src/modules/site-v2/base/views/tools/phenotype_database.py
@@ -12,7 +12,7 @@
 from extensions import cache, compress
 from sqlalchemy import or_, func
 
-from caendr.api.phenotype import query_phenotype_metadata, get_trait, filter_trait_query_by_text, filter_trait_query_by_tags
+from caendr.api.phenotype import query_phenotype_metadata, get_trait_categories
 from caendr.services.cloud.postgresql import rollback_on_error_handler
 
 from caendr.services.logger import logger
@@ -56,42 +56,11 @@ def phenotype_database():
     Phenotype Database table (non-bulk)
   """
   form = EmptyForm()
-  
-  # Get the list of traits for non-bulk files
+
+  # Get the list of unique tags
   try:
-    query = query_phenotype_metadata()
-
-    # Get the list of unique tags
-    tags = [ tr.tags.split(', ') for tr in query if tr.tags ]
-    tags_list = [tg for tr_tag in tags for tg in tr_tag]
-    unique_tags = list(set(tags_list))
-
-    if request.method == 'POST':
-      selected_tags = request.json.get('selected_tags', [])
-      search_val = request.json.get('search_val', '')
-      page = int(request.json.get('page', 1))
-      current_page = int(request.json.get('current_page', 1))
-      per_page = 10
-
-      # Filter by search value and tags, if provided
-      query = filter_trait_query_by_text(query, search_val)
-      query = filter_trait_query_by_tags(query, selected_tags)
-
-      # Paginate the query, rolling back on error
-      with rollback_on_error_handler():
-        pagination = query.paginate(page=page, per_page=per_page)
-
-      json_data = [ tr.to_json() for tr in pagination.items ]
-      pagination_data = {
-        'has_next':     pagination.has_next,
-        'has_prev':     pagination.has_prev,
-        'prev_num':     pagination.prev_num,
-        'next_num':     pagination.next_num,
-        'total_pages':  pagination.pages,
-        'current_page': current_page
-      }
-      return jsonify({'data': json_data, 'pagination': pagination_data })
-        
+    categories = get_trait_categories()
+
   except Exception as ex:
     logger.error(f'Failed to retrieve the list of traits: {ex}')
     abort(500, description='Failed to retrieve the list of traits')
@@ -102,73 +71,11 @@ def phenotype_database():
     "tool_alt_parent_breadcrumb": { "title": "Tools", "url": url_for('tools.tools') },
 
     # Data
-    'categories': unique_tags,
+    'categories': categories,
     'form': form
   })
 
 
-@phenotype_database_bp.route('/traits-zhang')
-@cache.memoize(60*60)
-@compress.compressed()
-def get_zhang_traits_json():
-  """
-    Phenotype Database table (bulk)
-    Fetch table content by request for each page and render the data for Datatables()
-  """
-  try:
-    # get parameters for query
-    draw = request.args.get('draw', type=int)
-    start = request.args.get('start', type=int)
-    length = request.args.get('length', type=int)
-    search_value = bleach.clean(request.args.get('search[value]', '')).lower()
-
-    query = query_phenotype_metadata(is_bulk_file=True)
-    total_records = query.count()
-
-    # Filter by search value, if provided
-    query = filter_trait_query_by_text(query, search_value)
-
-    # Query PhenotypeMetadata (include phenotype values for each trait)
-    with rollback_on_error_handler():
-      data = query.offset(start).limit(length).from_self().\
-        join(PhenotypeMetadata.phenotype_values).all()
-
-    json_data = [ trait.to_json_with_values() for trait in data ]
-
-    filtered_records = query.count()
-
-    response_data = {
-        "draw": draw,
-        "recordsTotal": total_records,
-        "recordsFiltered": filtered_records,
-        "data": json_data
-    }
-
-  except Exception as ex:
-    logger.error(f'Failed to retrieve the list of traits: {ex}')
-    response_data = []
-  return jsonify(response_data)
-
-@phenotype_database_bp.route('/traits-list', methods=['POST'])
-@cache.memoize(60*60)
-@compress.compressed()
-def get_traits_json():
-  """
-    Get traits data for non-bulk files in JSON format (include phenotype values)
-  """
-  trait_id = request.json.get('trait_id')
-  err_msg = f'Failed to retrieve metadata for trait {trait_id}'
-
-  if trait_id:
-    try:
-      trait = get_trait(trait_id).to_json_with_values()
-      return jsonify(trait)
-
-    except Exception as ex:
-      logger.error(f'{err_msg}: {ex}')
-      
-  return jsonify({ 'message': err_msg }), 404
-
 
 #
 # Submission Flow
@@ -191,14 +98,13 @@ def submit_traits():
 
   # Check for URL vars specifying an initial trait
   # These will be inherited from submit_start
-  initial_trait_name = request.args.get('trait')
-  initial_trait_set  = request.args.get('dataset')
+  initial_trait_id = request.args.get('trait')
 
   # Try looking up the specified trait
-  if initial_trait_name:
+  if initial_trait_id:
     try:
-      initial_trait = Trait(dataset=initial_trait_set, trait_name=initial_trait_name)
-    except NotFoundError:
+      initial_trait = Trait.from_id(initial_trait_id)
+    except (NotFoundError, ValueError):
       flash('That trait could not be found.', 'danger')
       initial_trait = None
   else:
diff --git a/src/modules/site-v2/templates/_includes/phenotype-database-table.html b/src/modules/site-v2/templates/_includes/phenotype-database-table.html
index d8f659dbc..69bc7140d 100644
--- a/src/modules/site-v2/templates/_includes/phenotype-database-table.html
+++ b/src/modules/site-v2/templates/_includes/phenotype-database-table.html
@@ -21,6 +21,10 @@
 </style>
 {% endblock %}
 
+
+{% set offcanvas_id = 'phenotype-offcanvas' %}
+
+
 <nav>
     <div class="nav nav-tabs border-1" id="nav-tab" role="tablist">
         <button class="nav-link active" id="nav-home-tab" data-bs-toggle="tab" data-bs-target="#nav-home" type="button"
@@ -31,31 +35,8 @@
 </nav>
 <div class="tab-content py-2" id="nav-tabContent">
     <div class="tab-pane fade show active" id="nav-home" role="tabpanel" aria-labelledby="nav-home-tab">
-        <div class="d-flex flex-wrap justify-content-between my-5">
-            <div class="col-12 col-md-3 mx-1 mb-3 mb-md-0">
-                <form>
-                    <label for="traitsSearch" class="form-label"><i class="bi bi-search"></i> Search:</label>
-                    <div class="input-wrapper">
-                        <input type="text" class="form-control" name="traitsSearch" id="traitsSearch">
-                        <i class="bi bi-x-circle-fill" id="clearSearch"></i>
-                    </div>
-                </form>
-        </div>
-            <div class="col-12 col-md-8 mx-1 align-self-end mb-0">
-                <div class="d-flex flex-wrap justify-content-center justify-content-md-end mt-3 mt-md-0" role="menu" id="tagsFilter">
-                    <input type="hidden" id="csrf_token" name="csrf_token" value="{{ csrf_token() }}" />
-                    {% for tag in categories %}
-                    <div class="d-flex align-items-center mx-2 mb-3">
-                        <input type="checkbox" class="custom-control-input me-1 filterCheckbox" value="{{tag}}" id="{{tag}}">
-                        <label class="custom-check-label" for="{{tag}}">{{tag|replace('/', ' • ')}}</label>
-                    </div>
-                    {% endfor %}
-                    <div class="d-flex mx-2 mb-3">
-                        <a class="fw-bold" role="button" id="clearAll">Clear All<i class="bi bi-x-circle-fill ms-1" aria-hidden="true"></i></a>
-                    </div>
-                </div>
-            </div>
-        </div>
+        <input type="hidden" id="csrf_token" name="csrf_token" value="{{ csrf_token() }}" />
+        {% include "_includes/phenotype-search-bar.html" %}
         <div class="table-responsive">
             <table class="table accordion p-0 text-center" id="tableAccordion">
                 <caption class="visually-hidden">A list of phenotype traits.</caption>
@@ -101,29 +82,17 @@
 </div>
 
 <!-- Offcanvas -->
-<div class="offcanvas offcanvas-end offcanvasPhenotype" tabindex="-1" id="offcanvas1"
-    aria-labelledby="offcanvas1Label">
-    <div id='spinner' class="d-flex flex-column align-items-center d-none">
-        <div class="m-5 spinner-border" style="width: 4rem; height: 4rem;" role="status"></div>
-      </div>
-    <div class="offcanvas-header">
-        <div>
-            <h1 class="h5">
-                <span id="offcanvas1-header-1" class="d-block mb-1"></span>
-                <span id="offcanvas1-header-2" class="d-block text-dark fw-normal"></span>
-                <span class="d-block text-dark fw-normal"><em id="offcanvas1-header-3"></em></span>
-            </h1>
-        </div>
-        <button type="button" class="btn-close text-reset" data-bs-dismiss="offcanvas" aria-label="Close"></button>
-    </div>
-    <div class="offcanvas-body p-4">
-        {% include "_includes/phenotype-offcanvas-content.html" %}
-    </div>
+<div class="offcanvas offcanvas-end offcanvasPhenotype" tabindex="-1" id="{{ offcanvas_id }}"
+    aria-labelledby="{{ offcanvas_id }}-label">
+    {% include "_includes/phenotype-offcanvas-content.html" %}
 </div>
+{# /Offcanvas #}
+
+
 
 {% block script %}
 <script>
-    {% include '_scripts/utils.js' %}       {#/* defines: flash_message */#}
+    {% include '_scripts/utils.js' %}       {#/* defines: flash_message, format_date, first_letter_caps */#}
     {% include '_scripts/trait_utils.js' %} {#/* defines: traitNameHTML, queryTraitByName */#}
 
     $(document).ready(function() {
@@ -133,8 +102,8 @@ <h1 class="h5">
                 if (!/^(GET|HEAD|OPTIONS|TRACE)$/i.test(settings.type) && !this.crossDomain) {
                     xhr.setRequestHeader("X-CSRFToken", "{{ form.csrf_token._value() }}")
                 }
-                }
-            });
+            }
+        });
 
         // Render first load results
         getResultsForPage(1, 1)
@@ -143,42 +112,46 @@ <h1 class="h5">
         const zhangTable = $('#zhangTraits').DataTable( {
             "processing": true,
             "serverSide": true,
-            "ajax": "/tools/phenotype-database/traits-zhang",
+            "ajax": "{{ url_for('api_trait.query_list_datatable_public', dataset='zhang') }}",
             "ordering": false,
             "columns": [
                 {
-                    "data": "Species",
+                    "data": "species_name",
                     "render": function(data, type, row) {
-                        return row.species_name.replace('c_', 'C. ').italics()
+                        return first_letter_caps(data).replace('_', '. ').italics();
                     }
                 },
                 {"data": "trait_name_caendr"},
-                {"data": "description_long"},
                 {
-                    "data": "Upload Date",
+                    "data": "description_long",
+                    // TODO: Should this be Markdown?
+                    // "render": function(data, type, row) {
+                    //     return markdownToHTML(data);
+                    // },
+                },
+                {
+                    "data": "created_on",
                     "render": function(data, type, row) {
-                        return formatDate(row.created_on)
+                        return formatDate(data)
                     }
                 },
                 {
-                    "data": "View Full Details",
                     "render": function(data, type, row) {
                         const d = JSON.stringify(row)
                         return `<td>
                             <div class="optionsToolbar">
-                            <a id="details" data-value='${d}' data-bs-toggle="offcanvas" data-bs-target="#offcanvas1" aria-controls="offcanvas1" 
+                            <a id="details" data-value='${d}' data-bs-toggle="offcanvas" data-bs-target="#{{ offcanvas_id }}" aria-controls="{{ offcanvas_id }}"
                             href="#"><i class="bi bi-list-ul" aria-hidden="true"></i>Full Details</a>
                             </div>
                             </td>`
                         }
                 },
                 {
-                    "data": "Analyze",
+                    "data": "id",
                     "render": function(data, type, row) {
-                        const trait_name = row.trait_name_caendr;
-                        const url = '{{ analyze_link | safe }}'.replace("TRAIT_NAME", trait_name).replace("TRAIT_SET", 'zhang');
+                        const url = '{{ analyze_link | safe }}'.replace("TRAIT_NAME", data);
                         return `
-                            <div id="trait-data-${row.trait_name_caendr}" class="ps-3 pt-0">
+                            <div id="trait-data-${data}" class="ps-3 pt-0">
                                 <a href='${url}'><i class="bi bi-arrow-right-circle-fill" aria-hidden="true"></i>Analyze</a>
                             </div>`
                     },
@@ -195,113 +168,64 @@ <h1 class="h5">
 
         // Fetch data for a trait and fill out side bar for non-bulk traits
         $(document).on('click','#traitDetails', function() {
-            $('.offcanvas-header, .offcanvas-body').hide()
-            $('#spinner').removeClass('d-none')
-            const data = {csrf_token: $('#csrf_token').val(), trait_id: $(this).data('value')}
-            $.ajax({
-                type: "POST",
-                url: "{{ url_for('phenotype_database.get_traits_json') }}",
-                data: JSON.stringify(data),
-                contentType: "application/json",
-                dataType: "json",
-                success: function(response) {
-                    $('#spinner').addClass('d-none')
-                    $('.offcanvas-header, .offcanvas-body').show()
+            const offcanvas_content = $('#{{ offcanvas_id }}-header, #{{ offcanvas_id }}-body');
+            const offcanvas_spinner = $('#{{ offcanvas_id }}-spinner');
+
+            // Show the loader
+            offcanvas_content.hide()
+            offcanvas_spinner.removeClass('d-none')
+
+            // Query data for the given trait
             queryTraitByName($(this).data('value'), $('#csrf_token').val())
+
+                // On success, fill out and show the offcanvas content
                 .then((response) => {
+                    offcanvas_spinner.addClass('d-none')
+                    offcanvas_content.show()
                     fillOutModal(response)
                 })
+
+                // On failure, close the offcanvas item and flash the error (if given)
                 .fail((error) => {
                     console.error(error)
-                    $('#offcanvas1 .btn-close').click()
-                    $('html').animate({
-                        scrollTop: $('body').offset().top
-                    }, 100);
-                    if (error.responseJSON && error.responseJSON.message) {
-                        $('.alert').remove()
-                        flash_message(error.responseJSON.message)
-                    }
+                    $('#{{ offcanvas_id }} .btn-close').click()
+                    flashErrorResponse(error.responseJSON, 'There was a problem retrieving this trait. Please try again later.')
                 })
         })
 
 
-        
-        // Handle the Categories filter
-        $(document).on( "change", "input[type=checkbox]", function () {
-            if ($(this).attr('id') !== 'selectAll') {
-                $('#selectAll').prop('checked', false)
-            }
-            search()
-        })
-
-        $('#selectAll').on('change', function() {
-            if ($(this).is(':checked')) {
-                $('.filterCheckbox').prop('checked', true)
-            } else {
-                $('.filterCheckbox').prop('checked', false)
-            }
-        })
-
-        // Clear all filters for Categories
-        $("#clearAll").on('click', function() {
-            $('input[type=checkbox]').prop('checked', false)
-            search()
-        })
-
-        // Handle search bar
-        $("#traitsSearch").on('keyup', function(){
-            search()
-        })
-
-        // Clear search bar and reset the table
-        $("#clearSearch").on('click', function() {
-            $("#traitsSearch").val('')
-            search()
-        })
-
         // Filter table by tag links
+        // Dispatches event for search bar to handle
         $('#tableAccordion').on('click', '[id^="tagLink"]', function() {
             const tagVal = $(this).data('value')
-            const filterTag = $("input[type=checkbox]").filter(function(){
-                return $(this).attr('value') === tagVal
-            })
-            filterTag.prop('checked', true)
-            search()
+            document.dispatchEvent(new CustomEvent('phenotype-table-update-tag', {
+                'detail': { tagVal },
+            }));
         })
 
-        // Prevent 'enter' key from reloading the page
-        $('#traitsSearch').closest('form').on('submit', function(e){
-            e.preventDefault();
-        });
     })
 
-    // Filter table by Search input and Categories
-    async function search() {
-        const checkedTagsSelector = $(".filterCheckbox:checked")
-        let selectedTags = []
-        if (checkedTagsSelector.length) {
-            selectedTags = $(".filterCheckbox:checked").map(function() {
-                return $(this).val()
-            }).get()
-        }
-        const data = {csrf_token: $('#csrf_token').val(), search_val: $("#traitsSearch").val(), selected_tags: selectedTags}
+    // Update search based on search widget
+    document.addEventListener('phenotype-table-search', async ({detail}) => {
         try {
-            const res = await sendPostRequest(data)
+            const res = await sendPostRequest(detail)
             return handlePostRequest(res)
         } catch(err) {
             console.error(err)
             flash_message(`Failed to retrieve the list of traits: ${err.statusText}`)
         }
-    }
+    });
 
     async function sendPostRequest(data) {
-        const resp = await fetch("{{ url_for('phenotype_database.phenotype_database') }}", {
+        const csrf_token = $("#csrf_token").val();
+
+        const resp = await fetch("{{ url_for('api_trait.query_list_sql_public', dataset='caendr') }}", {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
-                'X-CSRF-TOKEN': data.csrf_token
+                'X-CSRF-TOKEN': csrf_token
             },
-            body: JSON.stringify(data)
+            body: JSON.stringify({...data, csrf_token}),
         })
 
         if (resp.ok) {
@@ -316,9 +240,8 @@ <h1 class="h5">
     // Fill out table for non-bulk traits
     function filterTable(arr) {
         for (let i = 0; i < arr.length; i++) {
-            const speciesName = arr[i].species_name.charAt(0).toUpperCase() + arr[i].species_name.replace('_', '. ').slice(1)
-            const traitName = arr[i].trait_name_caendr
-            let url = '{{ analyze_link | safe }}'.replace("TRAIT_NAME", traitName).replace("TRAIT_SET", 'caendr')
+            const speciesName = first_letter_caps(arr[i].species_name).replace('_', '. ').italics();
+            const traitID = arr[i].id
             const createdOn = formatDate(arr[i].created_on)
             let tagsHTML = ''
             if (arr[i].tags !== null && arr[i].tags.length) {
@@ -327,6 +250,8 @@ <h1 class="h5">
                     tagsHTML += `<div class="mb-3"><a role="button" class="btn btn-link" id="tagLink-${j+1}" data-value="${tags[j]}">${tags[j].replaceAll('/', ' • ')}</a></div>`
                 }
             }
+
+            const url = '{{ analyze_link | safe }}'.replace("TRAIT_NAME", traitID);
             
             let html = `
                     <tr class="py-3 dislayedRow">
@@ -343,7 +268,7 @@ <h1 class="h5">
                         <td>${createdOn}</td>
                         <td class="d-flex-row flex-column" id="tags">${tagsHTML}</td>
                         <td class="optionsToolbar">
-                            <div class="ps-3 pt-0" id="trait-data-${arr[i].trait_name_caendr}"><a href='${url}'><i class="bi bi-arrow-right-circle-fill"
+                            <div class="ps-3 pt-0" id="trait-data-${ traitID }"><a href='${url}'><i class="bi bi-arrow-right-circle-fill"
                                         aria-hidden="true"></i>Analyze</a></div>
                         </td>
                     </tr>
@@ -355,8 +280,8 @@ <h3 class="h5 text-dark">Full Description</h3>
                                 <p>${arr[i].description_long}</p>
                             </div>
                             <div class="d-flex justify-content-end me-1 pb-3 optionsToolbar">
-                                <a data-bs-toggle="offcanvas" id="traitDetails" data-value="${arr[i].id}" data-bs-target="#offcanvas1"
-                                    aria-controls="offcanvas1" href=" #"><i class="bi bi-arrow-right"
+                                <a data-bs-toggle="offcanvas" id="traitDetails" data-value="${ traitID }" data-bs-target="#{{ offcanvas_id }}"
+                                    aria-controls="{{ offcanvas_id }}" href=" #"><i class="bi bi-arrow-right"
                                         aria-hidden="true"></i>View Full Details</a>
                             </div>
                         </td>
@@ -435,94 +360,9 @@ <h3 class="h5 text-dark">Full Description</h3>
     }
 
     function fillOutModal(trait) {
-        let traitName = ''
-        if (trait.dataset === 'zhang') {
-            traitName = trait.trait_name_caendr
-        } else {
-            traitName = trait.trait_name_display_1 + ' ' + trait.trait_name_display_2 + ' ' + trait.trait_name_display_3
-        }
-        $('#offcanvas1Label').text(traitName)
-        manageVal(trait.capture_date, '#captureDate', true)
-        manageVal(trait.created_on, '#createdOn', true)
-        manageVal(trait.modified_on, '#modifiedOn', true)
-        manageVal(trait.species_name, '#species')
-        manageVal(trait.wbgene_id, '#wbgeneID')
-        manageVal(trait.source_lab, '#sourceLab')
-        manageVal(trait.institution, '#institution')
-        manageVal(trait.submitted_by, '#submittedBy')
-        manageVal(trait.description_long, '#descriptionLong')
-        manageVal(trait.protocols, '#protocol', false, true)
-        manageVal(trait.publication, '#publication', false, true)
-        $('#offcanvas1 #tags').empty()
-        if (trait.tags !== null || (trait.tags && trait.tags.length)) {
-            $('#offcanvas1 #tags').prev().show()
-            $('#offcanvas1 #tags').append(displayTags(trait.tags.split(', ')))
-        } else {
-            $('#offcanvas1 #tags').prev().hide()
-        }
-        $('#values > tbody').empty()
-        if (trait.phenotype_values.length) {
-            $('#values').parent().prev().show()
-            $('#values').parent().show()
-            $('#values > tbody').append(populateValues(trait.phenotype_values))
-        } else {
-            $('#values').parent().prev().hide()
-            $('#values').parent().hide()
-        }
-    }
-
-    // The function populates phenotype values in the table inside the side bar.
-    function populateValues(arr) {
-        let result = ''
-        for (let i = 0; i < arr.length; i++) {
-            result += `<tr><td>${arr[i].strain_name}</td><td>${arr[i].trait_value}</td></tr>`
-        }
-        return result
-    }
-
-    // The function populates Categories field in the side bar
-    function displayTags(arr) {
-        if (arr == null) return;
-        let result = ''
-        for (tag of arr) {
-            result += `<div class="mb-3">${tag.replaceAll('/', ' • ')}</div>`
-        }
-        return result
-    }
-
-    function formatDate(d) {
-        if(d === null) return 'N/A'
-        const date = new Date(d)
-        const month = (date.getMonth()+1).toString().padStart(2, '0')
-        const day = date.getDate().toString().padStart(2, '0')
-        return `${date.getFullYear()}-${month}-${day}`
-    }
-
-    // The function manages the fields in the side bar. 
-    // If a field has a value the field will be displayed, if not - it will be hidden
-    function manageVal(d, id, isDate=false, isLink=false) {
-        if (id === '#species') {
-            d = d[0].toUpperCase() + '. ' + d.slice(2)
-        }
-        const hasValue = !(d === null || d === 'N/A' || !d.length )
-        if (hasValue && isDate) {
-            $(id).parent().show()
-            $(id).text(formatDate(d))
-        } else if (!hasValue && isDate) {
-            $(id).parent().hide()
-        } else if (hasValue && isLink) {
-            $(id).prev().show()
-            $(`${id} > a`).text(d)
-        } else if (!hasValue && isLink) {
-            $(`${id} > a`).text('')
-            $(id).prev().hide()
-        } else if (hasValue && !isDate && !isLink) {
-            $(id).prev().show()
-            $(id).text(d)
-        } else if (!hasValue && !isDate && !isLink) {
-            $(id).text('')
-            $(id).prev().hide()
-        }
+        document.dispatchEvent(new CustomEvent('phenotype-offcanvas-content', {
+            detail: { offcanvas_id: '{{offcanvas_id}}', trait: trait },
+        }));
     }
 
 </script>
diff --git a/src/modules/site-v2/templates/_includes/phenotype-offcanvas-content.html b/src/modules/site-v2/templates/_includes/phenotype-offcanvas-content.html
index 7e033b18c..58c21e5b1 100644
--- a/src/modules/site-v2/templates/_includes/phenotype-offcanvas-content.html
+++ b/src/modules/site-v2/templates/_includes/phenotype-offcanvas-content.html
@@ -1,48 +1,169 @@
-<div class="d-flex">
-    <div class="col-4">
-        <h2 class="h6 text-dark mb-3">Capture Date</h2>
-        <p id="captureDate"></p>
-    </div>
-    <div class="col-4">
-        <h2 class="h6 text-dark mb-3">Upload Date</h2>
-        <p id="createdOn"></p>
-    </div>
-    <div class="col-4">
-        <h2 class="h6 text-dark mb-3">Last Updated</h2>
-        <p id="modifiedOn"></p>
+{% if offcanvas_id is not defined %}
+    {% set offcanvas_id = "phenotype-offcanvas" %}
+{% endif %}
+
+<div id='{{ offcanvas_id }}-spinner' class="d-flex flex-column align-items-center d-none">
+    <div class="m-5 spinner-border" style="width: 4rem; height: 4rem;" role="status"></div>
+</div>
+
+<div id="{{ offcanvas_id }}-header" class="offcanvas-header">
+    <div>
+        <h1 class="h5">
+            <span id="{{ offcanvas_id }}-header-1" class="d-block mb-1"></span>
+            <span id="{{ offcanvas_id }}-header-2" class="d-block text-dark fw-normal"></span>
+            <span class="d-block text-dark fw-normal"><em id="{{ offcanvas_id }}-header-3"></em></span>
+        </h1>
     </div>
+    <button type="button" class="btn-close text-reset" data-bs-dismiss="offcanvas" aria-label="Close"></button>
 </div>
-<div>
-    <h2 class="h6 text-dark mb-3">Species</h2>
-    <p><em id="species"></em></p>
-    <h2 class="h6 text-dark mb-3">WormBaseGeneID</h2>
-    <p id="wbgeneID"></p>
-    <h2 class="h6 text-dark mb-3">Source Lab</h2>
-    <p id="sourceLab"></p>
-    <h2 class="h6 text-dark mb-3">Institution</h2>
-    <p id="institution"></p>
-    <h2 class="h6 text-dark mb-3">Submitted By</h2>
-    <p id="submittedBy"></p>
-    <h2 class="h6 text-dark mb-3">Full Description</h2>
-    <p id="descriptionLong"></p>
-    <h2 class="h6 text-dark mb-3">Protocol</h2>
-    <p id="protocol"><a href="#" target="_blank"></a></p>
-    <h2 class="h6 text-dark mb-3">Publication</h2>
-    <p id="publication"><a href="#" target="_blank"></a></p>
-    <h2 class="h6 text-dark mb-3">Categories</h2>
-    <div id="tags" class="d-flex flex-column px-4"></div>
-    <div class="mt-5">
-        <h2 class="h6 text-dark mb-3">Values</h2>
-        <div class="my-4 border border-1 rounded overflow-auto" style="height:30vh">
-            <table class="table table-hover mb-0" id="values">
-                <thead class="table-secondary" style="position:sticky;top:0;">
-                    <tr>
-                        <th scope="col">Strain</th>
-                        <th scope="col">Value</th>
-                    </tr>
-                </thead>
-                <tbody></tbody>
-            </table>
+
+<div id="{{ offcanvas_id }}-body" class="offcanvas-body p-4">
+    <div class="d-flex">
+        <div class="col-4">
+            <h2 class="h6 text-dark mb-3">Capture Date</h2>
+            <p id="{{offcanvas_id}}-captureDate"></p>
+        </div>
+        <div class="col-4">
+            <h2 class="h6 text-dark mb-3">Upload Date</h2>
+            <p id="{{offcanvas_id}}-createdOn"></p>
+        </div>
+        <div class="col-4">
+            <h2 class="h6 text-dark mb-3">Last Updated</h2>
+            <p id="{{offcanvas_id}}-modifiedOn"></p>
+        </div>
+    </div>
+    <div>
+        <h2 class="h6 text-dark mb-3">Species</h2>
+        <p><em id="{{offcanvas_id}}-species"></em></p>
+        <h2 class="h6 text-dark mb-3">WormBaseGeneID</h2>
+        <p id="{{offcanvas_id}}-wbgeneID"></p>
+        <h2 class="h6 text-dark mb-3">Source Lab</h2>
+        <p id="{{offcanvas_id}}-sourceLab"></p>
+        <h2 class="h6 text-dark mb-3">Institution</h2>
+        <p id="{{offcanvas_id}}-institution"></p>
+        <h2 class="h6 text-dark mb-3">Submitted By</h2>
+        <p id="{{offcanvas_id}}-submittedBy"></p>
+        <h2 class="h6 text-dark mb-3">Full Description</h2>
+        <p id="{{offcanvas_id}}-descriptionLong"></p>
+        <h2 class="h6 text-dark mb-3">Protocol</h2>
+        <p id="{{offcanvas_id}}-protocol"><a href="#" target="_blank"></a></p>
+        <h2 class="h6 text-dark mb-3">Publication</h2>
+        <p id="publication"><a href="#" target="_blank"></a></p>
+        <h2 class="h6 text-dark mb-3">Categories</h2>
+        <div id="{{offcanvas_id}}-tags" class="d-flex flex-column px-4"></div>
+        <div class="mt-5">
+            <h2 class="h6 text-dark mb-3">Values</h2>
+            <div class="my-4 border border-1 rounded overflow-auto" style="height:30vh">
+                <table class="table table-hover mb-0" id="{{offcanvas_id}}-values">
+                    <thead class="table-secondary" style="position:sticky;top:0;">
+                        <tr>
+                            <th scope="col">Strain</th>
+                            <th scope="col">Value</th>
+                        </tr>
+                    </thead>
+                    <tbody></tbody>
+                </table>
+            </div>
         </div>
     </div>
-</div>
\ No newline at end of file
+</div>
+
+<script type="module">
+    {% include '_scripts/utils.js' %} {#/* defines: format_date */#}
+
+    // Add event listener
+    // Only fills out offcanvas content if the ID matches
+    document.addEventListener('phenotype-offcanvas-content', ({detail}) => {
+        if (detail.offcanvas_id == '{{ offcanvas_id }}') {
+            fillOutModal(detail.trait);
+        }
+    });
+
+    // Main update function
+    function fillOutModal(trait) {
+
+        // Fill out header
+        $('#{{ offcanvas_id }}-header-1').text(trait.trait_name_display_1)
+        $('#{{ offcanvas_id }}-header-2').text(trait.trait_name_display_2)
+        $('#{{ offcanvas_id }}-header-3').text(trait.trait_name_display_3)
+
+        // Fill out basic fields
+        manageVal(trait.capture_date,     '#{{ offcanvas_id }}-captureDate', true)
+        manageVal(trait.created_on,       '#{{ offcanvas_id }}-createdOn',   true)
+        manageVal(trait.modified_on,      '#{{ offcanvas_id }}-modifiedOn',  true)
+        manageVal(trait.species_name,     '#{{ offcanvas_id }}-species')
+        manageVal(trait.wbgene_id,        '#{{ offcanvas_id }}-wbgeneID')
+        manageVal(trait.source_lab,       '#{{ offcanvas_id }}-sourceLab')
+        manageVal(trait.institution,      '#{{ offcanvas_id }}-institution')
+        manageVal(trait.submitted_by,     '#{{ offcanvas_id }}-submittedBy')
+        manageVal(trait.description_long, '#{{ offcanvas_id }}-descriptionLong')
+        manageVal(trait.protocols,        '#{{ offcanvas_id }}-protocol',    false, true)
+        manageVal(trait.publication,      '#{{ offcanvas_id }}-publication', false, true)
+
+        // Fill out tags
+        $('#{{ offcanvas_id }}-tags').empty()
+        if (trait.tags !== null || (trait.tags && trait.tags.length)) {
+            $('#{{ offcanvas_id }}-tags').prev().show()
+            $('#{{ offcanvas_id }}-tags').append(displayTags(trait.tags.split(', ')))
+        } else {
+            $('#{{ offcanvas_id }}-tags').prev().hide()
+        }
+
+        // Fill out data values
+        $('#{{ offcanvas_id }}-values > tbody').empty()
+        if (trait.phenotype_values.length) {
+            $('#{{ offcanvas_id }}-values').parent().prev().show()
+            $('#{{ offcanvas_id }}-values').parent().show()
+            $('#{{ offcanvas_id }}-values > tbody').append(populateValues(trait.phenotype_values))
+        } else {
+            $('#{{ offcanvas_id }}-values').parent().prev().hide()
+            $('#{{ offcanvas_id }}-values').parent().hide()
+        }
+    }
+
+    // The function populates phenotype values in the table inside the side bar.
+    function populateValues(arr) {
+        let result = ''
+        for (let i = 0; i < arr.length; i++) {
+            result += `<tr><td>${arr[i].strain_name}</td><td>${arr[i].trait_value}</td></tr>`
+        }
+        return result
+    }
+
+    // The function populates Categories field in the side bar
+    function displayTags(arr) {
+        if (arr == null) return;
+        let result = ''
+        for (let tag of arr) {
+            result += `<div class="mb-3">${tag.replaceAll('/', ' • ')}</div>`
+        }
+        return result
+    }
+
+    // The function manages the fields in the side bar.
+    // If a field has a value the field will be displayed, if not - it will be hidden
+    function manageVal(d, id, isDate=false, isLink=false) {
+        if (id === '#{{ offcanvas_id }}-species') {
+            d = d[0].toUpperCase() + '. ' + d.slice(2)
+        }
+        const hasValue = !(d === null || d === 'N/A' || !d.length )
+        if (hasValue && isDate) {
+            $(id).parent().show()
+            $(id).text(formatDate(d))
+        } else if (!hasValue && isDate) {
+            $(id).parent().hide()
+        } else if (hasValue && isLink) {
+            $(id).prev().show()
+            $(`${id} > a`).text(d)
+        } else if (!hasValue && isLink) {
+            $(`${id} > a`).text('')
+            $(id).prev().hide()
+        } else if (hasValue && !isDate && !isLink) {
+            $(id).prev().show()
+            $(id).text(d)
+        } else if (!hasValue && !isDate && !isLink) {
+            $(id).text('')
+            $(id).prev().hide()
+        }
+    }
+</script>
diff --git a/src/modules/site-v2/templates/_includes/phenotype-search-bar.html b/src/modules/site-v2/templates/_includes/phenotype-search-bar.html
new file mode 100644
index 000000000..216942fdb
--- /dev/null
+++ b/src/modules/site-v2/templates/_includes/phenotype-search-bar.html
@@ -0,0 +1,125 @@
+{% if table_id is not defined %}
+  {% set table_id = "phenotype-table" %}
+{% endif %}
+
+
+<div id="{{ table_id }}-search-container" class="d-flex flex-wrap justify-content-between my-5">
+
+  <!-- Keyword Search -->
+  <div class="col-12 col-md-3 mx-1 mb-3 mb-md-0">
+    <form>
+      <label for="{{ table_id }}-trait-search" class="form-label"><i class="bi bi-search"></i> Search:</label>
+      <div class="input-wrapper">
+        <input id="{{ table_id }}-trait-search" name="trait-search" type="text" class="form-control">
+        <i class="bi bi-x-circle-fill" id="{{ table_id }}-clear-search"></i>
+      </div>
+    </form>
+  </div>
+  <!-- /Keyword Search -->
+
+  <!-- Tag Search -->
+  <div class="col-12 col-md-8 mx-1 align-self-end mb-0">
+    <div id="{{ table_id }}-tags-filter" class="d-flex flex-wrap justify-content-center justify-content-md-end mt-3 mt-md-0" role="menu">
+      {% for tag in categories %}
+      <div class="d-flex align-items-center mx-2 mb-3">
+        <input id="{{ table_id }}-tag-{{ tag }}" type="checkbox" class="custom-control-input me-1 filterCheckbox" value="{{tag}}">
+        <label class="custom-check-label" for="{{tag}}">{{tag|replace('/', ' • ')}}</label>
+      </div>
+      {% endfor %}
+      <div class="d-flex mx-2 mb-3">
+        <a id="{{ table_id }}-clear-all-tags" class="fw-bold" role="button">Clear All<i class="bi bi-x-circle-fill ms-1" aria-hidden="true"></i></a>
+      </div>
+    </div>
+  </div>
+  <!-- /Tag Search -->
+
+</div>
+
+
+<script type="module">
+
+
+  // Main search function
+  function search() {
+
+    // Compile list of checked tags
+    const checkedTagsSelector = $("#{{ table_id }}-tags-filter .filterCheckbox:checked")
+    let selectedTags = []
+    if (checkedTagsSelector.length) {
+      selectedTags = checkedTagsSelector.map(function() {
+        return $(this).val()
+      }).get()
+    }
+
+    // Broadcast the new search terms
+    document.dispatchEvent(new CustomEvent('{{ table_id }}-search', {
+      "detail": {
+        "search_val":    $("#{{ table_id }}-trait-search").val(),
+        "selected_tags": selectedTags,
+      },
+    }));
+  }
+
+
+  // Update checked tags via event
+  document.addEventListener("{{table_id}}-update-tag", ({detail}) => {
+    const filterTag = $("#{{ table_id }}-tags-filter input[type=checkbox]").filter(function() {
+      console.log( $(this).attr('value'), detail.tagVal );
+      return $(this).attr('value') === detail.tagVal;
+    })
+    filterTag.prop('checked', true);
+    search();
+  })
+
+
+  $(document).ready(function() {
+
+    /* Category Tags */
+
+    // Handle the Categories filter
+    $(document).on( "change", "#{{ table_id }}-tags-filter input[type=checkbox]", function () {
+      if ($(this).attr('id') !== '{{ table_id }}-select-all') {
+        $('#{{ table_id }}-select-all').prop('checked', false)
+      }
+      search();
+    });
+
+    // Select all categories
+    $('#{{ table_id }}-select-all').on('change', function() {
+      if ($(this).is(':checked')) {
+        $('#{{ table_id }}-tags-filter .filterCheckbox').prop('checked', true);
+      } else {
+        $('#{{ table_id }}-tags-filter .filterCheckbox').prop('checked', false);
+      }
+    });
+
+    // Clear all categories
+    $("#{{ table_id }}-clear-all-tags").on('click', function() {
+      $('#{{ table_id }}-tags-filter input[type=checkbox]').prop('checked', false);
+      search();
+    });
+
+
+    /* Search Bar */
+
+    // Handle search bar
+    $("#{{ table_id }}-trait-search").on('keyup', function() {
+      search();
+    })
+
+    // Clear search bar and reset the table
+    $("#{{ table_id }}-clear-search").on('click', function() {
+      $("#{{ table_id }}-trait-search").val('')
+      search()
+    })
+
+
+    /* Misc */
+
+    // Prevent 'enter' key from reloading the page
+    $('#{{ table_id }}-trait-search').closest('form').on('submit', function(e) {
+      e.preventDefault();
+    });
+
+  });
+</script>
\ No newline at end of file
diff --git a/src/modules/site-v2/templates/_includes/trait-library-table.html b/src/modules/site-v2/templates/_includes/trait-library-table.html
new file mode 100644
index 000000000..f686a9da1
--- /dev/null
+++ b/src/modules/site-v2/templates/_includes/trait-library-table.html
@@ -0,0 +1,255 @@
+{% if table_id is not defined %}
+  {% set table_id = "library-table" %}
+{% endif %}
+
+{% set offcanvas_id = table_id + '-phenotype-offcanvas' %}
+
+
+{% block custom_head %}
+<style>
+  .input-wrapper {
+    position: relative;
+  }
+  .input-wrapper i {
+    position: absolute;
+    top: 20%;
+    right: 5px;
+    color: grey
+  }
+
+  #tagsFilter, #tags {
+    text-transform: capitalize;
+  }
+
+  label {
+    white-space: normal;
+    word-wrap: break-word;
+  }
+
+  .dropdown-column {
+    width: 1.5em !important;
+  }
+</style>
+{% endblock %}
+
+
+<div>
+  <input type="hidden" id="csrf_token" name="csrf_token" value="{{ csrf_token() }}" />
+  {% include "_includes/phenotype-search-bar.html" %}
+
+  <div class="table-responsive">
+    <table id="{{ table_id }}" class="table p-0 text-center w-100">
+      <caption class="visually-hidden">A list of phenotype traits.</caption>
+      <thead class="table-secondary align-middle">
+        <tr>
+          <th scope="col" class="col-1 text-center dropdown-column"></th>
+          <th scope="col" class="col-1 text-center">Internal Name</th>
+          <th scope="col" class="col-1 text-center">Display Name</th>
+          <th scope="col" class="col-1 text-center py-4">Species</th>
+          <th scope="col" class="col-1 text-center">Upload Date</th>
+          {% if trait_library_table_mode == 'full'%}
+          <th scope="col" class="col-1 text-center">Public Database</th>
+          <th scope="col" class="col-1 text-center">Phenotype Analysis</th>
+          <th scope="col" class="col-1 text-center">Genetic Mapping</th>
+          {% elif trait_library_table_mode == 'select' %}
+          <th scope="col" class="col-1 text-center">Select</th>
+          {% endif %}
+        </tr>
+      </thead>
+      <tbody class="table-group-divider align-middle"></tbody>
+    </table>
+  </div>
+
+  <div class="offcanvas offcanvas-end offcanvasPhenotype" tabindex="-1" id="{{ offcanvas_id }}"
+    aria-labelledby="{{ offcanvas_id }}-label">
+    {% include "_includes/phenotype-offcanvas-content.html" %}
+  </div>
+</div>
+
+
+
+{% block script %}
+<script type="module">
+  {% include '_scripts/utils.js' %}       {#/* defines: flash_message, first_letter_caps */#}
+  {% include '_scripts/trait_utils.js' %} {#/* defines: traitNameHTML, traitNameString, queryTraitByName */#}
+
+  $(document).ready(function() {
+
+    // Set standard header token for AJAX
+    $.ajaxSetup({
+      beforeSend: function(xhr, settings) {
+        if (!/^(GET|HEAD|OPTIONS|TRACE)$/i.test(settings.type) && !this.crossDomain) {
+          xhr.setRequestHeader("X-CSRFToken", "{{ form.csrf_token._value() }}")
+        }
+      }
+    });
+
+    // Create main table as a DataTable
+    const table = $('#{{ table_id }}').DataTable( {
+      "sDom": "tpr",
+      "processing": true,
+      "serverSide": true,
+      "ajax": {
+        url: "{{ url_for('api_trait.query_list_datatable_private') }}",
+        data: function(d) {
+          d.dataset = 'caendr';
+        },
+      },
+      "ordering": false,
+      "columns": [
+        {
+          "render": function(data, type, row) {
+            return `
+              <button type="button" class="btn btn-link text-dark fw-normal d-block w-100 row-toggle"
+                  aria-expanded="false" aria-controls="full-info-${row.trait_name_caendr}"
+                  aria-label="Show more details for trait ${traitNameString(row.trait_name_display_1, row.trait_name_display_2, row.trait_name_display_3)}"
+              ><i class="bi bi-chevron-right" aria-hidden="true"></i></button>
+            `;
+          },
+          "sClass": "p-0 m-0 dropdown-column",
+        },
+        {
+          "data": "trait_name_user",
+          "render": function(data, type, row) {
+            return data || row.trait_name_caendr;
+          },
+        },
+        {
+          "render": function(data, type, row) {
+            return traitNameHTML( row.trait_name_display_1, row.trait_name_display_2, row.trait_name_display_3 );
+          },
+          "width": '20%',
+        },
+        {
+          "data": "species_name",
+          "render": function(data, type, row) {
+            return first_letter_caps(data).replace('_', '. ').italics();
+          },
+        },
+        {
+          "data": "created_on",
+          "render": function(data, type, row) {
+            return formatDate(data);
+          },
+        },
+
+        {% if trait_library_table_mode == 'full' %}
+        {
+          "render": function(data, type, row) {
+            const url = "{{ url_for('phenotype_database.phenotype_database') }}";
+            return `
+              <a href='${url}'><i class="bi bi-arrow-right-circle-fill" aria-hidden="true"></i>Publish</a>
+            `;
+          },
+          "sClass": "optionsToolbar",
+        },
+        {
+          "render": function(data, type, row) {
+            const url = "{{ url_for('phenotype_database.submit_start', trait='TRAIT_NAME', dataset='TRAIT_SET') }}".replace("TRAIT_NAME", row.trait_name_caendr).replace("TRAIT_SET", row.dataset);
+            return `
+              <a href='${url}'><i class="bi bi-arrow-right-circle-fill" aria-hidden="true"></i>Analyze</a>
+            `;
+          },
+          "sClass": "optionsToolbar",
+        },
+        {
+          "render": function(data, type, row) {
+            const url = "{{ url_for('genetic_mapping.genetic_mapping') }}";
+            return `
+              <a href='${url}'><i class="bi bi-arrow-right-circle-fill" aria-hidden="true"></i>Analyze</a>
+            `;
+          },
+          "sClass": "optionsToolbar",
+        },
+        {% elif trait_library_table_mode == 'select' %}
+        {
+          "render": function(data, type, row) {
+            const url = `{{ trait_library_table_select_link | safe }}`.replace("TRAIT_NAME", row.trait_name_caendr).replace("TRAIT_SET", row.dataset);
+            return `
+              <a href='${url}'><i class="bi bi-arrow-right-circle-fill" aria-hidden="true"></i>Select</a>
+            `;
+          },
+          "sClass": "optionsToolbar",
+        },
+        {% endif %}
+      ],
+    });
+
+
+    /* Child Rows (Dropdowns) */
+
+    function format_child_row(data) {
+      return `
+        <div class="ms-5 pt-5 px-5 pb-2">
+            <h3 class="h5 text-dark">Full Description</h3>
+            <p>${data.description_long}</p>
+        </div>
+        <div class="d-flex justify-content-end me-1 pb-3 optionsToolbar">
+            <a class="trait-detail-button" href="#"
+              data-bs-toggle="offcanvas" data-bs-target="#{{ offcanvas_id }}" data-value="${data.trait_name_caendr}"
+              aria-controls="{{ offcanvas_id }}"
+            ><i class="bi bi-arrow-right" aria-hidden="true"></i>View Full Details</a>
+        </div>
+      `;
+    };
+
+    // Add event listener for opening and closing row details
+    table.on('click', '.row-toggle', function (e) {
+        const tr = e.target.closest('tr');
+        const row = table.row(tr);
+
+        if (row.child.isShown()) {
+          row.child.hide();
+          e.target.closest('button').setAttribute('aria-expanded', 'false')
+        } else {
+          row.child(format_child_row(row.data())).show();
+          row.child().attr('id', `full-info-${row.data().trait_name_caendr}`)
+          e.target.closest('button').setAttribute('aria-expanded', 'true')
+        }
+
+        update_arrows('#{{ table_id }} .row-toggle');
+    });
+
+    function update_arrows(selector) {
+      $(`${selector}[aria-expanded="true"]` ).html('<i class="bi bi-chevron-down"  aria-hidden="true"></i>');
+      $(`${selector}[aria-expanded="false"]`).html('<i class="bi bi-chevron-right" aria-hidden="true"></i>');
+    };
+
+
+    /* Offcanvas (Sidebar) */
+
+    // Fetch data for a trait and fill out side bar
+    $(document).on('click', '.trait-detail-button', function() {
+      queryTraitByName($(this).data('value'), $('#csrf_token').val())
+        .then((response) => {
+          fillOutModal(response)
+        })
+        .fail((error) => {
+          console.error(error)
+          $('#{{ offcanvas_id }} .btn-close').click()
+          flashErrorResponse(error.responseJSON, 'There was a problem retrieving this trait. Please try again later.')
+        })
+    })
+
+    function fillOutModal(trait) {
+      document.dispatchEvent(new CustomEvent('phenotype-offcanvas-content', {
+        detail: { offcanvas_id: '{{offcanvas_id}}', trait: trait },
+      }));
+    }
+
+
+    /* Searching / Filtering Handlers */
+
+    // Update search based on search widget
+    document.addEventListener('{{ table_id }}-search', async ({detail}) => {
+      try {
+        table.search( JSON.stringify(detail) ).draw()
+      } catch(err) {
+        console.error(err)
+        flash_message(`Failed to retrieve the list of traits: ${err.statusText}`)
+      }
+    });
+
+  });
+</script>
+{% endblock %}
\ No newline at end of file
diff --git a/src/modules/site-v2/templates/_scripts/trait_utils.js b/src/modules/site-v2/templates/_scripts/trait_utils.js
index 9298c1603..0f350a626 100644
--- a/src/modules/site-v2/templates/_scripts/trait_utils.js
+++ b/src/modules/site-v2/templates/_scripts/trait_utils.js
@@ -27,16 +27,16 @@ function traitNameString(name_1, name_2, name_3) {
 }
 
 
-function queryTraitByName(trait_name, csrf_token=null) {
+function queryTraitByName(trait_id, csrf_token=null) {
 
   // Construct the data object, using the optional CSRF token if provided
-  let data = {trait_name};
+  let data = {trait_id};
   if (csrf_token !== null) data['csrf_token'] = csrf_token;
 
   // Return the AJAX request as a Promise object
   return $.ajax({
       type:        "POST",
-      url:         "{{ url_for('phenotype_database.get_traits_json') }}",
+      url:         "{{ url_for('api_trait.query_trait_metadata') }}",
       data:        JSON.stringify(data),
       contentType: "application/json",
       dataType:    "json",
diff --git a/src/modules/site-v2/templates/_scripts/utils.js b/src/modules/site-v2/templates/_scripts/utils.js
index 98dd2220b..4a0c3fc2c 100644
--- a/src/modules/site-v2/templates/_scripts/utils.js
+++ b/src/modules/site-v2/templates/_scripts/utils.js
@@ -107,7 +107,7 @@ function create_node(html) {
 
 // Convert text from Markdown to HTML using Toast UI
 // This protects against code injection
-function markdown_to_html(text) {
+function markdownToHTML(text) {
   const editor = new toastui.Editor({
     el: document.createElement('div'),
     initialValue: text,
@@ -145,7 +145,7 @@ function flash_message(message, full_msg_link=null, full_msg_body=null) {
 
   // Create as a new DOM node, and insert the desired message as formatted (cleaned) HTML
   const node = create_node(raw_html);
-  node.firstElementChild.innerHTML = markdown_to_html(message);
+  node.firstElementChild.innerHTML = markdownToHTML(message);
 
   // If both full message fields are provided, add as a link & collapse dropdown
   if (full_msg_link && full_msg_body) {
@@ -175,3 +175,40 @@ function flash_message(message, full_msg_link=null, full_msg_body=null) {
   {%- endfor %}
   {%- endif %}
 }
+
+
+function flashErrorResponse(responseJSON, backupMessage, scrollToTop = true) {
+
+  // Optionally scroll to the top of the page to highlight the error message
+  if (scrollToTop) {
+    $('html').animate({
+      scrollTop: $('body').offset().top,
+    }, 100);
+  }
+
+  // If the response JSON contains a message, flash all the details it has
+  if (responseJSON && responseJSON.message) {
+    flash_message(responseJSON.message, responseJSON.full_msg_link, responseJSON.full_msg_body);
+  }
+
+  // Otherwise, flash a backup message
+  else {
+    flash_message(backupMessage);
+  }
+}
+
+
+/* Format a date as YYYY-MM-DD.
+ */
+function formatDate(d) {
+  if(d === null) return 'N/A'
+  const date = new Date(d)
+  const month = (date.getMonth()+1).toString().padStart(2, '0')
+  const day = date.getDate().toString().padStart(2, '0')
+  return `${date.getFullYear()}-${month}-${day}`
+}
+
+
+function first_letter_caps(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
diff --git a/src/modules/site-v2/templates/tools/genetic_mapping/mapping.html b/src/modules/site-v2/templates/tools/genetic_mapping/mapping.html
index d37f9dfd0..faa4ccab8 100644
--- a/src/modules/site-v2/templates/tools/genetic_mapping/mapping.html
+++ b/src/modules/site-v2/templates/tools/genetic_mapping/mapping.html
@@ -133,7 +133,7 @@ <h2 class="mb-4 text-center">Example Data</h2>
 {% from "_scripts/submit-job.js" import def_submit_job %}
 {% from "_includes/macros.html" import update_species_field %}
 <script>
-{% include '_scripts/utils.js' %} {#/* defines: flash_message */#}
+{% include '_scripts/utils.js' %} {#/* defines: flashErrorResponse */#}
 
 {{ def_submit_job('genetic_mapping', true) }}
 
@@ -173,10 +173,7 @@ <h2 class="mb-4 text-center">Example Data</h2>
     })
     // If file validation fails: flash the error, reset the file input, and re-enable the submit button
     .fail((error) => {
-      const resp = error.responseJSON
-      if (resp && resp.message) {
-        flash_message(resp.message, resp.full_msg_link, resp.full_msg_body);
-      }
+      flashErrorResponse(error.responseJSON, 'There was a problem with your submission. Please try again later.');
       document.getElementById('{{ form.file.id }}').value = '';
       enableButton();
     })
diff --git a/src/modules/site-v2/templates/tools/heritability_calculator/heritability-calculator.html b/src/modules/site-v2/templates/tools/heritability_calculator/heritability-calculator.html
index a46a96576..63eca5b9a 100644
--- a/src/modules/site-v2/templates/tools/heritability_calculator/heritability-calculator.html
+++ b/src/modules/site-v2/templates/tools/heritability_calculator/heritability-calculator.html
@@ -131,7 +131,7 @@ <h2 class="mb-4 text-center">Example Data</h2>
 {% from "_scripts/submit-job.js" import def_submit_job %}
 {% from "_includes/macros.html" import update_species_field %}
 <script>
-{% include '_scripts/utils.js' %} {#/* defines: flash_message */#}
+{% include '_scripts/utils.js' %} {#/* defines: flashErrorResponse */#}
 
 {{ def_submit_job('heritability_calculator', true) }}
 
@@ -171,10 +171,7 @@ <h2 class="mb-4 text-center">Example Data</h2>
     })
     // If file validation fails: flash the error, reset the file input, and re-enable the submit button
     .fail((error) => {
-      const resp = error.responseJSON
-      if (resp && resp.message) {
-        flash_message(resp.message, resp.full_msg_link, resp.full_msg_body);
-      }
+      flashErrorResponse(error.responseJSON, 'There was a problem with your submission. Please try again later.');
       document.getElementById('{{ form.file.id }}').value = '';
       enableButton();
     })
diff --git a/src/modules/site-v2/templates/tools/phenotype_database/phenotypedb.html b/src/modules/site-v2/templates/tools/phenotype_database/phenotypedb.html
index 637afe5e2..1a1bfe97c 100644
--- a/src/modules/site-v2/templates/tools/phenotype_database/phenotypedb.html
+++ b/src/modules/site-v2/templates/tools/phenotype_database/phenotypedb.html
@@ -8,7 +8,7 @@
                 class="bi bi-arrow-right-circle-fill me-1" aria-hidden="true"></i>Start an Analysis</a>
     </div>
     <div class="col mt-5">
-        {% with analyze_link = url_for("phenotype_database.submit_start", trait="TRAIT_NAME", dataset="TRAIT_SET") %}
+        {% with analyze_link = url_for("phenotype_database.submit_start", trait="TRAIT_NAME") %}
         {% include "_includes/phenotype-database-table.html" %}
         {% endwith %}
     </div>
diff --git a/src/modules/site-v2/templates/tools/phenotype_database/submit-traits.html b/src/modules/site-v2/templates/tools/phenotype_database/submit-traits.html
index 12ed7eb6c..310714b0c 100644
--- a/src/modules/site-v2/templates/tools/phenotype_database/submit-traits.html
+++ b/src/modules/site-v2/templates/tools/phenotype_database/submit-traits.html
@@ -38,7 +38,7 @@ <h5 class="modal-title" id="phenotypeDBModalLabel">Phenotype Database</h5>
             </div>
             <div class="modal-body">
                 <div class="container my-3">
-                    {% with analyze_link = 'javascript:select_trait(null, \"TRAIT_NAME\", \"TRAIT_SET\")' %}
+                    {% with analyze_link = 'javascript:select_trait(null, \"TRAIT_NAME\")' %}
                     {% include "_includes/phenotype-database-table.html" %}
                     {% endwith %}
                 </div>
@@ -129,7 +129,7 @@ <h5 class="modal-title" id="confirmationModalLabel">Thank you</h5>
     }
 
 
-    function select_trait(id=null, trait=null, dataset=null) {
+    function select_trait(id=null, trait=null) {
 
         // Unless a selector is specifically named,
         // default to last selector to open the phenotype db modal
@@ -142,17 +142,12 @@ <h5 class="modal-title" id="confirmationModalLabel">Thank you</h5>
                 // Response check prevents infinite recursion
                 .then((response) => {
                     if (response !== null && typeof response === 'string') throw Error(`Invalid response for trait ${id}: "${response}"`);
-                    select_trait(id, response, dataset);
+                    select_trait(id, response);
                 })
                 .fail((error) => {
                     // If an error message was received, display it, otherwise use a fallback message
                     console.error(error);
-                    const resp = error.responseJSON
-                    if (resp && resp.message && false) {
-                        flash_message(resp.message, resp.full_msg_link, resp.full_msg_body);
-                    } else{
-                        flash_message(`Failed to retrieve metadata for trait ${trait}`);
-                    }
+                    flashErrorResponse(error.responseJSON, `Failed to retrieve metadata for trait ${trait}.`)
 
                     // Close the modal so the user can see the error message
                     $('#phenotypeDBModal').modal('hide');
@@ -249,10 +244,7 @@ <h5 class="modal-title" id="confirmationModalLabel">Thank you</h5>
             })
             // If validation fails, just flash the error
             .fail((error) => {
-                const resp = error.responseJSON
-                if (resp && resp.message) {
-                    flash_message(resp.message, resp.full_msg_link, resp.full_msg_body);
-                }
+                flashErrorResponse(error.responseJSON, 'There was a problem with your submission. Please try again later.')
             })
     }
 </script>
diff --git a/src/pkg/caendr/caendr/api/phenotype.py b/src/pkg/caendr/caendr/api/phenotype.py
index ba9d06643..1b4d22538 100644
--- a/src/pkg/caendr/caendr/api/phenotype.py
+++ b/src/pkg/caendr/caendr/api/phenotype.py
@@ -1,59 +1,124 @@
 import bleach
 import os
+from typing import Optional, Union, Iterable
 
 from sqlalchemy import or_, func
 
-from caendr.models.datastore import Species
-from caendr.models.error import BadRequestError
+from caendr.models.datastore import Species, User
 from caendr.models.sql import PhenotypeMetadata
 from caendr.services.cloud.postgresql import rollback_on_error
 
 
-def query_phenotype_metadata(is_bulk_file=False, include_values=False, species: str = None):
+
+def query_phenotype_metadata(
+    include_values:  bool = False,
+    include_private: bool = False,
+    is_bulk_file: Optional[bool]                = None,
+    dataset:      Optional[str]                 = None,
+    species:      Optional[Union[Species, str]] = None,
+    user:         Optional[Union[User, str]]    = None,
+):
     """
-      Returns the list of traits with the corresponding metadata.
+      Create a trait metadata SQL query, with some optional initial filters.
+      Returns a query object that can be further refined.
 
       Args:
-      - is_bulk_file:     by default returns data for non-bulk files
-                          if 'is_bulk_file' set to True returns traits metadata for Zhang Expression file
-      - phenotype_values: if True, include phenotype values for each trait
-      - species:          filters by species
+        - `include_values`:  If `True`, includes the phenotype value measurements for each trait.
+        - `include_private`: If `True`, includes private (unpublished) traits in the query.
+        - `is_bulk_file`:    Optionally filter by whether the traits belong to a bulk dataset.
+                             If `None`, does not filter by this parameter.
+        - `dataset`:         Optionally filters by dataset.
+        - `species`:         Optionally filters by species.
+        - `user`:            Optionally filters by submitting user.
     """
+
+    # Create the initial query
     query = PhenotypeMetadata.query
 
-    # Get traits for bulk file
-    if is_bulk_file:
-      query = query.filter_by(is_bulk_file=True)
-    else:
-      # Get traits for non-bulk files
-      query = query.filter_by(is_bulk_file=False)
-
-    # Query by species
-    if species is not None:
-      if species in Species.all().keys():
-        query = query.filter_by(species_name=species)
-      else:
-        raise BadRequestError(f'Unrecognized species ID "{species}".')
-    
+    # TODO: Filter by public (published) / private (unpublished)
+    if not include_private:
+      pass
+
+    # Optionally query by bulk file
+    if is_bulk_file is not None:
+      query = query.filter_by(is_bulk_file=bool(is_bulk_file))
+
+    # Optionally query by dataset
+    if dataset is not None:
+      query = query.filter_by(dataset=dataset)
+
+    # Optionally query by species
+    # None values handled in function
+    query = filter_trait_query_by_species(query, species)
+    query = filter_trait_query_by_user(query, user)
+
     # Include phenotype values for traits
     if include_values:
-       query = query.join(PhenotypeMetadata.phenotype_values)
+      query = query.join(PhenotypeMetadata.phenotype_values)
+
+    # Order alphabetically by trait names
+    query = order_trait_query_by_name(query)
 
     return query
 
 
 def get_all_traits_metadata():
-    """
-      Returns metadata for all traits
-    """
-    return PhenotypeMetadata.query.all()
+  """
+    Returns metadata for all traits
+  """
+  return PhenotypeMetadata.query.all()
 
 
 def get_trait(trait_id):
-   return PhenotypeMetadata.query.get(trait_id)
+  return PhenotypeMetadata.query.get(trait_id)
+
+
+def order_trait_query_by_name(query):
+  '''
+    Sort a Phenotype Database trait query alphabetically by the display name(s).
+  '''
+  return query.order_by(
+
+    # Order by display names, in order
+    PhenotypeMetadata.trait_name_display_1.asc(),
+    PhenotypeMetadata.trait_name_display_2.asc(),
+    PhenotypeMetadata.trait_name_display_3.asc(),
+
+    # Fallback to internal CaeNDR trait name
+    PhenotypeMetadata.trait_name_caendr.asc(),
+  )
+
+
+
+#
+# Query Filters
+#
+# Conditionally add common filter types to a query object
+#
+
+
+def filter_trait_query(
+    query,
+    search_val: Optional[str]                 = None,
+    tags:       Optional[Iterable[str]]       = None,
+    species:    Optional[Union[Species, str]] = None,
+    user:       Optional[Union[User, str]]    = None,
+  ):
+  '''
+    Combined filtering function.
+  '''
+  query = filter_trait_query_by_text(query, search_val)
+  query = filter_trait_query_by_tags(query, tags)
+  query = filter_trait_query_by_species(query, species)
+  query = filter_trait_query_by_user(query, user)
+  return query
 
 
-def filter_trait_query_by_text(query, search_val):
+def filter_trait_query_by_text(query, search_val: Optional[str]):
+  '''
+    Filter by a text search value on the text fields.
+    Generic "search" functionality.
+  '''
   print(search_val)
   if search_val and len(search_val):
     query = query.filter(
@@ -70,9 +135,89 @@ def filter_trait_query_by_text(query, search_val):
   return query
 
 
-def filter_trait_query_by_tags(query, tags):
-  if len(tags):
+def filter_trait_query_by_tags(query, tags: Optional[Iterable[str]]):
+  '''
+    Filter by trait tags.
+  '''
+  if tags and len(tags):
     query = query.filter(or_(
       PhenotypeMetadata.tags.ilike(f"%{bleach.clean(tag)}%") for tag in tags
     ))
   return query
+
+
+def filter_trait_query_by_user(query, user: Optional[Union[User, str]]):
+  '''
+    Filter by submitting user.
+
+    If username is invalid, passes error raised by `User` class.
+  '''
+  if user:
+
+    # Cast string value to User object using unique datastore ID
+    if isinstance(user, str):
+      user = User.get_ds(user)
+
+    # Validate user type
+    if not isinstance(user, User):
+      raise ValueError(f'Expected user, got {user}')
+
+    # Filter by the username
+    query = query.filter_by(submitted_by=user.full_name)
+
+  return query
+
+
+def filter_trait_query_by_species(query, species: Optional[Union[Species, str]]):
+  '''
+    Filter by species.
+
+    If species is invalid, passes error raised by `Species` class.
+  '''
+  if species is not None:
+
+    # Cast string value to Species object
+    if isinstance(species, str):
+      species = Species.from_name(species)
+
+    # Validate species type
+    if not isinstance(species, Species):
+      raise ValueError(f'Expected species identifier, got {species}')
+
+    # Filter by the species name
+    query = query.filter_by(species_name=species.name)
+
+  # Return the (possibly filtered) query
+  return query
+
+
+
+#
+# Trait Categories
+#
+
+
+@rollback_on_error
+def get_trait_categories(query = None):
+  '''
+    Get the list of trait categories.
+
+    If a query is provided, only returns categories represented in that query.
+    Otherwise, creates a new query.
+
+    TODO: Currently, uses PhenotypeMetadata table queries to get the full list
+          of categories, as strings. In the future we may want to explicitly
+          store this list somewhere and attach metadata.
+  '''
+  # If no query given, default to full-database search
+  # TODO: We can speed this up a lot by excluding Zhang traits... what is the most data-agnostic way to do that?
+  if query is None:
+    query = query_phenotype_metadata()
+
+  # Parse the list of tags from each row
+  # `filter` with None removes all non-truthy values, i.e. empty tag sets
+  tags = filter(None, ( tr.get_tags() for tr in query ))
+
+  # Flatten the list of lists into a set, and sort the result
+  tags_list = { tg for tr_tag in tags for tg in tr_tag }
+  return sorted(tags_list)
diff --git a/src/pkg/caendr/caendr/models/sql/phenotype_metadata.py b/src/pkg/caendr/caendr/models/sql/phenotype_metadata.py
index ead869172..ebf413300 100644
--- a/src/pkg/caendr/caendr/models/sql/phenotype_metadata.py
+++ b/src/pkg/caendr/caendr/models/sql/phenotype_metadata.py
@@ -40,6 +40,8 @@ class PhenotypeMetadata(DictSerializable, db.Model):
 
   __tablename__ = 'phenotype_metadata'
 
+
+
   def to_json_with_values(self):
     """
       Converts PhenotypeMetadata instance to JSON in the joined queries
@@ -48,8 +50,17 @@ def to_json_with_values(self):
     phenotype_values = [ v.to_json() for v in self.phenotype_values ]
     json_trait['phenotype_values'] = phenotype_values
     return json_trait
-  
-  
+
+
+  def get_tags(self):
+    '''
+      Get the category tags as a set of strings.
+      If no tag set defined, returns None.
+    '''
+    if self.tags:
+      return { tg.strip() for tg in self.tags.split(',') }
+
+
   def add(self, trait_obj):
     new_trait = PhenotypeMetadata(
       id = trait_obj.name,
@@ -78,4 +89,4 @@ def add(self, trait_obj):
 
   def delete(self):
     db.session.delete(self)
-    db.session.commit()
\ No newline at end of file
+    db.session.commit()
diff --git a/src/pkg/caendr/caendr/models/trait.py b/src/pkg/caendr/caendr/models/trait.py
index 4a351c630..8d819f9d9 100644
--- a/src/pkg/caendr/caendr/models/trait.py
+++ b/src/pkg/caendr/caendr/models/trait.py
@@ -66,6 +66,24 @@ def __init__(self, dataset = None, trait_name = None, trait_file_id = None, trai
   # Constructors
   #
 
+  @staticmethod
+  def from_id(trait_id: str) -> 'Trait':
+    '''
+      Instantiate a `Trait` object from a unique trait ID.
+      The given ID must exist in the PhenotypeMetadata SQL table, otherwise a `ValueError` will be raised.
+    '''
+
+    # Get the SQL row with the given trait ID
+    sql_row = PhenotypeMetadata.query.get(trait_id)
+    if sql_row is None:
+      raise ValueError(f'Invalid trait ID {trait_id}')
+
+    # Construct a Trait object using the data in the SQL row
+    return Trait(
+      trait_name = sql_row.trait_name_caendr,
+      dataset    = sql_row.dataset,
+    )
+
   @staticmethod
   def from_dataset(dataset: str, trait_name: Optional[str] = None) -> 'Trait':
     return Trait( dataset = dataset, trait_name = trait_name )