fix(ruler): use a snake_case slog key for rule view decode errors

StorableRuleView and GettableRuleView meet only in converters; the list
conversion is a pure types function with per-id errors the provider logs.
Also renames test cases to the PascalCase convention, drops the dead
ensure_notification_channel helper and restores the create_rule_view
fixture lost in the main merge.

docs/api/openapi.yml

@@ -8928,6 +8928,30 @@ components:
       - kind
       - spec
       type: object
+    RuletypesGettableRuleView:
+      properties:
+        createdAt:
+          format: date-time
+          type: string
+        data:
+          $ref: '#/components/schemas/RuletypesRuleViewData'
+        id:
+          type: string
+        name:
+          type: string
+        orgId:
+          type: string
+        updatedAt:
+          format: date-time
+          type: string
+      required:
+      - id
+      - name
+      - data
+      - orgId
+      - createdAt
+      - updatedAt
+      type: object
     RuletypesGettableTestRule:
       properties:
         alertCount:
@@ -8995,6 +9019,15 @@ components:
       - alertType
       - ruleType
       type: object
+    RuletypesListableRuleViews:
+      properties:
+        views:
+          items:
+            $ref: '#/components/schemas/RuletypesGettableRuleView'
+          type: array
+      required:
+      - views
+      type: object
     RuletypesListableRules:
       properties:
         labels:
@@ -9092,6 +9125,16 @@ components:
       - ruleType
       - condition
       type: object
+    RuletypesPostableRuleView:
+      properties:
+        data:
+          $ref: '#/components/schemas/RuletypesRuleViewData'
+        name:
+          type: string
+      required:
+      - name
+      - data
+      type: object
     RuletypesQueryType:
       enum:
       - builder
@@ -9230,6 +9273,23 @@ components:
       - promql_rule
       - anomaly_rule
       type: string
+    RuletypesRuleViewData:
+      properties:
+        order:
+          $ref: '#/components/schemas/RuletypesListOrder'
+        query:
+          type: string
+        sort:
+          $ref: '#/components/schemas/RuletypesListSort'
+        states:
+          items:
+            type: string
+          type: array
+        version:
+          type: string
+      required:
+      - version
+      type: object
     RuletypesScheduleType:
       enum:
       - hourly
@@ -20968,6 +21028,231 @@ paths:
       summary: Get users by role id
       tags:
       - users
+  /api/v2/rule_views:
+    get:
+      deprecated: false
+      description: Returns every saved view in the calling user's org. Saved views
+        are shared org-wide.
+      operationId: ListRuleViews
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/RuletypesListableRuleViews'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: List rule saved views
+      tags:
+      - rules
+    post:
+      deprecated: false
+      description: Persists the calling user's rule listing state (query, states,
+        sort, order) as a named, reusable view shared across the org.
+      operationId: CreateRuleView
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesPostableRuleView'
+      responses:
+        "201":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/RuletypesGettableRuleView'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: Created
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Create rule saved view
+      tags:
+      - rules
+  /api/v2/rule_views/{id}:
+    delete:
+      deprecated: false
+      description: Removes a saved view. Saved views are shared org-wide. Deleting
+        a non-existent view returns 404.
+      operationId: DeleteRuleView
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "204":
+          description: No Content
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Delete rule saved view
+      tags:
+      - rules
+    put:
+      deprecated: false
+      description: Replaces a saved view's name and data. Saved views are shared org-wide.
+      operationId: UpdateRuleView
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RuletypesPostableRuleView'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/RuletypesGettableRuleView'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Update rule saved view
+      tags:
+      - rules
   /api/v2/rules:
     get:
       deprecated: true

frontend/src/api/generated/services/rules/index.ts

@@ -19,7 +19,9 @@ import type {
 
 import type {
 	CreateRule201,
+	CreateRuleView201,
 	DeleteRuleByIDPathParameters,
+	DeleteRuleViewPathParameters,
 	GetRuleByID200,
 	GetRuleByIDPathParameters,
 	GetRuleHistoryFilterKeys200,
@@ -40,6 +42,7 @@ import type {
 	GetRuleHistoryTopContributors200,
 	GetRuleHistoryTopContributorsParams,
 	GetRuleHistoryTopContributorsPathParameters,
+	ListRuleViews200,
 	ListRules200,
 	ListRulesV3200,
 	ListRulesV3Params,
@@ -47,8 +50,11 @@ import type {
 	PatchRuleByIDPathParameters,
 	RenderErrorResponseDTO,
 	RuletypesPostableRuleDTO,
+	RuletypesPostableRuleViewDTO,
 	TestRule200,
 	UpdateRuleByIDPathParameters,
+	UpdateRuleView200,
+	UpdateRuleViewPathParameters,
 } from '../sigNoz.schemas';
 
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
@@ -74,6 +80,351 @@ const withQueryKey = <T extends object, K>(
 	return result;
 };
 
+/**
+ * Returns every saved view in the calling user's org. Saved views are shared org-wide.
+ * @summary List rule saved views
+ */
+export const listRuleViews = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<ListRuleViews200>({
+		url: `/api/v2/rule_views`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getListRuleViewsQueryKey = () => {
+	return [`/api/v2/rule_views`] as const;
+};
+
+export const getListRuleViewsQueryOptions = <
+	TData = Awaited<ReturnType<typeof listRuleViews>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof listRuleViews>>,
+		TError,
+		TData
+	>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getListRuleViewsQueryKey();
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof listRuleViews>>> = ({
+		signal,
+	}) => listRuleViews(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof listRuleViews>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ListRuleViewsQueryResult = NonNullable<
+	Awaited<ReturnType<typeof listRuleViews>>
+>;
+export type ListRuleViewsQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List rule saved views
+ */
+
+export function useListRuleViews<
+	TData = Awaited<ReturnType<typeof listRuleViews>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof listRuleViews>>,
+		TError,
+		TData
+	>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getListRuleViewsQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	return withQueryKey(query, queryOptions.queryKey);
+}
+
+/**
+ * @summary List rule saved views
+ */
+export const invalidateListRuleViews = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getListRuleViewsQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * Persists the calling user's rule listing state (query, states, sort, order) as a named, reusable view shared across the org.
+ * @summary Create rule saved view
+ */
+export const createRuleView = (
+	ruletypesPostableRuleViewDTO?: BodyType<RuletypesPostableRuleViewDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<CreateRuleView201>({
+		url: `/api/v2/rule_views`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesPostableRuleViewDTO,
+		signal,
+	});
+};
+
+export const getCreateRuleViewMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createRuleView>>,
+		TError,
+		{ data?: BodyType<RuletypesPostableRuleViewDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createRuleView>>,
+	TError,
+	{ data?: BodyType<RuletypesPostableRuleViewDTO> },
+	TContext
+> => {
+	const mutationKey = ['createRuleView'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof createRuleView>>,
+		{ data?: BodyType<RuletypesPostableRuleViewDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return createRuleView(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateRuleViewMutationResult = NonNullable<
+	Awaited<ReturnType<typeof createRuleView>>
+>;
+export type CreateRuleViewMutationBody =
+	| BodyType<RuletypesPostableRuleViewDTO>
+	| undefined;
+export type CreateRuleViewMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create rule saved view
+ */
+export const useCreateRuleView = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createRuleView>>,
+		TError,
+		{ data?: BodyType<RuletypesPostableRuleViewDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createRuleView>>,
+	TError,
+	{ data?: BodyType<RuletypesPostableRuleViewDTO> },
+	TContext
+> => {
+	return useMutation(getCreateRuleViewMutationOptions(options));
+};
+/**
+ * Removes a saved view. Saved views are shared org-wide. Deleting a non-existent view returns 404.
+ * @summary Delete rule saved view
+ */
+export const deleteRuleView = (
+	{ id }: DeleteRuleViewPathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v2/rule_views/${id}`,
+		method: 'DELETE',
+		signal,
+	});
+};
+
+export const getDeleteRuleViewMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteRuleView>>,
+		TError,
+		{ pathParams: DeleteRuleViewPathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof deleteRuleView>>,
+	TError,
+	{ pathParams: DeleteRuleViewPathParameters },
+	TContext
+> => {
+	const mutationKey = ['deleteRuleView'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof deleteRuleView>>,
+		{ pathParams: DeleteRuleViewPathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return deleteRuleView(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteRuleViewMutationResult = NonNullable<
+	Awaited<ReturnType<typeof deleteRuleView>>
+>;
+
+export type DeleteRuleViewMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Delete rule saved view
+ */
+export const useDeleteRuleView = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteRuleView>>,
+		TError,
+		{ pathParams: DeleteRuleViewPathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof deleteRuleView>>,
+	TError,
+	{ pathParams: DeleteRuleViewPathParameters },
+	TContext
+> => {
+	return useMutation(getDeleteRuleViewMutationOptions(options));
+};
+/**
+ * Replaces a saved view's name and data. Saved views are shared org-wide.
+ * @summary Update rule saved view
+ */
+export const updateRuleView = (
+	{ id }: UpdateRuleViewPathParameters,
+	ruletypesPostableRuleViewDTO?: BodyType<RuletypesPostableRuleViewDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<UpdateRuleView200>({
+		url: `/api/v2/rule_views/${id}`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: ruletypesPostableRuleViewDTO,
+		signal,
+	});
+};
+
+export const getUpdateRuleViewMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateRuleView>>,
+		TError,
+		{
+			pathParams: UpdateRuleViewPathParameters;
+			data?: BodyType<RuletypesPostableRuleViewDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateRuleView>>,
+	TError,
+	{
+		pathParams: UpdateRuleViewPathParameters;
+		data?: BodyType<RuletypesPostableRuleViewDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateRuleView'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof updateRuleView>>,
+		{
+			pathParams: UpdateRuleViewPathParameters;
+			data?: BodyType<RuletypesPostableRuleViewDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateRuleView(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateRuleViewMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateRuleView>>
+>;
+export type UpdateRuleViewMutationBody =
+	| BodyType<RuletypesPostableRuleViewDTO>
+	| undefined;
+export type UpdateRuleViewMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update rule saved view
+ */
+export const useUpdateRuleView = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateRuleView>>,
+		TError,
+		{
+			pathParams: UpdateRuleViewPathParameters;
+			data?: BodyType<RuletypesPostableRuleViewDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateRuleView>>,
+	TError,
+	{
+		pathParams: UpdateRuleViewPathParameters;
+		data?: BodyType<RuletypesPostableRuleViewDTO>;
+	},
+	TContext
+> => {
+	return useMutation(getUpdateRuleViewMutationOptions(options));
+};
 /**
  * This endpoint lists all alert rules with their current evaluation state. Deprecated: use ListRulesV3, which supports filtering, sorting and pagination.
  * @deprecated

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -10177,6 +10177,60 @@ export enum RuletypesEvaluationKindDTO {
 	rolling = 'rolling',
 	cumulative = 'cumulative',
 }
+export enum RuletypesListOrderDTO {
+	asc = 'asc',
+	desc = 'desc',
+}
+export enum RuletypesListSortDTO {
+	updated_at = 'updated_at',
+	created_at = 'created_at',
+	name = 'name',
+	state = 'state',
+	severity = 'severity',
+}
+export interface RuletypesRuleViewDataDTO {
+	order?: RuletypesListOrderDTO;
+	/**
+	 * @type string
+	 */
+	query?: string;
+	sort?: RuletypesListSortDTO;
+	/**
+	 * @type array
+	 */
+	states?: string[];
+	/**
+	 * @type string
+	 */
+	version: string;
+}
+
+export interface RuletypesGettableRuleViewDTO {
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt: string;
+	data: RuletypesRuleViewDataDTO;
+	/**
+	 * @type string
+	 */
+	id: string;
+	/**
+	 * @type string
+	 */
+	name: string;
+	/**
+	 * @type string
+	 */
+	orgId: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt: string;
+}
+
 export interface RuletypesGettableTestRuleDTO {
 	/**
 	 * @type integer
@@ -10199,17 +10253,6 @@ export interface RuletypesLabelPairDTO {
 	value: string;
 }
 
-export enum RuletypesListOrderDTO {
-	asc = 'asc',
-	desc = 'desc',
-}
-export enum RuletypesListSortDTO {
-	updated_at = 'updated_at',
-	created_at = 'created_at',
-	name = 'name',
-	state = 'state',
-	severity = 'severity',
-}
 export type RuletypesListableRuleDTOLabels = { [key: string]: string };
 
 export enum RuletypesRuleTypeDTO {
@@ -10261,6 +10304,13 @@ export interface RuletypesListableRuleDTO {
 	updatedBy?: string;
 }
 
+export interface RuletypesListableRuleViewsDTO {
+	/**
+	 * @type array
+	 */
+	views: RuletypesGettableRuleViewDTO[];
+}
+
 export interface RuletypesListableRulesDTO {
 	/**
 	 * @type array
@@ -10429,6 +10479,14 @@ export interface RuletypesPostableRuleDTO {
 	version?: string;
 }
 
+export interface RuletypesPostableRuleViewDTO {
+	data: RuletypesRuleViewDataDTO;
+	/**
+	 * @type string
+	 */
+	name: string;
+}
+
 export type RuletypesRuleDTOAnnotations = { [key: string]: string };
 
 export type RuletypesRuleDTOLabels = { [key: string]: string };
@@ -13716,6 +13774,36 @@ export type GetUsersByRoleID200 = {
 	status: string;
 };
 
+export type ListRuleViews200 = {
+	data: RuletypesListableRuleViewsDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type CreateRuleView201 = {
+	data: RuletypesGettableRuleViewDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type DeleteRuleViewPathParameters = {
+	id: string;
+};
+export type UpdateRuleViewPathParameters = {
+	id: string;
+};
+export type UpdateRuleView200 = {
+	data: RuletypesGettableRuleViewDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type ListRules200 = {
 	/**
 	 * @type array

pkg/apiserver/signozapiserver/ruler.go

@@ -132,6 +132,64 @@ func (provider *provider) addRulerRoutes(router *mux.Router) error {
 		return err
 	}
 
+	if err := router.Handle("/api/v2/rule_views", handler.New(provider.authzMiddleware.ViewAccess(provider.rulerHandler.ListRuleViews), handler.OpenAPIDef{
+		ID:                  "ListRuleViews",
+		Tags:                []string{"rules"},
+		Summary:             "List rule saved views",
+		Description:         "Returns every saved view in the calling user's org. Saved views are shared org-wide.",
+		Response:            new(ruletypes.ListableRuleViews),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v2/rule_views", handler.New(provider.authzMiddleware.ViewAccess(provider.rulerHandler.CreateRuleView), handler.OpenAPIDef{
+		ID:                  "CreateRuleView",
+		Tags:                []string{"rules"},
+		Summary:             "Create rule saved view",
+		Description:         "Persists the calling user's rule listing state (query, states, sort, order) as a named, reusable view shared across the org.",
+		Request:             new(ruletypes.PostableRuleView),
+		RequestContentType:  "application/json",
+		Response:            new(ruletypes.GettableRuleView),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusCreated,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v2/rule_views/{id}", handler.New(provider.authzMiddleware.ViewAccess(provider.rulerHandler.UpdateRuleView), handler.OpenAPIDef{
+		ID:                  "UpdateRuleView",
+		Tags:                []string{"rules"},
+		Summary:             "Update rule saved view",
+		Description:         "Replaces a saved view's name and data. Saved views are shared org-wide.",
+		Request:             new(ruletypes.UpdatableRuleView),
+		RequestContentType:  "application/json",
+		Response:            new(ruletypes.GettableRuleView),
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodPut).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v2/rule_views/{id}", handler.New(provider.authzMiddleware.ViewAccess(provider.rulerHandler.DeleteRuleView), handler.OpenAPIDef{
+		ID:                  "DeleteRuleView",
+		Tags:                []string{"rules"},
+		Summary:             "Delete rule saved view",
+		Description:         "Removes a saved view. Saved views are shared org-wide. Deleting a non-existent view returns 404.",
+		ResponseContentType: "application/json",
+		SuccessStatusCode:   http.StatusNoContent,
+		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+	})).Methods(http.MethodDelete).GetError(); err != nil {
+		return err
+	}
+
 	if err := router.Handle("/api/v1/downtime_schedules", handler.New(provider.authzMiddleware.ViewAccess(provider.rulerHandler.ListDowntimeSchedules), handler.OpenAPIDef{
 		ID:                  "ListDowntimeSchedules",
 		Tags:                []string{"downtimeschedules"},

pkg/query-service/rules/manager_test.go

@@ -36,7 +36,7 @@ func TestManager_ListRules_ValidatesParams(t *testing.T) {
 	_, err = m.ListRules(context.Background(), &ruletypes.ListRulesParams{Limit: -1})
 	require.ErrorContains(t, err, "invalid limit")
 
-	_, err = m.ListRules(context.Background(), &ruletypes.ListRulesParams{States: []string{"bogus"}})
+	_, err = m.ListRules(context.Background(), &ruletypes.ListRulesParams{ListFilter: ruletypes.ListFilter{States: []string{"bogus"}}})
 	require.ErrorContains(t, err, `invalid state "bogus"`)
 }
 

pkg/ruler/handler.go

@@ -12,6 +12,11 @@ type Handler interface {
 	PatchRuleByID(http.ResponseWriter, *http.Request)
 	TestRule(http.ResponseWriter, *http.Request)
 
+	ListRuleViews(http.ResponseWriter, *http.Request)
+	CreateRuleView(http.ResponseWriter, *http.Request)
+	UpdateRuleView(http.ResponseWriter, *http.Request)
+	DeleteRuleView(http.ResponseWriter, *http.Request)
+
 	ListDowntimeSchedules(http.ResponseWriter, *http.Request)
 	GetDowntimeScheduleByID(http.ResponseWriter, *http.Request)
 	CreateDowntimeSchedule(http.ResponseWriter, *http.Request)

pkg/ruler/ruler.go

@@ -49,4 +49,9 @@ type Ruler interface {
 	// TODO: expose downtime CRUD as methods on Ruler directly instead of leaking the
 	// store interface. The handler should not call store methods directly.
 	MaintenanceStore() alertmanagertypes.MaintenanceStore
+
+	CreateRuleView(ctx context.Context, orgID valuer.UUID, postable ruletypes.PostableRuleView) (*ruletypes.GettableRuleView, error)
+	ListRuleViews(ctx context.Context, orgID valuer.UUID) (*ruletypes.ListableRuleViews, error)
+	UpdateRuleView(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatable ruletypes.UpdatableRuleView) (*ruletypes.GettableRuleView, error)
+	DeleteRuleView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
 }

pkg/ruler/rulestore/sqlrulestore/rule_view.go

@@ -0,0 +1,93 @@
+package sqlrulestore
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+func (r *rule) CreateRuleView(ctx context.Context, view *ruletypes.StorableRuleView) error {
+	_, err := r.sqlstore.
+		BunDBCtx(ctx).
+		NewInsert().
+		Model(view).
+		Exec(ctx)
+	if err != nil {
+		return r.sqlstore.WrapAlreadyExistsErrf(err, errors.CodeAlreadyExists, "rule view with id %s already exists", view.ID)
+	}
+	return nil
+}
+
+func (r *rule) GetRuleView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*ruletypes.StorableRuleView, error) {
+	view := new(ruletypes.StorableRuleView)
+	err := r.sqlstore.
+		BunDBCtx(ctx).
+		NewSelect().
+		Model(view).
+		Where("id = ?", id).
+		Where("org_id = ?", orgID).
+		Scan(ctx)
+	if err != nil {
+		return nil, r.sqlstore.WrapNotFoundErrf(err, ruletypes.ErrCodeRuleViewNotFound, "rule view with id %s doesn't exist", id)
+	}
+	return view, nil
+}
+
+func (r *rule) ListRuleViews(ctx context.Context, orgID valuer.UUID) ([]*ruletypes.StorableRuleView, error) {
+	views := make([]*ruletypes.StorableRuleView, 0)
+	err := r.sqlstore.
+		BunDBCtx(ctx).
+		NewSelect().
+		Model(&views).
+		Where("org_id = ?", orgID).
+		OrderExpr("updated_at DESC").
+		Scan(ctx)
+	if err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "couldn't list rule views")
+	}
+	return views, nil
+}
+
+func (r *rule) UpdateRuleView(ctx context.Context, view *ruletypes.StorableRuleView) error {
+	res, err := r.sqlstore.
+		BunDBCtx(ctx).
+		NewUpdate().
+		Model(view).
+		WherePK().
+		Where("org_id = ?", view.OrgID).
+		Exec(ctx)
+	if err != nil {
+		return errors.WrapInternalf(err, errors.CodeInternal, "couldn't update rule view")
+	}
+	rows, err := res.RowsAffected()
+	if err != nil {
+		return errors.WrapInternalf(err, errors.CodeInternal, "couldn't read rule view update result")
+	}
+	if rows == 0 {
+		return errors.Newf(errors.TypeNotFound, ruletypes.ErrCodeRuleViewNotFound, "rule view with id %s doesn't exist", view.ID)
+	}
+	return nil
+}
+
+func (r *rule) DeleteRuleView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
+	res, err := r.sqlstore.
+		BunDBCtx(ctx).
+		NewDelete().
+		Model(new(ruletypes.StorableRuleView)).
+		Where("id = ?", id).
+		Where("org_id = ?", orgID).
+		Exec(ctx)
+	if err != nil {
+		return errors.WrapInternalf(err, errors.CodeInternal, "couldn't delete rule view")
+	}
+	rows, err := res.RowsAffected()
+	if err != nil {
+		return errors.WrapInternalf(err, errors.CodeInternal, "couldn't read rule view delete result")
+	}
+	if rows == 0 {
+		return errors.Newf(errors.TypeNotFound, ruletypes.ErrCodeRuleViewNotFound, "rule view with id %s doesn't exist", id)
+	}
+	return nil
+}

pkg/ruler/signozruler/handler.go

@@ -345,3 +345,122 @@ func (handler *handler) DeleteDowntimeScheduleByID(rw http.ResponseWriter, req *
 
 	render.Success(rw, http.StatusNoContent, nil)
 }
+
+func (handler *handler) ListRuleViews(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	views, err := handler.ruler.ListRuleViews(ctx, orgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, views)
+}
+
+func (handler *handler) CreateRuleView(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	var postable ruletypes.PostableRuleView
+	if err := binding.JSON.BindBody(req.Body, &postable); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	view, err := handler.ruler.CreateRuleView(ctx, orgID, postable)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusCreated, view)
+}
+
+func (handler *handler) UpdateRuleView(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, err := valuer.NewUUID(mux.Vars(req)["id"])
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	var updatable ruletypes.UpdatableRuleView
+	if err := binding.JSON.BindBody(req.Body, &updatable); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	view, err := handler.ruler.UpdateRuleView(ctx, orgID, id, updatable)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, view)
+}
+
+func (handler *handler) DeleteRuleView(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, err := valuer.NewUUID(mux.Vars(req)["id"])
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	if err := handler.ruler.DeleteRuleView(ctx, orgID, id); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}

pkg/ruler/signozruler/provider.go

@@ -2,10 +2,12 @@ package signozruler
 
 import (
 	"context"
+	"log/slog"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/cache"
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
@@ -26,6 +28,7 @@ import (
 type provider struct {
 	manager   *rules.Manager
 	ruleStore ruletypes.RuleStore
+	logger    *slog.Logger
 	stopC     chan struct{}
 	healthyC  chan struct{}
 }
@@ -73,7 +76,7 @@ func NewFactory(
 			return nil, err
 		}
 
-		return &provider{manager: manager, ruleStore: ruleStore, stopC: make(chan struct{}), healthyC: make(chan struct{})}, nil
+		return &provider{manager: manager, ruleStore: ruleStore, logger: providerSettings.Logger, stopC: make(chan struct{}), healthyC: make(chan struct{})}, nil
 	})
 }
 
@@ -147,3 +150,50 @@ func (provider *provider) TestNotification(ctx context.Context, orgID valuer.UUI
 func (provider *provider) MaintenanceStore() alertmanagertypes.MaintenanceStore {
 	return provider.manager.MaintenanceStore()
 }
+
+func (provider *provider) CreateRuleView(ctx context.Context, orgID valuer.UUID, postable ruletypes.PostableRuleView) (*ruletypes.GettableRuleView, error) {
+	if err := postable.Validate(); err != nil {
+		return nil, err
+	}
+	storable, err := postable.ToStorableRuleView(orgID)
+	if err != nil {
+		return nil, err
+	}
+	if err := provider.ruleStore.CreateRuleView(ctx, storable); err != nil {
+		return nil, err
+	}
+	return storable.ToGettableRuleView()
+}
+
+func (provider *provider) ListRuleViews(ctx context.Context, orgID valuer.UUID) (*ruletypes.ListableRuleViews, error) {
+	storables, err := provider.ruleStore.ListRuleViews(ctx, orgID)
+	if err != nil {
+		return nil, err
+	}
+	views, errByViewID := ruletypes.NewGettableRuleViewsFromStorableRuleViews(storables)
+	for viewID, err := range errByViewID {
+		provider.logger.ErrorContext(ctx, "failed to decode rule view from db", slog.String("rule_view_id", viewID), errors.Attr(err))
+	}
+	return &ruletypes.ListableRuleViews{Views: views}, nil
+}
+
+func (provider *provider) UpdateRuleView(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatable ruletypes.UpdatableRuleView) (*ruletypes.GettableRuleView, error) {
+	if err := updatable.Validate(); err != nil {
+		return nil, err
+	}
+	storable, err := provider.ruleStore.GetRuleView(ctx, orgID, id)
+	if err != nil {
+		return nil, err
+	}
+	if err := storable.Update(updatable); err != nil {
+		return nil, err
+	}
+	if err := provider.ruleStore.UpdateRuleView(ctx, storable); err != nil {
+		return nil, err
+	}
+	return storable.ToGettableRuleView()
+}
+
+func (provider *provider) DeleteRuleView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
+	return provider.ruleStore.DeleteRuleView(ctx, orgID, id)
+}

pkg/signoz/provider.go

@@ -257,6 +257,7 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewAddCloudIntegrationTuplesFactory(sqlstore),
 		sqlmigration.NewAddNotificationChannelTuplesFactory(sqlstore),
 		sqlmigration.NewAddAIObservabilityQuickFiltersFactory(sqlstore),
+		sqlmigration.NewAddRuleViewFactory(sqlstore, sqlschema),
 	)
 }
 

pkg/sqlmigration/131_add_rule_view.go

@@ -0,0 +1,78 @@
+package sqlmigration
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlschema"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+)
+
+type addRuleView struct {
+	sqlstore  sqlstore.SQLStore
+	sqlschema sqlschema.SQLSchema
+}
+
+func NewAddRuleViewFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("add_rule_view"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+		return &addRuleView{
+			sqlstore:  sqlstore,
+			sqlschema: sqlschema,
+		}, nil
+	})
+}
+
+func (migration *addRuleView) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *addRuleView) Up(ctx context.Context, db *bun.DB) error {
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	sqls := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
+		Name: "rule_view",
+		Columns: []*sqlschema.Column{
+			{Name: "id", DataType: sqlschema.DataTypeText, Nullable: false},
+			{Name: "name", DataType: sqlschema.DataTypeText, Nullable: false},
+			{Name: "data", DataType: sqlschema.DataTypeText, Nullable: false},
+			{Name: "org_id", DataType: sqlschema.DataTypeText, Nullable: false},
+			{Name: "created_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
+			{Name: "updated_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
+		},
+		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{ColumnNames: []sqlschema.ColumnName{"id"}},
+		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
+			{
+				ReferencingColumnName: sqlschema.ColumnName("org_id"),
+				ReferencedTableName:   sqlschema.TableName("organizations"),
+				ReferencedColumnName:  sqlschema.ColumnName("id"),
+			},
+		},
+	})
+
+	for _, sql := range sqls {
+		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
+			return err
+		}
+	}
+
+	if _, err := tx.NewCreateIndex().
+		Table("rule_view").
+		Column("org_id").
+		Index("idx_rule_view_org_id").
+		IfNotExists().
+		Exec(ctx); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (migration *addRuleView) Down(_ context.Context, _ *bun.DB) error {
+	return nil
+}

pkg/types/ruletypes/list.go

@@ -49,66 +49,55 @@ func (o ListOrder) IsValid() bool {
 	return slices.ContainsFunc(o.Enum(), func(v any) bool { return v == o })
 }
 
-type ListRulesParams struct {
-	Query string `query:"query"`
-	// gin cannot bind a slice of valuer enums; AlertStates converts these.
-	States []string  `query:"states"`
-	Sort   ListSort  `query:"sort"`
-	Order  ListOrder `query:"order"`
-	Limit  int       `query:"limit"`
-	Offset int       `query:"offset"`
+// ListFilter is the rule listing state shared by the v3 list params and saved views.
+type ListFilter struct {
+	Query string `query:"query" json:"query"`
+	// gin cannot bind a slice of valuer enums; GetAlertStates converts these.
+	States []string  `query:"states" json:"states" nullable:"false"`
+	Sort   ListSort  `query:"sort" json:"sort"`
+	Order  ListOrder `query:"order" json:"order"`
 }
 
-// Validate normalizes in place; an over-max limit is clamped, not rejected.
-func (p *ListRulesParams) Validate() error {
-	if n := utf8.RuneCountInString(p.Query); n > MaxListQueryLen {
+// Validate normalizes in place; zero sort/order get the defaults, nil states an empty slice.
+func (f *ListFilter) Validate() error {
+	if f.States == nil {
+		f.States = []string{}
+	}
+
+	if n := utf8.RuneCountInString(f.Query); n > MaxListQueryLen {
 		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
 			"query cannot be longer than %d characters, got %d", MaxListQueryLen, n)
 	}
 
-	if p.Sort.IsZero() {
-		p.Sort = ListSortUpdatedAt
-	} else if !p.Sort.IsValid() {
-		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
-			"invalid sort %q, expected one of: `updated_at`, `created_at`, `name`, `state`, `severity`", p.Sort)
-	}
-
-	if p.Order.IsZero() {
-		p.Order = ListOrderDesc
-	} else if !p.Order.IsValid() {
-		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
-			"invalid order %q, expected `asc` or `desc`", p.Order)
-	}
-
-	if p.Limit == 0 {
-		p.Limit = DefaultListLimit
-	} else if p.Limit < 0 {
-		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
-			"invalid limit %d, must be a positive integer", p.Limit)
-	} else if p.Limit > MaxListLimit {
-		p.Limit = MaxListLimit
-	}
-
-	if p.Offset < 0 {
-		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
-			"invalid offset %d, must be a non-negative integer", p.Offset)
-	}
-
-	if _, err := p.GetAlertStates(); err != nil {
+	if _, err := f.GetAlertStates(); err != nil {
 		return err
 	}
 
+	if f.Sort.IsZero() {
+		f.Sort = ListSortUpdatedAt
+	} else if !f.Sort.IsValid() {
+		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
+			"invalid sort %q, expected one of: `updated_at`, `created_at`, `name`, `state`, `severity`", f.Sort)
+	}
+
+	if f.Order.IsZero() {
+		f.Order = ListOrderDesc
+	} else if !f.Order.IsValid() {
+		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
+			"invalid order %q, expected `asc` or `desc`", f.Order)
+	}
+
 	return nil
 }
 
 // GetAlertStates parses States; empty means no state filtering.
-func (p *ListRulesParams) GetAlertStates() ([]AlertState, error) {
-	if len(p.States) == 0 {
+func (f *ListFilter) GetAlertStates() ([]AlertState, error) {
+	if len(f.States) == 0 {
 		return nil, nil
 	}
 
-	states := make([]AlertState, 0, len(p.States))
-	for _, raw := range p.States {
+	states := make([]AlertState, 0, len(f.States))
+	for _, raw := range f.States {
 		state, err := parseAlertState(raw)
 		if err != nil {
 			return nil, err
@@ -127,3 +116,32 @@ func parseAlertState(raw string) (AlertState, error) {
 	}
 	return state, nil
 }
+
+type ListRulesParams struct {
+	ListFilter
+	Limit  int `query:"limit"`
+	Offset int `query:"offset"`
+}
+
+// Validate normalizes in place; an over-max limit is clamped, not rejected.
+func (p *ListRulesParams) Validate() error {
+	if err := p.ListFilter.Validate(); err != nil {
+		return err
+	}
+
+	if p.Limit == 0 {
+		p.Limit = DefaultListLimit
+	} else if p.Limit < 0 {
+		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
+			"invalid limit %d, must be a positive integer", p.Limit)
+	} else if p.Limit > MaxListLimit {
+		p.Limit = MaxListLimit
+	}
+
+	if p.Offset < 0 {
+		return errors.NewInvalidInputf(ErrCodeRuleListInvalid,
+			"invalid offset %d, must be a non-negative integer", p.Offset)
+	}
+
+	return nil
+}

pkg/types/ruletypes/list_test.go

@@ -27,7 +27,7 @@ func TestListRulesParamsValidate(t *testing.T) {
 		},
 		{
 			name:      "ExplicitValues_Kept",
-			params:    ListRulesParams{Sort: ListSortSeverity, Order: ListOrderAsc, Limit: 50, Offset: 100},
+			params:    ListRulesParams{ListFilter: ListFilter{Sort: ListSortSeverity, Order: ListOrderAsc}, Limit: 50, Offset: 100},
 			wantSort:  ListSortSeverity,
 			wantOrder: ListOrderAsc,
 			wantLimit: 50,
@@ -41,17 +41,17 @@ func TestListRulesParamsValidate(t *testing.T) {
 		},
 		{
 			name:    "InvalidState_Rejected",
-			params:  ListRulesParams{States: []string{"bogus"}},
+			params:  ListRulesParams{ListFilter: ListFilter{States: []string{"bogus"}}},
 			wantErr: `invalid state "bogus"`,
 		},
 		{
 			name:    "InvalidSort_Rejected",
-			params:  ListRulesParams{Sort: ListSort{valuer.NewString("bogus")}},
+			params:  ListRulesParams{ListFilter: ListFilter{Sort: ListSort{valuer.NewString("bogus")}}},
 			wantErr: "invalid sort",
 		},
 		{
 			name:    "InvalidOrder_Rejected",
-			params:  ListRulesParams{Order: ListOrder{valuer.NewString("bogus")}},
+			params:  ListRulesParams{ListFilter: ListFilter{Order: ListOrder{valuer.NewString("bogus")}}},
 			wantErr: "invalid order",
 		},
 		{
@@ -66,7 +66,7 @@ func TestListRulesParamsValidate(t *testing.T) {
 		},
 		{
 			name:    "OverLongQuery_Rejected",
-			params:  ListRulesParams{Query: strings.Repeat("a", MaxListQueryLen+1)},
+			params:  ListRulesParams{ListFilter: ListFilter{Query: strings.Repeat("a", MaxListQueryLen+1)}},
 			wantErr: "query cannot be longer",
 		},
 	}
@@ -112,7 +112,7 @@ func TestListRulesParamsAlertStates(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			params := ListRulesParams{States: tc.states}
+			params := ListRulesParams{ListFilter: ListFilter{States: tc.states}}
 			states, err := params.GetAlertStates()
 			if tc.wantErr != "" {
 				require.Error(t, err)

pkg/types/ruletypes/rule.go

@@ -65,4 +65,10 @@ type RuleStore interface {
 	GetStoredRuleLabels(context.Context, string) ([]string, error)
 	GetStoredRule(context.Context, valuer.UUID, valuer.UUID) (*StorableRule, error)
 	GetStoredRulesByMetricName(context.Context, string, string) ([]RuleAlert, error)
+
+	CreateRuleView(context.Context, *StorableRuleView) error
+	GetRuleView(context.Context, valuer.UUID, valuer.UUID) (*StorableRuleView, error)
+	ListRuleViews(context.Context, valuer.UUID) ([]*StorableRuleView, error)
+	UpdateRuleView(context.Context, *StorableRuleView) error
+	DeleteRuleView(context.Context, valuer.UUID, valuer.UUID) error
 }

pkg/types/ruletypes/rule_view.go

@@ -0,0 +1,163 @@
+package ruletypes
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/uptrace/bun"
+)
+
+const (
+	RuleViewSchemaVersion = "v1"
+	MaxRuleViewNameLen    = 64
+)
+
+var (
+	ErrCodeRuleViewInvalidInput = errors.MustNewCode("rule_view_invalid_input")
+	ErrCodeRuleViewNotFound     = errors.MustNewCode("rule_view_not_found")
+)
+
+type StorableRuleView struct {
+	bun.BaseModel `bun:"table:rule_view,alias:rule_view"`
+
+	types.Identifiable
+	types.TimeAuditable
+
+	Name  string      `bun:"name,type:text,notnull"`
+	Data  string      `bun:"data,type:text,notnull"`
+	OrgID valuer.UUID `bun:"org_id,type:text,notnull"`
+}
+
+func (s *StorableRuleView) ToGettableRuleView() (*GettableRuleView, error) {
+	data := RuleViewData{}
+	if err := json.Unmarshal([]byte(s.Data), &data); err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "couldn't decode rule view %s", s.ID)
+	}
+
+	return &GettableRuleView{
+		ID:        s.ID,
+		Name:      s.Name,
+		Data:      data,
+		OrgID:     s.OrgID,
+		CreatedAt: s.CreatedAt,
+		UpdatedAt: s.UpdatedAt,
+	}, nil
+}
+
+func (s *StorableRuleView) Update(updatable UpdatableRuleView) error {
+	data, err := json.Marshal(updatable.Data)
+	if err != nil {
+		return errors.WrapInternalf(err, errors.CodeInternal, "couldn't encode rule view %s", s.ID)
+	}
+
+	s.Name = updatable.Name
+	s.Data = string(data)
+	s.UpdatedAt = time.Now()
+	return nil
+}
+
+type GettableRuleView struct {
+	ID        valuer.UUID  `json:"id" required:"true"`
+	Name      string       `json:"name" required:"true"`
+	Data      RuleViewData `json:"data" required:"true"`
+	OrgID     valuer.UUID  `json:"orgId" required:"true"`
+	CreatedAt time.Time    `json:"createdAt" required:"true"`
+	UpdatedAt time.Time    `json:"updatedAt" required:"true"`
+}
+
+// RuleViewData holds the rule listing state (ListRulesParams minus pagination) a view replays.
+type RuleViewData struct {
+	Version string `json:"version" required:"true"`
+	ListFilter
+}
+
+func (d *RuleViewData) Validate() error {
+	if d.Version != RuleViewSchemaVersion {
+		return errors.NewInvalidInputf(ErrCodeRuleViewInvalidInput,
+			"version must be %q, got %q", RuleViewSchemaVersion, d.Version)
+	}
+	return d.ListFilter.Validate()
+}
+
+type PostableRuleView struct {
+	Name string       `json:"name" required:"true"`
+	Data RuleViewData `json:"data" required:"true"`
+}
+
+func (p *PostableRuleView) UnmarshalJSON(data []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(data))
+	dec.DisallowUnknownFields()
+	type alias PostableRuleView
+	var tmp alias
+	if err := dec.Decode(&tmp); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeRuleViewInvalidInput, "invalid saved view request body").WithAdditional(err.Error())
+	}
+	*p = PostableRuleView(tmp)
+	return p.Validate()
+}
+
+func (p *PostableRuleView) Validate() error {
+	if err := validateRuleViewName(p.Name); err != nil {
+		return err
+	}
+	return p.Data.Validate()
+}
+
+func (p PostableRuleView) ToStorableRuleView(orgID valuer.UUID) (*StorableRuleView, error) {
+	data, err := json.Marshal(p.Data)
+	if err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "couldn't encode rule view %q", p.Name)
+	}
+
+	now := time.Now()
+	return &StorableRuleView{
+		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
+		TimeAuditable: types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
+		Name:          p.Name,
+		Data:          string(data),
+		OrgID:         orgID,
+	}, nil
+}
+
+type UpdatableRuleView = PostableRuleView
+
+// NewGettableRuleViewsFromStorableRuleViews converts rows; corrupt rows come back keyed by view id for the caller to log.
+func NewGettableRuleViewsFromStorableRuleViews(storables []*StorableRuleView) ([]*GettableRuleView, map[string]error) {
+	views := make([]*GettableRuleView, 0, len(storables))
+	errByViewID := make(map[string]error)
+
+	for _, storable := range storables {
+		view, err := storable.ToGettableRuleView()
+		if err != nil {
+			errByViewID[storable.ID.StringValue()] = err
+			continue
+		}
+		views = append(views, view)
+	}
+
+	return views, errByViewID
+}
+
+type ListableRuleViews struct {
+	Views []*GettableRuleView `json:"views" required:"true" nullable:"false"`
+}
+
+func validateRuleViewName(name string) error {
+	if strings.TrimSpace(name) == "" {
+		return errors.NewInvalidInputf(ErrCodeRuleViewInvalidInput, "name is required")
+	}
+	if name != strings.TrimSpace(name) {
+		return errors.NewInvalidInputf(ErrCodeRuleViewInvalidInput, "name must not have leading or trailing whitespace")
+	}
+	if n := utf8.RuneCountInString(name); n > MaxRuleViewNameLen {
+		return errors.NewInvalidInputf(ErrCodeRuleViewInvalidInput,
+			"name must be at most %d characters, got %d", MaxRuleViewNameLen, n)
+	}
+	return nil
+}

pkg/types/ruletypes/rule_view_test.go

@@ -0,0 +1,219 @@
+package ruletypes
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRuleViewDataValidate(t *testing.T) {
+	testCases := []struct {
+		name        string
+		data        RuleViewData
+		expectError bool
+	}{
+		{
+			name:        "AllFieldsSet_Valid",
+			data:        RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{Query: "name CONTAINS 'prod'", States: []string{"firing", "pending"}, Sort: ListSortName, Order: ListOrderAsc}},
+			expectError: false,
+		},
+		{
+			name:        "ZeroStatesSortOrder_Valid",
+			data:        RuleViewData{Version: RuleViewSchemaVersion},
+			expectError: false,
+		},
+		{
+			name:        "QueryOverCap_Rejected",
+			data:        RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{Query: strings.Repeat("x", MaxListQueryLen+1)}},
+			expectError: true,
+		},
+		{
+			name:        "WrongVersion_Rejected",
+			data:        RuleViewData{Version: "v2"},
+			expectError: true,
+		},
+		{
+			name:        "EmptyVersion_Rejected",
+			data:        RuleViewData{},
+			expectError: true,
+		},
+		{
+			name:        "UnknownState_Rejected",
+			data:        RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{States: []string{"exploding"}}},
+			expectError: true,
+		},
+		{
+			name:        "UnknownSort_Rejected",
+			data:        RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{Sort: ListSort{valuer.NewString("bogus")}}},
+			expectError: true,
+		},
+		{
+			name:        "UnknownOrder_Rejected",
+			data:        RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{Order: ListOrder{valuer.NewString("sideways")}}},
+			expectError: true,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			err := testCase.data.Validate()
+			if testCase.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestRuleViewDataValidateDefaults(t *testing.T) {
+	data := RuleViewData{Version: RuleViewSchemaVersion}
+	require.NoError(t, data.Validate())
+	assert.Equal(t, ListSortUpdatedAt, data.Sort)
+	assert.Equal(t, ListOrderDesc, data.Order)
+	assert.Equal(t, []string{}, data.States)
+}
+
+func TestPostableRuleViewUnmarshalJSON(t *testing.T) {
+	testCases := []struct {
+		name           string
+		body           string
+		expectError    bool
+		expectedErrMsg string
+		expectedName   string
+	}{
+		{
+			name:         "ValidBody_NameKeptAsIs",
+			body:         `{"name":"my view","data":{"version":"v1","query":"severity = 'critical'","states":["firing"],"sort":"name","order":"asc"}}`,
+			expectError:  false,
+			expectedName: "my view",
+		},
+		{
+			name:           "NameSurroundingWhitespace_Rejected",
+			body:           `{"name":"  my view  ","data":{"version":"v1"}}`,
+			expectError:    true,
+			expectedErrMsg: "name must not have leading or trailing whitespace",
+		},
+		{
+			name:        "UnknownField_Rejected",
+			body:        `{"name":"my view","data":{"version":"v1"},"extra":true}`,
+			expectError: true,
+		},
+		{
+			name:           "BlankName_Rejected",
+			body:           `{"name":"   ","data":{"version":"v1"}}`,
+			expectError:    true,
+			expectedErrMsg: "name is required",
+		},
+		{
+			name:           "NameOverMaxLength_Rejected",
+			body:           `{"name":"` + strings.Repeat("x", MaxRuleViewNameLen+1) + `","data":{"version":"v1"}}`,
+			expectError:    true,
+			expectedErrMsg: "name must be at most",
+		},
+		{
+			name:        "InvalidDataVersion_Rejected",
+			body:        `{"name":"my view","data":{"version":"v9"}}`,
+			expectError: true,
+		},
+		{
+			name:           "InvalidState_Rejected",
+			body:           `{"name":"my view","data":{"version":"v1","states":["exploding"]}}`,
+			expectError:    true,
+			expectedErrMsg: "invalid state",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			var p PostableRuleView
+			err := json.Unmarshal([]byte(testCase.body), &p)
+			if testCase.expectError {
+				assert.Error(t, err)
+				if testCase.expectedErrMsg != "" {
+					assert.ErrorContains(t, err, testCase.expectedErrMsg)
+				}
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, testCase.expectedName, p.Name)
+		})
+	}
+}
+
+func TestToStorableRuleView(t *testing.T) {
+	orgID := valuer.GenerateUUID()
+	postable := PostableRuleView{
+		Name: "my view",
+		Data: RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{States: []string{"firing"}, Sort: ListSortName, Order: ListOrderAsc}},
+	}
+
+	storable, err := postable.ToStorableRuleView(orgID)
+	require.NoError(t, err)
+
+	assert.Equal(t, orgID, storable.OrgID)
+	assert.Equal(t, "my view", storable.Name)
+	assert.False(t, storable.ID.IsZero())
+	assert.False(t, storable.CreatedAt.IsZero())
+	assert.Equal(t, storable.CreatedAt, storable.UpdatedAt)
+
+	gettable, err := storable.ToGettableRuleView()
+	require.NoError(t, err)
+	assert.Equal(t, storable.ID, gettable.ID)
+	assert.Equal(t, "my view", gettable.Name)
+	assert.Equal(t, postable.Data, gettable.Data)
+	assert.Equal(t, orgID, gettable.OrgID)
+	assert.Equal(t, storable.CreatedAt, gettable.CreatedAt)
+}
+
+func TestToGettableRuleView_CorruptData_Errors(t *testing.T) {
+	_, err := (&StorableRuleView{Data: "not json"}).ToGettableRuleView()
+	require.Error(t, err)
+}
+
+func TestNewGettableRuleViewsFromStorableRuleViews(t *testing.T) {
+	orgID := valuer.GenerateUUID()
+	valid, err := PostableRuleView{
+		Name: "valid view",
+		Data: RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{Sort: ListSortName, Order: ListOrderAsc}},
+	}.ToStorableRuleView(orgID)
+	require.NoError(t, err)
+	corrupt := &StorableRuleView{Identifiable: types.Identifiable{ID: valuer.GenerateUUID()}, Data: "not json"}
+
+	views, errByViewID := NewGettableRuleViewsFromStorableRuleViews([]*StorableRuleView{valid, corrupt})
+
+	require.Len(t, views, 1)
+	assert.Equal(t, "valid view", views[0].Name)
+	require.Len(t, errByViewID, 1)
+	assert.Error(t, errByViewID[corrupt.ID.StringValue()])
+}
+
+func TestStorableRuleViewUpdate(t *testing.T) {
+	orgID := valuer.GenerateUUID()
+	storable, err := PostableRuleView{
+		Name: "original",
+		Data: RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{Sort: ListSortName, Order: ListOrderAsc}},
+	}.ToStorableRuleView(orgID)
+	require.NoError(t, err)
+	createdAt := storable.CreatedAt
+
+	err = storable.Update(UpdatableRuleView{
+		Name: "renamed",
+		Data: RuleViewData{Version: RuleViewSchemaVersion, ListFilter: ListFilter{States: []string{"disabled"}, Sort: ListSortCreatedAt, Order: ListOrderDesc}},
+	})
+	require.NoError(t, err)
+
+	gettable, err := storable.ToGettableRuleView()
+	require.NoError(t, err)
+	assert.Equal(t, "renamed", gettable.Name)
+	assert.Equal(t, []string{"disabled"}, gettable.Data.States)
+	assert.Equal(t, ListSortCreatedAt, gettable.Data.Sort)
+	assert.Equal(t, ListOrderDesc, gettable.Data.Order)
+	assert.Equal(t, createdAt, storable.CreatedAt)
+	assert.True(t, storable.UpdatedAt.After(createdAt))
+}

tests/fixtures/alerts.py

@@ -122,6 +122,36 @@ def seed_alert_rules(
     return _seed_alert_rules
 
 
+@pytest.fixture(name="create_rule_view", scope="function")
+def create_rule_view(signoz: types.SigNoz, get_token: Callable[[str, str], str]) -> Callable[[dict], dict]:
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    view_ids = []
+
+    def _create_rule_view(view: dict) -> dict:
+        response = requests.post(
+            signoz.self.host_configs["8080"].get("/api/v2/rule_views"),
+            json=view,
+            headers={"Authorization": f"Bearer {admin_token}"},
+            timeout=5,
+        )
+        assert response.status_code == HTTPStatus.CREATED, f"Failed to create rule view, api returned {response.status_code} with response: {response.text}"
+        created = response.json()["data"]
+        view_ids.append(created["id"])
+        return created
+
+    yield _create_rule_view
+    # A view the test already deleted returns 404; only real failures are logged.
+    for view_id in view_ids:
+        response = requests.delete(
+            signoz.self.host_configs["8080"].get(f"/api/v2/rule_views/{view_id}"),
+            headers={"Authorization": f"Bearer {admin_token}"},
+            timeout=5,
+        )
+        if response.status_code not in (HTTPStatus.NO_CONTENT, HTTPStatus.NOT_FOUND):
+            logger.error("Error deleting rule view: %s", {"view_id": view_id, "response": response.text})
+
+
 def labels_to_map(labels: list[dict]) -> dict[str, str]:
     """Converts the label list shape of the v2 rule history APIs to a plain map."""
     return {label["key"]["name"]: label["value"] for label in labels or []}

tests/integration/tests/alerts/07_rule_views.py

@@ -0,0 +1,269 @@
+import uuid
+from collections.abc import Callable
+from http import HTTPStatus
+
+import pytest
+import requests
+
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.types import Operation, SigNoz
+
+BASE_URL = "/api/v2/rule_views"
+
+
+@pytest.mark.parametrize(
+    ("body", "expected_code", "expected_message"),
+    [
+        ({"data": {"version": "v1"}}, "rule_view_invalid_input", "name is required"),
+        ({"name": "   ", "data": {"version": "v1"}}, "rule_view_invalid_input", "name is required"),
+        (
+            {"name": "  Storage  ", "data": {"version": "v1"}},
+            "rule_view_invalid_input",
+            "name must not have leading or trailing whitespace",
+        ),
+        (
+            {"name": "x" * 65, "data": {"version": "v1"}},
+            "rule_view_invalid_input",
+            "name must be at most 64 characters, got 65",
+        ),
+        (
+            {"name": "wrong-version", "data": {"version": "v2"}},
+            "rule_view_invalid_input",
+            'version must be "v1", got "v2"',
+        ),
+        (
+            {"name": "missing-version", "data": {}},
+            "rule_view_invalid_input",
+            'version must be "v1", got ""',
+        ),
+        (
+            {"name": "bad-state", "data": {"version": "v1", "states": ["exploding"]}},
+            "rule_list_invalid",
+            'invalid state "exploding"',
+        ),
+        (
+            {"name": "bad-sort", "data": {"version": "v1", "sort": "bogus"}},
+            "rule_list_invalid",
+            "invalid sort",
+        ),
+        (
+            {"name": "bad-order", "data": {"version": "v1", "order": "bogus"}},
+            "rule_list_invalid",
+            "invalid order",
+        ),
+        (
+            {"name": "long-query", "data": {"version": "v1", "query": "x" * 1025}},
+            "rule_list_invalid",
+            "query cannot be longer than 1024 characters",
+        ),
+        (
+            {"name": "rejects-unknown", "data": {"version": "v1"}, "unknownfield": "boom"},
+            "rule_view_invalid_input",
+            "invalid saved view request body",
+        ),
+    ],
+    ids=[
+        "missing_name",
+        "blank_name",
+        "whitespace_name",
+        "name_too_long",
+        "wrong_schema_version",
+        "missing_version",
+        "invalid_state",
+        "invalid_sort",
+        "invalid_order",
+        "query_too_long",
+        "unknown_field",
+    ],
+)
+def test_create_rejects_invalid_body(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    body: dict,
+    expected_code: str,
+    expected_message: str,
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        json=body,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    assert response.json()["error"]["code"] == expected_code
+    assert expected_message in response.json()["error"]["message"]
+
+
+def test_update_rejects_malformed_id(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.put(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/not-a-uuid"),
+        json={"name": "x", "data": {"version": "v1"}},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+
+
+def test_update_missing_view_returns_not_found(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.put(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/{uuid.uuid4()}"),
+        json={"name": "x", "data": {"version": "v1"}},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.NOT_FOUND
+    assert response.json()["error"]["code"] == "rule_view_not_found"
+
+
+def test_delete_rejects_malformed_id(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.delete(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/not-a-uuid"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+
+
+def test_delete_missing_view_returns_not_found(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.delete(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/{uuid.uuid4()}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+
+    assert response.status_code == HTTPStatus.NOT_FOUND
+    assert response.json()["error"]["code"] == "rule_view_not_found"
+
+
+def test_rule_view_lifecycle(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    create_rule_view: Callable[[dict], dict],
+):
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    # List assertions filter on this test's names so foreign views never interfere.
+    owned_names = {"Critical Prod", "Critical Staging", "Disabled"}
+
+    created = create_rule_view(
+        {
+            "name": "Critical Prod",
+            "data": {
+                "version": "v1",
+                "query": "name CONTAINS 'prod' AND severity = 'critical'",
+                "states": ["firing", "pending"],
+                "sort": "name",
+                "order": "asc",
+            },
+        }
+    )
+    view_id = created["id"]
+    assert created["name"] == "Critical Prod"
+    assert created["data"]["version"] == "v1"
+    assert created["data"]["query"] == "name CONTAINS 'prod' AND severity = 'critical'"
+    assert created["data"]["states"] == ["firing", "pending"]
+
+    # Omitted states, sort and order are normalized on save: [] and the list defaults, never null.
+    disabled = create_rule_view({"name": "Disabled", "data": {"version": "v1"}})
+    assert disabled["name"] == "Disabled"
+    assert disabled["data"]["states"] == []
+    assert disabled["data"]["sort"] == "updated_at"
+    assert disabled["data"]["order"] == "desc"
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    views = [v for v in response.json()["data"]["views"] if v["name"] in owned_names]
+    assert {v["name"] for v in views} == {"Critical Prod", "Disabled"}
+
+    response = requests.put(
+        signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+        json={
+            "name": "Critical Staging",
+            "data": {
+                "version": "v1",
+                "query": "name CONTAINS 'staging'",
+                "states": ["firing"],
+                "sort": "created_at",
+                "order": "desc",
+            },
+        },
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    updated = response.json()["data"]
+    assert updated["id"] == view_id
+    assert updated["name"] == "Critical Staging"
+    assert updated["data"]["query"] == "name CONTAINS 'staging'"
+    assert updated["data"]["states"] == ["firing"]
+    assert updated["data"]["sort"] == "created_at"
+    assert updated["data"]["order"] == "desc"
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    listed = {v["name"]: v for v in response.json()["data"]["views"] if v["name"] in owned_names}
+    assert set(listed) == {"Critical Staging", "Disabled"}
+    assert listed["Critical Staging"]["data"]["query"] == "name CONTAINS 'staging'"
+
+    assert (
+        requests.delete(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=5,
+        ).status_code
+        == HTTPStatus.NO_CONTENT
+    )
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(BASE_URL),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert {v["name"] for v in response.json()["data"]["views"] if v["name"] in owned_names} == {"Disabled"}
+
+    assert (
+        requests.delete(
+            signoz.self.host_configs["8080"].get(f"{BASE_URL}/{view_id}"),
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=5,
+        ).status_code
+        == HTTPStatus.NOT_FOUND
+    )