diff --git a/frontend/app/api/verify-amd/route.ts b/frontend/app/api/verify-amd/route.ts
new file mode 100644
index 0000000..3fffd30
--- /dev/null
+++ b/frontend/app/api/verify-amd/route.ts
@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from "next/server";
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json().catch(() => null);
+    const report = body?.report;
+
+    if (typeof report !== "string" || report.trim().length === 0) {
+      return NextResponse.json(
+        { success: false, error: "Invalid AMD attestation report provided" },
+        { status: 400 }
+      );
+    }
+
+    const upstreamRes = await fetch(
+      "https://nilcc-verifier.nillion.network/v1/attestations/verify-amd",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ report }),
+      }
+    );
+
+    const contentType = upstreamRes.headers.get("content-type") || "";
+
+    if (contentType.includes("application/json")) {
+      const json = await upstreamRes.json().catch(() => ({}));
+      // Treat any 2xx response from the verifier as success.
+      return NextResponse.json(
+        {
+          success: upstreamRes.ok,
+          ...json,
+        },
+        { status: upstreamRes.status }
+      );
+    } else {
+      const text = await upstreamRes.text();
+      if (!upstreamRes.ok) {
+        return NextResponse.json(
+          { success: false, error: text || "AMD attestation verification failed" },
+          { status: upstreamRes.status }
+        );
+      }
+
+      return new NextResponse(text, {
+        status: upstreamRes.status,
+        headers: { "Content-Type": "text/plain" },
+      });
+    }
+  } catch (err) {
+    console.error("AMD verifier Next.js API error:", err);
+    return NextResponse.json(
+      { success: false, error: "Failed to reach AMD verifier" },
+      { status: 502 }
+    );
+  }
+}
+
diff --git a/frontend/app/api/verify-attestation/route.ts b/frontend/app/api/verify-attestation/route.ts
new file mode 100644
index 0000000..28710ba
--- /dev/null
+++ b/frontend/app/api/verify-attestation/route.ts
@@ -0,0 +1,43 @@
+import { NextRequest, NextResponse } from "next/server";
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json().catch(() => null);
+    const { hex, type } = body || {};
+
+    if (typeof hex !== "string" || hex.trim().length === 0) {
+      return NextResponse.json(
+        { error: "Invalid attestation quote provided" },
+        { status: 400 }
+      );
+    }
+
+    const verifyRes = await fetch(
+      "https://cloud-api.phala.com/proofofcloud/attestations/verify",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ hex, type: type || "intel" }),
+      }
+    );
+
+    const verifyData = await verifyRes.json().catch(() => ({}));
+
+    if (!verifyRes.ok) {
+      return NextResponse.json(
+        { error: verifyData.error || verifyData.detail || verifyData.message || "Verification failed" },
+        { status: verifyRes.status }
+      );
+    }
+
+    return NextResponse.json(verifyData, { status: 200 });
+  } catch (err) {
+    console.error("Attestation verification API error:", err);
+    return NextResponse.json(
+      { error: "Failed to reach verification service" },
+      { status: 502 }
+    );
+  }
+}
diff --git a/frontend/app/api/view-attestation/[checksum]/route.ts b/frontend/app/api/view-attestation/[checksum]/route.ts
new file mode 100644
index 0000000..c1b6469
--- /dev/null
+++ b/frontend/app/api/view-attestation/[checksum]/route.ts
@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from "next/server";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ checksum: string }> }
+) {
+  try {
+    const { checksum } = await params;
+
+    if (!checksum) {
+      return NextResponse.json(
+        { error: "Checksum is required" },
+        { status: 400 }
+      );
+    }
+
+    const viewRes = await fetch(
+      `https://cloud-api.phala.com/proofofcloud/attestations/view/${checksum}`
+    );
+
+    const viewData = await viewRes.json().catch(() => ({}));
+
+    if (!viewRes.ok) {
+      return NextResponse.json(
+        { error: viewData.error || viewData.detail || "Failed to retrieve verification details" },
+        { status: viewRes.status }
+      );
+    }
+
+    return NextResponse.json(viewData, { status: 200 });
+  } catch (err) {
+    console.error("View attestation API error:", err);
+    return NextResponse.json(
+      { error: "Failed to reach verification service" },
+      { status: 502 }
+    );
+  }
+}
diff --git a/frontend/components/verification-form.tsx b/frontend/components/verification-form.tsx
index 126bcb9..4d0aeef 100644
--- a/frontend/components/verification-form.tsx
+++ b/frontend/components/verification-form.tsx
@@ -18,6 +18,7 @@ export function VerificationFormWithLabel() {
     uploadedAt?: string;
     error?: string;
   } | null>(null);
+  const [attestationType, setAttestationType] = useState<'intel' | 'amd'>('intel');
 
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
@@ -35,57 +36,86 @@ export function VerificationFormWithLabel() {
     setResult(null);
 
     try {
-      // Normalize to hex (remove 0x prefix if present, remove whitespace)
-      let quoteHex = attestation.trim().replace(/^0x/i, '').replace(/\s+/g, '');
-
-      // Check if it's potentially base64 and convert
-      if (!/^[0-9a-fA-F]+$/.test(quoteHex)) {
-        try {
-          // Attempt base64 to hex conversion
-          const binary = atob(quoteHex);
-          quoteHex = Array.from(binary, (char) =>
-            char.charCodeAt(0).toString(16).padStart(2, '0')
-          ).join('');
-        } catch {
-          throw new Error("Invalid attestation format. Please provide hex or base64 encoded quote.");
+      if (attestationType === 'intel') {
+        // Intel flow: normalize to hex and use Phala Proof of Cloud API
+        let quoteHex = attestation.trim().replace(/^0x/i, '').replace(/\s+/g, '');
+
+        if (!/^[0-9a-fA-F]+$/.test(quoteHex)) {
+          try {
+            const binary = atob(quoteHex);
+            quoteHex = Array.from(binary, (char) =>
+              char.charCodeAt(0).toString(16).padStart(2, '0')
+            ).join('');
+          } catch {
+            throw new Error("Invalid attestation format. Please provide hex or base64 encoded quote.");
+          }
         }
-      }
 
-      // Step 1: Submit attestation to get checksum
-      const verifyResponse = await fetch("https://cloud-api.phala.com/proofofcloud/attestations/verify", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ hex: quoteHex }),
-      });
+        // Use local API proxy to avoid CORS issues
+        const verifyResponse = await fetch("/api/verify-attestation", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ hex: quoteHex, type: attestationType }),
+        });
 
-      const verifyData = await verifyResponse.json();
+        const verifyData = await verifyResponse.json();
 
-      if (!verifyResponse.ok) {
-        throw new Error(verifyData.error || verifyData.message || "Verification failed");
-      }
+        if (!verifyResponse.ok) {
+          throw new Error(verifyData.error || verifyData.message || "Verification failed");
+        }
 
-      const checksum = verifyData.checksum;
-      if (!checksum) {
-        throw new Error("No checksum returned from verification service");
-      }
+        const checksum = verifyData.checksum;
+        if (!checksum) {
+          throw new Error("No checksum returned from verification service");
+        }
 
-      // Step 2: Fetch full verification result using checksum
-      const viewResponse = await fetch(`https://cloud-api.phala.com/proofofcloud/attestations/view/${checksum}`);
+        const viewResponse = await fetch(`/api/view-attestation/${checksum}`);
 
-      if (!viewResponse.ok) {
-        throw new Error("Failed to retrieve verification details");
-      }
+        if (!viewResponse.ok) {
+          throw new Error("Failed to retrieve verification details");
+        }
 
-      const viewData = await viewResponse.json();
+        const viewData = await viewResponse.json();
 
-      setResult({
-        verified: viewData.verified || false,
-        proofOfCloud: viewData.proof_of_cloud || false,
-        checksum: checksum,
-        uploadedAt: viewData.uploaded_at,
-      });
+        setResult({
+          verified: viewData.verified || false,
+          proofOfCloud: viewData.proof_of_cloud || false,
+          checksum: checksum,
+          uploadedAt: viewData.uploaded_at,
+        });
+      } else {
+        // AMD flow: send raw report to Nillion verifier
+        const report = attestation.trim();
+
+        const verifierResponse = await fetch('/api/verify-amd', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ report }),
+        });
+
+        const verifierData = await verifierResponse.json().catch(() => ({}));
+
+        const ok = verifierResponse.ok && (verifierData as any)?.success === true;
+
+        if (!ok) {
+          throw new Error(
+            (verifierData as any)?.error ||
+            (verifierData as any)?.message ||
+            "AMD attestation verification failed"
+          );
+        }
+
+        setResult({
+          verified: true,
+          proofOfCloud: false,
+          checksum: undefined,
+          uploadedAt: undefined,
+        });
+      }
     } catch (error) {
       console.error("Verification error:", error);
       setResult({
@@ -281,6 +311,31 @@ export function VerificationFormWithLabel() {
 
       {/* Form */}
       <form onSubmit={handleSubmit} className="space-y-4">
+        <div className="flex items-center gap-4">
+          <span className="text-sm font-medium text-gray-900">Platform</span>
+          <label className="inline-flex items-center gap-2 text-sm text-gray-700">
+            <input
+              type="radio"
+              name="attestationType"
+              value="intel"
+              checked={attestationType === 'intel'}
+              onChange={() => setAttestationType('intel')}
+              className="h-4 w-4"
+            />
+            Intel
+          </label>
+          <label className="inline-flex items-center gap-2 text-sm text-gray-700">
+            <input
+              type="radio"
+              name="attestationType"
+              value="amd"
+              checked={attestationType === 'amd'}
+              onChange={() => setAttestationType('amd')}
+              className="h-4 w-4"
+            />
+            AMD
+          </label>
+        </div>
         <Textarea
           id="attestation"
           value={attestation}
diff --git a/frontend/next.config.ts b/frontend/next.config.ts
index afcbe7e..1f6f6ce 100644
--- a/frontend/next.config.ts
+++ b/frontend/next.config.ts
@@ -1,7 +1,6 @@
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
-  output: 'export',
   images: {
     unoptimized: true,
   },
diff --git a/server/server.js b/server/server.js
index 3ae7c20..9889ab2 100644
--- a/server/server.js
+++ b/server/server.js
@@ -3,6 +3,7 @@ const cors = require('cors');
 const path = require('path');
 const { execFile } = require('child_process');
 const fs = require('fs');
+const https = require('https');
 
 const app = express();
 const PORT = process.env.PORT || 3000;
@@ -17,32 +18,32 @@ const DEFAULT_TOOL_PATH = path.join(
     'dcap_collateral_tool'
   );
   const TOOL_PATH = process.env.DCAP_TOOL_PATH || DEFAULT_TOOL_PATH;
-  
+
   // --- Helpers ---------------------------------------------------------------
-  
+
     // Returns true if `s` is a hex string with even length.
     function isHex(s) {
         return typeof s === 'string' && /^[0-9a-fA-F]+$/.test(s) && (s.length % 2 === 0);
     }
-  
+
 // Base64 detection is intentionally permissive (allows '=' and line breaks).
 function isBase64ish(s) {
     return typeof s === 'string'
       && /^[A-Za-z0-9+/=\r\n]+$/.test(s)
       && (s.replace(/\s+/g, '').length % 4 === 0);
   }
-  
+
   // Normalize user input into hex for the DCAP tool.
   // Returns hex string (lowercase) OR null (on unsupported/empty).
   function normalizeToHex(input) {
     const raw = (input ?? '').toString().trim();
     if (!raw) return null;
-  
+
     // Compact whitespace and drop leading 0x
     const compact = raw.replace(/\s+/g, '');
     const maybeHex = compact.replace(/^0x/i, '');
     if (isHex(maybeHex)) return maybeHex.toLowerCase();
-  
+
     // Try base64 → hex
     if (isBase64ish(raw)) {
       try {
@@ -53,7 +54,7 @@ function isBase64ish(s) {
     }
     return null;
   }
-  
+
   // Execute the DCAP tool with a hex-encoded quote; returns parsed JSON-like object.
   // Never rejects for user/quote errors; only rejects if the tool binary is missing.
   function runDcapTool(hexQuote) {
@@ -62,7 +63,7 @@ function isBase64ish(s) {
       if (!fs.existsSync(TOOL_PATH)) {
         return reject(new Error(`DCAP tool not found at ${TOOL_PATH}. Build it or set DCAP_TOOL_PATH.`));
       }
-  
+
       // If input is not valid hex, return a synthetic "invalid" result.
       if (!hexQuote || typeof hexQuote !== 'string' || !isHex(hexQuote)) {
         return resolve({
@@ -70,7 +71,7 @@ function isBase64ish(s) {
           collateral: { error: 'invalid_input' }
         });
       }
-  
+
       // Call the tool; if it errors, return "invalid" (do not reject).
       execFile(
         TOOL_PATH,
@@ -84,10 +85,10 @@ function isBase64ish(s) {
               collateral: { error: 'exec_error', message: (stderr && stderr.toString()) || err.message || 'DCAP tool error' }
             });
           }
-  
+
           try {
             const parsed = JSON.parse(stdout.toString());
-  
+
             // Coerce status/result to the string form your handler expects ('0' | '1')
             const out = { ...parsed, status: parsed.status || {} };
             out.status.result = String(Number(out.status.result ?? 1)); // '0' on success, otherwise '1'
@@ -193,14 +194,78 @@ function generateMockPPID() {
 
 // Health check endpoint
 app.get('/api/health', (req, res) => {
-    res.json({ 
-        status: 'healthy', 
+    res.json({
+        status: 'healthy',
         timestamp: new Date().toISOString(),
         service: 'Proof of Cloud Verification API'
     });
 });
 
+// AMD attestation verification proxy (Nillion verifier)
+// Note: When running the Next.js frontend dev server, the /api/verify-amd
+// route is handled by frontend/app/api/verify-amd/route.ts instead.
+app.post('/api/verify-amd', (req, res) => {
+    try {
+        const { report } = req.body || {};
+
+        if (!report || typeof report !== 'string' || report.trim().length === 0) {
+            return res.status(400).json({
+                error: 'Invalid AMD attestation report provided',
+            });
+        }
+
+        const payload = JSON.stringify({ report: report.trim() });
+
+        const options = {
+            hostname: 'nilcc-verifier.nillion.network',
+            port: 443,
+            path: '/v1/attestations/verify-amd',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+            },
+        };
+
+        const proxyReq = https.request(options, (proxyRes) => {
+            let data = '';
+
+            proxyRes.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            proxyRes.on('end', () => {
+                const statusCode = proxyRes.statusCode || 500;
+                res.status(statusCode);
+
+                // Try to forward JSON as-is; fall back to plain text if parsing fails
+                try {
+                    const json = data ? JSON.parse(data) : {};
+                    res.json(json);
+                } catch {
+                    res.type('text/plain').send(data || '');
+                }
+            });
+        });
+
+        proxyReq.on('error', (err) => {
+            console.error('AMD verifier proxy error:', err);
+            res.status(502).json({
+                error: 'Failed to reach AMD verifier',
+            });
+        });
+
+        proxyReq.write(payload);
+        proxyReq.end();
+    } catch (err) {
+        console.error('AMD verifier proxy handler error:', err);
+        res.status(500).json({
+            error: 'Internal server error in AMD verifier proxy',
+        });
+    }
+});
+
 app.listen(PORT, () => {
     console.log(`Proof of Cloud server running on port ${PORT}`);
     console.log(`Visit http://localhost:${PORT} to view the website`);
-});
\ No newline at end of file
+});