Pixel

Pixel Updates & Events

Server Updates & Events

Announcements

Document REST APIs with AI and DocStar

DEV Community

How to Document a REST API with DocStar: Let Your AI Agent Draft It

Documenting a REST API used to mean days of copying routes, parameters and example bodies into a docs tool. With DocStar, your AI coding agent does that part. Connect Claude Code, Cursor or Codex to DocStar, point it at your code, and it documents every endpoint as a draft: method, URL, auth, parameters, a full body example and sample responses. You review, test and publish an interactive API reference, and the same docs also give you a hosted MCP server and a CLI. This guide walks through the agent-first way to document a REST API with DocStar, what good endpoint docs need, and where your review matters most. What good REST API documentation includes Whether a person or an agent writes it, every endpoint needs the same parts. This is the checklist your agent works to, and the one you review against: Part What readers need Purpose One or two sentences on what the endpoint does and when to use it Method and URL GET, POST, PUT, PATCH or DELETE, plus the full path Parameters Query params and path variables, each with a description Authentication How to authorize the call Headers Required headers such as Content-Type Request body A complete, realistic example and what each field means Responses Real success and error examples Try it A way to send the request and see a live response DocStar has a home for each of these in its endpoint editor, and a TRY button on every published endpoint. Step 1: Connect your coding agent to DocStar DocStar runs an MCP server for documentation work. Add it to your agent as a remote MCP server: https://mcp.docstar.io/mcp
Or connect DocStar from your assistant's connector directory if it's listed there. The first time the agent needs your workspace, you sign in to DocStar in your browser. No API key to copy, and the agent only works with the collections your account can access. See Connect Your AI Assistant. Step 2: Ask it to document your API from the code Open the agent in your API's repository and ask in plain words: Use the DocStar MCP. Read our API routes and document every public endpoint in a new DocStar API collection called "Payments API". For each endpoint, write a clear description, every parameter and header, a full JSON body example with every accepted field, and sample success and error responses. The agent reads your routes and finds the auth, parameters, bodies and responses. It shows you the plan, including the collection slug, and waits for your OK. The slug is permanent and becomes part of your MCP URL and CLI commands, so pick something short like your product name. Already have an OpenAPI 3.x, Swagger 2.0 or Postman file? Ask the agent to import it first and then check each endpoint against your code. Our guide to going from OpenAPI to an MCP server shows that flow. Step 3: Review the drafts Everything the agent creates is a draft, so nothing is public yet. Open the collection in DocStar and review it like a pull request. The agent gets the structure right fast; your job is the judgment calls: Names. Action names readers scan for, like Create order or List invoices. Descriptions. Not "The order ID", but "ID of the order, returned by Create order. Starts with ord_." The same words are what AI assistants read when they call your API through your MCP server, so clear descriptions pay off twice. Body fields. Switch the body from Raw to Body Description to see a description box for every JSON field. Check units and formats (cents or dollars, ISO 8601 dates) and which fields are optional. What stays private. Internal or test-only endpoints can simply stay unpublished. Secrets. Tokens and keys belong in environment variables, never in URLs or examples. Want a change? Ask the agent ("make every description say when to use the endpoint") or edit directly. DocStar's editor is real-time and collaborative, so a writer and an engineer can work on the same page at once. Step 4: Test every endpoint against the real API Every endpoint in DocStar is also a working request, so you can check th...

Powered by Readybot.io

Document REST APIs with AI and DocStar

MCP Server Ecosystem: Data on 61,855 Servers

DEV Community

The State of MCP Servers: I analyzed all 61,855 of them

I run Serverdex, a directory that indexes the official Model Context Protocol (MCP) registry. That means I have a row for every published MCP server sitting in a database — so I pulled the numbers on all 61,855 of them and wrote up the state of the ecosystem. Here's what stood out. 1. The registry 100x'd in about a year In September 2025 the registry held a few hundred servers. It has roughly doubled month over month through 2026: Feb 2026: 845 new servers Jul 2026: 3,465 Sep 2026: 9,427 Oct 2026: 16,876 October 2026 alone added more servers than existed in the entire first six months. If you've felt like MCP went from "interesting protocol" to "everyone is shipping one" overnight — the data agrees. 2. Remote won MCP started as local stdio servers: you install a package and run it yourself. That is no longer the norm. 60% of servers are remote-only — a hosted HTTP endpoint with nothing to install. Only ~32% ship as a local package alone. streamable-http is now the dominant transport, well ahead of local stdio. The ecosystem has quietly shifted from "download and run" to "point your client at a URL." The median server is now something you connect to, not something you install. 3. How they ship Of the ~24,000 servers with an installable package: npm: 16,717 PyPI: 5,367 MCPB: 2,295 Docker (OCI): 1,794 NuGet: 175, Cargo: 129 MCP tooling is a JavaScript-first world, with Python a clear second. 4. A few giants, a long tail There are 1.27 million combined GitHub stars across the index — but attention is brutally concentrated. 92 servers hold 1,000+ stars each, while the vast majority have none. The head is names you'd expect: Browser Use, Scrapling, Metabase, CCXT, the official GitHub MCP server. 5. Open by default MIT is the default license of the MCP ecosystem by a wide margin (6,571 servers), with Apache-2.0 a distant second (778). The space is overwhelmingly open source. Methodology Numbers are from the Serverdex index of the official MCP registry, as of 15 November 2026: 61,855 published servers. Growth is by first-publication date. Languages, stars and licenses cover the servers with a resolvable public GitHub repository. "Remote-only" means a server advertises an HTTP endpoint and no installable package. The full report — with charts and the most-starred servers — is here: The State of MCP Servers. If you maintain an MCP server, it's probably already indexed; you can claim its page for free. And if you want a specific cut of the data (by category, by month, remote vs local over time), ask in the comments — happy to pull it.

Powered by Readybot.io

MCP Server Ecosystem: Data on 61,855 Servers

Fix Docker cgroupv2 Errors in CI Runners

DEV Community

Docker cannot enter cgroupv2, and cgroup mount errors in CI

Docker cannot enter cgroupv2, and the cgroup mount errors beside it, mean the runtime could not place your container into a control group, which on a CI runner nearly always means a daemon running nested inside another container without the v2 controllers delegated to it. Your image and your command are not involved: the container has nowhere to be accounted. A nested daemon can only place containers in cgroups its own environment was given. Delegation is what decides that, and it is not automatic. What this error means A container refuses to start and the message points at /sys/fs/cgroup rather than at anything you wrote, often with the phrase "with domain controllers" and a note that the state is invalid. It appears in Docker-in-Docker jobs, in Kubernetes-in-Docker tools, and in build engines that run their own daemon in a container, and it does not appear on a plain hosted runner doing a plain docker run. We did not reproduce it: it needs a nested daemon in a particular broken delegation state, and building one to photograph it would teach you less than the delegation rules below. The line below is quoted in full from containerd/containerd#6659, ctr prefix and line numbers included, because the clause that names the cause is in the middle of it: applying cgroup configuration for process. The Go file and line numbers move between runc releases, so match on that clause rather than on them. ```The line containerd/containerd#6659 reports (illustrative, not a recorded run) ctr: failed to create shim task: OCI runtime create failed: container_linux.go:380: starting container process caused: process_linux.go:385: applying cgroup configuration for process caused: cannot enter cgroupv2 "/sys/fs/cgroup/default" with domain controllers -- it is in an invalid state: unknown

Common causes

Controllers were never delegated to the nested environment

The dominant cause. A daemon inside a container gets a cgroup subtree, and the controllers it needs have to be enabled in that subtree by whatever created it. When they are not, the runtime cannot create the child cgroup for a new container, and reports that it cannot enter the cgroup it was given.

The cgroup mount is missing or read-only inside the container

A nested daemon needs /sys/fs/cgroup present and writable for its own subtree. A hardened container, a read-only mount, or a sandbox that hides the hierarchy produces mount errors in the same family, with the same effect: nothing can be placed in a cgroup.

The cgroup driver does not match the host

On a v2 host the default driver is systemd. A nested runtime or a tool configured for cgroupfs will fight the systemd hierarchy, and in our experience this is the cause when the error changes shape between runs rather than being stable.

The runtime predates proper cgroup v2 support

Older runc and containerd releases handle the unified hierarchy badly, which is what containerd/containerd#6659 is about. A pinned old runtime in a custom image, or a base image nobody has refreshed, is enough to reproduce a bug that current versions do not have.

How to fix it

Use the daemon the runner already has

  1. Drop the docker:dind service and run Docker commands directly in the job.
  2. If a tool insists on its own engine, check whether it has a mode that reuses the host daemon.
  3. Keep nesting for cases that genuinely need isolation between builds.

```.github/workflows/ci.yml
- run: docker info --format '{{.CgroupVersion}} {{.CgroupDriver}}'
- run: docker build -t app .
Give the nested daemon the cgroup environment it needs When you do nest, run the inner daemon with the host cgroup namespace and the privileges to manage its subtree, and mount the hierarchy so it is writable. This is a deliberate reduction in isolation, so scope it to the job that needs it rather than making it the default. docker run --privileged --cgroupns=host \
- v /sys/fs/cgroup:/sys/fs/cgroup:rw \
docker:29-dind
Align the cgroup drive...

Powered by Readybot.io

Fix Docker cgroupv2 Errors in CI Runners

Monetize Technical Content With No Upfront Costs

DEV Community

How to Monetize Technical Content Without Any Up‑Front Investment

Creating technical content—tutorials, code snippets, deep‑dive articles, or video walkthroughs—can be a rewarding way to share knowledge and build a personal brand. The challenge many creators face is turning that effort into a sustainable income stream without spending money on hosting, marketing tools, or paid advertising. Below is a practical roadmap that shows how you can start earning from your expertise today, using only free resources and a strategic approach. 1. Define a Precise Niche and Understand Your Audience A clear focus helps you stand out and attract a dedicated audience. Identify pain points: Look at forums, Q&A sites, and social media groups to see what questions keep recurring. Create audience personas: Sketch brief profiles—e.g., “mid‑level DevOps engineer looking for quick deployment tricks” or “student learning data‑science pipelines.” A well‑defined niche also makes it easier for platforms and sponsors to match you with relevant opportunities later on. 2. Use Free Platforms to Publish and Distribute Zero‑cost channels can host your content, drive traffic, and lay the groundwork for monetization. Platform Ideal Content Type Key Benefits GitHub Pages / GitLab Pages Written tutorials, documentation, static sites Free custom domain support, version control, SEO‑friendly YouTube Video tutorials, live coding, webinars Massive audience, built‑in ad revenue once thresholds are met Medium (Partner Program) Long‑form articles, case studies Access to a paying subscriber base Substack Newsletter‑style posts, curated resources Direct email list building, optional paid subscriptions Dev.to Blog posts, code snippets, community discussions Tech‑focused community, easy cross‑posting from GitHub Publish consistently on at least two of these platforms. Repurpose the same core material—e.g., turning a written guide into a short video—to maximize reach without extra creation effort. 3. Build Revenue Streams That Require No Up‑Front Costs Once you have a modest but engaged audience, you can layer on monetization methods that rely on existing traffic. a. Advertising and Platform Revenue Shares Platforms such as YouTube and Medium offer ad revenue sharing, typically requiring engagement metrics. The revenue is generated automatically from the views you already have. b. Affiliate Links for Relevant Tools Developer‑focused services (cloud providers, IDE plugins, API marketplaces) often run affiliate programs that pay per sign‑up or per sale. Insert contextual links within tutorials—e.g., a “Deploy this app with DigitalOcean” button—so readers can act immediately. c. Sponsored Content and Partnerships Brands looking to reach a technical audience sometimes pay for sponsored posts, product reviews, or webinars. Approach companies whose tools you already use and can speak about authentically. Since you’re not paying for ad placements, the cost is purely your time and the value you provide. d. Paid Memberships or Patreon‑Style Support If you consistently deliver deep, actionable content, a portion of your audience may be willing to support you directly. Platforms like Patreon, Ko‑fi, or a simple “Buy Me a Coffee” button let fans contribute monthly or per‑article. Offer exclusive perks—early access to drafts, private Q&A sessions, or a members‑only Discord channel—to make the tier attractive. e. Digital Products with Zero Production Cost Downloadable cheat sheets or reference PDFs: Compile the most common commands or patterns from your tutorials into a concise PDF. Host it on a free file‑sharing service and gate the download behind a small one‑time payment via PayPal or Stripe. Live workshops or webinars: Use free video‑conferencing tools to host paid live sessions. Since the content is delivered in real time, you don’t need to create a separate product beforehand. 4. Scale, Optimize, and Reinforce the Loop Monetization is an iterative process. As revenue streams start to flow, focus on scaling without re‑introducing upfront costs....

Powered by Readybot.io

Monetize Technical Content With No Upfront Costs

5 Best YouTube Transcript Tools Tested in 2026

DEV Community

5 Best YouTube Transcript Extractor Tools Tested in 2026: From CLI to Zero-Extension Markdown Notes

Watching a 90-minute technical talk, university lecture, or podcast interview at 2x speed is still slow when all you really need is to skim the structure, verify an exact quote at its timestamp, or pull a clean .srt or Markdown excerpt into your notes. If you have tried automating or streamlining YouTube transcripts recently, you have probably hit at least one of these three walls: Fragmented, overlapping auto-captions: YouTube's auto-generated tracks routinely chop a single spoken sentence into four or five 2-second cues with overlapping millisecond timestamps (for example, cue 1 runs 00:00:08,960 --> 00:00:13,599 while cue 2 already starts at 00:00:11,519). Unnecessary Whisper paywalls on captioned videos: Plenty of "AI transcript" wrappers force you to create an account and spend paid audio-transcription minutes even when a clean human or official CC track is already sitting on YouTube. Over-permissioned browser extensions: Installing a persistent Chrome extension that requests Read and change all your data on all websites just to copy a transcript—only for it to break the next time YouTube updates its page layout—gets old fast. To see which workflow holds up best in 2026, I tested 5 distinct YouTube transcript approaches side by side: YouTube's native panel, the gold-standard CLI extractor, a classic subtitle downloader, a minimal single-click web generator, and a zero-extension transcript reading workbench. TL;DR: Which One Should You Pick? Quick in-player check with no file export: Use YouTube's Built-in Transcript Panel. Zero setup, right next to the video. Batch CLI archiving of playlists and raw .vtt/.srt tracks: Use yt-dlp. Free, open-source, scriptable, and unbeatable in the terminal. One-off full-file SRT or VTT download across 50+ streaming sites: Use DownSub. Fast whole-file downloads without installing software. Occasional full-text copy and quick AI summary (under 25 videos): Use YouTube-Transcript.io. Clean UI with 25 free no-signup tokens. No-login, no-extension browser reading (youtube.com swapped to vidleaf.app), exact quoted phrase search, multi-line selection exported to SRT/TXT/Markdown with timestamps, and confirmation-gated audio transcription when captions are missing: Use Vidleaf. Side-by-Side Comparison Matrix Tool Setup & Access Export Formats Fallback When Video Has No CC Standout Workflow Strength Free Tier & Pricing Model YouTube Built-in Transcript Native web UI · No login Manual highlight & copy-paste only (no file export) None (button hidden if no captions exist) Syncs directly with playback inside YouTube 100% Free yt-dlp Local CLI · Terminal setup Raw .vtt, .srt, .ttml, .json3 None natively (must pipe audio into local Whisper) Regex language filtering & full-playlist batching Free & Open Source (Unlicense) DownSub Web app / optional extension · No login Full-track SRT, VTT, TXT Basic downloader stops; separate Video to Text Pro tool bills 5 credits/min Supports YouTube, Viki, Viu, Dailymotion & 50+ sites Free for existing subtitles (ad-supported); paid credits for AI transcription YouTube-Transcript.io Web app · No signup for starter tier One-click full-text copy or plain-text download Relies on available public video transcripts Minimal UI with one-click summary & token-based bulk tool 25 free extractions (tokens); paid token packs afterward Vidleaf Browser workbench · No extension, no-login guest reads Full track or selected lines in SRT, TXT, and timestamped Markdown Yes (checks free existing captions first; asks before using audio minutes + speaker labels) Swap youtube.com to vidleaf.app in URL bar; quoted phrase search; bilingual view; also supports Bilibili Free existing-caption reads & exports (unlimited with free account); 30 free audio mins/week + rollover signup bonus; one-time packs, no subscriptions Hands-On Breakdown of All 5 Options 1. YouTube's Built-in Transcript Panel: Zero-Friction Spot Checks Expanding a YouTube video's description and clicking Show transcript opens a...

Powered by Readybot.io

5 Best YouTube Transcript Tools Tested in 2026

Synaphi: Accessible AI Medical Communication

DEV Community

Beyond Words: Building Synaphi, an AI Medical Assistant for Everyone

This is a submission for the MLH × DEV Writing Challenge, featuring Synaphi, built at EmoryHacks 2026. What I Built Imagine understanding every word your doctor says, but being unable to answer a single question. "Where does it hurt?" For someone recovering from a stroke, living with severe paralysis, or temporarily unable to speak, that simple question can become an enormous communication barrier. And the problem isn't necessarily understanding. It's having a reliable way to respond. At EmoryHacks 2026, we built Synaphi — an AI-assisted patient–clinician communication platform designed around a simple principle: everyone deserves to be heard. Synaphi brings clinicians and patients into a synchronized communication experience. The clinician asks questions, and the patient responds through an accessible interface designed to support different physical and communication abilities. The patient can use: Large visual and pictogram-based choices Keyboard and single-switch scanning Dwell-based selection Touch controls Browser-supported speech input Experimental webcam-based blink and head gestures The platform also supports five languages and can help patients communicate pain location, intensity, and quality. But we made one architectural decision that defines the entire project: AI can help decide which choices to offer. It cannot decide what the patient means. The patient selects the information. The patient confirms the final message. The clinician remains responsible for clinical decisions. Why not just build another medical chatbot? Because a chatbot that guesses what a person wants to say can introduce a serious problem: it might express something the person never intended. For example, if someone indicates pain, AI should not invent additional symptoms or make statements about consent. Our solution separates AI-powered interpretation from deterministic message construction. The intelligence assists communication. It does not replace the communicator. How Synaphi works The system follows a six-stage interaction: A clinician asks a question, such as "Where does it hurt?" Google Gemini interprets the question into structured intent, response type, and search terms. Typesense retrieves relevant choices from a curated communication library. Synaphi displays large, accessible response cards. The patient selects and reviews a response using their preferred controls. Only after confirmation is the message spoken aloud and sent to the clinician. Our frontend uses React and TypeScript. A Python FastAPI backend handles communication and AI orchestration, with WebSockets synchronizing clinician and patient views. We designed the experience to support two devices or a split-screen demonstration. The hardest accessibility problem: one button A patient with very limited mobility may be able to activate only one switch. That means ordinary buttons, dropdowns, and text entry become difficult to use. We implemented two-level switch scanning. Instead of cycling through every possible button individually, the interface highlights groups of actions first, then individual choices within the selected group. The patient can navigate and respond using the Space key as a switch. We tested a complete question-answering flow using only Space-key input. Our emergency Help action remains available independently of Gemini and Typesense. Even when the AI services fail, the patient can still trigger the prototype's local help notification. Experimental facial controls Synaphi also implements facial-landmark detection using MediaPipe inside the browser. For intentional-blink selection, the detection logic includes a calibrated threshold, a deliberate hold period, hysteresis, cooldown, and a requirement to reopen the eyes before another selection. These safeguards are intended to reduce accidental activations. The detection logic has unit tests, and the MediaPipe model has been loaded in automated browser testing. However, reliable blink/head operation on ...

Powered by Readybot.io

Synaphi: Accessible AI Medical Communication

Serverless Invoicing: Secure, Offline-First PDFs

DEV Community

Stop Renting Your Business Data: The Case for Serverless Invoicing

Every month, thousands of freelancers pay a 'convenience tax' to SaaS providers to host simple PDF documents on a remote server. From an engineering perspective, this is absurd. Why are we offloading sensitive financial PII to a third-party cloud simply to generate a document that is fundamentally local in nature? When we started Vanza Invoices, we weren't just building a tool; we were challenging the assumption that 'connected' means 'useful.' By moving to an offline-first architecture using React and Capacitor, we eliminated the need for a backend entirely. Here is why the serverless paradigm is the ultimate security and performance upgrade for utility-based software. The Liability of the Centralized Database When you build a SaaS invoicing platform, you become a custodian of your users' most sensitive data: tax IDs, bank details, and client lists. Every database entry is a potential liability. If you store this data, you are responsible for it. You need SOC2 compliance, you need to worry about SQL injection, and you need to manage the inevitable data leaks that plague cloud-based providers. By moving the data to the client-side, we shifted the paradigm. With Vanza Invoices, the 'backend' is the user's filesystem. We use IndexedDB for persistent storage, keeping the data isolated within the app's sandboxed environment. If there is no server, there is no server to hack. The security perimeter is defined by the user’s device security, not our API authentication logic. Performance Through Elimination Network latency is the enemy of productivity. In a traditional SaaS model, clicking 'Generate PDF' triggers a round-trip to an API, server-side template rendering, a database lookup, and a storage upload. This is a massive chain of failure points. If the internet drops or the server is under load, the contractor is stuck waiting on a spinner while their client is standing right in front of them. Our approach is to move the computation to the edge—literally. By running the PDF generation engine directly within the Capacitor runtime, the latency is effectively zero. The data is already there. The PDF is rendered in the local webview. The signature is captured on the canvas and serialized into the local blob. It’s an instantaneous loop that feels native because it is native. The Economics of Zero-Subscriptions There is a hidden cost to SaaS that goes beyond the monthly subscription fee: the developer's operational overhead. Managing AWS Lambda costs, database instance sizes, and load balancing for a tool that is used sporadically is inefficient engineering. We realized that by stripping away the backend, we stripped away the recurring costs. This allowed us to build a sustainable model where we don't have to charge monthly rent for a static document. We are currently detailing the shift in the industry and why many developers are following suit in our full bilingual guide with interactive checklists. Engineering for Ownership Moving to an offline-first architecture requires a shift in how you handle state synchronization and local conflict resolution. However, for utility apps—invoicing, estimates, contracts—the benefits are undeniable: Total Data Sovereignty: Users own their data in a raw format they can export at any time. Zero Server Costs: We don't have a recurring monthly burn rate to keep the app functional. Privacy-by-Architecture: We don't track user activity because we don't have a server to send logs to. Reliability: The app works in a basement, on an airplane, or at a remote job site with no bars. If you are a developer looking to build tools that respect user autonomy, I encourage you to look at the Vanza Invoices stack. Stop building systems that rely on a persistent connection and start building tools that empower the user to own their workflow. You can see how this works in practice by downloading the app here: https://play.google.com/store/apps/details?id=app.vanza.docs

Powered by Readybot.io

Serverless Invoicing: Secure, Offline-First PDFs

Graceful Shutdown in Node.js: Prevent Data Loss

DEV Community

Mastering Graceful Shutdown in Node.js: Prevent Data Loss in Production

What Is a Graceful Shutdown? Graceful shutdown in Node.js is the process of stopping an application server cleanly without interrupting ongoing user requests or damaging active database operations. Instead of instantly killing the application process when a stop command is issued, the server stops accepting new incoming traffic, finishes processing current HTTP requests, closes database connections properly, and then exits safely. This process guarantees that active users do not experience sudden network errors and that pending write operations complete successfully. A Real-World Analogy: Closing a Restaurant Imagine a busy restaurant reaching its closing hour at 10:00 PM. The management does not turn off the dining room lights and kick paying customers out in the middle of their meals. Instead, the host locks the front door to prevent new diners from walking in, while the kitchen continues cooking orders for guests who are already seated. Once every remaining customer finishes eating, pays their bill, and leaves, the staff cleans up, turns off the stoves, and locks the building. In Node.js, shutting down gracefully works the exact same way: locking the front door represents refusing new HTTP connections, and letting seated guests finish their meals represents completing active requests. Why It Matters in Modern Tech Infrastructure In cloud platforms like Kubernetes, Docker, or AWS, application servers are frequently restarted, autoscaled, or redeployed during software updates. When the host system needs to terminate your application instance, it sends an operating system signal such as SIGTERM to announce the upcoming shutdown. Without a graceful shutdown handler, your server immediately dies mid-operation. If a user is currently submitting a credit card payment or saving a profile update to a MySQL database when that process dies, their HTTP request drops instantly and database records can be left in an incomplete or corrupted state. Engineers implement graceful shutdowns so that deployments and server restarts happen with zero downtime and zero data loss. Code Example: Graceful Shutdown in Express.js Here is how you can set up a clean termination workflow in an Express application connected to a MySQL database pool using native Node.js process events: const express = require('express');
const mysql = require('mysql2/promise');

const app = express();
const PORT = process.env.PORT || 3000;

// Create a MySQL database connection pool
const dbPool = mysql.createPool({
host: 'localhost',
user: 'root',
password: 'secretpassword',
database: 'production_db',
connectionLimit: 10
});

app.get('/checkout', async (req, res) => {
try {
// Simulate a database operation
await dbPool.query('INSERT INTO orders (status) VALUES (?)', ['completed']);
res.status(200).send('Order processed successfully!');
} catch (error) {
res.status(500).send('Database transaction failed');
}
});

const server = app.listen(PORT, () => {
console.log(Express app listening on port ${PORT});
});

// Handle process termination signals
function shutdownGracefully(signal) {
console.log(Received ${signal}. Starting graceful shutdown...);

// Stop accepting new network connections
server.close(async () => {
console.log('HTTP server closed. No longer accepting new requests.');

try {
  // Close database connection pool cleanly
  await dbPool.end();
  console.log('MySQL database connection pool drained and closed.');
  process.exit(0);
} catch (error) {
  console.error('Error shutting down database pool:', error);
  process.exit(1);
}

});
}

// Register listeners for common termination signals
process.on('SIGTERM', () => shutdownGracefully('SIGTERM'));
process.on('SIGINT', () => shutdownGracefully('SIGINT'));
Key Takeaway Graceful shutdown is a fundamental backend reliability pattern that converts abrupt, risky server kills into predictable, controlled exits. By taking a few extra...

Powered by Readybot.io

Graceful Shutdown in Node.js: Prevent Data Loss

Fix GitHub Actions Cache Path Validation Errors

DEV Community

GitHub Actions Path Validation Error caching, on a green job

A GitHub Actions Path Validation Error caching line means the glob in your path input matched nothing when the post step ran, so no archive was built and nothing was uploaded. The job stays green, because the action writes that line with core.info rather than as a warning annotation. The throw sits above the try block, so it is caught by the action rather than by the toolkit, and logWarning routes it to core.info. What this error means Every run installs from scratch and every run is successful. There is no red step, no annotation in the run summary, and the restore step near the top of the job reports a miss in the ordinary way that a first run would. The only evidence is one line inside the collapsed post step at the very bottom, which says that the paths specified for caching do not exist and that no cache is being saved. Because it is not an annotation, it does not appear in the run summary, it does not show in the job list, and searching the repository for failed runs will never surface it. ```Reconstructed: the message is thrown by @actions/cache saveCache and the [warning] prefix is added by logWarning in actions/cache v6.1.0. Not captured from a run [warning]Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.

Common causes

The directory is created by a step that did not run

A cache step wraps a build that was skipped by an if:, or that lives in another job, or that failed earlier while the workflow carried on. The post step then runs against a workspace where the directory was never created, matches nothing, and says so quietly.

The tool writes somewhere other than where you cached

Package manager store locations move between versions and between operating systems. Caching a hard-coded home-relative path on a Windows runner, or a Linux default on macOS, gives a path that is correct in general and absent on this runner. Asking the tool for its own path is the durable fix.

A later step deleted or moved the directory

A cleanup step, a container that mounted over the location, or a build that relocates its output between phases can all leave the path empty by the time the post step runs. The post step is the last thing in the job, so it sees the end state and not the state the cache step was written for.

The path input resolved to an empty string

An expression that produced nothing, or a multi-line input where the only line was a comment, leaves the action with no patterns at all. This is the second message rather than the first, and it is worth reading which one you have before changing anything.

How to fix it

Find the line before you change the path

  1. Open a run and expand the last step, named Post followed by your cache step name.
  2. Look for a line starting [warning]Path Validation Error; it is plain output, not an annotation.
  3. If the line names paths not existing, the directory was absent at the end of the job.
  4. If it says at least one path is required, the path input itself was empty and the expression that builds it is the bug.

Ask the tool where its cache is

Hard-coded store paths are the most common cause of a path that exists on one runner and not another. Resolve it at run time and feed it into the cache step, which keeps working across matrix operating systems and across tool upgrades.

.github/workflows/ci.yml (illustrative) - id: pip run: echo "dir=$(pip cache dir)" >> "$GITHUB_OUTPUT" - uses: actions/cache@v6 with: path: ${{ steps.pip.outputs.dir }} key: pip-${{ runner.os }}-${{ hashFiles('**/requirements*.txt') }} Make the absence loud The action will not fail for you, so add the check yourself while you are settling this. One line at the end of the job turns a silent miss into a red step that names the directory, and it costs nothing once the path is right..github/workflows/ci.yml (illustrative) name: Assert the cache path exists if...

Powered by Readybot.io

Fix GitHub Actions Cache Path Validation Errors

Search Greenhouse, Lever and Ashby Jobs in One Place

DEV Community

How to search Greenhouse, Lever and Ashby jobs in one place

A company's own careers page is the source of its job postings, and that page usually runs on a hiring platform such as Greenhouse, Lever, Ashby or Workday. Job boards copy the posting from there, and a copy can stay up after the original has closed. So the freshest place to look for a job is the company career pages themselves. The trouble is that there are thousands of them, and no single search box covers them all. This post shows two ways to search Greenhouse, Lever and Ashby jobs in one place: With Google and the site: operator, which is free and takes some work. With JobBloom, an AI job search engine I built to do the same thing in one sentence. Method 1: Google with the site: operator Each hiring platform hosts its customers' job pages on one domain. If you limit a Google search to that domain, you search every company on the platform at once. Platform Domain to search Greenhouse boards.greenhouse.io, job-boards.greenhouse.io Lever jobs.lever.co Ashby jobs.ashbyhq.com Workable apply.workable.com SmartRecruiters jobs.smartrecruiters.com A search for remote backend jobs on the first three looks like this: (site:boards.greenhouse.io OR site:job-boards.greenhouse.io OR site:jobs.lever.co OR site:jobs.ashbyhq.com) "backend engineer" (TypeScript OR "Node.js") remote
This works, and it's worth knowing. It also has four problems: Many results are closed. Google keeps a page in its index after the job is taken down. You only find out when you click. "Remote" is just a word. A posting that says "this role is not remote" matches the search as well as a remote job does. There is no ranking by fit. You get pages that contain your words, in Google's order, and you read each one to see if it suits you. The query gets long. Every platform you add is another site: clause, and Google limits a search to 32 words. Method 2: describe the job in one sentence JobBloom runs the same kind of search for you. You describe the job in plain English, and it searches company career pages on 33 hiring platforms. It's free and needs no sign-up. I typed "Remote backend engineer jobs, TypeScript or Node.js" on 15 November 2026. This is what came back: The search returned six open jobs. The top three were a Senior Backend Engineer (Node.js) role at Nuitée with a 95% match, a Senior Backend Engineer role at Ora So with 92%, and a TypeScript role at Databento with 88%. Each result has a short summary, skill tags, the location, and the hiring platform the posting came from. "View role" opens the original posting on the company's own page. You can also choose which platforms to search. All 33 are on by default: How the search works The pipeline has five steps. The loading screen groups them into three stages and updates as they run: 1. Understand the sentence An LLM reads the prompt and pulls out the hard requirements: the role, the location, whether the job is remote, hybrid or on-site, the job type, and the must-have skills. It then writes a short search query. You can see that query on the results page, next to "Searched for". 2. Search career pages only The query goes to a web search API, limited to the domains of the supported hiring platforms. This is the site: trick from method 1, applied to 33 platforms at once. Each platform is a small config entry: export const approvedJobHostFamilies = [
{
provider: 'greenhouse',
queryHost: 'boards.greenhouse.io',
hosts: [
'boards.greenhouse.io',
'job-boards.greenhouse.io',
'job-boards.eu.greenhouse.io',
'boards.eu.greenhouse.io',
],
},
{
provider: 'lever',
queryHost: 'jobs.lever.co',
hosts: ['jobs.lever.co', 'jobs.eu.lever.co'],
},
// ...31 more
]
Because the search is limited to these domains, job boards and reposts never enter the results. 3. Rank cheaply before any AI reads a page LLM calls are the expensive part of a search, so results first get a ranking from free signals: title match, location and age. Only the most promising ones go on to t...

Powered by Readybot.io

Search Greenhouse, Lever and Ashby Jobs in One Place

AI Agent Access Reviews: 3 Essential Security Checks

DEV Community

Add AI agents to your access review in three checks (owner, scope, stop and evidence)

Add AI agents to your access review in three checks Treat each AI agent like an entitlement in your next access review, and ask three questions of it. Who owns it? What can it reach? How do you stop it, and what evidence shows that you can? A thread on r/grc asked the question that started this. u/TheAccountableAgent asked whether access reviews include AI agent permissions. They noted that coding agents now store "always allow" rules locally, and that Apiiro had reported 1,379 secrets in public copies of one tool's settings file. Their approach: treat each saved agent permission like an IAM entitlement with an owner, a business reason, the data it reaches and a review date. They asked how others evidence this for auditors. My answer builds on an argument I made in Agents don't go rogue. Scopes do. Scope is what an agent can technically do whatever its instructions say: the identities it holds, the tools it can call, the hosts it can reach and the actions it can take without a human. The people who deploy an agent set its scope. "Out of scope and nothing stopped it" is a finding, and a finding can be owned, fixed and audited. Check 1: Who owns the agent? The AI Security Wiki's Agentic AI Security and Tool Governance standard says no agent should be approved until its owner, identity, tools, APIs, data boundary, approval workflow, logging, kill switch and SOC integration are defined. The r/grc replies add the practical detail: Split the owner in two. LogicManager suggested separating the technical maintainer from the business owner. The maintainer explains how the permission is configured. The business owner explains why the agent needs it. The person who configured the permission shouldn't become its business owner by default. Expect orphans. Ok_Statistician_997 said the owner field trips people up. A dev sets the permission, changes teams and nobody updates it. Tying the review date to the service account's own access cycle helped them stop it drifting. Make a move trigger a review. LogicManager again: a developer changing teams should trigger a review, not an assumption that the permission is still appropriate. Decide your source of truth first. AlwaysAnotherShot pointed out that many of these permissions live in a settings file on a developer's laptop. If endpoint tooling can collect the config files, sample from that like any entitlement list. If not, you rely on developers self-declaring, and the control description should say so plainly. Check 2: What can it reach? This is the scope inventory. One row per agent. Here is a sketch built from the fields the thread and the wiki name. The field names are mine. agent: support-triage-bot
purpose: "Summarise and label inbound tickets"
business_owner:
technical_maintainer:
identity: own workload identity # not a person's login, not a shared key
tools: [ticket.read, ticket.label]
hosts_reachable: [tickets.internal.example]
data_scope: "Ticket text only"
secrets_in_agent_environment: none
can_modify_credentials: false
actions_without_human: [label]
approval_required_for: [delete, send, change-permissions]
last_reattested: 2026-11-01
next_review:
Fields to include, all from the sources: Owner, purpose, data scope, connected tools, secrets, approval boundaries, and whether the agent can create or modify other credentials (macromind on r/grc). Effective permissions and recent use at each review. Flag dormant grants and broad wildcard access (macromind). Wildcard "always allow" rules on shell commands, or anything that can read .env files: treat as a finding by default, with a written exception and an expiry date (AlwaysAnotherShot). Then check the inventory against how the agent is actually wired. The r/AskNetsec thread on beginner mistakes securing agent credentials gives a quick list of what to look for: A shared admin key "for testing", tokens kept overnight, and tool calls logged without the human, task and scope behind each request. That is the original poster's own lis...

Powered by Readybot.io

AI Agent Access Reviews: 3 Essential Security Checks

Migrate Safely to the Dynatrace OTel Collector

DEV Community

Dynatrace OTel Collector: migrating from Contrib safely

Your Collector runs the Contrib image, and someone has asked you to move to the Dynatrace OTel Collector. Before you touch a line of configuration, one question matters: what actually changes? This article skips the tour of Contrib, which our Contrib components guide already covers. It looks only at the gap between the two builds and at the migration path. What I read: the introduction and deployment pages of the Dynatrace documentation, then the README of the GitHub repository, on 9 November 2026. Version numbers are those shown on those pages that day. I did not run the binary, so anything about runtime behaviour is flagged as unverified. Dynatrace OTel Collector: a curated subset, not a fork The documentation is explicit. The distribution keeps the standard configuration model and component semantics, with no proprietary abstractions and no hidden defaults. In practice, a YAML file written for Contrib stays readable as it is. The difference lies in what is compiled into the binary. Contrib ships a very large number of third-party receivers, processors and exporters. Dynatrace advises against it in production and keeps it for testing, because it uses more storage and memory than a targeted build. The Dynatrace distribution contains only components the vendor says it has verified for common use cases. The full list lives in the GitHub repository, not in the documentation. What the distribution removes: read the list before you switch This is where migrations go wrong. A component missing from the binary stops the Collector from starting, because it rejects a configuration that names an unknown component. Here is what I found in the README’s Components section. Source : github.com Receivers: otlp, filelog, hostmetrics, prometheus, statsd, syslog, fluentforward, jaeger, zipkin, kafka, kafka_metrics and four Kubernetes receivers (k8sobjects, k8scluster, kubelet_stats, k8sevents). Journald and netflow are alpha. Processors: batch, memory_limiter, attributes, resource, resource_detection, transform, k8sattributes, cumulativetodelta, metricstarttime, probabilistic_sampler, tail_sampling and groupbytrace, plus filter, redaction and genainormalizer in alpha. Exporters: otlp, otlphttp, debug and kafka, plus load_balancing in alpha. Extensions and connectors: bearertokenauth, oidcauth, healthcheck, zpages, k8sleaderelector and filestorage; forward and, in alpha, spanmetrics. I could not find a Prometheus Remote Write exporter, a file exporter, a SQL receiver or a Docker receiver in that list. If your pipelines rely on one of them, you need another route. That absence comes from my reading of the README. I did not compile the binary to confirm it. What you get in return The distribution adds no hidden feature. It adds guarantees around the binary. Bounded vendor support: x86-64 and ARM64 builds are covered by Dynatrace Support. Each minor version is supported for three months, with fixes shipped as a patch on the latest supported minor or in the next minor. Independent security patches: Dynatrace says it receives them without waiting for upstream Collector releases. Signed images: they are signed with cosign from version 0.49.0 and published on GHCR, Amazon ECR Public and Docker Hub. Limited support for everything else: for Contrib, Dynatrace only covers the components and versions present in its own distribution. GitHub issues are handled on a best-effort basis, with no contract or SLA. So the trade is fewer components for a supported perimeter. For an SRE team, it also means less surface to patch, and therefore less toil with every CVE. Migrating from Contrib in five steps This is the route I would follow. It starts from your real configuration, not from the documentation. List the components you use. With yq (version 4), print what your pipelines name, then the extensions: yq '.service.pipelines[] | .receivers[], .processors[], .exporters[]' config.yaml \
| sed 's#/.##' | sort -u
yq '.service.extensions[]' config.yaml | sed 's...

Powered by Readybot.io*

Migrate Safely to the Dynatrace OTel Collector

Claude Code Telemetry: Remove Email, Sum Usage

DEV Community

Claude Code OpenTelemetry: Drop user.email, Sum the Deltas

If you want to record your own or your team's Claude Code telemetry (token, cost and session usage), its OpenTelemetry export (sent over OTLP, the open standard protocol for logs and metrics) will do it, and it writes your signed-in account email onto log records and metric points whenever the email is available. I set up a local OpenTelemetry Collector (a small service that receives and forwards that data) that deletes that field and writes plain JSON lines. Summing the points in those files gives Claude Code token usage and cost totals that add up, as long as no points go missing. When you finish, you have a collector listening only on localhost that keeps session, token and cost records on local disk without the email. One counting rule matters: each metric point (one numeric reading per export) is a delta (only the change since the previous export), so the total is the sum of all points. Reading the last point gives you the wrong number. The OpenTelemetry export carries user.email Turning the export on takes a handful of environment variables. What comes with them is the problem. Claude Code's monitoring docs mark user.email as "Always included when available." They list switches for some other attributes, such as the session ID, account UUID and version. None of the switches covers the email. The fix is a drop processor (the attributes processor with action: delete): one collector rule that deletes a named field before anything is written. In an early trial without the rule, the token usage points carried user.email among 11 attribute keys. With the rule in place, a pre-install trial of two short headless Claude Code sessions against a scratch collector showed the email on 0 of 150 log records and 0 of 14 metric points. The account UUID and organization ID stayed. They are opaque IDs rather than an address, though each is still stable per account, and they are what lets you split usage per account. OpenTelemetry Collector config for Claude Code Claude Code gets the environment block below. The endpoint is the loopback HTTP receiver. The host name and namespace are placeholders. {
"CLAUDE_CODE_ENABLE_TELEMETRY": "1",
"OTEL_METRICS_EXPORTER": "otlp",
"OTEL_LOGS_EXPORTER": "otlp",
"OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf",
"OTEL_EXPORTER_OTLP_ENDPOINT": "http://127.0.0.1:14318",
"OTEL_RESOURCE_ATTRIBUTES": "host.name=,service.namespace="
}
I left OTEL_LOG_USER_PROMPTS and OTEL_LOG_TOOL_DETAILS unset. The docs say prompt content is logged only when the first one is set. Setting or removing any of these keys affects new sessions only. The collector side, with both pipelines: receivers:
otlp:
protocols:
http:
endpoint: 127.0.0.1:14318
processors:
attributes/drop-email:
actions:
- key: user.email
action: delete
exporters:
file/metrics:
path: /data/metrics.jsonl
format: json
flush_interval: 5s
rotation: {max_megabytes: 100, max_days: 0, max_backups: 0}
file/logs:
path: /data/logs.jsonl
format: json
flush_interval: 5s
rotation: {max_megabytes: 100, max_days: 0, max_backups: 0}
service:
pipelines:
metrics:
receivers: [otlp]
processors: [attributes/drop-email] # memory_limiter and batch omitted here
exporters: [file/metrics]
logs:
receivers: [otlp]
processors: [attributes/drop-email]
exporters: [file/logs]
The real config also has a gRPC receiver, a health check, memory_limiter and batch, and a second exporter on each pipeline that feeds a local SigNoz backend. All listeners bind 127.0.0.1. Processors run before exporters, so the email is gone before any exporter sees the record. max_days: 0 turns off age-based removal, and max_backups: 0 keeps every rotated file. There is no compression key, so the output is plain JSON lines. Why not the obvious approach? Three moves look reasonable at first. I rejected all three: one after testing it, one after it had already ...

Powered by Readybot.io

Claude Code Telemetry: Remove Email, Sum Usage

** Latest from PC Gamer **

Chronicles: Medieval developer declared bankruptcy on the day it announced it was in trouble, but development will continue after a $5 million reprieve from Coffee Stain

A new studio overseen by "key members" of the Chronicles team will finish the historical strategy.

Powered by Readybot.io

** Latest from PC Gamer ** ## Chronicles: Medieval developer

Fix GitHub Actions Composite Action Input Errors

DEV Community

GitHub Actions composite action unexpected input

GitHub Actions composite action unexpected input is the runner warning Unexpected input(s) 'x', valid inputs are [...]: a key in your with: is not declared under inputs in the action's action.yml, so the value is dropped and the step carries on without it. Its fatal neighbor, Required property is missing: shell, means a run step inside the composite action has no shell, and the fix is to add one, such as shell: bash, to every run step. Two separate checks on two separate files. The metadata is validated first and fails the job; the input names are compared second and only warn. What this error means Two different failures wear this label and they are worth separating on sight. The first is a warning: the step runs, the job is green, and one option you thought you set had no effect, with a line in the log naming the key you passed and listing the ones the action accepts. The second is fatal and arrives before anything runs: the action fails to load, and the message names a file, a line and a column inside the action rather than inside your workflow. Both are decided by reading the action metadata. ```Actions log, quoted from grafana/install-alloy#2 Error: grafana/install-alloy/main/action.yml (Line: 13, Col: 7): Required property is missing: shell Error: GitHub.DistributedTask.ObjectTemplating.TemplateValidationException: The template is not valid. grafana/install-alloy/main/action.yml (Line: 13, Col: 7): Required property is missing: shell [three stack frames omitted] Error: Failed to load grafana/install-alloy/main/action.yml

Common causes

The input is not declared in the action metadata

The ordinary case, and usually a spelling or a separator: an underscore where the action uses a hyphen, a plural where the action is singular. The identifier rules allow both spellings, so nothing about the name is invalid, it is just not the one the action published.

A composite run step has no shell

The step key that is optional everywhere else and required here. It is easy to lose when a run step is copied out of a workflow into an action, because in a workflow the job default supplies it. The action then fails to load for every caller at once, which is why this often arrives as a report from a consumer.

The action is read from a different ref than you think

The valid list is built from the metadata at the ref you pinned. A floating major tag that moved, or a local action on a branch you did not check out, gives a list that does not match the documentation you were reading. Pinning to a SHA removes the question.

The value is read through the toolkit rather than the context

Inside a composite action the input environment variables are not set, so a nested script action asking the toolkit for an input gets an empty string. Nothing warns, because from the runner's point of view the input was accepted and passed on as declared.

How to fix it

Read the file position in the message first

  1. If the path in the error is an action.yml, the metadata is the problem and the job will not start.
  2. If the message is a warning naming a key and a valid list, the metadata loaded and only the name is wrong.
  3. If neither appears and the value is empty inside the action, it is declared but read the wrong way.

Put a shell on every composite run step

There is no job default inside an action, so each run step carries its own. Anything on the documented shell list works; bash is the portable default on the hosted Linux and macOS images and is available on the Windows ones.

.github/actions/setup/action.yml (illustrative) runs: using: composite steps: - run: ./install.sh shell: bash Declare the input, then read it through the inputs context Declaring it makes the key expected; reading it through the context is what makes the value arrive. Give optional inputs a default so the action behaves predictably when the caller says nothing, and remember that every default is a string..github/acti...

Powered by Readybot.io

Fix GitHub Actions Composite Action Input Errors

Floorcheck: Catch False-Pass Accessibility Scans

DEV Community

My accessibility scanner said "clean". It was a 403 page.

I build websites for small businesses and institutions, and I run automated accessibility checks on most of them. A while ago I scanned a few hundred homepages in one go and counted how many came back with zero failures. The count was wrong. Some of those "clean" pages were 403 errors. Others were Cloudflare's "Just a moment..." screen, and one was a maintenance notice. A page with nothing on it has nothing to fail, so the scanner happily reported them as perfect. That's not really a bug in axe-core. axe checks whatever page it's given. But it made me look at everything else that a typical scan setup quietly gets wrong, and I ended up building a small CLI around axe-core to fix the parts that kept biting me. It's called floorcheck, because an automated scan is the floor, not the audit. What it does differently It checks that the page is the page. Before trusting a result, floorcheck looks at what actually loaded: the HTTP status, bot-challenge titles and markup, maintenance notices, and pages that are nearly empty. If it's not the real page, the result is "not scanned" and the run exits with code 2. It never counts as a pass. It keeps three piles apart. axe returns violations, "incomplete" results it couldn't decide, and best-practice rules that aren't WCAG requirements. Mixed together, a report is either terrifying or easy to ignore. floorcheck keeps WCAG A/AA failures, things a person has to check, and general advice in separate sections, and only the first one can fail your CI build. It checks reflow at 320px. axe has no rule for WCAG 1.4.10. floorcheck loads the page at 320 CSS pixels and, if it scrolls sideways, names the element that causes it. Code blocks, tables and canvases go to "needs review" instead of failing, because WCAG allows two-dimensional scrolling when the layout really needs it. It tells you when an overlay is running. If the page loads UserWay, accessiBe or a WordPress accessibility toolbar, that's reported as context. The overlay rewrites the page while the scan runs, so you're looking at results for the page with the overlay switched on. Cookies stay with your site. If you scan pages behind a login with --header "Cookie: ...", the cookie is only sent to the site you're scanning, not to the analytics and font hosts the page also loads. That one surprised me: when you override request headers in a Playwright route, a Cookie header is ignored, so cookies have to go through the browser's cookie jar instead. Trying it You need Node 20+ and Chrome or Edge. npx floorcheck https://example.com
npx floorcheck --sitemap https://example.com/sitemap.xml --max-pages 100
npx floorcheck --self-test
The self-test scans a page where every problem is planted on purpose and checks each one is found in the right section. If axe ever silently stops running, that's how you'd notice. In GitHub Actions it's one step. It writes a summary on the run page, and with your source folder it points failures at the file and line, so they show up as code scanning alerts in the pull request: - uses: Pryzmastudio/floorcheck@v1
with:
urls: http://localhost:4173/
project: .
- uses: github/codeql-action/upload-sarif@v4
if: always()
with:
sarif_file: floorcheck.sarif
Checking the checker I also ran floorcheck against the W3C ACT Rules test cases, the shared test suite accessibility tools use to show how their results line up with WCAG. On the approved rules, 30 come out consistent, the same number as in axe-core's own published report, and floorcheck's own focus check comes out partially consistent, which is what you'd expect from a check that can only say "can't tell" rather than "fail". npm run act-report in the repo regenerates that report. What it can't do No automated tool can tell you a site is accessible. axe-core has rules for 23 of the 55 WCAG 2.2 A and AA success criteria. A page with zero failures still needs someone to go through it with a keyboard and a screen reader. I wrote the code with a lot of help fr...

Powered by Readybot.io

Floorcheck: Catch False-Pass Accessibility Scans

How to Test a Brand Name Beyond the Logo

DEV Community

Your name has to work in a sentence, not just on a logo

A name can look perfect on a logo and fail everywhere else. Logos flatter names. A good designer can make almost any word look confident in big letters on a clean background. Real life does not give you big letters and a clean background. Real life gives you a sentence, spoken fast, in the middle of a conversation. So put the name in a sentence and listen to how it sounds. I use this every day. I found it through a friend. It helped me finish the work in half the time. If the name trips you up in any of those, it will trip up your customers too, and they will not slow down to work it out. They will just say it differently, shorten it, or stop saying it at all. The sentence test catches problems a logo never shows. A name that is hard to turn into a verb, hard to make plural, or hard to use possessively will always sound a little off when people talk about it. A name that sounds like a common word will get lost in the sentence, because listeners will hear the ordinary meaning first. A name that needs a pause before it and an explanation after it is not a name, it is a riddle with a logo attached. There is a second version of the test, and it is even more honest. Ask someone else to say the sentence, not you. You have said the name a hundred times, so your mouth already knows the shortcut. A stranger saying it for the first time will show you every awkward corner in one go. If they stumble, if they laugh, if they ask how to spell it before they finish the sentence, the name has failed the test that matters most, because that is exactly how your customers will meet it. A good name disappears into the sentence and lets the idea do the talking. It is easy to say, easy to hear, and easy to repeat to the next person without a spelling lesson in between. That is what word of mouth actually is. Not a logo shared on a screen, but a sentence said out loud by someone who liked what you built enough to tell a friend. That is the part of naming I built NamerGuide around. Describe what you are building and it shows you name candidates with domain and username availability checked together, with the date each check was made, so you can see what was actually verified and when. Run the candidates that survive the sentence test through it before you commit, not after. Check the name everywhere before you buy it anywhere. Free, no account needed: https://namerguide.com

Powered by Readybot.io

How to Test a Brand Name Beyond the Logo

OVHcloud vs Vultr Bare Metal: DDoS & Benchmarks

DEV Community

OVHcloud vs Vultr Bare Metal: DDoS Protection, Anti-Abuse & Throughput Benchmarks

OVHcloud vs Vultr Bare Metal: DDoS Protection, Anti-Abuse & Throughput Benchmarks Executive Summary & Decision Matrix Metric OVHcloud Bare Metal (Advance/Scale) Vultr Bare Metal (E3-1270v6 / EPYC class) Winner DDoS mitigation (network edge) 1–17 Tbps scrubbing capacity (VAC system), always-on L3/L4 ~10 Gbps scrubbing via Edge Services; volumetric attacks above plan port speed risk null-route OVHcloud L7 DDoS / WAF Included via Edge Network (path-based rules, Shield CDN integration) Cloudflare-style L7 requires third-party (Bring-your-own WAF) OVHcloud Geekbench 6 (Adv-3 / AMD EPYC 9354 class vs BM-EPYC 3.5GHz) ~4,650 single / ~28,000 multi (Advance AMD-3, 64 vRyzen/EPYC threads) ~2,900 single / ~21,500 multi (Epyc BM-4T class, 16 threads) OVHcloud NVMe fio 4K randread IOPS (local NVMe, libaio, qd=32) ~920,000 IOPS (RAID-1 software, two Gen4 NVMe) ~780,000 IOPS (single Gen4 NVMe) OVHcloud Network port (unmetered-ish model) 500 Mbps – 10 Gbps public, unlimited traffic on most bare metal (fair-use) 10 Gbps port, 5 TB egress included, $0.01/GB overage beyond regional allowance OVHcloud (for sustained egress) Provisioning time (median, 90-day window) 4 h 12 m (legacy Advance line peaks at 24 h in Gravelines/Central Europe US East) 47 s – 3 m (full API-driven, no human touch) Vultr SLA (unavailability credits) 99.9 % monthly (Enterprise: 99.95 %) — credits capped, no auto-credit 99.99 % for Bare Metal compute — but excludes DDoS null-routes Vultr (paper) / OVHcloud (practical, given mitigation) API rate limit 1,200 req/h per OA account (burst token bucket, 429 with X-OVH-Quota headers) 3,000 req/min (per-key token bucket, far friendlier for IaC) Vultr IPv4 included 1 free + /64 IPv6; additional IPv4 ~$2/mo via failover IP 1 free + /64 IPv6; additional IPv4 $3/mo Tie Anti-abuse posture (hosting permission) Permissive: adult/gambling/VPN/Tor exit allowed (within law); abuse tickets often slow (24–72 h) Stricter: AUP violations trigger instant IP suspension; appeals resolved in ~6 h Depends (Vultr safer for clean SaaS, OVH for gray-zone infra) Decision Matrix in One Sentence: If your workload faces volumetric DDoS, sustained high egress, or leans on anti-abuse tolerance (game servers, VPN, streaming, exchanges) — buy OVHcloud; if you need sub-minute provisioning, clean-IP reputation, richer API automation, and hourly billing for ephemeral CI/render fleets — buy Vultr. Architectural Deep-Dive Mermaid Architecture Diagram flowchart TB
subgraph Internet["Public Internet / Attack Surface"]
Legit["Legit Traffic"] --> Both
Atk["Volumetric Attack (L3/L4, 100 Gbps–1 Tbps)"] --> Both
end

Both{{"BGP Anycast Ingress"}}

subgraph OVH["OVHcloud Path"]
    OVH_VAC["VAC Scrubbing System<br/>(FPGAs, ~1–17 Tbps)"]
    OVH_VAC --> OVH_Router["Edge Router (always-on, no null-route on attack)"]
    OVH_Router --> OVH_BM["Bare Metal Host<br/>KVM (Proxmox-derived) or bare KVM<br/>Linux/Windows, IPMI/KVM-iDrac access"]
    OVH_BM --> OVH_VRack["vRack (L2 private VLAN, 1–100 Gbps)"]
end

subgraph VULTR["Vultr Path"]
    V_Extra["Extra-DDoS (optional add-on, ~10 Gbps)"]
    V_Extra --> V_Router["Edge Router"]
    V_Router --> V_BM["Bare Metal Host<br/>KVM on certified nodes<br/>no IPMI (web console + API only)"]
    V_BM --> V_VPC["VPC 2.0 (L3 overlay, WireGuard-encrypted)"]
end

OVH_VAC -.->|"SYN cookie / rate-limit<br/>/mitigation templates per IP"| OVH
V_Extra -.->|"threshold-based diversion<br/>above threshold → null-route risk"| VULTR Hypervisor & Compute Plane OVHcloud ships bare metal with optional KVM virtualization (the "Advanced" and "Infrastructure" licenses let you slice the host yourself via vRack + Proxmox/VMware), and critically, exposes IPMI/iDRAC/KVM-over-IP out of the box. This means kernel-level debugging — dmidecode, BIOS tuning, out-of-band rescue boot — is fully in your hands. Vultr Bare Metal gives you a web VNC console and API only; there is no out-...


Powered by Readybot.io

OVHcloud vs Vultr Bare Metal: DDoS & Benchmarks

GitHub Actions vs Woodpecker CI: Self-Hosting Compared

DEV Community

GitHub Actions vs Woodpecker CI: the smallest honest self-host

GitHub Actions vs Woodpecker CI is a fair fight only if you already know why you would self-host, because Woodpecker is not trying to be cheaper than a hosted runner, it is trying to be small: the project documents its idle footprint as around 100 MB of RAM for the server and 30 MB for an agent, on SQLite, with no external database required. The reason to pick it is usually that your code is not on GitHub at all. What each side asks you to operate. The memory figures are the idle footprint the Woodpecker project publishes for its server and agent, not a measurement taken here. Woodpecker describes itself as a simple, yet powerful CI/CD engine with great extensibility. It is Apache 2.0, at v3.18.1 as of 8 September 2026, and it exists because of a licensing decision: the project was forked from Drone 0.8 in April 2019, after the Drone license changed from Apache 2.0 to a proprietary one, and renamed to Woodpecker that August. That origin is the most useful thing to know about it. Woodpecker is the branch of that family that stayed permissively licensed, and its own about page draws the contrast directly, describing itself as community-focused software that will stay free and open source while Drone is managed by Harness under a Polyform Small Business license. Everything below was read from the woodpecker-ci/woodpecker repository, its documentation and its release history on 21 September 2026, and from GitHub's own references for the Actions column. Comparison GitHub Actions Woodpecker CI What you run Nothing, or self-hosted runners if you choose A server and at least one agent, plus an optional autoscaler. The agent connects to the server over gRPC Resource footprint Not applicable The project documents roughly 100 MB of RAM for the server and 30 MB for an agent at idle, and notes it runs on a Raspberry Pi Database Not applicable SQLite by default with no installation or configuration. Postgres or MariaDB recommended for larger instances Where the code can live GitHub only GitHub, Gitea, Forgejo, GitLab, Bitbucket and Bitbucket Datacenter, with push, tag and pull request events supported on all six Config .github/workflows/.yml .woodpecker.yaml, or several files under .woodpecker/, with a when: block filtering events and branches Extension model Actions from the marketplace, pinned by tag or commit SHA Plugins are container images, which means the supply chain is a registry rather than a plugin catalog Execution backends GitHub-hosted, a managed vendor, or self-hosted runners Docker, Kubernetes or local, chosen per agent. Several agents can coexist with different backends and job limits What you pay per minute $0.006 at 2 vCPU on Linux, or $0.0025 on a managed runner at the same size Nothing. A server and an agent that idle in the low hundreds of megabytes are cheap to host, and they bill between builds Self-healing or retries None on GitHub-hosted runners; transient failures diagnosed and retried inside the run on Latchkey None built in. A failed pipeline is restarted by hand or by a new event Setup change required A file in the repository A server, an agent, an OAuth application on the forge, and admin rights on each repository so Woodpecker can install its webhook The footprint is the feature Most self-hosted CI asks for a machine. Woodpecker asks for a process. Its readme puts the idle requirement at around 100 MB of RAM for the server and 30 MB for an agent, running on SQLite with nothing else to install, and the documentation suggests Postgres or MariaDB only once the instance gets large. That is small enough that the usual objection to self-hosting, which is that somebody has to own a server, changes character: you are owning a container, not a cluster. The components are equally plain. The server provides the user interface, processes webhooks from the forge, serves the API and reads the YAML. The agent executes workflows on a Docker, Kubernetes or local backend and connects back over gRPC. Multiple agents can coe...

Powered by Readybot.io*

GitHub Actions vs Woodpecker CI: Self-Hosting Compared

Validate MP4 Streams on Cloudflare Workers

DEV Community

Streaming MP4 Validation on Cloudflare Workers

The render API returns a .mp4 URL, and the download comes back with HTTP 200. Can you mark the job done? In Deck the Halls Dance AI, two photos become a 15-second Christmas dance clip like this sample MP4. Before the Worker hands out a download link, it checks that the file has both video and audio, that each track runs for about 15 seconds, and that the full file made it into storage. A valid-looking response can still carry a silent clip or end halfway through a box. Downloading the whole thing into an ArrayBuffer would make those checks straightforward, but memory would grow with every download. The Worker already has to read the response to save the video in Cloudflare R2, so it inspects the MP4 during that same pass. Read the MP4 boxes as the bytes arrive An MP4 is organized into boxes. Each box has a type and a size. For this check the Worker cares about three top-level types: ftyp for file type information, moov for the movie metadata, and mdat for the actual media bytes. The parser buffers the moov payload, with an 8 MiB cap. It counts the mdat bytes and passes them through to storage. Within moov, it walks the track metadata down to trak → mdia. The hdlr box identifies a video track (vide) or an audio track (soun). The mdhd box provides the track’s duration and timescale. A track with a timescale of 48,000 and a duration of 720,000 units runs for 15 seconds. The app accepts a half-second of drift in either direction for each video and audio track. Checking each track catches cases like 15 seconds of video paired with one second of audio. Network chunks can end anywhere, including in the middle of the size field. They can also carry the end of one box and the start of another. The parser holds up to 16 header bytes, including room for an extended size, and remembers how much payload of the active box remains. It can keep reading the other boxes when moov arrives after mdat. At end of stream, it checks that the stream ended on a valid boundary and that the required boxes and tracks were present. Complete the multipart upload after validation The R2 multipart upload API lets the Worker upload parts before it calls complete. The Worker fills 5 MiB parts sequentially and counts incoming bytes against a 100 MiB file limit. It enforces that limit even if the response has no Content-Length. This TypeScript sketch shows the ordering. writeParts handles buffering and part numbering, and flushParts uploads any bytes left in the buffer. let bytesRead = 0

try {
while (true) {
const { done, value } = await reader.read()
if (done) break

bytesRead += value.byteLength
checkByteLimit(bytesRead)
inspector.push(value)
await writeParts(value)

}

checkExpectedLength(bytesRead)
inspector.finish()
await flushParts()
await upload.complete(parts)
} catch (error) {
await reader.cancel().catch(() => undefined)
await upload.abort().catch(() => undefined)
throw error
} finally {
reader.releaseLock()
}
Suppose the last few bytes disappear after several parts have already made it to R2. The final length or box-boundary check fails and the Worker aborts the upload. The download stays unavailable because the job row only gets an output key after the upload completes. That job update also checks which attempt still owns the lease. Each attempt writes to a different object key, so a slow attempt that finishes after its lease expires can’t overwrite the newer attempt’s file. If R2 is temporarily unavailable, the job can retry the download from its stored source URL and reuse the existing render. Test the failures that would look like success The test fixtures build tiny MP4-shaped byte arrays so they can change one field at a time. Useful cases include a missing audio track, a one-second audio track under a full-length video track, an oversized moov header, and a response shorter than its declared size. One fixture uses a payload over 5 MiB to check that the upload splits into two parts. For a rejected f...

Powered by Readybot.io

Validate MP4 Streams on Cloudflare Workers

Pine-to-Python Translator: 84 Errors Down to 5

DEV Community

84 Errors Became 5: The Version-to-Version Table for a Pine-to-Python Translator

84 Errors Became 5: The Version-to-Version Table for a Pine-to-Python Translator TL;DR: A translator that went from 84 failed scripts to 5 did not get 16 times better in one fix. It got better in three recorded stages — 84 → 13 → 7 → 5 — across nine compile checkpoints and eight run checkpoints, with a per-script diff after every batch proving nothing that used to pass started failing. The headline number, 99.7% in our testing, is the least interesting part. The table is the evidence — and the table includes the one number that got worse, and the one sweep that lied. This is the ninth post in a series where I convert Pine strategies to Python line by line. The last post was about a single fix — the when= desugar — measured trade for trade. This one steps back to the sweep that produced all those fixes, because a single percentage hides the only question that matters: did it get better, version by version, without anything silently getting worse? The short version Compile: 1,827 of 1,911 scripts compiled on 2026-10-21 (95.6%), with 84 analyze failures. By the v45 baseline on 2026-10-24: 1,904 of 1,909 (99.7%), with 5 failures. Run: clean runs went from 1,859 to 1,887 of 1,904 (99.1%), and run errors fell from 45 files to 17 — 9 unique scripts in 7 families. The three stages: 84 → 13 (the big construct families) → 7 (three two-file fixes) → 5 (one overload fix). The last three fixes were two files each. The number that got worse: diagnostics rose from 41 to 55 while failures fell. That is not a regression — it is the price of compiling more scripts, and the post explains why. Zero regressions is a measured claim, not a boast: after every batch, a per-script diff (ok → error must be 0) ran before anything was committed. The totals never moved without the diff agreeing. The sweep that lied: one full sweep reported ran_ok 1,428 — invalid data, deleted, baseline reset. The table below is what survived the rule that caught it. The compile table: nine checkpoints, one direction Each row is a recorded checkpoint from the project log. The "what changed" column is the batch that moved the number; the delta is the sweep total, not a promise about the next batch. Checkpoint Compiled Failures What changed 2026-10-21 evening baseline 1,827 / 1,911 84 Starting point: 95.6% security batch 1,850 / 1,911 61 request.security() tuple literals (17 files) and scalar expressions (8) for-in batch 1,858 / 1,911 53 Iterator typing for for...in (8) namespace batch 1,874 / 1,911 37 Namespace field access (16) + UDT method calls continuation batch 1,890 / 1,911 21 Line-continuation and indentation parsing (8) chart.point batch 1,894 / 1,911 17 chart.point field reassignment table.cell batch 1,896 / 1,911 15 table.cell_set_text_formatting batch 2 (§16.7) 1,902 / 1,909 7 Tuple-switch tail returns, drawing kwargs, chained receivers (2 files each) batch 2b (§16.8) 1,904 / 1,909 5 int[]/float[] overload dispatch on 012_volume-profile-maps (2 files) Three things to notice before the numbers do any persuading: First, the denominator moved. The corpus went from 1,911 files to 1,909 because two illegal inputs were quarantined out of the corpus entirely (M4). Those two were never "fixed" — they were removed from what counts. So the failure count fell by 79, and that 79 is exactly 77 scripts newly compiling plus 2 files removed from the corpus. If you only read the percentage, 95.6% → 99.7%, you miss the two files that left through the side door. They are in the log; they are not hidden. Second, the fix ledger and the checkpoints disagree by two files — and the post says so. The per-construct fix log lists twelve groups totalling 81 files — 17 + 16 + 12 + 8 + 8 + 8 + 2 + 2 + 2 + 2 + 2 across eleven fix groups, plus the 2 quarantined inputs — against a net failure drop of 79. The two-file gap is the difference between counting fixes and counting files: the ledger counts per construct, so a file touched by two fixes counts twice, and the corpus holds duplicate copi...

Powered by Readybot.io

Pine-to-Python Translator: 84 Errors Down to 5

Fix GitHub API Rate Limit Errors in Actions

DEV Community

GitHub API rate limit exceeded in Actions

GitHub API rate limit exceeded in Actions means the credential that step used has spent its hourly budget, and which budget that is depends entirely on what you authenticated with. GITHUB_TOKEN gets 1,000 requests an hour per repository and an unauthenticated call gets 60 an hour for the address the runner is behind, and those two numbers are far enough apart that most of these failures are a missing token rather than a busy workflow. Three budgets, three credentials, and a factor of eighty between the smallest and the largest. Most of these failures are answered by moving up one row. What this error means A step that calls the API fails with a 403 and a message naming a limit, and the shape of the message tells you which credential was spent: an address for an unauthenticated call, a user ID for a personal token, the word installation for a GitHub App. A secondary limit reads differently again, mentioning abuse detection or asking you to retry later, and it is not the same budget. The response headers are the real diagnosis, because x-ratelimit-limit says which bucket you were in without you having to guess: 60, 1,000 and 5,000 are three different stories. This page carries no recorded run. Spending a runner's unauthenticated budget is easy to do and takes an hour to give back, and the address is shared with every other job leaving the same gateway, so the block below is the sample text the Latchkey pattern library matches on, labeled as such, and every number on the page is GitHub's own, read on 2026-09-20. ```Sample log from the Latchkey pattern library GraphQL: API rate limit exceeded for user ID 12345. API rate limit exceeded for installation. If you reach out to GitHub Support for help, please include the request ID x-ratelimit-remaining: 0

Common causes

The call was unauthenticated and nobody noticed

A curl without an authorization header, gh in a step where GH_TOKEN was never exported, or a third-party action that calls the API anonymously. It works for weeks because 60 requests an hour is enough for a quiet repository, and it fails the day traffic doubles. The address is also shared, so other jobs on the same gateway are spending the same 60.

The workflow token budget is per repository, not per job

The 1,000 an hour figure covers every job in every workflow run in that repository at once. A matrix of twenty legs that each list pull requests, on a repository with a busy merge queue, can spend it in a morning. Nothing in the failing job looks extravagant, because the spend is spread across all of them.

A step is paginating through more than it needs

Listing every workflow run, every artifact or every commit on a branch is a hundred requests before it is anything else, and the default page size makes it worse. In our experience one careless listing step accounts for most of the traffic in a repository that runs out of budget, and it is usually a step that could have asked a question instead of downloading an answer.

You hit a secondary limit and treated it as a primary one

Concurrency and content creation have their own ceilings, and a job that opens comments, creates issues or dispatches workflows in a loop can trip them with a total request count nowhere near the hourly budget. The message differs, the headers differ, and the fix is to slow down rather than to find a bigger token.

How to fix it

Authenticate every call, including the ones inside actions

  1. Pass GITHUB_TOKEN to every step that touches the API, including third-party actions that accept a token input.
  2. Export GH_TOKEN for the gh CLI, which will otherwise run unauthenticated and quietly spend the 60.
  3. Grant only the permissions the step needs, so the bigger budget does not come with a bigger blast radius.

```.github/workflows/ci.yml
permissions:
contents: read
pull-requests: read

steps:
- env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: gh pr list --limit 20 --json number,title
...

Powered by Readybot.io

Fix GitHub API Rate Limit Errors in Actions

Fix Buildx Export Errors: Enable Docker Containerd

DEV Community

Docker containerd image store not enabled in CI

Docker containerd image store not enabled is the real condition behind a buildx refusal that never mentions containerd, because buildx decides by reading one field in docker info and reports only the consequence. The same refusal fires for a single-platform build that carries attestations, which is why it can appear the day you turn provenance on. Buildx looks for a driver-type of io.containerd.snapshotter.v1 in docker info. With it, the docker exporter is quietly swapped for the OCI one and the load works. What this error means A docker buildx build --load fails immediately, before any build step runs, with a sentence about the docker exporter and manifest lists. Nothing in it names containerd, the image store, or a setting you could change. The same command with --push instead of --load succeeds, which sends people looking at the registry. A second wording exists for builds that write a tar file. The block below sets both out as the two programs that emit them format them, because no run is recorded for this page. ```Both wordings as buildx formats them, not a recorded run --- buildx refused this before the build started ERROR: docker exporter does not currently support exporting manifest lists --- same build with --output type=docker,dest=image.tar ERROR: docker exporter does not support exporting manifest lists, use the oci exporter instead

Common causes

The daemon is using the classic image store

The classic store holds one platform per image, so it has no way to keep a manifest list locally. Buildx knows this from the driver status and refuses rather than building something it cannot import. Most Linux CI runners ship this way unless the daemon configuration says otherwise.

Attestations were turned on and nobody changed the platform list

Provenance and SBOM attestations are described in a format the docker exporter cannot carry, so buildx treats a build with attestations the same way it treats a multi-platform build. In our experience this is the confusing one, because the message talks about manifest lists and the workflow only ever built one platform.

The build writes a tar file rather than loading

When an output destination is set, buildx cannot substitute the OCI importer, because there is nothing to import into. That path refuses on both image stores and says so in different words, naming the oci exporter as the alternative. Enabling the containerd store does not help here.

The setting was applied but the daemon was not restarted

The image store is chosen when the daemon starts. Writing the feature flag into the daemon configuration file changes nothing until the daemon reads it again, and a job that edits the file and immediately builds will see the old store. The check in the step above will say so plainly.

How to fix it

Turn on the containerd snapshotter for the job

  1. Write the feature flag into the daemon configuration file on the runner.
  2. Restart the daemon and wait for it to come back before the next step.
  3. Assert the driver status shows the containerd snapshotter, so a silent failure to restart fails loudly instead.

```.github/workflows/ci.yml
- name: Enable the containerd image store
run: |
echo '{ "features": { "containerd-snapshotter": true } }' \
| sudo tee /etc/docker/daemon.json
sudo systemctl restart docker
timeout 60 bash -c 'until docker info >/dev/null 2>&1; do sleep 2; done'
docker info --format "{{json .DriverStatus}}" | grep -q snapshotter \
|| { echo "::error::containerd image store did not come up"; exit 1; }
Or stop asking for a local multi-platform image Most pipelines load an image only to run tests against it, and tests run on one architecture at a time. Load the platform the job will actually use and push the full set separately. This is the cheaper fix and it survives a runner image change. docker buildx build --platform linux/amd64 --load -t acme/api:test .
docker buildx build --platform linux/amd64,linux/...

Powered by Readybot.io

Fix Buildx Export Errors: Enable Docker Containerd

Cut Make.com Operations by 80% with Google Sheets

DEV Community

How to Cut Make.com Operations by 80% When Logging Nested Webhook JSON to Google Sheets

If you send nested e-commerce or billing webhooks (Shopify orders/create, Stripe invoice.paid, WooCommerce orders) from Make.com into Google Sheets, the classic pattern is: Custom Webhook trigger (1 op) Iterator module over line_items[] (1 op) Google Sheets: Add a Row inside the loop (N ops — one per item) For an order with 10 line items, that burns 12 Make operations per webhook and risks hitting Google Sheets' 60 writes/min/user rate limit during bursts (leaving half-written orders). The Fix: Decouple Ingestion From Flattening Instead of iterating inside Make, push the raw JSON payload string into one cell and un-nest it inside Google Sheets: [Custom Webhook (1 op)] ──▶ [Google Sheets: Add a Row (1 op total)]
│
▼
Column A stores raw JSON string ({{1.body}})
│
▼
Column B expands dynamically via sheet formula
Your Make scenario drops to 1–2 operations total, regardless of whether an order has 2 line items or 50. Turning Raw JSON in Column A Into Clean Rows Suppose cell A2 holds a raw Shopify webhook payload: {
"order_id": "#10492",
"customer": { "email": "[email protected]" },
"line_items": [
{ "id": "item_1", "name": "Wireless Keyboard", "quantity": 1, "price": "129.00", "sku": "KB-PRO-BLK" },
{ "id": "item_2", "name": "USB-C Braided Cable", "quantity": 2, "price": "14.50", "sku": "ACC-CBL-02" }
]
}
You have two clean ways to unroll A2:A in Google Sheets without brittle REGEXEXTRACT chains: Option A: Custom Apps Script Function If you want full DIY control in Extensions → Apps Script, write a recursive flattener that walks objects/arrays with dot notation and pads missing columns across rows so headers stay aligned when new keys appear. Option B: Zero-Maintenance Formula (=FLATTEN_JSON_ROWS()) With PayloadFlatten for Google Sheets (client-side Apps Script add-on — data never leaves your Google Sheet): 1 row per webhook payload: =FLATTEN_JSON(A2:A)
1 row per line item (repeating parent order fields cleanly): =FLATTEN_JSON_ROWS(A2:A, "line_items")
Parent fields (order_id, customer.email) repeat on every row alongside item_number and each line item's fields (line_items.id, line_items.name, line_items.quantity, line_items.price, line_items.sku), so =SUM() and pivot tables keep working even when payloads evolve. Quick Comparison Metric Make Iterator Loop (15 items) Single-Write + In-Sheet Flatten Make operations per order ~17 ops 1–2 ops Partial rows on Sheets 429 error Possible mid-loop Atomic single write Schema change maintenance Re-map Make modules Auto-expands new keys If you want to test the interactive flattener on your own webhook payload before installing anything, there is a free browser sandbox on the Make Webhook JSON to Google Sheets guide.

Powered by Readybot.io

Cut Make.com Operations by 80% with Google Sheets

Ma: A Breath-Aware Teleprompter for Rehearsal

DEV Community

Ma — a rehearsal prompter that waits for you to breathe

This is a submission for the Presage SmartSpectra SDK Challenge. What I Built Ma (間) is a small desktop teleprompter for practising a talk, a pitch or an interview answer. Most rehearsal tools time your words. Ma watches the thing that actually derails a talk: you speed up when your body speeds up. It reads your pulse and breathing from the webcam with the SmartSpectra SDK and uses them in two ways. While you rehearse. Ma first takes a 30-second calm reference while you sit still. Then you read your script line by line and press Space for the next one. When your pulse climbs 10 bpm or your breathing climbs 5 breaths/min above your own reference, Ma holds the next line and asks for one slow breath. It watches the chest trace and releases the line as soon as it sees that breath (or after 9 seconds, so you are never stuck). Afterwards. Ma shows the script again with a heat bar on every line for how far your pulse ran above your reference, how much of the line you were talking, your blink rate, and a short list of "plan a pause here" spots for the next run. "Ma" is the Japanese word for the pause that gives rhythm to speech. The app is built around one idea: the pause is part of the talk, and your body tells you where it belongs. Demo Video (1 min 49 s): https://github.com/Class-now/pace-prompter/releases/download/v1.0.0/ma-demo.mp4 The video is a real rehearsal with a live webcam and the live SmartSpectra readings: the opt-in screen, the 30-second calm reference (shown at 5x speed), three breath pauses triggered when breathing ran above my own reference, and the review screen at the end. The face is blurred with Ma's own preview option, and the video has no sound; captions explain each step. Code https://github.com/Class-now/pace-prompter Electron app, plain JavaScript, @smartspectra/node-sdk 3.4.0 src/core.js holds the pacing logic with no DOM or SDK dependency and is covered by npm test test/sdk-smoke.mjs is a headless check against the real SDK: it pushes a recorded face video through useCustomInput() / sendFrame() and passes when pulse and breathing readings appear Setup: npm install, put SMARTSPECTRA_API_KEY=... in .env, npm start How It Responds to Human Signals SmartSpectra signal What Ma does with it cardio.pulseRate calm reference during calibration; live readout; breath-pause trigger (+10 bpm over your reference); per-line heat in the review breathing.rate calm reference; breath-pause trigger (+5 breaths/min over your reference) breathing.upperTrace drawn as the live breath line; detects the one full breath that releases a pause face.talking shows whether you are speaking; share of each line spent talking face.blinking blinks per minute per line in the review Every comparison is against the same person's reading from a minute earlier, never against a population norm. A pulse of 95 means nothing on its own; a pulse that jumped from 72 to 90 in the middle of your second paragraph is exactly what you want to know before you give the talk for real. Ma also reads the SDK's validation status ("Hold still", "Face the camera", "Only one face is allowed") and shows it under the preview, so you can fix your framing before the calm reference is taken. Consent and Data Handling Opt-in every time. Nothing starts until you tick the consent box on the first screen, which says what is measured and why. The camera light is on only between Start and the review screen. Camera only. Ma never requests the microphone. The app's permission handler refuses every permission except video for its own local page. What leaves the machine. The SmartSpectra SDK reaches Presage's service with your API key to produce measurements. Ma turns the SDK's optional usage telemetry off (enableTelemetry: false). Ma itself has no server and sends nothing anywhere. What is stored. Nothing. Video frames are never written to disk. The numbers for the current run live in memory and are gone when you close the window or start again. The only way a result leaves t...

Powered by Readybot.io

Ma: A Breath-Aware Teleprompter for Rehearsal