diff --git a/apps/admin/locale/en.json b/apps/admin/locale/en.json
index 5d7b14f09..df08bdea2 100644
--- a/apps/admin/locale/en.json
+++ b/apps/admin/locale/en.json
@@ -657,6 +657,8 @@
             "title": "Publish Event",
             "message": "Are you sure you want to publish this event? This will make the results public and visible to everyone.",
             "event-name": "Event: {eventName}",
+            "info": "If SendGrid integration is enabled, emails will be sent to team contacts with their results.",
+            "publishing-progress": "Publishing event...",
             "confirm": "Publish Event",
             "cancel": "Cancel",
             "publishing": "Publishing..."
@@ -666,6 +668,7 @@
             "message": "Download results as a ZIP file? This will include rubrics and scoresheets for all teams registered in this event.",
             "event-name": "Event: {eventName}",
             "info": "The ZIP file will be organized by team slug (e.g.,9999-IL) with PDFs inside each folder.",
+            "generating": "Generating results...",
             "confirm": "Download",
             "cancel": "Cancel",
             "downloading": "Downloading..."
@@ -677,6 +680,7 @@
           "complete-success": "Event completed successfully",
           "complete-error": "Failed to complete event",
           "publish-success": "Event published successfully",
+          "publish-success-with-emails": "Event published successfully! Sent {emailsSent} emails ({emailsFailed} failed).",
           "publish-error": "Failed to publish event",
           "download-success": "Event results downloaded successfully",
           "download-error": "Failed to download event results",
diff --git a/apps/admin/locale/he.json b/apps/admin/locale/he.json
index 5036328c6..d3f89fde1 100644
--- a/apps/admin/locale/he.json
+++ b/apps/admin/locale/he.json
@@ -657,6 +657,8 @@
             "title": "פרסום אירוע",
             "message": "האם אתם בטוחים שברצונכם לפרסם את האירוע? פעולה זו תהפוך את התוצאות לציבוריות ונראות לכולם.",
             "event-name": "אירוע: {eventName}",
+            "info": "אם קיימת אינטגרציה עם SendGrid, יישלחו הודעות דוא\"ל ליצירי קשר של הקבוצה עם התוצאות שלהם.",
+            "publishing-progress": "מפרסם תוצאות...",
             "confirm": "פרסום אירוע",
             "cancel": "ביטול",
             "publishing": "מפרסם..."
@@ -666,6 +668,7 @@
             "message": "להוריד תוצאות כקובץ ZIP? זה יכלול מחווני שיפוט ודפי ניקוד לכל הקבוצות הרשומות באירוע זה.",
             "event-name": "אירוע: {eventName}",
             "info": "קובץ ה-ZIP יהיה מאורגן לפי סימון הקבוצה (לדוגמה, 9999-IL) עם קבצי PDF בתוך כל תיקייה.",
+            "generating": "מייצר תוצאות...",
             "confirm": "הורדה",
             "cancel": "ביטול",
             "downloading": "מוריד..."
@@ -677,6 +680,7 @@
           "complete-success": "האירוע הושלם בהצלחה",
           "complete-error": "סיום האירוע נכשל",
           "publish-success": "האירוע פורסם בהצלחה",
+          "publish-success-with-emails": "האירוע פורסם בהצלחה! נשלחו {emailsSent} הודעות דוא\"ל ({emailsFailed} נכשלו).",
           "publish-error": "פרסום האירוע נכשל",
           "download-success": "תוצאות האירוע הורדו בהצלחה",
           "download-error": "הורדת תוצאות האירוע נכשלה",
diff --git a/apps/admin/locale/pl.json b/apps/admin/locale/pl.json
index 2e195edb0..3665a6779 100644
--- a/apps/admin/locale/pl.json
+++ b/apps/admin/locale/pl.json
@@ -657,6 +657,8 @@
             "title": "Opublikuj wydarzenie",
             "message": "Czy na pewno chcesz opublikować to wydarzenie? Wyniki będą widoczne dla wszystkich.",
             "event-name": "Wydarzenie: {eventName}",
+            "info": "Jeśli integracja SendGrid jest włączona, wiadomości e-mail z wynikami będą wysłane do kontaktów drużyn.",
+            "publishing-progress": "Publikowanie wydarzenia...",
             "confirm": "Opublikuj wydarzenie",
             "cancel": "Anuluj",
             "publishing": "Publikowanie..."
@@ -666,6 +668,7 @@
             "message": "Pobrać wyniki jako plik ZIP? Będzie zawierać rubryki i karty oceny dla wszystkich drużyn zarejestrowanych w tym wydarzeniu.",
             "event-name": "Wydarzenie: {eventName}",
             "info": "Plik ZIP będzie zorganizowany według identyfikatora drużyny (np. 9999-IL) z plikami PDF w każdym folderze.",
+            "generating": "Generowanie wyników...",
             "confirm": "Pobierz",
             "cancel": "Anuluj",
             "downloading": "Pobieranie..."
@@ -677,6 +680,7 @@
           "complete-success": "Wydarzenie zakończono pomyślnie",
           "complete-error": "Nie udało się zakończyć wydarzenia",
           "publish-success": "Wydarzenie opublikowano pomyślnie",
+          "publish-success-with-emails": "Wydarzenie opublikowano pomyślnie! Wysłano {emailsSent} wiadomości e-mail ({emailsFailed} nie powiodło się).",
           "publish-error": "Nie udało się opublikować wydarzenia",
           "download-success": "Wyniki wydarzenia pobrano pomyślnie",
           "download-error": "Nie udało się pobrać wyników wydarzenia",
diff --git a/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/download-results-dialog.tsx b/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/download-results-dialog.tsx
index 396b27608..75f74c916 100644
--- a/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/download-results-dialog.tsx
+++ b/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/download-results-dialog.tsx
@@ -10,13 +10,15 @@ import {
   DialogActions,
   Typography,
   CircularProgress,
-  Stack
+  LinearProgress,
+  Stack,
+  Box
 } from '@mui/material';
 
 interface DownloadResultsDialogProps {
   open: boolean;
   onClose: () => void;
-  onConfirm: () => Promise<void>;
+  onConfirm: (onProgress: (percent: number) => void) => Promise<void>;
   eventName: string;
 }
 
@@ -27,14 +29,17 @@ export const DownloadResultsDialog: React.FC<DownloadResultsDialogProps> = ({
   eventName
 }) => {
   const [isDownloading, setIsDownloading] = useState(false);
+  const [progress, setProgress] = useState<number | null>(null);
   const t = useTranslations('pages.events.settings.dialogs.download-results');
 
   const handleConfirm = async () => {
     setIsDownloading(true);
+    setProgress(0);
     try {
-      await onConfirm();
+      await onConfirm(setProgress);
     } finally {
       setIsDownloading(false);
+      setProgress(null);
     }
   };
 
@@ -50,6 +55,14 @@ export const DownloadResultsDialog: React.FC<DownloadResultsDialogProps> = ({
           <Typography variant="caption" color="text.secondary">
             {t('info')}
           </Typography>
+          {progress !== null && (
+            <Box>
+              <Typography variant="caption" color="text.secondary">
+                {t('generating')}
+              </Typography>
+              <LinearProgress variant="determinate" value={progress} sx={{ mt: 0.5 }} />
+            </Box>
+          )}
         </Stack>
       </DialogContent>
       <DialogActions>
diff --git a/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/event-actions-section.tsx b/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/event-actions-section.tsx
index 8e8b8ed99..d95873f81 100644
--- a/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/event-actions-section.tsx
+++ b/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/event-actions-section.tsx
@@ -5,7 +5,7 @@ import { KeyedMutator } from 'swr';
 import { useLocale, useTranslations } from 'next-intl';
 import { Box, Card, CardContent, Typography, Button, Divider, Stack } from '@mui/material';
 import { EventSettings } from '@lems/types/api/admin';
-import { apiFetch } from '@lems/shared';
+import { apiFetch, connectSseStream, getApiBase } from '@lems/shared';
 import { useEvent } from '../../components/event-context';
 import { CompleteEventDialog } from './complete-event-dialog';
 import { PublishEventDialog } from './publish-event-dialog';
@@ -29,7 +29,6 @@ export const EventActionsSection: React.FC<EventActionsSectionProps> = ({
   const [completeDialogOpen, setCompleteDialogOpen] = useState(false);
   const [publishDialogOpen, setPublishDialogOpen] = useState(false);
   const [downloadDialogOpen, setDownloadDialogOpen] = useState(false);
-  const [isDownloadLoading, setIsDownloadLoading] = useState(false);
 
   const handleCompleteEvent = async () => {
     setAlert(null);
@@ -50,57 +49,71 @@ export const EventActionsSection: React.FC<EventActionsSectionProps> = ({
     }
   };
 
-  const handlePublishEvent = async () => {
+  const handlePublishEvent = async (onProgress: (percent: number, message?: string) => void) => {
     setAlert(null);
     try {
-      const response = await apiFetch(`/admin/events/${event.id}/settings/publish`, {
-        method: 'POST'
-      });
+      const result = await connectSseStream<{
+        published: boolean;
+        emailsSent: number;
+        emailsFailed: number;
+        failedEmails?: string[];
+      }>(
+        `/admin/events/${event.id}/settings/publish`,
+        { method: 'POST' },
+        {
+          onStart: () => onProgress(0),
+          onProgress: (percent, message) => onProgress(percent, message)
+        }
+      );
 
-      if (response.ok) {
+      if (result?.published) {
         await mutateSettings();
-        setAlert({ type: 'success', message: t('messages.publish-success') });
+        const successMsg =
+          result.emailsSent > 0
+            ? t('messages.publish-success-with-emails', {
+                emailsSent: result.emailsSent,
+                emailsFailed: result.emailsFailed
+              })
+            : t('messages.publish-success');
+        setAlert({ type: 'success', message: successMsg });
         setPublishDialogOpen(false);
       } else {
         setAlert({ type: 'error', message: t('messages.publish-error') });
       }
-    } catch {
-      setAlert({ type: 'error', message: t('messages.publish-error') });
+    } catch (error) {
+      const errorMsg =
+        error instanceof Error ? error.message : t('messages.publish-error');
+      setAlert({ type: 'error', message: errorMsg });
     }
   };
 
-  const handleDownloadResults = async () => {
+  const handleDownloadResults = async (onProgress: (percent: number) => void) => {
     setAlert(null);
-    setIsDownloadLoading(true);
     try {
-      const response = await apiFetch(
+      const result = await connectSseStream<{ token: string }>(
         `/admin/events/${event.id}/settings/download?language=${locale}`,
+        { method: 'POST' },
         {
-          method: 'POST',
-          responseType: 'binary'
+          onStart: () => onProgress(0),
+          onProgress
         }
       );
 
-      if (response.ok) {
-        const blob = response.data as Blob;
-        const url = window.URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = `${event.name.replace(/\s+/g, '_')}-results.zip`;
-        document.body.appendChild(a);
-        a.click();
-        a.remove();
-        window.URL.revokeObjectURL(url);
-
-        setAlert({ type: 'success', message: t('messages.download-success') });
-        setDownloadDialogOpen(false);
-      } else {
+      if (!result?.token) {
         setAlert({ type: 'error', message: t('messages.download-error') });
+        return;
       }
+
+      const a = document.createElement('a');
+      a.href = `${getApiBase(true)}/admin/events/${event.id}/settings/download/file?token=${result.token}`;
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+
+      setAlert({ type: 'success', message: t('messages.download-success') });
+      setDownloadDialogOpen(false);
     } catch {
       setAlert({ type: 'error', message: t('messages.download-error') });
-    } finally {
-      setIsDownloadLoading(false);
     }
   };
 
@@ -173,7 +186,6 @@ export const EventActionsSection: React.FC<EventActionsSectionProps> = ({
                   disabled={!settings.published}
                   onClick={() => setDownloadDialogOpen(true)}
                   sx={{ minWidth: 160 }}
-                  loading={isDownloadLoading}
                 >
                   {t('event-actions.download-results')}
                 </Button>
diff --git a/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/publish-event-dialog.tsx b/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/publish-event-dialog.tsx
index 489a2c4f6..187ceabd1 100644
--- a/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/publish-event-dialog.tsx
+++ b/apps/admin/src/app/[locale]/(dashboard)/events/[slug]/settings/components/publish-event-dialog.tsx
@@ -9,13 +9,17 @@ import {
   DialogContent,
   DialogActions,
   Typography,
-  CircularProgress
+  CircularProgress,
+  LinearProgress,
+  Stack,
+  Box,
+  Alert
 } from '@mui/material';
 
 interface PublishEventDialogProps {
   open: boolean;
   onClose: () => void;
-  onConfirm: () => Promise<void>;
+  onConfirm: (onProgress: (percent: number, message?: string) => void) => Promise<void>;
   eventName: string;
 }
 
@@ -26,14 +30,23 @@ export const PublishEventDialog: React.FC<PublishEventDialogProps> = ({
   eventName
 }) => {
   const [isPublishing, setIsPublishing] = useState(false);
+  const [progress, setProgress] = useState<number | null>(null);
+  const [progressMessage, setProgressMessage] = useState<string | null>(null);
   const t = useTranslations('pages.events.settings.dialogs.publish-event');
 
   const handleConfirm = async () => {
     setIsPublishing(true);
+    setProgress(0);
+    setProgressMessage(null);
     try {
-      await onConfirm();
+      await onConfirm((percent, message) => {
+        setProgress(percent);
+        if (message) setProgressMessage(message);
+      });
     } finally {
       setIsPublishing(false);
+      setProgress(null);
+      setProgressMessage(null);
     }
   };
 
@@ -41,12 +54,34 @@ export const PublishEventDialog: React.FC<PublishEventDialogProps> = ({
     <Dialog open={open} onClose={isPublishing ? undefined : onClose} maxWidth="sm" fullWidth>
       <DialogTitle>{t('title')}</DialogTitle>
       <DialogContent>
-        <Typography>
-          {t('message')}
-        </Typography>
-        <Typography variant="body2" sx={{ mt: 2, fontWeight: 'bold' }}>
-          {t('event-name', { eventName })}
-        </Typography>
+        <Stack spacing={2}>
+          <Typography>{t('message')}</Typography>
+          <Typography variant="body2" sx={{ fontWeight: 'bold' }}>
+            {t('event-name', { eventName })}
+          </Typography>
+          <Typography variant="caption" color="text.secondary">
+            {t('info')}
+          </Typography>
+          {progress !== null && (
+            <Box>
+              {progressMessage ? (
+                <Alert severity="info" sx={{ mb: 1 }}>
+                  <Typography variant="caption" sx={{ display: 'block', mb: 1 }}>
+                    {progressMessage}
+                  </Typography>
+                  <LinearProgress variant="determinate" value={progress} />
+                </Alert>
+              ) : (
+                <Box>
+                  <Typography variant="caption" color="text.secondary">
+                    {t('publishing-progress')}
+                  </Typography>
+                  <LinearProgress variant="determinate" value={progress} sx={{ mt: 0.5 }} />
+                </Box>
+              )}
+            </Box>
+          )}
+        </Stack>
       </DialogContent>
       <DialogActions>
         <Button onClick={onClose} disabled={isPublishing}>
diff --git a/apps/backend/src/lib/results-download.ts b/apps/backend/src/lib/results-download.ts
index 877db51f2..ec943c85f 100644
--- a/apps/backend/src/lib/results-download.ts
+++ b/apps/backend/src/lib/results-download.ts
@@ -102,14 +102,19 @@ async function getZippedResults(
   eventSlug: string,
   archive: archiver.Archiver,
   language: string,
+  onProgress?: (percent: number) => void,
   batchSize: number = 10
 ): Promise<{
   totalTeams: number;
   teamsWithPdfs: number;
   failedPdfs: number;
 }> {
+  const registeredTeams = await db.events.byId(eventId).getRegisteredTeams();
+  const totalTeamCount = registeredTeams.length;
+
   const teamsWithResults = new Set<string>();
   let totalTeams = 0;
+  let teamsProcessed = 0;
   let failedPdfs = 0;
   let batchNumber = 0;
 
@@ -153,6 +158,11 @@ async function getZippedResults(
       } else {
         failedPdfs++;
       }
+
+      teamsProcessed++;
+      if (totalTeamCount > 0) {
+        onProgress?.(Math.round((teamsProcessed / totalTeamCount) * 100));
+      }
     }
 
     console.info(
@@ -189,7 +199,8 @@ async function getZippedResults(
  */
 export async function generateEventResultsZip(
   eventId: string,
-  language: string = 'en'
+  language: string = 'en',
+  onProgress?: (percent: number) => void
 ): Promise<{
   archive: archiver.Archiver;
   fileName: string;
@@ -210,6 +221,7 @@ export async function generateEventResultsZip(
     event.slug,
     archive,
     language,
+    onProgress,
     5 // Process 5 teams at a time
   );
 
diff --git a/apps/backend/src/lib/sse.ts b/apps/backend/src/lib/sse.ts
new file mode 100644
index 000000000..b4558368e
--- /dev/null
+++ b/apps/backend/src/lib/sse.ts
@@ -0,0 +1,55 @@
+import { Response } from 'express';
+import type { SseEvent } from '@lems/shared';
+
+export interface SseEmitter {
+  sendStart(): void;
+  sendProgress(percent: number, message?: string): void;
+  sendSuccess<T>(data?: T): void;
+  sendFailure(message: string): void;
+}
+
+export function createSseEmitter(res: Response): SseEmitter {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.flushHeaders();
+
+  let closed = false;
+
+  res.on('close', () => {
+    closed = true;
+  });
+
+  const write = (payload: SseEvent) => {
+    if (closed || res.writableEnded || res.destroyed) {
+      return;
+    }
+
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+  };
+
+  const end = () => {
+    if (closed || res.writableEnded || res.destroyed) {
+      return;
+    }
+
+    res.end();
+  };
+
+  return {
+    sendStart() {
+      write({ type: 'start' });
+    },
+    sendProgress(percent, message) {
+      write({ type: 'progress', percent, message });
+    },
+    sendSuccess(data) {
+      write({ type: 'success', data });
+      end();
+    },
+    sendFailure(message) {
+      write({ type: 'failure', message });
+      end();
+    }
+  };
+}
diff --git a/apps/backend/src/lib/temp-download-store.ts b/apps/backend/src/lib/temp-download-store.ts
new file mode 100644
index 000000000..0b42ad28e
--- /dev/null
+++ b/apps/backend/src/lib/temp-download-store.ts
@@ -0,0 +1,36 @@
+import fs from 'fs';
+import crypto from 'crypto';
+
+const TTL_MS = 30 * 60 * 1000; // 30 minutes
+
+interface TempFileEntry {
+  filePath: string;
+  fileName: string;
+  createdAt: number;
+}
+
+const store = new Map<string, TempFileEntry>();
+
+function purgeTtl(): void {
+  const now = Date.now();
+  for (const [token, entry] of store.entries()) {
+    if (now - entry.createdAt > TTL_MS) {
+      fs.unlink(entry.filePath, () => {});
+      store.delete(token);
+    }
+  }
+}
+
+export function storeTempFile(filePath: string, fileName: string): string {
+  purgeTtl();
+  const token = crypto.randomUUID();
+  store.set(token, { filePath, fileName, createdAt: Date.now() });
+  return token;
+}
+
+export function consumeTempFile(token: string): TempFileEntry | null {
+  purgeTtl();
+  const entry = store.get(token) ?? null;
+  if (entry) store.delete(token);
+  return entry;
+}
diff --git a/apps/backend/src/routers/admin/events/settings/index.ts b/apps/backend/src/routers/admin/events/settings/index.ts
index 0be1b92f3..b68037ada 100644
--- a/apps/backend/src/routers/admin/events/settings/index.ts
+++ b/apps/backend/src/routers/admin/events/settings/index.ts
@@ -1,15 +1,41 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
 import express from 'express';
+import rateLimit from 'express-rate-limit';
 import { IntegrationTypes } from '@lems/shared/integrations';
 import db from '../../../../lib/database';
 import { AdminEventRequest } from '../../../../types/express';
 import { publishEventResults } from '../../../integrations/sendgrid/publish';
 import { generateEventResultsZip } from '../../../../lib/results-download';
+import { createSseEmitter } from '../../../../lib/sse';
+import { storeTempFile, consumeTempFile } from '../../../../lib/temp-download-store';
 import { makeAdminSettingsResponse, makeUpdateableEventSettings } from './util';
 
 const router = express.Router({ mergeParams: true });
 
+const downloadRateLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 10,
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
+const downloadFileRateLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 30,
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
 router.get('/', async (req: AdminEventRequest, res) => {
   const settings = await db.events.byId(req.eventId).getSettings();
+  if (!settings) {
+    res.status(404).json({ error: 'Event not found' });
+    return;
+  }
+
   res.json(makeAdminSettingsResponse(settings));
 });
 
@@ -31,13 +57,22 @@ router.post('/complete', async (req: AdminEventRequest, res) => {
 });
 
 router.post('/publish', async (req: AdminEventRequest, res) => {
+  const emitter = createSseEmitter(res);
+
   try {
     const settings = await db.events.byId(req.eventId).getSettings();
+    if (!settings) {
+      emitter.sendFailure('Event not found');
+      return;
+    }
+
     if (!settings.completed) {
-      res.status(400).json({ error: 'Event must be completed before publishing' });
+      emitter.sendFailure('Event must be completed before publishing');
       return;
     }
 
+    emitter.sendStart();
+
     const updatedSettings = await db.events.byId(req.eventId).updateSettings({ published: true });
     if (!updatedSettings) {
       throw new Error('Failed to publish event');
@@ -51,28 +86,63 @@ router.post('/publish', async (req: AdminEventRequest, res) => {
 
     if (sendgridIntegration) {
       try {
-        await publishEventResults({
+        const emailResult = await publishEventResults({
           eventId: req.eventId,
-          settings: sendgridIntegration.settings
+          settings: sendgridIntegration.settings,
+          onProgress: (percent, message) => emitter.sendProgress(percent, message)
+        });
+        console.info(
+          `Event ${req.eventId} published with emails sent. ` +
+            `Total: ${emailResult.total}, Failed: ${emailResult.failed}`
+        );
+        emitter.sendSuccess({
+          published: true,
+          emailsSent: emailResult.total,
+          emailsFailed: emailResult.failed,
+          failedEmails: emailResult.failedEmails
         });
       } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
         console.error('Error sending SendGrid emails:', error);
-        // Don't fail the publish - log the error but continue
+        emitter.sendFailure(`Failed to send emails: ${message}`);
       }
+    } else {
+      console.info(`Event ${req.eventId} published`);
+      emitter.sendSuccess({
+        published: true,
+        emailsSent: 0,
+        emailsFailed: 0
+      });
     }
-
-    res.json({ success: true });
   } catch (error) {
-    console.error('Error publishing event:', error);
-    res.status(500).json({ error: 'Failed to publish event' });
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error publishing event ${req.eventId}: ${message}`, error);
+    emitter.sendFailure(`Failed to publish event: ${message}`);
   }
 });
 
-router.post('/download', async (req: AdminEventRequest, res) => {
+router.post('/download', downloadRateLimiter, async (req: AdminEventRequest, res) => {
+  const emitter = createSseEmitter(res);
+  let tempPath: string | undefined;
+  let fileStream: fs.WriteStream | undefined;
+  let archive:
+    | (NodeJS.ReadableStream & {
+        on(event: 'error', listener: (error: Error) => void): unknown;
+        pipe<T extends NodeJS.WritableStream>(destination: T): T;
+        finalize(): unknown;
+        destroy?: (error?: Error) => void;
+      })
+    | undefined;
+
   try {
     const settings = await db.events.byId(req.eventId).getSettings();
+    if (!settings) {
+      emitter.sendFailure('Event not found');
+      return;
+    }
+
     if (!settings.published) {
-      res.status(400).json({ error: 'Event must be published before downloading results' });
+      emitter.sendFailure('Event must be published before downloading results');
       return;
     }
 
@@ -81,43 +151,82 @@ router.post('/download', async (req: AdminEventRequest, res) => {
       `Starting results ZIP generation for event ${req.eventId} (language: ${language})`
     );
 
-    const { archive, fileName, statistics } = await generateEventResultsZip(req.eventId, language);
+    emitter.sendStart();
+
+    const result = await generateEventResultsZip(
+      req.eventId,
+      language,
+      percent => emitter.sendProgress(percent)
+    );
+    archive = result.archive;
+    const { fileName, statistics } = result;
 
     if (statistics.teamsWithPdfs === 0) {
       console.error(
         `CRITICAL: Event ${req.eventId} generated an empty ZIP with 0 successful PDFs. ` +
-          `Total teams: ${statistics.totalTeams}, Failed PDFs: ${statistics.failedPdfs}. ` +
-          `Check backend logs for PDF generation errors.`
+          `Total teams: ${statistics.totalTeams}, Failed PDFs: ${statistics.failedPdfs}.`
       );
-      res.status(500).json({
-        error: 'Failed to generate results: no PDFs were created.'
-      });
+      emitter.sendFailure('Failed to generate results: no PDFs were created.');
       return;
     }
 
     console.info(
-      `Results ZIP ready for download: ${fileName} ` +
+      `Results ZIP ready: ${fileName} ` +
         `(${statistics.teamsWithPdfs}/${statistics.totalTeams} teams with PDFs, ${statistics.failedPdfs} failed PDFs)`
     );
 
-    res.attachment(fileName);
-    res.setHeader('Content-Type', 'application/zip');
+    tempPath = path.join(os.tmpdir(), `${crypto.randomUUID()}.zip`);
+    fileStream = fs.createWriteStream(tempPath);
 
-    archive.on('error', err => {
-      console.error(`Archive error while generating ${fileName}:`, err);
-      // Note: Cannot send JSON response here - headers already sent
+    await new Promise<void>((resolve, reject) => {
+      fileStream!.on('finish', resolve);
+      fileStream!.on('error', reject);
+      archive!.on('error', reject);
+      archive!.pipe(fileStream!);
+      archive!.finalize();
     });
 
-    archive.pipe(res);
-    await archive.finalize();
+    const token = storeTempFile(tempPath, fileName);
+    emitter.sendSuccess({ token });
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(
-      `Error downloading event results for event ${req.eventId}: ${errorMessage}`,
-      error
-    );
-    res.status(500).json({ error: `Failed to download event results: ${errorMessage}` });
+    archive?.destroy?.(error instanceof Error ? error : undefined);
+    fileStream?.destroy(error instanceof Error ? error : undefined);
+
+    if (tempPath) {
+      try {
+        await fs.promises.unlink(tempPath);
+      } catch (unlinkError) {
+        if ((unlinkError as NodeJS.ErrnoException).code !== 'ENOENT') {
+          console.error(
+            `Failed to clean up temporary results ZIP for event ${req.eventId}: ${tempPath}`,
+            unlinkError
+          );
+        }
+      }
+    }
+
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error downloading event results for event ${req.eventId}: ${message}`, error);
+    emitter.sendFailure(`Failed to download event results: ${message}`);
+  }
+});
+
+router.get('/download/file', downloadFileRateLimiter, (req: AdminEventRequest, res) => {
+  const token = req.query.token as string;
+  if (!token) {
+    res.status(400).json({ error: 'Missing token' });
+    return;
+  }
+
+  const entry = consumeTempFile(token);
+  if (!entry) {
+    res.status(404).json({ error: 'Token not found or expired' });
+    return;
   }
+
+  res.download(entry.filePath, entry.fileName, () => {
+    fs.unlink(entry.filePath, () => {});
+  });
 });
 
 export default router;
diff --git a/apps/backend/src/routers/integrations/sendgrid/publish.ts b/apps/backend/src/routers/integrations/sendgrid/publish.ts
index dc382671a..b59c363dd 100644
--- a/apps/backend/src/routers/integrations/sendgrid/publish.ts
+++ b/apps/backend/src/routers/integrations/sendgrid/publish.ts
@@ -8,15 +8,21 @@ import { CSVRecord } from './types';
 export interface SendGridPublishOptions {
   eventId: string;
   settings: Record<string, unknown>;
+  onProgress?: (percent: number, message?: string) => void;
 }
 
-const apiKey = process.env.SENDGRID_API_KEY;
-
 const sendEmailToContact = async (
   event: Event,
   contact: CSVRecord,
   emailOptions: { templateId: string; fromAddress: string; language: string }
 ) => {
+  const apiKey = process.env.SENDGRID_API_KEY;
+
+  if (!apiKey) {
+    console.warn('SendGrid API key not configured. Skipping email sending.');
+    return { success: false, email: contact.recipient_email };
+  }
+
   const { templateId, fromAddress, language } = emailOptions;
 
   const teamNumber = parseInt(contact.team_number, 10);
@@ -78,7 +84,7 @@ const sendEmailToContact = async (
 };
 
 export async function publishEventResults(options: SendGridPublishOptions) {
-  const { eventId, settings } = options;
+  const { eventId, settings, onProgress } = options;
 
   if (!settings) {
     throw new Error('Missing integration settings');
@@ -118,7 +124,10 @@ export async function publishEventResults(options: SendGridPublishOptions) {
 
   for (const contact of contacts as CSVRecord[]) {
     emailCount++;
-    console.info(`Sending email ${emailCount}/${contacts.length}...`);
+    const percent = Math.round((emailCount / contacts.length) * 100);
+    const message = `Sending email ${emailCount}/${contacts.length}...`;
+    console.info(message);
+    onProgress?.(percent, message);
 
     const result = await sendEmailToContact(event, contact as CSVRecord, {
       templateId: String(templateId),
@@ -129,7 +138,7 @@ export async function publishEventResults(options: SendGridPublishOptions) {
     results.push(result);
 
     if (!result.success) {
-      console.warn(`✗ Failed to send email`);
+      console.warn(`✗ Failed to send email to ${contact.recipient_email}`);
     }
   }
 
diff --git a/libs/shared/src/index.ts b/libs/shared/src/index.ts
index 5583c6ad2..ea0b40283 100644
--- a/libs/shared/src/index.ts
+++ b/libs/shared/src/index.ts
@@ -1,6 +1,7 @@
 export * from './lib/components';
 export * from './lib/hooks';
 export * from './lib/fetch';
+export * from './lib/sse';
 export * from './lib/swr-provider';
 export * from './lib/awards';
 export * from './lib/deliberation';
diff --git a/libs/shared/src/lib/sse.ts b/libs/shared/src/lib/sse.ts
new file mode 100644
index 000000000..5266a6885
--- /dev/null
+++ b/libs/shared/src/lib/sse.ts
@@ -0,0 +1,89 @@
+import { getApiBase } from './fetch';
+
+export type SseEvent<T = unknown> =
+  | { type: 'start' }
+  | { type: 'progress'; percent: number; message?: string }
+  | { type: 'success'; data?: T }
+  | { type: 'failure'; message: string };
+
+/**
+ * Opens an SSE stream to the backend using a fetch-based approach.
+ * Supports POST (and other methods), unlike native EventSource which only supports GET.
+ * Automatically includes credentials and the CSRF bypass header.
+ *
+ * @param path - API path (e.g. '/admin/events/123/settings/download')
+ * @param init - Optional fetch RequestInit options (method, headers, body, etc.)
+ * @param handlers - Optional callbacks for `start` and `progress` events
+ * @returns A Promise that resolves with the `success` event data, or rejects on `failure`
+ */
+export async function connectSseStream<T = unknown>(
+  path: string,
+  init?: RequestInit,
+  handlers?: {
+    onStart?: () => void;
+    onProgress?: (percent: number, message?: string) => void;
+  }
+): Promise<T | undefined> {
+  const headers = new Headers(init?.headers);
+  headers.set('x-lems-csrf-enabled', 'true');
+
+  const response = await fetch(getApiBase() + path, {
+    ...init,
+    credentials: 'include',
+    headers
+  });
+
+  if (!response.ok || !response.body) {
+    throw new Error(`SSE request failed: ${response.status} ${response.statusText}`);
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      const parts = buffer.split('\n\n');
+      buffer = parts.pop() ?? '';
+
+      for (const part of parts) {
+        const line = part.trim();
+        if (!line.startsWith('data: ')) continue;
+
+        const event: SseEvent<T> = JSON.parse(line.slice(6));
+
+        switch (event.type) {
+          case 'start':
+            handlers?.onStart?.();
+            break;
+          case 'progress':
+            handlers?.onProgress?.(event.percent, event.message);
+            break;
+          case 'success':
+            return event.data as T;
+          case 'failure':
+            throw new Error(event.message);
+        }
+      }
+    }
+
+    return undefined;
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+      // Best-effort cleanup; preserve the original return value or error.
+    }
+
+    try {
+      reader.releaseLock();
+    } catch {
+      // Best-effort cleanup; preserve the original return value or error.
+    }
+  }
+}