@adityanair98/api-oracle 0.5.0

package/src/entries/testing/checkly.json

@@ -0,0 +1,89 @@
+{
+  "name": "Checkly",
+  "slug": "checkly",
+  "category": "testing",
+  "subcategory": "api-monitoring",
+  "website": "https://checklyhq.com",
+  "description": "Checkly is a monitoring-as-code platform that runs Playwright browser checks and API checks on a schedule to verify your production app is working. Write checks as code (JavaScript/TypeScript), deploy via CLI, and get alerting when they fail. Think synthetic testing meets uptime monitoring.",
+  "useCases": [
+    {
+      "task": "Monitor production API endpoints with scheduled health checks",
+      "fit": "perfect"
+    },
+    {
+      "task": "Run Playwright E2E tests against production on a schedule",
+      "fit": "perfect"
+    },
+    {
+      "task": "Get alerted when a critical user journey breaks in production",
+      "fit": "good"
+    },
+    {
+      "task": "Verify third-party API integrations are still working",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create a Checkly account at checklyhq.com",
+      "Navigate to User Settings in the top-right menu",
+      "Click on API Keys and then Create API Key",
+      "Copy the generated API key",
+      "Run npx checkly login or set CHECKLY_API_KEY and CHECKLY_ACCOUNT_ID as environment variables"
+    ],
+    "envVarName": "CHECKLY_API_KEY",
+    "codeSnippet": "// CHECKLY_API_KEY=your_api_key\n// CHECKLY_ACCOUNT_ID=your_account_id\n\n// Login via CLI (stores credentials locally)\n// npx checkly login\n\n// Or set env vars for CI environments\nimport { ApiCheck } from '@checkly/cli/constructs';\n\nnew ApiCheck('homepage-health', {\n  name: 'Homepage health check',\n  request: {\n    url: 'https://api.example.com/health',\n    method: 'GET',\n    assertions: [\n      { source: 'STATUS_CODE', comparison: 'EQUALS', target: '200' },\n    ],\n  },\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Free: 10,000 check runs/month, 2 team members, 5 minute check interval",
+    "startingPrice": "$20/month (Developer) for 50,000 check runs/month, 1 minute interval, private locations",
+    "costPer": null,
+    "pricingUrl": "https://www.checklyhq.com/pricing/"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "Check frequency minimum: 5 minutes (free), 1 minute (paid). Maximum check execution: 30 seconds for API checks, 4 minutes for browser checks.",
+    "notes": "Check run credits roll over within the month. Browser checks (Playwright) consume 2x check run credits vs API checks. Alerting is real-time with no delay.",
+    "retryStrategy": "Set check.retryStrategy to LINEAR or EXPONENTIAL in check config to handle transient failures. Configure alerting thresholds (e.g., alert after 2 consecutive failures)."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @checkly/cli",
+    "importStatement": "import { ApiCheck, BrowserCheck, CheckGroup } from '@checkly/cli/constructs';",
+    "otherLanguages": ["javascript"]
+  },
+  "codeExamples": [
+    {
+      "title": "Define an API health check with Checkly CLI",
+      "language": "typescript",
+      "code": "import { ApiCheck, AssertionBuilder, Frequency } from '@checkly/cli/constructs';\n\nnew ApiCheck('orders-api-health', {\n  name: 'Orders API — health endpoint',\n  activated: true,\n  muted: false,\n  frequency: Frequency.EVERY_5M,\n  locations: ['us-east-1', 'eu-west-1'],\n  tags: ['api', 'production'],\n  request: {\n    url: 'https://api.example.com/v1/health',\n    method: 'GET',\n    followRedirects: true,\n    timeout: 10_000,\n    assertions: [\n      AssertionBuilder.statusCode().equals(200),\n      AssertionBuilder.responseTime().lessThan(2000),\n      AssertionBuilder.jsonBody('$.status').equals('ok'),\n    ],\n  },\n  retryStrategy: {\n    type: 'LINEAR',\n    baseBackoffSeconds: 60,\n    maxRetries: 2,\n    maxDurationSeconds: 600,\n  },\n  alertChannels: [],\n});",
+      "notes": "Use AssertionBuilder for type-safe assertion definitions. Deploy with: npx checkly deploy. The check runs from all specified AWS regions simultaneously, so you detect region-specific outages."
+    },
+    {
+      "title": "Define a Playwright browser check",
+      "language": "typescript",
+      "code": "import { BrowserCheck, Frequency } from '@checkly/cli/constructs';\nimport * as path from 'path';\n\nnew BrowserCheck('checkout-flow', {\n  name: 'Checkout flow — add to cart and proceed',\n  activated: true,\n  frequency: Frequency.EVERY_10M,\n  locations: ['us-east-1', 'eu-central-1'],\n  tags: ['browser', 'critical-path'],\n  code: {\n    entrypoint: path.join(__dirname, 'checkout.spec.ts'),\n  },\n  retryStrategy: {\n    type: 'EXPONENTIAL',\n    baseBackoffSeconds: 30,\n    maxRetries: 2,\n    maxDurationSeconds: 300,\n  },\n});\n\n// In checkout.spec.ts (co-located file):\n// import { test, expect } from '@playwright/test';\n// test('add to cart and proceed to checkout', async ({ page }) => {\n//   await page.goto('https://shop.example.com');\n//   await page.getByRole('button', { name: 'Add to cart' }).first().click();\n//   await page.getByRole('link', { name: 'Checkout' }).click();\n//   await expect(page).toHaveURL(/checkout/);\n// });",
+      "notes": "Browser checks reference a separate Playwright spec file via entrypoint. The spec file must live alongside the check definition. Each browser check run consumes 2x credits on the free tier. Set frequency conservatively (every 10 minutes) for credit-heavy browser checks."
+    }
+  ],
+  "gotchas": [
+    "Checkly browser checks (Playwright) use their own isolated version of Playwright, not the version installed in your project. Playwright API changes between versions can cause checks written for a newer Playwright version to fail on Checkly if they haven't updated yet. Pin your Playwright syntax to a common, stable API.",
+    "Check run credits on the free tier (10,000/month) sound like a lot, but a 5-minute interval check running 24/7 consumes 12×24×30 = 8,640 credits/month. Two such checks nearly exhaust the free tier. Plan check frequency carefully.",
+    "Checkly runs from global check locations (AWS regions). If your API requires IP allowlisting, you need to allowlist all Checkly IP addresses — which change when new regions are added. Use Checkly Private Locations instead for self-hosted environments."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA (paid plans)",
+    "statusPageUrl": "https://status.checklyhq.com",
+    "notes": "AWS-hosted multi-region infrastructure. Check results are stored independently of the monitored service, ensuring alerting continues even during partial outages."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Best monitoring-as-code platform for teams that want Playwright-level testing in production on a schedule. The Checkly CLI is excellent — checks defined as code means they're version-controlled and reviewable. Generous free tier for small projects. Main limitation: browser check credit consumption and Playwright version lag.",
+  "alternatives": ["browserstack"],
+  "complementary": ["vercel", "fly-io", "sentry"],
+  "bestFor": "Synthetic monitoring of production APIs and user journeys — run Playwright checks on a schedule and get alerted the moment a critical flow breaks",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/workflow/inngest.json

@@ -0,0 +1,88 @@
+{
+  "name": "Inngest",
+  "slug": "inngest",
+  "category": "workflow",
+  "subcategory": "background-jobs",
+  "website": "https://www.inngest.com",
+  "description": "Event-driven background job platform for TypeScript and JavaScript. Write durable functions as plain code that respond to events, with built-in retries, step functions, scheduling, and fan-out. No separate queue infrastructure needed — integrates via HTTP with any serverless platform.",
+  "useCases": [
+    {
+      "task": "Run background tasks after user actions",
+      "fit": "perfect"
+    },
+    {
+      "task": "Orchestrate multi-step workflows with error recovery",
+      "fit": "perfect"
+    },
+    {
+      "task": "Run scheduled and cron jobs",
+      "fit": "perfect"
+    },
+    {
+      "task": "Process incoming webhook events",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create an account at inngest.com",
+      "Create a new app in the Inngest dashboard to get an event key and signing key",
+      "Set the INNGEST_EVENT_KEY and INNGEST_SIGNING_KEY environment variables in your app",
+      "Install the SDK and serve the Inngest handler at the /api/inngest route in your framework (Next.js, Express, Fastify, etc.)"
+    ],
+    "envVarName": "INNGEST_EVENT_KEY",
+    "codeSnippet": "import { Inngest } from 'inngest';\n\nexport const inngest = new Inngest({\n  id: 'my-app',\n  eventKey: process.env.INNGEST_EVENT_KEY,\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Free: 50,000 function runs/month, 3-day log retention",
+    "startingPrice": "$25/month (Basic) for 150,000 runs/month",
+    "costPer": null,
+    "pricingUrl": "https://www.inngest.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "50,000 function runs/month, 3-day log history, community support",
+    "notes": "Inngest functions run wherever your app runs (Vercel, Railway, Fly.io). The local dev server (npx inngest-cli@latest dev) runs entirely offline without an account.",
+    "retryStrategy": "Built-in automatic retry on thrown errors with exponential backoff. Configure via the retries option in createFunction or the function definition object. Step functions (step.run()) only retry the failed step, not the entire function."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact inngest",
+    "importStatement": "import { Inngest } from \"inngest\";",
+    "otherLanguages": ["python", "go"]
+  },
+  "codeExamples": [
+    {
+      "title": "Define and trigger an Inngest function",
+      "language": "typescript",
+      "code": "// lib/inngest.ts — shared client\nimport { Inngest } from 'inngest';\n\nexport const inngest = new Inngest({\n  id: 'my-app',\n  eventKey: process.env.INNGEST_EVENT_KEY,\n});\n\n// inngest/send-welcome-email.ts — function definition\nimport { inngest } from '../lib/inngest';\n\nexport const sendWelcomeEmail = inngest.createFunction(\n  { id: 'send-welcome-email', retries: 3 },\n  { event: 'user/signup.created' },\n  async ({ event, step }) => {\n    const { userId, email } = event.data;\n\n    await step.run('send-email', async () => {\n      // Any thrown error here triggers a retry of this step only\n      await fetch('https://api.email.com/send', {\n        method: 'POST',\n        body: JSON.stringify({ to: email, subject: 'Welcome!' }),\n      });\n    });\n\n    return { sent: true, userId };\n  }\n);\n\n// app/api/route.ts — trigger an event from your API\nimport { inngest } from '../../lib/inngest';\n\nexport async function POST(req: Request) {\n  const body = await req.json();\n\n  await inngest.send({\n    name: 'user/signup.created',\n    data: { userId: body.userId, email: body.email },\n  });\n\n  return Response.json({ ok: true });\n}",
+      "notes": "The Inngest handler must also be served at /api/inngest. In Next.js App Router: export the handler from app/api/inngest/route.ts using the serve() helper from 'inngest/next'."
+    },
+    {
+      "title": "Multi-step workflow with step.run()",
+      "language": "typescript",
+      "code": "import { inngest } from '../lib/inngest';\nimport { db } from '../lib/db';\nimport { resend } from '../lib/resend';\n\nexport const onboardUser = inngest.createFunction(\n  { id: 'onboard-user', retries: 5 },\n  { event: 'user/signup.created' },\n  async ({ event, step }) => {\n    const { userId } = event.data;\n\n    // Step 1: Fetch user data — retried independently if it fails\n    const user = await step.run('fetch-user', async () => {\n      return db.users.findUnique({ where: { id: userId } });\n    });\n\n    // Step 2: Send welcome email — only runs after step 1 succeeds\n    await step.run('send-welcome-email', async () => {\n      await resend.emails.send({\n        from: 'hello@acme.com',\n        to: user.email,\n        subject: 'Welcome to Acme!',\n        html: `<h1>Hi ${user.name}!</h1>`,\n      });\n    });\n\n    // Step 3: Update onboarding status in DB\n    await step.run('mark-onboarded', async () => {\n      await db.users.update({\n        where: { id: userId },\n        data: { onboardedAt: new Date() },\n      });\n    });\n\n    return { userId, onboarded: true };\n  }\n);",
+      "notes": "Each step.run() call is individually memoized. If step 3 fails and retries, Inngest replays the function but skips steps 1 and 2 using stored results — they do not re-execute."
+    }
+  ],
+  "gotchas": [
+    "Inngest functions are deployed as part of your existing app, not as standalone workers. Your app must expose an /api/inngest HTTP endpoint that Inngest calls via webhook. If your server is down or cold-starts too slowly, function invocations can be delayed or missed.",
+    "The free tier's 3-day log retention makes debugging intermittent production issues difficult. Any log or run older than 3 days cannot be retrieved from the dashboard. For any production app, the paid tier with 30-day retention is practically required.",
+    "Code outside of step.run() blocks runs on every replay. When Inngest retries a function, it replays the entire function from the top but skips completed steps using memoized results. Any side effects (API calls, database writes) placed outside step.run() will execute multiple times. Always wrap effectful code in step.run()."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA (Pro tier)",
+    "statusPageUrl": "https://www.inngeststatus.com",
+    "notes": "Functions execute within your own infrastructure. Inngest acts as an event relay and orchestration layer. Your app's reliability directly affects function execution reliability."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Excellent developer experience — works within your existing framework (Next.js, Express, Fastify) without a separate worker process. Step functions with automatic memoization and per-step retries are genuinely powerful for complex workflows. The local dev server with no account required is a standout feature. Slight drawback: free tier log retention is too short for production debugging.",
+  "alternatives": ["trigger-dev", "temporal"],
+  "complementary": ["vercel", "resend", "stripe", "supabase", "neon"],
+  "bestFor": "Event-driven background jobs and multi-step workflows that run within your existing serverless or server infrastructure",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/workflow/temporal.json

@@ -0,0 +1,90 @@
+{
+  "name": "Temporal",
+  "slug": "temporal",
+  "category": "workflow",
+  "subcategory": "workflow-engine",
+  "website": "https://temporal.io",
+  "description": "Open-source, battle-tested distributed workflow engine for running durable, fault-tolerant long-running processes. Write complex business logic as ordinary code; Temporal handles persistence, retries, timeouts, and recovery from infrastructure failures automatically.",
+  "useCases": [
+    {
+      "task": "Orchestrate multi-service business processes",
+      "fit": "perfect"
+    },
+    {
+      "task": "Long-running workflows spanning days or weeks with human approval steps",
+      "fit": "perfect"
+    },
+    {
+      "task": "Saga patterns for distributed transactions with compensating actions",
+      "fit": "perfect"
+    },
+    {
+      "task": "Run reliable scheduled tasks and cron jobs",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "For self-hosted: install Temporal server via Docker using 'docker compose up temporal' from the temporalio/docker-compose repository",
+      "Install the TypeScript SDK packages: @temporalio/client, @temporalio/worker, @temporalio/workflow, @temporalio/activity",
+      "Connect workers to localhost:7233 for local development",
+      "For Temporal Cloud: create a namespace at cloud.temporal.io and generate an API key from account settings",
+      "Set the TEMPORAL_API_KEY and TEMPORAL_NAMESPACE environment variables for Temporal Cloud connections"
+    ],
+    "envVarName": "TEMPORAL_API_KEY",
+    "codeSnippet": "import { Client, Connection } from '@temporalio/client';\n\nconst connection = await Connection.connect({\n  address: process.env.TEMPORAL_ADDRESS ?? 'localhost:7233',\n  // For Temporal Cloud, add TLS and API key options here\n});\n\nexport const client = new Client({ connection,\n  namespace: process.env.TEMPORAL_NAMESPACE ?? 'default',\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Self-host: completely free and unlimited. Temporal Cloud: free trial with $1,000 in credits",
+    "startingPrice": "Temporal Cloud: usage-based, approximately $0.42 per 1M workflow actions",
+    "costPer": "$0.42/1M workflow actions (executions, signals, queries, timers each count as one action)",
+    "pricingUrl": "https://temporal.io/pricing"
+  },
+  "rateLimits": {
+    "tier": "self-hosted",
+    "limit": "No limits when self-hosted. Temporal Cloud: configurable rate limits per namespace.",
+    "notes": "Self-hosted Temporal can handle millions of concurrent workflows depending on your database and server resources. Temporal Cloud scales automatically but has namespace-level rate limits that can be raised by contacting support.",
+    "retryStrategy": "Built-in. RetryPolicy in ActivityOptions controls maxAttempts and backoff coefficients. Workflows are automatically replayed from their event history on worker restart — no in-flight data is lost across restarts or failures."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @temporalio/client @temporalio/worker @temporalio/workflow @temporalio/activity",
+    "importStatement": "import { Client } from \"@temporalio/client\";",
+    "otherLanguages": ["go", "java", "python", "php", "dotnet"]
+  },
+  "codeExamples": [
+    {
+      "title": "Define a Workflow with Activities and start it from a Client",
+      "language": "typescript",
+      "code": "// activities.ts — I/O and side effects go here\nimport type { ActivityOptions } from '@temporalio/activity';\n\nexport async function processPayment(orderId: string, amount: number): Promise<string> {\n  // Call your payment provider SDK here\n  const result = await stripe.charges.create({ amount, currency: 'usd' });\n  return result.id;\n}\n\nexport async function sendConfirmationEmail(orderId: string, chargeId: string): Promise<void> {\n  await resend.emails.send({\n    from: 'orders@acme.com',\n    to: 'customer@example.com',\n    subject: `Order ${orderId} confirmed`,\n    html: `<p>Charge ID: ${chargeId}</p>`,\n  });\n}\n\n// workflow.ts — must be fully deterministic; no I/O, no Date.now(), no Math.random()\nimport { proxyActivities, log } from '@temporalio/workflow';\nimport type * as activities from './activities';\n\nconst { processPayment, sendConfirmationEmail } = proxyActivities<typeof activities>({\n  startToCloseTimeout: '30 seconds',\n  retry: { maximumAttempts: 3 },\n});\n\nexport async function orderWorkflow(orderId: string, amount: number): Promise<void> {\n  log.info('Starting order workflow', { orderId });\n  const chargeId = await processPayment(orderId, amount);\n  await sendConfirmationEmail(orderId, chargeId);\n  log.info('Order workflow complete', { orderId, chargeId });\n}\n\n// worker.ts — runs as a long-lived process alongside your app server\nimport { Worker } from '@temporalio/worker';\nimport * as activities from './activities';\n\nconst worker = await Worker.create({\n  workflowsPath: require.resolve('./workflow'),\n  activities,\n  taskQueue: 'orders',\n});\nawait worker.run();\n\n// client-usage.ts — start the workflow from an API route\nimport { client } from './temporal-client';\n\nconst handle = await client.workflow.start(orderWorkflow, {\n  taskQueue: 'orders',\n  workflowId: `order-${orderId}`,\n  args: [orderId, amount],\n});\nconsole.log('Workflow started:', handle.workflowId);",
+      "notes": "Activity functions contain all I/O and side effects. Workflow functions must be deterministic — all non-deterministic operations (network calls, timestamps, randomness) must be wrapped inside activities."
+    },
+    {
+      "title": "Long-running workflow with human approval signal",
+      "language": "typescript",
+      "code": "import {\n  defineSignal,\n  setHandler,\n  condition,\n  proxyActivities,\n  sleep,\n} from '@temporalio/workflow';\nimport type * as activities from './activities';\n\nexport const approveSignal = defineSignal<[{ approved: boolean; reviewerId: string }]>('approve');\n\nconst { requestHumanReview, processApprovedWithdrawal, notifyRejected } =\n  proxyActivities<typeof activities>({ startToCloseTimeout: '10 seconds' });\n\nexport async function withdrawalApprovalWorkflow(\n  withdrawalId: string,\n  amount: number\n): Promise<string> {\n  let approvalResult: { approved: boolean; reviewerId: string } | null = null;\n\n  // Register a signal handler — external callers can send this signal to the workflow\n  setHandler(approveSignal, (result) => {\n    approvalResult = result;\n  });\n\n  // Notify the review team that action is needed\n  await requestHumanReview(withdrawalId, amount);\n\n  // Wait up to 48 hours for a human to send the approval signal\n  const approved = await condition(() => approvalResult !== null, '48 hours');\n\n  if (!approved || !approvalResult?.approved) {\n    await notifyRejected(withdrawalId);\n    return 'rejected';\n  }\n\n  await processApprovedWithdrawal(withdrawalId, amount);\n  return `approved-by-${approvalResult.reviewerId}`;\n}",
+      "notes": "The workflow sleeps durably — the worker process can restart, crash, or be redeployed during the 48-hour wait and the workflow will resume correctly. Send the signal via: client.workflow.getHandle(workflowId).signal(approveSignal, { approved: true, reviewerId: 'alice' })"
+    }
+  ],
+  "gotchas": [
+    "Temporal Workflows must be strictly deterministic. You cannot use Date.now(), Math.random(), or make direct network/database calls inside a workflow function. All I/O must live in Activities. The TypeScript sandbox enforces this at runtime, but non-deterministic code that slips through causes workflow history replay failures — these are extremely difficult to diagnose in production.",
+    "Temporal requires a continuously running worker process alongside your application server. Unlike Inngest or Trigger.dev, Temporal is NOT serverless — you must keep workers deployed and running. This adds meaningful infrastructure overhead: you need to manage worker scaling, health checks, and restarts separately from your app.",
+    "Temporal Cloud pricing is per workflow action, where a single workflow execution can generate dozens of actions (one per activity, signal, timer, query, etc.). This makes costs nearly impossible to estimate without load testing. Always profile workflow action counts under realistic load before committing to Temporal Cloud for cost-sensitive use cases.",
+    "The event history for a single workflow execution is limited to 51,200 events by default on Temporal Cloud. Workflows with large loops, many activities, or indefinite runtimes will hit this limit and fail with a hard error. Use the Continue-as-New pattern (continueAsNew()) to reset history for workflows that must run indefinitely."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.99% SLA (Temporal Cloud)",
+    "statusPageUrl": "https://status.temporal.io",
+    "notes": "Temporal Cloud is fully managed with global multi-region replication and automatic failover. Self-hosted deployments require operating a highly available Temporal server cluster with a supported database (PostgreSQL, MySQL, or Cassandra)."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "The most powerful open-source workflow engine available — handles failures, retries, and persistent state automatically in a way that no other tool matches. Genuinely solves hard distributed systems problems that would otherwise require complex custom infrastructure. High learning curve (determinism constraint, worker management, new mental model) and infrastructure overhead make it best suited for teams with complex, mission-critical workflow needs rather than simple background jobs.",
+  "alternatives": ["trigger-dev", "inngest"],
+  "complementary": ["neon", "stripe", "resend"],
+  "bestFor": "Complex, long-running distributed workflows requiring bulletproof fault tolerance — order processing, financial transactions, and multi-step human-in-the-loop processes",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/workflow/trigger-dev.json

@@ -0,0 +1,89 @@
+{
+  "name": "Trigger.dev",
+  "slug": "trigger-dev",
+  "category": "workflow",
+  "subcategory": "background-jobs",
+  "website": "https://trigger.dev",
+  "description": "Open-source background job and workflow platform with a developer-first SDK. Write jobs as plain TypeScript functions with built-in retries, delays, concurrency controls, and real-time monitoring dashboard. No separate queue infrastructure needed.",
+  "useCases": [
+    {
+      "task": "Send emails after user signup",
+      "fit": "perfect"
+    },
+    {
+      "task": "Process uploaded files in the background",
+      "fit": "perfect"
+    },
+    {
+      "task": "Run scheduled cron jobs",
+      "fit": "perfect"
+    },
+    {
+      "task": "Fan-out tasks with parallelism",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create an account at trigger.dev",
+      "Create a new project in the dashboard",
+      "Copy the secret key from the project settings page",
+      "Set the TRIGGER_SECRET_KEY environment variable in your app",
+      "Install the SDK and optionally set TRIGGER_API_URL if self-hosting"
+    ],
+    "envVarName": "TRIGGER_SECRET_KEY",
+    "codeSnippet": "import { TriggerClient } from '@trigger.dev/sdk';\n\nexport const client = new TriggerClient({\n  id: 'my-app',\n  apiKey: process.env.TRIGGER_SECRET_KEY,\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Hobby: 50,000 runs/month, 60-day log retention",
+    "startingPrice": "$10/month (Pro) for 100K runs/month with team access",
+    "costPer": "$0.001/run after included monthly quota",
+    "pricingUrl": "https://trigger.dev/pricing"
+  },
+  "rateLimits": {
+    "tier": "cloud hobby",
+    "limit": "50K runs/month included, up to 15-minute execution duration per run",
+    "notes": "Runs can be paused and resumed using waitFor and waitForEvent. Concurrency can be configured per task. The free tier resets monthly.",
+    "retryStrategy": "Built-in retry with configurable maxAttempts (default: 3) and exponential backoff. Set retry.maxAttempts: 0 to disable."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @trigger.dev/sdk",
+    "importStatement": "import { task, logger } from '@trigger.dev/sdk/v3';",
+    "otherLanguages": []
+  },
+  "codeExamples": [
+    {
+      "title": "Define and trigger a background task",
+      "language": "typescript",
+      "code": "// src/trigger/send-welcome-email.ts\nimport { task, logger } from '@trigger.dev/sdk/v3';\nimport { sendEmail } from '../lib/email';\n\nexport const sendWelcomeEmail = task({\n  id: 'send-welcome-email',\n  run: async (payload: { userId: string; email: string }) => {\n    logger.log('Sending welcome email', { userId: payload.userId });\n\n    await sendEmail({\n      to: payload.email,\n      subject: 'Welcome!',\n      html: '<h1>Welcome aboard</h1>',\n    });\n\n    return { success: true };\n  },\n});\n\n// In your API route:\nimport { sendWelcomeEmail } from '../trigger/send-welcome-email';\n\n// Fire-and-forget: returns a handle immediately\nconst handle = await sendWelcomeEmail.trigger({\n  userId: 'user_123',\n  email: 'jane@example.com',\n});\n\nconsole.log('Triggered run:', handle.id);",
+      "notes": "Tasks must be exported from files inside the trigger/ directory (or wherever TRIGGER_DIRS points). The task id must be unique across your project."
+    },
+    {
+      "title": "Task with retry configuration and delay",
+      "language": "typescript",
+      "code": "import { task, logger, wait } from '@trigger.dev/sdk/v3';\nimport { fetchExternalData, processData } from '../lib/data';\n\nexport const processUserData = task({\n  id: 'process-user-data',\n  retry: {\n    maxAttempts: 5,\n    factor: 2,\n    minTimeoutInMs: 1_000,\n    maxTimeoutInMs: 30_000,\n  },\n  run: async (payload: { userId: string }) => {\n    logger.log('Processing user data', { userId: payload.userId });\n\n    const raw = await fetchExternalData(payload.userId);\n\n    // Pause the run for 30 seconds (does not block a worker thread)\n    await wait.for({ seconds: 30 });\n\n    const result = await processData(raw);\n\n    logger.log('Processing complete', { result });\n    return result;\n  },\n});",
+      "notes": "wait.for() suspends the run without consuming worker capacity. The run resumes automatically after the delay. Retries use exponential backoff with jitter between minTimeoutInMs and maxTimeoutInMs."
+    }
+  ],
+  "gotchas": [
+    "Trigger.dev v3 (current) is a major rewrite from v2. The defineJob API from v2 is replaced by task. Any documentation or examples using defineJob are outdated and will not work with the v3 SDK.",
+    "Tasks must be registered with Trigger.dev at build time via the trigger deploy command (or trigger dev for local development). You cannot dynamically define or register tasks at runtime — the task id must be statically known.",
+    "Long-running tasks must be split into sub-tasks or use checkpoints. The Hobby tier has a 60-second max execution duration per run; Pro allows up to 15 minutes. For tasks that need to run longer, use triggerAndWait() to chain tasks sequentially or use wait.for() to pause mid-run."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% for cloud (Pro tier)",
+    "statusPageUrl": "https://status.trigger.dev",
+    "notes": "Self-hosted deployment is supported on any Node.js-compatible host. Cloud uses isolated workers per customer. The open-source codebase can be self-hosted with Docker."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "The best open-source background job platform for TypeScript developers. Writing jobs as plain TypeScript functions with live log streaming and local dev mode is an outstanding DX. The v3 rewrite addressed major limitations of v2. Main drawback is a smaller ecosystem compared to Inngest and a steeper initial setup with the deploy step.",
+  "alternatives": ["inngest", "temporal"],
+  "complementary": ["resend", "supabase", "neon", "stripe", "uploadthing"],
+  "bestFor": "TypeScript-first background jobs and workflows with long-running task support and a great local development experience",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}