twelve-factor-processes

Audit Twelve-Factor Apps for stateless processes and local state persistence.

1|Updated Apr 4, 2026
One-click install
npx skills add https://github.com/niboj/agent-skills-12-factor-app --skill twelve-factor-processes
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: twelve-factor-processes
Source: https://github.com/niboj/agent-skills-12-factor-app/tree/main/skills/twelve-factor-processes
Command: npx skills add https://github.com/niboj/agent-skills-12-factor-app --skill twelve-factor-processes

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps teams ensure applications run as stateless processes, delegating persistence to external services and avoiding in-process state that can break scalability.

Core Features & Use Cases

  • Audit and verify that no durable in-memory state is stored locally or on disk.
  • Detect sticky sessions and improper local filesystem usage that violate the Stateless Processes principle.
  • Guidance for migration to external datastores and services to improve scalability and resilience.
  • Documentation support for architecture reviews and Twelve-Factor compliance.

Quick Start

Review the application's process model and generate a stateless design remediation plan.

Frequently Asked Questions about twelve-factor-processes

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

FAQPage Schema
How do I audit my application for stateless process compliance?

To audit stateless processes, review the application's process model to detect local state persistence, sticky sessions, and improper filesystem usage, then generate a remediation plan to migrate durable data to external datastores.

What are sticky sessions and how do they violate stateless architecture?

Sticky sessions bind user requests to specific processes using in-memory state, violating stateless architecture by preventing horizontal scalability and requiring migration to external shared datastores for session persistence.

How do I migrate local filesystem state to external datastores?

Migrate local filesystem state to external datastores by identifying improper disk usage within your processes, extracting that durable data, and delegating persistence to external services to ensure scalable, non-shared processes.

When do I need stateless processes for my application architecture?

Stateless processes are needed when applications require horizontal scalability and resilience, ensuring that any process can be replaced or scaled without losing critical in-memory or local filesystem state during architecture reviews.

How do I document Twelve-Factor compliance for architecture reviews?

Document Twelve-Factor compliance by auditing the application process model, verifying no durable state is stored locally or in-memory, and recording the migration steps taken to delegate persistence to external services.

Why does storing state on the local filesystem break scalability?

Storing state on the local filesystem breaks scalability because subsequent requests may route to different processes that lack access to that data, requiring external datastores to maintain consistent shared state across non-shared processes.