diff --git a/client/src/api/schema/schema.ts b/client/src/api/schema/schema.ts
index 057ea7c8c031..1eb290ef5ae3 100644
--- a/client/src/api/schema/schema.ts
+++ b/client/src/api/schema/schema.ts
@@ -1504,6 +1504,10 @@ export interface paths {
          */
         get: operations["version_api_version_get"];
     };
+    "/api/visualizations": {
+        /** Returns visualizations for the current user. */
+        get: operations["index_api_visualizations_get"];
+    };
     "/api/visualizations/{id}/disable_link_access": {
         /**
          * Makes this item inaccessible by a URL link.
@@ -1534,7 +1538,7 @@ export interface paths {
     };
     "/api/visualizations/{id}/sharing": {
         /**
-         * Get the current sharing status of the given Page.
+         * Get the current sharing status of the given Visualization.
          * @description Return the sharing status of the item.
          */
         get: operations["sharing_api_visualizations__id__sharing_get"];
@@ -9446,6 +9450,81 @@ export interface components {
          * @description Base model definition with common configuration used by all derived models.
          */
         Visualization: Record<string, never>;
+        /**
+         * VisualizationSummary
+         * @description Base model definition with common configuration used by all derived models.
+         */
+        VisualizationSummary: {
+            /**
+             * Annotation
+             * @description The annotation of this Visualization.
+             */
+            annotation?: string;
+            /**
+             * Create Time
+             * Format: date-time
+             * @description The time and date this item was created.
+             */
+            create_time?: string;
+            /**
+             * DbKey
+             * @description The database key of the visualization.
+             */
+            dbkey?: string;
+            /**
+             * Deleted
+             * @description Whether this Visualization has been deleted.
+             */
+            deleted: boolean;
+            /**
+             * ID
+             * @description Encoded ID of the Visualization.
+             * @example 0123456789ABCDEF
+             */
+            id: string;
+            /**
+             * Importable
+             * @description Whether this Visualization can be imported.
+             */
+            importable: boolean;
+            /**
+             * Published
+             * @description Whether this Visualization has been published.
+             */
+            published: boolean;
+            /**
+             * Tags
+             * @description A list of tags to add to this item.
+             */
+            tags: components["schemas"]["TagCollection"];
+            /**
+             * Title
+             * @description The name of the visualization.
+             */
+            title: string;
+            /**
+             * Type
+             * @description The type of the visualization.
+             */
+            type: string;
+            /**
+             * Update Time
+             * Format: date-time
+             * @description The last time and date this item was updated.
+             */
+            update_time?: string;
+            /**
+             * Username
+             * @description The name of the user owning this Visualization.
+             */
+            username: string;
+        };
+        /**
+         * VisualizationSummaryList
+         * @description Base model definition with common configuration used by all derived models.
+         * @default []
+         */
+        VisualizationSummaryList: components["schemas"]["VisualizationSummary"][];
         /**
          * WorkflowInvocationStateSummary
          * @description Base model definition with common configuration used by all derived models.
@@ -17858,6 +17937,82 @@ export interface operations {
             };
         };
     };
+    index_api_visualizations_get: {
+        /** Returns visualizations for the current user. */
+        parameters?: {
+            /** @description Whether to include deleted visualizations in the result. */
+            /** @description The maximum number of items to return. */
+            /** @description Starts at the beginning skip the first ( offset - 1 ) items and begin returning at the Nth item */
+            /** @description Sort visualization index by this specified attribute on the visualization model */
+            /** @description Sort in descending order? */
+            /**
+             * @description A mix of free text and GitHub-style tags used to filter the index operation.
+             *
+             * ## Query Structure
+             *
+             * GitHub-style filter tags (not be confused with Galaxy tags) are tags of the form
+             * `<tag_name>:<text_no_spaces>` or `<tag_name>:'<text with potential spaces>'`. The tag name
+             * *generally* (but not exclusively) corresponds to the name of an attribute on the model
+             * being indexed (i.e. a column in the database).
+             *
+             * If the tag is quoted, the attribute will be filtered exactly. If the tag is unquoted,
+             * generally a partial match will be used to filter the query (i.e. in terms of the implementation
+             * this means the database operation `ILIKE` will typically be used).
+             *
+             * Once the tagged filters are extracted from the search query, the remaining text is just
+             * used to search various documented attributes of the object.
+             *
+             * ## GitHub-style Tags Available
+             *
+             * `title`
+             * : The visualization's title.
+             *
+             * `slug`
+             * : The visualization's slug. (The tag `s` can be used a short hand alias for this tag to filter on this attribute.)
+             *
+             * `tag`
+             * : The visualization's tags. (The tag `t` can be used a short hand alias for this tag to filter on this attribute.)
+             *
+             * `user`
+             * : The visualization's owner's username. (The tag `u` can be used a short hand alias for this tag to filter on this attribute.)
+             *
+             * ## Free Text
+             *
+             * Free text search terms will be searched against the following attributes of the
+             * Visualizations: `title`, `slug`, `tag`, `type`.
+             */
+            query?: {
+                deleted?: boolean;
+                limit?: number;
+                offset?: number;
+                user_id?: string;
+                show_own?: boolean;
+                show_published?: boolean;
+                show_shared?: boolean;
+                sort_by?: "create_time" | "title" | "update_time" | "username";
+                sort_desc?: boolean;
+                search?: string;
+            };
+            /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+            header?: {
+                "run-as"?: string;
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["VisualizationSummaryList"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     disable_link_access_api_visualizations__id__disable_link_access_put: {
         /**
          * Makes this item inaccessible by a URL link.
@@ -17985,7 +18140,7 @@ export interface operations {
     };
     sharing_api_visualizations__id__sharing_get: {
         /**
-         * Get the current sharing status of the given Page.
+         * Get the current sharing status of the given Visualization.
          * @description Return the sharing status of the item.
          */
         parameters: {
diff --git a/client/src/components/Grid/GridElements/GridLink.vue b/client/src/components/Grid/GridElements/GridLink.vue
new file mode 100644
index 000000000000..8556fc3bf3b4
--- /dev/null
+++ b/client/src/components/Grid/GridElements/GridLink.vue
@@ -0,0 +1,13 @@
+<script setup lang="ts">
+interface Props {
+    text: string;
+}
+defineProps<Props>();
+const emit = defineEmits<{
+    (e: "click"): void;
+}>();
+</script>
+
+<template>
+    <button class="ui-link font-weight-bold" @click="emit('click')">{{ text }}</button>
+</template>
diff --git a/client/src/components/Grid/GridElements/GridOperations.vue b/client/src/components/Grid/GridElements/GridOperations.vue
new file mode 100644
index 000000000000..d135109286fc
--- /dev/null
+++ b/client/src/components/Grid/GridElements/GridOperations.vue
@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faCaretDown } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+
+import type { Operation, RowData } from "@/components/Grid/configs/types";
+
+library.add(faCaretDown);
+
+interface Props {
+    rowData: RowData;
+    operations: Array<Operation>;
+}
+
+const props = defineProps<Props>();
+
+const emit = defineEmits<{
+    (e: "execute", operation: Operation): void;
+}>();
+
+/**
+ * Availibility of operations might required certain conditions
+ */
+function hasCondition(conditionHandler: (rowData: RowData) => Boolean) {
+    return conditionHandler ? conditionHandler(props.rowData) : true;
+}
+</script>
+
+<template>
+    <span>
+        <button
+            id="grid-operations"
+            data-toggle="dropdown"
+            aria-haspopup="true"
+            aria-expanded="false"
+            class="ui-link font-weight-bold">
+            <FontAwesomeIcon icon="caret-down" class="fa-lg" />
+            <span class="font-weight-bold">{{ rowData.title }}</span>
+        </button>
+        <div v-if="operations" class="dropdown-menu" aria-labelledby="dataset-dropdown">
+            <span v-for="(operation, operationIndex) in operations" :key="operationIndex">
+                <button
+                    v-if="operation && operation.condition && hasCondition(operation.condition)"
+                    class="dropdown-item"
+                    @click.prevent="emit('execute', operation)">
+                    <icon :icon="operation.icon" />
+                    <span v-localize>{{ operation.title }}</span>
+                </button>
+            </span>
+        </div>
+    </span>
+</template>
diff --git a/client/src/components/Grid/GridElements/GridText.vue b/client/src/components/Grid/GridElements/GridText.vue
new file mode 100644
index 000000000000..7128471a6ccc
--- /dev/null
+++ b/client/src/components/Grid/GridElements/GridText.vue
@@ -0,0 +1,10 @@
+<script setup lang="ts">
+interface Props {
+    text?: string;
+}
+defineProps<Props>();
+</script>
+
+<template>
+    <span v-localize>{{ text ?? "Not available." }}</span>
+</template>
diff --git a/client/src/components/Grid/GridList.test.js b/client/src/components/Grid/GridList.test.js
new file mode 100644
index 000000000000..44a94a0e5178
--- /dev/null
+++ b/client/src/components/Grid/GridList.test.js
@@ -0,0 +1,174 @@
+import { mount } from "@vue/test-utils";
+import { getLocalVue } from "tests/jest/helpers";
+import { useRouter } from "vue-router/composables";
+
+import Filtering from "@/utils/filtering";
+
+import MountTarget from "./GridList.vue";
+
+const localVue = getLocalVue();
+
+jest.mock("vue-router/composables");
+
+useRouter.mockImplementation(() => "router");
+
+const testGrid = {
+    actions: [
+        {
+            title: "test",
+            icon: "test-icon",
+            handler: jest.fn(),
+        },
+    ],
+    fields: [
+        {
+            key: "id",
+            title: "id",
+            type: "text",
+        },
+        {
+            key: "link",
+            title: "link",
+            type: "link",
+        },
+        {
+            key: "operation",
+            title: "operation",
+            type: "operations",
+            condition: jest.fn(),
+            operations: [
+                {
+                    title: "operation-title-1",
+                    icon: "operation-icon-1",
+                    condition: () => true,
+                    handler: jest.fn(),
+                },
+                {
+                    title: "operation-title-2",
+                    icon: "operation-icon-2",
+                    condition: () => false,
+                    handler: jest.fn(),
+                },
+                {
+                    title: "operation-title-3",
+                    icon: "operation-icon-3",
+                    condition: () => true,
+                    handler: jest.fn(),
+                },
+            ],
+        },
+    ],
+    filtering: new Filtering({}, undefined, false, false),
+    getData: jest.fn((offset, limit) => {
+        const data = [];
+        for (let i = offset; i < offset + limit; i++) {
+            data.push({
+                id: `id-${i + 1}`,
+                link: `link-${i + 1}`,
+                operation: `operation-${i + 1}`,
+            });
+        }
+        return [data, 100];
+    }),
+    plural: "Tests",
+    sortBy: "id",
+    sortDesc: true,
+    sortKeys: ["id"],
+    title: "Test",
+};
+
+function createTarget(propsData) {
+    return mount(MountTarget, {
+        localVue,
+        propsData,
+        stubs: {
+            Icon: true,
+        },
+    });
+}
+
+describe("GridList", () => {
+    it("basic rendering", async () => {
+        const wrapper = createTarget({
+            config: testGrid,
+        });
+        const findInput = wrapper.find("[data-description='filter text input']");
+        expect(findInput.attributes().placeholder).toBe("search tests");
+        expect(wrapper.find(".loading-message").text()).toBe("Loading...");
+        const findAction = wrapper.find("[data-description='grid action test']");
+        expect(findAction.text()).toBe("test");
+        await findAction.trigger("click");
+        expect(testGrid.actions[0].handler).toHaveBeenCalledTimes(1);
+        expect(testGrid.getData).toHaveBeenCalledTimes(1);
+        expect(testGrid.getData.mock.calls[0]).toEqual([0, 25, "", "id", true]);
+        expect(findAction.find("[icon='test-icon']").exists()).toBeTruthy();
+        await wrapper.vm.$nextTick();
+        expect(wrapper.find("[data-description='grid title']").text()).toBe("Test");
+        expect(wrapper.find("[data-description='grid cell 0-0']").text()).toBe("id-1");
+        expect(wrapper.find("[data-description='grid cell 1-0']").text()).toBe("id-2");
+        expect(wrapper.find("[data-description='grid cell 0-1'] > button").text()).toBe("link-1");
+        expect(wrapper.find("[data-description='grid cell 1-1'] > button").text()).toBe("link-2");
+        const firstHeader = wrapper.find("[data-description='grid header 0']");
+        expect(firstHeader.find("a").text()).toBe("id");
+        await firstHeader.find("[data-description='grid sort asc']").trigger("click");
+        expect(testGrid.getData).toHaveBeenCalledTimes(2);
+        expect(testGrid.getData.mock.calls[1]).toEqual([0, 25, "", "id", false]);
+        expect(firstHeader.find("[data-description='grid sort asc']").exists()).toBeFalsy();
+        expect(firstHeader.find("[data-description='grid sort desc']").exists()).toBeTruthy();
+        const secondHeader = wrapper.find("[data-description='grid header 1']");
+        expect(secondHeader.find("[data-description='grid sort asc']").exists()).toBeFalsy();
+        expect(secondHeader.find("[data-description='grid sort desc']").exists()).toBeFalsy();
+    });
+
+    it("header rendering", async () => {
+        const wrapper = createTarget({
+            config: testGrid,
+        });
+        await wrapper.vm.$nextTick();
+        for (const [fieldIndex, field] of Object.entries(testGrid.fields)) {
+            expect(wrapper.find(`[data-description='grid header ${fieldIndex}']`).text()).toBe(field.title);
+        }
+    });
+
+    it("operation handling", async () => {
+        const wrapper = createTarget({
+            config: testGrid,
+        });
+        await wrapper.vm.$nextTick();
+        const dropdown = wrapper.find("[data-description='grid cell 0-2']");
+        const dropdownItems = dropdown.findAll(".dropdown-item");
+        expect(dropdownItems.at(0).text()).toBe("operation-title-1");
+        expect(dropdownItems.at(1).text()).toBe("operation-title-3");
+        await dropdownItems.at(0).trigger("click");
+        const clickHandler = testGrid.fields[2].operations[0].handler;
+        expect(clickHandler).toHaveBeenCalledTimes(1);
+        expect(clickHandler.mock.calls[0]).toEqual([
+            { id: "id-1", link: "link-1", operation: "operation-1" },
+            "router",
+        ]);
+    });
+
+    it("filter handling", async () => {
+        const wrapper = createTarget({
+            config: testGrid,
+        });
+        await wrapper.vm.$nextTick();
+        const filterInput = wrapper.find("[data-description='filter text input']");
+        await filterInput.setValue("filter query");
+        await new Promise((r) => setTimeout(r, 500));
+        expect(testGrid.getData).toHaveBeenCalledTimes(2);
+        expect(testGrid.getData.mock.calls[1]).toEqual([0, 25, "filter query", "id", true]);
+    });
+
+    it("pagination", async () => {
+        const wrapper = createTarget({
+            config: testGrid,
+            limit: 2,
+        });
+        await wrapper.vm.$nextTick();
+        const pageLinks = wrapper.findAll(".page-link");
+        await pageLinks.at(4).trigger("click");
+        expect(wrapper.find("[data-description='grid cell 0-0']").text()).toBe("id-5");
+        expect(wrapper.find("[data-description='grid cell 1-0']").text()).toBe("id-6");
+    });
+});
diff --git a/client/src/components/Grid/GridList.vue b/client/src/components/Grid/GridList.vue
new file mode 100644
index 000000000000..d43c9716f2d9
--- /dev/null
+++ b/client/src/components/Grid/GridList.vue
@@ -0,0 +1,292 @@
+<script setup lang="ts">
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faCaretDown, faCaretUp } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BAlert, BButton, BLink, BPagination } from "bootstrap-vue";
+import { computed, onMounted, ref, watch } from "vue";
+import { useRouter } from "vue-router/composables";
+
+import { timeout } from "@/utils/timeout";
+
+import { Config, FieldHandler, Operation, RowData } from "./configs/types";
+
+import GridLink from "./GridElements/GridLink.vue";
+import GridOperations from "./GridElements/GridOperations.vue";
+import GridText from "./GridElements/GridText.vue";
+import FilterMenu from "@/components/Common/FilterMenu.vue";
+import SharingIndicators from "@/components/Indices/SharingIndicators.vue";
+import LoadingSpan from "@/components/LoadingSpan.vue";
+import StatelessTags from "@/components/TagsMultiselect/StatelessTags.vue";
+import UtcDate from "@/components/UtcDate.vue";
+
+library.add(faCaretDown, faCaretUp);
+const router = useRouter();
+
+interface Props {
+    // provide a grid configuration
+    config: Config;
+    // rows per page to be shown
+    limit?: number;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+    limit: 25,
+});
+
+// contains the current grid data provided by the corresponding api endpoint
+const gridData = ref();
+
+// message references
+const errorMessage = ref("");
+const operationMessage = ref("");
+const operationStatus = ref("");
+
+// page references
+const currentPage = ref(1);
+const totalRows = ref(0);
+
+// loading indicator
+const loading = ref(true);
+
+// check if loading has completed and data rows are available
+const isAvailable = computed(() => !loading.value && totalRows.value > 0);
+
+// sort references
+const sortBy = ref(props.config ? props.config.sortBy : "");
+const sortDesc = ref(props.config ? props.config.sortDesc : false);
+
+// filtering refs and handlers
+const filterText = ref("");
+const searchTerm = ref("");
+const showAdvanced = ref(false);
+
+/**
+ * Manually set filter value, used for tags and `SharingIndicators`
+ */
+function applyFilter(filter: string, value: string | boolean, quoted = false) {
+    const filtering = props.config?.filtering;
+    const quotedValue = quoted ? `'${value}'` : value;
+    if (filtering) {
+        filterText.value = filtering.setFilterValue(filterText.value, filter, quotedValue.toString()) || "";
+    }
+}
+
+/**
+ * Request grid data
+ */
+async function getGridData() {
+    if (props.config) {
+        try {
+            const offset = props.limit * (currentPage.value - 1);
+            const [responseData, responseTotal] = await props.config.getData(
+                offset,
+                props.limit,
+                searchTerm.value,
+                sortBy.value,
+                sortDesc.value
+            );
+            gridData.value = responseData;
+            totalRows.value = responseTotal;
+            errorMessage.value = "";
+            loading.value = false;
+        } catch (e) {
+            errorMessage.value = `Failed to obtain grid data: ${e}`;
+            loading.value = false;
+        }
+    }
+}
+
+/**
+ * Execute grid operation and display message if available
+ */
+async function onOperation(operation: Operation, rowData: RowData) {
+    const response = await operation.handler(rowData, router);
+    if (response) {
+        await getGridData();
+        operationMessage.value = response.message;
+        operationStatus.value = response.status || "success";
+    }
+}
+
+/**
+ * Apply backend formatted filter and execute grid search
+ */
+function onSearch(query: string) {
+    searchTerm.value = query;
+}
+
+/**
+ * User changes sorting
+ */
+function onSort(sortKey: string) {
+    if (sortBy.value !== sortKey) {
+        sortBy.value = sortKey;
+    } else {
+        sortDesc.value = !sortDesc.value;
+    }
+}
+
+/**
+ * Process tag inputs
+ */
+function onTagInput(data: RowData, tags: Array<string>, tagsHandler?: FieldHandler) {
+    if (tagsHandler) {
+        tagsHandler({ ...data, tags: tags });
+        data.tags = tags;
+    }
+}
+function onFilter(filter?: string) {
+    if (filter) {
+        applyFilter(filter, true);
+    }
+}
+/**
+ * Initialize grid data
+ */
+onMounted(() => {
+    getGridData();
+});
+
+/**
+ * Load current page
+ */
+watch([currentPage, searchTerm, sortDesc, sortBy], () => getGridData());
+
+/**
+ * Operation message timeout handler
+ */
+watch(operationMessage, () => {
+    timeout(() => {
+        operationMessage.value = "";
+    });
+});
+</script>
+
+<template>
+    <div class="d-flex flex-column overflow-auto">
+        <BAlert v-if="!!errorMessage" variant="danger" show>{{ errorMessage }}</BAlert>
+        <BAlert v-if="!!operationMessage" :variant="operationStatus" fade show>{{ operationMessage }}</BAlert>
+        <div class="grid-header d-flex justify-content-between pb-2">
+            <div>
+                <h1 class="m-0" data-description="grid title">
+                    {{ config.title }}
+                </h1>
+                <FilterMenu
+                    class="py-2"
+                    :name="config.plural"
+                    :placeholder="`search ${config.plural.toLowerCase()}`"
+                    :filter-class="config.filtering"
+                    :filter-text.sync="filterText"
+                    :loading="loading"
+                    :show-advanced.sync="showAdvanced"
+                    @on-backend-filter="onSearch" />
+                <hr v-if="showAdvanced" />
+            </div>
+            <div v-if="!showAdvanced" class="py-3">
+                <BButton
+                    v-for="(action, actionIndex) in config.actions"
+                    :key="actionIndex"
+                    class="m-1"
+                    size="sm"
+                    variant="primary"
+                    :data-description="`grid action ${action.title.toLowerCase()}`"
+                    @click="action.handler(router)">
+                    <Icon :icon="action.icon" class="mr-1" />
+                    <span v-localize>{{ action.title }}</span>
+                </BButton>
+            </div>
+        </div>
+        <LoadingSpan v-if="loading" />
+        <BAlert v-else-if="!isAvailable" variant="info" show>
+            <span v-if="searchTerm" v-localize>
+                No entries found for: <b>{{ searchTerm }}</b
+                >.
+            </span>
+            <span v-else v-localize> No entries found. </span>
+        </BAlert>
+        <table v-else class="grid-table">
+            <thead>
+                <th
+                    v-for="(fieldEntry, fieldIndex) in config.fields"
+                    :key="fieldIndex"
+                    class="text-nowrap px-2"
+                    :data-description="`grid header ${fieldIndex}`">
+                    <span v-if="config.sortKeys.includes(fieldEntry.key)">
+                        <BLink @click="onSort(fieldEntry.key)">
+                            <span>{{ fieldEntry.title || fieldEntry.key }}</span>
+                            <span v-if="sortBy === fieldEntry.key">
+                                <FontAwesomeIcon v-if="sortDesc" icon="caret-up" data-description="grid sort asc" />
+                                <FontAwesomeIcon v-else icon="caret-down" data-description="grid sort desc" />
+                            </span>
+                        </BLink>
+                    </span>
+                    <span v-else>{{ fieldEntry.title || fieldEntry.key }}</span>
+                </th>
+            </thead>
+            <tr v-for="(rowData, rowIndex) in gridData" :key="rowIndex" :class="{ 'grid-dark-row': rowIndex % 2 }">
+                <td
+                    v-for="(fieldEntry, fieldIndex) in config.fields"
+                    :key="fieldIndex"
+                    class="px-2 py-3"
+                    :style="{ width: `${fieldEntry.width}%` }"
+                    :data-description="`grid cell ${rowIndex}-${fieldIndex}`">
+                    <GridOperations
+                        v-if="fieldEntry.type == 'operations'"
+                        :operations="fieldEntry.operations"
+                        :row-data="rowData"
+                        @execute="onOperation($event, rowData)" />
+                    <GridText v-else-if="fieldEntry.type == 'text'" :text="rowData[fieldEntry.key]" />
+                    <GridLink
+                        v-else-if="fieldEntry.type == 'link'"
+                        :text="rowData[fieldEntry.key]"
+                        @click="fieldEntry.handler && fieldEntry.handler(rowData, router)" />
+                    <SharingIndicators
+                        v-else-if="fieldEntry.type == 'sharing'"
+                        :object="rowData"
+                        @filter="onFilter($event)" />
+                    <UtcDate v-else-if="fieldEntry.type == 'date'" :date="rowData[fieldEntry.key]" mode="elapsed" />
+                    <StatelessTags
+                        v-else-if="fieldEntry.type == 'tags'"
+                        clickable
+                        :value="rowData[fieldEntry.key]"
+                        :disabled="fieldEntry.disabled"
+                        @input="onTagInput(rowData, $event, fieldEntry.handler)"
+                        @tag-click="applyFilter('tag', $event, true)" />
+                    <span v-else v-localize> Data not available. </span>
+                </td>
+            </tr>
+        </table>
+        <div class="flex-grow-1 h-100" />
+        <div v-if="isAvailable" class="grid-footer d-flex justify-content-center pt-3">
+            <BPagination
+                v-model="currentPage"
+                :total-rows="totalRows"
+                :per-page="limit"
+                class="m-0"
+                size="sm"
+                aria-controls="grid-table" />
+        </div>
+    </div>
+</template>
+
+<style scoped lang="scss">
+@import "theme/blue.scss";
+
+.grid-footer {
+    @extend .grid-sticky;
+    bottom: 0;
+}
+.grid-header {
+    @extend .grid-sticky;
+    top: 0;
+}
+.grid-sticky {
+    z-index: 1;
+    background: $white;
+    opacity: 0.95;
+    position: sticky;
+}
+.grid-dark-row {
+    background: $gray-200;
+}
+</style>
diff --git a/client/src/components/Grid/GridShared.vue b/client/src/components/Grid/GridShared.vue
deleted file mode 100644
index 017beab7eaef..000000000000
--- a/client/src/components/Grid/GridShared.vue
+++ /dev/null
@@ -1,33 +0,0 @@
-<template>
-    <div ref="target" />
-</template>
-
-<script>
-import GridShared from "mvc/grid/grid-shared";
-
-export default {
-    props: {
-        actionId: {
-            type: String,
-            default: null,
-        },
-        plural: {
-            type: String,
-            default: null,
-        },
-        item: {
-            type: String,
-            default: null,
-        },
-    },
-    mounted() {
-        const activeTab = this.actionId == "list_published" ? "shared" : "user";
-        new GridShared.View({
-            action_id: this.actionId,
-            plural: this.plural,
-            item: this.item,
-            active_tab: activeTab,
-        }).$el.appendTo(this.$refs.target);
-    },
-};
-</script>
diff --git a/client/src/components/Grid/configs/types.ts b/client/src/components/Grid/configs/types.ts
new file mode 100644
index 000000000000..80e357fa1b5e
--- /dev/null
+++ b/client/src/components/Grid/configs/types.ts
@@ -0,0 +1,55 @@
+import { IconDefinition } from "@fortawesome/fontawesome-svg-core";
+import type Router from "vue-router";
+
+import Filtering from "@/utils/filtering";
+
+export interface Action {
+    title: string;
+    icon?: IconDefinition;
+    handler: (router: Router) => void;
+}
+
+export type ActionArray = Array<Action>;
+
+export interface Config {
+    actions?: ActionArray;
+    fields: FieldArray;
+    filtering: Filtering<any>;
+    getData: (offset: number, limit: number, search: string, sort_by: string, sort_desc: boolean) => Promise<any>;
+    plural: string;
+    sortBy: string;
+    sortKeys: Array<string>;
+    sortDesc: boolean;
+    title: string;
+}
+
+export type FieldArray = Array<FieldEntry>;
+
+export interface FieldEntry {
+    key: string;
+    title: string;
+    condition?: (data: RowData) => boolean;
+    disabled?: boolean;
+    type: string;
+    operations?: Array<Operation>;
+    handler?: FieldHandler;
+    width?: number;
+}
+
+export type FieldHandler = (data: RowData, router?: Router) => void;
+
+export interface Operation {
+    title: string;
+    icon: IconDefinition;
+    condition?: (data: RowData) => boolean;
+    handler: (data: RowData, router: Router) => OperationHandlerReturn;
+}
+
+interface OperationHandlerMessage {
+    message: string;
+    status: string;
+}
+
+type OperationHandlerReturn = Promise<OperationHandlerMessage> | void;
+
+export type RowData = Record<string, unknown>;
diff --git a/client/src/components/Grid/configs/visualizations.ts b/client/src/components/Grid/configs/visualizations.ts
new file mode 100644
index 000000000000..784aab8a4a68
--- /dev/null
+++ b/client/src/components/Grid/configs/visualizations.ts
@@ -0,0 +1,249 @@
+import { faCopy, faEdit, faEye, faPlus, faShareAlt, faTrash, faTrashRestore } from "@fortawesome/free-solid-svg-icons";
+import axios from "axios";
+import type Router from "vue-router";
+
+import { fetcher } from "@/api/schema";
+import { getGalaxyInstance } from "@/app";
+import Filtering, { contains, equals, expandNameTag, toBool, type ValidFilter } from "@/utils/filtering";
+import { withPrefix } from "@/utils/redirect";
+import { errorMessageAsString, rethrowSimple } from "@/utils/simple-error";
+
+import type { ActionArray, Config, FieldArray } from "./types";
+
+/**
+ * Api endpoint handlers
+ */
+const getVisualizations = fetcher.path("/api/visualizations").method("get").create();
+const updateTags = fetcher.path("/api/tags").method("put").create();
+
+/**
+ * Local types
+ */
+type SortKeyLiteral = "create_time" | "title" | "update_time" | "username" | undefined;
+type VisualizationEntry = Record<string, unknown>;
+
+/**
+ * Request and return data from server
+ */
+async function getData(offset: number, limit: number, search: string, sort_by: string, sort_desc: boolean) {
+    // TODO: Avoid using Galaxy instance to identify current user
+    const Galaxy = getGalaxyInstance();
+    const userId = !Galaxy.isAnonymous && Galaxy.user.id;
+    if (!userId) {
+        rethrowSimple("Please login to access this page.");
+    }
+    const { data, headers } = await getVisualizations({
+        limit,
+        offset,
+        search,
+        sort_by: sort_by as SortKeyLiteral,
+        sort_desc,
+        show_published: false,
+        user_id: userId,
+    });
+    const totalMatches = parseInt(headers.get("total_matches") ?? "0");
+    return [data, totalMatches];
+}
+
+/**
+ * Actions are grid-wide operations
+ */
+const actions: ActionArray = [
+    {
+        title: "Create",
+        icon: faPlus,
+        handler: (router: Router) => {
+            router.push(`/visualizations`);
+        },
+    },
+];
+
+/**
+ * Declare columns to be displayed
+ */
+const fields: FieldArray = [
+    {
+        title: "Title",
+        key: "title",
+        type: "operations",
+        width: 40,
+        condition: (data: VisualizationEntry) => !data.deleted,
+        operations: [
+            {
+                title: "Open",
+                icon: faEye,
+                condition: (data: VisualizationEntry) => !data.deleted,
+                handler: (data: VisualizationEntry) => {
+                    window.location.href = withPrefix(`/plugins/visualizations/${data.type}/saved?id=${data.id}`);
+                },
+            },
+            {
+                title: "Edit Attributes",
+                icon: faEdit,
+                condition: (data: VisualizationEntry) => !data.deleted,
+                handler: (data: VisualizationEntry, router: Router) => {
+                    router.push(`/visualizations/edit?id=${data.id}`);
+                },
+            },
+            {
+                title: "Copy",
+                icon: faCopy,
+                condition: (data: VisualizationEntry) => !data.deleted,
+                handler: async (data: VisualizationEntry) => {
+                    try {
+                        const copyResponse = await axios.get(withPrefix(`/api/visualizations/${data.id}`));
+                        const copyViz = copyResponse.data;
+                        const newViz = {
+                            title: `Copy of '${copyViz.title}'`,
+                            type: copyViz.type,
+                            config: copyViz.latest_revision.config,
+                        };
+                        await axios.post(withPrefix(`/api/visualizations`), newViz);
+                        return {
+                            status: "success",
+                            message: `'${data.title}' has been copied.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to copy '${data.title}': ${errorMessageAsString(e)}.`,
+                        };
+                    }
+                },
+            },
+            {
+                title: "Share and Publish",
+                icon: faShareAlt,
+                condition: (data: VisualizationEntry) => !data.deleted,
+                handler: (data: VisualizationEntry, router: Router) => {
+                    router.push(`/visualizations/sharing?id=${data.id}`);
+                },
+            },
+            {
+                title: "Delete",
+                icon: faTrash,
+                condition: (data: VisualizationEntry) => !data.deleted,
+                handler: async (data: VisualizationEntry) => {
+                    try {
+                        await axios.put(withPrefix(`/api/visualizations/${data.id}`), { deleted: true });
+                        return {
+                            status: "success",
+                            message: `'${data.title}' has been deleted.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to delete '${data.title}': ${errorMessageAsString(e)}.`,
+                        };
+                    }
+                },
+            },
+            {
+                title: "Restore",
+                icon: faTrashRestore,
+                condition: (data: VisualizationEntry) => !!data.deleted,
+                handler: async (data: VisualizationEntry) => {
+                    try {
+                        await axios.put(withPrefix(`/api/visualizations/${data.id}`), { deleted: false });
+                        return {
+                            status: "success",
+                            message: `'${data.title}' has been restored.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to restore '${data.title}': ${errorMessageAsString(e)}.`,
+                        };
+                    }
+                },
+            },
+        ],
+    },
+    {
+        key: "type",
+        title: "Type",
+        type: "text",
+    },
+    {
+        key: "tags",
+        title: "Tags",
+        type: "tags",
+        handler: async (data: VisualizationEntry) => {
+            try {
+                await updateTags({
+                    item_id: data.id as string,
+                    item_class: "Visualization",
+                    item_tags: data.tags as Array<string>,
+                });
+            } catch (e) {
+                rethrowSimple(e);
+            }
+        },
+    },
+    {
+        key: "create_time",
+        title: "Created",
+        type: "date",
+    },
+    {
+        key: "update_time",
+        title: "Updated",
+        type: "date",
+    },
+    {
+        key: "sharing",
+        title: "Shared",
+        type: "sharing",
+    },
+];
+
+/**
+ * Declare filter options
+ */
+const validFilters: Record<string, ValidFilter<string | boolean | undefined>> = {
+    title: { placeholder: "title", type: String, handler: contains("title"), menuItem: true },
+    slug: { handler: contains("slug"), menuItem: false },
+    tag: {
+        placeholder: "tag(s)",
+        type: "MultiTags",
+        handler: contains("tag", "tag", expandNameTag),
+        menuItem: true,
+    },
+    published: {
+        placeholder: "Filter on published visualizations",
+        type: Boolean,
+        boolType: "is",
+        handler: equals("published", "published", toBool),
+        menuItem: true,
+    },
+    importable: {
+        placeholder: "Filter on importable visualizations",
+        type: Boolean,
+        boolType: "is",
+        handler: equals("importable", "importable", toBool),
+        menuItem: true,
+    },
+    deleted: {
+        placeholder: "Filter on deleted visualizations",
+        type: Boolean,
+        boolType: "is",
+        handler: equals("deleted", "deleted", toBool),
+        menuItem: true,
+    },
+};
+
+/**
+ * Grid configuration
+ */
+const config: Config = {
+    actions: actions,
+    fields: fields,
+    filtering: new Filtering(validFilters, undefined, false, false),
+    getData: getData,
+    plural: "Visualizations",
+    sortBy: "update_time",
+    sortDesc: true,
+    sortKeys: ["create_time", "title", "update_time"],
+    title: "Saved Visualizations",
+};
+export default config;
diff --git a/client/src/components/Grid/configs/visualizationsPublished.ts b/client/src/components/Grid/configs/visualizationsPublished.ts
new file mode 100644
index 000000000000..0be07fb90dbe
--- /dev/null
+++ b/client/src/components/Grid/configs/visualizationsPublished.ts
@@ -0,0 +1,96 @@
+import { fetcher } from "@/api/schema";
+import Filtering, { contains, expandNameTag, type ValidFilter } from "@/utils/filtering";
+import { withPrefix } from "@/utils/redirect";
+
+/**
+ * Api endpoint handlers
+ */
+const getVisualizations = fetcher.path("/api/visualizations").method("get").create();
+
+/**
+ * Local types
+ */
+type SortKeyLiteral = "create_time" | "title" | "update_time" | "username" | undefined;
+type VisualizationEntry = Record<string, unknown>;
+
+/**
+ * Request and return data from server
+ */
+async function getData(offset: number, limit: number, search: string, sort_by: string, sort_desc: boolean) {
+    const { data, headers } = await getVisualizations({
+        limit,
+        offset,
+        search,
+        sort_by: sort_by as SortKeyLiteral,
+        sort_desc,
+        show_own: false,
+        show_published: true,
+        show_shared: true,
+    });
+    const totalMatches = parseInt(headers.get("total_matches") ?? "0");
+    return [data, totalMatches];
+}
+
+/**
+ * Declare columns to be displayed
+ */
+const fields = [
+    {
+        title: "Title",
+        key: "title",
+        type: "link",
+        width: "30%",
+        handler: (data: VisualizationEntry) => {
+            window.location.href = withPrefix(`/plugins/visualizations/${data.type}/saved?id=${data.id}`);
+        },
+    },
+    {
+        key: "annotation",
+        title: "Annotation",
+        type: "text",
+    },
+    {
+        key: "username",
+        title: "Owner",
+        type: "text",
+    },
+    {
+        key: "tags",
+        title: "Tags",
+        type: "tags",
+        disabled: true,
+    },
+    {
+        key: "update_time",
+        title: "Updated",
+        type: "date",
+    },
+];
+
+/**
+ * Declare filter options
+ */
+const validFilters: Record<string, ValidFilter<string | boolean | undefined>> = {
+    title: { placeholder: "title", type: String, handler: contains("title"), menuItem: true },
+    slug: { handler: contains("slug"), menuItem: false },
+    tag: {
+        placeholder: "tag(s)",
+        type: "MultiTags",
+        handler: contains("tag", "tag", expandNameTag),
+        menuItem: true,
+    },
+};
+
+/**
+ * Grid configuration
+ */
+export default {
+    fields: fields,
+    filtering: new Filtering(validFilters, undefined, false, false),
+    getData: getData,
+    plural: "Visualizations",
+    sortBy: "update_time",
+    sortDesc: true,
+    sortKeys: ["create_time", "title", "update_time"],
+    title: "Published Visualizations",
+};
diff --git a/client/src/components/Indices/SharingIndicators.vue b/client/src/components/Indices/SharingIndicators.vue
index b2f1cd3fdae2..529a99dd3ed5 100644
--- a/client/src/components/Indices/SharingIndicators.vue
+++ b/client/src/components/Indices/SharingIndicators.vue
@@ -1,10 +1,10 @@
 <script setup lang="ts">
 import { library } from "@fortawesome/fontawesome-svg-core";
-import { faGlobe, faLink, faShareAlt } from "@fortawesome/free-solid-svg-icons";
+import { faGlobe, faLink, faShareAlt, faUsers } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
 import { BButton, VBTooltip } from "bootstrap-vue";
 
-library.add(faGlobe, faShareAlt, faLink);
+library.add(faGlobe, faShareAlt, faLink, faUsers);
 
 interface SharingIndicatorsProps {
     object: Object;
diff --git a/client/src/entry/analysis/router.js b/client/src/entry/analysis/router.js
index c995cf368c40..81283b5c7be4 100644
--- a/client/src/entry/analysis/router.js
+++ b/client/src/entry/analysis/router.js
@@ -7,8 +7,10 @@ import DatasetAttributes from "components/DatasetInformation/DatasetAttributes";
 import DatasetDetails from "components/DatasetInformation/DatasetDetails";
 import DatasetError from "components/DatasetInformation/DatasetError";
 import FormGeneric from "components/Form/FormGeneric";
+import visualizationsGrid from "components/Grid/configs/visualizations";
+import visualizationsPublishedGrid from "components/Grid/configs/visualizationsPublished";
 import GridHistory from "components/Grid/GridHistory";
-import GridShared from "components/Grid/GridShared";
+import GridList from "components/Grid/GridList";
 import HistoryExportTasks from "components/History/Export/HistoryExport";
 import HistoryPublished from "components/History/HistoryPublished";
 import HistoryPublishedList from "components/History/HistoryPublishedList";
@@ -454,13 +456,18 @@ export function getRouter(Galaxy) {
                         }),
                     },
                     {
-                        path: "visualizations/:actionId",
-                        component: GridShared,
-                        props: (route) => ({
-                            actionId: route.params.actionId,
-                            item: "visualization",
-                            plural: "Visualizations",
-                        }),
+                        path: "visualizations/list",
+                        component: GridList,
+                        props: {
+                            config: visualizationsGrid,
+                        },
+                    },
+                    {
+                        path: "visualizations/list_published",
+                        component: GridList,
+                        props: {
+                            config: visualizationsPublishedGrid,
+                        },
                     },
                     {
                         path: "welcome/new",
diff --git a/client/src/mvc/grid/grid-shared.js b/client/src/mvc/grid/grid-shared.js
deleted file mode 100644
index 9c06c698317e..000000000000
--- a/client/src/mvc/grid/grid-shared.js
+++ /dev/null
@@ -1,69 +0,0 @@
-/** This class renders the grid list with shared section. */
-import { getGalaxyInstance } from "app";
-import Backbone from "backbone";
-import $ from "jquery";
-import GridView from "mvc/grid/grid-view";
-import { getAppRoot } from "onload/loadConfig";
-import LoadingIndicator from "ui/loading-indicator";
-import _ from "underscore";
-
-var View = Backbone.View.extend({
-    initialize: function (options) {
-        var self = this;
-        const Galaxy = getGalaxyInstance();
-        LoadingIndicator.markViewAsLoading(this);
-        this.model = new Backbone.Model(options);
-        this.item = this.model.get("item");
-        this.title = this.model.get("plural");
-        if (options && options.active_tab) {
-            this.active_tab = options.active_tab;
-        }
-        $.ajax({
-            url: `${getAppRoot() + this.item}/${this.model.get("action_id")}?${$.param(Galaxy.params)}`,
-            success: function (response) {
-                self.model.set(response);
-                self.render();
-            },
-        });
-    },
-
-    render: function () {
-        var grid = new GridView(this.model.attributes);
-        this.$el.empty().append(grid.$el);
-        this.$el.append(this._templateShared());
-    },
-
-    _templateShared: function () {
-        var self = this;
-        var $tmpl = $(`<div><br/><h2>${this.model.get("plural")} shared with you by others</h2></div>`);
-        var options = this.model.attributes;
-        if (options.shared_by_others && options.shared_by_others.length > 0) {
-            var $table = $(
-                '<table class="colored" border="0" cellspacing="0" cellpadding="0" width="100%">' +
-                    '<tr class="header">' +
-                    "<th>Title</th>" +
-                    "<th>Owner</th>" +
-                    "</tr>" +
-                    "</table>"
-            );
-            _.each(options.shared_by_others, (it, index) => {
-                var display_url = `${getAppRoot() + self.item}/display_by_username_and_slug?username=${
-                    it.username
-                }&slug=${it.slug}`;
-                $table.append(
-                    `<tr><td><a href="${display_url}">${_.escape(it.title)}</a></td><td>${_.escape(
-                        it.username
-                    )}</td></tr>`
-                );
-            });
-            $tmpl.append($table);
-        } else {
-            $tmpl.append(`No ${this.model.get("plural").toLowerCase()} have been shared with you.`);
-        }
-        return $tmpl;
-    },
-});
-
-export default {
-    View: View,
-};
diff --git a/client/src/utils/timeout.ts b/client/src/utils/timeout.ts
new file mode 100644
index 000000000000..29845b06b9eb
--- /dev/null
+++ b/client/src/utils/timeout.ts
@@ -0,0 +1,7 @@
+let timeoutHandler: ReturnType<typeof setTimeout> | null = null;
+export const timeout = (callback: () => void, delay = 5000) => {
+    if (timeoutHandler) {
+        clearTimeout(timeoutHandler);
+    }
+    timeoutHandler = setTimeout(callback, delay);
+};
diff --git a/lib/galaxy/managers/visualizations.py b/lib/galaxy/managers/visualizations.py
index 59657a902853..6a1db77d3570 100644
--- a/lib/galaxy/managers/visualizations.py
+++ b/lib/galaxy/managers/visualizations.py
@@ -5,20 +5,63 @@
 reproduce a specific view in a Galaxy visualization.
 """
 import logging
-
-from galaxy import model
-from galaxy.managers import sharable
+from typing import (
+    Dict,
+    List,
+    Tuple,
+)
+
+from sqlalchemy import (
+    false,
+    or_,
+    true,
+)
+from sqlalchemy.orm import aliased
+
+from galaxy import (
+    exceptions,
+    model,
+)
+from galaxy.managers import (
+    base,
+    sharable,
+)
+from galaxy.managers.context import ProvidesUserContext
+from galaxy.model.index_filter_util import (
+    append_user_filter,
+    raw_text_column_filter,
+    tag_filter,
+    text_column_filter,
+)
+from galaxy.schema.visualization import VisualizationIndexQueryPayload
 from galaxy.structured_app import MinimalManagerApp
+from galaxy.util.search import (
+    FilteredTerm,
+    parse_filters_structured,
+    RawTextTerm,
+)
 
 log = logging.getLogger(__name__)
 
 
+INDEX_SEARCH_FILTERS = {
+    "title": "title",
+    "slug": "slug",
+    "tag": "tag",
+    "user": "user",
+    "u": "user",
+    "s": "slug",
+    "t": "tag",
+    "is": "is",
+}
+
+
 class VisualizationManager(sharable.SharableModelManager):
     """
     Handle operations outside and between visualizations and other models.
     """
 
-    # TODO: revisions
+    # TODO: copy, revisions
 
     model_class = model.Visualization
     foreign_key_name = "visualization"
@@ -28,10 +71,104 @@ class VisualizationManager(sharable.SharableModelManager):
     annotation_assoc = model.VisualizationAnnotationAssociation
     rating_assoc = model.VisualizationRatingAssociation
 
-    # def copy( self, trans, visualization, user, **kwargs ):
-    #    """
-    #    """
-    #    pass
+    def index_query(
+        self, trans: ProvidesUserContext, payload: VisualizationIndexQueryPayload, include_total_count: bool = False
+    ) -> Tuple[List[model.Visualization], int]:
+        show_deleted = payload.deleted
+        show_shared = payload.show_shared
+        show_published = payload.show_published
+        show_own = payload.show_own
+        is_admin = trans.user_is_admin
+        user = trans.user
+
+        if show_shared is None:
+            show_shared = not show_deleted
+
+        if show_shared and show_deleted:
+            message = "show_shared and show_deleted cannot both be specified as true"
+            raise exceptions.RequestParameterInvalidException(message)
+
+        query = trans.sa_session.query(self.model_class)
+
+        filters = []
+        if show_own or (not show_published and not is_admin):
+            filters = [self.model_class.user == user]
+        if show_published:
+            filters.append(self.model_class.published == true())
+        if user and show_shared:
+            filters.append(self.user_share_model.user == user)
+            query = query.outerjoin(self.model_class.users_shared_with)
+        query = query.filter(or_(*filters))
+
+        if payload.user_id:
+            query = query.filter(self.model_class.user_id == payload.user_id)
+
+        if payload.search:
+            search_query = payload.search
+            parsed_search = parse_filters_structured(search_query, INDEX_SEARCH_FILTERS)
+
+            def p_tag_filter(term_text: str, quoted: bool):
+                nonlocal query
+                alias = aliased(model.VisualizationTagAssociation)
+                query = query.outerjoin(self.model_class.tags.of_type(alias))
+                return tag_filter(alias, term_text, quoted)
+
+            for term in parsed_search.terms:
+                if isinstance(term, FilteredTerm):
+                    key = term.filter
+                    q = term.text
+                    if key == "tag":
+                        pg = p_tag_filter(term.text, term.quoted)
+                        query = query.filter(pg)
+                    elif key == "title":
+                        query = query.filter(text_column_filter(self.model_class.title, term))
+                    elif key == "slug":
+                        query = query.filter(text_column_filter(self.model_class.slug, term))
+                    elif key == "user":
+                        query = append_user_filter(query, self.model_class, term)
+                    elif key == "is":
+                        if q == "deleted":
+                            show_deleted = True
+                        if q == "published":
+                            query = query.filter(self.model_class.published == true())
+                        if q == "importable":
+                            query = query.filter(self.model_class.importable == true())
+                        elif q == "shared_with_me":
+                            if not show_shared:
+                                message = "Can only use tag is:shared_with_me if show_shared parameter also true."
+                                raise exceptions.RequestParameterInvalidException(message)
+                            query = query.filter(self.user_share_model.user == user)
+                elif isinstance(term, RawTextTerm):
+                    tf = p_tag_filter(term.text, False)
+                    alias = aliased(model.User)
+                    query = query.outerjoin(self.model_class.user.of_type(alias))
+                    query = query.filter(
+                        raw_text_column_filter(
+                            [
+                                self.model_class.title,
+                                self.model_class.slug,
+                                tf,
+                                alias.username,
+                            ],
+                            term,
+                        )
+                    )
+
+        query = query.filter(self.model_class.deleted == (true() if show_deleted else false()))
+
+        if include_total_count:
+            total_matches = query.count()
+        else:
+            total_matches = None
+        sort_column = getattr(model.Visualization, payload.sort_by)
+        if payload.sort_desc:
+            sort_column = sort_column.desc()
+        query = query.order_by(sort_column)
+        if payload.limit is not None:
+            query = query.limit(payload.limit)
+        if payload.offset is not None:
+            query = query.offset(payload.offset)
+        return query, total_matches
 
 
 class VisualizationSerializer(sharable.SharableModelSerializer):
@@ -52,7 +189,8 @@ def __init__(self, app: MinimalManagerApp):
 
     def add_serializers(self):
         super().add_serializers()
-        self.serializers.update({})
+        serializers: Dict[str, base.Serializer] = {}
+        self.serializers.update(serializers)
 
 
 class VisualizationDeserializer(sharable.SharableModelDeserializer):
diff --git a/lib/galaxy/model/__init__.py b/lib/galaxy/model/__init__.py
index c437cb1ee65a..cb78947ae025 100644
--- a/lib/galaxy/model/__init__.py
+++ b/lib/galaxy/model/__init__.py
@@ -9865,7 +9865,7 @@ class PageUserShareAssociation(Base, UserShareAssociation):
     page = relationship("Page", back_populates="users_shared_with")
 
 
-class Visualization(Base, HasTags, RepresentById):
+class Visualization(Base, HasTags, Dictifiable, RepresentById):
     __tablename__ = "visualization"
     __table_args__ = (
         Index("ix_visualization_dbkey", "dbkey", mysql_length=200),
@@ -9924,11 +9924,32 @@ class Visualization(Base, HasTags, RepresentById):
     # returns a list of users that visualization is shared with.
     users_shared_with_dot_users = association_proxy("users_shared_with", "user")
 
+    dict_element_visible_keys = [
+        "id",
+        "annotation",
+        "create_time",
+        "db_key",
+        "deleted",
+        "importable",
+        "published",
+        "tags",
+        "title",
+        "type",
+        "update_time",
+        "username",
+    ]
+
     def __init__(self, **kwd):
         super().__init__(**kwd)
         if self.latest_revision:
             self.revisions.append(self.latest_revision)
 
+    @property
+    def annotation(self):
+        if len(self.annotations) == 1:
+            return self.annotations[0].annotation
+        return None
+
     def copy(self, user=None, title=None):
         """
         Provide copy of visualization with only its latest revision.
@@ -9950,6 +9971,15 @@ def copy(self, user=None, title=None):
         copy_viz.latest_revision = copy_revision
         return copy_viz
 
+    def to_dict(self, view="element"):
+        rval = super().to_dict(view=view)
+        return rval
+
+    # username needed for slug generation
+    @property
+    def username(self):
+        return self.user.username
+
 
 class VisualizationRevision(Base, RepresentById):
     __tablename__ = "visualization_revision"
diff --git a/lib/galaxy/schema/visualization.py b/lib/galaxy/schema/visualization.py
new file mode 100644
index 000000000000..34b9ecb80b89
--- /dev/null
+++ b/lib/galaxy/schema/visualization.py
@@ -0,0 +1,103 @@
+from datetime import datetime
+from typing import (
+    List,
+    Optional,
+)
+
+from pydantic import (
+    Extra,
+    Field,
+)
+from typing_extensions import Literal
+
+from galaxy.schema.fields import (
+    DecodedDatabaseIdField,
+    EncodedDatabaseIdField,
+)
+from galaxy.schema.schema import (
+    CreateTimeField,
+    Model,
+    TagCollection,
+    UpdateTimeField,
+)
+
+VisualizationSortByEnum = Literal["create_time", "title", "update_time", "username"]
+
+
+class VisualizationIndexQueryPayload(Model):
+    deleted: bool = False
+    show_own: Optional[bool] = None
+    show_published: Optional[bool] = None
+    show_shared: Optional[bool] = None
+    user_id: Optional[DecodedDatabaseIdField] = None
+    sort_by: VisualizationSortByEnum = Field(
+        "update_time", title="Sort By", description="Sort pages by this attribute."
+    )
+    sort_desc: Optional[bool] = Field(default=True, title="Sort descending", description="Sort in descending order.")
+    search: Optional[str] = Field(default=None, title="Filter text", description="Freetext to search.")
+    limit: Optional[int] = Field(default=100, lt=1000, title="Limit", description="Maximum number of pages to return.")
+    offset: Optional[int] = Field(default=0, title="Offset", description="Number of pages to skip.")
+
+
+class VisualizationSummary(Model):
+    id: EncodedDatabaseIdField = Field(
+        ...,
+        title="ID",
+        description="Encoded ID of the Visualization.",
+    )
+    annotation: Optional[str] = Field(
+        default=None,
+        title="Annotation",
+        description="The annotation of this Visualization.",
+    )
+    dbkey: Optional[str] = Field(
+        default=None,
+        title="DbKey",
+        description="The database key of the visualization.",
+    )
+    deleted: bool = Field(
+        ...,  # Required
+        title="Deleted",
+        description="Whether this Visualization has been deleted.",
+    )
+    importable: bool = Field(
+        ...,  # Required
+        title="Importable",
+        description="Whether this Visualization can be imported.",
+    )
+    published: bool = Field(
+        ...,  # Required
+        title="Published",
+        description="Whether this Visualization has been published.",
+    )
+    tags: Optional[TagCollection] = Field(
+        ...,
+        title="Tags",
+        description="A list of tags to add to this item.",
+    )
+    title: str = Field(
+        title="Title",
+        description="The name of the visualization.",
+    )
+    type: str = Field(
+        ...,
+        title="Type",
+        description="The type of the visualization.",
+    )
+    username: str = Field(
+        ...,  # Required
+        title="Username",
+        description="The name of the user owning this Visualization.",
+    )
+    create_time: Optional[datetime] = CreateTimeField
+    update_time: Optional[datetime] = UpdateTimeField
+
+    class Config:
+        extra = Extra.allow  # Allow any other extra fields
+
+
+class VisualizationSummaryList(Model):
+    __root__: List[VisualizationSummary] = Field(
+        default=[],
+        title="List with detailed information of Visualizations.",
+    )
diff --git a/lib/galaxy/webapps/base/controller.py b/lib/galaxy/webapps/base/controller.py
index f3fc7603931a..3a2eb11ac13f 100644
--- a/lib/galaxy/webapps/base/controller.py
+++ b/lib/galaxy/webapps/base/controller.py
@@ -8,10 +8,6 @@
     Optional,
 )
 
-from sqlalchemy import (
-    select,
-    true,
-)
 from webob.exc import (
     HTTPBadRequest,
     HTTPInternalServerError,
@@ -631,48 +627,6 @@ def get_visualization(self, trans, id, check_ownership=True, check_accessible=Fa
         else:
             return self.security_check(trans, visualization, check_ownership, check_accessible)
 
-    def get_visualizations_by_user(self, trans, user):
-        """Return query results of visualizations filtered by a user."""
-        stmt = select(model.Visualization).filter(model.Visualization.user == user).order_by(model.Visualization.title)
-        return trans.sa_session.scalars(stmt).all()
-
-    def get_visualizations_shared_with_user(self, trans, user):
-        """Return query results for visualizations shared with the given user."""
-        # The second `where` clause removes duplicates when a user shares with themselves.
-        stmt = (
-            select(model.Visualization)
-            .join(model.VisualizationUserShareAssociation)
-            .where(model.VisualizationUserShareAssociation.user_id == user.id)
-            .where(model.Visualization.user_id != user.id)
-            .order_by(model.Visualization.title)
-        )
-        return trans.sa_session.scalars(stmt).all()
-
-    def get_published_visualizations(self, trans, exclude_user=None):
-        """
-        Return query results for published visualizations optionally excluding the user in `exclude_user`.
-        """
-        stmt = select(model.Visualization).filter(model.Visualization.published == true())
-        if exclude_user:
-            stmt = stmt.filter(model.Visualization.user != exclude_user)
-        stmt = stmt.order_by(model.Visualization.title)
-        return trans.sa_session.scalars(stmt).all()
-
-    # TODO: move into model (to_dict)
-    def get_visualization_summary_dict(self, visualization):
-        """
-        Return a set of summary attributes for a visualization in dictionary form.
-        NOTE: that encoding ids isn't done here should happen at the caller level.
-        """
-        # TODO: deleted
-        # TODO: importable
-        return {
-            "id": visualization.id,
-            "title": visualization.title,
-            "type": visualization.type,
-            "dbkey": visualization.dbkey,
-        }
-
     def get_visualization_dict(self, visualization):
         """
         Return a set of detailed attributes for a visualization in dictionary form.
diff --git a/lib/galaxy/webapps/galaxy/api/visualizations.py b/lib/galaxy/webapps/galaxy/api/visualizations.py
index 28db3c02dae8..6fdba09f3358 100644
--- a/lib/galaxy/webapps/galaxy/api/visualizations.py
+++ b/lib/galaxy/webapps/galaxy/api/visualizations.py
@@ -6,10 +6,12 @@
 """
 import json
 import logging
+from typing import Optional
 
 from fastapi import (
     Body,
     Path,
+    Query,
     Response,
     status,
 )
@@ -29,6 +31,11 @@
     ShareWithStatus,
     SharingStatus,
 )
+from galaxy.schema.visualization import (
+    VisualizationIndexQueryPayload,
+    VisualizationSortByEnum,
+    VisualizationSummaryList,
+)
 from galaxy.util.hash_util import md5_hash_str
 from galaxy.web import expose_api
 from galaxy.webapps.base.controller import UsesVisualizationMixin
@@ -37,7 +44,13 @@
     BaseGalaxyAPIController,
     depends,
     DependsOnTrans,
+    IndexQueryTag,
     Router,
+    search_query_param,
+)
+from galaxy.webapps.galaxy.api.common import (
+    LimitQueryParam,
+    OffsetQueryParam,
 )
 from galaxy.webapps.galaxy.services.visualizations import VisualizationsService
 
@@ -45,6 +58,52 @@
 
 router = Router(tags=["visualizations"])
 
+DeletedQueryParam: bool = Query(
+    default=False, title="Display deleted", description="Whether to include deleted visualizations in the result."
+)
+
+UserIdQueryParam: Optional[DecodedDatabaseIdField] = Query(
+    default=None,
+    title="Encoded user ID to restrict query to, must be own id if not an admin user",
+)
+
+query_tags = [
+    IndexQueryTag("title", "The visualization's title."),
+    IndexQueryTag("slug", "The visualization's slug.", "s"),
+    IndexQueryTag("tag", "The visualization's tags.", "t"),
+    IndexQueryTag("user", "The visualization's owner's username.", "u"),
+]
+
+SearchQueryParam: Optional[str] = search_query_param(
+    model_name="Visualization",
+    tags=query_tags,
+    free_text_fields=["title", "slug", "tag", "type"],
+)
+
+SharingQueryParam: bool = Query(
+    default=False, title="Provide sharing status", description="Whether to provide sharing details in the result."
+)
+
+ShowOwnQueryParam: bool = Query(default=True, title="Show visualizations owned by user.", description="")
+
+ShowPublishedQueryParam: bool = Query(default=True, title="Include published visualizations.", description="")
+
+ShowSharedQueryParam: bool = Query(
+    default=False, title="Include visualizations shared with authenticated user.", description=""
+)
+
+SortByQueryParam: VisualizationSortByEnum = Query(
+    default="update_time",
+    title="Sort attribute",
+    description="Sort visualization index by this specified attribute on the visualization model",
+)
+
+SortDescQueryParam: bool = Query(
+    default=True,
+    title="Sort Descending",
+    description="Sort in descending order?",
+)
+
 VisualizationIdPathParam: DecodedDatabaseIdField = Path(
     ..., title="Visualization ID", description="The encoded database identifier of the Visualization."
 )
@@ -54,9 +113,44 @@
 class FastAPIVisualizations:
     service: VisualizationsService = depends(VisualizationsService)
 
+    @router.get(
+        "/api/visualizations",
+        summary="Returns visualizations for the current user.",
+    )
+    async def index(
+        self,
+        response: Response,
+        trans: ProvidesUserContext = DependsOnTrans,
+        deleted: bool = DeletedQueryParam,
+        limit: Optional[int] = LimitQueryParam,
+        offset: Optional[int] = OffsetQueryParam,
+        user_id: Optional[DecodedDatabaseIdField] = UserIdQueryParam,
+        show_own: bool = ShowOwnQueryParam,
+        show_published: bool = ShowPublishedQueryParam,
+        show_shared: bool = ShowSharedQueryParam,
+        sort_by: VisualizationSortByEnum = SortByQueryParam,
+        sort_desc: bool = SortDescQueryParam,
+        search: Optional[str] = SearchQueryParam,
+    ) -> VisualizationSummaryList:
+        payload = VisualizationIndexQueryPayload.construct(
+            deleted=deleted,
+            user_id=user_id,
+            show_published=show_published,
+            show_own=show_own,
+            show_shared=show_shared,
+            sort_by=sort_by,
+            sort_desc=sort_desc,
+            limit=limit,
+            offset=offset,
+            search=search,
+        )
+        entries, total_matches = self.service.index(trans, payload, include_total_count=True)
+        response.headers["total_matches"] = str(total_matches)
+        return entries
+
     @router.get(
         "/api/visualizations/{id}/sharing",
-        summary="Get the current sharing status of the given Page.",
+        summary="Get the current sharing status of the given Visualization.",
     )
     def sharing(
         self,
@@ -150,32 +244,6 @@ class VisualizationsController(BaseGalaxyAPIController, UsesVisualizationMixin,
 
     service: VisualizationsService = depends(VisualizationsService)
 
-    @expose_api
-    def index(self, trans: GalaxyWebTransaction, **kwargs):
-        """
-        GET /api/visualizations:
-        """
-        rval = []
-        user = trans.user
-
-        # TODO: search for: title, made by user, creation time range, type (vis name), dbkey, etc.
-        # TODO: limit, offset, order_by
-        # TODO: deleted
-
-        # this is the default search - user's vis, vis shared with user, published vis
-        visualizations = self.get_visualizations_by_user(trans, user)
-        visualizations += self.get_visualizations_shared_with_user(trans, user)
-        visualizations += self.get_published_visualizations(trans, exclude_user=user)
-        # TODO: the admin case - everything
-
-        for visualization in visualizations:
-            item = self.get_visualization_summary_dict(visualization)
-            item = trans.security.encode_dict_ids(item)
-            item["url"] = web.url_for("visualization", id=item["id"])
-            rval.append(item)
-
-        return rval
-
     @expose_api
     def show(self, trans: GalaxyWebTransaction, id: str, **kwargs):
         """
@@ -247,12 +315,11 @@ def update(self, trans: GalaxyWebTransaction, id: str, payload: dict, **kwargs):
         PUT /api/visualizations/{encoded_visualization_id}
         """
         rval = None
-
         payload = self._validate_and_parse_payload(payload)
 
-        # there's a differentiation here between updating the visualiztion and creating a new revision
-        #   that needs to be handled clearly here
-        # or alternately, using a different controller like PUT /api/visualizations/{id}/r/{id}
+        # there's a differentiation here between updating the visualization and creating a new revision
+        # that needs to be handled clearly here or alternately, using a different controller
+        # like e.g. PUT /api/visualizations/{id}/r/{id}
 
         # TODO: consider allowing direct alteration of revisions title (without a new revision)
         #   only create a new revsion on a different config
@@ -261,6 +328,7 @@ def update(self, trans: GalaxyWebTransaction, id: str, payload: dict, **kwargs):
         visualization = self.get_visualization(trans, id, check_ownership=True)
         title = payload.get("title", visualization.latest_revision.title)
         dbkey = payload.get("dbkey", visualization.latest_revision.dbkey)
+        deleted = payload.get("deleted", visualization.deleted)
         config = payload.get("config", visualization.latest_revision.config)
 
         latest_config = visualization.latest_revision.config
@@ -274,6 +342,7 @@ def update(self, trans: GalaxyWebTransaction, id: str, payload: dict, **kwargs):
 
         # allow updating vis title
         visualization.title = title
+        visualization.deleted = deleted
         with transaction(trans.sa_session):
             trans.sa_session.commit()
 
@@ -297,7 +366,6 @@ def _validate_and_parse_payload(self, payload):
             "model_class"
             # TODO: fill out when we create to_dict, get_dict, whatevs
         )
-        # TODO: deleted
         # TODO: importable
         ValidationError = exceptions.RequestParameterInvalidException
 
@@ -311,11 +379,13 @@ def _validate_and_parse_payload(self, payload):
             elif key == "config":
                 if not isinstance(val, dict):
                     raise ValidationError(f"{key} must be a dictionary: {str(type(val))}")
-
             elif key == "annotation":
                 if not isinstance(val, str):
                     raise ValidationError(f"{key} must be a string or unicode: {str(type(val))}")
                 val = util.sanitize_html.sanitize_html(val)
+            elif key == "deleted":
+                if not isinstance(val, bool):
+                    raise ValidationError(f"{key} must be a bool: {str(type(val))}")
 
             # these are keys that actually only be *updated* at the revision level and not here
             #   (they are still valid for create, tho)
diff --git a/lib/galaxy/webapps/galaxy/services/pages.py b/lib/galaxy/webapps/galaxy/services/pages.py
index 2540314ecf17..444149b17d19 100644
--- a/lib/galaxy/webapps/galaxy/services/pages.py
+++ b/lib/galaxy/webapps/galaxy/services/pages.py
@@ -64,8 +64,6 @@ def index(
     ) -> Tuple[PageSummaryList, int]:
         """Return a list of Pages viewable by the user
 
-        :param deleted: Display deleted pages
-
         :rtype:     list
         :returns:   dictionaries containing summary or detailed Page information
         """
diff --git a/lib/galaxy/webapps/galaxy/services/visualizations.py b/lib/galaxy/webapps/galaxy/services/visualizations.py
index 557d4cd65082..7a6866223cfa 100644
--- a/lib/galaxy/webapps/galaxy/services/visualizations.py
+++ b/lib/galaxy/webapps/galaxy/services/visualizations.py
@@ -1,10 +1,16 @@
 import logging
+from typing import Tuple
 
+from galaxy import exceptions
 from galaxy.managers.notification import NotificationManager
 from galaxy.managers.visualizations import (
     VisualizationManager,
     VisualizationSerializer,
 )
+from galaxy.schema.visualization import (
+    VisualizationIndexQueryPayload,
+    VisualizationSummaryList,
+)
 from galaxy.security.idencoding import IdEncodingHelper
 from galaxy.webapps.galaxy.services.base import ServiceBase
 from galaxy.webapps.galaxy.services.sharable import ShareableService
@@ -32,3 +38,25 @@ def __init__(
         self.shareable_service = ShareableService(self.manager, self.serializer, notification_manager)
 
     # TODO: add the rest of the API actions here and call them directly from the API controller
+
+    def index(
+        self,
+        trans,
+        payload: VisualizationIndexQueryPayload,
+        include_total_count: bool = False,
+    ) -> Tuple[VisualizationSummaryList, int]:
+        """Return a list of Visualizations viewable by the user
+
+        :rtype:     list
+        :returns:   dictionaries containing Visualization details
+        """
+        if not trans.user_is_admin:
+            user_id = trans.user and trans.user.id
+            if payload.user_id and payload.user_id != user_id:
+                raise exceptions.AdminRequiredException("Only admins can index the visualizations of others")
+
+        entries, total_matches = self.manager.index_query(trans, payload, include_total_count)
+        return (
+            VisualizationSummaryList(__root__=[entry.to_dict() for entry in entries]),
+            total_matches,
+        )
diff --git a/lib/galaxy_test/api/test_pages.py b/lib/galaxy_test/api/test_pages.py
index a74909dfc1a9..e99210fbb34a 100644
--- a/lib/galaxy_test/api/test_pages.py
+++ b/lib/galaxy_test/api/test_pages.py
@@ -451,8 +451,6 @@ def _index_raw(self, params: Optional[Dict[str, Any]] = None) -> Response:
     def _index(self, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
         index_response = self._index_raw(params)
         self._assert_status_code_is(index_response, 200)
-        print(params)
-        print(index_response.json())
         return index_response.json()
 
     def _index_ids(self, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
diff --git a/lib/galaxy_test/api/test_visualizations.py b/lib/galaxy_test/api/test_visualizations.py
index 2ed359f3134a..9d020fef6697 100644
--- a/lib/galaxy_test/api/test_visualizations.py
+++ b/lib/galaxy_test/api/test_visualizations.py
@@ -7,7 +7,7 @@
 from galaxy_test.base.api_asserts import assert_has_keys
 from ._framework import ApiTestCase
 
-INDEX_KEYS = ["id", "title", "type", "dbkey", "url"]
+INDEX_KEYS = ["id", "title", "type", "dbkey"]
 SHOW_KEYS = INDEX_KEYS + ["user_id", "model_class", "revisions", "latest_revision", "annotation"]
 REVISION_KEYS = ["id", "title", "visualization_id", "dbkey", "model_class", "config"]
 
@@ -28,20 +28,54 @@ def test_index_and_show(self):
         first_viz = index[0]
         self._show_viz(first_viz["id"])
 
+    def test_index_ordering(self):
+        ids = []
+        for x in range(3):
+            v = self._new_viz(title=f"visualization-order-{x}", slug=f"slug-order-{x}").json()
+            ids.append(v["id"])
+        index_ids = self._index_ids()
+        for x in range(2):
+            assert index_ids.index(ids[x]) > index_ids.index(ids[x + 1])
+        index_ids = self._index_ids(dict(sort_desc=False))
+        for x in range(2):
+            assert index_ids.index(ids[x]) < index_ids.index(ids[x + 1])
+
+    def test_index_filtering(self):
+        ids = []
+        for x in range(3):
+            v = self._new_viz(title=f"visualization-filter-{x}", slug=f"slug-filter-{x}").json()
+            ids.append(v["id"])
+        index_ids = self._index_ids(dict(show_own=False))
+        for x in range(3):
+            assert ids[x] not in index_ids
+        self._publish_viz(ids[0])
+        index_ids = self._index_ids(dict(show_own=False))
+        assert ids[0] in index_ids
+        index_ids = self._index_ids(dict(show_own=False, show_published=False))
+        for x in range(3):
+            assert ids[x] in index_ids
+        index_ids = self._index_ids(dict(search="visualization-filter-1"))
+        assert ids[1] in index_ids
+        self._update_viz(ids[1], dict(deleted=True))
+        index_ids = self._index_ids(dict(search="visualization-filter-1"))
+        assert ids[1] not in index_ids
+        index_ids = self._index_ids(dict(search="is:deleted"))
+        assert ids[1] in index_ids
+
     def test_create(self):
         viz_id, viz_request = self._create_viz()
         self._show_viz(viz_id, assert_ok=True)
 
     def test_create_fails_without_title(self):
-        response = self._raw_create_viz(title="")
+        response = self._new_viz(title="")
         self._assert_status_code_is(response, 400)
 
     def test_create_fails_with_bad_slug(self):
-        response = self._raw_create_viz(slug="123_()")
+        response = self._new_viz(slug="123_()")
         self._assert_status_code_is(response, 400)
 
     def test_create_fails_with_invalid_config(self):
-        response = self._raw_create_viz(config="3 = nime")
+        response = self._new_viz(config="3 = nime")
         self._assert_status_code_is(response, 400)
 
     def test_sharing(self):
@@ -60,21 +94,21 @@ def test_update_title(self):
         updated_viz = self._show_viz(viz_id)
         assert updated_viz["title"] == "New Name"
 
-    def _show_viz(self, viz_id, assert_ok=True):
-        show_response = self._get(f"visualizations/{viz_id}")
-        if assert_ok:
-            self._assert_status_code_is(show_response, 200)
-
-        viz = show_response.json()
+    def _create_viz(self, **kwds):
+        response = self._new_viz(**kwds)
+        self._assert_status_code_is(response, 200)
+        viz = response.json()
+        return viz["id"], viz
 
-        if assert_ok:
-            self._verify_viz_object(viz, show=True)
+    def _index(self, params):
+        index_response = self._get("visualizations", data=params or {})
+        return index_response.json()
 
-        return viz
+    def _index_ids(self, params=None):
+        return [entry["id"] for entry in self._index(params)]
 
-    def _raw_create_viz(self, title=None, slug=None, config=None):
+    def _new_viz(self, title=None, slug=None, config=None):
         uuid_str = str(uuid.uuid4())
-
         title = title if title is not None else "Test Visualization"
         slug = slug if slug is not None else f"test-visualization-{uuid_str}"
         config = (
@@ -98,23 +132,33 @@ def _raw_create_viz(self, title=None, slug=None, config=None):
         response = self._post("visualizations", data=create_payload)
         return response
 
-    def _create_viz(self, **kwds):
-        response = self._raw_create_viz(**kwds)
+    def _publish_viz(self, id):
+        sharing_response = self._put(f"visualizations/{id}/publish")
+        assert sharing_response.status_code == 200
+        return sharing_response.json()
+
+    def _show_viz(self, viz_id, assert_ok=True):
+        show_response = self._get(f"visualizations/{viz_id}")
+        if assert_ok:
+            self._assert_status_code_is(show_response, 200)
+        viz = show_response.json()
+        if assert_ok:
+            self._verify_viz_object(viz, show=True)
+        return viz
+
+    def _update_viz(self, viz_id, params=None):
+        response = self._put(f"visualizations/{viz_id}", params or {}, json=True)
         self._assert_status_code_is(response, 200)
-        viz = response.json()
-        return viz["id"], viz
+        return response
 
     def _verify_viz_object(self, obj, show=False):
         assert_has_keys(obj, *(SHOW_KEYS if show else INDEX_KEYS))
-
         if show:
             assert "revisions" in obj
             revisions = obj["revisions"]
             assert len(revisions) >= 1
-
             assert "latest_revision" in obj
             latest_revision = obj["latest_revision"]
             assert_has_keys(latest_revision, *REVISION_KEYS)
             assert latest_revision["model_class"] == "VisualizationRevision"
-
             assert latest_revision["id"] in revisions