DEV Community: Moksh Gupta

AI Release Management in 2026: Which Tools Actually Take an Action

Moksh Gupta — Mon, 07 Sep 2026 18:29:52 +0000

Shipping the artifact stopped being the interesting problem a while ago. What still hurts is the window right after rollout, where the 5xx rate has moved by half a percent, the p99 chart has a new shape, and one person has to call it: noise, or the leading edge of a regression that needs pulling.

Google's DORA team put numbers on that window. The 2025 State of AI-assisted Software Development report surveyed close to 5,000 practitioners and found 90 percent using AI at work, with over 80 percent reporting a productivity gain. It also found that AI adoption correlates negatively with software delivery stability, even though its correlation with throughput finally turned positive this year. Faster shipping, more breakage. I dug into the whole category and wrote it up in full on DevToolLab; this is the compressed version.

Two Different Products, One Label

Vendors put "AI release management" on two things that behave nothing alike, and telling them apart is most of the buying decision.

One is statistical deployment verification, which is older than the current AI hype cycle. It records what your metrics and logs looked like before the change, routes a fraction of traffic to the new build, runs tests against that recorded baseline, and then either advances or reverts on its own. That is a closed loop, and it is the thing that keeps an incident short. Harness, Argo Rollouts, Flagger and Kayenta from the Spinnaker project all sit here.

The other is a language model wired into a deploy tool: it summarizes a broken pipeline, drafts release notes, proposes a fix. Genuinely handy during a postmortem, and completely passive. It will not touch traffic at 3 AM. So the question to ask a vendor is not "is there a model in here" but "what is it allowed to do without me".

The Short Version

Tool	Behavior during a release	Reverts on its own	License and cost, checked September 2026
Harness	Baselines logs and metrics, correlates drift across endpoints	Yes, or gates for review	Proprietary, no public pricing
Argo Rollouts	Executes metric queries as rollout steps	Yes	Apache 2.0, free, v1.10.0
Flagger	Canary analysis plus per-step conformance webhooks	Yes	Apache 2.0, free, v1.45.0
LaunchDarkly	Sequential testing against guardrail metrics	Yes, if enabled	Proprietary, free tier then metered
Octopus Deploy	Explains a failed deployment, suggests recovery	No, diagnosis only	Proprietary, $2,080/yr self-hosted
Statsig	Experiment analysis via CUPED and sequential testing	Through a flag, not a deploy	Proprietary, free to roughly $150/mo
Unleash	Kill switches and staged rollout, no analysis engine	Manual flip	AGPL-3.0, free to self-host

Harness

Harness has stopped being coy about this: the relevant product page is called AI Verification and leads with "Rollback before customers know it's broken."

Mechanically it snapshots logs and metrics before the release, diffs them against live telemetry from your observability vendor, and correlates findings across endpoints before reaching a verdict. You pick the consequence: revert automatically, hold at a review gate, or page a named engineer. It ingests metrics from AppDynamics, Datadog, Prometheus and CloudWatch plus roughly fifteen more, and logs from Splunk, Elasticsearch, Grafana Loki and Google Cloud Ops, so an existing APM contract does most of the integration work. The friction is procurement: Harness lists tiers and quotas, 60 concurrent pipeline executions on Essentials against 500 on Enterprise, but publishes no dollar figures anywhere.

Argo Rollouts

If Argo CD is already in your cluster, this is the cheapest possible way to get automated reverts, because you are adding a controller rather than a vendor. Argo Rollouts ships a set of CRDs that give blue-green and canary strategies, with analysis, to workloads that would otherwise only get a rolling update. Release 1.10.0 landed on August 27, 2026 under Apache 2.0, and the repo sits around 3,600 stars.

What turns it from a traffic splitter into a verifier is the AnalysisTemplate, bundling a metric query with a success condition and a failure tolerance, then plugging in as a rollout step. Recent work has concentrated on the Kubernetes Gateway API plugin, collapsing per-mesh integrations into one standard surface.

Flagger

Flagger is the equivalent operator from the Flux ecosystem, and the obvious answer if your GitOps flow is Flux rather than Argo. Version 1.45.0 came out on September 1, 2026, also Apache 2.0, with the repo near 5,400 stars.

It ramps traffic in stages while sampling metrics and running conformance checks, aborting the moment thresholds fail. Canary, A/B and blue/green mirroring work across App Mesh, Istio, Linkerd and Kuma, or ingress controllers such as Contour, NGINX, Traefik and APISIX, with analysis from Prometheus, InfluxDB, Datadog, New Relic, CloudWatch or Graphite. Its edge over Argo Rollouts is the webhook: any HTTP endpoint can run at any step, so a smoke test lives inside the promotion gate rather than a separate CI job.

LaunchDarkly

LaunchDarkly solves the same problem one layer up, at the flag rather than the deployment, and its guarded rollout genuinely closes the loop. It steps traffic onto a new variation while sampling metrics you choose, applying sequential testing to judge whether the gap is a real regression rather than noise. Once the confidence interval lands wholly on the bad side of your criteria, it marks the regression, pings the flag owner, and reverts by itself if you switched that on. Guardrails can be built from errors, latency, clicks or conversions, fed by integrations, SDK events, the metric import API, or OpenTelemetry traces.

Billing moved off seats. Developer costs nothing: unlimited seats, 5 service connections, 1,000 client-side MAU and 5,000 AI runs monthly. Foundation meters at $10 per service connection plus $8.33 per 1,000 client-side MAU, with 5,000 AI runs bundled and $5 per extra 1,000. Enterprise is quoted. Guarded rollouts exist on every tier, but the fuller Release Monitoring capability is a Guardian add-on restricted to Enterprise, and that is the line item that changes the quote.

Octopus Deploy

Octopus is the cleanest illustration of category two, and refreshingly upfront about it. Recovery Agent identifies the root cause of a failed deployment in a click, the Octopus AI Assistant is a Chrome extension that spins up projects from prompts and reads deployment logs, and the Octopus MCP Server exposes change management and auditing to outside agents. All of it compresses the gap between breakage and comprehension. None of it stands between a bad build and your users.

What Octopus is genuinely good at is governed orchestration over many environments and tenants, a separate discipline from canary analysis, and it publishes real numbers. Cloud runs $0, $4,330 and $24,600 per year across Free, Professional and Enterprise; the self-hosted server is $0, $2,080 and $15,600. Projects are the unit of scale, Free stops at 10 projects, tenants, machines and users, and more headroom costs $770 per year.

Statsig

Statsig is a strong product that mostly belongs here as a reminder about a criterion nobody puts on the evaluation sheet. It runs warehouse-native against Snowflake, BigQuery or Databricks, leans on CUPED and sequential testing, and costs between nothing and about $150 a month before overages.

The awkward part is who owns it. OpenAI bought Statsig for $1.1 billion in all stock, announced September 2025, and founder Vijaye Raji moved over as CTO of Applications. By May 2026 Amplitude had absorbed the brand and customer base while OpenAI kept the engineers, a split the site now advertises with a "Statsig is part of the Amplitude family" banner. Optimizely CEO Alex Atzberger called it "a race car without a driver." Anything holding a gate in front of production deserves a boring ownership story.

Unleash

Unleash runs no analysis engine and makes no claim to, yet its homepage frames the problem better than any competitor: "Friends don't let friends ship AI-generated code without feature flags," sold as governance for machine-written software. That is essentially the DORA result rendered as marketing copy.

In practice it hands you the bluntest and most dependable revert available, a switch that kills a feature with no deploy, plus staged rollout through activation strategies. Licensing is AGPL-3.0-or-later, the repo is near 13,800 stars, and it self-hosts anywhere on PostgreSQL. Two constraints before you standardize on it: the open-source build caps you at 1 project, 2 environments and 5,000 flags per instance, and open-source Unleash Edge hits end of life on December 31, 2026, after which edge evaluation is Enterprise-only.

Wiring Up a Gate in Two Manifests

None of this requires replatforming. With Argo Rollouts installed, automated reverts are two YAML files. The first encodes your definition of healthy as a query, a threshold and a failure budget.

apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: error-rate
spec:
  args:
    - name: service-name
  metrics:
    - name: error-rate
      interval: 1m
      count: 5
      successCondition: result[0] < 0.01
      failureLimit: 1
      provider:
        prometheus:
          address: http://prometheus.monitoring.svc.cluster.local:9090
          query: |
            sum(rate(http_requests_total{service="{{args.service-name}}",status=~"5.."}[2m]))
            /
            sum(rate(http_requests_total{service="{{args.service-name}}"}[2m]))

The second drops that template between two traffic weights, so 10 percent of users get the new build for five minutes, the analysis runs, and 50 percent only happens if errors stayed below 1 percent across all five samples.

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: checkout-api
spec:
  replicas: 6
  strategy:
    canary:
      steps:
        - setWeight: 10
        - pause: { duration: 5m }
        - analysis:
            templates:
              - templateName: error-rate
            args:
              - name: service-name
                value: checkout-api
        - setWeight: 50
        - pause: { duration: 10m }

Both files parse, and the strategy resolves to five canary steps ordered setWeight, pause, analysis, setWeight, pause. Three settings decide whether this earns its keep. Choose a signal that genuinely fails when the service fails, usually 5xx rate or tail latency and almost never CPU. Leave failureLimit above zero, or one bad scrape discards a healthy release. And multiply interval by count, because that is exactly how long every gate parks your traffic. The Latency Percentile Calculator turns raw samples into a defensible p99 threshold, and the Uptime SLA Calculator converts an availability target into the error budget that failure limit spends. The longer DevToolLab writeup covers how each vendor's analysis differs.

Picking One

Running Argo CD already? Argo Rollouts. Apache 2.0, no procurement, and AnalysisTemplate replicates most of what the commercial tier charges for.

On Flux? Flagger, using conformance webhooks so smoke tests gate promotion directly.

Off Kubernetes? LaunchDarkly guarded rollouts. The free Developer tier validates the idea, but price Guardian before building a process around it.

Windows, .NET or tenant sprawl? Octopus Deploy for orchestration and governance, with Recovery Agent treated as postmortem acceleration, nothing more.

Enterprise with an APM bill already paid? Harness AI Verification consumes telemetry you own and reverts unattended. Open the procurement thread early, given the absent pricing.

Nothing to spend and no mesh? Self-host Unleash and put a kill switch behind anything risky. It needs a human, but a flag flip still beats a rollback pipeline.

Wrapping Up

Sort this market by capability, not by whether "AI" appears in the copy. Harness, Argo Rollouts, Flagger and LaunchDarkly take an action against a metric you defined. Octopus Recovery Agent, and the broader wave of assistants and MCP servers, shortens the distance from failure to understanding, which is worth paying for but solves a different problem.

Since DORA still shows AI adoption pulling stability down while throughput climbs, the highest-leverage move in 2026 is not another assistant. It is one metric-gated canary step in front of whichever service would hurt most, and the open-source controllers hand you that for nothing.

References

Transactional Email APIs in 2026: The Same 50,000 Sends Cost $5 or $66

Moksh Gupta — Mon, 07 Sep 2026 17:13:20 +0000

Sending an email is a POST request. Getting it into an inbox is a reputation problem, and reputation depends on your SPF, DKIM and DMARC records, plus how aggressively your provider retires addresses that bounce or complain before Gmail decides your domain is the issue.

So the API is not what you are choosing between. Price and bounce handling are. And the price range is wider than anyone expects: at 50,000 emails a month the same workload runs $5.00 on Amazon SES and $66.00 on Postmark, both computed from the vendors' own published rates. The full comparison lives on DevToolLab with every tier, add-on and screenshot; this is the compressed version.

The spread, in one table

Prices below were read from each vendor's pricing page on September 5, 2026.

Provider	Free tier	Entry plan	Overage per 1,000	Owned by
Resend	3,000/mo, 100/day	$20/mo, 50,000 included	$0.90	Independent
Postmark	100/mo, no overage	$15/mo, 10,000 included	$1.80 down to $1.20	ActiveCampaign
SendGrid	60-day trial, 100/day	Essentials from $19.95/mo	Unpublished	Twilio
Amazon SES	AWS credit only	$0.10 per 1,000, no minimum	$0.10	AWS
Mailgun	100/day	$15/mo, 10,000 included	$1.80 down to $1.10	Sinch
Mailtrap	4,000/mo, 150/day	$15/mo, 10,000 included	$1.00	Railsware
Loops	1,000 contacts, 4,000 sends	Per subscribed contact	Sends not metered	Astrodon
Plunk	1,000/mo hosted	$0.001 per email	n/a	AGPL-3.0
Postal	Self-host	Your hardware	n/a	MIT

Notice these are not the same unit. Resend, Mailgun and Mailtrap sell a monthly bucket and bill overflow. SES sells thousands with no bucket at all. Loops meters stored contacts and stops caring how much you send. Postmark quotes off a volume slider, so its "price" depends where you drag the handle.

Resend

Resend is where new Node and Next.js projects land right now, and the adoption numbers explain why: it announced 3,000,000 users on June 3, 2026, three times what it had six months earlier, with 6.8 million weekly npm downloads on its SDK. It also maintains React Email, now at 6.0, so your templates are just components.

Free covers 3,000 a month with a 100/day ceiling and 3 domains. Pro is $20 for 50,000 with no daily cap. Scale is $90 for 100,000. Overage sits at $0.90 per 1,000 on both paid tiers, and the add-on sheet is public rather than sales-gated: $30 a month buys a dedicated IP, though only from Scale upward, and SSO is $150.

Two caveats. That dedicated IP gate means a Pro customer shares reputation. And Resend publishes its own incident reports, with entries from November 18, 2025 and February 15, 2026, which is a healthy habit and also a reminder that a provider tripling in size has rough days.

Postmark

Postmark, now an ActiveCampaign property, sells deliverability rather than volume and does not apologize for the premium. At the 10,000 mark on its slider, Basic runs $15, Pro $16.50 with inbound processing and retention stretchable to 365 days, and Platform $18 with unlimited sending domains. Overage lands at $1.80, $1.30 and $1.20 per 1,000, which is the steepest entry rate in this group alongside Mailgun.

What earns the price is operational visibility: transactional and broadcast traffic run as separate message streams, and per-inbox-provider delivery statistics are published on the status page. The free tier is 100 emails a month, never expires, and refuses overage entirely.

One thing to be careful with when you compare: because Postmark quotes per slider position rather than a flat plan plus overage, any calculation that models it as "10,000-email tier plus published overage" overstates what you would really pay at higher volume.

SendGrid, which now lives on twilio.com

SendGrid still carries more mail than anything else listed here, with Twilio claiming north of 200 billion emails a month. The change this year is administrative: every sendgrid.com pricing URL redirected to a Twilio product page when checked on September 5, 2026, and sendgrid.com now displays a notice that the two sites are merging.

The current card reads: a 60-day trial at 100 emails a day, Essentials "starting at $19.95/mo", Pro "starting at $89.95/mo" with dedicated IPs bundled, and Premier on request. Note what is missing. There is no permanent free tier anymore, and no exact price, because it "depends on email send volume, features." If you built on the old free plan, budget for a migration.

Mailgun and Mailtrap

Mailgun is the API-first original, now inside Sinch. Free gives 100 a day with a single day of log retention. Basic is $15 for 10,000, Foundation $35 for 50,000, Scale $90 for 100,000 with 30-day logs, and overage falls from $1.80 to $1.10 across those tiers. The trap is retention: one day of logs on Free and Basic is precisely the window in which you need to explain a bounce.

Mailtrap arrived from the other direction, as the staging inbox developers used to catch test mail, and its production pricing is sharp in the middle of the range. Free is 4,000 a month at 150 a day, then Basic scales $15 to $30 for 10,000 to 100,000 emails with $1.00 overage. Business starts at $85 for the same 100,000 and bundles dedicated IPs. Read those two carefully, because Basic at $30 and Business at $85 both deliver 100,000 emails; what separates them is retention, seats and the IP.

Amazon SES, the number everyone prices against

SES charges $0.10 per 1,000 outbound emails a la carte, with no minimum and no contract, plus $0.12 per GB of attachments. Dedicated IPs are $24.95 a month.

The wrinkle is new. From July 21, 2026, fresh accounts, along with any account-region pair with no metered activity since June 1, 2025, land on tiered plans instead: Essentials at $0.16 per 1,000 for the first 10 million monthly emails, Pro at $0.22 per 1,000 plus $105 per account per region with an IP bundled, Enterprise at $0.23 plus $500. The $0.10 a la carte rate has not gone away, but it is no longer the automatic default.

What you are not buying at that price is a product. SES hands over an SMTP endpoint and a reputation dashboard. Templates, suppression logic and support are yours to build, and deliverability analytics cost another $0.07 per 1,000 unless a plan includes them. The SES pricing page carries eighteen footnotes across three tables, and the longer write-up unpacks the add-on sheet properly, including the Virtual Deliverability Manager surcharge and both dedicated IP models.

Loops, priced by contact

Loops is structurally different and worth knowing exists. It bills for stored subscribers, not sends. Free holds 1,000 contacts and 4,000 monthly sends; paid tiers stop metering sends altogether, up to 1,000 emails a second, and fold transactional mail in at no extra cost. If you already want Loops driving onboarding sequences, your password resets ride along free. If you have a handful of contacts firing enormous transactional volume, the model works against you.

Running it yourself

Plunk is the open-source answer shaped like Resend: AGPL-3.0, 5,400 GitHub stars, transactional plus campaigns and automations, Docker-deployable. Hosted is free to 1,000 emails a month then a flat $0.001 each, so 50,000 sends is roughly $50. Self-hosting still leaves you needing delivery infrastructure or a relay behind it.

Postal is the serious version: MIT-licensed, 16,800 stars, and an actual MTA. You operate the servers, warm the IP addresses and answer to Gmail's postmaster tools directly. Below a few hundred thousand emails a month that is more labor than the SES invoice it displaces.

Compute your own unit rate

Comparing buckets against per-thousand metering in your head does not work. This prints what each provider actually costs at a given volume, and the effective rate per 1,000 once included volume is exhausted:

// unit-rate.mjs - effective cost per 1,000 emails at a given monthly volume.
// Prices read from vendor pricing pages on September 5, 2026.
const volume = Number(process.argv[2] ?? 250_000)

// [monthly USD, emails included, overage USD per 1,000]
const plans = {
  Resend:   [[0, 3_000, null], [20, 50_000, 0.90], [90, 100_000, 0.90]],
  Postmark: [[0, 100, null], [15, 10_000, 1.80], [16.5, 10_000, 1.30], [18, 10_000, 1.20]],
  Mailgun:  [[0, 3_000, null], [15, 10_000, 1.80], [35, 50_000, 1.30], [90, 100_000, 1.10]],
  Mailtrap: [[0, 4_000, null], [15, 10_000, 1.00], [30, 100_000, 1.00], [85, 100_000, 0.88], [200, 250_000, 0.88]],
}
const metered = {
  "Amazon SES": { per1k: 0.10, free: 0 },
  Plunk:        { per1k: 1.00, free: 1_000 },
}

const cheapest = (tiers, n) => tiers.reduce((best, [price, incl, over]) => {
  if (n > incl && over == null) return best
  const cost = n <= incl ? price : price + Math.ceil((n - incl) / 1_000) * over
  return best == null || cost < best ? cost : best
}, null)

const rows = []
for (const [name, tiers] of Object.entries(plans)) rows.push([name, cheapest(tiers, volume)])
for (const [name, m] of Object.entries(metered)) rows.push([name, Math.max(0, volume - m.free) / 1_000 * m.per1k])
rows.sort((a, b) => a[1] - b[1])

const usd = n => n.toLocaleString("en-US", { style: "currency", currency: "USD" })
console.log(`\n${volume.toLocaleString("en-US")} emails/month\n`)
for (const [name, cost] of rows) {
  const unit = (cost / volume) * 1_000
  console.log(`  ${name.padEnd(12)} ${usd(cost).padStart(9)}   ${usd(unit)} per 1,000`)
}
const [cheap, dear] = [rows[0][1], rows[rows.length - 1][1]]
console.log(`\n  spread: ${(dear / cheap).toFixed(1)}x\n`)

At 50,000 emails a month:

50,000 emails/month

  Amazon SES       $5.00   $0.10 per 1,000
  Resend          $20.00   $0.40 per 1,000
  Mailtrap        $30.00   $0.60 per 1,000
  Mailgun         $35.00   $0.70 per 1,000
  Plunk           $49.00   $0.98 per 1,000
  Postmark        $66.00   $1.32 per 1,000

  spread: 13.2x

And at 250,000, where the buckets start to matter more than the sticker price:

250,000 emails/month

  Amazon SES      $25.00   $0.10 per 1,000
  Mailtrap       $180.00   $0.72 per 1,000
  Resend         $200.00   $0.80 per 1,000
  Plunk          $249.00   $1.00 per 1,000
  Mailgun        $255.00   $1.02 per 1,000
  Postmark       $306.00   $1.22 per 1,000

  spread: 12.2x

Read that gap honestly. The $155 to $280 a month separating SES from the managed providers at 250,000 emails buys suppression handling, templates, a dashboard and somebody else's IP reputation. Whether that is a bargain depends entirely on whether you have an engineer who wants to own bounce processing.

Before your first production send, two things matter more than which vendor you picked: check your SPF record actually includes the provider, and confirm your DMARC policy has a valid reporting address, which every mailbox provider now expects from bulk senders.

Picking one

New product, Node or Next.js, under 100,000 a month: Resend, for the SDK and a price sheet that fits on one screen. Transactional mail where a late password reset becomes a support ticket: Postmark, checked against its slider at your real volume. Already inside AWS with someone willing to own suppression lists and IP warming: SES, at a fraction of everything else. Millions of sends and dedicated IP pools: SendGrid, through twilio.com now. Onboarding sequences and transactional from one tool: Loops. Determined to self-host: Plunk for the product shape, Postal if you genuinely want to be the mail server.

The APIs converged. The prices did not. Choose on the unit you actually consume, then go spend the afternoon on DNS, because no provider can deliver mail your own records declare forged.

References

Best Email API Providers in 2026: Resend vs Postmark vs SendGrid vs Amazon SES vs Mailgun - the full version on DevToolLab, with every tier and add-on
Email Authentication for Developers: SPF, DKIM, DMARC, BIMI and MTA-STS
Resend pricing
Postmark pricing
Twilio SendGrid Email API pricing
Amazon SES pricing
Mailgun pricing
Mailtrap pricing
Loops pricing
Plunk
Postal

SOC 2 Type 2, Explained Without the Compliance Marketing

Moksh Gupta — Sun, 06 Sep 2026 17:44:59 +0000

Sooner or later an enterprise deal stalls on a security questionnaire, and the line holding it up asks for a SOC 2 Type 2. Most explanations of what that means are written by companies selling you one, which is a bad place to start.

The short version: Type 2 is about a stretch of time. Type 1 is about a day. Everything else follows from that. I published a longer treatment of this over on DevToolLab, including the full report-reading procedure, so this is the condensed pass.

The distinction the whole thing rests on

A SOC 2 Type 2 is an examination by a licensed CPA firm asking two questions at once: were the controls designed properly, and did they actually run that way across a stated window of time. The dates are printed on the report and every conclusion inside is bounded by them.

A Type 1 asks only the first question, as of one calendar date.

Why that gap matters is easiest to see with a broken control. Suppose employee offboarding works fine in January, quietly breaks in April, and gets repaired in July. A Type 1 stamped August looks at a healthy control and says so, correctly. A Type 2 spanning January through August pulls samples from the whole run and surfaces the April failures. Buyers ask for Type 2 because it is the only one of the two that can find something.

	Type 1	Type 2
Question asked	Are controls designed well	Designed well and operating
Window	One date	A start date and an end date
Evidence	Snapshot	Samples drawn across the window
Finds	Design gaps	Design gaps and runtime failures

Nobody is SOC 2 certified

There is no such thing as a SOC 2 certificate, and the language matters more than it sounds. What a CPA firm issues is an opinion, and opinions come in four flavors: unqualified, qualified, adverse, or disclaimed. The Journal of Accountancy, which is the AICPA's own publication, made the point sharply in February 2026 when it described vendors promising "compliance" and noted in the same breath that this is "a term never used in SOC 2 examinations."

SOC reports date to 2011 and are performed under the AICPA's Statements on Standards for Attestation Engagements. Current reporting requirements for service auditor reports come from SSAE-21.

One more thing that catches people out: a SOC 2 is a restricted-use document, released to specified parties who understand the system being described. That is why companies put a SOC 3 or a trust page on their marketing site and keep the SOC 2 itself behind an NDA.

The five criteria, and why most reports only use one

The control criteria come from the AICPA's 2017 Trust Services Criteria with Revised Points of Focus, 2022. Five categories exist:

Security is the common criteria and appears in every SOC 2 examination
Availability applies once you sell an uptime promise
Processing integrity applies when you transform or transact on customer data
Confidentiality applies to information contractually marked confidential
Privacy applies to personal information, and gets confused with confidentiality constantly

The other four are elected, not mandatory. Every category you add drags in more controls, more evidence gathering, and more audit hours, which is why a first report is usually security and nothing else.

How long does the window have to be?

The honest answer is that no rule fixes it. The report declares the period it covers, and the length gets decided by management together with the service auditor. It is not written down in the Trust Services Criteria.

That is worth saying plainly because an enormous amount of published guidance states a mandatory three, six, or twelve month window as though quoting the standard. It is not in there. What is real is the commercial pressure: a longer window means more samples across more time, which buys more confidence, and procurement teams generally want unbroken coverage year over year. First-time reports often run short to unblock a deal, then settle into a rolling annual cycle.

Two adjacent things you will meet. The gap between a report period ending and today is normal and gets covered by a bridge letter, which is management asserting nothing has changed, not an auditor opinion. And a report whose period closed a year and a half ago is describing a system that may not exist anymore.

What the AICPA said about fast reports in 2026

This is the part that changed, and the part the full article digs into properly.

Across 2026 the AICPA published an unusual run of material questioning SOC 2 report quality: FAQs on software tools used in SOC 2 examinations dated March 31, ethics guidance covering business arrangements with SOC tool providers dated April 13, and peer reviewer guidance on SOC 2 risks dated May 14. Its SOC landing page also carries a notice that it is looking into allegations about a compliance vendor's business practices.

Sean Linton, CPA/CITP, an audit partner at EisnerAmper LLP who chairs the AICPA Assurance Services Executive Committee's SOC 2 Working Group, told the Journal of Accountancy that SOC "professionals are seeing indications that 'fast and easy' may come at the expense of quality and objectivity." The same reporting notes that tool vendors now number in the dozens, market compliance in weeks or hours, and through heavy SEO spending dominate search results for SOC 2 services.

The structural issue is that most of these vendors are not CPA firms and cannot attest to anything, so some have assembled referral networks of accounting firms, with marketing that gestures at thousands of reports a year. Terry O'Brien, CPA/CITP, a director at Schellman and a Working Group member, described the result bluntly: "You just know it's a template. You can compare any five of their reports, and they're all exactly the same, with a different client logo on it."

Jeff Cook, CPA, of Fortreum Associates LLC pointed out the practical cost, that a report rejected by a business partner is "not worth the paper it's on." Jeff Krull, CPA/CITP, of Baker Tilly US framed the collective risk: "Even if there are 100 good SOC 2 reports, the one bad one that people get their hands on, they're posting it on LinkedIn, they're posting on social media."

Worth being fair here: the same CPAs credit these tools for replacing screenshot-and-spreadsheet evidence collection with direct system integrations, which genuinely is better. The complaint is narrow and specific. Marketing built on speed and audit rigor pull against each other.

Seven checks before you trust a report someone hands you

Verify the auditor is a licensed CPA firm. Nobody else can issue the opinion. Look them up.
Read the opinion paragraph. Unqualified, qualified, adverse, or disclaimed. A qualified opinion is not automatically disqualifying, but it is a conversation.
Measure the gap. Note the end date, count forward to today, and request a bridge letter past roughly three months.
Read the exceptions. Zero findings across a full year should raise an eyebrow, not lower one. Findings are evidence somebody actually tested.
Read the scope and system description. Confirm the product you are buying is inside it. Scope drift is the quietest way a clean report covers nothing you care about.
Check which criteria are included. Security only is normal. If availability or privacy was promised, confirm it is really in there.
Check subservice organizations and CUECs. Note which subprocessors are carved out, and read the complementary user entity controls, because those are obligations landing on you.

If you are on the other side of this and building toward a report, two things worth having open while you work: the AWS IAM Policy Generator for the least-privilege policies that get sampled under the logical access criteria, and the Security Headers Checker for the transport protections you will be evidencing repeatedly across the window.

So which one do you need

Selling into enterprise and blocked in procurement, you need a Type 2, and a Type 1 buys you one pass before renewal. Pre-revenue with a single urgent contract, a Type 1 unblocks you and is only defensible if the Type 2 window opens immediately behind it. Evaluating somebody else's report, run the seven checks and spend your attention on scope and exceptions rather than the opinion line. Choosing an audit firm or a platform, treat an unusually fixed short timeline as a question rather than a feature, which is precisely what the AICPA's own working group flagged in 2026.

SOC 2 Type 2 means an independent CPA firm looked at your controls over a declared period and formed an opinion about whether they worked. Not a badge, not a pass mark, and not a twelve month window anybody mandated.

References

What Is SOC 2 Type 2? Scope and Period - the full version on DevToolLab, with the complete report-reading procedure
Best SOC 2 Compliance Automation Platforms: Vanta vs Drata vs Secureframe vs Sprinto
Journal of Accountancy: Promises of 'fast and easy' threaten SOC credibility (February 1, 2026)
AICPA: System and Organization Controls, SOC Suite of Services
AICPA: FAQs on the effect of the use of software tools on SOC 2 examinations (March 31, 2026)
AICPA: 2017 Trust Services Criteria with Revised Points of Focus, 2022

AI Voice Agents in 2026: The Same Minute Costs $0.03 or $0.31 Depending on Who Meters the Model

Moksh Gupta — Sat, 05 Sep 2026 19:22:09 +0000

An AI agent that answers the phone is four systems pretending to be one. Speech-to-text, an LLM, text-to-speech and telephony all have to hand off inside about a second, while the caller interrupts, reads out a policy number one digit at a time, or sits on hold. Someone has to host that chain and charge you for it, and how each vendor slices the bill turns out to matter more than any feature list.

I priced six platforms against their published September 5, 2026 rates. The headline: a minute of AI phone call runs anywhere from roughly $0.03 to $0.31, and most of that spread is not quality. It is a question of who meters the LLM. The full version of this comparison lives on DevToolLab with the per-component tables; this is the condensed pass.

The three billing models

Everything on the market falls into one of three shapes.

Compute plus pass-through. You pay for hosting, and the model bills land on your own accounts. Vapi and Pipecat work this way.

Fully metered. The vendor buys the models wholesale and resells them inside one per-minute rate. Retell and LiveKit Cloud do this.

Flat all-in. One talk-time number covering LLM, STT and TTS, priced like a phone company. That is Bland.

Platform	Published rate	Included concurrency	Compliance
Vapi	$0.05/min hosting, models at cost	10, then $10 per line/mo	HIPAA $2,000/mo, ZDR $1,000/mo
Retell AI	$0.07 to $0.31/min all-in	20	HIPAA and SSO on Enterprise
Bland AI	$0.14, $0.12 or $0.11/min	10, 50 or 100	SOC 2 Type II, HIPAA, PCI, FedRAMP
ElevenLabs Agents	$6 to $990/mo, or $0.08/min API	4 to 40 by plan	BAAs on Enterprise
LiveKit Agents	$0.01/min session, plus inference	5, 20 or 50+ by plan	HIPAA on Scale
Pipecat	$0.01/min active compute	Unlimited	Enterprise billing

Vapi

Vapi treats the agent as an API object. You describe an assistant, bolt on a phone number, and start placing calls. Hosting is $0.05 a minute, SMS and chat are $0.005 a message, and STT, LLM and TTS are billed at cost, dropping to nothing on Vapi's side when you supply your own provider keys. Ten concurrent lines are included; extras run $10 each per month. Build retains call history for 14 days.

Here is the server SDK shape, on @vapi-ai/server-sdk 1.2.0:

import { VapiClient } from "@vapi-ai/server-sdk";

const vapi = new VapiClient({ token: process.env.VAPI_API_KEY! });

const assistant = await vapi.assistants.create({
  name: "Appointment reminders",
  firstMessage: "Hi, this is the clinic calling to confirm your appointment.",
  model: {
    provider: "openai",
    model: "gpt-4o-mini",
    messages: [{ role: "system", content: "Confirm, reschedule, or cancel. Keep answers short." }],
  },
  voice: { provider: "11labs", voiceId: "burt" },
  transcriber: { provider: "deepgram", model: "nova-3" },
});

const call = await vapi.calls.create({
  assistantId: assistant.id,
  phoneNumberId: process.env.VAPI_PHONE_NUMBER_ID!,
  customer: { number: "+14155550123" },
});

The adoption numbers are not marketing fluff. TechCrunch's May 12, 2026 piece on the $50 million Series B led by Peak XV reported over 1 billion calls processed, 1 to 5 million calls a day, more than 1 million developers, and Amazon Ring, New York Life and Intuit as customers. Ring landed there after evaluating more than 40 vendors.

The catch is compliance pricing. HIPAA is a $2,000 monthly add-on and Zero Data Retention another $1,000, on either plan. SOC 2, SSO and RBAC require the annual Scale contract. So the same platform costs a side project five cents a minute and costs a clinic $3,000 a month before anyone picks up the phone.

Retell AI

Retell sells the inverse of Vapi's deal: hand over key management entirely and let one vendor meter every component. The quoted band is $0.07 to $0.31 per minute, and the component breakdown explains why it is that wide. Voice infrastructure is fixed at $0.055. TTS is $0.015 for Retell's own voices plus Minimax, Fish, Cartesia and OpenAI, or $0.040 if you want ElevenLabs.

The LLM line is what moves. GPT-5 nano costs $0.003 a minute, GPT-5 mini $0.012, GPT-4.1 $0.045, Claude 5 Sonnet $0.08, and GPT-5.5 $0.16, doubling to $0.32 on the fast tier. Retell's default estimator stack lands at $0.115.

New accounts get $10 of credit and 20 concurrent calls, the most generous starting concurrency among the metered platforms. The SDK is unremarkable in a good way, on retell-sdk 5.64.0:

const call = await client.call.createPhoneCall({
  from_number: "+14155550100",
  to_number: "+14155550123",
  override_agent_id: agentId,
});
// -> { call_id, call_status }

Watch the Enterprise wall: SSO, RBAC, a dedicated server and custom MSA, DPA or BAA terms all sit behind custom pricing. Pay-as-you-go gets a shared server and community support.

Bland AI

Bland refuses the itemized bill on principle: no token charges, no model pass-throughs. Start is $0.14 a minute with no platform fee, 10 concurrent calls and a 100 call daily cap, and signup includes two credits and an inbound number. Build cuts the rate to $0.12 for $299 a month with 50 concurrent calls and 2,000 daily. Scale is $0.11 for $499 with 100 concurrent and 5,000 daily. Minutes after a handoff to a human are billed separately at $0.05, $0.04 or $0.03.

Compliance is the strongest of the self-serve group: SOC 2 Type I and II, HIPAA eligibility, GDPR, PCI DSS, and a FedRAMP banner on the pricing page, though the signed BAA is an Enterprise item.

Do the arithmetic before you upgrade, though. Dividing that $299 fee by the two cents it saves you per minute means Build is a worse deal than Start until you are past roughly 15,000 minutes. And measured against Vapi's hosting fee, Bland costs about three times as much. Simplicity is the product here, and if your model bills are already small because you run cheap models on your own keys, it is a product you may not need.

ElevenLabs Agents

ElevenLabs is the voice model vendor selling the whole agent rather than just the speech. Its self-serve tiers bundle minutes instead of metering them:

Plan	Monthly	Minutes	Concurrent
Free	$0	15	4
Starter	$6	75	6
Creator	$22	275	10
Pro	$99	1,238	20
Scale	$299	-	-
Business	$990	-	-

Going through the API instead, the Agents speech engine is $0.08 a minute and handles both STT and TTS in a single low-latency pipeline across more than 70 languages. Which model does the thinking is left to you.

If recognizable voice quality is the actual product, this is the shortest route to it, and the balance sheet is the deepest in the category at $781 million raised. Two things to keep in mind: the $0.08 excludes the LLM entirely, and bundled minutes evaporate faster than they read. Pro's 1,238 minutes is about 20 hours of talk time, which is not a call center.

LiveKit Agents and Pipecat

Both open-source options let you own the pipeline, and both sell a cloud so you do not have to at first.

LiveKit Agents is Apache 2.0, 14,000 GitHub stars, Python and Node, with turn detection, telephony and native MCP tool support built in. Cloud pricing is itemized: Build is free, Ship starts at $50 a month, Scale starts at $500 and unlocks HIPAA plus security reports. The calculator's default phone stack adds up to $0.0672 a minute: agent session $0.0100, US number $0.0100, Gemma 4 31B $0.0014, Deepgram Nova-3 $0.0058, Cartesia Sonic 3 $0.0300, observability $0.0100. Switching the model to GPT-5 mini drops that LLM line to $0.0011.

Pipecat is BSD-2, 15,200 stars, maintained by Daily. Its abstraction is the frame: audio and text move down a chain of Python processors, one per stage, so transport, transcription, the model and speech synthesis are each a swappable link. Dozens of providers plug into those slots, OpenAI, Anthropic, Gemini, Deepgram, ElevenLabs and Cartesia included. Pipecat Cloud matches LiveKit's compute rate: the agent-1x profile (0.5 vCPU, 1 GB) is $0.01 a minute active, $0.0005 reserved, with no concurrency cap. WebRTC is free for one-to-one voice, PSTN dial-in and dial-out is $0.018, SIP runs $0.003 to $0.02, and Krisp noise cancellation is bundled up to 10,000 session minutes monthly. Model providers bill you directly.

Both carry the same tradeoff: what you get is a toolkit, not a finished product. Anything a managed platform hands you out of the box, cloned voices, staged rollouts, a dashboard to actually see what your calls are doing, becomes a line item on your own roadmap. If none of that appeals, Synthflow occupies the fully managed end of the market, where contracts open at $30,000 a year.

Price your own volume

Per-minute headline numbers hide six different bundles, so the only honest comparison is against your own traffic. This uses the rates above:

// voice-agent-cost.mjs - what a month of AI phone calls costs on each platform.
// Usage: node voice-agent-cost.mjs 20000   (minutes of talk time per month)
const minutes = Number(process.argv[2] ?? 20_000)

// Published rates, read from each vendor's pricing page on September 5, 2026.
const PLATFORMS = [
  { name: "Vapi (BYO model keys)", fixed: 0, perMin: 0.05, note: "models at cost, $0 if you bring your own API keys" },
  { name: "Retell (GPT-5 mini)", fixed: 0, perMin: 0.055 + 0.015 + 0.012, note: "infra + platform voice + LLM, all Retell-metered" },
  { name: "Bland Start", fixed: 0, perMin: 0.14, note: "all-in, 10 concurrent calls" },
  { name: "Bland Build", fixed: 299, perMin: 0.12, note: "all-in, 50 concurrent calls" },
  { name: "Bland Scale", fixed: 499, perMin: 0.11, note: "all-in, 100 concurrent calls" },
  { name: "ElevenLabs Agents", fixed: 0, perMin: 0.08, note: "speech engine only, LLM extra" },
  { name: "LiveKit Cloud (example stack)", fixed: 0, perMin: 0.0672, note: "calculator default: Gemma 4 31B, Deepgram Nova-3, Cartesia Sonic 3" },
  { name: "Pipecat Cloud (agent-1x + PSTN)", fixed: 0, perMin: 0.01 + 0.018, note: "STT/LLM/TTS billed by your providers" },
]

const usd = (n) => n.toLocaleString("en-US", { style: "currency", currency: "USD", maximumFractionDigits: 0 })
console.log(`\n${minutes.toLocaleString("en-US")} talk minutes per month\n`)
for (const p of PLATFORMS) {
  const total = p.fixed + p.perMin * minutes
  console.log(`  ${p.name.padEnd(32)} ${usd(total).padStart(9)}   ${p.note}`)
}
const breakEven = Math.ceil(299 / (0.14 - 0.12))
console.log(`\n  Bland Build beats Bland Start above ${breakEven.toLocaleString("en-US")} minutes/month\n`)

At 20,000 minutes:

20,000 talk minutes per month

  Vapi (BYO model keys)               $1,000   models at cost, $0 if you bring your own API keys
  Retell (GPT-5 mini)                 $1,640   infra + platform voice + LLM, all Retell-metered
  Bland Start                         $2,800   all-in, 10 concurrent calls
  Bland Build                         $2,699   all-in, 50 concurrent calls
  Bland Scale                         $2,699   all-in, 100 concurrent calls
  ElevenLabs Agents                   $1,600   speech engine only, LLM extra
  LiveKit Cloud (example stack)       $1,344   calculator default: Gemma 4 31B, Deepgram Nova-3, Cartesia Sonic 3
  Pipecat Cloud (agent-1x + PSTN)       $560   STT/LLM/TTS billed by your providers

  Bland Build beats Bland Start above 14,950 minutes/month

Do not read those totals without the notes. Vapi's $1,000 and Pipecat's $560 leave out the OpenAI and Deepgram invoices you still receive. Retell's and LiveKit's include them. Bland's include everything plus a compliance posture. Push it to 100,000 minutes and the gap runs from $2,800 to $14,000. The original article walks through the per-component tables each of these rates comes from.

If you are prototyping before you commit to a TTS bill, DevToolLab's Text to Speech tool will read your agent's opening line back in a browser voice, and the WAV File Generator produces silence or white noise for testing how your STT endpoint handles dead air.

Picking one

Shipping a product where voice is one feature and you already hold model keys, take Vapi for the itemized bill and the SDK. Want a single vendor metering everything with no keys to rotate, take Retell, and use the 20 free concurrent calls to load test. Regulated deployment where HIPAA, PCI or FedRAMP paperwork outweighs five cents a minute, take Bland, or Vapi Scale if you need model flexibility and can absorb $2,000 a month for HIPAA. Voice quality as the whole product at modest volume, ElevenLabs Agents. Engineers who want the cost curve under their own control, LiveKit Agents or Pipecat, on the vendor cloud until self-hosting pays off.

Three pricing shapes, then, and a funding round every few weeks to keep pushing them around. Every figure above is a September 5, 2026 snapshot with a short shelf life, so re-run the script yourself before you sign anything annual. The underlying question survives the repricing, though. Find whoever is metering your LLM minute, because that is the party holding your margin.

References

Best AI Voice Agent Platforms in 2026: Vapi vs Retell vs Bland vs ElevenLabs Agents - the original, with full per-component pricing tables
Best Speech-to-Text and AI Voice APIs - what the underlying transcription and synthesis vendors charge when nobody is reselling them to you
Best LLM Gateways and API Routers - how to add failover and routing to the model that sits in the middle of the call
Prompt Caching - the technique that attacks the biggest line item on a long conversation
Vapi pricing
Retell AI pricing
Bland AI pricing
ElevenLabs API pricing
LiveKit Agents on GitHub
Pipecat on GitHub
Pipecat Cloud pricing

Web Scraping APIs for AI in 2026: What 100,000 Pages Really Cost

Moksh Gupta — Fri, 04 Sep 2026 18:46:33 +0000

Feed an LLM anything current and you run into the same problem within a week. The URL you want returns a consent modal, a skeleton loader, or 200KB of JavaScript where the article should be. From there it is a build-or-rent decision: stand up your own headless browser fleet, or pay somebody per API call to keep one running.

I priced the five options I keep seeing in production against a single workload, and published the long version of this comparison on DevToolLab: Best Web Scraping APIs for AI in 2026. This is the compressed take.

Two data points frame the market. Firecrawl's repository crossed 176,000 GitHub stars, more than the open source projects of Bright Data, Zyte and Apify put together. And Apify's State of Web Scraping Report 2026, out January 29, 2026, found 62.5 percent of scraping teams spending more on infrastructure than a year earlier. Demand is not the constraint. Price is.

Who Actually Runs This

The Apify survey is worth reading for the buyer profile alone. Proxy spend rose year over year for 58.3 percent of respondents, total infrastructure spend for 62.5 percent, and nearly a quarter saw that bill climb by more than 30 percent, mostly because target sites keep hardening their anti-bot layers.

AI adoption inside these teams is still ahead of its own hype: 54.2 percent have not put AI anywhere in the workflow yet, though 66.2 percent intend to try, and of the minority already using an AI-assisted tool, 72.7 percent said it measurably helped. The population is also smaller than the enterprise sales pitch implies. 35.8 percent freelance, 49.1 percent sit inside a startup or SMB.

One Workload, Five Bills

No vendor publishes what the others charge, so pick a workload and price it yourself. Mine: 100,000 pages a month into a RAG index, priced from each vendor's own rate card as of September 3, 2026.

// Per-page cost of a 100,000-page/month RAG ingestion job.
const PAGES = 100_000

const options = [
  // Firecrawl Standard covers exactly 100k credits; 1 credit = 1 page.
  { vendor: 'Firecrawl Standard (annual prepay)', monthly: 83 },
  { vendor: 'Firecrawl Standard (month to month)', monthly: 99 },
  // Bright Data bills per successfully delivered record, not per attempt.
  { vendor: 'Bright Data (standard $1.00/1k)', monthly: (PAGES / 1000) * 1.0 },
  { vendor: 'Bright Data (promo $0.75/1k)', monthly: (PAGES / 1000) * 0.75 },
  // Zyte prices by site-difficulty tier; these are HTTP responses.
  { vendor: 'Zyte pay-as-you-go, simple sites', monthly: (PAGES / 1000) * 0.13 },
  { vendor: 'Zyte pay-as-you-go, hard sites', monthly: (PAGES / 1000) * 1.27 },
  { vendor: 'Zyte $500 commitment, simple sites', monthly: (PAGES / 1000) * 0.06 },
  { vendor: 'Zyte $500 commitment, hard sites', monthly: (PAGES / 1000) * 0.61 },
  // Crawl4AI is free; you rent the box that runs headless Chromium.
  { vendor: 'Crawl4AI self-hosted (4GB VPS)', monthly: 24 },
]

const rows = options
  .map(o => ({ ...o, perPage: o.monthly / PAGES }))
  .sort((a, b) => a.perPage - b.perPage)

const width = Math.max(...rows.map(r => r.vendor.length))
for (const r of rows) {
  console.log(
    `${r.vendor.padEnd(width)}  $${r.monthly.toFixed(2).padStart(7)}/mo   $${r.perPage.toFixed(5)}/page`
  )
}
const spread = rows.at(-1).perPage / rows[0].perPage
console.log(`\nCheapest to most expensive: ${spread.toFixed(1)}x, same 100,000 pages.`)

Zyte $500 commitment, simple sites   $   6.00/mo   $0.00006/page
Zyte pay-as-you-go, simple sites     $  13.00/mo   $0.00013/page
Crawl4AI self-hosted (4GB VPS)       $  24.00/mo   $0.00024/page
Zyte $500 commitment, hard sites     $  61.00/mo   $0.00061/page
Bright Data (promo $0.75/1k)         $  75.00/mo   $0.00075/page
Firecrawl Standard (annual prepay)   $  83.00/mo   $0.00083/page
Firecrawl Standard (month to month)  $  99.00/mo   $0.00099/page
Bright Data (standard $1.00/1k)      $ 100.00/mo   $0.00100/page
Zyte pay-as-you-go, hard sites       $ 127.00/mo   $0.00127/page

A 21x spread on identical volume, and the ordering is doing something sneaky. Two caveats before you read anything into it. Zyte's commitment rows assume you are already spending $500 a month, so the $6 line is a marginal rate, not a bill. And Firecrawl's $83 only exists if you prepay twelve months; month to month it is $99, which puts it beside Bright Data's standard rate rather than under it.

Apify is missing from the list because it cannot be on it. It meters compute units, not pages, so the number depends on your actor's code rather than your page count.

Firecrawl

Firecrawl takes a URL and hands back clean Markdown or structured JSON in one call. Scrape, Crawl and Map each cost 1 credit per page with JavaScript rendering already included, which is the part that usually carries a surcharge elsewhere.

Version 2.11.0, shipped June 19, 2026, added a research index over 3 million arXiv papers, automatic PII redaction, and a deterministicJson format that caches a per-site extractor so repeat crawls stop paying an LLM to re-learn the same page shape.

The catches: Stealth Mode costs 5 credits a page, Search and Interact bill above the base rate, and credits expire monthly on everything except Scale. The self-hosted repo is also behind the hosted product, since the managed anti-bot layer is not in the open source code.

Priced yearly: free tier at 1,000 credits, Hobby $16/month, Standard $83/month for 100,000, Scale $599/month for a million. Month to month those are $19, $99 and $749. AGPL-3.0 core, MIT SDKs.

Apify

Apify is a marketplace rather than a single endpoint. You run Actors, small scraping programs you write yourself or pull from the 67,000 already published, and you are billed for compute: one CU equals 1GB of RAM for an hour, at $0.20 down to $0.13 depending on plan.

That model rewards good code and punishes lazy code. A Cheerio actor parsing static HTML is genuinely cheap. Swap in Playwright to render the pages Cheerio skipped and the same job burns CU several times faster. There is no per-page figure to budget from until you have written the actor and watched it run.

Two dates matter. Apify went live on x402 in June 2026, so an agent can pay per run instead of holding a prepaid balance. And monthly actor rental retires October 1, 2026, with anything unmigrated moved automatically to pay-per-usage.

Plans: free with $5 usage, Starter $19/month, Scale $199/month, Business $999/month. The platform is proprietary; its Crawlee library is Apache-2.0.

Crawl4AI

Crawl4AI is what the managed vendors sell, unbundled and unmetered. Point it at a URL, get LLM-ready Markdown, no key, no invoice.

It is past 81,000 stars, runs headless Chromium, handles CSS-selector and LLM-guided extraction, and ships a Docker image, so nothing has to leave your infrastructure. Version 0.9.3, released August 31, 2026, was a security release closing five coordinated-disclosure bugs including an arbitrary file write and an SSRF in the PDF path. Worth noting if you are pinned to something older.

What it does not solve is the reason the paid tiers exist. No managed proxy pool, no SLA. The first time a target fingerprints your IP you are shopping for proxies, and that bill is now yours to negotiate.

Free, Apache-2.0, your own compute.

Bright Data

Bright Data is the oldest name here, built on a residential proxy network it advertises at 400 million monthly IPs across 195 countries, with a Web Scraper API sitting on top.

Its best property is billing per successfully delivered record, so blocked attempts cost nothing. It ships more than 1,500 site-specific scrapers that handle parsing for you, and bulk jobs take up to 5,000 URLs per request. Standard pricing is $1.00 per 1,000 records, or $0.75 with promo code APIS25 for six months.

No self-hosted path exists, and the catalog is sprawling: proxies, SERP API, Unlocker and datasets are all separate line items.

Zyte

Zyte was Scrapinghub until February 2021 and still employs the team maintaining Scrapy, which means a lot of this industry's existing spiders were written against their work.

Zyte prices by difficulty, not volume: five tiers from Simple to Advanced, different rates for plain HTTP versus browser-rendered responses, and a lower rate at every tier once you commit to a monthly spend. A $5 trial credit runs for 30 days.

The tradeoff is that you cannot budget in advance, because Zyte classifies your targets, not you. The same 1,000 requests land anywhere between $0.06 and $16.08 depending on tier, commitment and render mode. That is a 268x range inside one rate card. Existing Scrapy users also get Scrapy Cloud, which is usually the cheaper migration than rewriting spiders.

Side by Side

Tool	Billing model	Entry price	Self-host	License
Firecrawl	Credits per page	$16/month yearly, $19 monthly	Core only	AGPL-3.0
Apify	Compute units	$19/month plus usage	Via Crawlee	Proprietary
Crawl4AI	None	$0	Yes	Apache-2.0
Bright Data	Per successful record	$0.75 to $1.00 per 1,000	No	Proprietary
Zyte	Per response, by tier	$0.06 to $16.08 per 1,000	Scrapy only	Proprietary

Choosing Once Instead of Twice

Sort your real domain list before you look at any pricing page. Split it into static HTML, JavaScript-rendered, and CAPTCHA or login-walled. That distribution moves your bill far more than raw page count does, and it is the input every vendor's rate card quietly depends on.

Then decide who owns the anti-bot problem. Renting it from Firecrawl, Bright Data or Zyte buys you a bill that scales with target difficulty. Owning it with Crawl4AI buys a flat server cost plus a proxy budget that arrives unannounced the first time you get blocked.

Check the license before you modify anything you plan to redistribute: AGPL-3.0 on Firecrawl's core obliges you to publish modifications offered as a network service, while Apache-2.0 and BSD do not. Then test your single hardest target, not the vendor demo. Advertised entry pricing describes the easiest tier, and easy sites are not why you are shopping. The full DevToolLab guide works through each of these steps with the per-tier numbers.

The Short Answer

Building a RAG pipeline or agent and want Markdown without plumbing: Firecrawl. Predictable credits, JS rendering at base rate, and the deterministic JSON caching pays for itself on recrawls.

Thousands of sites at unpredictable volume: Apify if you will tune actor code, Bright Data if you would rather pay flat per record and use its prebuilt scrapers.

Data cannot leave your infrastructure, or there is no budget: Crawl4AI, accepting that you are now the proxy team.

No commitment and tolerance for variance: Zyte, whose $5 trial is the cheapest way to learn what your specific sites actually cost.

Already running Scrapy: Scrapy Cloud, same maintainers, no rewrite.

Whichever you pick, the raw HTML arriving at your ingestion step is rarely what you want in a context window. HTML Cleaner strips inline styles and markup noise before it burns tokens, and JSON to CSV Converter turns a scrape result into a spreadsheet when you just need to eyeball what came back.

Conclusion

Firecrawl's star count and Apify's survey point the same way: this category grew because AI pipelines need it, not because scraping became easier. Apify killing rental pricing in October 2026 and Firecrawl shipping an arXiv index rather than more output formats both read like a market still deciding what it sells. Before you renew anything, answer one question. Are you billed per page or per unit of compute, and does that match the axis your workload grows along?

References

Best Web Scraping APIs for AI in 2026: Firecrawl vs Apify vs Bright Data vs Zyte - the original, with the full pricing script and per-vendor detail
Apify State of Web Scraping Report 2026 - January 29, 2026
Firecrawl pricing
Bright Data Web Scraper API
Zyte pricing
Crawl4AI on GitHub
Best RAG Platforms and Tools - where these pages end up indexed
Best AI Browser Automation Tools - the layer above extraction

Stop Writing try/except Around Your LLM Calls: Structured Outputs in 2026

Moksh Gupta — Thu, 03 Sep 2026 18:26:03 +0000

Anyone who shipped an LLM feature before 2026 knows the ritual. Write "return valid JSON only" in the prompt. Wrap the parse in a try block. Add a retry for the runs where the model opened with "Sure! Here's your JSON:" and wrapped everything in a markdown fence. Maybe strip fences with a regex. That whole layer is now dead weight.

Anthropic shipped Structured Outputs to GA on February 4, 2026, which made it the last major provider to support this natively. OpenAI has offered it since August 2024, Gemini does it through response_schema, and the open-source serving stack (vLLM, Ollama, SGLang) has shipped grammar-constrained decoding for well over a year. Parsing and praying is now a decision you are making, not a constraint you are living under.

I wrote a longer version of this on DevToolLab, LLM Structured Outputs: Get JSON That Always Parses, with more provider detail. This is the compressed take: the three things people mean by "structured output," the token-level mechanism behind the guarantee, the per-provider API, and the schema rules that quietly break your requests.

Three Different Things Share the Name

Conflating these is where most confusion begins.

Prompt-only JSON means you describe the shape in the prompt and hope for the best. Nothing is guaranteed, and the failure rate rises with schema complexity and falls with model size.

JSON mode is a flag, OpenAI's json_object being the canonical example, that forces the output to be syntactically parseable. That is all it forces. Required fields can go missing, types can be wrong, extra keys can appear. OpenAI labels it legacy now.

Schema-constrained generation is the real thing: you supply a JSON Schema and the response is guaranteed to conform, every required key present, every type right, every enum value drawn from your list. When OpenAI, Anthropic and Google say "Structured Outputs," this is what they mean.

Approach	Parses as JSON	Conforms to your schema	Needs retry logic
Prompt-only	No	No	Yes
JSON mode (`json_object`)	Yes	No	Sometimes
Schema-constrained (`json_schema`, `strict`)	Yes	Yes	No

Only the last one lets you delete code rather than accumulate it.

The Math That Kills Agent Loops

A single call failing to parse 1% of the time reads as acceptable. Put it in an agent that makes ten tool calls and the run has roughly a 10% chance of dying somewhere in the middle. Chain two or three agents together and you have built something that fails often enough to be unshippable.

The failure modes are dull and repetitive: a trailing comma, an unexpected code fence, an enum value the model invented, a number returned as a string, a required field that just is not there. Calling these model errors misses the point. Unconstrained sampling draws from the entire vocabulary at every step, and no part of that process knows your structure exists.

What Constrained Decoding Actually Does

The guarantee comes from constrained decoding, sometimes called guided or grammar-constrained generation, and the concept is straightforward even though the implementation is not.

Generation is token by token. At each step the model produces a probability distribution across a vocabulary that often exceeds 100,000 tokens, then samples one. Constrained decoding inserts itself between those two steps: your JSON Schema gets compiled into a formal grammar, the decoder tracks the current position within that grammar, and any token that would produce invalid output has its probability driven to zero. Broken JSON is not merely unlikely, it is unreachable. Anthropic's framing is that the schema becomes a formal grammar constraining generation token by token.

Open source got there first. Outlines made grammar-based generation practical for open weights, and XGrammar made it fast enough to be free, using adaptive token-mask caching. That is why XGrammar is the default backend in vLLM from v0.7.0 on, and why SGLang, TensorRT-LLM and MLC-LLM use it too. Overhead on JSON generation is effectively nil. The mechanism is identical everywhere; only the API surface and the accepted slice of JSON Schema differ.

Provider by Provider

OpenAI supports it from gpt-4o-2024-08-06 forward, including the GPT-5 models. You pass a JSON Schema with strict: true, via response_format in Chat Completions or text.format in the Responses API. The Python SDK wraps all of it in a parse helper that accepts a Pydantic model and hands back a typed object:

# Reference: requires OPENAI_API_KEY
from openai import OpenAI
from pydantic import BaseModel

class Ticket(BaseModel):
    title: str
    priority: str
    estimate_hours: float

resp = OpenAI().responses.parse(
    model="gpt-5",
    input="Open a ticket: login redirect broken, high priority, ~3.5h",
    text_format=Ticket,
)
print(resp.output_parsed)   # Ticket(title=..., priority='high', ...)

Watch two things. Legacy json_object guarantees syntax only, never your schema. And because the output is grammar-constrained, a safety refusal cannot arrive as ordinary content, so OpenAI returns it in a separate refusal field that you must check before touching the payload.

Anthropic has been GA since February 2026 across the current lineup, Opus 4.8, Sonnet 5 and Haiku 4.5, with the beta header no longer required. The pattern matches:

# Reference: requires ANTHROPIC_API_KEY
from anthropic import Anthropic
from pydantic import BaseModel

class Contact(BaseModel):
    name: str
    email: str
    plan_interest: str

resp = Anthropic().messages.parse(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user",
               "content": "John Smith (john@example.com) wants the Enterprise plan."}],
    output_format=Contact,
)
print(resp.parsed_output)   # Contact(name='John Smith', ...)

At the raw HTTP level the schema rides in an output_config.format object. Claude covers two cases: JSON against a schema, shown above, and tool use, where a tool call's arguments are automatically constrained to that tool's input schema. The second is what stops agent function calls from arriving malformed.

Gemini takes a config object instead. Set response_mime_type to application/json and supply response_schema, which accepts a Pydantic model, a dict, or an enum:

# Reference: requires a Gemini API key
from google import genai
from pydantic import BaseModel

class Recipe(BaseModel):
    name: str
    ingredients: list[str]

resp = genai.Client().models.generate_content(
    model="gemini-3.5-flash",
    contents="Give me a simple pancake recipe.",
    config={"response_mime_type": "application/json", "response_schema": Recipe},
)
print(resp.parsed)

Gemini takes a subset of JSON Schema and will reject schemas that are very large or deeply nested, so keep the structure flat.

Local models need no hosted API at all. Ollama has accepted a JSON Schema in format since 0.3.0, constraining the local model's decoding and dropping fences and preamble on its own:

# Reference: requires a running Ollama server + a pulled model
from ollama import chat
from pydantic import BaseModel

class Country(BaseModel):
    name: str
    capital: str
    population: int

resp = chat(model="llama3.1",
            messages=[{"role": "user", "content": "Tell me about Japan."}],
            format=Country.model_json_schema())
print(Country.model_validate_json(resp.message.content))

On self-hosted vLLM or SGLang the parameter is guided_json, with XGrammar underneath. Identical guarantee, running on hardware you control.

Wiring It Into an Application

Four steps, and they are the same regardless of provider.

Start by defining the shape exactly once, in Pydantic for Python or Zod for TypeScript. That single definition serves as both the schema you transmit and the type you validate against.

from pydantic import BaseModel, Field
from enum import Enum
import json

class Priority(str, Enum):
    low = "low"; medium = "medium"; high = "high"

class Ticket(BaseModel):
    title: str
    priority: Priority
    tags: list[str] = Field(default_factory=list)
    estimate_hours: float

print(json.dumps(Ticket.model_json_schema(), indent=2))

Look closely at what that emits. The required array contains title, priority and estimate_hours, but not tags, because tags carries a default. Hold that thought, it causes real pain shortly.

Second, send it, either as a raw schema or as a Pydantic model handed to a parse helper, and receive a conforming typed object.

Third, validate locally anyway. It costs microseconds and it protects you from SDK quirks, proxy rewrites, and whichever endpoint in your stack lacks native support:

from jsonschema import validate, ValidationError

schema = Ticket.model_json_schema()
good = '{"title":"Fix login redirect","priority":"high","tags":["auth"],"estimate_hours":3.5}'
validate(instance=json.loads(good), schema=schema)   # raises if wrong
print(Ticket.model_validate_json(good))              # typed object

try:
    validate(instance={"title":"x","priority":"urgent","estimate_hours":2}, schema=schema)
except ValidationError as e:
    print("rejected:", e.message)   # 'urgent' is not one of ['low', 'medium', 'high']

Fourth, deal with refusals and gaps in support. Branch on OpenAI's refusal field before reading data, and for any endpoint without native support keep a repair-then-retry fallback rather than counting braces by hand. DevToolLab's JSON Repair tool is the browser version of that fallback when you are debugging by hand instead of in code.

The Schema Rules That Cost You an Afternoon

This is where the 400 responses come from, because every provider accepts a different subset of JSON Schema.

OpenAI's strict mode requires every field. You cannot simply omit a property from required. Every declared property must appear there, and every object needs additionalProperties: false. Making something optional means keeping it in required while giving it a nullable type such as "type": ["string", "null"]. Combine that with the earlier detail, Pydantic excluding defaulted fields from required, and any model with defaults fails strict mode untouched. This helper repairs any schema in place:

def make_strict(schema: dict) -> dict:
    """additionalProperties:false + every key required, at every level."""
    if isinstance(schema, dict):
        if schema.get("type") == "object" and "properties" in schema:
            schema["additionalProperties"] = False
            schema["required"] = list(schema["properties"].keys())
        for value in schema.values():
            make_strict(value)
    elif isinstance(schema, list):
        for item in schema:
            make_strict(item)
    return schema

Certain keywords get dropped or refused. OpenAI strict mode does not enforce minLength, maxLength, pattern or format, and it rejects default outright. Anything depending on a regex pattern has to be checked after the fact. Claude and Gemini each define their own subset, so portability across providers is not automatic. Depth and size limits apply on all three hosted providers, so flatten aggressively and split oversized schemas into separate calls. Checking a response against your schema in the JSON Schema Validator is faster than guessing which keyword the provider silently ignored. The original post goes through each provider's subset in more detail.

TypeScript teams get the same rules through Zod, defining once and validating identically:

import { z } from "zod"

const Ticket = z.object({
  title: z.string(),
  priority: z.enum(["low", "medium", "high"]),
  tags: z.array(z.string()),
  estimateHours: z.number(),
})

const parsed = Ticket.parse(JSON.parse(rawModelOutput)) // throws on mismatch

What This Does Not Fix

Constrained decoding enforces shape, never truth. Nothing prevents "estimate_hours": 400 on a two-line fix, or a confidently extracted email address belonging to the wrong person. Schema conformance is the floor of output quality, not the ceiling, and evals remain the only way to measure the rest.

There is a modest cost too. Forcing the grammar can steer the model down a slightly less natural path, and compiling an unfamiliar complex schema adds a one-time warm-up that gets cached afterward. For extraction, classification and tool calling that trade is obvious. For long-form creative writing it is usually the wrong instrument.

Conclusion

Structured outputs convert "get JSON out of an LLM" from a reliability problem into a schema-design problem, which is a far better problem to own. Define the shape once in Pydantic or Zod, ship it as a JSON Schema, let constrained decoding enforce it, and keep local validation as a cheap backstop. Fences, trailing commas, absent fields and illegal enums all stop at the source.

Treat the schema as a contract. Get additionalProperties, required and nullability right, keep the structure flat, and stay honest that a valid shape is not a correct answer. Then find your single most parse-prone call, the one wrapped in the ugliest error handling you own, and convert it this week. It is usually about ten lines of change that removes a hundred lines of defense.

Provider availability, model names and API parameters here reflect July 2026. This area moves fast, so confirm field names and the supported JSON Schema subset in each provider's current docs before shipping.

References

Secrets Management in 2026: The Cheap Vault SaaS Is Gone, So What Now?

Moksh Gupta — Thu, 03 Sep 2026 18:22:29 +0000

If you were planning to buy Vault as a managed service on a small budget, that option closed last month. HCP Vault Secrets went end of sale on June 30, 2025, and remaining contract customers hit end of life on whichever came first, their contract expiry or July 1, 2026. HashiCorp points you at HCP Vault Dedicated instead, which is hosted Vault Enterprise: a different product with a different bill.

Two weeks before that cutoff, Vault jumped from 1.21 to 2.0. No rewrite happened. The number now tracks IBM's versioning and its Support Cycle-2 policy, which retires HashiCorp's long-term support labels. At the same time, the fork that appeared when Vault left open source has been shipping features Vault charges for. I published a longer version of this comparison on DevToolLab, Best Secrets Management Tools in 2026, with the full pricing tables and a migration checklist. This is the condensed pass.

The Job, and the Two Jobs Next to It

A secrets manager stores credentials, hands them to workloads that can prove identity, and takes them back. Two adjacent categories get confused with it constantly. Secrets scanning hunts for credentials already sitting in your git history. Non-human identity management decides which machine identities should exist and what they may touch. Neither one is this. This is the storage and distribution layer between them.

The question that actually sorts these tools is whether you need dynamic secrets: credentials minted on request with a lease attached, so a leaked one dies on its own. That single capability is why Vault exists and why it costs more to run than a key-value store behind an API.

Four Shapes, Not Eight Products

Everything in this category collapses into four operating models.

Run your own engine (Vault, OpenBao) and you get dynamic secrets, PKI and encryption as a service, plus a cluster to keep alive at 3am. Buy a SaaS platform (Infisical, Doppler) and you get a solid CLI, environment sync and a bill that meters either seats or identities. Use whatever your cloud already ships (AWS Secrets Manager, Google Secret Manager, Azure Key Vault) and it inherits your existing IAM and audit trail, charged per secret or per call. Or skip servers entirely with SOPS plus age, encrypting values inside files you commit.

Tool	Shape	License	Dynamic secrets	Cost
Vault	Self-hosted engine	BUSL 1.1	Yes	Community free, Enterprise quoted
OpenBao	Self-hosted engine	MPL 2.0	Yes	Free, 8 vendors sell support
Infisical	SaaS + self-host	MIT core	Advanced tier	Free 5 identities, $20-$40/identity/mo
Doppler	SaaS	Proprietary	Enterprise tier	Free 3 users, Team $21/user/mo
AWS Secrets Manager	Cloud native	Proprietary	Rotation Lambdas	$0.40/secret/mo + $0.05/10k calls
Google Secret Manager	Cloud native	Proprietary	No	$0.06/version/mo + $0.03/10k ops
SOPS + age	Encrypted in git	MPL 2.0 / BSD	No	Free
External Secrets Operator	Kubernetes glue	Apache 2.0	Passes through	Free

Two of these shapes in one org is the normal outcome, not a failure. Choosing the boundary on purpose is the part teams skip.

Vault Is Now an IBM Product

Vault stays the deepest toolbox here and has not been open source since the Business Source License 1.1 switch in August 2023. Enterprise 2.0 arrived April 13, 2026 carrying workload identity federation for secret distribution, credential rotation targeting RHEL and Ubuntu hosts, envelope encryption for large payloads, a SPIFFE engine that issues JWT SVIDs, public CA support, and SCIM in beta.

The release cadence changed more than the feature list did. Self-managed Enterprise now ships two feature releases a year, spring and fall, with monthly security patches, and IBM's SC2 policy guarantees at least two years of standard support per release with extended cover reaching year six. The HashiCorp support portal itself folds into IBM's on August 21, 2026.

Community Edition remains free and still mints dynamic secrets. Skipping Enterprise costs you namespaces, DR replication, HSM auto-unseal and the compliance surface, and buys you a cluster to operate.

OpenBao Ships What Vault Bills For

OpenBao branched off Vault's final MPL 2.0 release and now lives under the Linux Foundation with OpenSSF governance. It is maintained, not archived: 2.6.0 landed July 14, 2026 and 2.6.1 followed on July 22.

The 2.6 line introduced namespace sealing, giving each namespace its own Shamir key material so a single tenant can be sealed off independently. Auto-unseal moved out into external kms plugin binaries that restart themselves, a sys/workflows API arrived for wrapping the standard API in simpler interfaces, the old unauthenticated root token generation endpoint was replaced with an authenticated one, and a distroless container image shipped. Version 2.5 had already added horizontal read scaling.

Compare that list against the Vault price sheet: namespaces and read scaling are Enterprise line items, free here. GitLab, SAP, Proton, Fermilab, ControlPlane and Adfinis sponsor the project, NVIDIA shows up as an adopter, and eight companies sell commercial support.

The real cost is gravity. Vault has more tutorials, more answered Stack Overflow questions and more engineers who have already survived an outage with it. API compatibility carries most of that knowledge across, but you are the one signing off.

SaaS: Read the Meter, Not the Feature List

Infisical and Doppler are both polished, both have a CLI that injects secrets into a running process, both sync into CI and cloud providers, and both self-host on paid tiers. Their feature grids will not decide anything for you. Their billing units will.

Infisical is MIT at the core with 27,000 GitHub stars and charges per identity. Free covers 5 identities, 3 environments and 10 syncs. Pro runs $20 per identity per month annually ($23 monthly) with access controls, rotation, SAML SSO and 30-day audit logs. Advanced doubles that to $40 and unlocks dynamic secrets, honey tokens, custom roles and 90-day logs. Enterprise adds approvals, LDAP, SCIM, KMIP and self-hosting.

Doppler charges per human instead. Developer is free up to 3 users, then $8 a month each. Team is $21 per user per month with change requests, SAML SSO, RBAC, 90-day logs and automatic rotation. Enterprise adds dynamic secrets and log forwarding. Doppler states plainly that AI agents and non-human identities are free and never consume a seat.

Put a shape to it. Eight engineers running 150 services and agents costs roughly $168 a month on Doppler Team; the same estate on Infisical Pro, if each of those 150 identities bills, lands in four figures. Invert it, three engineers with 10 identities, and Infisical is cheap while both are affordable. So count your machine identities before you open either pricing page. That number is outgrowing your headcount and it is the widest cost gap in the category.

The Cloud Manager You Are Already Paying For

Living in one cloud makes the native manager the least work available. It already sits inside your IAM policies, already lands in CloudTrail, and needs no cluster.

AWS Secrets Manager bills $0.40 per secret per month plus $0.05 per 10,000 API calls. Google Secret Manager bills $0.06 per active version per location per month plus $0.03 per 10,000 access operations, with rotation notifications at $0.05 and destroyed versions free. Azure Key Vault meters per 10,000 operations rather than per stored secret.

Volume is where this bites. 500 secrets on AWS is $200 a month before anything reads them, and per-secret pricing nudges teams into cramming many values into one JSON blob, which silently deletes per-secret access control. At that scale, Google's per-version rate or your own engine costs less. Anything that is configuration rather than a credential belongs in AWS Systems Manager Parameter Store standard parameters, which are free.

SOPS and age: Encryption Without a Server

SOPS is a CNCF sandbox project that encrypts only the values in YAML, JSON or .env files, leaving keys in the clear so an encrypted file still diffs meaningfully in git. Pair it with age and no cloud KMS is involved at all.

The entire setup, on sops 3.13.3 and age 1.3.1:

age-keygen -o key.txt                      # prints the public key to stderr
cat > .sops.yaml <<'YAML'
creation_rules:
  - path_regex: \.yaml$
    age: age1v0hwa90c72kq737nmldg25kragalsez390fefpahyu9y8n5tsdcsukz20r
YAML
sops --encrypt --in-place secrets.yaml

What gets committed keeps every structural key and loses every value:

database:
    host: ENC[AES256_GCM,data:VR2SjbbqDZ4tQgE=,iv:p6Vh3yvG1i7hDZVok16lnU5ekraECwG6nA/OSrEKcmM=,tag:cT71TttqKRWcuKkEAY+wtw==,type:str]
    password: ENC[AES256_GCM,data:fyaQknjAvt2gYR+Ebfr2B64=,iv:1t+3u5JEBvt7B9z9PyrzrkBa4cKX30ALTmiT4MJH+ls=,tag:sLeVLckj0U//drSKrq+10Q==,type:str]
stripe:
    secret_key: ENC[AES256_GCM,data:EYm3G333nlxQzRPJrrQD4YFdBotUADQ/d7rH,iv:d4us0HydwkJMzrevJw38Rb0J7Bge736ZiG2FvabuwZU=,tag:HB+hnnJJ8pKLf+QSOsfwPA==,type:str]

Confirming the round trip actually works, against that same file:

$ grep -c 'database:\|stripe:\|password:\|secret_key:' secrets.yaml
4
$ grep -c 'hunter2\|sk_live_51H' secrets.yaml
0
$ SOPS_AGE_KEY_FILE=key.txt sops --decrypt secrets.yaml
database:
    host: db.internal
    password: hunter2-but-worse
stripe:
    secret_key: sk_live_51Hxxxxxxxxxxxxxxxx

Four keys readable, zero plaintext values, decrypt returns the originals. Missing from this picture: rotation, leases, dynamic secrets and any audit log, and the age key is now your distribution problem. For a homelab, a three-person team or the manifests in a GitOps repo, that is frequently the right trade.

Make the Decision Reversible First

External Secrets Operator, another CNCF sandbox project, matters no matter which shape you pick. It runs inside your cluster, pulls from Vault, OpenBao, AWS, Google, Azure, Infisical or Doppler, and turns a declarative ExternalSecret into a native Kubernetes Secret.

That layer of indirection is the whole point. Your applications read an ordinary Secret, the operator holds the provider integration, and swapping AWS Secrets Manager for OpenBao edits one resource instead of every deployment. On Kubernetes, install it before you commit to any provider.

Picking One

Need dynamic database credentials or internal PKI? OpenBao when license terms or budget block you, Vault when you want the vendor relationship and the ecosystem. Both deliver; one carries a BUSL.

Single cloud with tens of secrets? Use the native manager and stop there. Bolting a secrets platform onto an estate that already has IAM buys nothing at that size.

More services and agents than engineers? Price Doppler per seat against Infisical per identity using your real numbers.

Want self-hosting with a modern UI? Infisical, MIT at the core, unless leases and dynamic secrets outrank the interface, in which case OpenBao.

Small team on GitOps with no server budget? SOPS with age, and be honest with yourself that you picked encryption over rotation.

Getting Out of .env Files

Gather every .env, CI variable and shared credential note first. A diff across environments catches the variable that somehow only exists in production, and DevToolLab's Env File Diff Checker does that in the browser. Lint those files before migrating them, because duplicate keys and unquoted values with spaces surface later as bugs that look like secret-manager failures.

Treat every value that ever touched git as public and rotate it. Then pick one boundary, write down which system owns application credentials and which owns infrastructure credentials, and hand workloads an identity rather than a token: OIDC federation in CI, IRSA or workload identity in Kubernetes, so short-lived credentials replace static ones.

Verify what actually landed. A base64 round trip is where mismatched values usually show themselves, and the Kubernetes Secret Decoder will tell you what the cluster is really holding. Delete the originals last, then add scanning so they cannot creep back. The full guide on DevToolLab walks through each of those steps with the specific tooling.

Conclusion

What changed in 2026 is that the open options stopped being compromises, so the license became the deciding variable instead of the capability. OpenBao ships namespaces and horizontal read scaling under MPL 2.0. Infisical is MIT at the core. SOPS costs nothing and runs no server. External Secrets Operator keeps the whole decision reversible. Vault is still the most capable thing here and is now an IBM product on an IBM cadence with no budget SaaS door. Count your non-human identities, settle whether dynamic secrets are genuinely required, and then choose the meter you can live with.

Prices and versions move fast. Check each vendor's page before committing.

References

Container Security in 2026: Why One Free Scanner Beats a $32B Acquisition on Half the Job

Moksh Gupta — Wed, 02 Sep 2026 17:44:54 +0000

Every container image is somebody else's OS packages zipped into layers, and whatever base image you picked last quarter is still shipping today, unchanged, every time CI runs. That's the uncomfortable part of container security: it's never a one-time check, because the image you scanned yesterday isn't the image that ships tomorrow.

Here's a number that makes the point. On September 2, 2026, running Trivy against node:18-alpine turned up 17 HIGH and CRITICAL OS vulnerabilities. Running it against alpine:3.20 turned up zero. Same scanner, same afternoon, one line changed in a Dockerfile. Meanwhile Google closed its $32 billion purchase of Wiz back in March 2026, the biggest acquisition in company history, buying a platform that solves a problem overlapping heavily with what that free 37,000-star binary just did in under a minute. I wrote up the full comparison on DevToolLab, including every tool's current pricing and license.

Both of those facts are true at once because "container security" isn't one job. It's three.

Three jobs, not one

Build-time scanning looks at an image or manifest and checks it against a CVE database. Fast, runs in CI, catches known vulnerabilities and misconfig before deploy. Blind to anything happening at runtime.

Runtime detection watches kernel events on live workloads and flags abnormal behavior: a container spawning a shell, reading /etc/shadow, opening an unexpected connection. This is what catches a zero-day nothing in a database has heard of yet. It can't stop a bad image from shipping in the first place.

Posture and compliance checks your cluster config against a framework like CIS Benchmarks or SOC 2. It answers the auditor's question, not the attacker's.

Most teams need exactly one tool per job. A platform selling you "all three in one" is usually a budget conversation dressed up as a coverage conversation.

Scanning before it ships

Trivy is the default pick for most teams, and for good reason: one Go binary (v0.74.0 as of mid-August 2026) covers container images, filesystems, git repos, Kubernetes manifests and IaC, handling CVEs, secrets, misconfig and SBOM generation in one pass. It reads straight from a registry, so no Docker daemon required.

The misconfig scanner is underrated. Pointing trivy config at a deliberately sloppy Dockerfile turned up 4 failures out of 27 checks, including a CRITICAL for a token passed through an ENV line and a flag on USER root. Neither of those is a CVE. Both are exactly how containers get popped in practice. What Trivy won't do is prioritize for you: 200 findings get treated the same whether they're on an internet-facing API or a monthly batch job. That triage is on you.

Grype takes the SBOM-first route: pair it with Syft, generate a bill of materials once, then scan that artifact repeatedly instead of re-reading the image each time. It's narrower than Trivy on purpose, doing vulnerability matching well and staying out of IaC and secrets entirely.

If your org already pays for Docker, Docker Scout is one command away, but repo limits bite fast: one Scout-enabled repo on Personal, two on Pro at $11/user/month, unlimited only from Team at $16/user/month. Fine for a single flagship image, expensive for a microservice fleet. Snyk Container leans the other direction, leading with base-image remediation advice rather than a flat CVE list, though it's usually sold bundled with Snyk Open Source rather than standalone.

What scanning can't see

Falco is a CNCF graduated project (the foundation's top maturity tier) using eBPF to watch kernel events in real time. A container that suddenly execs a shell or mounts something it shouldn't triggers an alert immediately, no CVE database required. The catch: it's detection-only, and the default ruleset is noisy enough against real production workloads that an unattended alert stream is worse than useless. Budget actual time for tuning.

Tetragon, a Cilium sub-project, goes a step further: because policy runs in-kernel via eBPF, it can enforce, not just observe, killing a process outright rather than just logging it. That enforcement is also the risk. Most teams run it in observation mode first before trusting it to kill anything in prod.

Compliance and the paid tier

Kubescape (CNCF incubating, v4.0.12) scans clusters, manifests and Helm charts against CIS Benchmarks, NSA-CISA guidance, MITRE ATT&CK and SOC 2, producing the actual artifact an auditor will accept. It also checks network policies and seccomp profiles, which nobody enjoys doing by hand.

On the commercial side, Wiz (now part of Google Cloud) sells correlation: tying a container CVE to cloud IAM exposure and network reachability so you know which of your 200 findings is actually exploitable from the internet. That's genuinely something open-source scanners don't do. Sysdig and Aqua Security play similar territory, both quote-only, both clearly built for a buyer with a procurement department. None of it is detection Trivy and Falco can't already do; what you're buying is prioritization and a support contract. The original post breaks down where each paid platform actually earns its price versus where it's just consolidation.

Wiring it into CI

The highest-value hour here is simple: fail builds on new HIGH/CRITICAL findings with an available fix, ignore everything else until you have a real triage process.

# scan locally first, no daemon needed
trivy image --severity HIGH,CRITICAL --scanners vuln node:18-alpine
trivy config .

In GitHub Actions, ignore-unfixed: true matters more than any other flag, since failing a build on a CVE with no patch just trains developers to ignore the scanner entirely:

- name: Run Trivy vulnerability scanner
  uses: aquasecurity/trivy-action@v0.36.0
  with:
    image-ref: 'docker.io/my-organization/my-app:${{ github.sha }}'
    exit-code: '1'
    ignore-unfixed: true
    severity: 'CRITICAL,HIGH'

Pin and update your base image regularly. The 17-versus-zero gap above came entirely from a base image swap, not a code change, and it's the single highest-leverage fix on this whole list.

If you're auditing what's actually in a Dockerfile, DevToolLab's dockerignore generator is worth a minute to make sure .env and .git never reach the build context a scanner has to find in the first place.

Picking a stack

Solo dev or side project: Trivy in CI, nothing else. Fail on fixable HIGH/CRITICAL, bump the base image monthly. Costs nothing.

Small team on Kubernetes: Trivy in CI plus Kubescape on a weekly cron against the cluster. Add Falco in observation mode once someone's actually committed to reading the alerts.

Regulated environment: Kubescape for SOC 2/CIS evidence, Trivy for scanning, Tetragon where a control specifically demands prevention over detection. Fully open source, fully auditable, and the cost shows up as configuration time instead of a license line.

Large multi-cloud fleet with a security team: This is genuinely where Wiz, Sysdig or Aqua pay for themselves. At thousands of findings across several clouds, knowing which twelve are actually reachable is the product.

References

Container Security Tools Compared, on DevToolLab - the full comparison with pricing tables, CNCF maturity status, and the complete CI workflow
Trivy
Grype
Falco
Tetragon
Kubescape
Wiz

Browser Agent Tools in 2026: What the Licenses and Benchmarks Actually Say

Moksh Gupta — Wed, 02 Sep 2026 05:01:10 +0000

Anyone who has pointed a scraper at a modern SaaS pricing page knows the failure mode: the request succeeds, the HTML is enormous, and the number you came for is nowhere in it. The page assembles itself in JavaScript after the response lands, so a plain HTTP client sees the scaffolding and none of the content.

Here is the version of that I measured. Azure's Content Safety pricing page, hit twice inside the same minute: fetch handed back 212kB of markup with zero dollar figures in it, and a real Chrome instance handed back 6kB of rendered text containing both $0.38 and $0.75.

That one gap explains why this whole tool category exists. Two other findings from the same afternoon are worth your attention before you pick anything: the WebVoyager percentages that show up in every comparison post are not measured against the same denominator, and one of the four most-starred open frameworks ships under AGPL-3.0. I checked every license, version and price below against the project's own repo or pricing page in August 2026. The fuller writeup, including the complete test script, is on DevToolLab.

One Label, Three Unrelated Products

"AI browser automation" gets stuck on three things that do not compete with each other.

Consumer AI browsers (Atlas, Comet, Dia) are end-user products, not something you build against. Agent frameworks are libraries that let a model decide what to click. Managed infrastructure runs the browser somewhere else and deals with proxies, fingerprints and concurrency limits, while staying completely indifferent to what your agent does once the page loads.

Most real deployments pair a framework with infrastructure. That pairing is also why Browserbase sells hosting and gives away Stagehand.

First, Prove You Need a Browser

Rendering a page is the slowest and most expensive way to read it, so settle that question before you shop for tooling. You can test it with nothing but Node's built-in fetch and WebSocket against a Chrome started with its debugging port exposed:

"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" \
  --remote-debugging-port=9333 --headless=new --no-first-run \
  --user-data-dir=/tmp/cdp-demo about:blank

From there you open a tab over http://localhost:9333/json/new?<url>, attach to webSocketDebuggerUrl, call Runtime.enable, then poll Runtime.evaluate on document.body.innerText until a price regex matches instead of sleeping for an arbitrary number of seconds. The full script is in the original article if you want to paste and run it.

Two of the four runs I logged:

plain fetch    12208ms  212kB html  prices found: NONE
real browser    2134ms  6kB text  prices found: $0.38, $0.75

plain fetch    11040ms  212kB html  prices found: NONE
real browser    4087ms  6kB text  prices found: $0.38, $0.75

Treat the timings as incidental. A static page would reverse them. The payload sizes are the finding: 212kB of markup containing nothing a person would read off the screen, versus 6kB of text containing all of it. Hand the fetch output to an agent and it will confidently tell you Azure publishes no pricing, which is exactly the wrong answer I got the first time.

The Open Source Field

browser-use is MIT, v0.13.7 as of July 27, 2026, and wants Python 3.11 or newer plus an LLM key. It has the largest community and the most sample code, which makes it the reasonable default. Its docs are also candid about the ceiling: CAPTCHAs push you toward their hosted stealth browsers, memory climbs as soon as you run tasks in parallel, and they steer production workloads to their cloud.

Stagehand is Browserbase's own, MIT, v4.0.0 on August 10, 2026, with SDKs for TypeScript, Python and Go. Instead of dumping a page into a model and hoping for the best, it gives you act, extract and observe as discrete calls. That means each step is something you can log, cache and write an assertion against. If you have ever watched a twelve-step agent quietly do the wrong thing at step seven and had no trace to inspect, this is the design that fixes it.

Skyvern sits at v1.0.48 (August 5, 2026) and is the one to read the LICENSE file on first: it is AGPL-3.0, not MIT and not Apache. Internal use is unproblematic. Shipping or hosting it means a conversation with whoever handles licensing at your company. Most roundups file it next to the permissive projects and never mention the difference. Technically it is the vision-first option, working from the rendered page rather than element IDs, which holds up better when a site's markup churns weekly.

Playwright MCP is Microsoft's, Apache 2.0, v0.0.79 (August 6, 2026). It hands Playwright to any MCP client, so an existing coding agent picks up a browser with no glue code, navigating via structured accessibility snapshots instead of a vision model. The version string is refreshingly honest about how young it is; the underlying lineage is the strongest in the category.

Steel (Apache 2.0) is the outlier: open source browser infrastructure rather than an agent framework, effectively a self-hostable Browserbase. It is where you start when session data is not allowed to leave your own network.

Browserbase, and What "Browser Hours" Bills For

Credit where it is due: Browserbase posts its prices publicly, which is not universal here.

Free: $0, 1 browser hour, 3 concurrent, 15-minute session cap, 3 agent runs · Developer: $20/month, 100 hours, 25 concurrent, $0.12 per additional hour · Startup: $99/month, 500 hours, 100 concurrent, $0.10 per additional hour · Scale: custom

A single browser hour with a 15-minute ceiling per session is a trial, not a tier, so plan on Developer the moment anything runs on a cron. The pricing detail with real consequences: a browser hour is wall-clock time the session stays open, not compute consumed. An agent blocked on a slow network request bills identically to one doing work, which makes aggressive session teardown your main cost control. On the will-they-still-exist question, they raised a $40 million Series B in June 2025 at a $300 million valuation.

Side by Side

Tool	License	Type	Self-hosted	Status
browser-use	MIT	Agent framework, Python	Yes	v0.13.7, ~109.1k stars
Stagehand	MIT	Agent framework, TS/Python/Go	Yes	v4.0.0, ~23.9k stars
Skyvern	AGPL-3.0	Vision-first agent framework	Yes	v1.0.48, ~22.7k stars
Playwright MCP	Apache 2.0	MCP server over Playwright	Yes	v0.0.79, ~36k stars
Steel	Apache 2.0	Self-hostable browser infra	Yes	~7.5k stars
Browserbase	Commercial	Managed browser infra	No	Free, then $20 or $99/month

WebVoyager Is Not a Leaderboard

You will see 89.1 percent for browser-use next to 85.85 for Skyvern, laid out like standings. Both figures are honestly reported. Putting them side by side is still meaningless.

The task counts do not match: browser-use scored over 586 tasks, Skyvern over 635, Agent-E over 643. The conditions diverge in the direction that flatters whoever is on top, since browser-use ran locally on clean IPs with no bot detection in the way while Skyvern ran in the cloud against live bot protection. In other words the lower number came out of the harder environment. Everything is self-reported, and the benchmark itself covers 643 tasks across 15 sites skewed toward reading, with logins, 2FA, form submission and downloads barely represented.

That is not a criticism of either project. It just means 89 percent tells you nothing about how either behaves on a Cloudflare-protected target, and the only benchmark that predicts your results is your own task list.

The Security Model Is Broken by Design, Not by Bug

Stand back and look at what a browser agent is: private data reachable through your authenticated sessions, untrusted input because it is reading the open web, and outbound communication because filling in forms is the entire point. That is all three legs of the lethal trifecta, aimed at your own logged-in accounts.

This is not theoretical. Brave published indirect prompt injection against Perplexity Comet, planting instructions in page elements no human would ever see and getting the agent to perform cross-site actions, one-time passcodes lifted out of email included. LayerX showed injected instructions can be persisted into an agent's long-term memory over CSRF and survive into later sessions.

OpenAI's own security writeup calls prompt injection "one of the most significant risks we actively defend against," and as of late December 2025 their stated position is that it may never be fully solved for browser agents. The UK's National Cyber Security Centre reached the same conclusion. Practical upshot: give the agent a dedicated, narrowly scoped account that cannot move money, rotate credentials or reach a password reset inbox, and treat every page it visits as hostile input.

Picking One, and the First Five Steps

Python codebase, take browser-use. Want per-step traces you can assert on, Stagehand. Form-heavy work on unstable markup and the AGPL question already answered, Skyvern. Already running MCP, Playwright MCP. Data cannot leave the building, Steel. Do not want to operate browsers at all, Browserbase starting at $20.

Then, in this order:

Verify a browser is necessary. Run the fetch-versus-browser comparison against your actual target. If plain HTTP already has your data, walk away from this category.
Check you are permitted to automate the path. DevToolLab's Robots.txt Tester tells you whether a specific URL is allowed for a given user agent.
Lock down whatever is deterministic. Confirm selectors in the XPath Tester and reserve the model for the steps that genuinely need judgment. A selector costs nothing; an LLM call costs every time.
Shrink pages before they eat your context. Raw HTML spends tokens on markup, and the HTML to Markdown converter makes the size difference obvious.
Least-privilege account plus a hard session timeout. Both in place before the first scheduled run, not after.

Conclusion

The open source layer here is genuinely good and the marketing around it is not. browser-use owns the community and the MIT license, Stagehand has the most inspectable structure, Playwright MCP has the best pedigree, Steel answers data residency, and Skyvern is an AGPL-3.0 decision that deserves more than a footnote. Skip the WebVoyager table entirely, spend an afternoon running your own tasks, and design the security posture in from the start rather than bolting it on.

Licenses, versions and prices in this category move fast. Confirm each one against the project's own repo before you commit to anything.

References

CI/CD Pricing in 2026: Why Your Seats Cost More Than Your Builds

Moksh Gupta — Tue, 01 Sep 2026 18:54:39 +0000

Pick a CI platform on features and you will end up comparing four YAML dialects that all do roughly the same thing. Pick one on its billing model and the differences get sharp fast, because these vendors do not meter the same units. One charges you per build minute, one per credit, one per seat with the compute thrown back at you.

I dug through every vendor's published rates for a longer writeup on DevToolLab, Best CI/CD Tools in 2026. This is the condensed version: what the meters actually cost, and which open-source engines skip them entirely.

The Fee That Got Walked Back

December 15, 2025 is the date to remember. GitHub said it would start charging $0.002 a minute as an Actions "cloud platform" fee on private-repo workflows, and critically that included jobs on runners you host and pay a cloud provider for yourself. Developers pushed back hard, and GitHub shelved the self-hosted portion within a couple of days. The hosted-runner discount survived and took effect January 1, 2026, cutting net prices by as much as 39 percent.

Read that sequence carefully, because it tells you where the industry is heading. Raw compute is commoditizing. The orchestration layer sitting on top of it is what vendors now want to bill for. GitHub called the pause a re-evaluation rather than a cancellation, so anyone running a big self-hosted fleet should treat that fee as deferred, not dead.

Nobody Has Standardized

JetBrains surveyed developers for its State of Developer Ecosystem 2025 and found GitHub Actions at 33 percent inside organizations, Jenkins at 28 percent, and GitLab CI at 19 percent. A further 18 percent reported no CI/CD tooling at all. Their follow-up State of CI/CD survey, 805 respondents, found roughly a third of organizations running two CI systems side by side.

Jenkins holding second place is the surprise. It dates to 2011, runs on the JVM, and carries 2,102 plugins in its update center. It survives because nothing about it counts your seats or your minutes.

One Workload, Four Meters

Rather than trust marketing pages, price a single realistic month against each vendor: ten active developers, twelve thousand Linux build minutes.

// Same workload, four billing models. Rates from vendor pricing pages,
// September 2026. Assumes GitHub Team seats, CircleCI Docker medium
// (10 credits/min), Buildkite 2-vCPU agents.
const devs = 10, minutes = 12000;

const plans = [
  // name,                base, freeSeats, perSeat, freeMin, $/min
  ['GitHub Actions',         0,         0,       4,    3000, 0.006],
  ['GitLab Premium',         0,         0,      29,   10000, 0.010],
  ['CircleCI Performance',  15,         5,      15,    3000, 0.006],
  ['Buildkite Pro',          0,         0,      30,    2000, 0.008],
];

for (const [name, base, free, perSeat, freeMin, rate] of plans) {
  const seats = base + Math.max(0, devs - free) * perSeat;
  const compute = Math.max(0, minutes - freeMin) * rate;
  console.log(`${name.padEnd(22)} $${seats} seats + $${compute} compute`);
}

$ node ci-cost.mjs
GitHub Actions         $40 seats + $54 compute
GitLab Premium         $290 seats + $20 compute
CircleCI Performance   $90 seats + $54 compute
Buildkite Pro          $300 seats + $80 compute

Totals: $94, $310, $144 and $380 a month. Look at which column carries the weight. Compute never breaks $80 anywhere, while seats swing by a factor of seven. GitLab and Buildkite bundle far more than a build runner into that seat, so this is not a fair feature comparison, but it does tell you which number to audit first when finance asks about the CI line.

The Four You Pay For

GitHub Actions wins on being already installed. Free tiers get 2,000 private-repo minutes monthly, Pro and Team 3,000, Enterprise Cloud 50,000, and public repos run free on standard runners. Post-January rates: $0.006 a minute for 2-core Linux x64, $0.005 arm64, $0.010 Windows, $0.062 macOS. Storage bites quietly. Artifacts run $0.25 per GB-month and cache runs $0.07 beyond a free 10 GB per repository.

GitLab CI/CD ships as one slice of a much larger platform. Free grants 400 compute minutes and five users per top-level group. Premium runs $29 per user monthly on an annual term with 10,000 minutes; Ultimate switched to quote-only pricing this year and includes 50,000. Overflow minutes are $10 per thousand as a one-off purchase. The detail worth stealing sits in GitLab's FAQ: your own runners never consume the quota and have no cap, on every tier including Free.

CircleCI denominates everything in credits, so translation is mandatory before you can budget. Docker small costs 5 credits a minute, medium 10, large 20. Linux VM pricing varies by generation, with the default x86 medium at 10 and Gen 3 medium at 7. macOS M4 Pro medium sits at 200 credits a minute, which puts an iOS build around forty times a comparable Linux job. The free allotment is real though: 30,000 credits, five users, 30x concurrency.

Buildkite splits the job. Their servers handle scheduling, logs, secrets and the interface; your machines execute the work. Free covers five users and 2,000 Linux vCPU-minutes. Pro is $30 per active user monthly for up to fifty users, ten agents included and $3.50 for each one after. Optional managed agents cost $0.004 per vCPU-minute on Linux, so a 2-vCPU box lands at $0.008 of wall-clock time. Agents you own incur no per-minute charge whatsoever.

The Four You Host

Jenkins remains MIT-licensed with 26.5k stars and LTS 2.568.2 as of August 5, 2026. Java 21 is mandatory from the 2.555 line forward. There is no meter and no seat count, and in exchange you own a controller, a JVM and a plugin dependency graph that turns into a part-time job somewhere past two hundred plugins. Reach for it when build steps refuse to containerize or when hardware legally cannot leave your premises.

Semaphore Community Edition is the newest option worth attention, because Semaphore released its engine under Apache 2.0. Self-hosted means unlimited users and unlimited concurrency, with artifacts, test dashboards and flaky-test detection in the box. Two things to know: the ee directory carries a separate Enterprise license covering SAML, RBAC and audit logs, and the newest tag is v1.5.0 from October 10, 2025 even though main gets daily commits. Pin your version. Their cloud offering charges $0.0075 a minute for 2-vCPU x64 with no seat fee at all.

Woodpecker CI split off from Drone back in 2021 when a licensing change clamped down on self-hosting. It is Apache 2.0, sits at 7.8k stars, and shipped v3.18.0 on August 24, 2026. Architecture is a Go server plus agents, every step is a container, and it speaks GitHub, GitLab, Gitea, Forgejo and Bitbucket. Expect no hosted tier, no test analytics, and plugins numbering in the dozens rather than thousands.

Argo CD belongs in a different column entirely. It is a CNCF graduated GitOps reconciler that syncs a cluster against a Git repo, so it substitutes for your deploy stage, not your build stage. CNCF's July 2025 end user survey put it in nearly 60 percent of Kubernetes clusters doing application delivery, with 97 percent of respondents running it in production and an NPS of 79. Currently v3.5.2. Treat CI selection and CD selection as two separate calls.

Quick Comparison

Tool	Meter	Starting point	License
GitHub Actions	Seats plus minutes	2,000 free min, $0.006/min after	Proprietary
GitLab CI/CD	Seats plus minutes	400 free min, Premium $29/user	Open core
CircleCI	Seats plus credits	30,000 free credits, $15/mo up	Proprietary
Buildkite	Seats, you supply agents	5 free users, Pro $30/user	Proprietary
Jenkins	None	Free	MIT
Semaphore CE	None self-hosted	Free, cloud $0.0075/min	Apache 2.0, open core
Woodpecker	None	Free	Apache 2.0
Argo CD	None, CD only	Free	Apache 2.0

Picking One

Start with two numbers off last month's invoice: build minutes consumed and humans who actually committed. Feed them through the script above. Where seats dominate, hunting a lower per-minute rate is wasted effort.

Confirm the macOS multiplier before committing if you ship mobile, since that single line dwarfs everything else on both CircleCI and GitHub. Ask each vendor what bringing your own runners costs, because the answers genuinely differ: GitLab meters nothing, Buildkite charges no per-minute fee, GitHub charges nothing today with a caveat attached. Then trial on your slowest genuine pipeline instead of a toy repo, and time it with caches cold.

Keep the definition portable while you are at it. Containerized steps and plain shell survive a migration; vendor orbs, marketplace actions and Groovy pipelines do not. Two utilities that help around the edges: Dockerfile Linter for catching image build waste before a runner bills you for it, and JWT Decoder for checking the OIDC token your pipeline swaps for cloud credentials.

The full breakdown, with per-vendor screenshots, the complete credit tables and the reasoning behind each recommendation, lives in the original post on DevToolLab.

References

Best CI/CD Tools in 2026: What They Really Cost and When to Self-Host - the original, fuller article
Pricing changes for GitHub Actions - GitHub's own December 15, 2025 notice
GitHub Actions billing documentation
GitLab pricing
CircleCI resource classes and credit rates
Buildkite pricing
Semaphore Open Source
Woodpecker CI
Argo CD documentation
CNCF end user survey on Argo CD adoption
GitHub Actions Best Practices - companion guide on securing the pipeline you pick

LaunchDarkly Dropped Per-Seat Pricing. Here Are 3 Ways to Skip the Bill Entirely

Moksh Gupta — Mon, 31 Aug 2026 19:02:14 +0000

Feature flags exist so a bad deploy becomes a config change instead of an incident. That part hasn't changed. What has changed is the bill: LaunchDarkly shipped AgentControl on May 19, 2026, a runtime layer that reconfigures an AI agent's behavior in under 200ms without a redeploy, and quietly dropped per-seat pricing in the process. The current plan meters two things instead: service connections and client-side monthly active users.

I wrote up the full breakdown, with every number pulled from the live pricing pages, on DevToolLab. Here's the short version, plus a demo proving the "avoid lock-in" pitch for the open standard underneath all of this actually holds up.

What changed and why it matters

LaunchDarkly's free Developer tier is still generous: unlimited seats and flags, 5 service connections, 1,000 MAU, 5,000 AI runs, 14-day retention, no card required. The paid Foundation tier is where the new shape shows: $10 per service connection a month plus $8.33 per 1,000 client-side MAU, no seat fee at all. Per Vendr's marketplace data, the median contract still lands between $63,960 and $72,000 a year.

None of that is unreasonable for what the platform does. But if you're not using agent orchestration, you're paying enterprise rates for flag delivery alone, and that's exactly the gap three open source projects have been eating for years.

The three ways out

Switch vendors. Unleash, GrowthBook, and Flagsmith each sell a hosted plan, priced on very different terms than LaunchDarkly. All three matter more for what comes next.

Self-host. Each of those three also ships a real, free, open source edition, not a crippled trial. The cost becomes a small VPS instead of a connection meter.

Stop caring which vendor you're on. OpenFeature is a CNCF specification, not a product. Your code calls one vendor-neutral API; the provider underneath becomes a config line instead of an architecture decision.

The three self-hosted options, briefly

Unleash is AGPL-3.0, sits around 13,800 GitHub stars, and self-hosting is one docker compose up -d away. The catch: choosing self-hosted under its Pay-As-You-Go cloud plan carries a 5-seat minimum, and the license means modifications you distribute as a service need to stay open.

GrowthBook licenses most of the repo MIT, with a handful of enterprise directories carved out under a separate license, the exact same shape as several other "open core" tools in this space. Free self-hosting has no user cap, just a one-project ceiling. It also does warehouse-native experimentation, not just flags, which the other two don't.

Flagsmith is BSD-3-Clause and, unusually, publishes no request ceiling at all on self-hosted deployments. Its hosted free tier is a real but small 50,000 requests a month for one seat.

Proving OpenFeature actually avoids lock-in

The claim is easy to make and worth testing instead of trusting. Here's business logic that only imports the OpenFeature client, never a vendor SDK:

import { OpenFeature } from "@openfeature/server-sdk"

export async function renderCheckoutButton(userId) {
  const client = OpenFeature.getClient()
  const enabled = await client.getBooleanValue("new-checkout-flow", false, {
    targetingKey: userId,
  })
  return enabled ? "new checkout" : "classic checkout"
}

Now swap the provider underneath it, twice, using the SDK's built-in in-memory provider as a stand-in for a real vendor plugin:

import { OpenFeature, InMemoryProvider } from "@openfeature/server-sdk"
import { renderCheckoutButton } from "./checkout.mjs"

await OpenFeature.setProviderAndWait(new InMemoryProvider({
  "new-checkout-flow": { variants: { on: true, off: false }, disabled: false, defaultVariant: "off" },
}))
console.log(await renderCheckoutButton("user-1")) // "classic checkout"

await OpenFeature.setProviderAndWait(new InMemoryProvider({
  "new-checkout-flow": { variants: { on: true, off: false }, disabled: false, defaultVariant: "on" },
}))
console.log(await renderCheckoutButton("user-1")) // "new checkout"

I ran this with @openfeature/server-sdk 1.23.0 before publishing, and the output matches the comments exactly. checkout.mjs never changes between the two runs. Swapping a real vendor's provider in production is the same operation: change what you pass to setProvider, not what your application calls.

The part that breaks during migration

Config vars and builds port cleanly between any of these platforms. What doesn't is percentage rollout math: LaunchDarkly, Unleash, and GrowthBook each hash users into targeting buckets differently, so a 10% rollout on one system is not the same 10% of users on another. Verify parity before you cut traffic over, and keep the old vendor running for a full billing cycle after the new one goes live, so a rollback is a config change and not an emergency.

The full article on DevToolLab also covers GrowthBook's exact license split, the complete pricing comparison table, and a step-by-step migration checklist.

Related DevToolLab tools

If you're standing up a self-hosted flag server, two tools are worth bookmarking: an .env file generator for scaffolding the environment variables Unleash, GrowthBook or Flagsmith need before your first docker compose up, and a webhook signature verifier for checking the HMAC on incoming flag-change webhooks before you trust the payload.

References

Heroku Went Into Maintenance Mode. Here Are Six Places to Take Your App Instead

Moksh Gupta — Mon, 31 Aug 2026 04:31:42 +0000

In February 2026, Salesforce announced that Heroku is moving to "sustaining engineering": stability, security and support, with no mention of new features. Nothing breaks today. But a platform that will never ship anything new again is a different bet than the one teams made when they first ran git push heroku main. I wrote up the full comparison on DevToolLab, and this is the short version.

The Real Push Isn't the Announcement, It's the Price List

Existing customers keep their billing and support. What actually moves teams is Heroku's own tier structure: Standard-2X tops out at 1 GB for $50/mo, and the next step up, Performance-M, is $250/mo for 2.5 GB. That is five times the cost for two and a half times the memory, with nothing in between. Teams that outgrow the middle tier hit that wall long before they think about the sustaining engineering announcement.

Managed vs Self-Hosted

Render, Railway, Fly.io and DigitalOcean App Platform all take a repo, build it and run it, the same shape as Heroku, just with a different bill. Coolify and Dokku instead run on a VPS you rent yourself, trading a per-app fee for the job of patching the box and owning your own uptime.

Render is the closest match to Heroku's actual feel, down to running a dedicated "Migrate to Render" push with migration credits. The catch is a two-part bill: a flat $25/mo Pro workspace fee sits on top of instance pricing, so a Standard 2 GB instance at $25/mo is really $50/mo once the workspace fee is counted.

Railway bills what you consume, not what you reserve, at roughly $20 per vCPU-month and $10 per GB-month, metered by the second. That is great for spiky traffic and bad for predictability: a service that's up but idle still accrues cost every second.

Fly.io runs apps as Firecracker microVMs and has the cheapest raw compute of the group, a 1 GB machine for $5.92/mo in Amsterdam. The trap is the database: managed Postgres starts at $38/mo, six times the app it's backing, and you're editing fly.toml and thinking about regions and volumes in a way the others don't ask of you.

DigitalOcean App Platform is flat-rate with bandwidth bundled in, no separate workspace fee, no metering. A 1 vCPU / 1 GB container is $10/mo with 100 GiB of transfer included. It's also the plainest of the four, and the $7/mo dev database is explicitly not for production traffic.

Coolify is Apache-2.0 with no feature gates, a Laravel app managing Docker Compose deployments with 280+ one-click services. Coolify Cloud is $5/mo for the control plane on top of your own servers. A single-server setup has no failover, so a bad kernel update takes the app down with it.

Dokku is the minimalist option, MIT licensed, and the one that most literally reproduces the Heroku workflow: dokku apps:create, add a git remote, push. It's CLI and SSH only with no dashboard, single-host by default, and you're the entire ops team.

Pricing a Real App

I built a small script that prices one always-on 1 GB web service plus each platform's cheapest managed Postgres, since RAM is the one unit every provider actually publishes. At 1 GB, DigitalOcean comes out cheapest at $17/mo, Railway a dollar behind at $18, Render at $31, and Fly.io at $43.92 once you add its $38/mo Postgres. Heroku itself lands at $55/mo for the same shape. The full runnable script and the comparison table covering all seven platforms are in the original writeup on DevToolLab.

Migrating Without Losing Anything

The mechanical parts of a Heroku migration - config vars, builds, Postgres - port cleanly with heroku config -s and pg:backups:capture. The part that actually bites people is Heroku Scheduler, which has no direct equivalent anywhere else and needs to become cron or a scheduled GitHub Actions workflow before cutover, not after. Run both stacks in parallel behind a low DNS TTL and leave the old Heroku app running one full billing cycle before you shut it down.

Which One to Pick

If you want to think about this the least, DigitalOcean App Platform at $17/mo for a 1 GB app is the answer. Render costs more but matches Heroku's polish closest. Railway suits spiky or multi-service workloads where metered billing works for you. Fly.io wins on latency and raw compute if you bring your own database. Coolify and Dokku are for teams who'd rather own a VPS than pay a per-app fee indefinitely.

References

Best Heroku Alternatives in 2026: Render, Railway, Fly.io and Open Source PaaS Compared - the original article, with the full seven-way comparison table and the complete pricing script
Connection String Parser - breaks a Heroku DATABASE_URL into host, port, user and sslmode when repointing it at a new database
Caddyfile Generator - generates a reverse proxy config with automatic TLS for a self-hosted Coolify or Dokku box
Salesforce's February 6, 2026 announcement on Heroku moving to sustaining engineering