fix: concurrent rendering in markdown renderer

Merge branch 'feat/alert_manager_template' into feat/markdown_renderer
chore: removed notifier test files
2026-04-16 17:00:28 +01:00 · 2026-04-16 18:20:25 +05:30 · 2026-04-16 17:59:31 +05:30 · 2026-04-16 17:29:34 +05:30 · 2026-04-16 16:46:44 +05:30 · 2026-04-14 17:51:05 +05:30
56 changed files with 4536 additions and 542 deletions
--- a/cmd/community/server.go
+++ b/cmd/community/server.go
@@ -75,7 +75,7 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		},
 		signoz.NewEmailingProviderFactories(),
 		signoz.NewCacheProviderFactories(),
-		signoz.NewWebProviderFactories(config.Global),
+		signoz.NewWebProviderFactories(),
 		func(sqlstore sqlstore.SQLStore) factory.NamedMap[factory.ProviderFactory[sqlschema.SQLSchema, sqlschema.Config]] {
 			return signoz.NewSQLSchemaProviderFactories(sqlstore)
 		},
--- a/cmd/enterprise/server.go
+++ b/cmd/enterprise/server.go
@@ -96,7 +96,7 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		},
 		signoz.NewEmailingProviderFactories(),
 		signoz.NewCacheProviderFactories(),
-		signoz.NewWebProviderFactories(config.Global),
+		signoz.NewWebProviderFactories(),
 		func(sqlstore sqlstore.SQLStore) factory.NamedMap[factory.ProviderFactory[sqlschema.SQLSchema, sqlschema.Config]] {
 			existingFactories := signoz.NewSQLSchemaProviderFactories(sqlstore)
 			if err := existingFactories.Add(postgressqlschema.NewFactory(sqlstore)); err != nil {
--- a/conf/example.yaml
+++ b/conf/example.yaml
@@ -6,8 +6,6 @@
 ##################### Global #####################
 global:
  # the url under which the signoz apiserver is externally reachable.
-  # the path component (e.g. /signoz in https://example.com/signoz) is used
-  # as the base path for all HTTP routes (both API and web frontend).
  external_url: <unset>
  # the url where the SigNoz backend receives telemetry data (traces, metrics, logs) from instrumented applications.
  ingestion_url: <unset>
@@ -52,8 +50,8 @@ pprof:
 web:
  # Whether to enable the web frontend
  enabled: true
-  # The index file to use as the SPA entrypoint.
-  index: index.html
+  # The prefix to serve web on
+  prefix: /
  # The directory containing the static build files.
  directory: /etc/signoz/web

--- a/ee/query-service/app/server.go
+++ b/ee/query-service/app/server.go
@@ -262,20 +262,6 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 		return nil, err
 	}

-	routePrefix := s.config.Global.ExternalPath()
-	if routePrefix != "" {
-		prefixed := http.StripPrefix(routePrefix, handler)
-		handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-			switch req.URL.Path {
-			case "/api/v1/health", "/api/v2/healthz", "/api/v2/readyz", "/api/v2/livez":
-				r.ServeHTTP(w, req)
-				return
-			}
-
-			prefixed.ServeHTTP(w, req)
-		})
-	}
-
 	return &http.Server{
 		Handler: handler,
 	}, nil
--- a/frontend/.gitignore
+++ b/frontend/.gitignore
@@ -28,7 +28,4 @@ e2e/test-plan/saved-views/
 e2e/test-plan/service-map/
 e2e/test-plan/services/
 e2e/test-plan/traces/
-e2e/test-plan/user-preferences/
-
-# Generated by `vite build` — do not commit
-index.html.gotmpl
+e2e/test-plan/user-preferences/
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -2,7 +2,6 @@
 <html lang="en">
 	<head>
 		<meta charset="utf-8" />
-		<base href="[[.BasePath]]" />
 		<meta
 			http-equiv="Cache-Control"
 			content="no-cache, no-store, must-revalidate, max-age: 0"
@@ -60,7 +59,7 @@
 		<meta data-react-helmet="true" name="docusaurus_locale" content="en" />
 		<meta data-react-helmet="true" name="docusaurus_tag" content="default" />
 		<meta name="robots" content="noindex" />
-		<link data-react-helmet="true" rel="shortcut icon" href="favicon.ico" />
+		<link data-react-helmet="true" rel="shortcut icon" href="/favicon.ico" />
 	</head>
 	<body data-theme="default">
 		<noscript>You need to enable JavaScript to run this app.</noscript>
@@ -114,7 +113,7 @@
 				})(document, 'script');
 			}
 		</script>
-		<link rel="stylesheet" href="css/uPlot.min.css" />
+		<link rel="stylesheet" href="/css/uPlot.min.css" />
 		<script type="module" src="./src/index.tsx"></script>
 	</body>
 </html>
--- a/frontend/src/api/generatedAPIInstance.ts
+++ b/frontend/src/api/generatedAPIInstance.ts
@@ -1,6 +1,5 @@
 import {
 	interceptorRejected,
-	interceptorsRequestBasePath,
 	interceptorsRequestResponse,
 	interceptorsResponse,
 } from 'api';
@@ -18,7 +17,6 @@ export const GeneratedAPIInstance = <T>(
 	return generatedAPIAxiosInstance({ ...config }).then(({ data }) => data);
 };

-generatedAPIAxiosInstance.interceptors.request.use(interceptorsRequestBasePath);
 generatedAPIAxiosInstance.interceptors.request.use(interceptorsRequestResponse);
 generatedAPIAxiosInstance.interceptors.response.use(
 	interceptorsResponse,
--- a/frontend/src/api/index.ts
+++ b/frontend/src/api/index.ts
@@ -11,7 +11,6 @@ import axios, {
 import { ENVIRONMENT } from 'constants/env';
 import { Events } from 'constants/events';
 import { LOCALSTORAGE } from 'constants/localStorage';
-import { getBasePath } from 'utils/getBasePath';
 import { eventEmitter } from 'utils/getEventEmitter';

 import apiV1, { apiAlertManager, apiV2, apiV3, apiV4, apiV5 } from './apiV1';
@@ -68,28 +67,6 @@ export const interceptorsRequestResponse = (
 	return value;
 };

-// Prepends the runtime base path to outgoing requests so API calls work under
-// a URL prefix (e.g. /signoz/api/v1/…). No-op for root deployments and dev
-// (dev baseURL is a full http:// URL, not an absolute path).
-export const interceptorsRequestBasePath = (
-	value: InternalAxiosRequestConfig,
-): InternalAxiosRequestConfig => {
-	const basePath = getBasePath();
-	if (basePath === '/') {
-		return value;
-	}
-
-	if (value.baseURL?.startsWith('/')) {
-		// Named instances: baseURL='/api/v1/' → '/signoz/api/v1/'
-		value.baseURL = basePath + value.baseURL.slice(1);
-	} else if (!value.baseURL && value.url?.startsWith('/')) {
-		// Generated instance: baseURL is '' in prod, path is in url
-		value.url = basePath + value.url.slice(1);
-	}
-
-	return value;
-};
-
 export const interceptorRejected = async (
 	value: AxiosResponse<any>,
 ): Promise<AxiosResponse<any>> => {
@@ -156,7 +133,6 @@ const instance = axios.create({
 });

 instance.interceptors.request.use(interceptorsRequestResponse);
-instance.interceptors.request.use(interceptorsRequestBasePath);
 instance.interceptors.response.use(interceptorsResponse, interceptorRejected);

 export const AxiosAlertManagerInstance = axios.create({
@@ -171,7 +147,6 @@ ApiV2Instance.interceptors.response.use(
 	interceptorRejected,
 );
 ApiV2Instance.interceptors.request.use(interceptorsRequestResponse);
-ApiV2Instance.interceptors.request.use(interceptorsRequestBasePath);

 // axios V3
 export const ApiV3Instance = axios.create({
@@ -183,7 +158,6 @@ ApiV3Instance.interceptors.response.use(
 	interceptorRejected,
 );
 ApiV3Instance.interceptors.request.use(interceptorsRequestResponse);
-ApiV3Instance.interceptors.request.use(interceptorsRequestBasePath);
 //

 // axios V4
@@ -196,7 +170,6 @@ ApiV4Instance.interceptors.response.use(
 	interceptorRejected,
 );
 ApiV4Instance.interceptors.request.use(interceptorsRequestResponse);
-ApiV4Instance.interceptors.request.use(interceptorsRequestBasePath);
 //

 // axios V5
@@ -209,7 +182,6 @@ ApiV5Instance.interceptors.response.use(
 	interceptorRejected,
 );
 ApiV5Instance.interceptors.request.use(interceptorsRequestResponse);
-ApiV5Instance.interceptors.request.use(interceptorsRequestBasePath);
 //

 // axios Base
@@ -222,7 +194,6 @@ LogEventAxiosInstance.interceptors.response.use(
 	interceptorRejectedBase,
 );
 LogEventAxiosInstance.interceptors.request.use(interceptorsRequestResponse);
-LogEventAxiosInstance.interceptors.request.use(interceptorsRequestBasePath);
 //

 AxiosAlertManagerInstance.interceptors.response.use(
@@ -230,7 +201,6 @@ AxiosAlertManagerInstance.interceptors.response.use(
 	interceptorRejected,
 );
 AxiosAlertManagerInstance.interceptors.request.use(interceptorsRequestResponse);
-AxiosAlertManagerInstance.interceptors.request.use(interceptorsRequestBasePath);

 export { apiV1 };
 export default instance;
--- a/frontend/src/lib/history.ts
+++ b/frontend/src/lib/history.ts
@@ -1,4 +1,3 @@
 import { createBrowserHistory } from 'history';
-import { getBasePath } from 'utils/getBasePath';

-export default createBrowserHistory({ basename: getBasePath() });
+export default createBrowserHistory();
--- a/frontend/src/pages/ErrorBoundaryFallback/ErrorBoundaryFallback.tsx
+++ b/frontend/src/pages/ErrorBoundaryFallback/ErrorBoundaryFallback.tsx
@@ -2,7 +2,6 @@ import { useCallback } from 'react';
 import { Button } from 'antd';
 import ROUTES from 'constants/routes';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-import history from 'lib/history';
 import { Home, LifeBuoy } from 'lucide-react';
 import { handleContactSupport } from 'pages/Integrations/utils';

@@ -12,9 +11,8 @@ import './ErrorBoundaryFallback.styles.scss';

 function ErrorBoundaryFallback(): JSX.Element {
 	const handleReload = (): void => {
-		// Use history.push so the navigation stays within the base path prefix
-		// (window.location.href would strip any /signoz/ prefix).
-		history.push(ROUTES.HOME);
+		// Go to home page
+		window.location.href = ROUTES.HOME;
 	};

 	const { isCloudUser: isCloudUserVal } = useGetTenantLicense();
--- a/frontend/src/utils/tests/getBasePath.test.ts
+++ b/frontend/src/utils/tests/getBasePath.test.ts
@@ -1,50 +0,0 @@
-import { getBasePath } from 'utils/getBasePath';
-
-/**
- * Contract tests for getBasePath().
- *
- * These lock down the exact DOM-reading contract so that any future change to
- * the utility (or to how index.html injects the <base> tag) surfaces
- * immediately as a test failure.
- */
-describe('getBasePath', () => {
-	afterEach(() => {
-		// Remove any <base> elements added during the test.
-		document.head.querySelectorAll('base').forEach((el) => el.remove());
-	});
-
-	it('returns the href from the <base> tag when present', () => {
-		const base = document.createElement('base');
-		base.setAttribute('href', '/signoz/');
-		document.head.appendChild(base);
-
-		expect(getBasePath()).toBe('/signoz/');
-	});
-
-	it('returns "/" when no <base> tag exists in the document', () => {
-		expect(getBasePath()).toBe('/');
-	});
-
-	it('returns "/" when the <base> tag has no href attribute', () => {
-		const base = document.createElement('base');
-		document.head.appendChild(base);
-
-		expect(getBasePath()).toBe('/');
-	});
-
-	it('returns the href unchanged when it already has a trailing slash', () => {
-		const base = document.createElement('base');
-		base.setAttribute('href', '/my/nested/path/');
-		document.head.appendChild(base);
-
-		expect(getBasePath()).toBe('/my/nested/path/');
-	});
-
-	it('appends a trailing slash when the href is missing one', () => {
-		const base = document.createElement('base');
-		base.setAttribute('href', '/signoz');
-		document.head.appendChild(base);
-
-		expect(getBasePath()).toBe('/signoz/');
-	});
-});
--- a/frontend/src/utils/getBasePath.ts
+++ b/frontend/src/utils/getBasePath.ts
@@ -1,17 +0,0 @@
-/**
- * Returns the base path for this SigNoz deployment by reading the
- * `<base href>` element injected into index.html by the Go backend at
- * serve time.
- *
- * Always returns a string ending with `/` (e.g. `/`, `/signoz/`).
- * Falls back to `/` when no `<base>` element is present so the app
- * behaves correctly in local Vite dev and unit-test environments.
- *
- * @internal — consume through `src/lib/history` and the axios interceptor;
- * do not read `<base>` directly anywhere else in the codebase.
- */
-export function getBasePath(): string {
-	const href = document.querySelector('base')?.getAttribute('href') ?? '/';
-	// Trailing slash is required for relative asset resolution and API prefixing.
-	return href.endsWith('/') ? href : `${href}/`;
-}
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -10,18 +10,6 @@ import { createHtmlPlugin } from 'vite-plugin-html';
 import { ViteImageOptimizer } from 'vite-plugin-image-optimizer';
 import tsconfigPaths from 'vite-tsconfig-paths';

-// In dev the Go backend is not involved, so replace the [[.BasePath]] placeholder
-// with "/" so relative assets resolve correctly from the Vite dev server.
-function devBasePathPlugin(): Plugin {
-	return {
-		name: 'dev-base-path',
-		apply: 'serve',
-		transformIndexHtml(html): string {
-			return html.replace('[[.BasePath]]', '/');
-		},
-	};
-}
-
 function rawMarkdownPlugin(): Plugin {
 	return {
 		name: 'raw-markdown',
@@ -44,7 +32,6 @@ export default defineConfig(
 		const plugins = [
 			tsconfigPaths(),
 			rawMarkdownPlugin(),
-			devBasePathPlugin(),
 			react(),
 			createHtmlPlugin({
 				inject: {
@@ -137,7 +124,6 @@ export default defineConfig(
 				'process.env.TUNNEL_DOMAIN': JSON.stringify(env.VITE_TUNNEL_DOMAIN),
 				'process.env.DOCS_BASE_URL': JSON.stringify(env.VITE_DOCS_BASE_URL),
 			},
-			base: './',
 			build: {
 				sourcemap: true,
 				outDir: 'build',
--- a/go.mod
+++ b/go.mod
@@ -64,6 +64,7 @@ require (
 	github.com/uptrace/bun/dialect/pgdialect v1.2.9
 	github.com/uptrace/bun/dialect/sqlitedialect v1.2.9
 	github.com/uptrace/bun/extra/bunotel v1.2.9
+	github.com/yuin/goldmark v1.7.16
 	go.opentelemetry.io/collector/confmap v1.51.0
 	go.opentelemetry.io/collector/otelcol v0.144.0
 	go.opentelemetry.io/collector/pdata v1.51.0
--- a/go.sum
+++ b/go.sum
@@ -1144,6 +1144,8 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.7.16 h1:n+CJdUxaFMiDUNnWC3dMWCIQJSkxH4uz3ZwQBkAlVNE=
+github.com/yuin/goldmark v1.7.16/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 github.com/zeebo/assert v1.3.1 h1:vukIABvugfNMZMQO1ABsyQDJDTVQbn+LWSMy1ol1h6A=
--- a/pkg/alertmanager/alertmanagertemplate/alertmanagertemplate.go
+++ b/pkg/alertmanager/alertmanagertemplate/alertmanagertemplate.go
@@ -0,0 +1,292 @@
+package alertmanagertemplate
+
+import (
+	"context"
+	"log/slog"
+	"sort"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/template"
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/common/model"
+)
+
+// AlertManagerTemplater processes alert notification templates.
+type AlertManagerTemplater interface {
+	// ProcessTemplates expands the title and body templates from input
+	// against the provided alerts and returns the expanded templates.
+	ProcessTemplates(ctx context.Context, input TemplateInput, alerts []*types.Alert) (*ExpandedTemplates, error)
+	// BuildNotificationTemplateData builds the NotificationTemplateData from context and alerts.
+	// This exposes the structured alert data that gets used in the notification templates.
+	BuildNotificationTemplateData(ctx context.Context, alerts []*types.Alert) *NotificationTemplateData
+}
+
+type alertManagerTemplater struct {
+	tmpl   *template.Template
+	logger *slog.Logger
+}
+
+func New(tmpl *template.Template, logger *slog.Logger) AlertManagerTemplater {
+	return &alertManagerTemplater{tmpl: tmpl, logger: logger}
+}
+
+// ProcessTemplates expands the title and body templates from input
+// against the provided alerts and returns the expanded templates.
+func (at *alertManagerTemplater) ProcessTemplates(
+	ctx context.Context,
+	input TemplateInput,
+	alerts []*types.Alert,
+) (*ExpandedTemplates, error) {
+	ntd := at.buildNotificationTemplateData(ctx, alerts)
+	missingVars := make(map[string]bool)
+
+	title, titleMissingVars, err := at.expandTitle(input.TitleTemplate, ntd)
+	if err != nil {
+		return nil, err
+	}
+	// if title template results in empty string, use default template
+	// this happens for rules where custom title annotation was not set
+	if title == "" && input.DefaultTitleTemplate != "" {
+		title, err = at.expandDefaultTemplate(ctx, input.DefaultTitleTemplate, alerts)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		mergeMissingVars(missingVars, titleMissingVars)
+	}
+
+	// isDefaultTemplated tracks whether the body is templated using default templates
+	isDefaultTemplated := false
+	body, bodyMissingVars, err := at.expandBody(input.BodyTemplate, ntd)
+	if err != nil {
+		return nil, err
+	}
+	// if body template results in nil, use default template
+	// this happens for rules where custom body annotation was not set
+	if body == nil {
+		isDefaultTemplated = true
+		defaultBody, err := at.expandDefaultTemplate(ctx, input.DefaultBodyTemplate, alerts)
+		if err != nil {
+			return nil, err
+		}
+		body = []string{defaultBody} // default template combines all alerts message into a single body
+	} else {
+		mergeMissingVars(missingVars, bodyMissingVars)
+	}
+
+	// convert the internal map to a sorted slice for returning missing variables
+	missingVarsList := make([]string, 0, len(missingVars))
+	for k := range missingVars {
+		missingVarsList = append(missingVarsList, k)
+	}
+	sort.Strings(missingVarsList)
+
+	return &ExpandedTemplates{
+		Title:                  title,
+		Body:                   body,
+		MissingVars:            missingVarsList,
+		IsDefaultTemplatedBody: isDefaultTemplated,
+	}, nil
+}
+
+// BuildNotificationTemplateData builds the NotificationTemplateData from context and alerts.
+func (at *alertManagerTemplater) BuildNotificationTemplateData(
+	ctx context.Context,
+	alerts []*types.Alert,
+) *NotificationTemplateData {
+	return at.buildNotificationTemplateData(ctx, alerts)
+}
+
+// expandDefaultTemplate uses go-template to expand the default template.
+func (at *alertManagerTemplater) expandDefaultTemplate(
+	ctx context.Context,
+	tmplStr string,
+	alerts []*types.Alert,
+) (string, error) {
+	// if even the default template is empty, return empty string
+	// this is possible if user added channel with blank template
+	if tmplStr == "" {
+		at.logger.WarnContext(ctx, "default template is empty")
+		return "", nil
+	}
+	data := notify.GetTemplateData(ctx, at.tmpl, alerts, at.logger)
+	result, err := at.tmpl.ExecuteTextString(tmplStr, data)
+	if err != nil {
+		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute default template: %s", err.Error())
+	}
+	return result, nil
+}
+
+// mergeMissingVars adds all keys from src into dst.
+func mergeMissingVars(dst, src map[string]bool) {
+	for k := range src {
+		dst[k] = true
+	}
+}
+
+// expandTitle expands the title template. Returns empty string if the template is empty.
+func (at *alertManagerTemplater) expandTitle(
+	titleTemplate string,
+	ntd *NotificationTemplateData,
+) (string, map[string]bool, error) {
+	if titleTemplate == "" {
+		return "", nil, nil
+	}
+	processRes, err := PreProcessTemplateAndData(titleTemplate, ntd)
+	if err != nil {
+		return "", nil, err
+	}
+	result, err := at.tmpl.ExecuteTextString(processRes.Template, processRes.Data)
+	if err != nil {
+		return "", nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute custom title template: %s", err.Error())
+	}
+	return strings.TrimSpace(result), processRes.UnknownVars, nil
+}
+
+// expandBody expands the body template for each individual alert. Returns nil if the template is empty.
+func (at *alertManagerTemplater) expandBody(
+	bodyTemplate string,
+	ntd *NotificationTemplateData,
+) ([]string, map[string]bool, error) {
+	if bodyTemplate == "" {
+		return nil, nil, nil
+	}
+	var sb []string
+	missingVars := make(map[string]bool)
+	for i := range ntd.Alerts {
+		processRes, err := PreProcessTemplateAndData(bodyTemplate, &ntd.Alerts[i])
+		if err != nil {
+			return nil, nil, err
+		}
+		part, err := at.tmpl.ExecuteTextString(processRes.Template, processRes.Data)
+		if err != nil {
+			return nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute custom body template: %s", err.Error())
+		}
+		// add unknown variables and templated text to the result
+		for k := range processRes.UnknownVars {
+			missingVars[k] = true
+		}
+		if strings.TrimSpace(part) != "" {
+			sb = append(sb, strings.TrimSpace(part))
+		}
+	}
+	return sb, missingVars, nil
+}
+
+// buildNotificationTemplateData creates the NotificationTemplateData using
+// info from context and the raw alerts.
+func (at *alertManagerTemplater) buildNotificationTemplateData(
+	ctx context.Context,
+	alerts []*types.Alert,
+) *NotificationTemplateData {
+	// extract the required data from the context
+	receiver, ok := notify.ReceiverName(ctx)
+	if !ok {
+		at.logger.WarnContext(ctx, "missing receiver name in context")
+	}
+
+	groupLabels, ok := notify.GroupLabels(ctx)
+	if !ok {
+		at.logger.WarnContext(ctx, "missing group labels in context")
+	}
+
+	// extract the external URL from the template
+	externalURL := ""
+	if at.tmpl.ExternalURL != nil {
+		externalURL = at.tmpl.ExternalURL.String()
+	}
+
+	commonAnnotations := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
+	commonLabels := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Labels })
+
+	// aggregate labels and annotations from all alerts
+	labels := aggregateKV(alerts, func(a *types.Alert) model.LabelSet { return a.Labels })
+	annotations := aggregateKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
+
+	// build the alert data slice
+	alertDataSlice := make([]AlertData, 0, len(alerts))
+	for _, a := range alerts {
+		ad := buildAlertData(a, receiver)
+		alertDataSlice = append(alertDataSlice, ad)
+	}
+
+	// count the number of firing and resolved alerts
+	var firing, resolved int
+	for _, ad := range alertDataSlice {
+		if ad.IsFiring {
+			firing++
+		} else if ad.IsResolved {
+			resolved++
+		}
+	}
+
+	// extract the rule-level convenience fields from common labels
+	alertName := commonLabels[ruletypes.LabelAlertName]
+	ruleID := commonLabels[ruletypes.LabelRuleID]
+	ruleLink := commonLabels[ruletypes.LabelRuleSource]
+
+	// build the group labels
+	gl := make(template.KV, len(groupLabels))
+	for k, v := range groupLabels {
+		gl[string(k)] = string(v)
+	}
+
+	// build the notification template data
+	return &NotificationTemplateData{
+		Receiver:          receiver,
+		Status:            string(types.Alerts(alerts...).Status()),
+		AlertName:         alertName,
+		RuleID:            ruleID,
+		RuleLink:          ruleLink,
+		TotalFiring:       firing,
+		TotalResolved:     resolved,
+		Alerts:            alertDataSlice,
+		GroupLabels:       gl,
+		CommonLabels:      commonLabels,
+		CommonAnnotations: commonAnnotations,
+		ExternalURL:       externalURL,
+		Labels:            labels,
+		Annotations:       annotations,
+	}
+}
+
+// buildAlertData converts a single *types.Alert into an AlertData.
+func buildAlertData(a *types.Alert, receiver string) AlertData {
+	labels := make(template.KV, len(a.Labels))
+	for k, v := range a.Labels {
+		labels[string(k)] = string(v)
+	}
+
+	annotations := make(template.KV, len(a.Annotations))
+	for k, v := range a.Annotations {
+		annotations[string(k)] = string(v)
+	}
+
+	return AlertData{
+		Receiver:      receiver,
+		Status:        string(a.Status()),
+		Labels:        labels,
+		Annotations:   annotations,
+		StartsAt:      a.StartsAt,
+		EndsAt:        a.EndsAt,
+		GeneratorURL:  a.GeneratorURL,
+		Fingerprint:   a.Fingerprint().String(),
+		AlertName:     labels[ruletypes.LabelAlertName],
+		RuleID:        labels[ruletypes.LabelRuleID],
+		RuleLink:      labels[ruletypes.LabelRuleSource],
+		Severity:      labels[ruletypes.LabelSeverityName],
+		LogLink:       annotations[ruletypes.AnnotationRelatedLogs],
+		TraceLink:     annotations[ruletypes.AnnotationRelatedTraces],
+		Value:         annotations[ruletypes.AnnotationValue],
+		Threshold:     annotations[ruletypes.AnnotationThresholdValue],
+		CompareOp:     annotations[ruletypes.AnnotationCompareOp],
+		MatchType:     annotations[ruletypes.AnnotationMatchType],
+		IsFiring:      a.Status() == model.AlertFiring,
+		IsResolved:    a.Status() == model.AlertResolved,
+		IsMissingData: labels[ruletypes.LabelNoData] == "true",
+		IsRecovering:  labels[ruletypes.LabelIsRecovering] == "true",
+	}
+}
--- a/pkg/alertmanager/alertmanagertemplate/alertmanagertemplate_test.go
+++ b/pkg/alertmanager/alertmanagertemplate/alertmanagertemplate_test.go
@@ -0,0 +1,283 @@
+package alertmanagertemplate
+
+import (
+	"context"
+	"log/slog"
+	"sort"
+	"testing"
+	"time"
+
+	test "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/alertmanagernotifytest"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/require"
+
+	"github.com/prometheus/alertmanager/notify"
+	"github.com/prometheus/alertmanager/types"
+)
+
+// testSetup returns an AlertTemplater and a context pre-populated with group key,
+// receiver name, and group labels for use in tests.
+func testSetup(t *testing.T) (AlertManagerTemplater, context.Context) {
+	t.Helper()
+	tmpl := test.CreateTmpl(t)
+	ctx := context.Background()
+	ctx = notify.WithGroupKey(ctx, "test-group")
+	ctx = notify.WithReceiverName(ctx, "slack")
+	ctx = notify.WithGroupLabels(ctx, model.LabelSet{"alertname": "TestAlert", "severity": "critical"})
+	logger := slog.New(slog.DiscardHandler)
+	return New(tmpl, logger), ctx
+}
+
+func createAlert(labels, annotations map[string]string, isFiring bool) *types.Alert {
+	ls := model.LabelSet{}
+	for k, v := range labels {
+		ls[model.LabelName(k)] = model.LabelValue(v)
+	}
+	ann := model.LabelSet{}
+	for k, v := range annotations {
+		ann[model.LabelName(k)] = model.LabelValue(v)
+	}
+	startsAt := time.Now()
+	var endsAt time.Time
+	if isFiring {
+		endsAt = startsAt.Add(time.Hour)
+	} else {
+		startsAt = startsAt.Add(-2 * time.Hour)
+		endsAt = startsAt.Add(-time.Hour)
+	}
+	return &types.Alert{Alert: model.Alert{Labels: ls, Annotations: ann, StartsAt: startsAt, EndsAt: endsAt}}
+}
+
+func TestExpandTemplates(t *testing.T) {
+	at, ctx := testSetup(t)
+
+	tests := []struct {
+		name              string
+		alerts            []*types.Alert
+		input             TemplateInput
+		wantTitle         string
+		wantBody          []string
+		wantMissingVars   []string
+		errorContains     string
+		wantIsDefaultBody bool
+	}{
+		{
+			// High request throughput on a service — service is a custom label.
+			// $labels.service extracts the label value; $annotations.description pulls the annotation.
+			name: "new template: high request throughput for a service",
+			alerts: []*types.Alert{
+				createAlert(
+					map[string]string{
+						ruletypes.LabelAlertName:    "HighRequestThroughput",
+						ruletypes.LabelSeverityName: "warning",
+						"service":                   "payment-service",
+					},
+					map[string]string{"description": "Request rate exceeded 10k/s"},
+					true,
+				),
+			},
+			input: TemplateInput{
+				TitleTemplate: "High request throughput for $service",
+				BodyTemplate: `The service $service is getting high request. Please investigate.
+Severity: $severity
+Status: $status
+Service: $service
+Description: $description`,
+			},
+			wantTitle: "High request throughput for payment-service",
+			wantBody: []string{`The service payment-service is getting high request. Please investigate.
+Severity: warning
+Status: firing
+Service: payment-service
+Description: Request rate exceeded 10k/s`},
+			wantIsDefaultBody: false,
+		},
+		{
+			// Disk usage alert using old Go template syntax throughout.
+			// No custom templates — both title and body use the default fallback path.
+			name: "old template: disk usage high on database host",
+			alerts: []*types.Alert{
+				createAlert(
+					map[string]string{ruletypes.LabelAlertName: "DiskUsageHigh",
+						ruletypes.LabelSeverityName: "critical",
+						"instance":                  "db-primary-01",
+					},
+					map[string]string{
+						"summary":        "Disk usage high on database host",
+						"description":    "Disk usage is high on the database host",
+						"related_logs":   "https://logs.example.com/search?q=DiskUsageHigh",
+						"related_traces": "https://traces.example.com/search?q=DiskUsageHigh",
+					},
+					true,
+				),
+			},
+			input: TemplateInput{
+				DefaultTitleTemplate: `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }} for {{ .CommonLabels.job }}
+     {{- if gt (len .CommonLabels) (len .GroupLabels) -}}
+       {{" "}}(
+       {{- with .CommonLabels.Remove .GroupLabels.Names }}
+         {{- range $index, $label := .SortedPairs -}}
+           {{ if $index }}, {{ end }}
+           {{- $label.Name }}="{{ $label.Value -}}"
+         {{- end }}
+       {{- end -}}
+       )
+     {{- end }}`,
+				DefaultBodyTemplate: `{{ range .Alerts -}}
+     *Alert:* {{ .Labels.alertname }}{{ if .Labels.severity }} - {{ .Labels.severity }}{{ end }}
+
+     *Summary:* {{ .Annotations.summary }}
+     *Description:* {{ .Annotations.description }}
+     *RelatedLogs:* {{ if gt (len .Annotations.related_logs) 0 -}} View in <{{ .Annotations.related_logs }}|logs explorer> {{- end}}
+     *RelatedTraces:* {{ if gt (len .Annotations.related_traces) 0 -}} View in <{{ .Annotations.related_traces }}|traces explorer> {{- end}}
+
+     *Details:*
+       {{ range .Labels.SortedPairs }} • *{{ .Name }}:* {{ .Value }}
+       {{ end }}
+     {{ end }}`,
+			},
+			wantTitle: "[FIRING:1] DiskUsageHigh for  (instance=\"db-primary-01\")",
+			wantBody: []string{`*Alert:* DiskUsageHigh - critical
+
+     *Summary:* Disk usage high on database host
+     *Description:* Disk usage is high on the database host
+     *RelatedLogs:* View in <https://logs.example.com/search?q=DiskUsageHigh|logs explorer>
+     *RelatedTraces:* View in <https://traces.example.com/search?q=DiskUsageHigh|traces explorer>
+
+     *Details:*
+        • *alertname:* DiskUsageHigh
+        • *instance:* db-primary-01
+        • *severity:* critical
+       
+     `},
+			wantIsDefaultBody: true,
+		},
+		{
+			// Pod crash loop on multiple pods — body is expanded once per alert
+			// and joined with "\n\n", with the pod name pulled from labels.
+			name: "new template: pod crash loop on multiple pods, body per-alert",
+			alerts: []*types.Alert{
+				createAlert(map[string]string{ruletypes.LabelAlertName: "PodCrashLoop", "pod": "api-worker-1"}, nil, true),
+				createAlert(map[string]string{ruletypes.LabelAlertName: "PodCrashLoop", "pod": "api-worker-2"}, nil, true),
+				createAlert(map[string]string{ruletypes.LabelAlertName: "PodCrashLoop", "pod": "api-worker-3"}, nil, true),
+			},
+			input: TemplateInput{
+				TitleTemplate: "$rule_name: $total_firing pods affected",
+				BodyTemplate:  "$labels.pod is crash looping",
+			},
+			wantTitle:         "PodCrashLoop: 3 pods affected",
+			wantBody:          []string{"api-worker-1 is crash looping", "api-worker-2 is crash looping", "api-worker-3 is crash looping"},
+			wantIsDefaultBody: false,
+		},
+		{
+			// Incident partially resolved — one service still down, one recovered.
+			// Title shows the aggregate counts; body shows per-service status.
+			name: "new template: service degradation with mixed firing and resolved alerts",
+			alerts: []*types.Alert{
+				createAlert(map[string]string{ruletypes.LabelAlertName: "ServiceDown", "service": "auth-service"}, nil, true),
+				createAlert(map[string]string{ruletypes.LabelAlertName: "ServiceDown", "service": "payment-service"}, nil, false),
+			},
+			input: TemplateInput{
+				TitleTemplate: "$total_firing firing, $total_resolved resolved",
+				BodyTemplate:  "$labels.service ($status)",
+			},
+			wantTitle:         "1 firing, 1 resolved",
+			wantBody:          []string{"auth-service (firing)", "payment-service (resolved)"},
+			wantIsDefaultBody: false,
+		},
+		{
+			// $environment is not a known AlertData or NotificationTemplateData field,
+			// so it lands in MissingVars and renders as "<no value>" in the output.
+			name: "missing vars: unknown $environment variable in title",
+			alerts: []*types.Alert{
+				createAlert(map[string]string{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical"}, nil, true),
+			},
+			input: TemplateInput{
+				TitleTemplate: "[$environment] $rule_name",
+			},
+			wantTitle:         "[<no value>] HighCPU",
+			wantMissingVars:   []string{"environment"},
+			wantIsDefaultBody: true,
+		},
+		{
+			// $runbook_url is not a known field — someone tried to embed a runbook link
+			// directly as a variable instead of via annotations.
+			name: "missing vars: unknown $runbook_url variable in body",
+			alerts: []*types.Alert{
+				createAlert(map[string]string{ruletypes.LabelAlertName: "PodOOMKilled", ruletypes.LabelSeverityName: "warning"}, nil, true),
+			},
+			input: TemplateInput{
+				BodyTemplate: "$rule_name: see runbook at $runbook_url",
+			},
+			wantBody:        []string{"PodOOMKilled: see runbook at <no value>"},
+			wantMissingVars: []string{"runbook_url"},
+		},
+		{
+			// Both title and body use unknown variables; MissingVars is the union of both.
+			name: "missing vars: unknown variables in both title and body",
+			alerts: []*types.Alert{
+				createAlert(map[string]string{ruletypes.LabelAlertName: "HighMemory", ruletypes.LabelSeverityName: "critical"}, nil, true),
+			},
+			input: TemplateInput{
+				TitleTemplate: "[$environment] $rule_name and [{{ $service }}]",
+				BodyTemplate:  "$rule_name: see runbook at $runbook_url",
+			},
+			wantTitle:       "[<no value>] HighMemory and [<no value>]",
+			wantBody:        []string{"HighMemory: see runbook at <no value>"},
+			wantMissingVars: []string{"environment", "runbook_url", "service"},
+		},
+		{
+			// Custom title template that expands to only whitespace triggers the fallback,
+			// so the default title template is used instead.
+			name: "fallback: whitespace-only custom title falls back to default",
+			alerts: []*types.Alert{
+				createAlert(map[string]string{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical"}, nil, false),
+			},
+			input: TemplateInput{
+				TitleTemplate:        "   ",
+				DefaultTitleTemplate: "{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})",
+				DefaultBodyTemplate:  "Runbook: https://runbook.example.com",
+			},
+			wantTitle:         "HighCPU (RESOLVED)",
+			wantBody:          []string{"Runbook: https://runbook.example.com"},
+			wantIsDefaultBody: true,
+		},
+		{
+			name: "using non-existing function in template",
+			alerts: []*types.Alert{
+				createAlert(map[string]string{ruletypes.LabelAlertName: "HighCPU", ruletypes.LabelSeverityName: "critical"}, nil, true),
+			},
+			input: TemplateInput{
+				TitleTemplate: "$rule_name ({{$severity | toUpperAndTrim}}) for $alertname",
+			},
+			errorContains: "function \"toUpperAndTrim\" not defined",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got, err := at.ProcessTemplates(ctx, tc.input, tc.alerts)
+			if tc.errorContains != "" {
+				require.ErrorContains(t, err, tc.errorContains)
+				return
+			}
+			require.NoError(t, err)
+
+			if tc.wantTitle != "" {
+				require.Equal(t, tc.wantTitle, got.Title)
+			}
+			if tc.wantBody != nil {
+				require.Equal(t, tc.wantBody, got.Body)
+			}
+			require.Equal(t, tc.wantIsDefaultBody, got.IsDefaultTemplatedBody)
+
+			if len(tc.wantMissingVars) == 0 {
+				require.Empty(t, got.MissingVars)
+			} else {
+				sort.Strings(tc.wantMissingVars)
+				require.Equal(t, tc.wantMissingVars, got.MissingVars)
+			}
+		})
+	}
+}
--- a/pkg/alertmanager/alertmanagertemplate/preprocessor.go
+++ b/pkg/alertmanager/alertmanagertemplate/preprocessor.go
@@ -0,0 +1,271 @@
+package alertmanagertemplate
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/go-viper/mapstructure/v2"
+)
+
+// fieldMapping represents a mapping from a JSON tag name to its struct field name.
+type fieldMapping struct {
+	VarName   string // JSON tag name (e.g., "receiver", "rule_name")
+	FieldName string // Struct field name (e.g., "Receiver", "AlertName")
+}
+
+// extractFieldMappings uses reflection to extract field mappings from a struct.
+func extractFieldMappings(data any) []fieldMapping {
+	val := reflect.ValueOf(data)
+	// Handle pointer types
+	if val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			return nil
+		}
+		val = val.Elem()
+	}
+	// return nil if the given data is not a struct
+	if val.Kind() != reflect.Struct {
+		return nil
+	}
+	typ := val.Type()
+
+	var mappings []fieldMapping
+	for i := 0; i < typ.NumField(); i++ {
+		field := typ.Field(i)
+		// Skip unexported fields
+		if !field.IsExported() {
+			continue
+		}
+		// Get JSON tag name
+		jsonTag := field.Tag.Get("json")
+		if jsonTag == "" || jsonTag == "-" {
+			continue
+		}
+		// Extract the name part (before any comma options like omitempty)
+		varName := strings.Split(jsonTag, ",")[0]
+		if varName == "" {
+			continue
+		}
+		varFieldName := field.Tag.Get("mapstructure")
+		if varFieldName == "" {
+			varFieldName = field.Name
+		}
+		// Skip complex types: slices and interfaces
+		kind := field.Type.Kind()
+		if kind == reflect.Slice || kind == reflect.Interface {
+			continue
+		}
+		// For struct types, we skip all but with few exceptions like time.Time
+		if kind == reflect.Struct {
+			// Allow time.Time which is commonly used
+			if field.Type.String() != "time.Time" {
+				continue
+			}
+		}
+
+		mappings = append(mappings, fieldMapping{
+			VarName:   varName,
+			FieldName: varFieldName,
+		})
+	}
+
+	return mappings
+}
+
+// prepareVariableName prepares the variable name to be used in go-text-template
+// it replaces every unwanted character like dots, spaces, etc. with an underscore
+// for example, "http.request.method" becomes "http_request_method".
+func prepareVariableName(key string) string {
+	var b strings.Builder
+	b.Grow(len(key))
+
+	for i, r := range key {
+		switch {
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r == '_': // valid variable name characters
+			b.WriteRune(r)
+		case r >= '0' && r <= '9':
+			if b.Len() == 0 {
+				// leading digit — replace with underscore
+				b.WriteByte('_')
+			} else {
+				b.WriteRune(r)
+			}
+		default:
+			// dots, hyphens, spaces, etc. → underscore
+			b.WriteByte('_')
+		}
+		_ = i
+	}
+	return b.String()
+}
+
+// extractNestedFieldsDefinitions adds the labels and annotations keys from the data struct to the template variable definitions
+// it takes the known data struct and extracts the labels and annotations maps and adds their keys to template variable definitions to be used in the template.
+func extractNestedFieldsDefinitions(data any) map[string]string {
+	variables := make(map[string]string)
+
+	addLabelsAndAnnotations := func(labels, annotations map[string]string) {
+		for k := range annotations {
+			variables[prepareVariableName(k)] = fmt.Sprintf("index .annotations \"%s\"", k)
+		}
+		for k := range labels {
+			variables[prepareVariableName(k)] = fmt.Sprintf("index .labels \"%s\"", k)
+		}
+	}
+
+	switch data := data.(type) {
+	case *NotificationTemplateData:
+		addLabelsAndAnnotations(data.Labels, data.Annotations)
+	case *AlertData:
+		addLabelsAndAnnotations(data.Labels, data.Annotations)
+	default:
+		return variables
+	}
+
+	return variables
+}
+
+// prepareDataForTemplating prepares the data for templating by adding the labels and annotations values to the resulting map
+// so they can be accessed directly from root level, the predefined values take precedence over the labels and annotations values
+// for example, if labels have a value called rule_name, which collides with the rule_name field in the data struct, the value from the data struct will take precedence.
+func prepareDataForTemplating(data any) (map[string]interface{}, error) {
+	var result map[string]interface{}
+	if err := mapstructure.Decode(data, &result); err != nil {
+		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to prepare data for templating")
+	}
+
+	addLabelsAndAnnotationsValues := func(labels, annotations map[string]string) {
+		for k, v := range labels {
+			k = prepareVariableName(k)
+			if _, ok := result[k]; !ok {
+				result[k] = v
+			}
+		}
+		for k, v := range annotations {
+			k = prepareVariableName(k)
+			if _, ok := result[k]; !ok {
+				result[k] = v
+			}
+		}
+	}
+
+	switch data := data.(type) {
+	case *NotificationTemplateData:
+		addLabelsAndAnnotationsValues(data.Labels, data.Annotations)
+	case *AlertData:
+		addLabelsAndAnnotationsValues(data.Labels, data.Annotations)
+	default:
+		return result, nil
+	}
+
+	return result, nil
+}
+
+// generateVariableDefinitions creates `{{ $varname := "" }}` declarations for each variable name.
+func generateVariableDefinitions(varNames map[string]string) string {
+	if len(varNames) == 0 {
+		return ""
+	}
+	var sb strings.Builder
+	for name := range varNames {
+		fmt.Fprintf(&sb, `{{ $%s := %s }}`, name, varNames[name])
+	}
+	return sb.String()
+}
+
+// buildVariableDefinitions constructs the full variable definition preamble for a template.
+// containing all known and unknown variables, the reason to include unknown variables is to
+// populate them with "<no value>" in template so go-text-template don't throw errors
+// when these variables are used in the template.
+func buildVariableDefinitions(tmpl string, data any) (string, map[string]bool, error) {
+	// Extract the initial fields from the data struct and add to the definitions
+	mappings := extractFieldMappings(data)
+
+	// Add variables from struct root level fields to the definitions
+	variables := make(map[string]string)
+	for _, m := range mappings {
+		variables[m.VarName] = fmt.Sprintf(".%s", m.FieldName)
+	}
+
+	// Extract the nested fields definitions from the data struct, like labels, annotations, etc.
+	// once extracted we add them to the variables map along with the field address
+	nestedVariables := extractNestedFieldsDefinitions(data)
+	for k, v := range nestedVariables {
+		variables[k] = v
+	}
+
+	// variables that are used throughout the template
+	usedVars, err := ExtractUsedVariables(tmpl)
+	if err != nil {
+		return "", nil, err
+	}
+
+	// Compute unknown variables: used in template but not covered by a field mapping
+	probableUnknownVars := make(map[string]bool)
+	for name := range usedVars {
+		_, ok := variables[name]
+		if !ok {
+			probableUnknownVars[name] = true
+		}
+	}
+
+	// Add missing variables to the definitions with "<no value>"
+	// missingkey=zero is used to replace the missing value with "<no value>"
+	// but it only works when getting map values like {{ .keyfrommap }} from map and in struct this breaks
+	// with missing variable errors, we add missing variables in map so when directly variables
+	// are accessed directly in template block like {{ $variable }} it's handled and doesn't throw errors.
+	for name := range probableUnknownVars {
+		variables[name] = `"<no value>"`
+	}
+
+	return generateVariableDefinitions(variables), probableUnknownVars, nil
+}
+
+type ProcessingResult struct {
+	Template string
+	Data     map[string]interface{}
+	// UnknownVars is the set of possible unknown variables exptracted using regex
+	UnknownVars map[string]bool
+}
+
+// PreProcessTemplateAndData prepares a template string and struct data for Go template execution.
+//
+//	Input:  "$receiver has $rule_name in $status state"
+//	Output: "{{ $receiver := .Receiver }}...{{ $receiver }} has {{ $rule_name }} in {{ $status }} state"
+func PreProcessTemplateAndData(tmpl string, data any) (*ProcessingResult, error) {
+	// Handle empty template
+	unknownVars := make(map[string]bool)
+	if tmpl == "" {
+		result, err := prepareDataForTemplating(data)
+		if err != nil {
+			return nil, err
+		}
+		return &ProcessingResult{Data: result, UnknownVars: unknownVars}, nil
+	}
+
+	// Build variable definitions: known struct fields + fallback empty-string declarations
+	definitions, unknownVars, err := buildVariableDefinitions(tmpl, data)
+	if err != nil {
+		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to build template definitions")
+	}
+
+	// Attach definitions prefix so WrapDollarVariables can parse the AST without "undefined variable" errors.
+	finalTmpl := definitions + tmpl
+
+	// Call WrapDollarVariables to transform bare $variable references to go-text-template format
+	// with {{ $variable }} syntax from $variable syntax
+	wrappedTmpl, err := WrapDollarVariables(finalTmpl)
+	if err != nil {
+		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to prepare template for templating")
+	}
+
+	// Convert struct to map using mapstructure to be used for template execution
+	result, err := prepareDataForTemplating(data)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ProcessingResult{Template: wrappedTmpl, Data: result, UnknownVars: unknownVars}, nil
+}
--- a/pkg/alertmanager/alertmanagertemplate/preprocessor_test.go
+++ b/pkg/alertmanager/alertmanagertemplate/preprocessor_test.go
@@ -0,0 +1,327 @@
+package alertmanagertemplate
+
+import (
+	"testing"
+	"time"
+
+	"github.com/prometheus/alertmanager/template"
+	"github.com/stretchr/testify/require"
+)
+
+func TestExtractFieldMappings(t *testing.T) {
+	// Struct with various field types to test extraction logic
+	type TestStruct struct {
+		Name            string    `json:"name"`
+		Status          string    `json:"status"`
+		ActiveUserCount int       `json:"user_count" mapstructure:"active_user_count"`
+		IsActive        bool      `json:"is_active"`
+		CreatedAt       time.Time `json:"created_at"` // time.Time allowed
+		Items           []string  `json:"items"`      // slice skipped
+		unexported      string    // unexported skipped (no tag needed)
+		NoTag           string    // no json tag skipped
+		SkippedTag      string    `json:"-"` // json:"-" skipped
+	}
+
+	testCases := []struct {
+		name     string
+		data     any
+		expected []fieldMapping
+	}{
+		{
+			name: "struct with mixed field types",
+			data: TestStruct{Name: "test", ActiveUserCount: 5, unexported: ""},
+			expected: []fieldMapping{
+				{VarName: "name", FieldName: "Name"},
+				{VarName: "status", FieldName: "Status"},
+				{VarName: "user_count", FieldName: "active_user_count"},
+				{VarName: "is_active", FieldName: "IsActive"},
+				{VarName: "created_at", FieldName: "CreatedAt"},
+			},
+		},
+		{
+			name:     "nil data",
+			data:     nil,
+			expected: nil,
+		},
+		{
+			name:     "non-struct type",
+			data:     "string",
+			expected: nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := extractFieldMappings(tc.data)
+			require.Equal(t, tc.expected, result)
+		})
+	}
+}
+
+func TestBuildVariableDefinitions(t *testing.T) {
+	testCases := []struct {
+		name         string
+		tmpl         string
+		data         any
+		expectedVars []string // substrings that must appear in result
+		expectError  bool
+	}{
+		{
+			name: "empty template still returns struct field definitions",
+			tmpl: "",
+			data: &NotificationTemplateData{Receiver: "test"},
+			expectedVars: []string{
+				"{{ $receiver := .receiver }}",
+				"{{ $status := .status }}",
+			},
+		},
+		{
+			name: "mix of known and unknown vars",
+			tmpl: "$rule_name: $custom_label",
+			data: &AlertData{AlertName: "test", Status: "ok", Severity: "critical"},
+			expectedVars: []string{
+				"{{ $rule_name := .rule_name }}",
+				"{{ $status := .status }}",
+				"{{ $severity := .severity }}",
+				`{{ $custom_label := "<no value>" }}`,
+			},
+		},
+		{
+			name: "nested fields definitions coming from NotificationTemplateData",
+			tmpl: "$severity for $service",
+			data: &NotificationTemplateData{Labels: template.KV{
+				"severity":              "critical",
+				"service":               "test",
+				"cloud.region.instance": "ap-south-1",
+			}},
+			expectedVars: []string{
+				"{{ $severity := index .labels \"severity\" }}",
+				"{{ $service := index .labels \"service\" }}",
+				"{{ $cloud_region_instance := index .labels \"cloud.region.instance\" }}",
+			},
+		},
+		{
+			name: "nested fields definitions coming from AlertData",
+			tmpl: "$severity for $service",
+			data: &AlertData{Labels: template.KV{
+				"severity": "critical",
+				"service":  "test",
+			}},
+			expectedVars: []string{
+				"{{ $severity := index .labels \"severity\" }}",
+				"{{ $service := index .labels \"service\" }}",
+			},
+		},
+		{
+			name:        "invalid template syntax returns error",
+			tmpl:        "{{invalid",
+			data:        &NotificationTemplateData{},
+			expectError: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, _, err := buildVariableDefinitions(tc.tmpl, tc.data)
+			if tc.expectError {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			if len(tc.expectedVars) == 0 {
+				require.Empty(t, result)
+				return
+			}
+			for _, expected := range tc.expectedVars {
+				require.Contains(t, result, expected)
+			}
+		})
+	}
+}
+
+func TestPreProcessTemplateAndData(t *testing.T) {
+	testCases := []struct {
+		name                     string
+		tmpl                     string
+		data                     any
+		expectedTemplateContains []string
+		expectedData             map[string]any
+		expectedUnknownVars      map[string]bool
+		expectError              bool
+	}{
+		{
+			name: "NotificationTemplateData with dollar variables and labels with dots and hyphens",
+			tmpl: "[$status] $rule_name (ID: $rule_id) - Firing: $total_firing, Resolved: $total_resolved, Severity: $severity\nHTTP method is: $http_request_method\nRequest path is: $http_request_path",
+			data: &NotificationTemplateData{
+				Receiver:  "pagerduty",
+				Status:    "firing",
+				AlertName: "HighMemory",
+				RuleID:    "rule-123",
+				Labels: template.KV{
+					"severity":            "critical",
+					"http.request.method": "GET",
+					"http-request-path":   "/api/v1/metrics",
+				},
+				TotalFiring:   3,
+				TotalResolved: 1,
+			},
+			expectedTemplateContains: []string{
+				"{{$status := .status}}",
+				"{{$rule_name := .rule_name}}",
+				"{{$rule_id := .rule_id}}",
+				"{{$total_firing := .total_firing}}",
+				"{{$total_resolved := .total_resolved}}",
+				"{{$severity := index .labels \"severity\"}}",
+				"[{{ .status }}] {{ .rule_name }} (ID: {{ .rule_id }}) - Firing: {{ .total_firing }}, Resolved: {{ .total_resolved }}",
+				"{{$http_request_method := index .labels \"http.request.method\"}}",
+				"{{$http_request_path := index .labels \"http-request-path\"}}",
+			},
+			expectedData: map[string]any{
+				"status":              "firing",
+				"rule_name":           "HighMemory",
+				"rule_id":             "rule-123",
+				"total_firing":        3,
+				"total_resolved":      1,
+				"severity":            "critical",
+				"http_request_method": "GET",
+				"http_request_path":   "/api/v1/metrics",
+			},
+			expectedUnknownVars: map[string]bool{},
+		},
+		{
+			name: "AlertData with dollar variables",
+			tmpl: "$rule_name: Value $value exceeded $threshold (Status: $status, Severity: $severity, Description: $description)",
+			data: &AlertData{
+				Receiver:  "webhook",
+				Status:    "resolved",
+				AlertName: "DiskFull",
+				RuleID:    "disk-001",
+				Severity:  "warning",
+				Annotations: template.KV{
+					"description": "Disk full and cannot be written to",
+				},
+				Value:      "85%",
+				Threshold:  "80%",
+				IsFiring:   false,
+				IsResolved: true,
+			},
+			expectedTemplateContains: []string{
+				"{{$rule_name := .rule_name}}",
+				"{{$value := .value}}",
+				"{{$threshold := .threshold}}",
+				"{{$status := .status}}",
+				"{{$severity := .severity}}",
+				"{{$description := index .annotations \"description\"}}",
+				"{{ .rule_name }}: Value {{ .value }} exceeded {{ .threshold }} (Status: {{ .status }}, Severity: {{ .severity }}, Description: {{ .description }})",
+			},
+			expectedData: map[string]any{
+				"status":      "resolved",
+				"rule_name":   "DiskFull",
+				"rule_id":     "disk-001",
+				"severity":    "warning",
+				"value":       "85%",
+				"threshold":   "80%",
+				"description": "Disk full and cannot be written to",
+			},
+			expectedUnknownVars: map[string]bool{},
+		},
+		{
+			name: "mixed dollar and dot notation with both labels and annotations",
+			tmpl: "Alert $rule_name has {{.total_firing}} firing alerts",
+			data: &NotificationTemplateData{
+				AlertName:   "HighCPU",
+				TotalFiring: 5,
+				Labels: template.KV{
+					"value":      "<MASKED VALUE>",
+					"cpu.number": "10",
+				},
+				Annotations: template.KV{
+					"value": "85%",
+				},
+			},
+			expectedTemplateContains: []string{
+				"{{$rule_name := .rule_name}}",
+				"{{$value := index .labels \"value\"}}",
+				"Alert {{ .rule_name }} has {{.total_firing}} firing alerts",
+				"{{$cpu_number := index .labels \"cpu.number\"}}",
+			},
+			expectedData: map[string]any{
+				"rule_name":    "HighCPU",
+				"total_firing": 5,
+				"value":        "<MASKED VALUE>",
+				"cpu_number":   "10",
+			},
+			expectedUnknownVars: map[string]bool{},
+		},
+		{
+			name: "empty template",
+			tmpl: "",
+			data: &NotificationTemplateData{Receiver: "slack"},
+		},
+		{
+			name:        "invalid template syntax",
+			tmpl:        "{{invalid",
+			data:        &NotificationTemplateData{},
+			expectError: true,
+		},
+		{
+			name: "unknown dollar var in text renders empty",
+			tmpl: "alert $custom_note fired",
+			data: &NotificationTemplateData{AlertName: "HighCPU"},
+			expectedTemplateContains: []string{
+				`{{$custom_note := "<no value>"}}`,
+				"alert {{ .custom_note }} fired",
+			},
+			expectedUnknownVars: map[string]bool{"custom_note": true},
+		},
+		{
+			name: "unknown dollar var in action block renders empty",
+			tmpl: "alert {{ $custom_note }} fired",
+			data: &NotificationTemplateData{AlertName: "HighCPU"},
+			expectedTemplateContains: []string{
+				`{{$custom_note := "<no value>"}}`,
+				`alert {{$custom_note}} fired`,
+			},
+			expectedUnknownVars: map[string]bool{"custom_note": true},
+		},
+		{
+			name: "mix of known and unknown vars",
+			tmpl: "$rule_name: $custom_label",
+			data: &NotificationTemplateData{AlertName: "HighCPU"},
+			expectedTemplateContains: []string{
+				"{{$rule_name := .rule_name}}",
+				`{{$custom_label := "<no value>"}}`,
+				"{{ .rule_name }}: {{ .custom_label }}",
+			},
+			expectedData:        map[string]any{"rule_name": "HighCPU"},
+			expectedUnknownVars: map[string]bool{"custom_label": true},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := PreProcessTemplateAndData(tc.tmpl, tc.data)
+
+			if tc.expectError {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			if tc.tmpl == "" {
+				require.Equal(t, "", result.Template)
+				return
+			}
+
+			for _, substr := range tc.expectedTemplateContains {
+				require.Contains(t, result.Template, substr)
+			}
+			for k, v := range tc.expectedData {
+				require.Equal(t, v, result.Data[k])
+			}
+			if tc.expectedUnknownVars != nil {
+				require.Equal(t, tc.expectedUnknownVars, result.UnknownVars)
+			}
+		})
+	}
+}
--- a/pkg/alertmanager/alertmanagertemplate/types.go
+++ b/pkg/alertmanager/alertmanagertemplate/types.go
@@ -0,0 +1,90 @@
+package alertmanagertemplate
+
+import (
+	"time"
+
+	"github.com/prometheus/alertmanager/template"
+)
+
+// TemplateInput carries the title/body templates
+// and their defaults to apply in case the custom templates
+// are result in empty strings.
+type TemplateInput struct {
+	TitleTemplate        string
+	BodyTemplate         string
+	DefaultTitleTemplate string
+	DefaultBodyTemplate  string
+}
+
+// ExpandedTemplates is the result of ExpandTemplates.
+type ExpandedTemplates struct {
+	Title string
+	// Body is notification array of body for each alert
+	Body []string
+	// IsDefaultTemplatedBody is true if the body templates are templated using
+	// default templates, false when custom templates were used for templating.
+	IsDefaultTemplatedBody bool
+	MissingVars            []string // union of unknown vars from title + body templates
+}
+
+// AlertData holds per-alert data used when expanding body templates.
+type AlertData struct {
+	Receiver     string      `json:"receiver" mapstructure:"receiver"`
+	Status       string      `json:"status" mapstructure:"status"`
+	Labels       template.KV `json:"labels" mapstructure:"labels"`
+	Annotations  template.KV `json:"annotations" mapstructure:"annotations"`
+	StartsAt     time.Time   `json:"starts_at" mapstructure:"starts_at"`
+	EndsAt       time.Time   `json:"ends_at" mapstructure:"ends_at"`
+	GeneratorURL string      `json:"generator_url" mapstructure:"generator_url"`
+	Fingerprint  string      `json:"fingerprint" mapstructure:"fingerprint"`
+
+	// Convenience fields extracted from well-known labels/annotations.
+	AlertName string `json:"rule_name" mapstructure:"rule_name"`
+	RuleID    string `json:"rule_id" mapstructure:"rule_id"`
+	RuleLink  string `json:"rule_link" mapstructure:"rule_link"`
+	Severity  string `json:"severity" mapstructure:"severity"`
+
+	// Alert internal data fields
+	Value     string `json:"value" mapstructure:"value"`
+	Threshold string `json:"threshold" mapstructure:"threshold"`
+	CompareOp string `json:"compare_op" mapstructure:"compare_op"`
+	MatchType string `json:"match_type" mapstructure:"match_type"`
+
+	// Link annotations added by the rule evaluator.
+	LogLink   string `json:"log_link" mapstructure:"log_link"`
+	TraceLink string `json:"trace_link" mapstructure:"trace_link"`
+
+	// Status booleans for easy conditional templating.
+	IsFiring      bool `json:"is_firing" mapstructure:"is_firing"`
+	IsResolved    bool `json:"is_resolved" mapstructure:"is_resolved"`
+	IsMissingData bool `json:"is_missing_data" mapstructure:"is_missing_data"`
+	IsRecovering  bool `json:"is_recovering" mapstructure:"is_recovering"`
+}
+
+// NotificationTemplateData is the top-level data struct provided to custom templates.
+type NotificationTemplateData struct {
+	Receiver string `json:"receiver" mapstructure:"receiver"`
+	Status   string `json:"status" mapstructure:"status"`
+
+	// Convenience fields for title templates.
+	AlertName     string `json:"rule_name" mapstructure:"rule_name"`
+	RuleID        string `json:"rule_id" mapstructure:"rule_id"`
+	RuleLink      string `json:"rule_link" mapstructure:"rule_link"`
+	TotalFiring   int    `json:"total_firing" mapstructure:"total_firing"`
+	TotalResolved int    `json:"total_resolved" mapstructure:"total_resolved"`
+
+	// Per-alert data, also available as filtered sub-slices.
+	Alerts []AlertData `json:"-" mapstructure:"-"`
+
+	// Cross-alert aggregates, computed as intersection across all alerts.
+	GroupLabels       template.KV `json:"group_labels" mapstructure:"group_labels"`
+	CommonLabels      template.KV `json:"common_labels" mapstructure:"common_labels"`
+	CommonAnnotations template.KV `json:"common_annotations" mapstructure:"common_annotations"`
+	ExternalURL       string      `json:"external_url" mapstructure:"external_url"`
+	// Labels and Annotations that are collection of labels
+	// and annotations from all alerts, it includes only the common labels and annotations
+	// and for non-common labels and annotations, it picks some first few labels/annotations
+	// and joins them with ", " to avoid blank values in the template
+	Labels      template.KV `json:"labels" mapstructure:"labels"`
+	Annotations template.KV `json:"annotations" mapstructure:"annotations"`
+}
--- a/pkg/alertmanager/alertmanagertemplate/utils.go
+++ b/pkg/alertmanager/alertmanagertemplate/utils.go
@@ -0,0 +1,230 @@
+package alertmanagertemplate
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"text/template/parse"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/prometheus/alertmanager/template"
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/common/model"
+)
+
+// maxAggregatedValues is the maximum number of unique values to include
+// when aggregating non-common label/annotation values across alerts.
+const maxAggregatedValues = 5
+
+// bareVariableRegex matches bare $variable references including dotted paths like $service.name.
+var bareVariableRegex = regexp.MustCompile(`\$(\w+(?:\.\w+)*)`)
+
+// bareVariableRegexFirstSeg matches only the base $variable name, stopping before any dotted path.
+// e.g. "$labels.severity" matches "$labels", "$name" matches "$name".
+var bareVariableRegexFirstSeg = regexp.MustCompile(`\$\w+`)
+
+// ExtractTemplatesFromAnnotations computes the common annotations across all alerts
+// and returns the values for the title_template and body_template annotation keys as title and body templates.
+func ExtractTemplatesFromAnnotations(alerts []*types.Alert) (titleTemplate, bodyTemplate string) {
+	if len(alerts) == 0 {
+		return "", ""
+	}
+
+	commonAnnotations := extractCommonKV(alerts, func(a *types.Alert) model.LabelSet { return a.Annotations })
+	return commonAnnotations[ruletypes.AnnotationTitleTemplate], commonAnnotations[ruletypes.AnnotationBodyTemplate]
+}
+
+// WrapDollarVariables wraps bare $variable references in Go template syntax.
+// Example transformations:
+//   - "$name is $status" -> "{{ $name }} is {{ $status }}"
+//   - "$labels.severity" -> "{{ index .labels \"severity\" }}"
+//   - "$labels.http.status" -> "{{ index .labels \"http.status\" }}"
+//   - "$annotations.summary" -> "{{ index .annotations \"summary\" }}"
+//   - "$service.name" -> "{{ index . \"service.name\" }}"
+//   - "$name is {{ .Status }}" -> "{{ $name }} is {{ .Status }}"
+func WrapDollarVariables(src string) (string, error) {
+	if src == "" {
+		return src, nil
+	}
+
+	// Create a new parse.Tree directly
+	tree := parse.New("template")
+	tree.Mode = parse.SkipFuncCheck
+
+	// Parse the template
+	_, err := tree.Parse(src, "{{", "}}", make(map[string]*parse.Tree), nil)
+	if err != nil {
+		return "", err
+	}
+
+	// Walk the AST and transform TextNodes
+	walkAndWrapTextNodes(tree.Root)
+
+	// Return the reassembled template
+	return tree.Root.String(), nil
+}
+
+// walkAndWrapTextNodes recursively walks the parse tree trying to find a text node.
+// Once a text node is found, it wraps the bare $variable and changes it to index-based
+// element access from the data map, like '.key' or '.key.subkey'.
+func walkAndWrapTextNodes(node parse.Node) {
+	if reflect.ValueOf(node).IsNil() {
+		return
+	}
+
+	switch n := node.(type) {
+	// `$name is {{.Status}}` is a list node with one text and one action node
+	case *parse.ListNode:
+		// Recurse into all child nodes
+		if n.Nodes != nil {
+			for _, child := range n.Nodes {
+				walkAndWrapTextNodes(child)
+			}
+		}
+
+	// `$name is ` is a text node with plain text in root
+	// we try to find the $name variable and wrap it with template block
+	// like `{{ .name }}`, for labels and annotations we use the index to access the value
+	// so `$labels.service` becomes `{{ index .labels "service" }}`
+	case *parse.TextNode:
+		// Transform $variable based on its pattern
+		n.Text = bareVariableRegex.ReplaceAllFunc(n.Text, func(match []byte) []byte {
+			// Extract variable name without the $
+			varName := string(match[1:])
+
+			// Check if variable contains dots
+			if strings.Contains(varName, ".") {
+				// Check for reserved prefixes: labels.* or annotations.*
+				if strings.HasPrefix(varName, "labels.") {
+					key := strings.TrimPrefix(varName, "labels.")
+					return []byte(fmt.Sprintf(`{{ index .labels "%s" }}`, key))
+				}
+				if strings.HasPrefix(varName, "annotations.") {
+					key := strings.TrimPrefix(varName, "annotations.")
+					return []byte(fmt.Sprintf(`{{ index .annotations "%s" }}`, key))
+				}
+				// Other dotted variables: index into root context
+				return []byte(fmt.Sprintf(`{{ index . "%s" }}`, varName))
+			}
+
+			// Simple variables: use dot notation to directly access the field
+			// without raising any error due to missing variables
+			return []byte(fmt.Sprintf("{{ .%s }}", varName))
+		})
+
+	// `{{if pipeline}} T1 {{else}} T0 {{end}}` is a if node with T1 part of List and T0 part of ElseList
+	case *parse.IfNode:
+		// Recurse into both branches
+		walkAndWrapTextNodes(n.List)
+		walkAndWrapTextNodes(n.ElseList)
+
+	// `{{range pipeline}} T1 {{else}} T0 {{end}}` is a range node with T1 part of List and T0 part of ElseList
+	case *parse.RangeNode:
+		// Recurse into both branches
+		walkAndWrapTextNodes(n.List)
+		walkAndWrapTextNodes(n.ElseList)
+
+		// All other node types (ActionNode, PipeNode, VariableNode, etc.) are already
+		// inside {{ }} action blocks and don't need transformation
+
+		// Support for `with` can be added later when we start supporting it in editor block
+	}
+}
+
+// ExtractUsedVariables returns the set of all $variable referenced in template
+// — text nodes, action blocks, branch conditions, and loop declarations — regardless of scope.
+// After finding all variables, we find those that are not part of our alert data and handle them so the
+// text/template parser does not reject undefined $variables.
+func ExtractUsedVariables(src string) (map[string]bool, error) {
+	if src == "" {
+		return map[string]bool{}, nil
+	}
+
+	// Regex-scan raw template string to collect all $var base names.
+	// bareVariableRegexFirstSeg stops before dots, so "$labels.severity" yields "$labels".
+	used := make(map[string]bool)
+	for _, m := range bareVariableRegexFirstSeg.FindAll([]byte(src), -1) {
+		used[string(m[1:])] = true // strip leading "$"
+	}
+
+	// Build a preamble that pre-declares every found variable.
+	// This prevents "undefined variable" parse errors for $vars used in action
+	// blocks while still letting genuine syntax errors propagate.
+	var preamble strings.Builder
+	for name := range used {
+		fmt.Fprintf(&preamble, `{{$%s := ""}}`, name)
+	}
+
+	// Validate template syntax.
+	tree := parse.New("template")
+	tree.Mode = parse.SkipFuncCheck
+	if _, err := tree.Parse(preamble.String()+src, "{{", "}}", make(map[string]*parse.Tree), nil); err != nil {
+		return nil, errors.WrapInvalidInputf(err, errors.CodeInternal, "failed to extract used variables")
+	}
+
+	return used, nil
+}
+
+// aggregateKV aggregates key-value pairs (labels or annotations) from all alerts into a single template.KV.
+// The result is used to populate the labels and annotations in the notification template data.
+func aggregateKV(alerts []*types.Alert, extractFn func(*types.Alert) model.LabelSet) template.KV {
+	// track unique values per key in order of first appearance
+	valuesPerKey := make(map[string][]string)
+	// track which values have been seen for deduplication
+	seenValues := make(map[string]map[string]bool)
+
+	for _, alert := range alerts {
+		kvPairs := extractFn(alert)
+		for k, v := range kvPairs {
+			key := string(k)
+			value := string(v)
+
+			if seenValues[key] == nil {
+				seenValues[key] = make(map[string]bool)
+			}
+
+			// only add if not already seen and under the limit of maxAggregatedValues
+			if !seenValues[key][value] && len(valuesPerKey[key]) < maxAggregatedValues {
+				seenValues[key][value] = true
+				valuesPerKey[key] = append(valuesPerKey[key], value)
+			}
+		}
+	}
+
+	// build the result by joining values
+	result := make(template.KV, len(valuesPerKey))
+	for key, values := range valuesPerKey {
+		result[key] = strings.Join(values, ", ")
+	}
+
+	return result
+}
+
+// extractCommonKV returns the intersection of key-value pairs across all alerts.
+// A key/value pair is included only if it appears identically on every alert.
+func extractCommonKV(alerts []*types.Alert, extractFn func(*types.Alert) model.LabelSet) template.KV {
+	if len(alerts) == 0 {
+		return template.KV{}
+	}
+
+	common := make(template.KV, len(extractFn(alerts[0])))
+	for k, v := range extractFn(alerts[0]) {
+		common[string(k)] = string(v)
+	}
+
+	for _, a := range alerts[1:] {
+		kv := extractFn(a)
+		for k := range common {
+			if string(kv[model.LabelName(k)]) != common[k] {
+				delete(common, k)
+			}
+		}
+		if len(common) == 0 {
+			break
+		}
+	}
+
+	return common
+}
--- a/pkg/alertmanager/alertmanagertemplate/utils_test.go
+++ b/pkg/alertmanager/alertmanagertemplate/utils_test.go
@@ -0,0 +1,348 @@
+package alertmanagertemplate
+
+import (
+	"testing"
+
+	"github.com/prometheus/alertmanager/template"
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWrapBareVars(t *testing.T) {
+	testCases := []struct {
+		name        string
+		input       string
+		expected    string
+		expectError bool
+	}{
+		{
+			name:     "mixed variables with actions",
+			input:    "$name is {{.Status}}",
+			expected: "{{ .name }} is {{.Status}}",
+		},
+		{
+			name: "nested variables in range",
+			input: `{{range .items}}
+				$title
+				{{end}}`,
+			expected: `{{range .items}}
+				{{ .title }}
+				{{end}}`,
+		},
+		{
+			name:     "nested variables in if else",
+			input:    "{{if .ok}}$a{{else}}$b{{end}}",
+			expected: "{{if .ok}}{{ .a }}{{else}}{{ .b }}{{end}}",
+		},
+		// Labels prefix: index into .labels map
+		{
+			name:     "labels variables prefix simple",
+			input:    "$labels.service",
+			expected: `{{ index .labels "service" }}`,
+		},
+		{
+			name:     "labels variables prefix nested with multiple dots",
+			input:    "$labels.http.status",
+			expected: `{{ index .labels "http.status" }}`,
+		},
+		{
+			name:     "multiple labels variables simple and nested",
+			input:    "$labels.service and $labels.instance.id",
+			expected: `{{ index .labels "service" }} and {{ index .labels "instance.id" }}`,
+		},
+		// Annotations prefix: index into .annotations map
+		{
+			name:     "annotations variables prefix simple",
+			input:    "$annotations.summary",
+			expected: `{{ index .annotations "summary" }}`,
+		},
+		{
+			name:     "annotations variables prefix nested with multiple dots",
+			input:    "$annotations.alert.url",
+			expected: `{{ index .annotations "alert.url" }}`,
+		},
+		// Other dotted paths: index into root context
+		{
+			name:     "other variables with multiple dots",
+			input:    "$service.name",
+			expected: `{{ index . "service.name" }}`,
+		},
+		{
+			name:     "other variables with multiple dots nested",
+			input:    "$http.status.code",
+			expected: `{{ index . "http.status.code" }}`,
+		},
+		// Hybrid: all types combined
+		{
+			name:     "hybrid - all variables types",
+			input:    "Alert: $alert_name Labels: $labels.severity Annotations: $annotations.desc Service: $service.name Count: $error_count",
+			expected: `Alert: {{ .alert_name }} Labels: {{ index .labels "severity" }} Annotations: {{ index .annotations "desc" }} Service: {{ index . "service.name" }} Count: {{ .error_count }}`,
+		},
+		{
+			name:     "already wrapped should not be changed",
+			input:    "{{$status := .status}}{{.name}} is {{$status | toUpper}}",
+			expected: "{{$status := .status}}{{.name}} is {{$status | toUpper}}",
+		},
+		{
+			name:     "no variables should not be changed",
+			input:    "Hello world",
+			expected: "Hello world",
+		},
+		{
+			name:     "empty string",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "deeply nested",
+			input:    "{{range .items}}{{if .ok}}$deep{{end}}{{end}}",
+			expected: "{{range .items}}{{if .ok}}{{ .deep }}{{end}}{{end}}",
+		},
+		{
+			name: "complex example",
+			input: `Hello $name, your score is $score.
+				{{if .isAdmin}}
+					Welcome back $name, you have {{.unreadCount}} messages.
+				{{end}}`,
+			expected: `Hello {{ .name }}, your score is {{ .score }}.
+				{{if .isAdmin}}
+					Welcome back {{ .name }}, you have {{.unreadCount}} messages.
+				{{end}}`,
+		},
+		{
+			name:     "with custom function",
+			input:    "$name triggered at {{urlescape .url}}",
+			expected: "{{ .name }} triggered at {{urlescape .url}}",
+		},
+		{
+			name:        "invalid template",
+			input:       "{{invalid",
+			expectError: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := WrapDollarVariables(tc.input)
+
+			if tc.expectError {
+				require.Error(t, err, "should error on invalid template syntax")
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestExtractUsedVariables(t *testing.T) {
+	testCases := []struct {
+		name        string
+		input       string
+		expected    map[string]bool
+		expectError bool
+	}{
+		{
+			name:     "simple usage in text",
+			input:    "$name is $status",
+			expected: map[string]bool{"name": true, "status": true},
+		},
+		{
+			name:     "declared in action block",
+			input:    "{{ $name := .name }}",
+			expected: map[string]bool{"name": true},
+		},
+		{
+			name:     "range loop vars",
+			input:    "{{ range $i, $v := .items }}{{ end }}",
+			expected: map[string]bool{"i": true, "v": true},
+		},
+		{
+			name:     "mixed text and action",
+			input:    "$x and {{ $y }}",
+			expected: map[string]bool{"x": true, "y": true},
+		},
+		{
+			name:     "dotted path in text extracts base only",
+			input:    "$labels.severity",
+			expected: map[string]bool{"labels": true},
+		},
+		{
+			name:     "nested if else",
+			input:    "{{ if .ok }}{{ $a }}{{ else }}{{ $b }}{{ end }}",
+			expected: map[string]bool{"a": true, "b": true},
+		},
+		{
+			name:     "empty string",
+			input:    "",
+			expected: map[string]bool{},
+		},
+		{
+			name:     "no variables",
+			input:    "Hello world",
+			expected: map[string]bool{},
+		},
+		{
+			name:        "invalid template returns error",
+			input:       "{{invalid",
+			expectError: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := ExtractUsedVariables(tc.input)
+
+			if tc.expectError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestAggregateKV(t *testing.T) {
+	extractLabels := func(a *types.Alert) model.LabelSet { return a.Labels }
+
+	testCases := []struct {
+		name      string
+		alerts    []*types.Alert
+		extractFn func(*types.Alert) model.LabelSet
+		expected  template.KV
+	}{
+		{
+			name:      "empty alerts slice",
+			alerts:    []*types.Alert{},
+			extractFn: extractLabels,
+			expected:  template.KV{},
+		},
+		{
+			name: "single alert",
+			alerts: []*types.Alert{
+				{
+					Alert: model.Alert{
+						Labels: model.LabelSet{
+							"env":     "production",
+							"service": "backend",
+						},
+					},
+				},
+			},
+			extractFn: extractLabels,
+			expected: template.KV{
+				"env":     "production",
+				"service": "backend",
+			},
+		},
+		{
+			name: "varying values with duplicates deduped",
+			alerts: []*types.Alert{
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "production", "service": "backend"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "production", "service": "api"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "production", "service": "frontend"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "production", "service": "api"}}},
+			},
+			extractFn: extractLabels,
+			expected: template.KV{
+				"env":     "production",
+				"service": "backend, api, frontend",
+			},
+		},
+		{
+			name: "more than 5 unique values truncates to 5",
+			alerts: []*types.Alert{
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc1"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc2"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc3"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc4"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc5"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc6"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "svc7"}}},
+			},
+			extractFn: extractLabels,
+			expected: template.KV{
+				"service": "svc1, svc2, svc3, svc4, svc5",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := aggregateKV(tc.alerts, tc.extractFn)
+			require.Equal(t, tc.expected, result)
+		})
+	}
+}
+
+func TestExtractCommonKV(t *testing.T) {
+	extractLabels := func(a *types.Alert) model.LabelSet { return a.Labels }
+	extractAnnotations := func(a *types.Alert) model.LabelSet { return a.Annotations }
+
+	testCases := []struct {
+		name      string
+		alerts    []*types.Alert
+		extractFn func(*types.Alert) model.LabelSet
+		expected  template.KV
+	}{
+		{
+			name:      "empty alerts slice",
+			alerts:    []*types.Alert{},
+			extractFn: extractLabels,
+			expected:  template.KV{},
+		},
+		{
+			name: "single alert returns all labels",
+			alerts: []*types.Alert{
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "service": "api"}}},
+			},
+			extractFn: extractLabels,
+			expected:  template.KV{"env": "prod", "service": "api"},
+		},
+		{
+			name: "multiple alerts with fully common labels",
+			alerts: []*types.Alert{
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "region": "us-east"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "region": "us-east"}}},
+			},
+			extractFn: extractLabels,
+			expected:  template.KV{"env": "prod", "region": "us-east"},
+		},
+		{
+			name: "multiple alerts with partially common labels",
+			alerts: []*types.Alert{
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "service": "api"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"env": "prod", "service": "worker"}}},
+			},
+			extractFn: extractLabels,
+			expected:  template.KV{"env": "prod"},
+		},
+		{
+			name: "multiple alerts with no common labels",
+			alerts: []*types.Alert{
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "api"}}},
+				{Alert: model.Alert{Labels: model.LabelSet{"service": "worker"}}},
+			},
+			extractFn: extractLabels,
+			expected:  template.KV{},
+		},
+		{
+			name: "annotations extract common annotations",
+			alerts: []*types.Alert{
+				{Alert: model.Alert{Annotations: model.LabelSet{"summary": "high cpu", "runbook": "http://x"}}},
+				{Alert: model.Alert{Annotations: model.LabelSet{"summary": "high cpu", "runbook": "http://y"}}},
+			},
+			extractFn: extractAnnotations,
+			expected:  template.KV{"summary": "high cpu"},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := extractCommonKV(tc.alerts, tc.extractFn)
+			require.Equal(t, tc.expected, result)
+		})
+	}
+}
--- a/pkg/global/config.go
+++ b/pkg/global/config.go
@@ -2,8 +2,6 @@ package global

 import (
 	"net/url"
-	"path"
-	"strings"

 	"github.com/SigNoz/signoz/pkg/errors"

@@ -39,34 +37,5 @@ func newConfig() factory.Config {
 }

 func (c Config) Validate() error {
-	if c.ExternalURL != nil {
-		if c.ExternalURL.Path != "" && c.ExternalURL.Path != "/" {
-			if !strings.HasPrefix(c.ExternalURL.Path, "/") {
-				return errors.NewInvalidInputf(ErrCodeInvalidGlobalConfig, "global::external_url path must start with '/', got %q", c.ExternalURL.Path)
-			}
-		}
-	}
-
 	return nil
 }
-
-func (c Config) ExternalPath() string {
-	if c.ExternalURL == nil || c.ExternalURL.Path == "" || c.ExternalURL.Path == "/" {
-		return ""
-	}
-
-	p := path.Clean("/" + c.ExternalURL.Path)
-	if p == "/" {
-		return ""
-	}
-
-	return p
-}
-
-func (c Config) ExternalPathTrailing() string {
-	if p := c.ExternalPath(); p != "" {
-		return p + "/"
-	}
-
-	return "/"
-}
--- a/pkg/global/config_test.go
+++ b/pkg/global/config_test.go
@@ -1,139 +0,0 @@
-package global
-
-import (
-	"net/url"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestExternalPath(t *testing.T) {
-	testCases := []struct {
-		name     string
-		config   Config
-		expected string
-	}{
-		{
-			name:     "NilURL",
-			config:   Config{ExternalURL: nil},
-			expected: "",
-		},
-		{
-			name:     "EmptyPath",
-			config:   Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: ""}},
-			expected: "",
-		},
-		{
-			name:     "RootPath",
-			config:   Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/"}},
-			expected: "",
-		},
-		{
-			name:     "SingleSegment",
-			config:   Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/signoz"}},
-			expected: "/signoz",
-		},
-		{
-			name:     "TrailingSlash",
-			config:   Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/signoz/"}},
-			expected: "/signoz",
-		},
-		{
-			name:     "MultiSegment",
-			config:   Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/a/b/c"}},
-			expected: "/a/b/c",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			assert.Equal(t, tc.expected, tc.config.ExternalPath())
-		})
-	}
-}
-
-func TestExternalPathTrailing(t *testing.T) {
-	testCases := []struct {
-		name     string
-		config   Config
-		expected string
-	}{
-		{
-			name:     "NilURL",
-			config:   Config{ExternalURL: nil},
-			expected: "/",
-		},
-		{
-			name:     "EmptyPath",
-			config:   Config{ExternalURL: &url.URL{Path: ""}},
-			expected: "/",
-		},
-		{
-			name:     "RootPath",
-			config:   Config{ExternalURL: &url.URL{Path: "/"}},
-			expected: "/",
-		},
-		{
-			name:     "SingleSegment",
-			config:   Config{ExternalURL: &url.URL{Path: "/signoz"}},
-			expected: "/signoz/",
-		},
-		{
-			name:     "MultiSegment",
-			config:   Config{ExternalURL: &url.URL{Path: "/a/b/c"}},
-			expected: "/a/b/c/",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			assert.Equal(t, tc.expected, tc.config.ExternalPathTrailing())
-		})
-	}
-}
-
-func TestValidate(t *testing.T) {
-	testCases := []struct {
-		name   string
-		config Config
-		fail   bool
-	}{
-		{
-			name:   "NilURL",
-			config: Config{ExternalURL: nil},
-			fail:   false,
-		},
-		{
-			name:   "EmptyPath",
-			config: Config{ExternalURL: &url.URL{Path: ""}},
-			fail:   false,
-		},
-		{
-			name:   "RootPath",
-			config: Config{ExternalURL: &url.URL{Path: "/"}},
-			fail:   false,
-		},
-		{
-			name:   "ValidPath",
-			config: Config{ExternalURL: &url.URL{Path: "/signoz"}},
-			fail:   false,
-		},
-		{
-			name:   "NoLeadingSlash",
-			config: Config{ExternalURL: &url.URL{Path: "signoz"}},
-			fail:   true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			err := tc.config.Validate()
-			if tc.fail {
-				assert.Error(t, err)
-				return
-			}
-
-			assert.NoError(t, err)
-		})
-	}
-}
--- a/pkg/query-service/app/http_handler.go
+++ b/pkg/query-service/app/http_handler.go
@@ -587,6 +587,7 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/query_filter/analyze", am.ViewAccess(aH.QueryParserAPI.AnalyzeQueryFilter)).Methods(http.MethodPost)
 }

+
 func Intersection(a, b []int) (c []int) {
 	m := make(map[int]bool)

--- a/pkg/query-service/app/server.go
+++ b/pkg/query-service/app/server.go
@@ -244,20 +244,6 @@ func (s *Server) createPublicServer(api *APIHandler, web web.Web) (*http.Server,
 		return nil, err
 	}

-	routePrefix := s.config.Global.ExternalPath()
-	if routePrefix != "" {
-		prefixed := http.StripPrefix(routePrefix, handler)
-		handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-			switch req.URL.Path {
-			case "/api/v1/health", "/api/v2/healthz", "/api/v2/readyz", "/api/v2/livez":
-				r.ServeHTTP(w, req)
-				return
-			}
-
-			prefixed.ServeHTTP(w, req)
-		})
-	}
-
 	return &http.Server{
 		Handler: handler,
 	}, nil
--- a/pkg/signoz/provider.go
+++ b/pkg/signoz/provider.go
@@ -88,9 +88,9 @@ func NewCacheProviderFactories() factory.NamedMap[factory.ProviderFactory[cache.
 	)
 }

-func NewWebProviderFactories(globalConfig global.Config) factory.NamedMap[factory.ProviderFactory[web.Web, web.Config]] {
+func NewWebProviderFactories() factory.NamedMap[factory.ProviderFactory[web.Web, web.Config]] {
 	return factory.MustNewNamedMap(
-		routerweb.NewFactory(globalConfig),
+		routerweb.NewFactory(),
 		noopweb.NewFactory(),
 	)
 }
--- a/pkg/signoz/provider_test.go
+++ b/pkg/signoz/provider_test.go
@@ -8,7 +8,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/nfmanagertest"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
@@ -35,7 +34,7 @@ func TestNewProviderFactories(t *testing.T) {
 	})

 	assert.NotPanics(t, func() {
-		NewWebProviderFactories(global.Config{})
+		NewWebProviderFactories()
 	})

 	assert.NotPanics(t, func() {
--- a/pkg/templating/markdownrenderer/html.go
+++ b/pkg/templating/markdownrenderer/html.go
@@ -0,0 +1,28 @@
+package markdownrenderer
+
+import (
+	"bytes"
+	"context"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+// SoftLineBreakHTML is a HTML tag that is used to represent a soft line break.
+const SoftLineBreakHTML = `<p></p>`
+
+func (r *markdownRenderer) renderHTML(_ context.Context, markdown string) (string, error) {
+	var buf bytes.Buffer
+	if err := newHTMLRenderer().Convert([]byte(markdown), &buf); err != nil {
+		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to convert markdown to HTML")
+	}
+
+	// return buf.String(), nil
+
+	// TODO: check if there is another way to handle soft line breaks in HTML
+	// the idea with paragraph tags is that it will start the content in new
+	// line without using a line break tag, this works well in variety of cases
+	// but not all, for example, in case of code block, the paragraph tags will be added
+	// to the code block where newline is present.
+	return strings.ReplaceAll(buf.String(), "\n", SoftLineBreakHTML), nil
+}
--- a/pkg/templating/markdownrenderer/html_test.go
+++ b/pkg/templating/markdownrenderer/html_test.go
@@ -0,0 +1,182 @@
+package markdownrenderer
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	testMarkdown = `# 🔥 FIRING: High CPU Usage on api-gateway
+
+https://signoz.example.com/alerts/123
+https://runbooks.example.com/cpu-high
+
+## Alert Details
+
+**Status:** **FIRING** | *api-gateway* service is experiencing high CPU usage. ~~resolved~~ previously.
+
+Alert triggered because ` + "`cpu_usage_percent`" + ` exceeded threshold ` + "`90`" + `.
+
+[View Alert in SigNoz](https://signoz.example.com/alerts/123) | [View Logs](https://signoz.example.com/logs?service=api-gateway) | [View Traces](https://signoz.example.com/traces?service=api-gateway)
+
+![critical](https://signoz.example.com/badges/critical.svg "Critical Alert")
+
+## Alert Labels
+
+| Label    | Value       |
+| -------- | ----------- |
+| service  | api-gateway |
+| instance | pod-5a8b3c  |
+| severity | critical    |
+| region   | us-east-1   |
+
+## Remediation Steps
+
+1. Check current CPU usage on the pod
+2. Review recent deployments for regressions
+3. Scale horizontally if load-related
+    1. Increase replica count
+    2. Verify HPA configuration
+
+## Affected Services
+
+* api-gateway
+* auth-service
+* payment-service
+    * payment-processor
+    * payment-validator
+
+## Incident Checklist
+
+- [x] Alert acknowledged
+- [x] On-call notified
+- [ ] Root cause identified
+- [ ] Fix deployed
+
+## Alert Rule Description
+
+> This alert fires when CPU usage exceeds 90% for more than 5 minutes on any pod in the api-gateway service.
+>
+>> For capacity planning guidelines, see the infrastructure runbook section on horizontal pod autoscaling.
+
+## Triggered Query
+` + "```promql\navg(rate(container_cpu_usage_seconds_total{service=\"api-gateway\"}[5m])) by (pod) > 0.9\n```" + `
+
+## Inline Details
+
+This alert was generated by SigNoz using ` + "`alertmanager`" + ` rules engine.
+`
+)
+
+func newTestRenderer() MarkdownRenderer {
+	return NewMarkdownRenderer(slog.New(slog.NewTextHandler(os.Stdout, nil)))
+}
+
+func TestRenderHTML_Composite(t *testing.T) {
+	renderer := newTestRenderer()
+
+	html, err := renderer.Render(context.Background(), testMarkdown, MarkdownFormatHTML)
+	require.NoError(t, err)
+
+	// Full expected output for exact match
+	expected := `<h1>🔥 FIRING: High CPU Usage on api-gateway</h1><p></p>` +
+		`<p><a href="https://signoz.example.com/alerts/123">https://signoz.example.com/alerts/123</a><p></p><a href="https://runbooks.example.com/cpu-high">https://runbooks.example.com/cpu-high</a></p><p></p>` +
+		`<h2>Alert Details</h2><p></p>` +
+		`<p><strong>Status:</strong> <strong>FIRING</strong> | <em>api-gateway</em> service is experiencing high CPU usage. <del>resolved</del> previously.</p><p></p>` +
+		`<p>Alert triggered because <code>cpu_usage_percent</code> exceeded threshold <code>90</code>.</p><p></p>` +
+		`<p><a href="https://signoz.example.com/alerts/123">View Alert in SigNoz</a> | <a href="https://signoz.example.com/logs?service=api-gateway">View Logs</a> | <a href="https://signoz.example.com/traces?service=api-gateway">View Traces</a></p><p></p>` +
+		`<p><img src="https://signoz.example.com/badges/critical.svg" alt="critical" title="Critical Alert"></p><p></p>` +
+		`<h2>Alert Labels</h2><p></p>` +
+		`<table><p></p><thead><p></p><tr><p></p><th>Label</th><p></p><th>Value</th><p></p></tr><p></p></thead><p></p>` +
+		`<tbody><p></p><tr><p></p><td>service</td><p></p><td>api-gateway</td><p></p></tr><p></p>` +
+		`<tr><p></p><td>instance</td><p></p><td>pod-5a8b3c</td><p></p></tr><p></p>` +
+		`<tr><p></p><td>severity</td><p></p><td>critical</td><p></p></tr><p></p>` +
+		`<tr><p></p><td>region</td><p></p><td>us-east-1</td><p></p></tr><p></p></tbody><p></p></table><p></p>` +
+		`<h2>Remediation Steps</h2><p></p>` +
+		`<ol><p></p><li>Check current CPU usage on the pod</li><p></p><li>Review recent deployments for regressions</li><p></p><li>Scale horizontally if load-related<p></p>` +
+		`<ol><p></p><li>Increase replica count</li><p></p><li>Verify HPA configuration</li><p></p></ol><p></p></li><p></p></ol><p></p>` +
+		`<h2>Affected Services</h2><p></p>` +
+		`<ul><p></p><li>api-gateway</li><p></p><li>auth-service</li><p></p><li>payment-service<p></p>` +
+		`<ul><p></p><li>payment-processor</li><p></p><li>payment-validator</li><p></p></ul><p></p></li><p></p></ul><p></p>` +
+		`<h2>Incident Checklist</h2><p></p>` +
+		`<ul><p></p><li><input checked="" disabled="" type="checkbox"> Alert acknowledged</li><p></p>` +
+		`<li><input checked="" disabled="" type="checkbox"> On-call notified</li><p></p>` +
+		`<li><input disabled="" type="checkbox"> Root cause identified</li><p></p>` +
+		`<li><input disabled="" type="checkbox"> Fix deployed</li><p></p></ul><p></p>` +
+		`<h2>Alert Rule Description</h2><p></p>` +
+		`<blockquote><p></p><p>This alert fires when CPU usage exceeds 90% for more than 5 minutes on any pod in the api-gateway service.</p><p></p>` +
+		`<blockquote><p></p><p>For capacity planning guidelines, see the infrastructure runbook section on horizontal pod autoscaling.</p><p></p></blockquote><p></p></blockquote><p></p>` +
+		`<h2>Triggered Query</h2><p></p>` +
+		`<pre><code class="language-promql">avg(rate(container_cpu_usage_seconds_total{service=&quot;api-gateway&quot;}[5m])) by (pod) &gt; 0.9<p></p></code></pre><p></p>` +
+		`<h2>Inline Details</h2><p></p>` +
+		`<p>This alert was generated by SigNoz using <code>alertmanager</code> rules engine.</p><p></p>`
+
+	assert.Equal(t, expected, html)
+}
+
+func TestRenderHTML_InlineFormatting(t *testing.T) {
+	renderer := newTestRenderer()
+
+	input := `# 🔥 FIRING: High CPU on api-gateway
+## Alert Status
+
+**FIRING** alert for *api-gateway* service — ~~resolved~~ previously.
+
+Metric ` + "`cpu_usage_percent`" + ` exceeded threshold. [View in SigNoz](https://signoz.example.com/alerts/123)
+
+![critical](https://signoz.example.com/badges/critical.svg "Critical Alert")`
+
+	html, err := renderer.Render(context.Background(), input, MarkdownFormatHTML)
+	require.NoError(t, err)
+
+	expected := `<h1>🔥 FIRING: High CPU on api-gateway</h1><p></p><h2>Alert Status</h2><p></p>` +
+		`<p><strong>FIRING</strong> alert for <em>api-gateway</em> service — <del>resolved</del> previously.</p><p></p>` +
+		`<p>Metric <code>cpu_usage_percent</code> exceeded threshold. <a href="https://signoz.example.com/alerts/123">View in SigNoz</a></p><p></p>` +
+		`<p><img src="https://signoz.example.com/badges/critical.svg" alt="critical" title="Critical Alert"></p><p></p>`
+
+	assert.Equal(t, expected, html)
+}
+
+func TestRenderHTML_BlockElements(t *testing.T) {
+	renderer := newTestRenderer()
+
+	input := `1. Check CPU usage on the pod
+2. Review recent deployments
+3. Scale horizontally if needed
+
+* api-gateway
+* auth-service
+* payment-service
+
+- [x] Alert acknowledged
+- [ ] Root cause identified
+
+> This alert fires when CPU usage exceeds 90% for more than 5 minutes.
+
+| Label    | Value       |
+| -------- | ----------- |
+| service  | api-gateway |
+| severity | <no value>    |
+
+` + "```promql\navg(rate(container_cpu_usage_seconds_total{service=\"api-gateway\"}[5m])) by (pod) > 0.9\n```"
+
+	html, err := renderer.Render(context.Background(), input, MarkdownFormatHTML)
+	require.NoError(t, err)
+
+	expected := `<ol><p></p><li>Check CPU usage on the pod</li><p></p><li>Review recent deployments</li><p></p><li>Scale horizontally if needed</li><p></p></ol><p></p>` +
+		`<ul><p></p><li>api-gateway</li><p></p><li>auth-service</li><p></p><li>payment-service</li><p></p></ul><p></p>` +
+		`<ul><p></p><li><input checked="" disabled="" type="checkbox"> Alert acknowledged</li><p></p>` +
+		`<li><input disabled="" type="checkbox"> Root cause identified</li><p></p></ul><p></p>` +
+		`<blockquote><p></p><p>This alert fires when CPU usage exceeds 90% for more than 5 minutes.</p><p></p></blockquote><p></p>` +
+		`<table><p></p><thead><p></p><tr><p></p><th>Label</th><p></p><th>Value</th><p></p></tr><p></p></thead><p></p>` +
+		`<tbody><p></p><tr><p></p><td>service</td><p></p><td>api-gateway</td><p></p></tr><p></p>` +
+		`<tr><p></p><td>severity</td><p></p><td>&lt;no value&gt;</td><p></p></tr><p></p></tbody><p></p></table><p></p>` +
+		`<pre><code class="language-promql">avg(rate(container_cpu_usage_seconds_total{service=&quot;api-gateway&quot;}[5m])) by (pod) &gt; 0.9<p></p></code></pre><p></p>`
+
+	assert.Equal(t, expected, html)
+}
--- a/pkg/templating/markdownrenderer/markdownrenderer.go
+++ b/pkg/templating/markdownrenderer/markdownrenderer.go
@@ -0,0 +1,75 @@
+package markdownrenderer
+
+import (
+	"context"
+	"log/slog"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/templating/slackblockkitrenderer"
+	"github.com/SigNoz/signoz/pkg/templating/slackmrkdwnrenderer"
+	"github.com/SigNoz/signoz/pkg/templating/templatingextensions"
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/extension"
+)
+
+// newHTMLRenderer creates a new goldmark.Markdown instance for HTML rendering.
+func newHTMLRenderer() goldmark.Markdown {
+	return goldmark.New(
+		goldmark.WithExtensions(extension.GFM),
+		goldmark.WithExtensions(templatingextensions.EscapeNoValue),
+	)
+}
+
+// newSlackBlockKitRenderer creates a new goldmark.Markdown instance for Slack Block Kit rendering.
+func newSlackBlockKitRenderer() goldmark.Markdown {
+	return goldmark.New(
+		goldmark.WithExtensions(slackblockkitrenderer.BlockKitV2),
+	)
+}
+
+// newSlackMrkdwnRenderer creates a new goldmark.Markdown instance for Slack mrkdwn rendering.
+func newSlackMrkdwnRenderer() goldmark.Markdown {
+	return goldmark.New(
+		goldmark.WithExtensions(slackmrkdwnrenderer.SlackMrkdwn),
+	)
+}
+
+type OutputFormat int
+
+const (
+	MarkdownFormatHTML OutputFormat = iota
+	MarkdownFormatSlackBlockKit
+	MarkdownFormatSlackMrkdwn
+	MarkdownFormatNoop
+)
+
+// MarkdownRenderer is the interface for rendering markdown to different formats.
+type MarkdownRenderer interface {
+	// Render renders the markdown to the given output format.
+	Render(ctx context.Context, markdown string, outputFormat OutputFormat) (string, error)
+}
+
+type markdownRenderer struct {
+	logger *slog.Logger
+}
+
+func NewMarkdownRenderer(logger *slog.Logger) MarkdownRenderer {
+	return &markdownRenderer{
+		logger: logger,
+	}
+}
+
+func (r *markdownRenderer) Render(ctx context.Context, markdown string, outputFormat OutputFormat) (string, error) {
+	switch outputFormat {
+	case MarkdownFormatHTML:
+		return r.renderHTML(ctx, markdown)
+	case MarkdownFormatSlackBlockKit:
+		return r.renderSlackBlockKit(ctx, markdown)
+	case MarkdownFormatSlackMrkdwn:
+		return r.renderSlackMrkdwn(ctx, markdown)
+	case MarkdownFormatNoop:
+		return markdown, nil
+	default:
+		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "unknown output format: %v", outputFormat)
+	}
+}
--- a/pkg/templating/markdownrenderer/noop_test.go
+++ b/pkg/templating/markdownrenderer/noop_test.go
@@ -0,0 +1,17 @@
+package markdownrenderer
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRenderNoop(t *testing.T) {
+	renderer := newTestRenderer()
+
+	output, err := renderer.Render(context.Background(), testMarkdown, MarkdownFormatNoop)
+	require.NoError(t, err)
+	assert.Equal(t, testMarkdown, output)
+}
--- a/pkg/templating/markdownrenderer/slack.go
+++ b/pkg/templating/markdownrenderer/slack.go
@@ -0,0 +1,24 @@
+package markdownrenderer
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+func (r *markdownRenderer) renderSlackBlockKit(_ context.Context, markdown string) (string, error) {
+	var buf bytes.Buffer
+	if err := newSlackBlockKitRenderer().Convert([]byte(markdown), &buf); err != nil {
+		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to convert markdown to Slack Block Kit")
+	}
+	return buf.String(), nil
+}
+
+func (r *markdownRenderer) renderSlackMrkdwn(_ context.Context, markdown string) (string, error) {
+	var buf bytes.Buffer
+	if err := newSlackMrkdwnRenderer().Convert([]byte(markdown), &buf); err != nil {
+		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to convert markdown to Slack Mrkdwn")
+	}
+	return buf.String(), nil
+}
--- a/pkg/templating/markdownrenderer/slack_test.go
+++ b/pkg/templating/markdownrenderer/slack_test.go
@@ -0,0 +1,152 @@
+package markdownrenderer
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"testing"
+)
+
+func jsonEqual(a, b string) bool {
+	var va, vb any
+	if err := json.Unmarshal([]byte(a), &va); err != nil {
+		return false
+	}
+	if err := json.Unmarshal([]byte(b), &vb); err != nil {
+		return false
+	}
+	ja, _ := json.Marshal(va)
+	jb, _ := json.Marshal(vb)
+	return string(ja) == string(jb)
+}
+
+func prettyJSON(s string) string {
+	var v any
+	if err := json.Unmarshal([]byte(s), &v); err != nil {
+		return s
+	}
+	b, _ := json.MarshalIndent(v, "", "  ")
+	return string(b)
+}
+
+func TestRenderSlackBlockKit(t *testing.T) {
+	renderer := NewMarkdownRenderer(slog.Default())
+
+	tests := []struct {
+		name     string
+		markdown string
+		expected string
+	}{
+		{
+			name:     "simple paragraph",
+			markdown: "Hello world",
+			expected: `[
+				{
+					"type": "section",
+					"text": { "type": "mrkdwn", "text": "Hello world" }
+				}
+			]`,
+		},
+		{
+			name: "alert-themed with heading, list, and code block",
+			markdown: `# Alert Triggered
+
+- Service: **checkout-api**
+- Status: _critical_
+
+` + "```" + `
+error: connection timeout after 30s
+` + "```",
+			expected: `[
+				{
+					"type": "section",
+					"text": { "type": "mrkdwn", "text": "*Alert Triggered*" }
+				},
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [
+									{ "type": "text", "text": "Service: " },
+									{ "type": "text", "text": "checkout-api", "style": { "bold": true } }
+								]},
+								{ "type": "rich_text_section", "elements": [
+									{ "type": "text", "text": "Status: " },
+									{ "type": "text", "text": "critical", "style": { "italic": true } }
+								]}
+							]
+						}
+					]
+				},
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_preformatted",
+							"border": 0,
+							"elements": [
+								{ "type": "text", "text": "error: connection timeout after 30s" }
+							]
+						}
+					]
+				}
+			]`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := renderer.Render(context.Background(), tt.markdown, MarkdownFormatSlackBlockKit)
+			if err != nil {
+				t.Fatalf("Render error: %v", err)
+			}
+
+			// Verify output is valid JSON
+			if !json.Valid([]byte(got)) {
+				t.Fatalf("output is not valid JSON:\n%s", got)
+			}
+
+			if !jsonEqual(got, tt.expected) {
+				t.Errorf("JSON mismatch\n\nMarkdown:\n%s\n\nExpected:\n%s\n\nGot:\n%s",
+					tt.markdown, prettyJSON(tt.expected), prettyJSON(got))
+			}
+		})
+	}
+}
+
+func TestRenderSlackMrkdwn(t *testing.T) {
+	renderer := NewMarkdownRenderer(slog.Default())
+
+	markdown := `# Alert Triggered
+
+- Service: **checkout-api**
+- Status: _critical_
+- Dashboard: [View Dashboard](https://example.com/dashboard)
+
+| Metric | Value | Threshold |
+| --- | --- | --- |
+| Latency | 250ms | 100ms |
+| Error Rate | 5.2% | 1% |
+
+` + "```" + `
+error: connection timeout after 30s
+` + "```"
+
+	expected := "*Alert Triggered*\n\n" +
+		"• Service: *checkout-api*\n" +
+		"• Status: _critical_\n" +
+		"• Dashboard: <https://example.com/dashboard|View Dashboard>\n\n" +
+		"```\nMetric     | Value | Threshold\n-----------|-------|----------\nLatency    | 250ms | 100ms    \nError Rate | 5.2%  | 1%       \n```\n\n" +
+		"```\nerror: connection timeout after 30s\n```\n\n"
+
+	got, err := renderer.Render(context.Background(), markdown, MarkdownFormatSlackMrkdwn)
+	if err != nil {
+		t.Fatalf("Render error: %v", err)
+	}
+
+	if got != expected {
+		t.Errorf("mrkdwn mismatch\n\nExpected:\n%q\n\nGot:\n%q", expected, got)
+	}
+}
--- a/pkg/templating/slackblockkitrenderer/extender.go
+++ b/pkg/templating/slackblockkitrenderer/extender.go
@@ -0,0 +1,23 @@
+package slackblockkitrenderer
+
+import (
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/extension"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/util"
+)
+
+type blockKitV2 struct{}
+
+// BlockKitV2 is a goldmark.Extender that configures the Slack Block Kit v2 renderer.
+var BlockKitV2 = &blockKitV2{}
+
+// Extend implements goldmark.Extender.
+func (e *blockKitV2) Extend(m goldmark.Markdown) {
+	extension.Table.Extend(m)
+	extension.Strikethrough.Extend(m)
+	extension.TaskList.Extend(m)
+	m.Renderer().AddOptions(
+		renderer.WithNodeRenderers(util.Prioritized(NewRenderer(), 1)),
+	)
+}
--- a/pkg/templating/slackblockkitrenderer/renderer_test.go
+++ b/pkg/templating/slackblockkitrenderer/renderer_test.go
@@ -0,0 +1,542 @@
+package slackblockkitrenderer
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/yuin/goldmark"
+)
+
+func jsonEqual(a, b string) bool {
+	var va, vb interface{}
+	if err := json.Unmarshal([]byte(a), &va); err != nil {
+		return false
+	}
+	if err := json.Unmarshal([]byte(b), &vb); err != nil {
+		return false
+	}
+	ja, _ := json.Marshal(va)
+	jb, _ := json.Marshal(vb)
+	return string(ja) == string(jb)
+}
+
+func prettyJSON(s string) string {
+	var v interface{}
+	if err := json.Unmarshal([]byte(s), &v); err != nil {
+		return s
+	}
+	b, _ := json.MarshalIndent(v, "", "  ")
+	return string(b)
+}
+
+func TestRenderer(t *testing.T) {
+	tests := []struct {
+		name     string
+		markdown string
+		expected string
+	}{
+		{
+			name:     "empty input",
+			markdown: "",
+			expected: `[]`,
+		},
+		{
+			name:     "simple paragraph",
+			markdown: "Hello world",
+			expected: `[
+				{
+					"type": "section",
+					"text": { "type": "mrkdwn", "text": "Hello world" }
+				}
+			]`,
+		},
+		{
+			name:     "heading",
+			markdown: "# My Heading",
+			expected: `[
+				{
+					"type": "section",
+					"text": { "type": "mrkdwn", "text": "*My Heading*" }
+				}
+			]`,
+		},
+		{
+			name:     "multiple paragraphs",
+			markdown: "First paragraph\n\nSecond paragraph",
+			expected: `[
+				{
+					"type": "section",
+					"text": { "type": "mrkdwn", "text": "First paragraph\nSecond paragraph" }
+				}
+			]`,
+		},
+		{
+			name:     "todo list ",
+			markdown: "- [ ] item 1\n- [x] item 2",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+					{ 
+						"border": 0, 
+						"elements": [ 
+							{ "elements": [ { "text": "[ ] ", "type": "text" }, { "text": "item 1", "type": "text" } ], "type": "rich_text_section" }, 
+							{ "elements": [ { "text": "[x] ", "type": "text" }, { "text": "item 2", "type": "text" } ], "type": "rich_text_section" } 
+						],
+						"indent": 0, 
+						"style": "bullet", 
+						"type": "rich_text_list" 
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "thematic break between paragraphs",
+			markdown: "Before\n\n---\n\nAfter",
+			expected: `[
+				{ "type": "section", "text": { "type": "mrkdwn", "text": "Before" } },
+				{ "type": "divider" },
+				{ "type": "section", "text": { "type": "mrkdwn", "text": "After" } }
+			]`,
+		},
+		{
+			name:     "fenced code block with language",
+			markdown: "```go\nfmt.Println(\"hello\")\n```",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_preformatted",
+							"border": 0,
+							"language": "go",
+							"elements": [
+								{ "type": "text", "text": "fmt.Println(\"hello\")" }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "indented code block",
+			markdown: "    code line 1\n    code line 2",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_preformatted",
+							"border": 0,
+							"elements": [
+								{ "type": "text", "text": "code line 1\ncode line 2" }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "empty fenced code block",
+			markdown: "```\n```",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_preformatted",
+							"border": 0,
+							"elements": [
+								{ "type": "text", "text": " " }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "simple bullet list",
+			markdown: "- item 1\n- item 2\n- item 3",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 1" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 2" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 3" }] }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "simple ordered list",
+			markdown: "1. first\n2. second\n3. third",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "first" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "second" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "third" }] }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "nested bullet list (2 levels)",
+			markdown: "- item 1\n- item 2\n  - sub a\n  - sub b\n- item 3",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 1" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 2" }] }
+							]
+						},
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 1, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sub a" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sub b" }] }
+							]
+						},
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 3" }] }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "nested ordered list with offset",
+			markdown: "1. first\n   1. nested-a\n   2. nested-b\n2. second\n3. third",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "first" }] }
+							]
+						},
+						{
+							"type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "nested-a" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "nested-b" }] }
+							]
+						},
+						{
+							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "second" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "third" }] }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "mixed ordered/bullet nesting",
+			markdown: "1. ordered\n   - bullet child\n2. ordered again",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "ordered" }] }
+							]
+						},
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 1, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "bullet child" }] }
+							]
+						},
+						{
+							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "ordered again" }] }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "list items with bold/italic/link/code",
+			markdown: "- **bold item**\n- _italic item_\n- [link](http://example.com)\n- `code item`",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "bold item", "style": { "bold": true } }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "italic item", "style": { "italic": true } }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "link", "url": "http://example.com", "text": "link" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "code item", "style": { "code": true } }] }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "table with header and body",
+			markdown: "| Name | Age |\n|------|-----|\n| Alice | 30 |",
+			expected: `[
+				{
+					"type": "table",
+					"rows": [
+						[
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Name", "style": { "bold": true } }] }
+							]},
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Age", "style": { "bold": true } }] }
+							]}
+						],
+						[
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Alice" }] }
+							]},
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "30" }] }
+							]}
+						]
+					]
+				}
+			]`,
+		},
+		{
+			name:     "blockquote",
+			markdown: "> quoted text",
+			expected: `[
+				{
+					"type": "section",
+					"text": { "type": "mrkdwn", "text": "> quoted text" }
+				}
+			]`,
+		},
+		{
+			name:     "blockquote with nested list",
+			markdown: "> item 1\n> > item 2\n> > item 3",
+			expected: `[
+				{
+					"text": {
+					"text": "> item 1\n> > item 2\n> > item 3",
+					"type": "mrkdwn"
+					},
+					"type": "section"
+				}
+			]`,
+		},
+		{
+			name:     "inline formatting in paragraph",
+			markdown: "This is **bold** and _italic_ and ~strike~ and `code`",
+			expected: `[
+				{
+					"type": "section",
+					"text": { "type": "mrkdwn", "text": "This is *bold* and _italic_ and ~strike~ and ` + "`code`" + `" }
+				}
+			]`,
+		},
+		{
+			name:     "link in paragraph",
+			markdown: "Visit [Google](http://google.com)",
+			expected: `[
+				{
+					"type": "section",
+					"text": { "type": "mrkdwn", "text": "Visit <http://google.com|Google>" }
+				}
+			]`,
+		},
+		{
+			name:     "image is skipped",
+			markdown: "![alt](http://example.com/image.png)",
+			// For image skip the block and return empty array
+			expected: `[]`,
+		},
+		{
+			name:     "paragraph then list then paragraph",
+			markdown: "Before\n\n- item\n\nAfter",
+			expected: `[
+				{ "type": "section", "text": { "type": "mrkdwn", "text": "Before" } },
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item" }] }
+							]
+						}
+					]
+				},
+				{ "type": "section", "text": { "type": "mrkdwn", "text": "After" } }
+			]`,
+		},
+		{
+			name:     "ordered list with start > 1",
+			markdown: "5. fifth\n6. sixth",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 4,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "fifth" }] },
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sixth" }] }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "deeply nested ordered list (3 levels) with offsets",
+			markdown: "1. Some things\n\t1. are best left\n2. to the fate\n\t1. of the world\n\t\t1. and then\n\t\t2. this is how\n3. it turns out to be",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
+						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Some things" }] }] },
+
+						{ "type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
+						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "are best left" }] }] },
+
+						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
+						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "to the fate" }] }] },
+
+						{ "type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
+						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "of the world" }] }] },
+
+						{ "type": "rich_text_list", "style": "ordered", "indent": 2, "border": 0,
+						  "elements": [
+						    { "type": "rich_text_section", "elements": [{ "type": "text", "text": "and then" }] },
+						    { "type": "rich_text_section", "elements": [{ "type": "text", "text": "this is how" }] }
+						  ]
+						},
+
+						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 2,
+						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "it turns out to be" }] }] }
+					]
+				}
+			]`,
+		},
+		{
+			name:     "link with bold label in list item",
+			markdown: "- [**docs**](http://example.com)",
+			expected: `[
+				{
+					"type": "rich_text",
+					"elements": [
+						{
+							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
+							"elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "link", "url": "http://example.com", "text": "docs" }] }
+							]
+						}
+					]
+				}
+			]`,
+		},
+		{
+			name:     "table with empty cell",
+			markdown: "| A | B |\n|---|---|\n| 1 | |",
+			expected: `[
+				{
+					"type": "table",
+					"rows": [
+						[
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "A", "style": { "bold": true } }] }
+							]},
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "B", "style": { "bold": true } }] }
+							]}
+						],
+						[
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "1" }] }
+							]},
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": " " }] }
+							]}
+						]
+					]
+				}
+			]`,
+		},
+		{
+			name:     "table with missing column in row",
+			markdown: "| A | B |\n|---|---|\n| 1 |",
+			expected: `[
+				{
+					"type": "table",
+					"rows": [
+						[
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "A", "style": { "bold": true } }] }
+							]},
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "B", "style": { "bold": true } }] }
+							]}
+						],
+						[
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "1" }] }
+							]},
+							{ "type": "rich_text", "elements": [
+								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": " " }] }
+							]}
+						]
+					]
+				}
+			]`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			md := goldmark.New(
+				goldmark.WithExtensions(BlockKitV2),
+			)
+			var buf bytes.Buffer
+			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {
+				t.Fatalf("convert error: %v", err)
+			}
+			got := buf.String()
+			if !jsonEqual(got, tt.expected) {
+				t.Errorf("JSON mismatch\n\nMarkdown:\n%s\n\nExpected:\n%s\n\nGot:\n%s",
+					tt.markdown, prettyJSON(tt.expected), prettyJSON(got))
+			}
+		})
+	}
+}
--- a/pkg/templating/slackblockkitrenderer/slackblockkitrenderer.go
+++ b/pkg/templating/slackblockkitrenderer/slackblockkitrenderer.go
@@ -0,0 +1,737 @@
+package slackblockkitrenderer
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+
+	"github.com/yuin/goldmark/ast"
+	extensionast "github.com/yuin/goldmark/extension/ast"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/util"
+)
+
+// listFrame tracks state for a single level of list nesting.
+type listFrame struct {
+	style     string // "bullet" or "ordered"
+	indent    int
+	itemCount int
+}
+
+// listContext holds all state while processing a list tree.
+type listContext struct {
+	result             []RichTextList
+	stack              []listFrame
+	current            *RichTextList
+	currentItemInlines []interface{}
+}
+
+// tableContext holds state while processing a table.
+type tableContext struct {
+	rows               [][]TableCell
+	currentRow         []TableCell
+	currentCellInlines []interface{}
+	isHeader           bool
+}
+
+// Renderer converts Markdown AST to Slack Block Kit JSON.
+type Renderer struct {
+	blocks []interface{}
+	mrkdwn strings.Builder
+	// holds active styles for the current rich text element
+	styleStack []RichTextStyle
+	// holds the current list context while processing a list tree.
+	listCtx *listContext
+	// holds the current table context while processing a table.
+	tableCtx *tableContext
+	// stores the current blockquote depth while processing a blockquote.
+	// so blockquote with nested list can be rendered correctly.
+	blockquoteDepth int
+}
+
+// NewRenderer returns a new block kit renderer.
+func NewRenderer() renderer.NodeRenderer {
+	return &Renderer{}
+}
+
+// RegisterFuncs registers node rendering functions.
+func (r *Renderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	// Blocks
+	reg.Register(ast.KindDocument, r.renderDocument)
+	reg.Register(ast.KindHeading, r.renderHeading)
+	reg.Register(ast.KindParagraph, r.renderParagraph)
+	reg.Register(ast.KindThematicBreak, r.renderThematicBreak)
+	reg.Register(ast.KindCodeBlock, r.renderCodeBlock)
+	reg.Register(ast.KindFencedCodeBlock, r.renderFencedCodeBlock)
+	reg.Register(ast.KindBlockquote, r.renderBlockquote)
+	reg.Register(ast.KindList, r.renderList)
+	reg.Register(ast.KindListItem, r.renderListItem)
+	reg.Register(ast.KindImage, r.renderImage)
+
+	// Inlines
+	reg.Register(ast.KindText, r.renderText)
+	reg.Register(ast.KindEmphasis, r.renderEmphasis)
+	reg.Register(ast.KindCodeSpan, r.renderCodeSpan)
+	reg.Register(ast.KindLink, r.renderLink)
+
+	// Extensions
+	reg.Register(extensionast.KindStrikethrough, r.renderStrikethrough)
+	reg.Register(extensionast.KindTable, r.renderTable)
+	reg.Register(extensionast.KindTableHeader, r.renderTableHeader)
+	reg.Register(extensionast.KindTableRow, r.renderTableRow)
+	reg.Register(extensionast.KindTableCell, r.renderTableCell)
+	reg.Register(extensionast.KindTaskCheckBox, r.renderTaskCheckBox)
+}
+
+// inRichTextMode returns true when we're inside a list or table context
+// in slack blockkit list and table items are rendered as rich_text elements
+// if more cases are found in future those needs to be added here.
+func (r *Renderer) inRichTextMode() bool {
+	return r.listCtx != nil || r.tableCtx != nil
+}
+
+// currentStyle merges the stored style stack into RichTextStyle
+// which can be applied on rich text elements.
+func (r *Renderer) currentStyle() *RichTextStyle {
+	s := RichTextStyle{}
+	for _, f := range r.styleStack {
+		s.Bold = s.Bold || f.Bold
+		s.Italic = s.Italic || f.Italic
+		s.Strike = s.Strike || f.Strike
+		s.Code = s.Code || f.Code
+	}
+	if s == (RichTextStyle{}) {
+		return nil
+	}
+	return &s
+}
+
+// flushMrkdwn collects markdown text and adds it as a SectionBlock with mrkdwn text
+// whenever starting a new block we flush markdown to render it as a separate block.
+func (r *Renderer) flushMrkdwn() {
+	text := strings.TrimSpace(r.mrkdwn.String())
+	if text != "" {
+		r.blocks = append(r.blocks, SectionBlock{
+			Type: "section",
+			Text: &TextObject{
+				Type: "mrkdwn",
+				Text: text,
+			},
+		})
+	}
+	r.mrkdwn.Reset()
+}
+
+// addInline adds an inline element to the appropriate context.
+func (r *Renderer) addInline(el interface{}) {
+	if r.listCtx != nil {
+		r.listCtx.currentItemInlines = append(r.listCtx.currentItemInlines, el)
+	} else if r.tableCtx != nil {
+		r.tableCtx.currentCellInlines = append(r.tableCtx.currentCellInlines, el)
+	}
+}
+
+// --- Document ---
+
+func (r *Renderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.blocks = nil
+		r.mrkdwn.Reset()
+		r.styleStack = nil
+		r.listCtx = nil
+		r.tableCtx = nil
+		r.blockquoteDepth = 0
+	} else {
+		// on exiting the document node write the json for the collected blocks.
+		r.flushMrkdwn()
+		var data []byte
+		var err error
+		if len(r.blocks) > 0 {
+			data, err = json.Marshal(r.blocks)
+			if err != nil {
+				return ast.WalkStop, err
+			}
+		} else {
+			// if no blocks are collected, write an empty array.
+			data = []byte("[]")
+		}
+		_, err = w.Write(data)
+		if err != nil {
+			return ast.WalkStop, err
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- Heading ---
+
+func (r *Renderer) renderHeading(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.mrkdwn.WriteString("*")
+	} else {
+		r.mrkdwn.WriteString("*\n")
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- Paragraph ---
+
+func (r *Renderer) renderParagraph(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		if r.mrkdwn.Len() > 0 {
+			text := r.mrkdwn.String()
+			if !strings.HasSuffix(text, "\n") {
+				r.mrkdwn.WriteString("\n")
+			}
+		}
+		// handling of nested blockquotes
+		if r.blockquoteDepth > 0 {
+			r.mrkdwn.WriteString(strings.Repeat("> ", r.blockquoteDepth))
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- ThematicBreak ---
+
+func (r *Renderer) renderThematicBreak(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.flushMrkdwn()
+		r.blocks = append(r.blocks, DividerBlock{Type: "divider"})
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- CodeBlock (indented) ---
+
+func (r *Renderer) renderCodeBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	r.flushMrkdwn()
+
+	var buf bytes.Buffer
+	lines := node.Lines()
+	for i := 0; i < lines.Len(); i++ {
+		line := lines.At(i)
+		buf.Write(line.Value(source))
+	}
+
+	text := buf.String()
+	// Remove trailing newline
+	text = strings.TrimRight(text, "\n")
+	// Slack API rejects empty text in rich_text_preformatted elements
+	if text == "" {
+		text = " "
+	}
+
+	elements := []interface{}{
+		RichTextInline{Type: "text", Text: text},
+	}
+
+	r.blocks = append(r.blocks, RichTextBlock{
+		Type: "rich_text",
+		Elements: []interface{}{
+			RichTextPreformatted{
+				Type:     "rich_text_preformatted",
+				Elements: elements,
+				Border:   0,
+			},
+		},
+	})
+	return ast.WalkContinue, nil
+}
+
+// --- FencedCodeBlock ---
+
+func (r *Renderer) renderFencedCodeBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	r.flushMrkdwn()
+
+	n := node.(*ast.FencedCodeBlock)
+	var buf bytes.Buffer
+	lines := node.Lines()
+	for i := 0; i < lines.Len(); i++ {
+		line := lines.At(i)
+		buf.Write(line.Value(source))
+	}
+
+	text := buf.String()
+	text = strings.TrimRight(text, "\n")
+	// Slack API rejects empty text in rich_text_preformatted elements
+	if text == "" {
+		text = " "
+	}
+
+	elements := []interface{}{
+		RichTextInline{Type: "text", Text: text},
+	}
+
+	// If language is specified, collect it.
+	var language string
+	lang := n.Language(source)
+	if len(lang) > 0 {
+		language = string(lang)
+	}
+	// Add the preformatted block to the blocks slice with the collected language.
+	r.blocks = append(r.blocks, RichTextBlock{
+		Type: "rich_text",
+		Elements: []interface{}{
+			RichTextPreformatted{
+				Type:     "rich_text_preformatted",
+				Elements: elements,
+				Border:   0,
+				Language: language,
+			},
+		},
+	})
+
+	return ast.WalkSkipChildren, nil
+}
+
+// --- Blockquote ---
+
+func (r *Renderer) renderBlockquote(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.blockquoteDepth++
+	} else {
+		r.blockquoteDepth--
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- List ---
+
+func (r *Renderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	list := node.(*ast.List)
+
+	if entering {
+		style := "bullet"
+		if list.IsOrdered() {
+			style = "ordered"
+		}
+
+		if r.listCtx == nil {
+			// Top-level list: flush mrkdwn and create context
+			r.flushMrkdwn()
+			r.listCtx = &listContext{}
+		} else {
+			// Nested list: check if we already have some collected list items that needs to be flushed.
+			// in slack blockkit, list items with different levels of indentation are added as different rich_text_list blocks.
+			if len(r.listCtx.currentItemInlines) > 0 {
+				sec := RichTextBlock{
+					Type:     "rich_text_section",
+					Elements: r.listCtx.currentItemInlines,
+				}
+				if r.listCtx.current != nil {
+					r.listCtx.current.Elements = append(r.listCtx.current.Elements, sec)
+				}
+				r.listCtx.currentItemInlines = nil
+				// Increment parent's itemCount
+				if len(r.listCtx.stack) > 0 {
+					r.listCtx.stack[len(r.listCtx.stack)-1].itemCount++
+				}
+			}
+			// Finalize current list to result only if items were collected
+			if r.listCtx.current != nil && len(r.listCtx.current.Elements) > 0 {
+				r.listCtx.result = append(r.listCtx.result, *r.listCtx.current)
+			}
+		}
+
+		// the stack accumulated till this level derives hte indentation
+		// the stack get's collected as we go in more nested levels of list
+		// and as we get our of the nesting we remove the items from the slack
+		indent := len(r.listCtx.stack)
+		r.listCtx.stack = append(r.listCtx.stack, listFrame{
+			style:     style,
+			indent:    indent,
+			itemCount: 0,
+		})
+
+		newList := &RichTextList{
+			Type:     "rich_text_list",
+			Style:    style,
+			Indent:   indent,
+			Border:   0,
+			Elements: []interface{}{},
+		}
+
+		// Handle ordered list with start > 1
+		if list.IsOrdered() && list.Start > 1 {
+			newList.Offset = list.Start - 1
+		}
+
+		r.listCtx.current = newList
+
+	} else {
+		// Leaving list: finalize current list
+		if r.listCtx.current != nil && len(r.listCtx.current.Elements) > 0 {
+			r.listCtx.result = append(r.listCtx.result, *r.listCtx.current)
+		}
+
+		// Pop stack to so upcoming indentations can be handled correctly.
+		r.listCtx.stack = r.listCtx.stack[:len(r.listCtx.stack)-1]
+
+		if len(r.listCtx.stack) > 0 {
+			// Resume parent: start a new list segment at parent indent/style
+			parent := &r.listCtx.stack[len(r.listCtx.stack)-1]
+			newList := &RichTextList{
+				Type:     "rich_text_list",
+				Style:    parent.style,
+				Indent:   parent.indent,
+				Border:   0,
+				Elements: []interface{}{},
+			}
+			// Set offset for ordered parent continuation
+			if parent.style == "ordered" && parent.itemCount > 0 {
+				newList.Offset = parent.itemCount
+			}
+			r.listCtx.current = newList
+		} else {
+			// Top-level list is done since all stack are popped: build RichTextBlock if non-empty
+			if len(r.listCtx.result) > 0 {
+				elements := make([]interface{}, len(r.listCtx.result))
+				for i, l := range r.listCtx.result {
+					elements[i] = l
+				}
+				r.blocks = append(r.blocks, RichTextBlock{
+					Type:     "rich_text",
+					Elements: elements,
+				})
+			}
+			r.listCtx = nil
+		}
+	}
+
+	return ast.WalkContinue, nil
+}
+
+// --- ListItem ---
+
+func (r *Renderer) renderListItem(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.listCtx.currentItemInlines = nil
+	} else {
+		// Only add if there are inlines (might be empty after nested list consumed them)
+		if len(r.listCtx.currentItemInlines) > 0 {
+			sec := RichTextBlock{
+				Type:     "rich_text_section",
+				Elements: r.listCtx.currentItemInlines,
+			}
+			if r.listCtx.current != nil {
+				r.listCtx.current.Elements = append(r.listCtx.current.Elements, sec)
+			}
+			r.listCtx.currentItemInlines = nil
+			// Increment parent frame's itemCount
+			if len(r.listCtx.stack) > 0 {
+				r.listCtx.stack[len(r.listCtx.stack)-1].itemCount++
+			}
+		}
+	}
+
+	return ast.WalkContinue, nil
+}
+
+// --- Table ---
+// when table is encountered, we flush the markdown and create a table context.
+// when header row is encountered, we set the isHeader flag to true
+// when each row ends in renderTableRow we add that row to rows array of table context.
+// when table cell is encountered, we apply header related styles to the collected inline items,
+// all inline items are parsed as separate AST items like list item, links, text, etc. are collected
+// using the addInline function and wrapped in a rich_text_section block.
+
+func (r *Renderer) renderTable(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.flushMrkdwn()
+		r.tableCtx = &tableContext{}
+	} else {
+		// Pad short rows to match header column count for valid Block Kit payload
+		// without this slack blockkit attachment is invalid and the API fails
+		rows := r.tableCtx.rows
+		if len(rows) > 0 {
+			maxCols := len(rows[0])
+			for i, row := range rows {
+				for len(row) < maxCols {
+					emptySec := RichTextBlock{
+						Type:     "rich_text_section",
+						Elements: []interface{}{RichTextInline{Type: "text", Text: " "}},
+					}
+					row = append(row, TableCell{
+						Type:     "rich_text",
+						Elements: []interface{}{emptySec},
+					})
+				}
+				rows[i] = row
+			}
+		}
+		r.blocks = append(r.blocks, TableBlock{
+			Type: "table",
+			Rows: rows,
+		})
+		r.tableCtx = nil
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderTableHeader(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.tableCtx.isHeader = true
+		r.tableCtx.currentRow = nil
+	} else {
+		r.tableCtx.rows = append(r.tableCtx.rows, r.tableCtx.currentRow)
+		r.tableCtx.currentRow = nil
+		r.tableCtx.isHeader = false
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderTableRow(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.tableCtx.currentRow = nil
+	} else {
+		r.tableCtx.rows = append(r.tableCtx.rows, r.tableCtx.currentRow)
+		r.tableCtx.currentRow = nil
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderTableCell(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.tableCtx.currentCellInlines = nil
+	} else {
+		// If header, make text bold for the collected inline items.
+		if r.tableCtx.isHeader {
+			for i, el := range r.tableCtx.currentCellInlines {
+				if inline, ok := el.(RichTextInline); ok {
+					if inline.Style == nil {
+						inline.Style = &RichTextStyle{Bold: true}
+					} else {
+						inline.Style.Bold = true
+					}
+					r.tableCtx.currentCellInlines[i] = inline
+				}
+			}
+		}
+		// Ensure cell has at least one element for valid Block Kit payload
+		if len(r.tableCtx.currentCellInlines) == 0 {
+			r.tableCtx.currentCellInlines = []interface{}{
+				RichTextInline{Type: "text", Text: " "},
+			}
+		}
+		// All inline items that are collected for a table cell are wrapped in a rich_text_section block.
+		sec := RichTextBlock{
+			Type:     "rich_text_section",
+			Elements: r.tableCtx.currentCellInlines,
+		}
+		// The rich_text_section block is wrapped in a rich_text block.
+		cell := TableCell{
+			Type:     "rich_text",
+			Elements: []interface{}{sec},
+		}
+		r.tableCtx.currentRow = append(r.tableCtx.currentRow, cell)
+		r.tableCtx.currentCellInlines = nil
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- TaskCheckBox ---
+
+func (r *Renderer) renderTaskCheckBox(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	n := node.(*extensionast.TaskCheckBox)
+	text := "[ ] "
+	if n.IsChecked {
+		text = "[x] "
+	}
+	if r.inRichTextMode() {
+		r.addInline(RichTextInline{Type: "text", Text: text})
+	} else {
+		r.mrkdwn.WriteString(text)
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- Inline: Text ---
+
+func (r *Renderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	n := node.(*ast.Text)
+	value := string(n.Segment.Value(source))
+
+	if r.inRichTextMode() {
+		r.addInline(RichTextInline{
+			Type:  "text",
+			Text:  value,
+			Style: r.currentStyle(),
+		})
+		if n.HardLineBreak() || n.SoftLineBreak() {
+			r.addInline(RichTextInline{Type: "text", Text: "\n"})
+		}
+	} else {
+		r.mrkdwn.WriteString(value)
+		if n.HardLineBreak() || n.SoftLineBreak() {
+			r.mrkdwn.WriteString("\n")
+			if r.blockquoteDepth > 0 {
+				r.mrkdwn.WriteString(strings.Repeat("> ", r.blockquoteDepth))
+			}
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- Inline: Emphasis ---
+
+func (r *Renderer) renderEmphasis(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	n := node.(*ast.Emphasis)
+	if r.inRichTextMode() {
+		if entering {
+			s := RichTextStyle{}
+			if n.Level == 1 {
+				s.Italic = true
+			} else {
+				s.Bold = true
+			}
+			r.styleStack = append(r.styleStack, s)
+		} else {
+			// the collected style gets used by the rich text element using currentStyle()
+			// so we remove this style from the stack.
+			if len(r.styleStack) > 0 {
+				r.styleStack = r.styleStack[:len(r.styleStack)-1]
+			}
+		}
+	} else {
+		if n.Level == 1 {
+			r.mrkdwn.WriteString("_")
+		} else {
+			r.mrkdwn.WriteString("*")
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- Inline: Strikethrough ---
+
+func (r *Renderer) renderStrikethrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if r.inRichTextMode() {
+		if entering {
+			r.styleStack = append(r.styleStack, RichTextStyle{Strike: true})
+		} else {
+			// the collected style gets used by the rich text element using currentStyle()
+			// so we remove this style from the stack.
+			if len(r.styleStack) > 0 {
+				r.styleStack = r.styleStack[:len(r.styleStack)-1]
+			}
+		}
+	} else {
+		r.mrkdwn.WriteString("~")
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- Inline: CodeSpan ---
+
+func (r *Renderer) renderCodeSpan(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	if r.inRichTextMode() {
+		// Collect all child text
+		var buf bytes.Buffer
+		for c := node.FirstChild(); c != nil; c = c.NextSibling() {
+			if t, ok := c.(*ast.Text); ok {
+				v := t.Segment.Value(source)
+				if bytes.HasSuffix(v, []byte("\n")) {
+					buf.Write(v[:len(v)-1])
+					buf.WriteByte(' ')
+				} else {
+					buf.Write(v)
+				}
+			} else if s, ok := c.(*ast.String); ok {
+				buf.Write(s.Value)
+			}
+		}
+		style := r.currentStyle()
+		if style == nil {
+			style = &RichTextStyle{Code: true}
+		} else {
+			style.Code = true
+		}
+		r.addInline(RichTextInline{
+			Type:  "text",
+			Text:  buf.String(),
+			Style: style,
+		})
+		return ast.WalkSkipChildren, nil
+	}
+	// mrkdwn mode
+	r.mrkdwn.WriteByte('`')
+	for c := node.FirstChild(); c != nil; c = c.NextSibling() {
+		if t, ok := c.(*ast.Text); ok {
+			v := t.Segment.Value(source)
+			if bytes.HasSuffix(v, []byte("\n")) {
+				r.mrkdwn.Write(v[:len(v)-1])
+				r.mrkdwn.WriteByte(' ')
+			} else {
+				r.mrkdwn.Write(v)
+			}
+		} else if s, ok := c.(*ast.String); ok {
+			r.mrkdwn.Write(s.Value)
+		}
+	}
+	r.mrkdwn.WriteByte('`')
+	return ast.WalkSkipChildren, nil
+}
+
+// --- Inline: Link ---
+
+func (r *Renderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	n := node.(*ast.Link)
+	if r.inRichTextMode() {
+		if entering {
+			// Walk the entire subtree to collect text from all descendants,
+			// including nested inline nodes like emphasis, strong, code spans, etc.
+			var buf bytes.Buffer
+			_ = ast.Walk(node, func(child ast.Node, entering bool) (ast.WalkStatus, error) {
+				if !entering || child == node {
+					return ast.WalkContinue, nil
+				}
+				if t, ok := child.(*ast.Text); ok {
+					buf.Write(t.Segment.Value(source))
+				} else if s, ok := child.(*ast.String); ok {
+					buf.Write(s.Value)
+				}
+				return ast.WalkContinue, nil
+			})
+			// Once we've collected the text for the link (given it was present)
+			// let's add the link to the rich text block.
+			r.addInline(RichTextLink{
+				Type:  "link",
+				URL:   string(n.Destination),
+				Text:  buf.String(),
+				Style: r.currentStyle(),
+			})
+			return ast.WalkSkipChildren, nil
+		}
+	} else {
+		if entering {
+			r.mrkdwn.WriteString("<")
+			r.mrkdwn.Write(n.Destination)
+			r.mrkdwn.WriteString("|")
+		} else {
+			r.mrkdwn.WriteString(">")
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+// --- Image (skip) ---
+
+func (r *Renderer) renderImage(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	return ast.WalkSkipChildren, nil
+}
--- a/pkg/templating/slackblockkitrenderer/types.go
+++ b/pkg/templating/slackblockkitrenderer/types.go
@@ -0,0 +1,80 @@
+package slackblockkitrenderer
+
+// SectionBlock represents a Slack section block with mrkdwn text.
+type SectionBlock struct {
+	Type string      `json:"type"`
+	Text *TextObject `json:"text"`
+}
+
+// DividerBlock represents a Slack divider block.
+type DividerBlock struct {
+	Type string `json:"type"`
+}
+
+// RichTextBlock is a container for rich text elements (lists, code blocks, table and cell blocks).
+type RichTextBlock struct {
+	Type     string        `json:"type"`
+	Elements []interface{} `json:"elements"`
+}
+
+// TableBlock represents a Slack table rendered as a rich_text block with preformatted text.
+type TableBlock struct {
+	Type string        `json:"type"`
+	Rows [][]TableCell `json:"rows"`
+}
+
+// TableCell is a cell in a table block.
+type TableCell struct {
+	Type     string        `json:"type"`
+	Elements []interface{} `json:"elements"`
+}
+
+// TextObject is the text field inside a SectionBlock.
+type TextObject struct {
+	Type string `json:"type"`
+	Text string `json:"text"`
+}
+
+// RichTextList represents an ordered or unordered list.
+type RichTextList struct {
+	Type     string        `json:"type"`
+	Style    string        `json:"style"`
+	Indent   int           `json:"indent"`
+	Border   int           `json:"border"`
+	Offset   int           `json:"offset,omitempty"`
+	Elements []interface{} `json:"elements"`
+}
+
+// RichTextPreformatted represents a code block.
+type RichTextPreformatted struct {
+	Type     string        `json:"type"`
+	Elements []interface{} `json:"elements"`
+	Border   int           `json:"border"`
+	Language string        `json:"language,omitempty"`
+}
+
+// RichTextInline represents inline text with optional styling
+// ex: text inside list, table cell
+type RichTextInline struct {
+	Type  string         `json:"type"`
+	Text  string         `json:"text"`
+	Style *RichTextStyle `json:"style,omitempty"`
+}
+
+// RichTextLink represents a link inside rich text
+// ex: link inside list, table cell
+type RichTextLink struct {
+	Type  string         `json:"type"`
+	URL   string         `json:"url"`
+	Text  string         `json:"text,omitempty"`
+	Style *RichTextStyle `json:"style,omitempty"`
+}
+
+// RichTextStyle holds boolean style flags for inline elements
+// these bools can toggle different styles for a rich text element at once.
+type RichTextStyle struct {
+	Bold   bool `json:"bold,omitempty"`
+	Italic bool `json:"italic,omitempty"`
+	Strike bool `json:"strike,omitempty"`
+	Code   bool `json:"code,omitempty"`
+}
--- a/pkg/templating/slackmrkdwnrenderer/extender.go
+++ b/pkg/templating/slackmrkdwnrenderer/extender.go
@@ -0,0 +1,22 @@
+package slackmrkdwnrenderer
+
+import (
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/extension"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/util"
+)
+
+type slackMrkdwn struct{}
+
+// SlackMrkdwn is a goldmark.Extender that configures the Slack mrkdwn renderer.
+var SlackMrkdwn = &slackMrkdwn{}
+
+// Extend implements goldmark.Extender.
+func (e *slackMrkdwn) Extend(m goldmark.Markdown) {
+	extension.Table.Extend(m)
+	extension.Strikethrough.Extend(m)
+	m.Renderer().AddOptions(
+		renderer.WithNodeRenderers(util.Prioritized(NewRenderer(), 1)),
+	)
+}
--- a/pkg/templating/slackmrkdwnrenderer/slack.go
+++ b/pkg/templating/slackmrkdwnrenderer/slack.go
@@ -0,0 +1,383 @@
+package slackmrkdwnrenderer
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/yuin/goldmark/ast"
+	extensionast "github.com/yuin/goldmark/extension/ast"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/util"
+)
+
+// Renderer renders nodes as Slack mrkdwn.
+type Renderer struct {
+	prefixes []string
+}
+
+// NewRenderer returns a new Renderer with given options.
+func NewRenderer() renderer.NodeRenderer {
+	return &Renderer{}
+}
+
+// RegisterFuncs implements NodeRenderer.RegisterFuncs.
+func (r *Renderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	// Blocks
+	reg.Register(ast.KindDocument, r.renderDocument)
+	reg.Register(ast.KindHeading, r.renderHeading)
+	reg.Register(ast.KindBlockquote, r.renderBlockquote)
+	reg.Register(ast.KindCodeBlock, r.renderCodeBlock)
+	reg.Register(ast.KindFencedCodeBlock, r.renderCodeBlock)
+	reg.Register(ast.KindList, r.renderList)
+	reg.Register(ast.KindListItem, r.renderListItem)
+	reg.Register(ast.KindParagraph, r.renderParagraph)
+	reg.Register(ast.KindTextBlock, r.renderTextBlock)
+	reg.Register(ast.KindRawHTML, r.renderRawHTML)
+	reg.Register(ast.KindThematicBreak, r.renderThematicBreak)
+
+	// Inlines
+	reg.Register(ast.KindAutoLink, r.renderAutoLink)
+	reg.Register(ast.KindCodeSpan, r.renderCodeSpan)
+	reg.Register(ast.KindEmphasis, r.renderEmphasis)
+	reg.Register(ast.KindImage, r.renderImage)
+	reg.Register(ast.KindLink, r.renderLink)
+	reg.Register(ast.KindText, r.renderText)
+
+	// Extensions
+	reg.Register(extensionast.KindStrikethrough, r.renderStrikethrough)
+	reg.Register(extensionast.KindTable, r.renderTable)
+}
+
+func (r *Renderer) writePrefix(w util.BufWriter) {
+	for _, p := range r.prefixes {
+		_, _ = w.WriteString(p)
+	}
+}
+
+// writeLineSeparator writes a newline followed by the current prefix.
+// Used for tight separations (e.g., between list items or text blocks).
+func (r *Renderer) writeLineSeparator(w util.BufWriter) {
+	_ = w.WriteByte('\n')
+	r.writePrefix(w)
+}
+
+// writeBlockSeparator writes a blank line separator between block-level elements,
+// respecting any active prefixes for proper nesting (e.g., inside blockquotes).
+func (r *Renderer) writeBlockSeparator(w util.BufWriter) {
+	r.writeLineSeparator(w)
+	r.writeLineSeparator(w)
+}
+
+// separateFromPrevious writes a block separator if the node has a previous sibling.
+func (r *Renderer) separateFromPrevious(w util.BufWriter, n ast.Node) {
+	if n.PreviousSibling() != nil {
+		r.writeBlockSeparator(w)
+	}
+}
+
+func (r *Renderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		_, _ = w.WriteString("\n\n")
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderHeading(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.separateFromPrevious(w, node)
+	}
+	_, _ = w.WriteString("*")
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderBlockquote(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.separateFromPrevious(w, n)
+		r.prefixes = append(r.prefixes, "> ")
+		_, _ = w.WriteString("> ")
+	} else {
+		r.prefixes = r.prefixes[:len(r.prefixes)-1]
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderCodeBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.separateFromPrevious(w, n)
+		// start code block and write code line by line
+		_, _ = w.WriteString("```\n")
+		l := n.Lines().Len()
+		for i := 0; i < l; i++ {
+			line := n.Lines().At(i)
+			v := line.Value(source)
+			_, _ = w.Write(v)
+		}
+	} else {
+		_, _ = w.WriteString("```")
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		if node.PreviousSibling() != nil {
+			r.writeLineSeparator(w)
+			// another line break if not a nested list item and starting another block
+			if node.Parent() == nil || node.Parent().Kind() != ast.KindListItem {
+				r.writeLineSeparator(w)
+			}
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderListItem(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		if n.PreviousSibling() != nil {
+			r.writeLineSeparator(w)
+		}
+		parent := n.Parent().(*ast.List)
+		// compute and write the prefix based on list type and index
+		var prefixStr string
+		if parent.IsOrdered() {
+			index := parent.Start
+			for c := parent.FirstChild(); c != nil && c != n; c = c.NextSibling() {
+				index++
+			}
+			prefixStr = fmt.Sprintf("%d. ", index)
+		} else {
+			prefixStr = "• "
+		}
+		_, _ = w.WriteString(prefixStr)
+		r.prefixes = append(r.prefixes, "\t") // add tab for nested list items
+	} else {
+		r.prefixes = r.prefixes[:len(r.prefixes)-1]
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderParagraph(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.separateFromPrevious(w, n)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderTextBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering && n.PreviousSibling() != nil {
+		r.writeLineSeparator(w)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderRawHTML(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		n := n.(*ast.RawHTML)
+		l := n.Segments.Len()
+		for i := 0; i < l; i++ {
+			segment := n.Segments.At(i)
+			_, _ = w.Write(segment.Value(source))
+		}
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderThematicBreak(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		r.separateFromPrevious(w, n)
+		_, _ = w.WriteString("---")
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderAutoLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	n := node.(*ast.AutoLink)
+	url := string(n.URL(source))
+	label := string(n.Label(source))
+
+	if n.AutoLinkType == ast.AutoLinkEmail && !strings.HasPrefix(strings.ToLower(url), "mailto:") {
+		url = "mailto:" + url
+	}
+
+	if url == label {
+		_, _ = fmt.Fprintf(w, "<%s>", url)
+	} else {
+		_, _ = fmt.Fprintf(w, "<%s|%s>", url, label)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderCodeSpan(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		_ = w.WriteByte('`')
+		for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+			segment := c.(*ast.Text).Segment
+			value := segment.Value(source)
+			if bytes.HasSuffix(value, []byte("\n")) { // replace newline with space
+				_, _ = w.Write(value[:len(value)-1])
+				_ = w.WriteByte(' ')
+			} else {
+				_, _ = w.Write(value)
+			}
+		}
+		return ast.WalkSkipChildren, nil
+	}
+	_ = w.WriteByte('`')
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderEmphasis(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	n := node.(*ast.Emphasis)
+	mark := "_"
+	if n.Level == 2 {
+		mark = "*"
+	}
+	_, _ = w.WriteString(mark)
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	n := node.(*ast.Link)
+	if entering {
+		_, _ = w.WriteString("<")
+		_, _ = w.Write(util.URLEscape(n.Destination, true))
+		_, _ = w.WriteString("|")
+	} else {
+		_, _ = w.WriteString(">")
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderImage(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	n := node.(*ast.Image)
+	_, _ = w.WriteString("<")
+	_, _ = w.Write(util.URLEscape(n.Destination, true))
+	_, _ = w.WriteString("|")
+
+	// Write the alt text directly
+	var altBuf bytes.Buffer
+	for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+		if textNode, ok := c.(*ast.Text); ok {
+			altBuf.Write(textNode.Segment.Value(source))
+		}
+	}
+	_, _ = w.Write(altBuf.Bytes())
+
+	_, _ = w.WriteString(">")
+	return ast.WalkSkipChildren, nil
+}
+
+func (r *Renderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+	n := node.(*ast.Text)
+	segment := n.Segment
+	value := segment.Value(source)
+	_, _ = w.Write(value)
+	if n.HardLineBreak() || n.SoftLineBreak() {
+		r.writeLineSeparator(w)
+	}
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderStrikethrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	_, _ = w.WriteString("~")
+	return ast.WalkContinue, nil
+}
+
+func (r *Renderer) renderTable(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkContinue, nil
+	}
+
+	r.separateFromPrevious(w, node)
+
+	// Collect cells and max widths
+	var rows [][]string
+	var colWidths []int
+
+	for c := node.FirstChild(); c != nil; c = c.NextSibling() {
+		if c.Kind() == extensionast.KindTableHeader || c.Kind() == extensionast.KindTableRow {
+			var row []string
+			colIdx := 0
+			for cc := c.FirstChild(); cc != nil; cc = cc.NextSibling() {
+				if cc.Kind() == extensionast.KindTableCell {
+					cellText := extractPlainText(cc, source)
+					row = append(row, cellText)
+					runeLen := utf8.RuneCountInString(cellText)
+					if colIdx >= len(colWidths) {
+						colWidths = append(colWidths, runeLen)
+					} else if runeLen > colWidths[colIdx] {
+						colWidths[colIdx] = runeLen
+					}
+					colIdx++
+				}
+			}
+			rows = append(rows, row)
+		}
+	}
+
+	// writing table in code block
+	_, _ = w.WriteString("```\n")
+	for i, row := range rows {
+		for colIdx, cellText := range row {
+			width := 0
+			if colIdx < len(colWidths) {
+				width = colWidths[colIdx]
+			}
+			runeLen := utf8.RuneCountInString(cellText)
+			padding := max(0, width-runeLen)
+
+			_, _ = w.WriteString(cellText)
+			_, _ = w.WriteString(strings.Repeat(" ", padding))
+			if colIdx < len(row)-1 {
+				_, _ = w.WriteString(" | ")
+			}
+		}
+		_ = w.WriteByte('\n')
+
+		// Print separator after header
+		if i == 0 {
+			for colIdx := range row {
+				width := 0
+				if colIdx < len(colWidths) {
+					width = colWidths[colIdx]
+				}
+				_, _ = w.WriteString(strings.Repeat("-", width))
+				if colIdx < len(row)-1 {
+					_, _ = w.WriteString("-|-")
+				}
+			}
+			_ = w.WriteByte('\n')
+		}
+	}
+	_, _ = w.WriteString("```")
+
+	return ast.WalkSkipChildren, nil
+}
+
+// extractPlainText extracts all the text content from the given node.
+func extractPlainText(n ast.Node, source []byte) string {
+	var buf bytes.Buffer
+	_ = ast.Walk(n, func(node ast.Node, entering bool) (ast.WalkStatus, error) {
+		if !entering {
+			return ast.WalkContinue, nil
+		}
+		if textNode, ok := node.(*ast.Text); ok {
+			buf.Write(textNode.Segment.Value(source))
+		} else if strNode, ok := node.(*ast.String); ok {
+			buf.Write(strNode.Value)
+		}
+		return ast.WalkContinue, nil
+	})
+	return strings.TrimSpace(buf.String())
+}
--- a/pkg/templating/slackmrkdwnrenderer/slack_test.go
+++ b/pkg/templating/slackmrkdwnrenderer/slack_test.go
@@ -0,0 +1,115 @@
+package slackmrkdwnrenderer
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/yuin/goldmark"
+)
+
+func TestRenderer(t *testing.T) {
+	tests := []struct {
+		name     string
+		markdown string
+		expected string
+	}{
+		{
+			name:     "Heading with Thematic Break",
+			markdown: "# Title 1\n# Hello World\n---\nthis is sometext",
+			expected: "*Title 1*\n\n*Hello World*\n\n---\n\nthis is sometext\n\n",
+		},
+		{
+			name:     "Blockquote",
+			markdown: "> This is a quote\n> It continues",
+			expected: "> This is a quote\n> It continues\n\n",
+		},
+		{
+			name:     "Fenced Code Block",
+			markdown: "```go\npackage main\nfunc main() {}\n```",
+			expected: "```\npackage main\nfunc main() {}\n```\n\n",
+		},
+		{
+			name:     "Unordered List",
+			markdown: "- item 1\n- item 2\n- item 3",
+			expected: "• item 1\n• item 2\n• item 3\n\n",
+		},
+		{
+			name:     "nested unordered list",
+			markdown: "- item 1\n- item 2\n\t- item 2.1\n\t\t- item 2.1.1\n\t\t- item 2.1.2\n\t- item 2.2\n- item 3",
+			expected: "• item 1\n• item 2\n\t• item 2.1\n\t\t• item 2.1.1\n\t\t• item 2.1.2\n\t• item 2.2\n• item 3\n\n",
+		},
+		{
+			name:     "Ordered List",
+			markdown: "1. item 1\n2. item 2\n3. item 3",
+			expected: "1. item 1\n2. item 2\n3. item 3\n\n",
+		},
+		{
+			name:     "nested ordered list",
+			markdown: "1. item 1\n2. item 2\n\t1. item 2.1\n\t\t1. item 2.1.1\n\t\t2. item 2.1.2\n\t2. item 2.2\n\t3. item 2.3\n3. item 3\n4. item 4",
+			expected: "1. item 1\n2. item 2\n\t1. item 2.1\n\t\t1. item 2.1.1\n\t\t2. item 2.1.2\n\t2. item 2.2\n\t3. item 2.3\n3. item 3\n4. item 4\n\n",
+		},
+		{
+			name:     "Links and AutoLinks",
+			markdown: "This is a [link](https://example.com) and an autolink <https://test.com>",
+			expected: "This is a <https://example.com|link> and an autolink <https://test.com>\n\n",
+		},
+		{
+			name:     "Images",
+			markdown: "An image ![alt text](https://example.com/image.png)",
+			expected: "An image <https://example.com/image.png|alt text>\n\n",
+		},
+		{
+			name:     "Emphasis",
+			markdown: "This is **bold** and *italic* and __bold__ and _italic_",
+			expected: "This is *bold* and _italic_ and *bold* and _italic_\n\n",
+		},
+		{
+			name:     "Strikethrough",
+			markdown: "This is ~~strike~~",
+			expected: "This is ~strike~\n\n",
+		},
+		{
+			name:     "Code Span",
+			markdown: "This is `inline code` embedded.",
+			expected: "This is `inline code` embedded.\n\n",
+		},
+		{
+			name:     "Table",
+			markdown: "Col 1 | Col 2 | Col 3\n--- | --- | ---\nVal 1 | Long Value 2 | 3\nShort | V | 1000",
+			expected: "```\nCol 1 | Col 2        | Col 3\n------|--------------|------\nVal 1 | Long Value 2 | 3    \nShort | V            | 1000 \n```\n\n",
+		},
+		{
+			name:     "Mixed Nested Lists",
+			markdown: "1. first\n\t- nested bullet\n\t- another bullet\n2. second",
+			expected: "1. first\n\t• nested bullet\n\t• another bullet\n2. second\n\n",
+		},
+		{
+			name:     "Email AutoLink",
+			markdown: "<user@example.com>",
+			expected: "<mailto:user@example.com|user@example.com>\n\n",
+		},
+		{
+			name:     "No value string parsed as is",
+			markdown: "Service: <no value>",
+			expected: "Service: <no value>\n\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			md := goldmark.New(goldmark.WithExtensions(SlackMrkdwn))
+
+			var buf bytes.Buffer
+			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {
+				t.Fatalf("failed to convert: %v", err)
+			}
+
+			// Do exact string matching
+			actual := buf.String()
+			if actual != tt.expected {
+				t.Errorf("\nExpected:\n%q\nGot:\n%q\nRaw Expected:\n%s\nRaw Got:\n%s",
+					tt.expected, actual, tt.expected, actual)
+			}
+		})
+	}
+}
--- a/pkg/templating/templatingextensions/html.go
+++ b/pkg/templating/templatingextensions/html.go
@@ -0,0 +1,66 @@
+package templatingextensions
+
+import (
+	"github.com/yuin/goldmark"
+	gast "github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/renderer/html"
+	"github.com/yuin/goldmark/util"
+)
+
+// NoValueHTMLRenderer is a renderer.NodeRenderer implementation that
+// renders <no value> as escaped visible text instead of omitting it.
+type NoValueHTMLRenderer struct {
+	html.Config
+}
+
+// NewNoValueHTMLRenderer returns a new NoValueHTMLRenderer.
+func NewNoValueHTMLRenderer(opts ...html.Option) renderer.NodeRenderer {
+	r := &NoValueHTMLRenderer{
+		Config: html.NewConfig(),
+	}
+	for _, opt := range opts {
+		opt.SetHTMLOption(&r.Config)
+	}
+	return r
+}
+
+// RegisterFuncs implements renderer.NodeRenderer.RegisterFuncs.
+func (r *NoValueHTMLRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	reg.Register(gast.KindRawHTML, r.renderRawHTML)
+}
+
+func (r *NoValueHTMLRenderer) renderRawHTML(
+	w util.BufWriter, source []byte, node gast.Node, entering bool) (gast.WalkStatus, error) {
+	if !entering {
+		return gast.WalkSkipChildren, nil
+	}
+	if r.Unsafe {
+		n := node.(*gast.RawHTML)
+		for i := 0; i < n.Segments.Len(); i++ {
+			segment := n.Segments.At(i)
+			_, _ = w.Write(segment.Value(source))
+		}
+		return gast.WalkSkipChildren, nil
+	}
+	n := node.(*gast.RawHTML)
+	raw := string(n.Segments.Value(source))
+	if raw == "<no value>" {
+		_, _ = w.WriteString("&lt;no value&gt;")
+		return gast.WalkSkipChildren, nil
+	}
+	_, _ = w.WriteString("<!-- raw HTML omitted -->")
+	return gast.WalkSkipChildren, nil
+}
+
+type escapeNoValue struct{}
+
+// EscapeNoValue is an extension that renders <no value> as visible
+// escaped text instead of omitting it as raw HTML.
+var EscapeNoValue = &escapeNoValue{}
+
+func (e *escapeNoValue) Extend(m goldmark.Markdown) {
+	m.Renderer().AddOptions(renderer.WithNodeRenderers(
+		util.Prioritized(NewNoValueHTMLRenderer(), 500),
+	))
+}
--- a/pkg/templating/templatingextensions/html_test.go
+++ b/pkg/templating/templatingextensions/html_test.go
@@ -0,0 +1,66 @@
+package templatingextensions
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/extension"
+)
+
+func TestEscapeNoValue(t *testing.T) {
+	tests := []struct {
+		name     string
+		markdown string
+		expected string
+	}{
+		{
+			name:     "plain text",
+			markdown: "Service: <no value>",
+			expected: "<p>Service: &lt;no value&gt;</p>\n",
+		},
+		{
+			name:     "inside strong",
+			markdown: "Service: **<no value>**",
+			expected: "<p>Service: <strong>&lt;no value&gt;</strong></p>\n",
+		},
+		{
+			name:     "inside emphasis",
+			markdown: "Service: *<no value>*",
+			expected: "<p>Service: <em>&lt;no value&gt;</em></p>\n",
+		},
+		{
+			name:     "inside strikethrough",
+			markdown: "Service: ~~<no value>~~",
+			expected: "<p>Service: <del>&lt;no value&gt;</del></p>\n",
+		},
+		{
+			name:     "real html still omitted",
+			markdown: "hello <div>world</div>",
+			expected: "<p>hello <!-- raw HTML omitted -->world<!-- raw HTML omitted --></p>\n",
+		},
+		{
+			name:     "inside heading",
+			markdown: "# Title <no value>",
+			expected: "<h1>Title &lt;no value&gt;</h1>\n",
+		},
+		{
+			name:     "inside list item",
+			markdown: "- item <no value>",
+			expected: "<ul>\n<li>item &lt;no value&gt;</li>\n</ul>\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gm := goldmark.New(goldmark.WithExtensions(EscapeNoValue, extension.Strikethrough))
+			var buf bytes.Buffer
+			if err := gm.Convert([]byte(tt.markdown), &buf); err != nil {
+				t.Fatal(err)
+			}
+			if buf.String() != tt.expected {
+				t.Errorf("expected:\n%s\ngot:\n%s", tt.expected, buf.String())
+			}
+		})
+	}
+}
--- a/pkg/types/alertmanagertypes/template.go
+++ b/pkg/types/alertmanagertypes/template.go
@@ -11,19 +11,22 @@ import (
 	alertmanagertemplate "github.com/prometheus/alertmanager/template"
 )

+func AdditionalFuncMap() tmpltext.FuncMap {
+	return tmpltext.FuncMap{
+		// urlescape escapes the string for use in a URL query parameter.
+		// It returns tmplhtml.HTML to prevent the template engine from escaping the already escaped string.
+		// url.QueryEscape escapes spaces as "+", and html/template escapes "+" as "&#43;" if tmplhtml.HTML is not used.
+		"urlescape": func(value string) tmplhtml.HTML {
+			return tmplhtml.HTML(url.QueryEscape(value))
+		},
+	}
+}
+
 // customTemplateOption returns an Option that adds custom functions to the template.
 func customTemplateOption() alertmanagertemplate.Option {
 	return func(text *tmpltext.Template, html *tmplhtml.Template) {
-		funcs := tmpltext.FuncMap{
-			// urlescape escapes the string for use in a URL query parameter.
-			// It returns tmplhtml.HTML to prevent the template engine from escaping the already escaped string.
-			// url.QueryEscape escapes spaces as "+", and html/template escapes "+" as "&#43;" if tmplhtml.HTML is not used.
-			"urlescape": func(value string) tmplhtml.HTML {
-				return tmplhtml.HTML(url.QueryEscape(value))
-			},
-		}
-		text.Funcs(funcs)
-		html.Funcs(funcs)
+		text.Funcs(AdditionalFuncMap())
+		html.Funcs(AdditionalFuncMap())
 	}
 }

--- a/pkg/types/ruletypes/constants.go
+++ b/pkg/types/ruletypes/constants.go
@@ -9,4 +9,20 @@ const (
 	LabelSeverityName     = "severity"
 	LabelLastSeen         = "lastSeen"
 	LabelRuleID           = "ruleId"
+	LabelRuleSource       = "ruleSource"
+	LabelNoData           = "nodata"
+	LabelTestAlert        = "testalert"
+	LabelAlertName        = "alertname"
+	LabelIsRecovering     = "is_recovering"
+)
+
+const (
+	AnnotationRelatedLogs    = "related_logs"
+	AnnotationRelatedTraces  = "related_traces"
+	AnnotationTitleTemplate  = "title_template"
+	AnnotationBodyTemplate   = "body_template"
+	AnnotationValue          = "value"
+	AnnotationThresholdValue = "threshold.value"
+	AnnotationCompareOp      = "compare_op"
+	AnnotationMatchType      = "match_type"
 )
--- a/pkg/web/config.go
+++ b/pkg/web/config.go
@@ -8,11 +8,10 @@ import (
 type Config struct {
 	// Whether the web package is enabled.
 	Enabled bool `mapstructure:"enabled"`
-
-	// The name of the index file to serve.
-	Index string `mapstructure:"index"`
-
-	// The directory from which to serve the web files.
+	// The prefix to serve the files from
+	Prefix string `mapstructure:"prefix"`
+	// The directory containing the static build files. The root of this directory should
+	// have an index.html file.
 	Directory string `mapstructure:"directory"`
 }

@@ -23,7 +22,7 @@ func NewConfigFactory() factory.ConfigFactory {
 func newConfig() factory.Config {
 	return &Config{
 		Enabled:   true,
-		Index:     "index.html",
+		Prefix:    "/",
 		Directory: "/etc/signoz/web",
 	}
 }
--- a/pkg/web/config_test.go
+++ b/pkg/web/config_test.go
@@ -12,6 +12,7 @@ import (
 )

 func TestNewWithEnvProvider(t *testing.T) {
+	t.Setenv("SIGNOZ_WEB_PREFIX", "/web")
 	t.Setenv("SIGNOZ_WEB_ENABLED", "false")

 	conf, err := config.New(
@@ -36,7 +37,7 @@ func TestNewWithEnvProvider(t *testing.T) {

 	expected := &Config{
 		Enabled:   false,
-		Index:     def.Index,
+		Prefix:    "/web",
 		Directory: def.Directory,
 	}

--- a/pkg/web/routerweb/provider.go
+++ b/pkg/web/routerweb/provider.go
@@ -8,55 +8,56 @@ import (

 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/web"
 	"github.com/gorilla/mux"
 )

+const (
+	indexFileName string = "index.html"
+)
+
 type provider struct {
-	config        web.Config
-	indexContents []byte
-	fileHandler   http.Handler
+	config web.Config
 }

-func NewFactory(globalConfig global.Config) factory.ProviderFactory[web.Web, web.Config] {
-	return factory.NewProviderFactory(factory.MustNewName("router"), func(ctx context.Context, settings factory.ProviderSettings, config web.Config) (web.Web, error) {
-		return New(ctx, settings, config, globalConfig)
-	})
+func NewFactory() factory.ProviderFactory[web.Web, web.Config] {
+	return factory.NewProviderFactory(factory.MustNewName("router"), New)
 }

-func New(ctx context.Context, settings factory.ProviderSettings, config web.Config, globalConfig global.Config) (web.Web, error) {
+func New(ctx context.Context, settings factory.ProviderSettings, config web.Config) (web.Web, error) {
 	fi, err := os.Stat(config.Directory)
 	if err != nil {
 		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "cannot access web directory")
 	}

-	if !fi.IsDir() {
+	ok := fi.IsDir()
+	if !ok {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "web directory is not a directory")
 	}

-	indexPath := filepath.Join(config.Directory, config.Index)
-	raw, err := os.ReadFile(indexPath)
+	fi, err = os.Stat(filepath.Join(config.Directory, indexFileName))
 	if err != nil {
-		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "cannot read %q in web directory", config.Index)
+		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "cannot access %q in web directory", indexFileName)
 	}

-	logger := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/web/routerweb").Logger()
-	indexContents := web.NewIndex(ctx, logger, config.Index, raw, web.TemplateData{BaseHref: globalConfig.ExternalPathTrailing()})
+	if os.IsNotExist(err) || fi.IsDir() {
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "%q does not exist", indexFileName)
+	}

 	return &provider{
-		config:        config,
-		indexContents: indexContents,
-		fileHandler:   http.FileServer(http.Dir(config.Directory)),
+		config: config,
 	}, nil
 }

 func (provider *provider) AddToRouter(router *mux.Router) error {
 	cache := middleware.NewCache(0)
-	err := router.PathPrefix("/").
+	err := router.PathPrefix(provider.config.Prefix).
 		Handler(
-			cache.Wrap(http.HandlerFunc(provider.ServeHTTP)),
+			http.StripPrefix(
+				provider.config.Prefix,
+				cache.Wrap(http.HandlerFunc(provider.ServeHTTP)),
+			),
 		).GetError()
 	if err != nil {
 		return errors.WrapInternalf(err, errors.CodeInternal, "unable to add web to router")
@@ -74,7 +75,7 @@ func (provider *provider) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	if err != nil {
 		// if the file doesn't exist, serve index.html
 		if os.IsNotExist(err) {
-			provider.serveIndex(rw)
+			http.ServeFile(rw, req, filepath.Join(provider.config.Directory, indexFileName))
 			return
 		}

@@ -86,15 +87,10 @@ func (provider *provider) ServeHTTP(rw http.ResponseWriter, req *http.Request) {

 	if fi.IsDir() {
 		// path is a directory, serve index.html
-		provider.serveIndex(rw)
+		http.ServeFile(rw, req, filepath.Join(provider.config.Directory, indexFileName))
 		return
 	}

 	// otherwise, use http.FileServer to serve the static file
-	provider.fileHandler.ServeHTTP(rw, req)
-}
-
-func (provider *provider) serveIndex(rw http.ResponseWriter) {
-	rw.Header().Set("Content-Type", "text/html; charset=utf-8")
-	_, _ = rw.Write(provider.indexContents)
+	http.FileServer(http.Dir(provider.config.Directory)).ServeHTTP(rw, req)
 }
--- a/pkg/web/routerweb/provider_test.go
+++ b/pkg/web/routerweb/provider_test.go
@@ -5,113 +5,45 @@ import (
 	"io"
 	"net"
 	"net/http"
-	"net/url"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"

 	"github.com/SigNoz/signoz/pkg/factory/factorytest"
-	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/web"
 	"github.com/gorilla/mux"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )

-func startServer(t *testing.T, config web.Config, globalConfig global.Config) string {
-	t.Helper()
+func TestServeHttpWithoutPrefix(t *testing.T) {
+	t.Parallel()
+	fi, err := os.Open(filepath.Join("testdata", indexFileName))
+	require.NoError(t, err)

-	web, err := New(context.Background(), factorytest.NewSettings(), config, globalConfig)
+	expected, err := io.ReadAll(fi)
+	require.NoError(t, err)
+
+	web, err := New(context.Background(), factorytest.NewSettings(), web.Config{Prefix: "/", Directory: filepath.Join("testdata")})
 	require.NoError(t, err)

 	router := mux.NewRouter()
-	require.NoError(t, web.AddToRouter(router))
+	err = web.AddToRouter(router)
+	require.NoError(t, err)

 	listener, err := net.Listen("tcp", "localhost:0")
 	require.NoError(t, err)

-	server := &http.Server{Handler: router}
-	go func() { _ = server.Serve(listener) }()
-	t.Cleanup(func() { _ = server.Close() })
-
-	return "http://" + listener.Addr().String()
-}
-
-func httpGet(t *testing.T, url string) string {
-	t.Helper()
-
-	res, err := http.DefaultClient.Get(url)
-	require.NoError(t, err)
-	defer func() { _ = res.Body.Close() }()
-
-	body, err := io.ReadAll(res.Body)
-	require.NoError(t, err)
-
-	return string(body)
-}
-
-func TestServeTemplatedIndex(t *testing.T) {
-	t.Parallel()
-
-	testCases := []struct {
-		name         string
-		path         string
-		globalConfig global.Config
-		expected     string
-	}{
-		{
-			name:         "RootBaseHrefAtRoot",
-			path:         "/",
-			globalConfig: global.Config{},
-			expected:     `<html><head><base href="/" /></head><body>Welcome to test data!!!</body></html>`,
-		},
-		{
-			name:         "RootBaseHrefAtNonExistentPath",
-			path:         "/does-not-exist",
-			globalConfig: global.Config{},
-			expected:     `<html><head><base href="/" /></head><body>Welcome to test data!!!</body></html>`,
-		},
-		{
-			name:         "RootBaseHrefAtDirectory",
-			path:         "/assets",
-			globalConfig: global.Config{},
-			expected:     `<html><head><base href="/" /></head><body>Welcome to test data!!!</body></html>`,
-		},
-		{
-			name:         "SubPathBaseHrefAtRoot",
-			path:         "/",
-			globalConfig: global.Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/signoz"}},
-			expected:     `<html><head><base href="/signoz/" /></head><body>Welcome to test data!!!</body></html>`,
-		},
-		{
-			name:         "SubPathBaseHrefAtNonExistentPath",
-			path:         "/does-not-exist",
-			globalConfig: global.Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/signoz"}},
-			expected:     `<html><head><base href="/signoz/" /></head><body>Welcome to test data!!!</body></html>`,
-		},
-		{
-			name:         "SubPathBaseHrefAtDirectory",
-			path:         "/assets",
-			globalConfig: global.Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/signoz"}},
-			expected:     `<html><head><base href="/signoz/" /></head><body>Welcome to test data!!!</body></html>`,
-		},
+	server := &http.Server{
+		Handler: router,
 	}

-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			base := startServer(t, web.Config{Index: "valid_template.html", Directory: "testdata"}, testCase.globalConfig)
-
-			assert.Equal(t, testCase.expected, strings.TrimSuffix(httpGet(t, base+testCase.path), "\n"))
-		})
-	}
-}
-
-func TestServeNoTemplateIndex(t *testing.T) {
-	t.Parallel()
-
-	expected, err := os.ReadFile(filepath.Join("testdata", "no_template.html"))
-	require.NoError(t, err)
+	go func() {
+		_ = server.Serve(listener)
+	}()
+	defer func() {
+		_ = server.Close()
+	}()

 	testCases := []struct {
 		name string
@@ -122,7 +54,11 @@ func TestServeNoTemplateIndex(t *testing.T) {
 			path: "/",
 		},
 		{
-			name: "NonExistentPath",
+			name: "Index",
+			path: "/" + indexFileName,
+		},
+		{
+			name: "DoesNotExist",
 			path: "/does-not-exist",
 		},
 		{
@@ -131,55 +67,104 @@ func TestServeNoTemplateIndex(t *testing.T) {
 		},
 	}

-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			base := startServer(t, web.Config{Index: "no_template.html", Directory: "testdata"}, global.Config{})
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			res, err := http.DefaultClient.Get("http://" + listener.Addr().String() + tc.path)
+			require.NoError(t, err)

-			assert.Equal(t, string(expected), httpGet(t, base+testCase.path))
+			defer func() {
+				_ = res.Body.Close()
+			}()
+
+			actual, err := io.ReadAll(res.Body)
+			require.NoError(t, err)
+
+			assert.Equal(t, expected, actual)
 		})
 	}
+
 }

-func TestServeInvalidTemplateIndex(t *testing.T) {
+func TestServeHttpWithPrefix(t *testing.T) {
 	t.Parallel()
-
-	expected, err := os.ReadFile(filepath.Join("testdata", "invalid_template.html"))
+	fi, err := os.Open(filepath.Join("testdata", indexFileName))
 	require.NoError(t, err)

+	expected, err := io.ReadAll(fi)
+	require.NoError(t, err)
+
+	web, err := New(context.Background(), factorytest.NewSettings(), web.Config{Prefix: "/web", Directory: filepath.Join("testdata")})
+	require.NoError(t, err)
+
+	router := mux.NewRouter()
+	err = web.AddToRouter(router)
+	require.NoError(t, err)
+
+	listener, err := net.Listen("tcp", "localhost:0")
+	require.NoError(t, err)
+
+	server := &http.Server{
+		Handler: router,
+	}
+
+	go func() {
+		_ = server.Serve(listener)
+	}()
+	defer func() {
+		_ = server.Close()
+	}()
+
 	testCases := []struct {
-		name string
-		path string
+		name  string
+		path  string
+		found bool
 	}{
 		{
-			name: "Root",
-			path: "/",
+			name:  "Root",
+			path:  "/web",
+			found: true,
 		},
 		{
-			name: "NonExistentPath",
-			path: "/does-not-exist",
+			name:  "Index",
+			path:  "/web/" + indexFileName,
+			found: true,
 		},
 		{
-			name: "Directory",
-			path: "/assets",
+			name:  "FileDoesNotExist",
+			path:  "/web/does-not-exist",
+			found: true,
+		},
+		{
+			name:  "Directory",
+			path:  "/web/assets",
+			found: true,
+		},
+		{
+			name:  "DoesNotExist",
+			path:  "/does-not-exist",
+			found: false,
 		},
 	}

-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			base := startServer(t, web.Config{Index: "invalid_template.html", Directory: "testdata"}, global.Config{ExternalURL: &url.URL{Path: "/signoz"}})
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			res, err := http.DefaultClient.Get("http://" + listener.Addr().String() + tc.path)
+			require.NoError(t, err)
+
+			defer func() {
+				_ = res.Body.Close()
+			}()
+
+			if tc.found {
+				actual, err := io.ReadAll(res.Body)
+				require.NoError(t, err)
+
+				assert.Equal(t, expected, actual)
+			} else {
+				assert.Equal(t, http.StatusNotFound, res.StatusCode)
+			}

-			assert.Equal(t, string(expected), httpGet(t, base+testCase.path))
 		})
 	}
-}
-
-func TestServeStaticFilesUnchanged(t *testing.T) {
-	t.Parallel()
-
-	expected, err := os.ReadFile(filepath.Join("testdata", "assets", "style.css"))
-	require.NoError(t, err)
-
-	base := startServer(t, web.Config{Index: "valid_template.html", Directory: "testdata"}, global.Config{ExternalURL: &url.URL{Path: "/signoz"}})
-
-	assert.Equal(t, string(expected), httpGet(t, base+"/assets/style.css"))
+
 }
--- a/pkg/web/routerweb/testdata/assets/index.css
+++ b/pkg/web/routerweb/testdata/assets/index.css
@@ -0,0 +1,3 @@
+#root {
+  background-color: red;
+}
--- a/pkg/web/routerweb/testdata/assets/style.css
+++ b/pkg/web/routerweb/testdata/assets/style.css
@@ -1 +0,0 @@
-body { color: red; }
--- a/pkg/web/routerweb/testdata/index.html
+++ b/pkg/web/routerweb/testdata/index.html
@@ -0,0 +1 @@
+<h1>Welcome to test data!!!</h1>
--- a/pkg/web/routerweb/testdata/invalid_template.html
+++ b/pkg/web/routerweb/testdata/invalid_template.html
@@ -1 +0,0 @@
-<html><head><base href="[[." /></head><body>Bad template</body></html>
--- a/pkg/web/routerweb/testdata/no_template.html
+++ b/pkg/web/routerweb/testdata/no_template.html
@@ -1 +0,0 @@
-<html><head></head><body>No template here</body></html>
--- a/pkg/web/routerweb/testdata/valid_template.html
+++ b/pkg/web/routerweb/testdata/valid_template.html
@@ -1 +0,0 @@
-<html><head><base href="[[.BaseHref]]" /></head><body>Welcome to test data!!!</body></html>
--- a/pkg/web/template.go
+++ b/pkg/web/template.go
@@ -1,42 +0,0 @@
-package web
-
-import (
-	"bytes"
-	"context"
-	"log/slog"
-	"text/template"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-)
-
-// Field names map to the HTML attributes they populate in the template:
-//   - BaseHref  → <base href="[[.BaseHref]]" />
-type TemplateData struct {
-	BaseHref string
-}
-
-// If the template cannot be parsed or executed, the raw bytes are
-// returned unchanged and the error is logged.
-func NewIndex(ctx context.Context, logger *slog.Logger, name string, raw []byte, data TemplateData) []byte {
-	result, err := NewIndexE(name, raw, data)
-	if err != nil {
-		logger.ErrorContext(ctx, "cannot render index template, serving raw file", slog.String("name", name), errors.Attr(err))
-		return raw
-	}
-
-	return result
-}
-
-func NewIndexE(name string, raw []byte, data TemplateData) ([]byte, error) {
-	tmpl, err := template.New(name).Delims("[[", "]]").Parse(string(raw))
-	if err != nil {
-		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "cannot parse %q as template", name)
-	}
-
-	var buf bytes.Buffer
-	if err := tmpl.Execute(&buf, data); err != nil {
-		return nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "cannot execute template for %q", name)
-	}
-
-	return buf.Bytes(), nil
-}
Author	SHA1	Message	Date
Abhishek Kumar Singh	c5c450c58c	fix: concurrent rendering in markdown renderer	2026-04-16 18:20:25 +05:30
Abhishek Kumar Singh	dc67f8551f	Merge branch 'feat/alert_manager_template' into feat/markdown_renderer	2026-04-16 17:59:31 +05:30
Abhishek Kumar Singh	c46c0e105a	chore: removed notifier test files	2026-04-16 17:29:34 +05:30
Abhishek Kumar Singh	cc5a0b93ae	Merge branch 'main' into feat/alert_manager_template	2026-04-16 16:46:44 +05:30
Abhishek Kumar Singh	d1e332fb16	Merge branch 'feat/alert_manager_template' into feat/markdown_renderer	2026-04-14 17:51:05 +05:30
Abhishek Kumar Singh	c9f3e1ae26	Merge branch 'chore/am_custom_notifiers' into feat/alert_manager_template	2026-04-14 17:50:45 +05:30
Abhishek Kumar Singh	41ded342a1	Merge branch 'main' into chore/am_custom_notifiers	2026-04-14 17:50:27 +05:30
Abhishek Kumar Singh	7f22cb0442	chore: integrated slack mrkdwn renderer and added NoOp formatter	2026-04-14 17:46:33 +05:30
Abhishek Kumar Singh	6b77835050	feat: custom raw html renderer to escape <no value>	2026-04-14 17:44:57 +05:30
Abhishek Kumar Singh	909c3a80b1	feat: slack mrkdwn renderer	2026-04-14 17:44:15 +05:30
Abhishek Kumar Singh	42726747d8	Merge branch 'feat/alert_manager_template' into feat/markdown_renderer	2026-04-14 17:35:19 +05:30
Abhishek Kumar Singh	64ce90e418	fix: variables with symbols in template	2026-04-14 17:27:41 +05:30
Abhishek Kumar Singh	2fcffb7cdc	feat: return single templating result from with flag for template type	2026-04-14 17:24:40 +05:30
Abhishek Kumar Singh	782eee23d2	Merge branch 'feat/alert_manager_template' into feat/markdown_renderer	2026-04-14 14:16:08 +05:30
Abhishek Kumar Singh	abc0d71c16	Merge branch 'chore/am_custom_notifiers' into feat/alert_manager_template	2026-04-13 22:13:25 +05:30
Abhishek Kumar Singh	2e2dd4c42b	Merge branch 'main' into chore/am_custom_notifiers	2026-04-13 22:04:08 +05:30
Abhishek Kumar Singh	629929c6a6	Merge branch 'feat/alert_manager_template' into feat/markdown_renderer	2026-03-31 17:57:21 +05:30
Abhishek Kumar Singh	0ce76a94d6	Merge branch 'chore/am_custom_notifiers' into feat/alert_manager_template	2026-03-31 17:57:02 +05:30
Abhishek Kumar Singh	46ae74ced5	chore: updated email notifier from upstream	2026-03-31 11:52:08 +05:30
Abhishek Kumar Singh	2d8c1b7c86	chore: updated licenses for notifiers	2026-03-31 11:51:45 +05:30
Abhishek Kumar Singh	6602c8c523	refactor: lint fixes	2026-03-31 10:46:52 +05:30
Abhishek Kumar Singh	c22dbcbf74	refactor: review comments	2026-03-31 10:44:37 +05:30
Abhishek Kumar Singh	250bd9abeb	Merge branch 'main' into chore/am_custom_notifiers	2026-03-31 10:15:39 +05:30
Abhishek Kumar Singh	f132dc28c3	chore: updated br with new line in test and logs added	2026-03-23 17:02:30 +05:30
Abhishek Kumar Singh	834df680f0	Merge branch 'feat/alert_manager_template' into feat/markdown_renderer	2026-03-23 16:48:26 +05:30
Abhishek Kumar Singh	48b9f15e18	feat: integrated slack blockit in markdownrenderer package and removed plaintext format	2026-03-23 16:45:29 +05:30
Abhishek Kumar Singh	55fa03fe7e	test: added test for html rendering	2026-03-23 16:32:25 +05:30
Abhishek Kumar Singh	933717f309	feat: slack blockkit renderer using goldmark	2026-03-23 15:36:32 +05:30
Abhishek Kumar Singh	9ffc1203da	chore: updated newline to markdown format	2026-03-19 22:50:24 +05:30
Abhishek Kumar Singh	205a78f0e6	feat: added basic html markdown templater	2026-03-17 20:17:57 +05:30
Abhishek Kumar Singh	79518b6823	Merge branch 'chore/am_custom_notifiers' into feat/alert_manager_template	2026-03-17 20:15:00 +05:30
Abhishek Kumar Singh	e6a9f49cec	Merge branch 'main' into chore/am_custom_notifiers	2026-03-17 20:14:30 +05:30
Abhishek Kumar Singh	fd5fc40823	chore: updated comments	2026-03-16 18:19:03 +05:30
Abhishek Kumar Singh	db2e2a4617	chore: lint fix	2026-03-16 15:54:22 +05:30
Abhishek Kumar Singh	9368d3f393	refactor: comments and test improvements	2026-03-16 15:47:45 +05:30
Abhishek Kumar Singh	0c97ba36d6	refactor: test case and sb related changed	2026-03-16 15:12:23 +05:30
Abhishek Kumar Singh	2e1bdbc2fd	chore: added test for missing function	2026-03-16 14:49:52 +05:30
Abhishek Kumar Singh	330737f779	chore: renamed the interface	2026-03-13 19:20:49 +05:30
Abhishek Kumar Singh	f0c531ae2b	chore: lint fix	2026-03-13 19:11:34 +05:30
Abhishek Kumar Singh	54477ee786	feat: added support for and in templating	2026-03-13 19:09:39 +05:30
Abhishek Kumar Singh	d281f7b6a2	test: fix preprocessor test case	2026-03-13 17:31:28 +05:30
Abhishek Kumar Singh	378dc350ef	refactor: added extractCommonKV instead of 2 different functions	2026-03-13 17:10:13 +05:30
Abhishek Kumar Singh	89c38ed9bc	feat: converted alerttemplater to interface and updated tests	2026-03-13 17:02:26 +05:30
Abhishek Kumar Singh	04c4869b12	chore: added handling for missing variable used in template	2026-03-13 14:10:13 +05:30
Abhishek Kumar Singh	388a1184ca	chore: fix lint issues	2026-03-12 21:51:13 +05:30
Abhishek Kumar Singh	03901b353b	chore: hooked preProcess function in expandTitle and body, added labels and annotations in alertdata	2026-03-12 21:47:43 +05:30
Abhishek Kumar Singh	74441c74a8	feat: added preprocessor for alert templater	2026-03-12 20:54:28 +05:30
Abhishek Kumar Singh	93d332bef2	chore: exposed templates for alertmanager types	2026-03-12 18:52:40 +05:30
Abhishek Kumar Singh	1e730cae8c	chore: added utils for using variables with $ notation	2026-03-12 16:34:43 +05:30
Abhishek Kumar Singh	01a09cf6d2	chore: updated test name + code for timeout errors	2026-03-12 10:22:42 +05:30
Abhishek Kumar Singh	403dddab85	feat: alert manager template to template title and notification body	2026-03-11 21:55:09 +05:30
Abhishek Kumar Singh	d07a833574	chore: added tracing to msteamsv2 notifier	2026-03-11 16:05:00 +05:30
Abhishek Kumar Singh	b39bec7245	Merge branch 'main' into chore/am_custom_notifiers	2026-03-10 22:37:24 +05:30
Abhishek Kumar Singh	6ff55c48be	chore: fix email linter	2026-03-10 22:19:05 +05:30
Abhishek Kumar Singh	b15fa0f88f	chore: lint fixs	2026-03-10 21:57:53 +05:30
Abhishek Kumar Singh	19fe4f860e	chore: custom notifiers in alert manager	2026-03-10 13:20:04 +05:30
				`@@ -1 +0,0 @@`
				`<html><head><base href="[[." /></head><body>Bad template</body></html>`
				`@@ -1 +0,0 @@`
				`<html><head></head><body>No template here</body></html>`
				`@@ -1 +0,0 @@`
				`<html><head><base href="[[.BaseHref]]" /></head><body>Welcome to test data!!!</body></html>`