enterprise-infrastructure

Scale Kailash infrastructure from SQLite to shared-database and multi-worker deployments.

Updated Apr 2, 2026
One-click install
npx skills add https://github.com/myeohVmzrka92/disease-risk-controller-S2 --skill enterprise-infrastructure-myeohvmzrka92
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: enterprise-infrastructure
Source: https://github.com/myeohVmzrka92/disease-risk-controller-S2/tree/main/.claude/skills/15-enterprise-infrastructure
Command: npx skills add https://github.com/myeohVmzrka92/disease-risk-controller-S2 --skill enterprise-infrastructure-myeohvmzrka92

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill removes the complexity of building and operating Kailash infrastructure across single-process, shared-database, and multi-worker deployments by giving you one consistent way to scale without rewriting workflow code.

Core Features & Use Cases

  • Progressive infrastructure scaling: Move from Level 0 SQLite to Level 1 shared database storage and Level 2 multi-worker execution using environment variables alone.
  • Dialect-portable SQL and connection management: Write one canonical SQL style that works across PostgreSQL, MySQL, and SQLite while safely handling pools, transactions, and placeholder translation.
  • Reliability patterns: Implement task queues, worker heartbeats, idempotent execution, schema versioning, and shared store factories for production-ready orchestration.
  • Use case: A team can start with local development on SQLite, switch to PostgreSQL for shared persistence, and later enable Redis or SQL-backed workers without changing application logic.

Quick Start

Ask for the enterprise infrastructure skill to help you scale a Kailash project from local SQLite to a shared database and multi-worker queue while preserving the same workflow code.

Frequently Asked Questions about enterprise-infrastructure

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

FAQPage Schema
How do I scale infrastructure from SQLite to a shared database without rewriting workflow code?

You can scale infrastructure from single-process SQLite to a shared database by using environment variables and store factories, allowing multi-worker deployment without changing application logic. This progressive scaling preserves your existing workflow code.

How does dialect-portable SQL handle placeholder translation across PostgreSQL, MySQL, and SQLite?

Dialect-portable SQL lets you write one canonical SQL style that works across PostgreSQL, MySQL, and SQLite by safely handling connection pools, transactions, and placeholder translation. This ensures database portability without query rewrites.

What is the best way to implement idempotent execution and worker heartbeats for task queues?

The best way to implement idempotent execution and worker heartbeats is through reliability patterns like task queues, worker registry, and heartbeat recovery. This guarantees exactly-once execution requirements for production-ready orchestration.

Does this infrastructure scaling approach support schema versioning for shared database storage?

Yes, infrastructure scaling supports schema versioning for shared database storage alongside store factories and transaction safety. This ensures operational workflow scenarios maintain data integrity during multi-worker execution.

Can I use environment variables alone to switch from local development SQLite to PostgreSQL for shared persistence?

Yes, you can use environment variables alone to switch from local development SQLite to PostgreSQL for shared persistence and later enable Redis or SQL-backed workers. This progressive scaling requires no code changes to your application logic.

Why does multi-worker deployment require a worker registry and heartbeat recovery for transaction safety?

Multi-worker deployment requires a worker registry and heartbeat recovery to ensure transaction safety and exactly-once execution. These reliability patterns prevent duplicate processing and recover failed workers in shared-database orchestration scenarios.