diff --git a/gateway/sds_gateway/api_methods/admin.py b/gateway/sds_gateway/api_methods/admin.py
index 125f6f9a..dcd846cd 100644
--- a/gateway/sds_gateway/api_methods/admin.py
+++ b/gateway/sds_gateway/api_methods/admin.py
@@ -21,10 +21,19 @@ class CaptureAdmin(admin.ModelAdmin):  # pyright: ignore[reportMissingTypeArgume
 
 @admin.register(models.Dataset)
 class DatasetAdmin(admin.ModelAdmin):  # pyright: ignore[reportMissingTypeArgument]
-    list_display = ("name", "doi")
-    search_fields = ("name", "doi")
+    list_display = ("name", "doi", "get_keywords", "status", "owner")
+    search_fields = ("name", "doi", "keywords__name", "owner__email")
+    list_filter = ("status", "keywords")
     ordering = ("-updated_at",)
 
+    @admin.display(description="Keywords")
+    def get_keywords(self, obj):
+        """Display comma-separated list of keywords."""
+        keywords = obj.keywords.filter(is_deleted=False)
+        if keywords.exists():
+            return ", ".join([kw.name for kw in keywords[:5]])
+        return "-"
+
 
 @admin.register(models.TemporaryZipFile)
 class TemporaryZipFileAdmin(admin.ModelAdmin):  # pyright: ignore[reportMissingTypeArgument]
@@ -85,3 +94,16 @@ class ShareGroupAdmin(admin.ModelAdmin):  # pyright: ignore[reportMissingTypeArg
     list_display = ("name", "owner")
     search_fields = ("name", "owner")
     ordering = ("-updated_at",)
+
+
+@admin.register(models.Keyword)
+class KeywordAdmin(admin.ModelAdmin):  # pyright: ignore[reportMissingTypeArgument]
+    list_display = ("name", "get_datasets", "created_at")
+    search_fields = ("name", "datasets__name")
+    list_filter = ("datasets",)
+    ordering = ("name",)
+
+    @admin.display(description="Datasets")
+    def get_datasets(self, obj):
+        """Display comma-separated list of dataset names."""
+        return ", ".join([dataset.name for dataset in obj.datasets.all()[:3]])
diff --git a/gateway/sds_gateway/api_methods/migrations/max_migration.txt b/gateway/sds_gateway/api_methods/migrations/max_migration.txt
index f8c6298f..c68e76aa 100644
--- a/gateway/sds_gateway/api_methods/migrations/max_migration.txt
+++ b/gateway/sds_gateway/api_methods/migrations/max_migration.txt
@@ -1 +1 @@
-0017_convert_dataset_authors_to_object_format
+0021_remove_old_dataset_keywords_table
diff --git a/gateway/sds_gateway/api_methods/models.py b/gateway/sds_gateway/api_methods/models.py
index 9328fe18..26456dbb 100644
--- a/gateway/sds_gateway/api_methods/models.py
+++ b/gateway/sds_gateway/api_methods/models.py
@@ -18,6 +18,7 @@
 from django.db.models.signals import post_save
 from django.db.models.signals import pre_delete
 from django.dispatch import receiver
+from django.template.defaultfilters import slugify
 
 from .utils.opensearch_client import get_opensearch_client
 
@@ -27,6 +28,24 @@
 log = logging.getLogger(__name__)
 
 
+class KeywordNameField(models.CharField):
+    """
+    Custom field that auto-slugifies keyword names for consistency.
+    Enforces lowercase, converts spaces to hyphens, removes non-printable chars.
+    """
+
+    def get_prep_value(self, value):
+        """Convert the value to a slug before saving to database."""
+        value = super().get_prep_value(value)
+        if value is None:
+            return value
+        if not isinstance(value, str):
+            msg = "Name attribute must be a string"
+            raise TypeError(msg)
+        # Slugify the value (lowercase, hyphens instead of spaces, etc.)
+        return slugify(value)
+
+
 class CaptureType(StrEnum):
     """The type of radiofrequency capture."""
 
@@ -571,6 +590,40 @@ def debug_opensearch_response(self) -> dict[str, Any] | None:
             return None
 
 
+class Keyword(BaseModel):
+    """
+    Model for user-entered keywords that can be associated with datasets.
+    Keywords can be associated with multiple datasets via ManyToManyField.
+
+    The name field is auto-slugified and serves as the primary key,
+    enforcing uniqueness and immutability after creation.
+    """
+
+    # Override the uuid primary key from BaseModel
+    uuid = models.UUIDField(default=uuid.uuid4, editable=False)
+
+    name = KeywordNameField(
+        max_length=255,
+        primary_key=True,
+        help_text=(
+            "The keyword slug (auto-slugified, e.g., 'RF Spectrum' → 'rf-spectrum')"
+        ),
+    )
+    datasets = models.ManyToManyField(
+        "Dataset",
+        related_name="keywords",
+        help_text="The datasets this keyword is associated with",
+    )
+
+    class Meta:  # pyright: ignore[reportIncompatibleVariableOverride]
+        ordering = ["name"]
+        verbose_name = "Keyword"
+        verbose_name_plural = "Keywords"
+
+    def __str__(self) -> str:
+        return self.name
+
+
 class Dataset(BaseModel):
     """
     Model for datasets defined and created through the API.
@@ -578,7 +631,7 @@ class Dataset(BaseModel):
     Schema Definition: https://github.com/spectrumx/schema-definitions/blob/master/definitions/sds/abstractions/dataset/README.md
     """
 
-    list_fields = ["authors", "keywords", "institutions"]
+    list_fields = ["authors", "institutions"]
 
     STATUS_CHOICES = [
         (DatasetStatus.DRAFT, "Draft"),
@@ -604,7 +657,6 @@ class Dataset(BaseModel):
     doi = models.CharField(max_length=255, blank=True)
     authors = models.TextField(blank=True)
     license = models.CharField(max_length=255, blank=True)
-    keywords = models.TextField(blank=True)
     institutions = models.TextField(blank=True)
     release_date = models.DateTimeField(blank=True, null=True)
     repository = models.URLField(blank=True)
diff --git a/gateway/sds_gateway/api_methods/serializers/dataset_serializers.py b/gateway/sds_gateway/api_methods/serializers/dataset_serializers.py
index 7a96da66..1831585c 100644
--- a/gateway/sds_gateway/api_methods/serializers/dataset_serializers.py
+++ b/gateway/sds_gateway/api_methods/serializers/dataset_serializers.py
@@ -10,6 +10,7 @@
 
 class DatasetGetSerializer(serializers.ModelSerializer[Dataset]):
     authors = serializers.SerializerMethodField()
+    keywords = serializers.SerializerMethodField()
     created_at = serializers.DateTimeField(format="%m/%d/%Y %H:%M:%S", read_only=True)
     is_shared_with_me = serializers.SerializerMethodField()
     is_owner = serializers.SerializerMethodField()
@@ -24,6 +25,10 @@ def get_authors(self, obj):
         """Return the full authors list using the model's get_authors_display method."""
         return obj.get_authors_display()
 
+    def get_keywords(self, obj):
+        """Return a list of keyword names for the dataset."""
+        return [kw.name for kw in obj.keywords.filter(is_deleted=False)]
+
     def get_is_shared_with_me(self, obj):
         """Check if the dataset is shared with the current user."""
         request = self.context.get("request")
diff --git a/gateway/sds_gateway/api_methods/tests/factories.py b/gateway/sds_gateway/api_methods/tests/factories.py
index 10352124..f71d222f 100644
--- a/gateway/sds_gateway/api_methods/tests/factories.py
+++ b/gateway/sds_gateway/api_methods/tests/factories.py
@@ -20,6 +20,7 @@
 from sds_gateway.api_methods.models import Dataset
 from sds_gateway.api_methods.models import File
 from sds_gateway.api_methods.models import ItemType
+from sds_gateway.api_methods.models import Keyword
 from sds_gateway.api_methods.models import UserSharePermission
 from sds_gateway.users.tests.factories import UserFactory
 
@@ -42,7 +43,6 @@ class DatasetFactory(DjangoModelFactory):
         doi: Random UUID4 for DOI identifier
         authors: Fixed list of test authors ["John Doe", "Jane Smith"]
         license: Fixed value "MIT"
-        keywords: Fixed list ["RF", "capture", "analysis"]
         institutions: Fixed list ["Example University"]
         release_date: Random datetime
         repository: Random URL
@@ -55,8 +55,14 @@ class DatasetFactory(DjangoModelFactory):
         is_deleted: Fixed value False
         is_public: Fixed value False
 
+    Post-generation Hooks:
+        keywords: Creates Keyword instances after Dataset creation.
+                 Pass keyword names as a list:
+                 DatasetFactory(keywords=["RF", "capture"])
+                 Pass None to skip keyword creation: DatasetFactory(keywords=None)
+
     Example:
-        # Create a basic dataset
+        # Create a basic dataset with default keywords
         dataset = DatasetFactory()
 
         # Create a dataset with custom owner
@@ -65,6 +71,12 @@ class DatasetFactory(DjangoModelFactory):
 
         # Create a public dataset
         dataset = DatasetFactory(is_public=True)
+
+        # Create a dataset with custom keywords
+        dataset = DatasetFactory(keywords=["custom", "keywords"])
+
+        # Create a dataset without keywords
+        dataset = DatasetFactory(keywords=None)
     """
 
     uuid = Faker("uuid4")
@@ -74,7 +86,6 @@ class DatasetFactory(DjangoModelFactory):
     doi = Faker("uuid4")
     authors = ["John Doe", "Jane Smith"]
     license = "MIT"
-    keywords = ["RF", "capture", "analysis"]
     institutions = ["Example University"]
     release_date = Faker("date_time")
     repository = Faker("url")
@@ -87,6 +98,46 @@ class DatasetFactory(DjangoModelFactory):
     is_deleted = False
     is_public = False
 
+    @post_generation
+    def keywords(self, create, extracted, **kwargs):
+        """Create Keyword instances for the dataset after creation.
+
+        This post-generation hook creates Keyword objects associated with this
+        dataset. By default, it creates three keywords: "RF", "capture", "analysis".
+
+        Args:
+            create: Boolean indicating if the object is being created
+            extracted: Value passed to the factory for keywords parameter.
+                      If a list is provided, those keyword names will be used.
+                      If None is provided, no keywords will be created.
+                      If not provided, default keywords will be created.
+            **kwargs: Additional keyword arguments
+
+        Example:
+            # Default keywords
+            dataset = DatasetFactory()  # Creates "RF", "capture", "analysis"
+
+            # Custom keywords
+            dataset = DatasetFactory(keywords=["custom", "test"])
+
+            # No keywords
+            dataset = DatasetFactory(keywords=None)
+        """
+        if not create:
+            return
+
+        # If extracted is None, skip keyword creation entirely
+        if extracted is None:
+            return
+
+        # Use extracted keywords or default keywords
+        keyword_names = extracted or ["RF", "capture", "analysis"]
+
+        # Create Keyword instances
+        for keyword_name in keyword_names:
+            keyword, _created = Keyword.objects.get_or_create(name=keyword_name)
+            keyword.datasets.add(self)
+
     class Meta:
         model = Dataset
 
diff --git a/gateway/sds_gateway/static/js/actions/DetailsActionManager.js b/gateway/sds_gateway/static/js/actions/DetailsActionManager.js
index 02202532..73fd4763 100644
--- a/gateway/sds_gateway/static/js/actions/DetailsActionManager.js
+++ b/gateway/sds_gateway/static/js/actions/DetailsActionManager.js
@@ -203,6 +203,9 @@ class DetailsActionManager {
 		// Update authors
 		this.updateAuthors(modal, datasetData.authors || []);
 
+		// Update keywords
+		this.updateKeywords(modal, datasetData.keywords || []);
+
 		// Update statistics
 		if (statistics) {
 			this.updateElementText(
@@ -442,6 +445,33 @@ class DetailsActionManager {
 		authorsContainer.textContent = authorsText;
 	}
 
+	/**
+	 * Update keywords section
+	 * @param {Element} modal - Modal element
+	 * @param {Array} keywords - Keywords array
+	 */
+	updateKeywords(modal, keywords) {
+		const keywordsContainer = modal.querySelector(".dataset-details-keywords");
+		if (!keywordsContainer) return;
+
+		// Clear existing content
+		keywordsContainer.innerHTML = "";
+
+		if (!keywords || keywords.length === 0) {
+			keywordsContainer.innerHTML =
+				'<span class="text-muted">No keywords</span>';
+			return;
+		}
+
+		// Create badges for each keyword
+		for (const keyword of keywords) {
+			const badge = document.createElement("span");
+			badge.className = "badge bg-secondary me-2 mb-2";
+			badge.textContent = keyword;
+			keywordsContainer.appendChild(badge);
+		}
+	}
+
 	/**
 	 * Update captures table
 	 * @param {Element} modal - Modal element
diff --git a/gateway/sds_gateway/static/js/deprecated/captureGroupingComponents.js b/gateway/sds_gateway/static/js/deprecated/captureGroupingComponents.js
index 4aef04ab..17a6535a 100644
--- a/gateway/sds_gateway/static/js/deprecated/captureGroupingComponents.js
+++ b/gateway/sds_gateway/static/js/deprecated/captureGroupingComponents.js
@@ -128,6 +128,7 @@ class FormHandler {
 
 	show(container, showClass = "display-block") {
 		container.classList.remove("display-none");
+		container.classList.remove("d-none"); // ensure Bootstrap's d-none is removed
 		container.classList.add(showClass);
 	}
 
@@ -178,6 +179,9 @@ class FormHandler {
 				document.querySelector("#step4 .dataset-description").textContent =
 					document.getElementById("id_description").value ||
 					"No description provided.";
+				const keywordsInput = document.getElementById("id_keywords");
+				document.querySelector("#step4 .dataset-keywords").textContent =
+					keywordsInput?.value.trim() || "No keywords";
 
 				// Update captures table
 				const capturesTableBody = document.querySelector(
@@ -466,6 +470,7 @@ class FormHandler {
 					method: "POST",
 					body: formData,
 					headers: {
+						"X-Requested-With": "XMLHttpRequest",
 						"X-CSRFToken": document.querySelector("[name=csrfmiddlewaretoken]")
 							.value,
 					},
diff --git a/gateway/sds_gateway/static/js/deprecated/datasetDetailsModal.js b/gateway/sds_gateway/static/js/deprecated/datasetDetailsModal.js
index d7df56ec..cb07c774 100644
--- a/gateway/sds_gateway/static/js/deprecated/datasetDetailsModal.js
+++ b/gateway/sds_gateway/static/js/deprecated/datasetDetailsModal.js
@@ -123,6 +123,22 @@ class DatasetDetailsModal {
 		document.querySelector(".dataset-details-description").textContent =
 			dataset.description || "No description available";
 
+		// Populate keywords
+		const keywordsContainer = document.querySelector(
+			".dataset-details-keywords",
+		);
+		if (dataset.keywords && dataset.keywords.length > 0) {
+			keywordsContainer.innerHTML = dataset.keywords
+				.map(
+					(keyword) =>
+						`<span class="badge bg-secondary me-1 mb-1">${this.escapeHtml(keyword)}</span>`,
+				)
+				.join("");
+		} else {
+			keywordsContainer.innerHTML =
+				'<span class="text-muted">No keywords</span>';
+		}
+
 		// Format status with badge using database values
 		const statusElement = document.querySelector(".dataset-details-status");
 		if (dataset.status === "draft") {
diff --git a/gateway/sds_gateway/templates/users/group_captures.html b/gateway/sds_gateway/templates/users/group_captures.html
index dc412d65..9eafd82c 100644
--- a/gateway/sds_gateway/templates/users/group_captures.html
+++ b/gateway/sds_gateway/templates/users/group_captures.html
@@ -120,6 +120,177 @@ <h5 class="mb-0">
         {# djlint:off #}
         <script>
             document.addEventListener('DOMContentLoaded', () => {
+                // ========== Keyword Autocomplete ==========
+                class KeywordAutocomplete {
+                    constructor(inputElement, apiUrl = '/users/api/keyword-autocomplete/') {
+                        this.input = inputElement;
+                        this.apiUrl = apiUrl;
+                        this.minChars = 1;
+                        this.debounceMs = 300;
+                        this.debounceTimer = null;
+                        this.suggestionsContainer = null;
+                        this.currentFocus = -1;
+                        this.init();
+                    }
+
+                    init() {
+                        this.createSuggestionsContainer();
+                        this.input.addEventListener('input', this.handleInput.bind(this));
+                        this.input.addEventListener('keydown', this.handleKeydown.bind(this));
+                        this.input.addEventListener('blur', this.handleBlur.bind(this));
+                        document.addEventListener('click', (e) => {
+                            if (e.target !== this.input) this.closeSuggestions();
+                        });
+                    }
+
+                    createSuggestionsContainer() {
+                        this.suggestionsContainer = document.createElement('div');
+                        this.suggestionsContainer.className = 'keyword-autocomplete-suggestions';
+                        this.suggestionsContainer.style.cssText = 'position: absolute; border: 1px solid #ddd; border-top: none; z-index: 1000; background: white; max-height: 200px; overflow-y: auto; box-shadow: 0 2px 4px rgba(0,0,0,0.1); display: none;';
+                        this.input.parentNode.style.position = 'relative';
+                        this.input.parentNode.appendChild(this.suggestionsContainer);
+                    }
+
+                    handleInput() {
+                        const value = this.getCurrentWord();
+                        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+                        if (value.length < this.minChars) {
+                            this.closeSuggestions();
+                            return;
+                        }
+                        this.debounceTimer = setTimeout(() => this.fetchSuggestions(value), this.debounceMs);
+                    }
+
+                    getCurrentWord() {
+                        const fullValue = this.input.value;
+                        const cursorPos = this.input.selectionStart;
+                        const textBeforeCursor = fullValue.substring(0, cursorPos);
+                        const lastCommaIndex = textBeforeCursor.lastIndexOf(',');
+                        return lastCommaIndex >= 0 ? textBeforeCursor.substring(lastCommaIndex + 1).trim() : textBeforeCursor.trim();
+                    }
+
+                    async fetchSuggestions(query) {
+                        try {
+                            const response = await fetch(`${this.apiUrl}?q=${encodeURIComponent(query)}`);
+                            const data = await response.json();
+                            if (data.suggestions && data.suggestions.length > 0) {
+                                this.showSuggestions(data.suggestions);
+                            } else {
+                                this.closeSuggestions();
+                            }
+                        } catch (error) {
+                            console.error('Error fetching keyword suggestions:', error);
+                            this.closeSuggestions();
+                        }
+                    }
+
+                    showSuggestions(suggestions) {
+                        this.suggestionsContainer.innerHTML = '';
+                        this.currentFocus = -1;
+                        suggestions.forEach((suggestion) => {
+                            const item = document.createElement('div');
+                            item.className = 'keyword-autocomplete-item';
+                            item.textContent = suggestion;
+                            item.style.cssText = 'padding: 10px; cursor: pointer; border-bottom: 1px solid #f0f0f0;';
+                            item.addEventListener('mouseenter', () => {
+                                this.removeActiveClass();
+                                item.classList.add('keyword-autocomplete-active');
+                                item.style.backgroundColor = '#e9ecef';
+                            });
+                            item.addEventListener('mouseleave', () => {
+                                item.classList.remove('keyword-autocomplete-active');
+                                item.style.backgroundColor = '';
+                            });
+                            item.addEventListener('mousedown', (e) => {
+                                e.preventDefault();
+                                this.selectSuggestion(suggestion);
+                            });
+                            this.suggestionsContainer.appendChild(item);
+                        });
+                        const rect = this.input.getBoundingClientRect();
+                        this.suggestionsContainer.style.width = `${rect.width}px`;
+                        this.suggestionsContainer.style.top = `${this.input.offsetTop + this.input.offsetHeight}px`;
+                        this.suggestionsContainer.style.left = `${this.input.offsetLeft}px`;
+                        this.suggestionsContainer.style.display = 'block';
+                    }
+
+                    selectSuggestion(suggestion) {
+                        const fullValue = this.input.value;
+                        const cursorPos = this.input.selectionStart;
+                        const textBeforeCursor = fullValue.substring(0, cursorPos);
+                        const textAfterCursor = fullValue.substring(cursorPos);
+                        const lastCommaIndex = textBeforeCursor.lastIndexOf(',');
+                        let newValue;
+                        if (lastCommaIndex >= 0) {
+                            const beforeComma = fullValue.substring(0, lastCommaIndex + 1);
+                            newValue = beforeComma + ' ' + suggestion + textAfterCursor;
+                        } else {
+                            newValue = suggestion + textAfterCursor;
+                        }
+                        this.input.value = newValue;
+                        this.input.focus();
+                        const newCursorPos = lastCommaIndex >= 0 ? lastCommaIndex + 2 + suggestion.length : suggestion.length;
+                        this.input.setSelectionRange(newCursorPos, newCursorPos);
+                        this.closeSuggestions();
+                    }
+
+                    handleKeydown(e) {
+                        const items = this.suggestionsContainer.querySelectorAll('.keyword-autocomplete-item');
+                        if (!items.length) return;
+                        if (e.key === 'ArrowDown') {
+                            e.preventDefault();
+                            this.currentFocus++;
+                            if (this.currentFocus >= items.length) this.currentFocus = 0;
+                            this.addActiveClass(items);
+                        } else if (e.key === 'ArrowUp') {
+                            e.preventDefault();
+                            this.currentFocus--;
+                            if (this.currentFocus < 0) this.currentFocus = items.length - 1;
+                            this.addActiveClass(items);
+                        } else if (e.key === 'Enter') {
+                            if (this.currentFocus > -1 && items[this.currentFocus]) {
+                                e.preventDefault();
+                                items[this.currentFocus].click();
+                            }
+                        } else if (e.key === 'Escape') {
+                            this.closeSuggestions();
+                        }
+                    }
+
+                    addActiveClass(items) {
+                        this.removeActiveClass();
+                        if (this.currentFocus >= items.length) this.currentFocus = 0;
+                        if (this.currentFocus < 0) this.currentFocus = items.length - 1;
+                        items[this.currentFocus].classList.add('keyword-autocomplete-active');
+                        items[this.currentFocus].style.backgroundColor = '#e9ecef';
+                        items[this.currentFocus].scrollIntoView({ block: 'nearest' });
+                    }
+
+                    removeActiveClass() {
+                        const items = this.suggestionsContainer.querySelectorAll('.keyword-autocomplete-item');
+                        items.forEach(item => {
+                            item.classList.remove('keyword-autocomplete-active');
+                            item.style.backgroundColor = '';
+                        });
+                    }
+
+                    handleBlur() {
+                        setTimeout(() => this.closeSuggestions(), 200);
+                    }
+
+                    closeSuggestions() {
+                        this.suggestionsContainer.style.display = 'none';
+                        this.suggestionsContainer.innerHTML = '';
+                        this.currentFocus = -1;
+                    }
+                }
+
+                // Initialize keyword autocomplete
+                const keywordInput = document.getElementById('id_keywords');
+                if (keywordInput) {
+                    new KeywordAutocomplete(keywordInput);
+                }
+
                 // Initialize the dataset mode manager
                 const datasetModeManager = new DatasetModeManager({
                     isEditMode: {{ existing_dataset|yesno:"true,false" }},
diff --git a/gateway/sds_gateway/templates/users/partials/dataset_details_modal.html b/gateway/sds_gateway/templates/users/partials/dataset_details_modal.html
index cc99927d..7f7ad998 100644
--- a/gateway/sds_gateway/templates/users/partials/dataset_details_modal.html
+++ b/gateway/sds_gateway/templates/users/partials/dataset_details_modal.html
@@ -66,6 +66,12 @@ <h6 class="mb-0">
                                         <label class="fw-bold text-muted">Description:</label>
                                         <p class="mb-0 dataset-details-description">Loading...</p>
                                     </div>
+                                    <div class="mb-3">
+                                        <label class="fw-bold text-muted">Keywords:</label>
+                                        <div class="dataset-details-keywords">
+                                            <span class="text-muted">Loading...</span>
+                                        </div>
+                                    </div>
                                 </div>
                             </div>
                         </div>
diff --git a/gateway/sds_gateway/templates/users/partials/review_create_dataset.html b/gateway/sds_gateway/templates/users/partials/review_create_dataset.html
index 649fca72..8e6fd998 100644
--- a/gateway/sds_gateway/templates/users/partials/review_create_dataset.html
+++ b/gateway/sds_gateway/templates/users/partials/review_create_dataset.html
@@ -31,6 +31,11 @@ <h5 class="mb-0">Dataset Information</h5>
                 <ul class="mb-0 dataset-description-change-list">
                 </ul>
             </div>
+            <hr />
+            <div class="mb-0">
+                <label class="fw-bold">Keywords</label>
+                <p class="mb-0 dataset-keywords"></p>
+            </div>
         </div>
     </div>
 </div>
diff --git a/gateway/sds_gateway/templates/users/partials/step_1.html b/gateway/sds_gateway/templates/users/partials/step_1.html
index f6daa6f9..20ad92cf 100644
--- a/gateway/sds_gateway/templates/users/partials/step_1.html
+++ b/gateway/sds_gateway/templates/users/partials/step_1.html
@@ -12,6 +12,14 @@
                             </label>
                             {{ dataset_form.name }}
                         </div>
+                        <div class="form-group mt-4">
+                            <label for="{{ dataset_form.keywords.id_for_label }}" class="form-label">
+                                {{ dataset_form.keywords.label }}
+                                <span class="text-muted">(Optional)</span>
+                            </label>
+                            {{ dataset_form.keywords }}
+                            {% if dataset_form.keywords.help_text %}<div class="form-text">{{ dataset_form.keywords.help_text }}</div>{% endif %}
+                        </div>
                         <div class="form-group mt-4">
                             <label for="{{ dataset_form.status.id_for_label }}" class="form-label">
                                 {{ dataset_form.status.label }}
@@ -28,6 +36,13 @@
                                    value="{{ existing_dataset.name }}"
                                    readonly />
                         </div>
+                        <div class="form-group mt-4">
+                            <label class="form-label">Keywords</label>
+                            <input type="text"
+                                   class="form-control"
+                                   value="{% for keyword in existing_dataset.keywords.all %}{{ keyword.name }}{% if not forloop.last %}, {% endif %}{% endfor %}"
+                                   readonly />
+                        </div>
                         <div class="form-group mt-4">
                             <label class="form-label">Status</label>
                             <input type="text"
diff --git a/gateway/sds_gateway/users/forms.py b/gateway/sds_gateway/users/forms.py
index 994a44cb..988aef3f 100644
--- a/gateway/sds_gateway/users/forms.py
+++ b/gateway/sds_gateway/users/forms.py
@@ -10,6 +10,7 @@
 from django.core.exceptions import ValidationError
 from django.forms import EmailField
 from django.http import HttpRequest
+from django.template.defaultfilters import slugify
 from django.utils.translation import gettext_lazy as _
 from loguru import logger
 
@@ -148,6 +149,17 @@ class DatasetInfoForm(forms.Form):
         required=False,
         widget=forms.Textarea(attrs={"class": "form-control", "rows": 5}),
     )
+    keywords = forms.CharField(
+        label="Keywords",
+        required=False,
+        widget=forms.TextInput(
+            attrs={
+                "class": "form-control",
+                "placeholder": "e.g. spectrum, RF, SDR",
+            }
+        ),
+        help_text="Comma-separated list of keywords",
+    )
     authors = forms.CharField(
         label="Authors",
         required=True,
@@ -188,6 +200,15 @@ def clean_name(self):
 
         return name.strip()
 
+    def clean_keywords(self):
+        """Normalize keywords string using slugify."""
+        raw = self.cleaned_data.get("keywords", "") or ""
+        # Split on commas or semicolons, strip whitespace
+        parts = [p.strip() for p in raw.replace(";", ",").split(",") if p.strip()]
+        # Slugify each keyword (lowercase, hyphens, no special chars) and deduplicate
+        slugified = {slugify(p) for p in parts if slugify(p)}
+        return ", ".join(sorted(slugified))
+
     def clean_authors(self):
         """Validate the authors list."""
         authors_json = self.cleaned_data["authors"]
diff --git a/gateway/sds_gateway/users/urls.py b/gateway/sds_gateway/users/urls.py
index b884c4b4..ac68157b 100644
--- a/gateway/sds_gateway/users/urls.py
+++ b/gateway/sds_gateway/users/urls.py
@@ -9,6 +9,7 @@
 from .views import ListCapturesView
 from .views import UploadCaptureView
 from .views import generate_api_key_form_view
+from .views import keyword_autocomplete_api_view
 from .views import new_api_key_view
 from .views import render_html_fragment_view
 from .views import revoke_api_key_view
@@ -44,6 +45,11 @@
     path("files/<uuid:uuid>/h5info/", FileH5InfoView.as_view(), name="file_h5info"),
     path("dataset-list/", user_dataset_list_view, name="dataset_list"),
     path("dataset-details/", user_dataset_details_view, name="dataset_details"),
+    path(
+        "api/keyword-autocomplete/",
+        keyword_autocomplete_api_view,
+        name="keyword_autocomplete",
+    ),
     path("render-html/", render_html_fragment_view, name="render_html"),
     path("group-captures/", user_group_captures_view, name="group_captures"),
     path(
diff --git a/gateway/sds_gateway/users/views.py b/gateway/sds_gateway/users/views.py
index 41816c2c..32bb6958 100644
--- a/gateway/sds_gateway/users/views.py
+++ b/gateway/sds_gateway/users/views.py
@@ -1,6 +1,5 @@
 import datetime
 import json
-import logging
 import uuid
 from pathlib import Path
 from typing import Any
@@ -27,6 +26,7 @@
 from django.shortcuts import get_object_or_404
 from django.shortcuts import redirect
 from django.shortcuts import render
+from django.template.defaultfilters import slugify
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
@@ -35,6 +35,7 @@
 from django.views.generic import RedirectView
 from django.views.generic import TemplateView
 from django.views.generic import UpdateView
+from loguru import logger as log
 from minio.error import MinioException
 from rest_framework import status
 
@@ -51,6 +52,7 @@
 from sds_gateway.api_methods.models import File
 from sds_gateway.api_methods.models import ItemType
 from sds_gateway.api_methods.models import KeySources
+from sds_gateway.api_methods.models import Keyword
 from sds_gateway.api_methods.models import PermissionLevel
 from sds_gateway.api_methods.models import ShareGroup
 from sds_gateway.api_methods.models import TemporaryZipFile
@@ -107,10 +109,6 @@ def __init__(self, message: str, status_code: int = 400):
         super().__init__(message)
 
 
-# Add logger for debugging
-logger = logging.getLogger(__name__)
-
-
 def get_active_api_key_count(api_keys) -> int:
     """
     Calculate the number of active (non-revoked and non-expired) API keys.
@@ -1148,7 +1146,7 @@ def get(self, request: HttpRequest, uuid: str, *args, **kwargs) -> HttpResponse:
         try:
             content = download_file(file_obj)
         except (MinioException, FileDownloadError) as e:
-            logger.warning("Error downloading file %s: %s", file_obj.name, e)
+            log.warning("Error downloading file %s: %s", file_obj.name, e)
             return JsonResponse({"error": "Failed to download file"}, status=500)
 
         response = HttpResponse(
@@ -1187,7 +1185,7 @@ def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
         try:
             return get_file_content_response(file_obj, self.MAX_BYTES)
         except OSError as e:
-            logger.warning("Error reading file content for preview: %s", e)
+            log.warning("Error reading file content for preview: %s", e)
             return JsonResponse({"error": "Error reading file"}, status=500)
 
 
@@ -1421,7 +1419,6 @@ def _extract_request_params(self, request):
 
     def get(self, request, *args, **kwargs) -> JsonResponse:
         """Handle AJAX requests for the captures API."""
-        logger = logging.getLogger(__name__)
 
         try:
             # Extract and validate parameters
@@ -1496,10 +1493,10 @@ def get(self, request, *args, **kwargs) -> JsonResponse:
             return JsonResponse(response_data)
 
         except (ValueError, TypeError) as e:
-            logger.warning("Invalid parameter in captures API request: %s", e)
+            log.warning("Invalid parameter in captures API request: %s", e)
             return JsonResponse({"error": "Invalid search parameters"}, status=400)
         except DatabaseError:
-            logger.exception("Database error in captures API request")
+            log.exception("Database error in captures API request")
             return JsonResponse({"error": "Database error occurred"}, status=500)
 
 
@@ -1507,6 +1504,38 @@ def get(self, request, *args, **kwargs) -> JsonResponse:
 user_captures_api_view = CapturesAPIView.as_view()
 
 
+class KeywordAutocompleteAPIView(Auth0LoginRequiredMixin, View):
+    """Handle API requests for keyword autocomplete suggestions."""
+
+    def get(self, request, *args, **kwargs) -> JsonResponse:
+        """
+        Return keyword suggestions based on search query.
+
+        Returns up to 10 unique keyword suggestions that match the query
+        anywhere in the keyword.
+        """
+        query = request.GET.get("q", "").strip()
+
+        if not query:
+            return JsonResponse({"suggestions": []})
+
+        try:
+            # Search for keywords that contain the query anywhere (case-insensitive)
+            keywords = Keyword.objects.filter(
+                name__icontains=query,
+                is_deleted=False,
+            ).values_list("name", flat=True)[:10]
+
+            return JsonResponse({"suggestions": list(keywords)})
+
+        except DatabaseError:
+            log.exception("Database error in keyword autocomplete")
+            return JsonResponse({"error": "Database error occurred"}, status=500)
+
+
+keyword_autocomplete_api_view = KeywordAutocompleteAPIView.as_view()
+
+
 class GroupCapturesView(
     Auth0LoginRequiredMixin, FormSearchMixin, FileTreeMixin, TemplateView
 ):
@@ -1650,6 +1679,9 @@ def get_context_data(self, **kwargs):
                 initial_data = {
                     "name": existing_dataset.name,
                     "description": existing_dataset.description,
+                    "keywords": ", ".join(
+                        existing_dataset.keywords.values_list("name", flat=True)
+                    ),
                     "authors": authors_json,
                     "status": existing_dataset.status,
                 }
@@ -1729,7 +1761,7 @@ def post(self, request, *args, **kwargs):
             return self._handle_dataset_creation(request)
 
         except (DatabaseError, IntegrityError) as e:
-            logger.exception("Database error in dataset creation")
+            log.exception("Database error in dataset creation")
             return JsonResponse(
                 {"success": False, "errors": {"non_field_errors": [str(e)]}},
                 status=500,
@@ -1875,6 +1907,24 @@ def _handle_dataset_edit(self, request, dataset_uuid: str) -> JsonResponse:
                 dataset.status = dataset_form.cleaned_data["status"]
                 dataset.save()
 
+                # Handle keywords update
+                # Clear existing keyword relationships
+                dataset.keywords.clear()
+                # Persist keywords from form (comma-separated)
+                raw_keywords = dataset_form.cleaned_data.get("keywords", "") or ""
+                if raw_keywords:
+                    # Slugify and deduplicate keywords
+                    slugified_keywords = {
+                        slugify(p.strip())
+                        for p in raw_keywords.split(",")
+                        if p.strip() and slugify(p.strip())
+                    }
+
+                    # Get or create keywords and associate them with the dataset
+                    for slug in slugified_keywords:
+                        keyword, _created = Keyword.objects.get_or_create(name=slug)
+                        keyword.datasets.add(dataset)
+
         # Handle asset changes
         asset_changes = self._parse_asset_changes(request)
 
@@ -2047,6 +2097,8 @@ def _create_or_update_dataset(self, request, dataset_form) -> Dataset:
             # Clear existing relationships
             dataset.captures.clear()
             dataset.files.clear()
+            # Clear existing keyword relationships (not the keywords themselves)
+            dataset.keywords.clear()
         else:
             # Create new dataset
             # Parse authors from JSON string
@@ -2060,6 +2112,21 @@ def _create_or_update_dataset(self, request, dataset_form) -> Dataset:
                 owner=request.user,
             )
 
+        # Persist keywords from form (comma-separated)
+        raw_keywords = dataset_form.cleaned_data.get("keywords", "") or ""
+        if raw_keywords:
+            # Slugify and deduplicate keywords
+            slugified_keywords = {
+                slugify(p.strip())
+                for p in raw_keywords.split(",")
+                if p.strip() and slugify(p.strip())
+            }
+
+            # Get or create keywords and associate them with the dataset
+            for slug in slugified_keywords:
+                keyword, _created = Keyword.objects.get_or_create(name=slug)
+                keyword.datasets.add(dataset)
+
         return dataset
 
     def _add_captures_to_dataset(
@@ -2223,7 +2290,11 @@ def _build_order_by(self, sort_by: str, sort_order: str) -> str:
 
     def _get_owned_datasets(self, user: User, order_by: str) -> QuerySet[Dataset]:
         """Get datasets owned by the user."""
-        return user.datasets.filter(is_deleted=False).all().order_by(order_by)
+        return (
+            user.datasets.filter(is_deleted=False)
+            .prefetch_related("keywords")
+            .order_by(order_by)
+        )
 
     def _get_shared_datasets(self, user: User, order_by: str) -> QuerySet[Dataset]:
         """Get datasets shared with the user."""
@@ -2238,6 +2309,7 @@ def _get_shared_datasets(self, user: User, order_by: str) -> QuerySet[Dataset]:
         return (
             Dataset.objects.filter(uuid__in=shared_dataset_uuids, is_deleted=False)
             .exclude(owner=user)
+            .prefetch_related("keywords")
             .order_by(order_by)
         )
 
@@ -2356,8 +2428,8 @@ def _apply_frequency_filters(
 
         return qs.filter(uuid__in=filtered_uuids)
 
-    except Exception:
-        logger.exception("Error applying frequency filters")
+    except Exception:  # noqa: BLE001
+        log.exception("Error applying frequency filters")
         return qs  # Return unfiltered queryset on error
 
 
@@ -2423,7 +2495,7 @@ def get(self, request, *args, **kwargs) -> HttpResponse:
         """Display download page for a temporary zip file or serve the file."""
         zip_uuid = kwargs.get("uuid")
         if not zip_uuid:
-            logger.warning("No UUID provided in temporary zip download request")
+            log.warning("No UUID provided in temporary zip download request")
             error_msg = "UUID is required"
             raise Http404(error_msg)
 
@@ -2474,7 +2546,7 @@ def get(self, request, *args, **kwargs) -> HttpResponse:
             return render(request, template_name=self.template_name, context=context)
 
         except TemporaryZipFile.DoesNotExist as err:
-            logger.warning(
+            log.warning(
                 "Temporary zip file not found: %s for user: %s",
                 zip_uuid,
                 request.user.id,
@@ -2492,11 +2564,11 @@ def _serve_file_download(self, zip_uuid: str, user) -> HttpResponse:
                 owner=user,
             )
 
-            logger.info("Found temporary zip file: %s", temp_zip.filename)
+            log.info("Found temporary zip file: %s", temp_zip.filename)
 
             file_path = Path(temp_zip.file_path)
             if not file_path.exists():
-                logger.warning("File not found on disk: %s", temp_zip.file_path)
+                log.warning("File not found on disk: %s", temp_zip.file_path)
                 return JsonResponse(
                     {"error": "The file was not found on the server."}, status=404
                 )
@@ -2517,7 +2589,7 @@ def _serve_file_download(self, zip_uuid: str, user) -> HttpResponse:
                 return response
 
         except OSError:
-            logger.exception("Error reading file: %s", temp_zip.file_path)
+            log.exception("Error reading file: %s", temp_zip.file_path)
             return JsonResponse({"error": "Error reading file."}, status=500)
 
 
@@ -2733,8 +2805,8 @@ def get(self, request, *args, **kwargs) -> JsonResponse:
 
         except Dataset.DoesNotExist:
             return JsonResponse({"error": "Dataset not found"}, status=404)
-        except Exception:
-            logger.exception("Error retrieving dataset details")
+        except Exception:  # noqa: BLE001
+            log.exception("Error retrieving dataset details")
             return JsonResponse({"error": "Internal server error"}, status=500)
 
 
@@ -2770,7 +2842,7 @@ def post(self, request: HttpRequest) -> JsonResponse:
 
             # Security: Only allow templates from users/components/ directory
             if not template_name.startswith("users/components/"):
-                logger.error(
+                log.error(
                     "Invalid template path: %s",
                     template_name,
                 )
@@ -2788,8 +2860,8 @@ def post(self, request: HttpRequest) -> JsonResponse:
             return JsonResponse({"html": html})
         except json.JSONDecodeError:
             return JsonResponse({"error": "Invalid JSON"}, status=400)
-        except Exception as e:
-            logger.exception(
+        except Exception as e:  # noqa: BLE001
+            log.exception(
                 "Error rendering template %s", data.get("template", "unknown")
             )
             return JsonResponse({"error": str(e)}, status=500)
@@ -3233,7 +3305,7 @@ def _process_file_uploads(
 
         # Validate that both lists have the same length before processing
         if len(upload_chunk_files) != len(relative_paths):
-            logger.error(
+            log.error(
                 "upload_chunk_files and relative_paths have different lengths: "
                 "%d vs %d",
                 len(upload_chunk_files),
@@ -3254,7 +3326,7 @@ def _process_file_uploads(
 
             # Skip empty files (these are placeholders for skipped files)
             if file_size == 0:
-                logger.info(
+                log.info(
                     "Skipping empty file: %s (likely a placeholder for skipped file)",
                     filename,
                 )
@@ -3279,7 +3351,7 @@ def _process_file_uploads(
                 else:
                     error_msg = f"Failed to upload {filename}: {response.data}"
                     file_errors.append(error_msg)
-                    logger.error(error_msg)
+                    log.error(error_msg)
             file_errors.extend(upload_errors)
         file_errors.extend(skipped_files)
         return saved_files_count, file_errors
@@ -3306,10 +3378,10 @@ def _create_capture_with_endpoint_helper(
                 request, capture_data
             )
         except (ValueError, TypeError, AttributeError) as exc:
-            logger.exception("Data validation error creating capture")
+            log.exception("Data validation error creating capture")
             return None, f"Data validation error: {exc}"
         except (ConnectionError, TimeoutError) as exc:
-            logger.exception("Network error creating capture")
+            log.exception("Network error creating capture")
             return None, f"Network error: {exc}"
         else:
             if responses:
@@ -3320,7 +3392,7 @@ def _create_capture_with_endpoint_helper(
                     # Extract only the UUID since that's all we use
                     capture_uuid = capture_data.get("uuid")
                     return capture_uuid, None
-                logger.warning(
+                log.warning(
                     "Unexpected response format: %s",
                     response.data,
                 )
@@ -3330,7 +3402,7 @@ def _create_capture_with_endpoint_helper(
                 )
             # Capture creation failed
             error_msg = capture_errors[0] if capture_errors else "Unknown error"
-            logger.error(
+            log.error(
                 "Failed to create capture: %s",
                 error_msg,
             )
@@ -3565,7 +3637,7 @@ def _process_capture_creation(
         created_captures = []
 
         if has_required_fields:
-            logger.info(
+            log.info(
                 "Creating captures - has_required_fields: %s, capture_type: %s, "
                 "channels: %s, scan_group: %s",
                 has_required_fields,
@@ -3591,7 +3663,7 @@ def _process_capture_creation(
             )
 
             if capture_errors:
-                logger.error("Capture creation errors: %s", capture_errors)
+                log.error("Capture creation errors: %s", capture_errors)
         else:
             created_captures = []
             capture_errors = []
@@ -3629,7 +3701,7 @@ def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> JsonResponse:
                 all_files_empty = True
 
             # Debug logging for request data
-            logger.info(
+            log.info(
                 "Upload request - files count: %s, all_relative_paths count: %s, "
                 "all_files_empty: %s, capture_type: %s, channels: %s, scan_group: %s",
                 len(upload_chunk_files) if upload_chunk_files else 0,
@@ -3679,12 +3751,12 @@ def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> JsonResponse:
                     has_required_fields=has_required_fields,
                 )
             elif should_create_captures and file_errors:
-                logger.info(
+                log.info(
                     "Skipping capture creation due to file upload errors: %s",
                     file_errors,
                 )
             else:
-                logger.info(
+                log.info(
                     "Skipping capture creation for chunk %s of %s",
                     chunk_number,
                     total_chunks,
@@ -3692,7 +3764,7 @@ def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> JsonResponse:
 
             # Log file upload errors if they occurred
             if file_errors and not all_files_empty:
-                logger.error(
+                log.error(
                     "File upload errors occurred. Errors: %s",
                     file_errors,
                 )
@@ -3719,9 +3791,7 @@ def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> JsonResponse:
             return JsonResponse(file_capture_response_data)
 
         except (ValueError, TypeError, AttributeError) as e:
-            logger.warning(
-                "Data validation error in UploadCaptureView.post: %s", str(e)
-            )
+            log.warning("Data validation error in UploadCaptureView.post: %s", str(e))
             return JsonResponse(
                 {
                     "success": False,
@@ -3732,7 +3802,7 @@ def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> JsonResponse:
                 status=400,
             )
         except (ConnectionError, TimeoutError) as e:
-            logger.exception("Network error in UploadCaptureView.post")
+            log.exception("Network error in UploadCaptureView.post")
             return JsonResponse(
                 {
                     "success": False,
@@ -3742,8 +3812,8 @@ def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> JsonResponse:
                 },
                 status=503,
             )
-        except Exception as e:
-            logger.exception("Unexpected error in UploadCaptureView.post")
+        except Exception as e:  # noqa: BLE001
+            log.exception("Unexpected error in UploadCaptureView.post")
             return JsonResponse(
                 {
                     "success": False,
@@ -3826,7 +3896,7 @@ def get(self, request, *args, **kwargs) -> HttpResponse:
         current_dir = request.GET.get("dir", "/")
 
         # Debug logging
-        logger.debug("FilesView: current_dir=%s", current_dir)
+        log.debug("FilesView: current_dir=%s", current_dir)
 
         # Initialize items list with proper typing
         items: list[Item] = []
@@ -3858,11 +3928,11 @@ def get(self, request, *args, **kwargs) -> HttpResponse:
         breadcrumb_parts = build_breadcrumbs(nav_context.to_path(), request.user.email)
 
         # Debug logging
-        logger.debug(
+        log.debug(
             "FilesView: context summary items=%d",
             len(items),
         )
-        logger.debug(
+        log.debug(
             "FilesView: first items preview=%s",
             items[:3] if items else "No items",
         )
@@ -3870,7 +3940,7 @@ def get(self, request, *args, **kwargs) -> HttpResponse:
         # Additional debugging for directory items
         for i, item in enumerate(items):
             if hasattr(item, "type") and item.type == "directory":
-                logger.debug("FilesView: directory item %d => %s", i, item)
+                log.debug("FilesView: directory item %d => %s", i, item)
 
         # Convert Pydantic models to dictionaries for template
         items_data = items_to_dicts(items)