diff --git a/BackendAcademy/src/notifications/dto/create-notification.dto.ts b/BackendAcademy/src/notifications/dto/create-notification.dto.ts
index 5a602614d..d8588c387 100644
--- a/BackendAcademy/src/notifications/dto/create-notification.dto.ts
+++ b/BackendAcademy/src/notifications/dto/create-notification.dto.ts
@@ -1,4 +1,4 @@
-import { IsString, IsIn } from 'class-validator';
+import { IsString, IsIn, IsOptional } from 'class-validator';
 
 export class CreateNotificationDto {
   @IsString()
@@ -12,4 +12,16 @@ export class CreateNotificationDto {
 
   @IsString()
   message: string;
+
+  /**
+   * Optional deterministic deduplication key.
+   *
+   * When provided, the notification service will reject duplicate
+   * notifications that carry the same event key within the configured
+   * deduplication window. This prevents retries and scheduled jobs from
+   * sending duplicate reminders or alerts.
+   */
+  @IsOptional()
+  @IsString()
+  eventKey?: string;
 }
diff --git a/BackendAcademy/src/notifications/email.service.ts b/BackendAcademy/src/notifications/email.service.ts
index eff25ae0a..4f3497b7a 100644
--- a/BackendAcademy/src/notifications/email.service.ts
+++ b/BackendAcademy/src/notifications/email.service.ts
@@ -34,6 +34,80 @@ export interface EmailTemplateFields {
   [key: string]: string | undefined;
 }
 
+/**
+ * HTML entity map for escaping user-supplied values.
+ * Prevents XSS when interpolated into HTML templates.
+ */
+const HTML_ESCAPE_MAP: Record<string, string> = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#x27;',
+  '/': '&#x2F;',
+};
+
+/**
+ * Escapes HTML special characters in a string to prevent XSS.
+ * Used when interpolating user-supplied values into HTML email templates.
+ *
+ * @param raw - The raw string value to escape
+ * @returns The escaped string safe for HTML insertion
+ */
+export function escapeHtml(raw: string): string {
+  return raw.replace(/[&<>"'/]/g, (ch) => HTML_ESCAPE_MAP[ch] || ch);
+}
+
+/**
+ * Escapes characters that are significant in plain-text email contexts.
+ * Specifically handles leading dots (which can be confused with SMTP
+ * command prefixes) and backslash-n sequences.
+ *
+ * @param raw - The raw string value to escape
+ * @returns The escaped string safe for plain-text insertion
+ */
+export function escapePlainText(raw: string): string {
+  // Escape leading dots (SMTP dot-stuffing safety)
+  return raw
+    .split('\n')
+    .map((line) => (line.startsWith('.') ? `.${line}` : line))
+    .join('\n');
+}
+
+/**
+ * Strips known-dangerous HTML constructs from a value before interpolation.
+ * This is a defence-in-depth measure; primary protection is escaping.
+ *
+ * Removes `<script>`, `<iframe>`, `<object>`, `<embed>`, and `javascript:` URIs.
+ *
+ * @param raw - The raw string value to sanitise
+ * @returns The sanitised string with dangerous constructs removed
+ */
+export function stripDangerousHtml(raw: string): string {
+  let clean = raw;
+  // Remove script tags (and their content)
+  clean = clean.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '');
+  // Remove iframe, object, embed tags
+  clean = clean.replace(/<(iframe|object|embed)\b[^>]*>[\s\S]*?<\/\1>/gi, '');
+  clean = clean.replace(/<(iframe|object|embed)\b[^>]*\/?>/gi, '');
+  // Remove javascript: URIs
+  clean = clean.replace(/javascript\s*:/gi, '');
+  return clean;
+}
+
+/**
+ * Full sanitisation pipeline for a template field value.
+ * Applies stripping of dangerous constructs, then HTML escaping.
+ *
+ * @param value - The raw value to sanitise
+ * @returns The sanitised value safe for template interpolation
+ */
+export function sanitiseTemplateValue(value: string): string {
+  let clean = stripDangerousHtml(value);
+  clean = escapeHtml(clean);
+  return clean;
+}
+
 @Injectable()
 export class EmailService {
   private readonly logger = new Logger(EmailService.name);
@@ -43,6 +117,10 @@ export class EmailService {
    *
    * Missing personalization fields are replaced with sensible defaults
    * so the user never sees broken or blank content.
+   *
+   * Unknown or unrecognised placeholders are replaced with the
+   * placeholder token `[keyName]` so that the rendered content
+   * always remains readable.
    */
   async sendWelcomeEmail(
     email: string,
@@ -155,24 +233,29 @@ export class EmailService {
     this.logger.log(`Successfully sent submission graded email to ${email}`);
   }
 
-  // ── Template rendering with fallbacks (#387) ───────────────
+  // ── Template rendering with fallbacks and escaping (#387, Task 2) ──
 
   /**
    * Renders a template string by replacing {{key}} placeholders
-   * with values from the provided fields object. Any missing or
-   * empty fields are replaced with sensible defaults so the
-   * rendered content is never broken or blank.
+   * with values from the provided fields object.
    *
-   * This is the core fix for issue #387.
+   * Behaviour:
+   *  1. Values are sanitised: dangerous HTML constructs are stripped and
+   *     HTML special characters are escaped to prevent XSS.
+   *  2. Missing or empty fields fall back to the FALLBACKS map, then to
+   *     a visible `[keyName]` placeholder so the rendered content is
+   *     never broken or blank.
+   *  3. Unrecognised placeholders (keys not in FALLBACKS and not supplied)
+   *     are rendered as `[keyName]` — documented, predictable behaviour.
    */
   renderTemplate(
     template: string,
     fields: EmailTemplateFields = {},
   ): string {
     return template.replace(/\{\{(\w+)\}\}/g, (_match, key: string) => {
-      const value = fields[key];
-      if (value !== undefined && value !== null && value !== '') {
-        return value;
+      const raw = fields[key];
+      if (raw !== undefined && raw !== null && raw !== '') {
+        return sanitiseTemplateValue(raw);
       }
       // Resolve to a safe fallback default
       const fallback = FALLBACKS[key] || `[${key}]`;
diff --git a/BackendAcademy/src/notifications/interfaces/notifications.interface.ts b/BackendAcademy/src/notifications/interfaces/notifications.interface.ts
index 100feeb3b..7688201b8 100644
--- a/BackendAcademy/src/notifications/interfaces/notifications.interface.ts
+++ b/BackendAcademy/src/notifications/interfaces/notifications.interface.ts
@@ -6,4 +6,13 @@ export interface Notification {
   message: string;
   isRead: boolean;
   createdAt: Date;
+  /**
+   * Deterministic deduplication key.
+   *
+   * When set, the notification service will reject duplicate notifications
+   * carrying the same event key within the configured deduplication window.
+   * Retries and scheduled jobs that produce the same event key will therefore
+   * only result in a single delivered notification.
+   */
+  eventKey?: string;
 }
diff --git a/BackendAcademy/src/notifications/notifications.service.ts b/BackendAcademy/src/notifications/notifications.service.ts
index cbc8afd16..b8b70bf6c 100644
--- a/BackendAcademy/src/notifications/notifications.service.ts
+++ b/BackendAcademy/src/notifications/notifications.service.ts
@@ -22,6 +22,20 @@ export interface BatchConfig {
   enabled: boolean;
 }
 
+/**
+ * Configuration for notification deduplication.
+ *
+ * A deterministic event key prevents duplicates within the configured
+ * window. Retries and scheduled jobs that produce the same event key
+ * will only result in a single delivered notification.
+ */
+export interface DedupConfig {
+  /** How long (in ms) a previously seen event key is remembered. Default: 5 minutes. */
+  windowMs: number;
+  /** Whether deduplication is enabled. */
+  enabled: boolean;
+}
+
 /**
  * Result of a batch delivery operation.
  */
@@ -44,6 +58,8 @@ export class NotificationsService {
   /** Pending low-priority notifications awaiting batch flush */
   private pendingBatch: Notification[] = [];
   private batchTimer: ReturnType<typeof setTimeout> | null = null;
+  /** Lock to prevent concurrent batch flushes (Task 3) */
+  private flushing = false;
 
   private batchConfig: BatchConfig = {
     maxBatchSize: 10,
@@ -51,6 +67,14 @@ export class NotificationsService {
     enabled: false,
   };
 
+  // ── Deduplication state (Task 1) ─────────────────────────
+  /** Maps event keys to their last-seen timestamp (ms since epoch). */
+  private dedupWindow: Map<string, number> = new Map();
+  private dedupConfig: DedupConfig = {
+    windowMs: 5 * 60 * 1000, // 5 minutes
+    enabled: true,
+  };
+
   // ── Default localized notification templates ────────────────
   static readonly TEMPLATES: Record<
     string,
@@ -183,9 +207,101 @@ export class NotificationsService {
     return { ...this.batchConfig };
   }
 
+  // ── Deduplication configuration (Task 1) ──────────────────
+
+  /**
+   * Configures the deduplication window and toggle.
+   *
+   * @example
+   * service.configureDedup({ windowMs: 10 * 60 * 1000 }); // 10 min window
+   * service.configureDedup({ enabled: false }); // disable dedup
+   */
+  configureDedup(config: Partial<DedupConfig>): void {
+    this.dedupConfig = { ...this.dedupConfig, ...config };
+    this.logger.log(
+      `Dedup config updated: enabled=${this.dedupConfig.enabled}, windowMs=${this.dedupConfig.windowMs}`,
+    );
+  }
+
+  getDedupConfig(): DedupConfig {
+    return { ...this.dedupConfig };
+  }
+
+  // ── Deduplication internals (Task 1) ──────────────────────
+
+  /**
+   * Purges expired entries from the dedup window to prevent unbounded growth.
+   */
+  private purgeExpiredDedupKeys(): void {
+    if (!this.dedupConfig.enabled) return;
+    const now = Date.now();
+    for (const [key, timestamp] of this.dedupWindow) {
+      if (now - timestamp >= this.dedupConfig.windowMs) {
+        this.dedupWindow.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Returns true if the given event key has already been seen within the
+   * deduplication window.  If it hasn't, the key is recorded for future
+   * checks.  This is idempotent: a duplicate call with the same key within
+   * the window returns true without side-effects beyond the initial record.
+   *
+   * Provider retries that carry the same event key are therefore safe —
+   * only the first attempt gets through.
+   */
+  private isDuplicate(eventKey: string): boolean {
+    if (!this.dedupConfig.enabled || !eventKey) return false;
+
+    this.purgeExpiredDedupKeys();
+
+    const now = Date.now();
+    const lastSeen = this.dedupWindow.get(eventKey);
+    if (lastSeen !== undefined && now - lastSeen < this.dedupConfig.windowMs) {
+      this.logger.debug(
+        `Dedup: rejecting duplicate event key "${eventKey}" (seen ${now - lastSeen}ms ago, window ${this.dedupConfig.windowMs}ms)`,
+      );
+      return true;
+    }
+
+    // Record the key so subsequent calls within the window are rejected
+    this.dedupWindow.set(eventKey, now);
+    return false;
+  }
+
+  /**
+   * Returns the number of event keys currently tracked in the dedup window.
+   * Useful for monitoring and testing.
+   */
+  getDedupWindowSize(): number {
+    this.purgeExpiredDedupKeys();
+    return this.dedupWindow.size;
+  }
+
   // ── Notification CRUD ────────────────────────────────────
 
   create(createNotificationDto: CreateNotificationDto): Notification {
+    // Task 1: deterministic deduplication via event keys
+    const eventKey = createNotificationDto.eventKey;
+    if (eventKey && this.isDuplicate(eventKey)) {
+      this.logger.warn(
+        `Notification suppressed (duplicate event key "${eventKey}")`,
+      );
+      // Return a sentinel-like notification that callers can inspect.
+      // The notification is NOT persisted — preventing duplicate delivery.
+      return {
+        id: '__duplicate__',
+        userId: createNotificationDto.userId,
+        type: createNotificationDto.type,
+        title: createNotificationDto.title,
+        message: createNotificationDto.message,
+        isRead: true,
+        createdAt: new Date(),
+        eventKey,
+      };
+    }
+
     const newNotification: Notification = {
       id: Math.random().toString(36).substring(2, 9),
       ...createNotificationDto,
@@ -278,6 +394,14 @@ export class NotificationsService {
     return this.deliverImmediately(notification, context);
   }
 
+  /**
+   * Type guard: converts a BatchDeliveryResult into DeliveryResult[].
+   * Used by enqueueForBatch to return a uniform type to callers of deliver().
+   */
+  private batchToResults(batch: BatchDeliveryResult): DeliveryResult[] {
+    return batch.results;
+  }
+
   private async deliverImmediately(
     notification: Notification,
     context: DeliveryContext,
@@ -289,6 +413,8 @@ export class NotificationsService {
       return [];
     }
 
+    const enabledProviders = this.getEnabledProviders(context.userId);
+
     const results = await Promise.allSettled(
       enabledProviders.map((provider) =>
         provider.send(notification, context),
@@ -310,7 +436,7 @@ export class NotificationsService {
     });
   }
 
-  // ── Batching (#386) ──────────────────────────────────────
+  // ── Batching — concurrency-safe (Task 3) ─────────────────
 
   private async enqueueForBatch(
     notification: Notification,
@@ -322,7 +448,7 @@ export class NotificationsService {
     );
 
     if (this.pendingBatch.length >= this.batchConfig.maxBatchSize) {
-      return this.flushBatch(context);
+      return this.batchToResults(await this.flushBatch(context));
     }
 
     if (!this.batchTimer && this.batchConfig.batchWindowMs > 0) {
@@ -342,18 +468,25 @@ export class NotificationsService {
     ];
   }
 
+  /**
+   * Atomically claims the current pending batch and flushes it through
+   * all enabled providers.
+   *
+   * Concurrency safety (Task 3):
+   *  - A boolean `flushing` lock prevents two concurrent flushes from
+   *    operating on the same batch snapshot.
+   *  - The batch is swapped atomically (copy + clear) before any async
+   *    provider calls, so enqueued notifications that arrive during the
+   *    flush are captured in a fresh `pendingBatch` array.
+   *  - If a flush is already in progress, the caller receives an empty
+   *    result rather than duplicating delivery work.
+   */
   async flushBatch(context?: DeliveryContext): Promise<BatchDeliveryResult> {
-    if (this.batchTimer) {
-      clearTimeout(this.batchTimer);
-      this.batchTimer = null;
-    }
-
-    const batch = [...this.pendingBatch];
-    this.pendingBatch = [];
-
-    this.notifications.push(...batch);
-
-    if (batch.length === 0) {
+    // Task 3: concurrency guard
+    if (this.flushing) {
+      this.logger.debug(
+        'Batch flush already in progress — skipping duplicate flush',
+      );
       return {
         batchId: '',
         totalCount: 0,
@@ -364,44 +497,76 @@ export class NotificationsService {
       };
     }
 
-    this.logger.log(`Flushing batch of ${batch.length} notifications`);
+    this.flushing = true;
 
-    const ctx = context || {
-      userId: 'batch',
-      priority: NotificationPriority.LOW,
-    };
-    const allResults: DeliveryResult[] = [];
-
-    if (enabledProviders.length > 0) {
-      for (const provider of enabledProviders) {
-        if (provider.sendBatch) {
-          const results = await provider.sendBatch(batch, ctx);
-          allResults.push(...results);
-        } else {
-          for (const notification of batch) {
-            const result = await provider.send(notification, ctx);
-            allResults.push(result);
+    try {
+      if (this.batchTimer) {
+        clearTimeout(this.batchTimer);
+        this.batchTimer = null;
+      }
+
+      // Atomically claim the batch: snapshot and replace with empty array
+      const batch = [...this.pendingBatch];
+      this.pendingBatch = [];
+
+      this.notifications.push(...batch);
+
+      if (batch.length === 0) {
+        return {
+          batchId: '',
+          totalCount: 0,
+          successCount: 0,
+          failureCount: 0,
+          results: [],
+          flushedAt: new Date(),
+        };
+      }
+
+      this.logger.log(`Flushing batch of ${batch.length} notifications`);
+
+      const ctx = context || {
+        userId: 'batch',
+        priority: NotificationPriority.LOW,
+      };
+      const allResults: DeliveryResult[] = [];
+
+      const enabledProviders = ctx.userId === 'batch'
+        ? (this.providers ?? [])
+        : this.getEnabledProviders(ctx.userId);
+
+      if (enabledProviders.length > 0) {
+        for (const provider of enabledProviders) {
+          if (provider.sendBatch) {
+            const results = await provider.sendBatch(batch, ctx);
+            allResults.push(...results);
+          } else {
+            for (const notification of batch) {
+              const result = await provider.send(notification, ctx);
+              allResults.push(result);
+            }
           }
         }
       }
-    }
 
-    const batchId = `batch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const successCount = allResults.filter((r) => r.success).length;
-    const failureCount = allResults.filter((r) => !r.success).length;
+      const batchId = `batch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const successCount = allResults.filter((r) => r.success).length;
+      const failureCount = allResults.filter((r) => !r.success).length;
 
-    this.logger.log(
-      `Batch ${batchId}: ${successCount} succeeded, ${failureCount} failed`,
-    );
+      this.logger.log(
+        `Batch ${batchId}: ${successCount} succeeded, ${failureCount} failed`,
+      );
 
-    return {
-      batchId,
-      totalCount: batch.length,
-      successCount,
-      failureCount,
-      results: allResults,
-      flushedAt: new Date(),
-    };
+      return {
+        batchId,
+        totalCount: batch.length,
+        successCount,
+        failureCount,
+        results: allResults,
+        flushedAt: new Date(),
+      };
+    } finally {
+      this.flushing = false;
+    }
   }
 
   getPendingBatchCount(): number {
diff --git a/BackendAcademy/src/notifications/notifications.spec.ts b/BackendAcademy/src/notifications/notifications.spec.ts
new file mode 100644
index 000000000..d02f6a8c8
--- /dev/null
+++ b/BackendAcademy/src/notifications/notifications.spec.ts
@@ -0,0 +1,416 @@
+import { NotificationsService, BatchConfig, DedupConfig } from './notifications.service';
+import { CreateNotificationDto } from './dto/create-notification.dto';
+import {
+  NotificationPriority,
+  INotificationProvider,
+  DeliveryResult,
+  DeliveryContext,
+  NOTIFICATION_PROVIDERS,
+} from './interfaces/notification-provider.interface';
+import { Notification } from './interfaces/notifications.interface';
+
+// ── Helpers ────────────────────────────────────────────────
+
+function createMockProvider(
+  id = 'email',
+  shouldFail = false,
+): INotificationProvider {
+  const sendFn = jest.fn(
+    async (_n: Notification, _c: DeliveryContext): Promise<DeliveryResult> => ({
+      success: !shouldFail,
+      message: shouldFail ? 'delivery failed' : 'delivered',
+      deliveredAt: new Date(),
+    }),
+  );
+  return {
+    providerId: id,
+    providerName: `Mock ${id}`,
+    send: sendFn,
+    healthCheck: jest.fn(async () => true),
+  };
+}
+
+function createMockL10n() {
+  return { t: jest.fn((key: string) => key) } as any;
+}
+
+function createDto(overrides: Partial<CreateNotificationDto> = {}): CreateNotificationDto {
+  return {
+    userId: 'u1',
+    type: 'in-app',
+    title: 'Test',
+    message: 'msg',
+    ...overrides,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════
+// Task 1: Notification Deduplication Keys
+// ═══════════════════════════════════════════════════════════
+
+describe('Notification deduplication (Task 1)', () => {
+  let service: NotificationsService;
+
+  beforeEach(() => {
+    service = new NotificationsService(createMockL10n());
+  });
+
+  it('creates a notification when no eventKey is provided', () => {
+    const n = service.create(createDto());
+    expect(n.id).not.toBe('__duplicate__');
+    expect(service.findAll()).toHaveLength(1);
+  });
+
+  it('creates a notification with a new eventKey', () => {
+    const n = service.create(createDto({ eventKey: 'sub-graded:sub-1' }));
+    expect(n.id).not.toBe('__duplicate__');
+    expect(n.eventKey).toBe('sub-graded:sub-1');
+    expect(service.findAll()).toHaveLength(1);
+  });
+
+  it('rejects a duplicate eventKey within the dedup window', () => {
+    const dto = createDto({ eventKey: 'dup:1' });
+    const first = service.create(dto);
+    const second = service.create(dto);
+    expect(first.id).not.toBe('__duplicate__');
+    expect(second.id).toBe('__duplicate__');
+    expect(service.findAll()).toHaveLength(1);
+  });
+
+  it('allows the same eventKey after the dedup window expires', async () => {
+    service.configureDedup({ windowMs: 50 });
+    const dto = createDto({ eventKey: 'expire:1' });
+    service.create(dto);
+    await new Promise((r) => setTimeout(r, 80));
+    const second = service.create(dto);
+    expect(second.id).not.toBe('__duplicate__');
+    expect(service.findAll()).toHaveLength(2);
+  });
+
+  it('allows different eventKeys concurrently', () => {
+    const n1 = service.create(createDto({ eventKey: 'key-a' }));
+    const n2 = service.create(createDto({ eventKey: 'key-b' }));
+    expect(n1.id).not.toBe('__duplicate__');
+    expect(n2.id).not.toBe('__duplicate__');
+    expect(service.findAll()).toHaveLength(2);
+  });
+
+  it('passes through duplicates when dedup is disabled', () => {
+    service.configureDedup({ enabled: false });
+    const dto = createDto({ eventKey: 'no-dedup' });
+    const first = service.create(dto);
+    const second = service.create(dto);
+    expect(first.id).not.toBe('__duplicate__');
+    expect(second.id).not.toBe('__duplicate__');
+    expect(service.findAll()).toHaveLength(2);
+  });
+
+  it('returns a sentinel notification on duplicate', () => {
+    const dto = createDto({ eventKey: 'sentinel', title: 'Original' });
+    service.create(dto);
+    const dup = service.create({ ...dto, title: 'Changed' });
+    expect(dup.id).toBe('__duplicate__');
+    expect(dup.eventKey).toBe('sentinel');
+    expect(dup.isRead).toBe(true);
+    expect(service.findAll()[0].title).toBe('Original');
+  });
+
+  it('configureDedup updates config', () => {
+    service.configureDedup({ windowMs: 120_000, enabled: false });
+    const cfg = service.getDedupConfig();
+    expect(cfg.windowMs).toBe(120_000);
+    expect(cfg.enabled).toBe(false);
+  });
+
+  it('getDedupWindowSize tracks active keys', () => {
+    service.configureDedup({ enabled: true, windowMs: 60_000 });
+    expect(service.getDedupWindowSize()).toBe(0);
+    service.create(createDto({ eventKey: 'k1' }));
+    expect(service.getDedupWindowSize()).toBe(1);
+    service.create(createDto({ eventKey: 'k2' }));
+    expect(service.getDedupWindowSize()).toBe(2);
+  });
+
+  it('dedup window purges expired keys', async () => {
+    service.configureDedup({ windowMs: 30 });
+    service.create(createDto({ eventKey: 'short' }));
+    expect(service.getDedupWindowSize()).toBe(1);
+    await new Promise((r) => setTimeout(r, 50));
+    service.create(createDto({ eventKey: 'new' }));
+    expect(service.getDedupWindowSize()).toBe(1);
+  });
+});
+
+// ═══════════════════════════════════════════════════════════
+// Task 2: Hardened email template interpolation
+// ═══════════════════════════════════════════════════════════
+
+describe('Email template hardening (Task 2)', () => {
+  let escapeHtml: (raw: string) => string;
+  let sanitiseTemplateValue: (value: string) => string;
+  let stripDangerousHtml: (raw: string) => string;
+  let EmailService: any;
+
+  beforeAll(async () => {
+    const mod = await import('./email.service');
+    escapeHtml = mod.escapeHtml;
+    sanitiseTemplateValue = mod.sanitiseTemplateValue;
+    stripDangerousHtml = mod.stripDangerousHtml;
+    EmailService = mod.EmailService;
+  });
+
+  describe('escapeHtml', () => {
+    it('escapes ampersand', () => {
+      expect(escapeHtml('a & b')).toBe('a &amp; b');
+    });
+
+    it('escapes angle brackets and forward slashes', () => {
+      expect(escapeHtml('<b>bold</b>')).toBe('&lt;b&gt;bold&lt;&#x2F;b&gt;');
+    });
+
+    it('escapes double quotes', () => {
+      expect(escapeHtml('say "hello"')).toBe('say &quot;hello&quot;');
+    });
+
+    it('escapes single quotes', () => {
+      expect(escapeHtml("it's")).toBe("it&#x27;s");
+    });
+
+    it('escapes forward slash', () => {
+      expect(escapeHtml('a/b')).toBe('a&#x2F;b');
+    });
+
+    it('returns clean text unchanged', () => {
+      expect(escapeHtml('Hello World 123')).toBe('Hello World 123');
+    });
+
+    it('escapes multiple special chars', () => {
+      expect(escapeHtml('<script>alert("xss")</script>')).toBe(
+        '&lt;script&gt;alert(&quot;xss&quot;)&lt;&#x2F;script&gt;',
+      );
+    });
+  });
+
+  describe('stripDangerousHtml', () => {
+    it('removes script tags', () => {
+      expect(stripDangerousHtml('Hello <script>alert("xss")</script> World')).toBe('Hello  World');
+    });
+
+    it('removes script tags with attributes', () => {
+      expect(stripDangerousHtml('A <script type="text/javascript" src="evil.js"></script> B')).toBe('A  B');
+    });
+
+    it('removes iframe tags', () => {
+      expect(stripDangerousHtml('X <iframe src="evil.com"></iframe> Y')).toBe('X  Y');
+    });
+
+    it('removes object tags', () => {
+      expect(stripDangerousHtml('X <object data="evil.swf"></object> Y')).toBe('X  Y');
+    });
+
+    it('removes embed tags', () => {
+      expect(stripDangerousHtml('X <embed src="evil.swf"> Y')).toBe('X  Y');
+    });
+
+    it('strips javascript: URIs', () => {
+      expect(stripDangerousHtml('click javascript:alert(1)')).toBe('click alert(1)');
+    });
+
+    it('handles case-insensitive script tags', () => {
+      expect(stripDangerousHtml('<SCRIPT>alert(1)</SCRIPT>')).toBe('');
+    });
+
+    it('preserves safe HTML', () => {
+      const input = '<b>Hello</b> <i>World</i>';
+      expect(stripDangerousHtml(input)).toBe(input);
+    });
+  });
+
+  describe('sanitiseTemplateValue', () => {
+    it('strips and escapes dangerous content', () => {
+      const result = sanitiseTemplateValue('<script>alert("xss")</script>Hello & goodbye');
+      expect(result).not.toContain('<script>');
+      expect(result).toContain('&amp;');
+    });
+
+    it('passes through safe text unchanged', () => {
+      expect(sanitiseTemplateValue('Hello World')).toBe('Hello World');
+    });
+
+    it('escapes HTML entities in user names', () => {
+      expect(sanitiseTemplateValue("O'Brien & Co")).toBe("O&#x27;Brien &amp; Co");
+    });
+  });
+
+  describe('EmailService.renderTemplate', () => {
+    let emailService: InstanceType<typeof EmailService>;
+
+    beforeEach(() => {
+      emailService = new EmailService();
+    });
+
+    it('replaces known placeholders with field values', () => {
+      const result = emailService.renderTemplate(
+        'Hello {{name}}, welcome to {{courseName}}!',
+        { name: 'Alice', courseName: 'Rust 101' },
+      );
+      expect(result).toBe('Hello Alice, welcome to Rust 101!');
+    });
+
+    it('escapes HTML in field values', () => {
+      const result = emailService.renderTemplate(
+        'Hello {{name}}!',
+        { name: '<img src=x onerror=alert(1)>' },
+      );
+      expect(result).not.toContain('<img');
+      expect(result).toContain('&lt;img');
+    });
+
+    it('uses FALLBACKS for missing known fields', () => {
+      expect(emailService.renderTemplate('Hello {{name}}!', {})).toBe(
+        'Hello RustAcademy Learner!',
+      );
+    });
+
+    it('uses [keyName] for unknown missing fields', () => {
+      expect(emailService.renderTemplate('Score: {{unknownField}}', {})).toBe(
+        'Score: [unknownField]',
+      );
+    });
+
+    it('does not replace single-brace placeholders', () => {
+      const result = emailService.renderTemplate(
+        'Single {brace} stays, {{name}} replaced',
+        { name: 'Bob' },
+      );
+      expect(result).toBe('Single {brace} stays, Bob replaced');
+    });
+
+    it('handles template with no placeholders', () => {
+      expect(emailService.renderTemplate('No placeholders.', { name: 'A' })).toBe(
+        'No placeholders.',
+      );
+    });
+  });
+});
+
+// ═══════════════════════════════════════════════════════════
+// Task 3: Concurrency-safe notification batching
+// ═══════════════════════════════════════════════════════════
+
+describe('Batch concurrency safety (Task 3)', () => {
+  let service: NotificationsService;
+
+  beforeEach(() => {
+    service = new NotificationsService(createMockL10n());
+    service.configureBatch({
+      enabled: true,
+      maxBatchSize: 5,
+      batchWindowMs: 50_000, // large window so timer-based flush doesn't fire during tests
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  const ctx: DeliveryContext = {
+    userId: 'u1',
+    priority: NotificationPriority.LOW,
+  };
+
+  function enqueue(count: number, keyPrefix = 'k') {
+    const items: Notification[] = [];
+    for (let i = 0; i < count; i++) {
+      items.push(service.create(createDto({ eventKey: `${keyPrefix}${i}` })));
+    }
+    return items;
+  }
+
+  it('flushes when batch reaches maxBatchSize', async () => {
+    const items = enqueue(5);
+    for (const n of items) {
+      await service.deliver(n, ctx);
+    }
+    // The 5th delivery triggers flush
+    expect(service.getPendingBatchCount()).toBe(0);
+  });
+
+  it('returns empty result when batch is empty', async () => {
+    const result = await service.flushBatch();
+    expect(result.totalCount).toBe(0);
+    expect(result.batchId).toBe('');
+    expect(result.results).toHaveLength(0);
+  });
+
+  it('atomic swap: concurrent flushes do not double-deliver', async () => {
+    // Manually populate the batch directly
+    const items = enqueue(3, 'race');
+    for (const n of items) {
+      await service.deliver(n, ctx);
+    }
+
+    // Fire two flushes concurrently
+    const p1 = service.flushBatch(ctx);
+    const p2 = service.flushBatch(ctx);
+    const [r1, r2] = await Promise.all([p1, p2]);
+
+    const flushed = r1.totalCount > 0 ? r1 : r2;
+    const skipped = r1.totalCount === 0 ? r1 : r2;
+
+    expect(flushed.totalCount).toBe(3);
+    expect(skipped.totalCount).toBe(0);
+    expect(skipped.results).toHaveLength(0);
+  });
+
+  it('enqueues new notifications during an active flush', async () => {
+    const items = enqueue(3, 'during');
+    for (const n of items) {
+      await service.deliver(n, ctx);
+    }
+
+    // Start flush (captures batch snapshot)
+    const flushPromise = service.flushBatch(ctx);
+
+    // Batch should now be empty (atomically claimed)
+    expect(service.getPendingBatchCount()).toBe(0);
+
+    // Enqueue more while flush is in progress
+    const n4 = service.create(createDto({ eventKey: 'during-after' }));
+    await service.deliver(n4, ctx);
+
+    await flushPromise;
+
+    // The new item should be in pending, not flushed with first batch
+    expect(service.getPendingBatchCount()).toBe(1);
+  });
+
+  it('batch timer is cleared after flush', async () => {
+    const n1 = service.create(createDto({ eventKey: 'timer1' }));
+    await service.deliver(n1, ctx);
+
+    expect(service.getPendingBatchCount()).toBe(1);
+
+    await service.flushBatch(ctx);
+    expect(service.getPendingBatchCount()).toBe(0);
+  });
+
+  it('size boundary: exactly maxBatchSize triggers flush', async () => {
+    const items = enqueue(5, 'sz');
+    for (let i = 0; i < 4; i++) {
+      await service.deliver(items[i], ctx);
+    }
+    expect(service.getPendingBatchCount()).toBe(4);
+
+    await service.deliver(items[4], ctx);
+    expect(service.getPendingBatchCount()).toBe(0);
+  });
+
+  it('below size boundary: notifications stay queued', async () => {
+    const items = enqueue(3, 'below');
+    for (const n of items) {
+      await service.deliver(n, ctx);
+    }
+    expect(service.getPendingBatchCount()).toBe(3);
+  });
+});
diff --git a/BackendAcademy/src/notifications/providers/email.provider.ts b/BackendAcademy/src/notifications/providers/email.provider.ts
index 9cda86e3a..9aab61c5e 100644
--- a/BackendAcademy/src/notifications/providers/email.provider.ts
+++ b/BackendAcademy/src/notifications/providers/email.provider.ts
@@ -5,6 +5,7 @@ import {
   DeliveryContext,
 } from '../interfaces/notification-provider.interface';
 import { Notification } from '../interfaces/notifications.interface';
+import { sanitiseTemplateValue } from '../email.service';
 
 /**
  * Default fallback values for missing personalization fields.
@@ -26,6 +27,10 @@ const FALLBACKS: Record<string, string> = {
  * Handles sending notifications via email. Supports template-based rendering
  * with fallback content for missing personalization fields so broken
  * or blank email content is never sent to users.
+ *
+ * All user-supplied values are HTML-escaped and dangerous constructs
+ * (script, iframe, etc.) are stripped before interpolation to prevent
+ * XSS attacks in email content.
  */
 @Injectable()
 export class EmailNotificationProvider implements INotificationProvider {
@@ -103,7 +108,7 @@ export class EmailNotificationProvider implements INotificationProvider {
     return true;
   }
 
-  // ── Template rendering with fallback support (#387) ───────────
+  // ── Template rendering with fallback support (#387, Task 2) ────────
 
   /**
    * Renders the email subject, applying personalization fields
@@ -150,14 +155,20 @@ export class EmailNotificationProvider implements INotificationProvider {
    * Replaces {{placeholder}} patterns in text with values from the
    * delivery context, falling back to defaults for any missing fields.
    *
-   * This is the core fix for issue #387: email templates always render
-   * complete, readable content even when user data is incomplete.
+   * Security (Task 2):
+   *  - All interpolated values are HTML-escaped via `sanitiseTemplateValue`
+   *    to prevent XSS when email content is rendered in HTML-capable
+   *    email clients.
+   *  - Dangerous HTML constructs (script, iframe, object, embed) are
+   *    stripped before escaping as a defence-in-depth measure.
+   *  - Unknown or missing placeholders fall back to `[keyName]` for
+   *    predictable, documented behaviour.
    */
   private applyPersonalization(
     text: string,
     context: DeliveryContext,
   ): string {
-    const fields = {
+    const fields: Record<string, string | undefined> = {
       name: context.name,
       email: context.email,
       ...(context.personalization || {}),
@@ -166,7 +177,7 @@ export class EmailNotificationProvider implements INotificationProvider {
     return text.replace(/\{\{(\w+)\}\}/g, (_match, key: string) => {
       const value = fields[key];
       if (value !== undefined && value !== null && value !== '') {
-        return value;
+        return sanitiseTemplateValue(value);
       }
       // Use fallback or a safe placeholder
       return FALLBACKS[key] || `[${key}]`;