diff --git a/docs/frontend/rich-text-editor.md b/docs/frontend/rich-text-editor.md
index 81c2b2d2..7d5c0ea6 100644
--- a/docs/frontend/rich-text-editor.md
+++ b/docs/frontend/rich-text-editor.md
@@ -46,6 +46,7 @@ import { RichTextEditor } from '@/components/markdown/RichTextEditor';
 | `className` | `string` | Extra container classes |
 | `maxLength` | `number` | Shows a counter and truncates input |
 | `allowImages` | `boolean` | Toggle image insertion (default `true`) |
+| `showHtmlToggle` | `boolean` | Show the *HTML* view toggle (default `true`, issue #90) |
 | `onBlur` | `() => void` | Forwarded to the textarea (react-hook-form support) |
 | `aria-invalid` / `aria-describedby` | — | Forwarded for validation messaging |
 
@@ -71,8 +72,49 @@ the server-side `POST /api/v1/uploads` endpoint and reference the returned URL.
 The *Preview* toggle renders the markdown through `MarkdownContent` with
 sanitization enabled, so raw HTML and unsafe links are stripped before display.
 
+## HTML view and "save as HTML" (issue #90)
+
+The *HTML* toggle shows the sanitized HTML rendition of the current description
+with a **Copy HTML** button. The conversion lives in
+`frontend/lib/markdown/to-html.ts` (`markdownToHtml`), and the persisted payload
+is built by `frontend/lib/projects/work-description.ts` — both
+`/dashboard/projects/new` and its localized variant call
+`serializeWorkDescription`, so the on-chain shape stays consistent:
+
+```ts
+serializeWorkDescription({ title, description, repo });
+// => {
+//   title,
+//   description,       // markdown source of truth (issue #795)
+//   descriptionHtml,   // sanitized HTML rendition (issue #90)
+//   repo,
+// }
+```
+
+### Why a local serializer
+
+The preview renders with `react-markdown`, but the project does not depend on a
+markdown *stringifier* (`rehype-stringify`), and adding one purely for this would
+be a heavier change than the feature warrants. `to-html.ts` therefore covers the
+subset the editor can produce — headings, emphasis, strikethrough, inline and
+fenced code, links, images, lists, quotes and rules — and is dependency-free.
+
+Both paths share the same security posture:
+
+- raw HTML is never passed through — every text run is escaped, so `<script>`
+  becomes `&lt;script&gt;`;
+- only `http:`, `https:` and `mailto:` URLs are emitted (plus anything passed via
+  `allowedProtocols`); `javascript:`, `data:`, `vbscript:` and protocol-relative
+  URLs are dropped, and external links get `rel="noopener noreferrer"`;
+- images additionally use `loading="lazy"`.
+
 ## Tests
 
 `frontend/components/markdown/__tests__/RichTextEditor.test.tsx` covers
 formatting, list prefixes, image insertion/validation, preview rendering, the
 character limit, and the disabled state.
+
+`frontend/lib/markdown/__tests__/to-html.test.ts` and
+`frontend/lib/projects/__tests__/work-description.test.ts` cover the HTML
+rendition, including injection attempts and URL-scheme filtering, plus the
+"save as HTML" payload.
diff --git a/frontend/app/[locale]/dashboard/projects/new/page.tsx b/frontend/app/[locale]/dashboard/projects/new/page.tsx
index c60e3993..a8fe92d6 100644
--- a/frontend/app/[locale]/dashboard/projects/new/page.tsx
+++ b/frontend/app/[locale]/dashboard/projects/new/page.tsx
@@ -23,6 +23,7 @@ import { useAgenticPay } from '@/lib/hooks/useAgenticPay';
 import { useAccount } from 'wagmi';
 import { ConfirmModal } from '@/components/transaction/ConfirmModal';
 import { RichTextEditor } from '@/components/markdown/RichTextEditor';
+import { serializeWorkDescription } from '@/lib/projects/work-description';
 import { parseEther } from 'viem';
 
 type PendingTransaction = {
@@ -197,10 +198,13 @@ export default function CreateProjectPage() {
       // or just use description. The contract takes `_workDescription`.
       // Let's use JSON format for better structure if we want to include milestones later, 
       // but for now just a string.
-      const workDesc = JSON.stringify({
+      // Descriptions are authored as markdown (issue #795) and persisted as
+      // both markdown and HTML (issue #90) so consumers that cannot render
+      // markdown can display the description directly.
+      const workDesc = serializeWorkDescription({
         title: data.title,
         description: data.description,
-        repo: data.githubRepo
+        repo: data.githubRepo,
       });
 
       const prepared = await prepareTransaction('createProject', [
diff --git a/frontend/app/dashboard/projects/new/page.tsx b/frontend/app/dashboard/projects/new/page.tsx
index c60e3993..a8fe92d6 100644
--- a/frontend/app/dashboard/projects/new/page.tsx
+++ b/frontend/app/dashboard/projects/new/page.tsx
@@ -23,6 +23,7 @@ import { useAgenticPay } from '@/lib/hooks/useAgenticPay';
 import { useAccount } from 'wagmi';
 import { ConfirmModal } from '@/components/transaction/ConfirmModal';
 import { RichTextEditor } from '@/components/markdown/RichTextEditor';
+import { serializeWorkDescription } from '@/lib/projects/work-description';
 import { parseEther } from 'viem';
 
 type PendingTransaction = {
@@ -197,10 +198,13 @@ export default function CreateProjectPage() {
       // or just use description. The contract takes `_workDescription`.
       // Let's use JSON format for better structure if we want to include milestones later, 
       // but for now just a string.
-      const workDesc = JSON.stringify({
+      // Descriptions are authored as markdown (issue #795) and persisted as
+      // both markdown and HTML (issue #90) so consumers that cannot render
+      // markdown can display the description directly.
+      const workDesc = serializeWorkDescription({
         title: data.title,
         description: data.description,
-        repo: data.githubRepo
+        repo: data.githubRepo,
       });
 
       const prepared = await prepareTransaction('createProject', [
diff --git a/frontend/components/markdown/RichTextEditor.tsx b/frontend/components/markdown/RichTextEditor.tsx
index 48beedda..e25c1b47 100644
--- a/frontend/components/markdown/RichTextEditor.tsx
+++ b/frontend/components/markdown/RichTextEditor.tsx
@@ -13,6 +13,7 @@
 
 import {
   useCallback,
+  useMemo,
   useRef,
   useState,
   type ChangeEvent,
@@ -40,6 +41,7 @@ import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
 import { Textarea } from '@/components/ui/textarea';
 import { MarkdownContent } from '@/components/markdown/MarkdownContent';
+import { markdownToHtml } from '@/lib/markdown/to-html';
 import { cn } from '@/lib/utils';
 
 const MAX_IMAGE_BYTES = 5 * 1024 * 1024; // 5MB
@@ -86,6 +88,8 @@ export interface RichTextEditorProps {
   maxLength?: number;
   /** Allow inserting images (URL or drag/drop). Defaults to true. */
   allowImages?: boolean;
+  /** Also surface the description as HTML (see the HTML view toggle, issue #90). */
+  showHtmlToggle?: boolean;
   onBlur?: () => void;
   'aria-invalid'?: boolean;
   'aria-describedby'?: string;
@@ -146,12 +150,15 @@ export function RichTextEditor({
   className,
   maxLength,
   allowImages = true,
+  showHtmlToggle = true,
   onBlur,
   'aria-invalid': ariaInvalid,
   'aria-describedby': ariaDescribedBy,
 }: RichTextEditorProps) {
   const textareaRef = useRef<HTMLTextAreaElement | null>(null);
   const [showPreview, setShowPreview] = useState(false);
+  const [showHtml, setShowHtml] = useState(false);
+  const [copiedHtml, setCopiedHtml] = useState(false);
   const [showImageForm, setShowImageForm] = useState(false);
   const [imageUrl, setImageUrl] = useState('');
   const [imageAlt, setImageAlt] = useState('');
@@ -305,6 +312,18 @@ export function RichTextEditor({
     }
   };
 
+  // The HTML rendition of the description, i.e. what "save as HTML" persists.
+  const html = useMemo(() => markdownToHtml(value, { allowImages }), [value, allowImages]);
+
+  const handleCopyHtml = () => {
+    const clipboard = typeof navigator === 'undefined' ? undefined : navigator.clipboard;
+    if (!clipboard) return;
+    void clipboard.writeText(html).then(
+      () => setCopiedHtml(true),
+      () => setCopiedHtml(false),
+    );
+  };
+
   const sourceLength = value.length;
 
   return (
@@ -354,6 +373,27 @@ export function RichTextEditor({
             {showPreview ? <Pencil className="h-3.5 w-3.5" /> : <Eye className="h-3.5 w-3.5" />}
             {showPreview ? 'Edit' : 'Preview'}
           </Button>
+
+          {showHtmlToggle && (
+            <Button
+              type="button"
+              size="sm"
+              variant={showHtml ? 'default' : 'ghost'}
+              className="h-8 gap-1 px-2 text-xs"
+              aria-pressed={showHtml}
+              aria-label="View HTML"
+              title="View the generated HTML"
+              disabled={disabled}
+              onClick={() => {
+                setShowHtml((open) => !open);
+                setShowPreview(false);
+                setCopiedHtml(false);
+              }}
+            >
+              <Code className="h-3.5 w-3.5" />
+              HTML
+            </Button>
+          )}
         </div>
       </div>
 
@@ -405,7 +445,29 @@ export function RichTextEditor({
         </div>
       )}
 
-      {showPreview ? (
+      {showHtml ? (
+        <div className="space-y-2 p-3" data-testid="rich-text-html">
+          {value.trim() ? (
+            <>
+              <textarea
+                readOnly
+                rows={8}
+                aria-label="HTML output"
+                className="w-full resize-y rounded-md border bg-muted/40 p-2 font-mono text-xs"
+                value={html}
+              />
+              <div className="flex items-center gap-2">
+                <Button type="button" size="sm" variant="outline" onClick={handleCopyHtml}>
+                  Copy HTML
+                </Button>
+                {copiedHtml && <span className="text-xs text-muted-foreground">Copied</span>}
+              </div>
+            </>
+          ) : (
+            <p className="text-sm text-muted-foreground">Nothing to convert yet.</p>
+          )}
+        </div>
+      ) : showPreview ? (
         <div className="min-h-[120px] p-3" data-testid="rich-text-preview">
           {value.trim() ? (
             <MarkdownContent content={value} previewMode={false} />
diff --git a/frontend/lib/markdown/__tests__/to-html.test.ts b/frontend/lib/markdown/__tests__/to-html.test.ts
new file mode 100644
index 00000000..dcb1f974
--- /dev/null
+++ b/frontend/lib/markdown/__tests__/to-html.test.ts
@@ -0,0 +1,166 @@
+/**
+ * markdownToHtml tests — Issue #90 ("Save as HTML")
+ */
+import { describe, expect, it } from 'vitest';
+
+import { escapeHtml, markdownToHtml } from '@/lib/markdown/to-html';
+
+describe('markdownToHtml — block structure', () => {
+  it('returns an empty string for empty input', () => {
+    expect(markdownToHtml('')).toBe('');
+    expect(markdownToHtml('   \n\n  ')).toBe('');
+  });
+
+  it('wraps plain text in a paragraph', () => {
+    expect(markdownToHtml('Hello world')).toBe('<p>Hello world</p>');
+  });
+
+  it('joins consecutive lines into one paragraph', () => {
+    expect(markdownToHtml('line one\nline two')).toBe('<p>line one\nline two</p>');
+  });
+
+  it('separates paragraphs on blank lines', () => {
+    expect(markdownToHtml('first\n\nsecond')).toBe('<p>first</p>\n<p>second</p>');
+  });
+
+  it('renders headings h1–h6', () => {
+    expect(markdownToHtml('# One')).toBe('<h1>One</h1>');
+    expect(markdownToHtml('## Two')).toBe('<h2>Two</h2>');
+    expect(markdownToHtml('### Three')).toBe('<h3>Three</h3>');
+    expect(markdownToHtml('###### Six')).toBe('<h6>Six</h6>');
+  });
+
+  it('renders bullet lists', () => {
+    expect(markdownToHtml('- one\n- two')).toBe('<ul><li>one</li><li>two</li></ul>');
+  });
+
+  it('renders ordered lists', () => {
+    expect(markdownToHtml('1. first\n2. second')).toBe('<ol><li>first</li><li>second</li></ol>');
+  });
+
+  it('renders blockquotes', () => {
+    expect(markdownToHtml('> quoted')).toBe('<blockquote>quoted</blockquote>');
+  });
+
+  it('renders horizontal rules', () => {
+    expect(markdownToHtml('---')).toBe('<hr />');
+  });
+
+  it('renders fenced code with a language class and escapes the body', () => {
+    const html = markdownToHtml('```ts\nconst a = "<b>";\n```');
+    expect(html).toBe('<pre><code class="language-ts">const a = &quot;&lt;b&gt;&quot;;</code></pre>');
+  });
+
+  it('treats a fenced block as code rather than markdown', () => {
+    expect(markdownToHtml('```\n**not bold**\n```')).toContain('**not bold**');
+  });
+});
+
+describe('markdownToHtml — inline formatting', () => {
+  it('renders bold with ** and __', () => {
+    expect(markdownToHtml('**bold**')).toBe('<p><strong>bold</strong></p>');
+    expect(markdownToHtml('__bold__')).toBe('<p><strong>bold</strong></p>');
+  });
+
+  it('renders italic with * and _', () => {
+    expect(markdownToHtml('*italic*')).toBe('<p><em>italic</em></p>');
+    expect(markdownToHtml('some _italic_ text')).toBe('<p>some <em>italic</em> text</p>');
+  });
+
+  it('renders strikethrough', () => {
+    expect(markdownToHtml('~~gone~~')).toBe('<p><del>gone</del></p>');
+  });
+
+  it('renders inline code without applying formatting inside it', () => {
+    expect(markdownToHtml('use `**not bold**` here')).toBe(
+      '<p>use <code>**not bold**</code> here</p>'
+    );
+  });
+
+  it('escapes code span contents', () => {
+    expect(markdownToHtml('`<script>`')).toBe('<p><code>&lt;script&gt;</code></p>');
+  });
+
+  it('combines formatting with surrounding text', () => {
+    expect(markdownToHtml('a **b** and *c*')).toBe('<p>a <strong>b</strong> and <em>c</em></p>');
+  });
+});
+
+describe('markdownToHtml — links and images', () => {
+  it('renders links', () => {
+    expect(markdownToHtml('[docs](https://example.com/docs)')).toBe(
+      '<p><a href="https://example.com/docs" rel="noopener noreferrer">docs</a></p>'
+    );
+  });
+
+  it('renders relative links without a rel attribute', () => {
+    expect(markdownToHtml('[home](/dashboard)')).toBe('<p><a href="/dashboard">home</a></p>');
+  });
+
+  it('allows mailto links', () => {
+    expect(markdownToHtml('[mail](mailto:hi@example.com)')).toContain('href="mailto:hi@example.com"');
+  });
+
+  it('renders images with alt text and lazy loading', () => {
+    expect(markdownToHtml('![shot](/img/a.png)')).toBe(
+      '<p><img src="/img/a.png" alt="shot" loading="lazy" /></p>'
+    );
+  });
+
+  it('omits images when they are disabled', () => {
+    const html = markdownToHtml('![shot](/img/a.png)', { allowImages: false });
+    expect(html).toBe('<p>![shot](/img/a.png)</p>');
+  });
+
+  it('leaves a rejected-protocol link as inert literal text', () => {
+    const html = markdownToHtml('[click](javascript:alert(1))');
+    // No anchor is emitted; the syntax survives only as escaped text.
+    expect(html).not.toContain('<a ');
+    expect(html).toBe('<p>[click](javascript:alert(1))</p>');
+  });
+});
+
+describe('markdownToHtml — injection defence', () => {
+  it('escapes raw HTML instead of passing it through', () => {
+    const html = markdownToHtml('<script>alert(1)</script>');
+    expect(html).toBe('<p>&lt;script&gt;alert(1)&lt;/script&gt;</p>');
+    expect(html).not.toContain('<script>');
+  });
+
+  it('escapes HTML inside emphasis', () => {
+    expect(markdownToHtml('**<img src=x onerror=alert(1)>**')).toContain(
+      '&lt;img src=x onerror=alert(1)&gt;'
+    );
+  });
+
+  it('drops event-handler style attributes smuggled through a link', () => {
+    const html = markdownToHtml('[x](https://example.com" onmouseover="alert(1))');
+    // The payload may survive as escaped text, but never as a real attribute.
+    expect(html).not.toContain('<a ');
+    expect(html).not.toMatch(/<[a-z]+[^>]*onmouseover=/i);
+  });
+
+  it('rejects data: and vbscript: URLs', () => {
+    const dataUrl = markdownToHtml('[x](data:text/html;base64,PHNjcmlwdD4=)');
+    expect(dataUrl).not.toContain('<a ');
+
+    const vbscript = markdownToHtml('![x](vbscript:msgbox)');
+    expect(vbscript).not.toContain('<img ');
+  });
+
+  it('rejects protocol-relative URLs', () => {
+    expect(markdownToHtml('[x](//evil.example.com)')).not.toContain('href="//');
+  });
+
+  it('honours extra allowlisted protocols', () => {
+    expect(markdownToHtml('[call](tel:+15551234)', { allowedProtocols: ['tel:'] })).toContain(
+      'href="tel:+15551234"'
+    );
+  });
+});
+
+describe('escapeHtml', () => {
+  it('escapes the five HTML-significant characters', () => {
+    expect(escapeHtml(`<a href="x">&'</a>`)).toBe('&lt;a href=&quot;x&quot;&gt;&amp;&#39;&lt;/a&gt;');
+  });
+});
diff --git a/frontend/lib/markdown/to-html.ts b/frontend/lib/markdown/to-html.ts
new file mode 100644
index 00000000..3a39f27d
--- /dev/null
+++ b/frontend/lib/markdown/to-html.ts
@@ -0,0 +1,244 @@
+/**
+ * Markdown → HTML serialisation — Issue #90
+ *
+ * The rich text editor (issue #795) stores markdown as its source of truth, but
+ * issue #90 additionally requires descriptions to be **saved as HTML** for
+ * consumers that cannot render markdown (API payloads, emails, exports).
+ *
+ * This module converts the subset of markdown the editor can produce —
+ * headings, bold/italic/strikethrough, inline code, fenced code, links, images,
+ * lists, blockquotes and rules — into HTML.
+ *
+ * Security model: raw HTML is **never** passed through. Every plain text run is
+ * escaped, and `javascript:`/`data:`/`vbscript:` URLs are dropped, so hostile
+ * input cannot introduce script or event-handler attributes. The output is
+ * therefore safe to persist and render directly, mirroring the allowlist the
+ * preview applies via `rehype-sanitize` in `MarkdownContent`.
+ *
+ * Implemented without extra dependencies: the stringifier (`rehype-stringify`)
+ * is not a dependency of this project, and adding one solely for this would be
+ * a heavier change than the feature warrants.
+ */
+
+export interface MarkdownToHtmlOptions {
+  /** Render `![alt](url)` images. Defaults to `true`. */
+  allowImages?: boolean;
+  /** Additional URL schemes to allow for links, e.g. `['tel:']`. */
+  allowedProtocols?: string[];
+}
+
+/** Schemes that are safe to place in an `href`/`src`. */
+const DEFAULT_PROTOCOLS = ['http:', 'https:', 'mailto:'];
+
+const ESCAPE_MAP: Record<string, string> = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;',
+};
+
+/** Escape text for use in HTML content and attribute values. */
+export function escapeHtml(value: string): string {
+  return value.replace(/[&<>"']/g, (character) => ESCAPE_MAP[character] as string);
+}
+
+/**
+ * Resolve a URL from markdown, returning `undefined` when the scheme is not
+ * allowlisted. Relative URLs and fragments are permitted.
+ */
+function safeUrl(url: string, allowedProtocols: string[]): string | undefined {
+  const trimmed = url.trim();
+  if (!trimmed) return undefined;
+
+  // A scheme is only present before the first `/`, `?` or `#`. Anything without
+  // a scheme is relative and safe (e.g. `/docs`, `#section`, `images/x.png`).
+  const schemeMatch = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(trimmed);
+  if (!schemeMatch) {
+    // Protocol-relative URLs (`//evil.com`) inherit the page scheme; reject them.
+    return trimmed.startsWith('//') ? undefined : trimmed;
+  }
+
+  const scheme = `${schemeMatch[1]!.toLowerCase()}:`;
+  if (!allowedProtocols.includes(scheme)) return undefined;
+
+  // Block header/script smuggling inside the value.
+  if (/[\s\u0000-\u001F]/.test(trimmed)) return undefined;
+
+  return trimmed;
+}
+
+interface InlineContext {
+  allowedProtocols: string[];
+  allowImages: boolean;
+}
+
+/**
+ * Render a run of inline markdown. Code spans are extracted first so their
+ * contents are rendered verbatim, then the remaining text is escaped before
+ * formatting markers are turned into tags.
+ */
+function renderInline(source: string, context: InlineContext): string {
+  const codeSpans: string[] = [];
+  const stashedCode = source.replace(/(`+)([\s\S]*?)\1/g, (_match, _ticks: string, code: string) => {
+    codeSpans.push(`<code>${escapeHtml(code.trim())}</code>`);
+    return `\u0000${codeSpans.length - 1}\u0000`;
+  });
+
+  // When images are disabled the syntax must be preserved verbatim — otherwise
+  // the `![alt](url)` half would still be rewritten into a link.
+  const imageLiterals: string[] = [];
+  const stashed = context.allowImages
+    ? stashedCode
+    : stashedCode.replace(/!\[[^\]]*\]\([^)\s]+(?:\s+"[^"]*")?\)/g, (match) => {
+        imageLiterals.push(match);
+        return `\u0001${imageLiterals.length - 1}\u0001`;
+      });
+
+  let html = escapeHtml(stashed);
+
+  // Images before links: `![alt](url)` also contains a `[alt](url)` shape.
+  if (context.allowImages) {
+    html = html.replace(/!\[([^\]]*)\]\(([^)\s]+)(?:\s+&quot;([^&]*)&quot;)?\)/g, (match, alt: string, url: string, title?: string) => {
+      const safe = safeUrl(url, context.allowedProtocols);
+      if (!safe) return escapeHtml(match);
+      const titleAttribute = title ? ` title="${title}"` : '';
+      return `<img src="${escapeHtml(safe)}" alt="${alt}"${titleAttribute} loading="lazy" />`;
+    });
+  }
+
+  html = html.replace(/\[([^\]]+)\]\(([^)\s]+)(?:\s+&quot;([^&]*)&quot;)?\)/g, (match, text: string, url: string, title?: string) => {
+    const safe = safeUrl(url, context.allowedProtocols);
+    if (!safe) return escapeHtml(match);
+    const titleAttribute = title ? ` title="${title}"` : '';
+    // External links are marked so the UI can add rel="noopener".
+    const isExternal = /^https?:/i.test(safe);
+    const rel = isExternal ? ' rel="noopener noreferrer"' : '';
+    return `<a href="${escapeHtml(safe)}"${titleAttribute}${rel}>${text}</a>`;
+  });
+
+  html = html
+    .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
+    .replace(/__([^_]+)__/g, '<strong>$1</strong>')
+    .replace(/~~([^~]+)~~/g, '<del>$1</del>')
+    .replace(/(^|[^*])\*([^*\n]+)\*/g, '$1<em>$2</em>')
+    .replace(/(^|[^_\w])_([^_\n]+)_/g, '$1<em>$2</em>');
+
+  // Restore stashed spans. Code spans already hold HTML; disabled image syntax
+  // is restored as escaped literal text.
+  return html
+    .replace(/\u0000(\d+)\u0000/g, (_match, index: string) => codeSpans[Number(index)] ?? '')
+    .replace(/\u0001(\d+)\u0001/g, (_match, index: string) => escapeHtml(imageLiterals[Number(index)] ?? ''));
+}
+
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const FENCE = /^```(\w*)\s*$/;
+const BULLET_ITEM = /^\s*[-*+]\s+(.*)$/;
+const ORDERED_ITEM = /^\s*\d+[.)]\s+(.*)$/;
+const QUOTE = /^>\s?(.*)$/;
+const RULE = /^\s*(?:---+|\*\*\*+|___+)\s*$/;
+
+/**
+ * Convert markdown into sanitized HTML.
+ *
+ * @example
+ * markdownToHtml('**bold** and ![shot](/a.png)')
+ * // => '<p><strong>bold</strong> and <img src="/a.png" alt="shot" loading="lazy" /></p>'
+ */
+export function markdownToHtml(markdown: string, options: MarkdownToHtmlOptions = {}): string {
+  const context: InlineContext = {
+    allowImages: options.allowImages ?? true,
+    allowedProtocols: [...DEFAULT_PROTOCOLS, ...(options.allowedProtocols ?? [])],
+  };
+
+  const lines = markdown.replace(/\r\n?/g, '\n').split('\n');
+  const blocks: string[] = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    const line = lines[index] as string;
+
+    if (!line.trim()) {
+      index += 1;
+      continue;
+    }
+
+    // Fenced code block.
+    const fence = FENCE.exec(line);
+    if (fence) {
+      const language = fence[1] ?? '';
+      const code: string[] = [];
+      index += 1;
+      while (index < lines.length && !/^```/.test(lines[index] as string)) {
+        code.push(lines[index] as string);
+        index += 1;
+      }
+      index += 1; // consume the closing fence
+      const languageAttribute = language ? ` class="language-${escapeHtml(language)}"` : '';
+      blocks.push(`<pre><code${languageAttribute}>${escapeHtml(code.join('\n'))}</code></pre>`);
+      continue;
+    }
+
+    if (RULE.test(line)) {
+      blocks.push('<hr />');
+      index += 1;
+      continue;
+    }
+
+    const heading = HEADING.exec(line);
+    if (heading) {
+      const level = heading[1]!.length;
+      blocks.push(`<h${level}>${renderInline(heading[2]!.trim(), context)}</h${level}>`);
+      index += 1;
+      continue;
+    }
+
+    // Blockquote: consecutive `>` lines become one block.
+    if (QUOTE.test(line)) {
+      const quoted: string[] = [];
+      while (index < lines.length && QUOTE.test(lines[index] as string)) {
+        quoted.push(QUOTE.exec(lines[index] as string)![1] as string);
+        index += 1;
+      }
+      blocks.push(`<blockquote>${renderInline(quoted.join('\n').trim(), context)}</blockquote>`);
+      continue;
+    }
+
+    if (BULLET_ITEM.test(line) || ORDERED_ITEM.test(line)) {
+      const ordered = ORDERED_ITEM.test(line) && !BULLET_ITEM.test(line);
+      const pattern = ordered ? ORDERED_ITEM : BULLET_ITEM;
+      const items: string[] = [];
+      while (index < lines.length && pattern.test(lines[index] as string)) {
+        items.push(renderInline(pattern.exec(lines[index] as string)![1] as string, context));
+        index += 1;
+      }
+      const tag = ordered ? 'ol' : 'ul';
+      blocks.push(`<${tag}>${items.map((item) => `<li>${item}</li>`).join('')}</${tag}>`);
+      continue;
+    }
+
+    // Paragraph: consume until a blank line or the start of another block.
+    const paragraph: string[] = [];
+    while (index < lines.length) {
+      const candidate = lines[index] as string;
+      if (
+        !candidate.trim() ||
+        FENCE.test(candidate) ||
+        HEADING.test(candidate) ||
+        QUOTE.test(candidate) ||
+        RULE.test(candidate) ||
+        BULLET_ITEM.test(candidate) ||
+        ORDERED_ITEM.test(candidate)
+      ) {
+        break;
+      }
+      paragraph.push(candidate.trim());
+      index += 1;
+    }
+    blocks.push(`<p>${renderInline(paragraph.join('\n'), context)}</p>`);
+  }
+
+  return blocks.join('\n');
+}
+
+export default markdownToHtml;
diff --git a/frontend/lib/projects/__tests__/work-description.test.ts b/frontend/lib/projects/__tests__/work-description.test.ts
new file mode 100644
index 00000000..07c836bc
--- /dev/null
+++ b/frontend/lib/projects/__tests__/work-description.test.ts
@@ -0,0 +1,98 @@
+/**
+ * buildWorkDescription / serializeWorkDescription tests — Issue #90
+ */
+import { describe, expect, it } from 'vitest';
+
+import {
+  buildWorkDescription,
+  serializeWorkDescription,
+} from '@/lib/projects/work-description';
+
+describe('buildWorkDescription', () => {
+  it('keeps the markdown description as the source of truth', () => {
+    const result = buildWorkDescription({ title: 'Redesign', description: '**bold**' });
+
+    expect(result.description).toBe('**bold**');
+  });
+
+  it('also stores the HTML rendition of the description', () => {
+    const result = buildWorkDescription({ title: 'Redesign', description: '## Scope\n\n**bold**' });
+
+    expect(result.descriptionHtml).toBe('<h2>Scope</h2>\n<p><strong>bold</strong></p>');
+  });
+
+  it('renders images in the HTML rendition', () => {
+    const result = buildWorkDescription({
+      title: 'Redesign',
+      description: '![shot](/img/a.png)',
+    });
+
+    expect(result.descriptionHtml).toContain('<img src="/img/a.png" alt="shot" loading="lazy" />');
+  });
+
+  it('omits images when the editor disables them', () => {
+    const result = buildWorkDescription({
+      title: 'Redesign',
+      description: '![shot](/img/a.png)',
+      allowImages: false,
+    });
+
+    expect(result.descriptionHtml).toBe('<p>![shot](/img/a.png)</p>');
+  });
+
+  it('escapes hostile markup in the HTML rendition', () => {
+    const result = buildWorkDescription({ title: 'Redesign', description: '<script>alert(1)</script>' });
+
+    expect(result.descriptionHtml).not.toContain('<script>');
+    expect(result.descriptionHtml).toContain('&lt;script&gt;');
+  });
+
+  it('defaults missing description and repo to empty strings', () => {
+    const result = buildWorkDescription({ title: 'Redesign' });
+
+    expect(result).toEqual({
+      title: 'Redesign',
+      description: '',
+      descriptionHtml: '',
+      repo: '',
+    });
+  });
+
+  it('treats null description and repo as empty', () => {
+    const result = buildWorkDescription({ title: 'Redesign', description: null, repo: null });
+
+    expect(result.description).toBe('');
+    expect(result.repo).toBe('');
+  });
+
+  it('carries the repository URL through', () => {
+    const result = buildWorkDescription({ title: 'Redesign', repo: 'https://github.com/a/b' });
+
+    expect(result.repo).toBe('https://github.com/a/b');
+  });
+});
+
+describe('serializeWorkDescription', () => {
+  it('produces the JSON payload passed to the contract', () => {
+    const payload = serializeWorkDescription({
+      title: 'Redesign',
+      description: '**bold**',
+      repo: 'https://github.com/a/b',
+    });
+
+    expect(JSON.parse(payload)).toEqual({
+      title: 'Redesign',
+      description: '**bold**',
+      descriptionHtml: '<p><strong>bold</strong></p>',
+      repo: 'https://github.com/a/b',
+    });
+  });
+
+  it('round-trips a description containing quotes and newlines', () => {
+    const description = 'He said "hi"\n\n- one\n- two';
+    const payload = JSON.parse(serializeWorkDescription({ title: 't', description }));
+
+    expect(payload.description).toBe(description);
+    expect(payload.descriptionHtml).toBe('<p>He said &quot;hi&quot;</p>\n<ul><li>one</li><li>two</li></ul>');
+  });
+});
diff --git a/frontend/lib/projects/work-description.ts b/frontend/lib/projects/work-description.ts
new file mode 100644
index 00000000..f24e97bf
--- /dev/null
+++ b/frontend/lib/projects/work-description.ts
@@ -0,0 +1,51 @@
+/**
+ * Project work-description payload — Issue #90
+ *
+ * The create-project form stores the description inside the on-chain
+ * `workDescription` argument as JSON. Issue #795 made the description markdown
+ * (authored through the rich text editor); issue #90 requires it to also be
+ * **saved as HTML** so consumers that cannot render markdown can display it.
+ *
+ * `description` stays the markdown source of truth, and `descriptionHtml` is the
+ * sanitized rendition produced by {@link markdownToHtml}. Keeping the shape in
+ * one tested helper means both `/dashboard/projects/new` and its localized
+ * variant stay in sync with the on-chain contract.
+ */
+
+import { markdownToHtml } from '@/lib/markdown/to-html';
+
+export interface WorkDescriptionInput {
+  title: string;
+  /** Markdown authored in the rich text editor. */
+  description?: string | null;
+  /** Optional GitHub repository URL. */
+  repo?: string | null;
+  /** Forwarded to the HTML serializer; disable for editors without images. */
+  allowImages?: boolean;
+}
+
+export interface WorkDescription {
+  title: string;
+  description: string;
+  descriptionHtml: string;
+  repo: string;
+}
+
+/** Build the structured description stored on-chain. */
+export function buildWorkDescription(input: WorkDescriptionInput): WorkDescription {
+  const description = input.description ?? '';
+
+  return {
+    title: input.title,
+    description,
+    descriptionHtml: markdownToHtml(description, { allowImages: input.allowImages ?? true }),
+    repo: input.repo ?? '',
+  };
+}
+
+/** Serialize the description for the `workDescription` contract argument. */
+export function serializeWorkDescription(input: WorkDescriptionInput): string {
+  return JSON.stringify(buildWorkDescription(input));
+}
+
+export default buildWorkDescription;