concurrency-engine

Coordinate FastAPI, Redis, and browser pools to execute 100+ concurrent automation tasks.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/nguynbon03/API-XuongMedia-Backup --skill concurrency-engine
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: concurrency-engine
Source: https://github.com/nguynbon03/API-XuongMedia-Backup/tree/main/.claude/skills/concurrency-engine
Command: npx skills add https://github.com/nguynbon03/API-XuongMedia-Backup --skill concurrency-engine

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Browser automation tasks are slow when executed sequentially. This Skill coordinates a FastAPI gateway, Redis-backed queue, and a pool of pre-authenticated browser instances to process 100+ requests concurrently, dramatically reducing latency.

Core Features & Use Cases

  • Browser Pool + Async Queue + Workers to run tasks in parallel rather than one-by-one.
  • Non-blocking request handling: clients receive a job_id immediately while processing happens in the background.
  • Redis-backed job store and status tracking for reliable polling and resumption after restarts.
  • Scales with number of accounts/workers; ideal for high-throughput automation and batch processing.
  • Health checks and graceful shutdown to recover from browser crashes and maintain uptime.

Quick Start

Start by configuring FastAPI to enqueue jobs and run a worker pool to process them in parallel.

Frequently Asked Questions about concurrency-engine

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I parallelize Playwright browser automation tasks in FastAPI?

To handle 100+ concurrent browser automation requests, a FastAPI gateway enqueues jobs into a Redis-backed queue and immediately returns a job_id. Background workers then pull from the queue and execute tasks using a managed pool of parallel browser contexts.

Why does my FastAPI endpoint block when running heavy browser automation tasks?

Heavy browser automation blocks FastAPI endpoints when processing happens synchronously. By implementing non-blocking request handling with a Redis-backed queue, the server returns a job_id immediately and processes the task in the background, allowing clients to poll for status.

How does a Redis queue manage browser pool workers for concurrent web scraping?

A Redis-backed queue manages browser pool workers by storing job metadata and dispatching tasks to available pre-authenticated browser instances. This worker pattern enables parallel execution, reliable status tracking, and resumption of concurrent web scraping tasks after restarts.

Can I use a browser pool to run 100+ concurrent Playwright requests without blocking?

Yes, you can run 100+ concurrent Playwright requests without blocking by coordinating a FastAPI gateway with a Redis-backed queue and a browser pool. The gateway returns a job_id immediately while dedicated workers process the batch workload in parallel.

What are the limitations of using a worker pattern for parallel browser automation?

Limitations of a worker pattern for parallel browser automation include managing browser crashes and resource limits. Health checks and graceful shutdown mechanisms are required to recover from failures and maintain uptime when scaling to high-throughput batch workloads.