diff --git a/docs/schema/yaml/1.0.0.yaml b/docs/schema/yaml/1.0.0.yaml
index 61c6c8ab..7c7a6ded 100644
--- a/docs/schema/yaml/1.0.0.yaml
+++ b/docs/schema/yaml/1.0.0.yaml
@@ -48,13 +48,35 @@ environment:
       state: ''
       # @param environment.webhooks.type (required)
       type: ''
-      # @param environment.webhooks.pipelineId (required)
+      # @param environment.webhooks.pipelineId
       pipelineId: ''
       # @param environment.webhooks.trigger (required)
       trigger: ''
       # @param environment.webhooks.env (required)
       env:
 
+      # @param environment.webhooks.docker
+      docker:
+        # @param environment.webhooks.docker.image (required)
+        image: ''
+        # @param environment.webhooks.docker.command
+        command:
+          # @param environment.webhooks.docker.command[]
+          - ''
+        # @param environment.webhooks.docker.args
+        args:
+          # @param environment.webhooks.docker.args[]
+          - ''
+        # @param environment.webhooks.docker.timeout
+        timeout: 0
+      # @param environment.webhooks.command
+      command:
+        # @param environment.webhooks.command.image (required)
+        image: ''
+        # @param environment.webhooks.command.script (required)
+        script: ''
+        # @param environment.webhooks.command.timeout
+        timeout: 0
 # @section services
 services:
   # @param services[]
diff --git a/src/components/logs/PageLayout.tsx b/src/components/logs/PageLayout.tsx
index 4de773e7..88f773d8 100644
--- a/src/components/logs/PageLayout.tsx
+++ b/src/components/logs/PageLayout.tsx
@@ -28,56 +28,75 @@ interface PageLayoutProps {
 
 export function PageLayout({ backLink, title, serviceName, environmentId, deploymentType, children }: PageLayoutProps) {
   return (
-    <div style={{ 
-      height: '100vh',
-      overflow: 'hidden',
-      backgroundColor: '#f5f5f5',
-      fontFamily: "'Inter', 'Segoe UI', 'Roboto', 'Helvetica Neue', Arial, sans-serif",
-    }}>
-      <div style={{ 
-        padding: '32px', 
-        maxWidth: '100%', 
-        margin: '0',
-        height: '100%',
-        display: 'flex',
-        flexDirection: 'column',
-        boxSizing: 'border-box'
-      }}>
+    <div
+      style={{
+        height: '100vh',
+        overflow: 'hidden',
+        backgroundColor: '#f5f5f5',
+        fontFamily: "'Inter', 'Segoe UI', 'Roboto', 'Helvetica Neue', Arial, sans-serif",
+      }}
+    >
+      <div
+        style={{
+          padding: '32px',
+          maxWidth: '100%',
+          margin: '0',
+          height: '100%',
+          display: 'flex',
+          flexDirection: 'column',
+          boxSizing: 'border-box',
+        }}
+      >
         <div style={{ marginBottom: '24px', flexShrink: 0 }}>
-          <Link 
+          <Link
             href={backLink}
-            style={{ 
-              display: 'inline-flex', 
-              alignItems: 'center', 
-              color: '#666', 
+            style={{
+              display: 'inline-flex',
+              alignItems: 'center',
+              color: '#666',
               textDecoration: 'none',
               fontSize: '14px',
-              marginBottom: '16px'
+              marginBottom: '16px',
             }}
           >
-            <svg width="16" height="16" fill="none" stroke="currentColor" viewBox="0 0 24 24" style={{ marginRight: '6px' }}>
+            <svg
+              width="16"
+              height="16"
+              fill="none"
+              stroke="currentColor"
+              viewBox="0 0 24 24"
+              style={{ marginRight: '6px' }}
+            >
               <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M10 19l-7-7m0 0l7-7m-7 7h18" />
             </svg>
             Back to Environment
           </Link>
-          <h1 style={{ 
-            fontSize: '28px', 
-            fontWeight: 700, 
-            color: '#333',
-            margin: 0,
-            letterSpacing: '-0.02em'
-          }}>
+          <h1
+            style={{
+              fontSize: '28px',
+              fontWeight: 700,
+              color: '#333',
+              margin: 0,
+              letterSpacing: '-0.02em',
+            }}
+          >
             {title}
           </h1>
-          {serviceName && environmentId && (
-            <div style={{ marginTop: '8px', color: '#666', fontSize: '14px' }}>
-              <span style={{ fontWeight: 500 }}>Service:</span> {serviceName} &nbsp;&nbsp;•&nbsp;&nbsp;
-              <span style={{ fontWeight: 500 }}>Environment:</span> <code style={{ fontSize: '13px', color: '#555' }}>{environmentId}</code>
-              {deploymentType && (
-                <>
-                  &nbsp;&nbsp;•&nbsp;&nbsp;
-                  <span style={{ fontWeight: 500 }}>Type:</span>{' '}
-                  <span style={{
+          <div style={{ marginTop: '8px', color: '#666', fontSize: '14px' }}>
+            <span style={{ fontWeight: 500 }}>Environment:</span>{' '}
+            <code style={{ fontSize: '13px', color: '#555' }}>{environmentId}</code>
+            {serviceName && (
+              <>
+                <span style={{ fontWeight: 500 }}> &nbsp;&nbsp;•&nbsp;&nbsp; Service:</span>{' '}
+                <code style={{ fontSize: '13px', color: '#555' }}>{serviceName}</code>
+              </>
+            )}
+            {deploymentType && (
+              <>
+                &nbsp;&nbsp;•&nbsp;&nbsp;
+                <span style={{ fontWeight: 500 }}>Type:</span>{' '}
+                <span
+                  style={{
                     display: 'inline-flex',
                     alignItems: 'center',
                     padding: '2px 8px',
@@ -86,16 +105,16 @@ export function PageLayout({ backLink, title, serviceName, environmentId, deploy
                     fontWeight: 500,
                     backgroundColor: deploymentType === 'helm' ? '#dbeafe' : '#e0e7ff',
                     color: deploymentType === 'helm' ? '#1e40af' : '#4338ca',
-                    textTransform: 'uppercase'
-                  }}>
-                    {deploymentType}
-                  </span>
-                </>
-              )}
-            </div>
-          )}
+                    textTransform: 'uppercase',
+                  }}
+                >
+                  {deploymentType}
+                </span>
+              </>
+            )}
+          </div>
         </div>
-        
+
         {children}
 
         <style>{`
@@ -119,18 +138,24 @@ interface ErrorAlertProps {
 
 export function ErrorAlert({ error }: ErrorAlertProps) {
   return (
-    <div style={{
-      backgroundColor: '#fee',
-      border: '1px solid #fcc',
-      borderRadius: '8px',
-      padding: '16px',
-      marginBottom: '24px',
-      display: 'flex',
-      alignItems: 'flex-start',
-      flexShrink: 0
-    }}>
+    <div
+      style={{
+        backgroundColor: '#fee',
+        border: '1px solid #fcc',
+        borderRadius: '8px',
+        padding: '16px',
+        marginBottom: '24px',
+        display: 'flex',
+        alignItems: 'flex-start',
+        flexShrink: 0,
+      }}
+    >
       <svg width="20" height="20" fill="#dc2626" viewBox="0 0 20 20" style={{ marginRight: '12px', flexShrink: 0 }}>
-        <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
+        <path
+          fillRule="evenodd"
+          d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z"
+          clipRule="evenodd"
+        />
       </svg>
       <div>
         <div style={{ fontWeight: 600, color: '#dc2626', marginBottom: '4px' }}>Error</div>
@@ -147,16 +172,23 @@ interface EmptyStateProps {
 
 export function EmptyState({ title, description }: EmptyStateProps) {
   return (
-    <div style={{ 
-      backgroundColor: 'white',
-      borderRadius: '12px',
-      padding: '48px',
-      textAlign: 'center',
-      boxShadow: '0 1px 3px rgba(0,0,0,0.1)',
-      flex: 1
-    }}>
+    <div
+      style={{
+        backgroundColor: 'white',
+        borderRadius: '12px',
+        padding: '48px',
+        textAlign: 'center',
+        boxShadow: '0 1px 3px rgba(0,0,0,0.1)',
+        flex: 1,
+      }}
+    >
       <svg width="32" height="32" fill="none" stroke="#ccc" viewBox="0 0 24 24" style={{ margin: '0 auto' }}>
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+        <path
+          strokeLinecap="round"
+          strokeLinejoin="round"
+          strokeWidth={1.5}
+          d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"
+        />
       </svg>
       <h3 style={{ fontSize: '18px', fontWeight: 600, color: '#333', marginTop: '16px', marginBottom: '8px' }}>
         {title}
@@ -164,4 +196,5 @@ export function EmptyState({ title, description }: EmptyStateProps) {
       <p style={{ color: '#666', fontSize: '14px' }}>{description}</p>
     </div>
   );
-} 
\ No newline at end of file
+}
+
diff --git a/src/components/logs/TerminalContainer.tsx b/src/components/logs/TerminalContainer.tsx
index 6e57e3e8..49a4ae9f 100644
--- a/src/components/logs/TerminalContainer.tsx
+++ b/src/components/logs/TerminalContainer.tsx
@@ -35,6 +35,7 @@ interface TerminalContainerProps {
   showTimestamps: boolean;
   onTimestampsToggle: () => void;
   showDetailsTab?: boolean;
+  showEventsTab?: boolean;
 }
 
 export function TerminalContainer({
@@ -47,7 +48,8 @@ export function TerminalContainer({
   children,
   showTimestamps,
   onTimestampsToggle,
-  showDetailsTab = false
+  showDetailsTab = false,
+  showEventsTab = true
 }: TerminalContainerProps) {
   return (
     <>
@@ -136,26 +138,28 @@ export function TerminalContainer({
             Details
           </button>
         )}
-        <button
-          onClick={() => onTabChange('events')}
-          style={{
-            padding: '10px 16px',
-            backgroundColor: activeContainer === 'events' ? '#1a1a1a' : 'transparent',
-            color: activeContainer === 'events' ? '#fff' : '#999',
-            border: 'none',
-            borderBottom: activeContainer === 'events' ? '2px solid #3b82f6' : '2px solid transparent',
-            fontSize: '13px',
-            fontWeight: 500,
-            cursor: 'pointer',
-            display: 'flex',
-            alignItems: 'center',
-            gap: '8px',
-            transition: 'all 0.15s',
-            marginLeft: showDetailsTab ? undefined : 'auto'
-          }}
-        >
-          Job Events
-        </button>
+        {showEventsTab && (
+          <button
+            onClick={() => onTabChange('events')}
+            style={{
+              padding: '10px 16px',
+              backgroundColor: activeContainer === 'events' ? '#1a1a1a' : 'transparent',
+              color: activeContainer === 'events' ? '#fff' : '#999',
+              border: 'none',
+              borderBottom: activeContainer === 'events' ? '2px solid #3b82f6' : '2px solid transparent',
+              fontSize: '13px',
+              fontWeight: 500,
+              cursor: 'pointer',
+              display: 'flex',
+              alignItems: 'center',
+              gap: '8px',
+              transition: 'all 0.15s',
+              marginLeft: showDetailsTab ? undefined : 'auto'
+            }}
+          >
+            Job Events
+          </button>
+        )}
       </div>
 
       <div style={{ flex: 1, overflow: 'hidden', position: 'relative' }}>
@@ -165,7 +169,7 @@ export function TerminalContainer({
   );
 }
 
-export function EmptyTerminalState({ type }: { type: 'build' | 'deployment' }) {
+export function EmptyTerminalState({ type }: { type: 'build' | 'deployment' | 'webhook' }) {
   return (
     <div style={{ 
       display: 'flex', 
@@ -178,13 +182,13 @@ export function EmptyTerminalState({ type }: { type: 'build' | 'deployment' }) {
       textAlign: 'center'
     }}>
       <svg width="32" height="32" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M8 9l3 3-3 3m5 0h3M5 20h14a2 2 0 002-2V6a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z" />
+        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M8 9l3 3-3 3m5 0h3M5 20h14a2 2 0 002-2V6a2 2 0 00-2-2H5a2 2 0 002 2v12a2 2 0 002 2z" />
       </svg>
       <h3 style={{ marginTop: '16px', fontSize: '16px', fontWeight: 600, color: '#fff' }}>
-        Select a {type === 'build' ? 'build job' : 'deployment'}
+        Select a {type === 'build' ? 'build job' : type === 'deployment' ? 'deployment' : 'webhook'}
       </h3>
       <p style={{ marginTop: '8px', fontSize: '14px' }}>
-        Choose a {type} from the table to view its logs
+        Choose a {type} from the table to view its {type === 'webhook' ? 'details' : 'logs'}
       </p>
     </div>
   );
diff --git a/src/components/logs/hooks/useJobPolling.ts b/src/components/logs/hooks/useJobPolling.ts
index 5540e8bd..5ebfcf9f 100644
--- a/src/components/logs/hooks/useJobPolling.ts
+++ b/src/components/logs/hooks/useJobPolling.ts
@@ -35,6 +35,7 @@ interface UseJobPollingProps<T extends JobInfo> {
   fetchJobInfo: (job: T) => Promise<void>;
   // eslint-disable-next-line no-unused-vars
   onJobSelect: (job: T) => Promise<void>;
+  pollingInterval?: number; // in milliseconds, default 3000
 }
 
 export function useJobPolling<T extends JobInfo>({
@@ -45,6 +46,7 @@ export function useJobPolling<T extends JobInfo>({
   fetchJobs,
   fetchJobInfo,
   onJobSelect,
+  pollingInterval = 3000,
 }: UseJobPollingProps<T>) {
   const pollingIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
 
@@ -62,7 +64,7 @@ export function useJobPolling<T extends JobInfo>({
 
     pollingIntervalRef.current = setInterval(() => {
       fetchJobs(true);
-    }, 3000);
+    }, pollingInterval);
 
     return () => {
       if (pollingIntervalRef.current) {
@@ -70,7 +72,7 @@ export function useJobPolling<T extends JobInfo>({
       }
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [uuid, name]);
+  }, [uuid, name, pollingInterval]);
 
   const handleJobUpdate = (jobs: T[]) => {
     if (selectedJob) {
diff --git a/src/pages/api/v1/builds/[uuid]/jobs/[jobName]/logs.ts b/src/pages/api/v1/builds/[uuid]/jobs/[jobName]/logs.ts
new file mode 100644
index 00000000..ebb62b1f
--- /dev/null
+++ b/src/pages/api/v1/builds/[uuid]/jobs/[jobName]/logs.ts
@@ -0,0 +1,115 @@
+/**
+ * Copyright 2025 GoodRx, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { NextApiRequest, NextApiResponse } from 'next';
+import rootLogger from 'server/lib/logger';
+import unifiedLogStreamHandler from '../../services/[name]/logs/[jobName]';
+
+const logger = rootLogger.child({
+  filename: __filename,
+});
+
+/**
+ * @openapi
+ * /api/v1/builds/{uuid}/jobs/{jobName}/logs:
+ *   get:
+ *     summary: Get job log streaming information for webhooks
+ *     description: |
+ *       Returns WebSocket endpoint and parameters for streaming job logs from Kubernetes.
+ *       This endpoint provides information needed to establish a WebSocket connection
+ *       for real-time log streaming from webhook jobs.
+ *     tags:
+ *       - Webhooks
+ *       - Jobs
+ *     parameters:
+ *       - in: path
+ *         name: uuid
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: The UUID of the build
+ *       - in: path
+ *         name: jobName
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: The name of the job
+ *     responses:
+ *       200:
+ *         description: Successful response with WebSocket information
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 status:
+ *                   type: string
+ *                   enum: [Active, Complete, Failed, NotFound, Pending]
+ *                   description: Current status of the job
+ *                 websocket:
+ *                   type: object
+ *                   properties:
+ *                     endpoint:
+ *                       type: string
+ *                       example: /api/logs/stream
+ *                     parameters:
+ *                       type: object
+ *                       properties:
+ *                         podName:
+ *                           type: string
+ *                         namespace:
+ *                           type: string
+ *                         follow:
+ *                           type: boolean
+ *                         timestamps:
+ *                           type: boolean
+ *                         container:
+ *                           type: string
+ *                           required: false
+ *                 containers:
+ *                   type: array
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       name:
+ *                         type: string
+ *                       state:
+ *                         type: string
+ *                 error:
+ *                   type: string
+ *                   description: Error message if applicable
+ *       400:
+ *         description: Bad request - missing or invalid parameters
+ *       404:
+ *         description: Build or job not found
+ *       405:
+ *         description: Method not allowed
+ *       500:
+ *         description: Internal server error
+ */
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  logger.info(
+    `method=${req.method} jobName=${req.query.jobName} message="Job logs endpoint called, delegating to unified handler"`
+  );
+
+  // Set type to 'webhook' for job logs
+  req.query.type = 'webhook';
+
+  // Set name to undefined since it's not required for webhook jobs
+  req.query.name = undefined;
+
+  return unifiedLogStreamHandler(req, res);
+}
diff --git a/src/pages/api/v1/builds/[uuid]/services/[name]/logs/[jobName].ts b/src/pages/api/v1/builds/[uuid]/services/[name]/logs/[jobName].ts
index 948d802b..6d85e81d 100644
--- a/src/pages/api/v1/builds/[uuid]/services/[name]/logs/[jobName].ts
+++ b/src/pages/api/v1/builds/[uuid]/services/[name]/logs/[jobName].ts
@@ -51,7 +51,7 @@
  *         required: false
  *         schema:
  *           type: string
- *           enum: [build, deploy]
+ *           enum: [build, deploy, webhook]
  *         description: The type of logs to retrieve (defaults to auto-detection based on job name)
  *     responses:
  *       200:
@@ -190,7 +190,7 @@ interface LogStreamResponse {
   error?: string;
 }
 
-type LogType = 'build' | 'deploy';
+type LogType = 'build' | 'deploy' | 'webhook';
 
 function detectLogType(jobName: string): LogType {
   if (jobName.includes('-buildkit-') || jobName.includes('-kaniko-')) {
@@ -199,6 +199,9 @@ function detectLogType(jobName: string): LogType {
   if (jobName.includes('-helm-')) {
     return 'deploy';
   }
+  if (jobName.includes('webhook') || jobName.includes('wh-')) {
+    return 'webhook';
+  }
   return 'build';
 }
 
@@ -228,14 +231,19 @@ const unifiedLogStreamHandler = async (req: NextApiRequest, res: NextApiResponse
 
   const { uuid, name, jobName, type } = req.query;
 
-  if (typeof uuid !== 'string' || typeof name !== 'string' || typeof jobName !== 'string') {
-    logger.warn(`uuid=${uuid} name=${name} jobName=${jobName} message="Missing or invalid query parameters"`);
+  // For webhook jobs, name can be undefined
+  const isWebhookRequest = type === 'webhook';
+
+  if (typeof uuid !== 'string' || typeof jobName !== 'string' || (!isWebhookRequest && typeof name !== 'string')) {
+    logger.warn(
+      `uuid=${uuid} name=${name} jobName=${jobName} type=${type} message="Missing or invalid query parameters"`
+    );
     return res.status(400).json({ error: 'Missing or invalid parameters' });
   }
 
-  if (type && (typeof type !== 'string' || !['build', 'deploy'].includes(type))) {
+  if (type && (typeof type !== 'string' || !['build', 'deploy', 'webhook'].includes(type))) {
     logger.warn(`type=${type} message="Invalid type parameter"`);
-    return res.status(400).json({ error: 'Invalid type parameter. Must be "build" or "deploy"' });
+    return res.status(400).json({ error: 'Invalid type parameter. Must be "build", "deploy", or "webhook"' });
   }
 
   try {
@@ -269,7 +277,11 @@ const unifiedLogStreamHandler = async (req: NextApiRequest, res: NextApiResponse
     }
 
     const unifiedStatus = mapPodStatusToUnified(podInfo.status);
-    const streamingRequired = unifiedStatus === 'Active' || unifiedStatus === 'Pending';
+    const streamingRequired =
+      unifiedStatus === 'Active' ||
+      unifiedStatus === 'Pending' ||
+      unifiedStatus === 'Complete' ||
+      unifiedStatus === 'Failed';
 
     const response: LogStreamResponse = {
       status: unifiedStatus,
@@ -283,7 +295,7 @@ const unifiedLogStreamHandler = async (req: NextApiRequest, res: NextApiResponse
         parameters: {
           podName: podInfo.podName,
           namespace: namespace,
-          follow: streamingRequired,
+          follow: unifiedStatus === 'Active' || unifiedStatus === 'Pending',
           timestamps: true,
         },
       };
diff --git a/src/pages/builds/[uuid]/webhooks.tsx b/src/pages/builds/[uuid]/webhooks.tsx
new file mode 100644
index 00000000..383261a6
--- /dev/null
+++ b/src/pages/builds/[uuid]/webhooks.tsx
@@ -0,0 +1,629 @@
+/**
+ * Copyright 2025 GoodRx, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useState, useEffect, useRef } from 'react';
+import { useRouter } from 'next/router';
+import axios from 'axios';
+import {
+  PageLayout,
+  ErrorAlert,
+  EmptyState,
+  LoadingBox,
+  LoadingSpinner,
+  TerminalContainer,
+  EmptyTerminalState,
+  LogViewer,
+  EventsViewer,
+  useWebSocketLogs,
+  useJobPolling,
+} from '../../../components/logs';
+
+interface WebhookInvocation {
+  id: number;
+  name: string;
+  type: 'codefresh' | 'docker' | 'command';
+  state: string;
+  status: 'executing' | 'completed' | 'failed';
+  createdAt: string;
+  updatedAt: string;
+  yamlConfig: string;
+  metadata: any;
+  buildId: number;
+  runUUID: string;
+  owner: string;
+}
+
+interface WebhookHistoryResponse {
+  webhooks: WebhookInvocation[];
+}
+
+interface WebhookLogResponse {
+  status: 'executing' | 'completed' | 'failed' | 'not_found';
+  type: 'codefresh' | 'docker' | 'command';
+  metadata: any;
+  websocket?: {
+    endpoint: string;
+    parameters: {
+      podName: string;
+      namespace: string;
+      follow: boolean;
+      timestamps: boolean;
+      container?: string;
+    };
+  };
+  containers?: Array<{
+    name: string;
+    state: string;
+  }>;
+  error?: string;
+}
+
+interface K8sEvent {
+  name: string;
+  namespace: string;
+  reason: string;
+  message: string;
+  type: string;
+  count: number;
+  firstTimestamp?: string;
+  lastTimestamp?: string;
+  eventTime?: string;
+  source?: {
+    component?: string;
+    host?: string;
+  };
+}
+
+export default function WebhookHistory() {
+  const router = useRouter();
+  const { uuid } = router.query;
+
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [webhooks, setWebhooks] = useState<WebhookInvocation[]>([]);
+
+  const [selectedWebhook, setSelectedWebhook] = useState<WebhookInvocation | null>(null);
+  const [webhookInfo, setWebhookInfo] = useState<WebhookLogResponse | null>(null);
+  const [activeContainer, setActiveContainer] = useState<string>('');
+  const [loadingWebhook, setLoadingWebhook] = useState(false);
+
+  const [showTimestamps, setShowTimestamps] = useState(true);
+
+  const [events, setEvents] = useState<K8sEvent[]>([]);
+  const [eventsLoading, setEventsLoading] = useState(false);
+  const [eventsError, setEventsError] = useState<string | null>(null);
+
+  const isMountedRef = useRef(true);
+  const logContainerRef = useRef<HTMLDivElement>(null);
+
+  const {
+    logsByContainer,
+    connectingContainers,
+    error: wsError,
+    connectToContainer,
+    closeAllConnections,
+    setLogsByContainer,
+  } = useWebSocketLogs(showTimestamps, uuid as string);
+
+  useEffect(() => {
+    const originalOverflow = document.body.style.overflow;
+    document.body.style.overflow = 'hidden';
+
+    return () => {
+      isMountedRef.current = false;
+      closeAllConnections();
+      document.body.style.overflow = originalOverflow;
+    };
+  }, [closeAllConnections]);
+
+  useEffect(() => {
+    if (wsError) {
+      setError(wsError);
+    }
+  }, [wsError]);
+
+  useEffect(() => {
+    if (logContainerRef.current) {
+      setTimeout(() => {
+        if (logContainerRef.current) {
+          logContainerRef.current.scrollTop = logContainerRef.current.scrollHeight + 100;
+        }
+      }, 50);
+    }
+  }, [logsByContainer, activeContainer]);
+
+  const fetchWebhooks = async (silent = false) => {
+    try {
+      const response = await axios.get<WebhookHistoryResponse>(`/api/v1/builds/${uuid}/webhooks?limit=20`);
+
+      setWebhooks(response.data.webhooks);
+      setError(null);
+
+      if (!selectedWebhook && response.data.webhooks.length > 0 && !silent) {
+        handleWebhookSelect(response.data.webhooks[0]);
+      }
+
+      if (selectedWebhook) {
+        const updatedWebhook = response.data.webhooks.find((w) => w.id === selectedWebhook.id);
+        if (updatedWebhook && updatedWebhook.status !== selectedWebhook.status) {
+          setSelectedWebhook(updatedWebhook);
+          if (
+            selectedWebhook.status === 'executing' &&
+            (updatedWebhook.status === 'completed' || updatedWebhook.status === 'failed')
+          ) {
+            fetchWebhookInfo(updatedWebhook);
+          }
+        }
+      }
+    } catch (err: any) {
+      if (!silent) {
+        console.error('Error fetching webhooks:', err);
+        setError(err.response?.data?.error || err.message || 'Failed to fetch webhooks');
+      }
+    } finally {
+      if (!silent) {
+        setLoading(false);
+      }
+    }
+  };
+
+  const fetchWebhookInfo = async (webhook: WebhookInvocation) => {
+    try {
+      setLoadingWebhook(true);
+      setError(null);
+      setActiveContainer('');
+
+      // Create webhook info based on type
+      const webhookInfo: WebhookLogResponse = {
+        status: webhook.status,
+        type: webhook.type,
+        metadata: webhook.metadata,
+      };
+
+      if (webhook.type === 'codefresh') {
+        setActiveContainer('codefresh');
+      } else if (webhook.type === 'docker' || webhook.type === 'command') {
+        // Get job name from metadata
+        const jobName =
+          typeof webhook.metadata === 'string' ? JSON.parse(webhook.metadata)?.jobName : webhook.metadata?.jobName;
+
+        if (jobName) {
+          try {
+            const response = await axios.get(`/api/v1/builds/${uuid}/jobs/${jobName}/logs`);
+            webhookInfo.containers = response.data.containers;
+            webhookInfo.websocket = response.data.websocket;
+
+            const mainContainer =
+              webhookInfo.containers.find((c) => !c.name.includes('init')) || webhookInfo.containers[0];
+            setActiveContainer(mainContainer.name);
+
+            fetchWebhookEvents(jobName);
+          } catch (err) {
+            console.error('Error fetching job logs info:', err);
+            // Still set basic info even if logs API fails
+            webhookInfo.containers = [{ name: 'webhook-job', state: 'running' }];
+            setActiveContainer('webhook-job');
+          }
+        }
+      }
+
+      setWebhookInfo(webhookInfo);
+    } catch (err: any) {
+      console.error('Error setting webhook info:', err);
+      setError(err.message || 'Failed to load webhook information');
+    } finally {
+      setLoadingWebhook(false);
+    }
+  };
+
+  const fetchWebhookEvents = async (jobName: string) => {
+    try {
+      setEventsLoading(true);
+      setEventsError(null);
+
+      const response = await axios.get<{ events: K8sEvent[] }>(`/api/v1/builds/${uuid}/jobs/${jobName}/events`);
+
+      setEvents(response.data.events);
+    } catch (err: any) {
+      console.error('Error fetching webhook events:', err);
+      setEventsError(err.response?.data?.error || err.message || 'Failed to fetch events');
+    } finally {
+      setEventsLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    if (
+      activeContainer &&
+      activeContainer !== 'events' &&
+      activeContainer !== 'config' &&
+      activeContainer !== 'metadata' &&
+      activeContainer !== 'codefresh' &&
+      webhookInfo?.websocket
+    ) {
+      connectToContainer(activeContainer, webhookInfo);
+    }
+  }, [activeContainer, webhookInfo, connectToContainer]);
+
+  const handleWebhookSelect = async (webhook: WebhookInvocation) => {
+    closeAllConnections();
+
+    setSelectedWebhook(webhook);
+    setLogsByContainer({});
+    setWebhookInfo(null);
+    setActiveContainer('');
+    setEvents([]);
+    setEventsError(null);
+
+    await fetchWebhookInfo(webhook);
+  };
+
+  useJobPolling({
+    uuid: uuid as string,
+    name: 'webhooks',
+    selectedJob: selectedWebhook as any,
+    setSelectedJob: (webhook) => setSelectedWebhook(webhook as WebhookInvocation),
+    setJobs: (webhooks) => setWebhooks(webhooks as WebhookInvocation[]),
+    fetchJobs: fetchWebhooks,
+    fetchJobInfo: fetchWebhookInfo as any,
+    onJobSelect: handleWebhookSelect as any,
+    pollingInterval: 30000,
+  });
+
+  const handleTabChange = (containerName: string) => {
+    setActiveContainer(containerName);
+  };
+
+  const getContainerDisplayName = (containerName: string): string => {
+    if (containerName === 'codefresh') return 'Codefresh Link';
+    if (containerName === 'config') return 'Configuration';
+    if (containerName === 'metadata') return 'Metadata';
+    if (containerName.includes('[init]')) return containerName;
+    return containerName;
+  };
+
+  const renderWebhookBadges = (webhook: WebhookInvocation) => (
+    <div style={{ display: 'flex', gap: '6px', marginTop: '4px' }}>
+      <span
+        style={{
+          backgroundColor: webhook.type === 'codefresh' ? '#4f46e5' : webhook.type === 'docker' ? '#0ea5e9' : '#8b5cf6',
+          color: '#fff',
+          padding: '2px 6px',
+          borderRadius: '3px',
+          fontSize: '10px',
+          fontWeight: 500,
+        }}
+      >
+        {webhook.type}
+      </span>
+      <span
+        style={{
+          backgroundColor: '#374151',
+          color: '#d1d5db',
+          padding: '2px 6px',
+          borderRadius: '3px',
+          fontSize: '10px',
+          fontWeight: 500,
+        }}
+      >
+        {webhook.state}
+      </span>
+    </div>
+  );
+
+  const CustomJobHistoryTable = ({ jobs, selectedJob, onJobSelect, title }: any) => (
+    <div
+      style={{
+        backgroundColor: 'white',
+        borderRadius: '12px',
+        overflow: 'hidden',
+        boxShadow: '0 1px 3px rgba(0,0,0,0.1)',
+        display: 'flex',
+        flexDirection: 'column',
+        height: '100%',
+      }}
+    >
+      <div
+        style={{
+          padding: '16px 20px',
+          borderBottom: '1px solid #eee',
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'space-between',
+        }}
+      >
+        <h2 style={{ fontSize: '16px', fontWeight: 600, color: '#333', margin: 0 }}>{title}</h2>
+        <div style={{ fontSize: '12px', color: '#666' }}>Latest 20 invocations</div>
+      </div>
+      <div style={{ flex: 1, overflow: 'auto' }}>
+        <table style={{ width: '100%', borderSpacing: 0 }}>
+          <thead>
+            <tr style={{ backgroundColor: '#f9fafb', borderBottom: '1px solid #eee', position: 'sticky', top: 0 }}>
+              <th style={{ padding: '12px 20px', textAlign: 'left', fontSize: '14px', fontWeight: 600, color: '#666' }}>
+                Name
+              </th>
+              <th style={{ padding: '12px 20px', textAlign: 'left', fontSize: '14px', fontWeight: 600, color: '#666' }}>
+                Status
+              </th>
+              <th style={{ padding: '12px 20px', textAlign: 'left', fontSize: '14px', fontWeight: 600, color: '#666' }}>
+                Execution Time
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            {jobs.map((webhook: any) => (
+              <tr
+                key={webhook.id}
+                onClick={() => onJobSelect(webhook)}
+                style={{
+                  cursor: 'pointer',
+                  borderBottom: '1px solid #eee',
+                  backgroundColor: selectedJob?.id === webhook.id ? '#f3f4f6' : 'transparent',
+                  transition: 'background-color 0.15s',
+                }}
+                onMouseEnter={(e) => {
+                  if (selectedJob?.id !== webhook.id) {
+                    e.currentTarget.style.backgroundColor = '#f9fafb';
+                  }
+                }}
+                onMouseLeave={(e) => {
+                  if (selectedJob?.id !== webhook.id) {
+                    e.currentTarget.style.backgroundColor = 'transparent';
+                  }
+                }}
+              >
+                <td style={{ padding: '16px 20px' }}>
+                  <div>
+                    <div style={{ fontSize: '14px', fontWeight: 500, color: '#333', marginBottom: '4px' }}>
+                      {webhook.name}
+                    </div>
+                    {renderWebhookBadges(webhook)}
+                  </div>
+                </td>
+                <td style={{ padding: '16px 20px' }}>
+                  <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
+                    <div
+                      style={{
+                        width: '8px',
+                        height: '8px',
+                        borderRadius: '50%',
+                        backgroundColor:
+                          webhook.status === 'completed'
+                            ? '#10b981'
+                            : webhook.status === 'failed'
+                            ? '#dc2626'
+                            : webhook.status === 'executing'
+                            ? '#3b82f6'
+                            : '#f59e0b',
+                        ...(webhook.status === 'executing' && {
+                          animation: 'pulse 2s infinite',
+                        }),
+                      }}
+                    />
+                    <span
+                      style={{
+                        fontSize: '14px',
+                        fontWeight: 500,
+                        color:
+                          webhook.status === 'completed'
+                            ? '#10b981'
+                            : webhook.status === 'failed'
+                            ? '#dc2626'
+                            : webhook.status === 'executing'
+                            ? '#3b82f6'
+                            : '#f59e0b',
+                      }}
+                    >
+                      {webhook.status}
+                    </span>
+                  </div>
+                </td>
+                <td style={{ padding: '16px 20px', fontSize: '14px', color: '#666' }}>
+                  {new Date(webhook.createdAt).toLocaleString()}
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  );
+
+  const renderCodefreshView = () => {
+    const link = selectedWebhook?.metadata?.link;
+    return (
+      <div
+        style={{
+          padding: '20px',
+          color: '#fff',
+          fontFamily: 'Monaco, Consolas, monospace',
+          fontSize: '14px',
+          height: '100%',
+          overflow: 'auto',
+        }}
+      >
+        {link ? (
+          <div>
+            <div style={{ marginBottom: '16px', color: '#666' }}>Codefresh Pipeline Link:</div>
+            <a
+              href={link}
+              target="_blank"
+              rel="noopener noreferrer"
+              style={{
+                color: '#60a5fa',
+                textDecoration: 'underline',
+                wordBreak: 'break-all',
+              }}
+            >
+              {link}
+            </a>
+          </div>
+        ) : (
+          <div style={{ color: '#666' }}>No link available</div>
+        )}
+      </div>
+    );
+  };
+
+  const renderConfigView = () => {
+    let config;
+    try {
+      config = JSON.parse(selectedWebhook?.yamlConfig || '{}');
+    } catch {
+      config = selectedWebhook?.yamlConfig || '';
+    }
+
+    return (
+      <div
+        style={{
+          padding: '20px',
+          color: '#fff',
+          fontFamily: 'Monaco, Consolas, monospace',
+          fontSize: '12px',
+          height: '100%',
+          overflow: 'auto',
+        }}
+      >
+        <pre style={{ margin: 0, whiteSpace: 'pre-wrap' }}>
+          {typeof config === 'string' ? config : JSON.stringify(config, null, 2)}
+        </pre>
+      </div>
+    );
+  };
+
+  const renderMetadataView = () => {
+    return (
+      <div
+        style={{
+          padding: '20px',
+          color: '#fff',
+          fontFamily: 'Monaco, Consolas, monospace',
+          fontSize: '12px',
+          height: '100%',
+          overflow: 'auto',
+        }}
+      >
+        <pre style={{ margin: 0, whiteSpace: 'pre-wrap' }}>
+          {JSON.stringify(selectedWebhook?.metadata || {}, null, 2)}
+        </pre>
+      </div>
+    );
+  };
+
+  return (
+    <>
+      <PageLayout backLink={`/builds/${uuid}`} title="Webhook History" environmentId={uuid as string}>
+        {error && !selectedWebhook && <ErrorAlert error={error} />}
+
+        {loading ? (
+          <LoadingBox message="Loading webhooks..." />
+        ) : webhooks.length === 0 ? (
+          <EmptyState title="No webhooks found" description="Did you forget to invite them to the party?" />
+        ) : (
+          <div
+            style={{
+              display: 'grid',
+              gridTemplateColumns: '600px 1fr',
+              gap: '24px',
+              alignItems: 'stretch',
+              flex: 1,
+              minHeight: 0,
+            }}
+          >
+            <CustomJobHistoryTable
+              jobs={webhooks}
+              selectedJob={selectedWebhook}
+              onJobSelect={handleWebhookSelect}
+              title="Webhook History"
+            />
+
+            <div
+              style={{
+                backgroundColor: '#1a1a1a',
+                borderRadius: '12px',
+                overflow: 'hidden',
+                boxShadow: '0 1px 3px rgba(0,0,0,0.1)',
+                display: 'flex',
+                flexDirection: 'column',
+                height: '100%',
+                minHeight: '400px',
+              }}
+            >
+              {selectedWebhook ? (
+                <TerminalContainer
+                  jobName={selectedWebhook.name}
+                  containers={
+                    webhookInfo?.type === 'codefresh'
+                      ? [
+                          { name: 'codefresh', state: 'running' },
+                          { name: 'config', state: 'running' },
+                          { name: 'metadata', state: 'running' },
+                        ]
+                      : [
+                          ...(webhookInfo?.containers || []),
+                          { name: 'config', state: 'running' },
+                          { name: 'metadata', state: 'running' },
+                        ]
+                  }
+                  activeContainer={activeContainer}
+                  onTabChange={handleTabChange}
+                  connectingContainers={connectingContainers}
+                  getContainerDisplayName={getContainerDisplayName}
+                  showTimestamps={showTimestamps}
+                  onTimestampsToggle={() => setShowTimestamps(!showTimestamps)}
+                  showEventsTab={webhookInfo?.type !== 'codefresh'}
+                >
+                  {loadingWebhook ? (
+                    <div
+                      style={{
+                        display: 'flex',
+                        alignItems: 'center',
+                        justifyContent: 'center',
+                        height: '100%',
+                        color: '#666',
+                      }}
+                    >
+                      <LoadingSpinner size={24} />
+                      <span style={{ marginLeft: '12px' }}>Loading webhook details...</span>
+                    </div>
+                  ) : activeContainer === 'codefresh' ? (
+                    renderCodefreshView()
+                  ) : activeContainer === 'config' ? (
+                    renderConfigView()
+                  ) : activeContainer === 'metadata' ? (
+                    renderMetadataView()
+                  ) : activeContainer === 'events' ? (
+                    <EventsViewer events={events} loading={eventsLoading} error={eventsError} />
+                  ) : (
+                    <LogViewer
+                      logs={logsByContainer[activeContainer] || []}
+                      isConnecting={connectingContainers.includes(activeContainer)}
+                      containerRef={logContainerRef}
+                      showTimestamps={showTimestamps}
+                      containerState={webhookInfo?.containers?.find((c) => c.name === activeContainer)?.state}
+                    />
+                  )}
+                </TerminalContainer>
+              ) : (
+                <EmptyTerminalState type="webhook" />
+              )}
+            </div>
+          </div>
+        )}
+      </PageLayout>
+    </>
+  );
+}
diff --git a/src/server/lib/jsonschema/schemas/1.0.0.json b/src/server/lib/jsonschema/schemas/1.0.0.json
index 41f358c8..4895c3ff 100644
--- a/src/server/lib/jsonschema/schemas/1.0.0.json
+++ b/src/server/lib/jsonschema/schemas/1.0.0.json
@@ -106,12 +106,58 @@
                 "required": [
                   "branch"
                 ]
+              },
+              "docker": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "image": {
+                    "type": "string"
+                  },
+                  "command": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "args": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "timeout": {
+                    "type": "number"
+                  }
+                },
+                "required": [
+                  "image"
+                ]
+              },
+              "command": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "image": {
+                    "type": "string"
+                  },
+                  "script": {
+                    "type": "string"
+                  },
+                  "timeout": {
+                    "type": "number"
+                  }
+                },
+                "required": [
+                  "image",
+                  "script"
+                ]
               }
             },
             "required": [
               "state",
               "type",
-              "pipelineId",
+              "env",
               "trigger",
               "env"
             ]
diff --git a/src/server/lib/kubernetes/common/serviceAccount.ts b/src/server/lib/kubernetes/common/serviceAccount.ts
index 0b9a05b7..30811265 100644
--- a/src/server/lib/kubernetes/common/serviceAccount.ts
+++ b/src/server/lib/kubernetes/common/serviceAccount.ts
@@ -20,7 +20,10 @@ import { setupServiceAccountInNamespace } from '../../nativeHelm/utils';
 
 const logger = rootLogger.child({ filename: 'lib/kubernetes/serviceAccount.ts' });
 
-export async function ensureServiceAccountForJob(namespace: string, jobType: 'build' | 'deploy'): Promise<string> {
+export async function ensureServiceAccountForJob(
+  namespace: string,
+  jobType: 'build' | 'deploy' | 'webhook'
+): Promise<string> {
   const { serviceAccount } = await GlobalConfigService.getInstance().getAllConfigs();
   const serviceAccountName = serviceAccount?.name || 'default';
   const role = serviceAccount?.role || 'default';
diff --git a/src/server/lib/kubernetes/webhookJobFactory.ts b/src/server/lib/kubernetes/webhookJobFactory.ts
new file mode 100644
index 00000000..91b0852f
--- /dev/null
+++ b/src/server/lib/kubernetes/webhookJobFactory.ts
@@ -0,0 +1,108 @@
+/**
+ * Copyright 2025 GoodRx, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { V1Job } from '@kubernetes/client-node';
+import { createKubernetesJob, JobConfig } from './jobFactory';
+import { randomAlphanumeric } from 'server/lib/random';
+
+export interface WebhookJobConfig {
+  name: string;
+  namespace: string;
+  serviceAccount: string;
+  buildUuid: string;
+  buildId: string;
+  buildSha?: string;
+  webhookName: string;
+  webhookType: 'docker' | 'command';
+  image: string;
+  command?: string[];
+  args?: string[];
+  script?: string;
+  env: Record<string, string>;
+  timeout?: number;
+}
+
+const DEFAULT_WEBHOOK_TIMEOUT = 1800; // 30 minutes
+const DEFAULT_RESOURCES = {
+  requests: { cpu: '200m', memory: '1Gi' },
+  limits: { cpu: '200m', memory: '1Gi' },
+};
+
+export function createWebhookJob(config: WebhookJobConfig): V1Job {
+  const jobId = randomAlphanumeric(4).toLowerCase();
+  const sanitizedWebhookName =
+    config.webhookName
+      ?.toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .substring(0, 20) || 'webhook';
+
+  const shortSha = config.buildSha ? config.buildSha.substring(0, 7) : 'unknown';
+
+  let jobName = `wh-${sanitizedWebhookName}-${config.buildUuid}-${jobId}-${shortSha}`.substring(0, 63);
+  if (jobName.endsWith('-')) {
+    jobName = jobName.slice(0, -1);
+  }
+
+  const timeout = config.timeout || DEFAULT_WEBHOOK_TIMEOUT;
+  const ttl = 86400; // 24 hours
+
+  // Create container configuration based on webhook type
+  let container: any;
+  if (config.webhookType === 'docker') {
+    container = {
+      name: 'webhook-executor',
+      image: config.image,
+      command: config.command,
+      args: config.args,
+      env: Object.entries(config.env).map(([name, value]) => ({ name, value })),
+      resources: DEFAULT_RESOURCES,
+    };
+  } else if (config.webhookType === 'command') {
+    // For command type, we wrap the script in a shell command
+    container = {
+      name: 'webhook-executor',
+      image: config.image,
+      command: ['/bin/sh', '-c'],
+      args: [config.script],
+      env: Object.entries(config.env).map(([name, value]) => ({ name, value })),
+      resources: DEFAULT_RESOURCES,
+    };
+  }
+
+  const jobConfig: JobConfig = {
+    name: jobName,
+    namespace: config.namespace,
+    appName: 'webhook',
+    component: 'build',
+    serviceAccount: config.serviceAccount,
+    timeout,
+    ttl,
+    labels: {
+      lc_uuid: config.buildUuid,
+      'lfc/uuid': config.buildUuid,
+      'lfc/build_id': String(config.buildId),
+      'lfc/webhook_name': sanitizedWebhookName,
+      'lfc/webhook_type': config.webhookType,
+    },
+    annotations: {
+      'lfc/webhook_name': config.webhookName,
+      'lfc/webhook_type': config.webhookType,
+    },
+    containers: [container],
+  };
+
+  return createKubernetesJob(jobConfig);
+}
diff --git a/src/server/lib/webhook/index.ts b/src/server/lib/webhook/index.ts
new file mode 100644
index 00000000..0f984dd3
--- /dev/null
+++ b/src/server/lib/webhook/index.ts
@@ -0,0 +1,155 @@
+/**
+ * Copyright 2025 GoodRx, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import yaml from 'js-yaml';
+import fs from 'fs';
+import { Build } from 'server/models';
+import { Webhook } from 'server/models/yaml';
+import { createWebhookJob, WebhookJobConfig } from 'server/lib/kubernetes/webhookJobFactory';
+import { shellPromise } from 'server/lib/shell';
+import { waitForJobAndGetLogs } from 'server/lib/nativeBuild/utils';
+import { ensureServiceAccountForJob } from 'server/lib/kubernetes/common/serviceAccount';
+import rootLogger from 'server/lib/logger';
+import { nanoid } from 'nanoid';
+
+const logger = rootLogger.child({
+  filename: 'lib/webhook/index.ts',
+});
+
+const MANIFEST_PATH = process.env.MANIFEST_PATH || '/tmp/lifecycle/manifests';
+
+export interface WebhookExecutionResult {
+  success: boolean;
+  jobName: string;
+  logs: string;
+  status: string;
+  metadata?: Record<string, any>;
+}
+
+export async function executeDockerWebhook(
+  webhook: Webhook,
+  build: Build,
+  resolvedEnv: Record<string, string>
+): Promise<WebhookExecutionResult> {
+  if (!webhook.docker) {
+    throw new Error('Docker webhook configuration is missing');
+  }
+
+  const namespace = build.namespace;
+  const serviceAccountName = await ensureServiceAccountForJob(namespace, 'webhook');
+
+  const jobConfig: WebhookJobConfig = {
+    name: webhook.name || 'docker-webhook',
+    namespace,
+    serviceAccount: serviceAccountName,
+    buildUuid: build.uuid,
+    buildId: String(build.id),
+    buildSha: build.sha,
+    webhookName: webhook.name || 'docker-webhook',
+    webhookType: 'docker',
+    image: webhook.docker.image,
+    command: webhook.docker.command,
+    args: webhook.docker.args,
+    env: resolvedEnv,
+    timeout: webhook.docker.timeout,
+  };
+
+  return executeWebhookJob(jobConfig, build);
+}
+
+export async function executeCommandWebhook(
+  webhook: Webhook,
+  build: Build,
+  resolvedEnv: Record<string, string>
+): Promise<WebhookExecutionResult> {
+  if (!webhook.command) {
+    throw new Error('Command webhook configuration is missing');
+  }
+
+  const namespace = build.namespace;
+  const serviceAccountName = await ensureServiceAccountForJob(namespace, 'webhook');
+
+  const jobConfig: WebhookJobConfig = {
+    name: webhook.name || 'command-webhook',
+    namespace,
+    serviceAccount: serviceAccountName,
+    buildUuid: build.uuid,
+    buildId: String(build.id),
+    buildSha: build.sha,
+    webhookName: webhook.name || 'command-webhook',
+    webhookType: 'command',
+    image: webhook.command.image,
+    script: webhook.command.script,
+    env: resolvedEnv,
+    timeout: webhook.command.timeout,
+  };
+
+  return executeWebhookJob(jobConfig, build);
+}
+
+async function executeWebhookJob(jobConfig: WebhookJobConfig, build: Build): Promise<WebhookExecutionResult> {
+  const executionId = nanoid();
+  logger.info(`[WEBHOOK ${build.uuid}] Starting ${jobConfig.webhookType} webhook: ${jobConfig.webhookName}`, {
+    buildUuid: build.uuid,
+    webhookName: jobConfig.webhookName,
+    webhookType: jobConfig.webhookType,
+    executionId,
+  });
+
+  try {
+    const job = createWebhookJob(jobConfig);
+    const manifest = yaml.dump(job);
+
+    const manifestDir = `${MANIFEST_PATH}/webhooks`;
+    await fs.promises.mkdir(manifestDir, { recursive: true });
+    const manifestPath = `${manifestDir}/${job.metadata.name}-${executionId}.yaml`;
+    await fs.promises.writeFile(manifestPath, manifest, 'utf8');
+    await shellPromise(`kubectl apply -f ${manifestPath}`);
+
+    const jobResult = await waitForJobAndGetLogs(job.metadata.name, jobConfig.namespace, `[WEBHOOK ${build.uuid}]`);
+
+    logger.info(`[WEBHOOK ${build.uuid}] Webhook execution completed`, {
+      buildUuid: build.uuid,
+      webhookName: jobConfig.webhookName,
+      success: jobResult.success,
+      status: jobResult.status,
+    });
+
+    return {
+      success: jobResult.success,
+      jobName: job.metadata.name,
+      logs: jobResult.logs,
+      status: jobResult.status || (jobResult.success ? 'succeeded' : 'failed'),
+      metadata: {},
+    };
+  } catch (error) {
+    logger.error(`[WEBHOOK ${build.uuid}] Webhook execution failed`, {
+      buildUuid: build.uuid,
+      webhookName: jobConfig.webhookName,
+      error: error.message,
+    });
+
+    return {
+      success: false,
+      jobName: '',
+      logs: error.message,
+      status: 'failed',
+      metadata: {
+        error: error.message,
+      },
+    };
+  }
+}
diff --git a/src/server/lib/webhook/webhookValidator.ts b/src/server/lib/webhook/webhookValidator.ts
new file mode 100644
index 00000000..7504ca07
--- /dev/null
+++ b/src/server/lib/webhook/webhookValidator.ts
@@ -0,0 +1,109 @@
+/**
+ * Copyright 2025 GoodRx, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Webhook } from 'server/models/yaml';
+
+export interface WebhookValidationError {
+  field: string;
+  message: string;
+}
+
+/**
+ * Validates webhook configuration based on its type
+ * @param webhook The webhook to validate
+ * @returns Array of validation errors, empty if valid
+ */
+export function validateWebhook(webhook: Webhook): WebhookValidationError[] {
+  const errors: WebhookValidationError[] = [];
+
+  // Common validations
+  if (!webhook.type) {
+    errors.push({ field: 'type', message: 'Webhook type is required' });
+    return errors; // Can't validate further without type
+  }
+
+  if (!webhook.state) {
+    errors.push({ field: 'state', message: 'Webhook state is required' });
+  }
+
+  if (!webhook.env || typeof webhook.env !== 'object') {
+    errors.push({ field: 'env', message: 'Webhook env must be an object' });
+  }
+
+  // Type-specific validations
+  switch (webhook.type) {
+    case 'codefresh':
+      if (!webhook.pipelineId) {
+        errors.push({ field: 'pipelineId', message: 'Pipeline ID is required for codefresh webhooks' });
+      }
+      if (!webhook.trigger) {
+        errors.push({ field: 'trigger', message: 'Trigger is required for codefresh webhooks' });
+      }
+      break;
+
+    case 'docker':
+      if (!webhook.docker) {
+        errors.push({ field: 'docker', message: 'Docker configuration is required for docker webhooks' });
+      } else {
+        if (!webhook.docker.image) {
+          errors.push({ field: 'docker.image', message: 'Docker image is required' });
+        }
+        if (webhook.docker.timeout && (webhook.docker.timeout <= 0 || webhook.docker.timeout > 86400)) {
+          errors.push({ field: 'docker.timeout', message: 'Docker timeout must be between 1 and 86400 seconds' });
+        }
+      }
+      break;
+
+    case 'command':
+      if (!webhook.command) {
+        errors.push({ field: 'command', message: 'Command configuration is required for command webhooks' });
+      } else {
+        if (!webhook.command.image) {
+          errors.push({ field: 'command.image', message: 'Command image is required' });
+        }
+        if (!webhook.command.script) {
+          errors.push({ field: 'command.script', message: 'Command script is required' });
+        }
+        if (webhook.command.timeout && (webhook.command.timeout <= 0 || webhook.command.timeout > 86400)) {
+          errors.push({ field: 'command.timeout', message: 'Command timeout must be between 1 and 86400 seconds' });
+        }
+      }
+      break;
+
+    default:
+      errors.push({ field: 'type', message: `Invalid webhook type: ${webhook.type}` });
+  }
+
+  return errors;
+}
+
+/**
+ * Validates all webhooks in an array
+ * @param webhooks Array of webhooks to validate
+ * @returns Map of webhook index to validation errors
+ */
+export function validateWebhooks(webhooks: Webhook[]): Map<number, WebhookValidationError[]> {
+  const errorMap = new Map<number, WebhookValidationError[]>();
+
+  webhooks.forEach((webhook, index) => {
+    const errors = validateWebhook(webhook);
+    if (errors.length > 0) {
+      errorMap.set(index, errors);
+    }
+  });
+
+  return errorMap;
+}
diff --git a/src/server/lib/yamlConfigValidator.ts b/src/server/lib/yamlConfigValidator.ts
index df37f07b..e6748ae7 100644
--- a/src/server/lib/yamlConfigValidator.ts
+++ b/src/server/lib/yamlConfigValidator.ts
@@ -40,7 +40,10 @@ export class ValidationError extends LifecycleError {
   }
 }
 
-JsonSchema.Validator.prototype.customFormats.webhookType = (input) => input === 'codefresh';
+JsonSchema.Validator.prototype.customFormats.webhookType = (input) => {
+  const validTypes = ['codefresh', 'docker', 'command'];
+  return validTypes.includes(input);
+};
 JsonSchema.Validator.prototype.customFormats.webhookState = (input) => {
   let result: boolean = false;
 
diff --git a/src/server/lib/yamlSchemas/schema_1_0_0/schema_1_0_0.ts b/src/server/lib/yamlSchemas/schema_1_0_0/schema_1_0_0.ts
index 10fcd99a..2b004a60 100644
--- a/src/server/lib/yamlSchemas/schema_1_0_0/schema_1_0_0.ts
+++ b/src/server/lib/yamlSchemas/schema_1_0_0/schema_1_0_0.ts
@@ -17,6 +17,7 @@
 import { kedaScaleToZero } from './keda';
 import { deployment } from './deployment';
 import { docker } from './docker';
+import { webhooks } from './webhooks';
 
 const schema_1_0_0 = {
   id: 'schema-1.0.0',
@@ -62,27 +63,7 @@ const schema_1_0_0 = {
             required: ['name'],
           },
         },
-        webhooks: {
-          type: 'array',
-          minItems: 1,
-          items: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-              name: { type: 'string' },
-              description: { type: 'string' },
-              state: { type: 'string', format: 'webhookState' },
-              type: { type: 'string', format: 'webhookType' },
-              pipelineId: { type: 'string' },
-              trigger: { type: 'string' },
-              env: {
-                type: 'object',
-                required: ['branch'],
-              },
-            },
-            required: ['state', 'type', 'pipelineId', 'trigger', 'env'],
-          },
-        },
+        webhooks,
       },
     },
     services: {
diff --git a/src/server/lib/yamlSchemas/schema_1_0_0/webhooks.ts b/src/server/lib/yamlSchemas/schema_1_0_0/webhooks.ts
new file mode 100644
index 00000000..f65f2c1a
--- /dev/null
+++ b/src/server/lib/yamlSchemas/schema_1_0_0/webhooks.ts
@@ -0,0 +1,75 @@
+/**
+ * Copyright 2025 GoodRx, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const dockerWebhookConfig = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    image: { type: 'string' },
+    command: {
+      type: 'array',
+      items: { type: 'string' },
+    },
+    args: {
+      type: 'array',
+      items: { type: 'string' },
+    },
+    timeout: { type: 'number' },
+  },
+  required: ['image'],
+};
+
+const commandWebhookConfig = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    image: { type: 'string' },
+    script: { type: 'string' },
+    timeout: { type: 'number' },
+  },
+  required: ['image', 'script'],
+};
+
+const webhooks = {
+  type: 'array',
+  minItems: 1,
+  items: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      name: { type: 'string' },
+      description: { type: 'string' },
+      state: { type: 'string', format: 'webhookState' },
+      type: { type: 'string', format: 'webhookType' },
+
+      // Codefresh-specific fields (optional for new types)
+      pipelineId: { type: 'string' },
+      trigger: { type: 'string' },
+
+      // Docker webhook configuration
+      docker: dockerWebhookConfig,
+
+      // Command webhook configuration
+      command: commandWebhookConfig,
+
+      // Environment variables (required for all types)
+      env: { type: 'object' },
+    },
+    required: ['state', 'type', 'env'],
+  },
+};
+
+export { webhooks };
diff --git a/src/server/models/yaml/YamlWebhook.ts b/src/server/models/yaml/YamlWebhook.ts
index f6cb8ce8..8f0d355a 100644
--- a/src/server/models/yaml/YamlWebhook.ts
+++ b/src/server/models/yaml/YamlWebhook.ts
@@ -14,12 +14,35 @@
  * limitations under the License.
  */
 
+export interface DockerWebhookConfig {
+  readonly image: string;
+  readonly command?: string[];
+  readonly args?: string[];
+  readonly timeout?: number; // seconds, default 1800 (30 min)
+}
+
+export interface CommandWebhookConfig {
+  readonly image: string;
+  readonly script: string;
+  readonly timeout?: number; // seconds, default 1800 (30 min)
+}
+
 export interface Webhook {
   readonly name?: string;
   readonly description?: string;
   readonly state: string;
-  readonly type: string;
-  readonly pipelineId: string;
-  readonly trigger: string;
+  readonly type: string; // 'codefresh' | 'docker' | 'command'
+
+  // Codefresh-specific fields (required when type === 'codefresh')
+  readonly pipelineId?: string;
+  readonly trigger?: string;
+
+  // Docker webhook configuration (required when type === 'docker')
+  readonly docker?: DockerWebhookConfig;
+
+  // Command webhook configuration (required when type === 'command')
+  readonly command?: CommandWebhookConfig;
+
+  // Environment variables for all webhook types
   readonly env: Record<string, string>;
 }
diff --git a/src/server/services/webhook.ts b/src/server/services/webhook.ts
index d76143d5..5b954561 100644
--- a/src/server/services/webhook.ts
+++ b/src/server/services/webhook.ts
@@ -25,6 +25,8 @@ import { ConfigFileWebhookEnvironmentVariables } from 'server/lib/configFileWebh
 import { LifecycleError } from 'server/lib/errors';
 import { JOB_VERSION } from 'shared/config';
 import { redisClient } from 'server/lib/dependencies';
+import { validateWebhook } from 'server/lib/webhook/webhookValidator';
+import { executeDockerWebhook, executeCommandWebhook } from 'server/lib/webhook';
 
 const logger = rootLogger.child({
   filename: 'services/webhook.ts',
@@ -120,30 +122,119 @@ export default class WebhookService extends BaseService {
    * @param build
    */
   private async runYamlConfigFileWebhookForBuild(webhook: YamlService.Webhook, build: Build): Promise<void> {
+    // Validate webhook configuration
+    const validationErrors = validateWebhook(webhook);
+    if (validationErrors.length > 0) {
+      const errorMessage = validationErrors.map((e) => `${e.field}: ${e.message}`).join(', ');
+      throw new Error(`Invalid webhook configuration: ${errorMessage}`);
+    }
+
     const envVariables = await new ConfigFileWebhookEnvironmentVariables(this.db).resolve(build, webhook);
     const data = merge(envVariables, build.commentRuntimeEnv);
+
     try {
-      const buildId: string = await this.db.services.Codefresh.triggerYamlConfigWebhookPipeline(webhook, data);
-      logger
-        .child({ url: `https://g.codefresh.io/build/${buildId}` })
-        .info(`[BUILD ${build.uuid}] Webhook (${webhook.name}) triggered: ${buildId}`);
-
-      const metadata = {
-        link: `https://g.codefresh.io/build/${buildId}`,
-      };
-      // create the invocation history record
+      let metadata: Record<string, any> = {};
+
+      switch (webhook.type) {
+        case 'codefresh': {
+          const buildId: string = await this.db.services.Codefresh.triggerYamlConfigWebhookPipeline(webhook, data);
+          logger
+            .child({ url: `https://g.codefresh.io/build/${buildId}` })
+            .info(`[BUILD ${build.uuid}] Webhook (${webhook.name}) triggered: ${buildId}`);
+          metadata = {
+            link: `https://g.codefresh.io/build/${buildId}`,
+          };
+          await this.db.models.WebhookInvocations.create({
+            buildId: build.id,
+            runUUID: build.runUUID,
+            name: webhook.name,
+            type: webhook.type,
+            state: webhook.state,
+            yamlConfig: JSON.stringify(webhook),
+            metadata,
+            status: 'completed',
+          });
+          break;
+        }
+
+        case 'docker': {
+          const invocation = await this.db.models.WebhookInvocations.create({
+            buildId: build.id,
+            runUUID: build.runUUID,
+            name: webhook.name,
+            type: webhook.type,
+            state: webhook.state,
+            yamlConfig: JSON.stringify(webhook),
+            metadata: { status: 'starting' },
+            status: 'executing',
+          });
+          logger.info(`[BUILD ${build.uuid}] Docker webhook (${webhook.name}) invoked`);
+
+          // Execute webhook (this waits for completion)
+          const result = await executeDockerWebhook(webhook, build, data);
+          logger.info(`[BUILD ${build.uuid}] Docker webhook (${webhook.name}) executed: ${result.jobName}`);
+
+          // Update the invocation record with final status
+          await invocation.$query().patch({
+            metadata: {
+              jobName: result.jobName,
+              success: result.success,
+              ...result.metadata,
+            },
+            status: result.success ? 'completed' : 'failed',
+          });
+
+          break;
+        }
+
+        case 'command': {
+          const invocation = await this.db.models.WebhookInvocations.create({
+            buildId: build.id,
+            runUUID: build.runUUID,
+            name: webhook.name,
+            type: webhook.type,
+            state: webhook.state,
+            yamlConfig: JSON.stringify(webhook),
+            metadata: { status: 'starting' },
+            status: 'executing',
+          });
+          logger.info(`[BUILD ${build.uuid}] Command webhook (${webhook.name}) invoked`);
+
+          // Execute webhook (this waits for completion)
+          const result = await executeCommandWebhook(webhook, build, data);
+          logger.info(`[BUILD ${build.uuid}] Command webhook (${webhook.name}) executed: ${result.jobName}`);
+
+          // Update the invocation record with final status
+          await invocation.$query().patch({
+            metadata: {
+              jobName: result.jobName,
+              success: result.success,
+              ...result.metadata,
+            },
+            status: result.success ? 'completed' : 'failed',
+          });
+
+          break;
+        }
+        default:
+          throw new Error(`Unsupported webhook type: ${webhook.type}`);
+      }
+
+      logger.debug(`[BUILD ${build.uuid}] Webhook history added for runUUID: ${build.runUUID}`);
+    } catch (error) {
+      logger.error(`[BUILD ${build.uuid}] Error invoking webhook: ${error}`);
+
+      // Still create a failed invocation record
       await this.db.models.WebhookInvocations.create({
         buildId: build.id,
         runUUID: build.runUUID,
         name: webhook.name,
+        type: webhook.type,
         state: webhook.state,
         yamlConfig: JSON.stringify(webhook),
-        metadata,
-        status: 'invoked',
+        metadata: { error: error.message },
+        status: 'failed',
       });
-      logger.debug(`[BUILD ${build.uuid}] Webhook history added for runUUID: ${build.runUUID}`);
-    } catch (error) {
-      logger.error(`[BUILD ${build.uuid}] Error invoking webhook: ${error}`);
     }
   }