Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide

SEO Metadata

SEO Title Options

1. Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda
2. Deploying PHP Apps to AWS: EC2, ECS: Practical 2026 Guide
3. Tooling Playbook: Deploying PHP Apps to AWS: EC2, ECS

Meta Description Options

1. Learn Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide with a practical Tooling framework, expert mistakes, implementation steps, examples.
2. Compares deployment approaches for PHP on AWS - from traditional EC2 to containerized Fargate and serverless Bref Lambda functions.

URL Slug

deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide

Focus Keyword

Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide

Additional LSI Keywords

• Tooling
• PHP
• AWS
• EC2
• ECS Fargate
• Lambda
• Bref
• Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide
• production checklist
• implementation guide
• best practices
• architecture decisions

Table of Contents

• Article overview
• What Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide means
• Why it matters now
• Implementation framework
• Practical comparison
• Expert workflow
• Common mistakes
• Media and link plan
• Original technical deep dive
• FAQ
• Structured data
• Conclusion

Article overview

Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide is the kind of topic that looks simple until it reaches production. Teams usually discover the real cost late: unclear boundaries, weak defaults, hidden maintenance work, and decisions that seemed harmless when the codebase was small.

The problem gets worse when the article, tutorial, or implementation guide only explains the happy path. This guide closes that gap with a practical framework, a comparison table, common mistakes, and a deep technical section you can use while planning real work.

Keep reading for the non-obvious part: the safest implementation is rarely the most impressive-looking one. It is the one your team can debug, test, document, and evolve without turning every future change into archaeology.

Key Takeaways

• Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide should be evaluated as a production decision, not only as a syntax or tooling choice.
• The best implementation keeps responsibilities visible, with clear ownership, tests, documentation, and rollback paths.
• Search visibility improves when practical depth, structured answers, and expert examples live on the same page.

[IMAGE: A mobile-first technical article layout showing the main concept, decision table, implementation checklist, and FAQ blocks. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide expert guide for Tooling]

What Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide means

Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide means applying tooling knowledge to a concrete engineering decision, then turning that decision into reliable code, documentation, and operational behavior. In practice, it combines the topic's core concepts with trade-off analysis, implementation boundaries, testing strategy, and maintenance discipline.

This is the definition worth optimizing for featured snippets because it avoids hype. It tells the reader what the topic does and what a professional implementation must include.

Why it matters now

The technical web is more crowded than it was a few years ago. Thin tutorials can still get indexed, but they rarely earn trust from senior developers, buyers, AI answer systems, or teams that need production guidance.

For tooling topics, the strongest content now has three layers:

• a clear answer for fast scanning
• a practical framework for implementation
• expert context that explains what breaks later

That same structure helps search engines understand the page. It also helps readers decide whether the advice fits their project.

Implementation framework

Use this framework before adopting the approach described in this article.

1. Define the user problem and the production risk.
2. Identify the smallest reliable implementation boundary.
3. Keep configuration, secrets, and environment-specific behavior outside the article's core logic.
4. Add tests for the behavior that would hurt if it regressed.
5. Document the trade-off, not only the final code.
6. Measure the result with logs, metrics, or user-facing outcomes.
7. Revisit the decision after real usage exposes edge cases.

The sequence is deliberately conservative. It keeps the work grounded in outcomes instead of novelty.

[IMAGE: A seven-step implementation framework with discovery, boundary design, configuration, tests, documentation, measurement, and iteration. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide implementation framework]

Practical comparison

This table is intentionally practical. It gives a reviewer something to check before the implementation becomes expensive to change.

Expert workflow

Expert tip: "Treat Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide as a system boundary. If the next developer cannot find where the decision lives, how it is tested, and when it should be avoided, the implementation is not finished."

A useful workflow is simple:

• Start with the smallest working example.
• Add the constraints that exist in your real project.
• Remove anything that only demonstrates cleverness.
• Write down the failure modes.
• Add links to related decisions so future readers can navigate the topic cluster.

That last point matters for both humans and search systems. A single article can answer a question; a cluster proves authority.

Common mistakes

Mistake 1: Copying a pattern without its context

A pattern that works in a small demo can fail in a real application. The missing context is usually data volume, team experience, deployment process, security requirements, or observability.

Before copying the pattern, ask what assumption made it safe in the original example.

Mistake 2: Putting business logic in the wrong layer

This is the fastest way to make future debugging expensive. In Laravel, PHP, and server-rendered websites, presentation should receive prepared data, not discover rules on its own.

Keep decision logic in models, actions, services, policies, requests, jobs, or documented helpers where it can be tested directly.

Mistake 3: Optimizing for novelty instead of maintainability

Newer tools and language features can be valuable. They can also hide simple behavior behind unfamiliar syntax.

Use the option that makes the next production incident easier to understand.

Mistake 4: Publishing without a measurement plan

If the article describes a performance, SEO, security, or architecture improvement, define how success will be checked. Logs, tests, crawl diagnostics, analytics, and user behavior are all stronger than assumptions.

[IMAGE: A common-mistakes board with context loss, wrong layer, novelty bias, and missing measurement highlighted. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide common mistakes]

Media and link plan

Image placeholders

• [IMAGE: A concept diagram for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide with input, decision boundary, implementation, tests, and production feedback. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide concept diagram]
• [IMAGE: A mobile screenshot-style checklist for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide mobile checklist]
• [IMAGE: A comparison table visualization for strong versus weak implementation choices. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide comparison table]

Video placeholder

[VIDEO: Insert a 5-8 minute YouTube walkthrough that demonstrates the main decision, the implementation boundary, the test strategy, and the production caveats for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide.]

Trustworthy outbound links

• PHP manual - use this as the trust reference for language-level reference.
• Google Search quality guidance - use this as the trust reference for people-first content and E-E-A-T alignment.

Internal linking opportunities

• Internal guide: PHP Workers and Queues: Supervisor, Horizon - use this when readers need a related Tooling follow-up.
• Internal guide: PHP Webhooks With Filament: Admin Panels and - use this when readers need a related Tooling follow-up.

Original Technical Deep Dive

The deployment choice is an operations choice

PHP can run well on AWS in three very different shapes:

• EC2: virtual servers that you provision, patch, and operate.
• ECS Fargate: containers run by ECS without managing EC2 worker nodes.
• Lambda with Bref: PHP executed through Lambda custom runtimes, usually behind API Gateway, queues, or scheduled events.

The right answer depends less on PHP and more on how much infrastructure your team wants to own.

EC2 is closest to a traditional VPS. Fargate is the cleanest fit when your app is already containerized. Lambda with Bref is strongest for bursty HTTP endpoints, jobs, cron tasks, webhooks, and event-driven workloads, but it requires the app to be stateless and comfortable with Lambda limits.

Quick decision guide

Use EC2 when:

• The app is a legacy monolith with mutable local files.
• You need full control over Nginx, Apache, PHP-FPM, system packages, agents, or long-running processes.
• The traffic pattern is stable enough that always-on servers are acceptable.
• You want the simplest mental model for a small team already comfortable with Linux servers.

Use ECS Fargate when:

• The app can be packaged as a Docker image.
• You want rolling deploys, health checks, task replacement, and horizontal scaling without managing EC2 instances.
• You run separate containers for web, queues, schedulers, and workers.
• You want production to match local Docker builds.

Use Lambda with Bref when:

• Requests or jobs are bursty and pay-per-execution makes sense.
• The app writes uploads to S3, sessions to Redis or a database, and logs to stdout/stderr.
• You can handle occasional cold starts.
• No single request, job, or command needs more than Lambda's execution timeout.

Avoid Lambda for long-running WebSocket servers, heavy background workers that run for hours, workloads needing local persistent disk, or apps that cannot tolerate occasional cold-start latency.

Option 1: EC2 with Nginx and PHP-FPM

EC2 gives you a virtual server. You choose an instance type, storage, networking, security groups, AMI, SSH access pattern, and deployment process.

A conventional PHP stack looks like this:

ALB or CloudFront
  -> EC2 instance
    -> Nginx or Apache
      -> PHP-FPM
        -> application code
        -> RDS, ElastiCache, S3, SQS

On a single Ubuntu host, the rough package shape is familiar:

sudo apt-get update
sudo apt-get install -y nginx php8.2-fpm php8.2-cli php8.2-mbstring php8.2-xml php8.2-mysql unzip

Then deploy the application code, install dependencies, cache configuration, and reload services:

composer install --no-dev --prefer-dist --optimize-autoloader
php artisan config:cache
php artisan route:cache
php artisan view:cache
sudo systemctl reload php8.2-fpm
sudo systemctl reload nginx

For a framework-agnostic app, replace the Laravel cache commands with your own build and warmup steps. The important part is that the deployment is repeatable and does not depend on manual SSH edits.

[IMAGE: Supporting visual 1 for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide, showing Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide decisions, examples, and PHP, AWS, EC2. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide visual 1]

[IMAGE: Supporting visual 1 for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide, showing Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide decisions, examples, and PHP, AWS, EC2. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide visual 1]

EC2 production baseline

Do not treat EC2 like a hand-maintained pet server. At minimum:

• Build AMIs with the PHP extensions and system packages your app needs.
• Put instances behind an Application Load Balancer.
• Terminate TLS at the load balancer or CloudFront.
• Use security groups that expose only required ports.
• Send logs to CloudWatch Logs or another central log system.
• Store uploads in S3, not on instance-local disk.
• Use RDS for the database and ElastiCache for Redis.
• Run queues under systemd or Supervisor, with restart policies.
• Patch the OS and PHP runtime on a schedule.
• Use Auto Scaling groups if more than one instance is needed.

A good EC2 setup still works well. The problem is ownership: you own the operating system, runtime upgrades, scaling policy, failed instance replacement, log agents, disk pressure, and deploy rollback mechanics.

If that work is acceptable, EC2 is a solid deployment target. If it becomes the main source of operational drag, move the app into containers.

Option 2: ECS Fargate

Fargate runs containers for ECS without asking you to manage the underlying EC2 cluster. You package the app as one or more containers, define CPU and memory, configure networking and IAM, and let ECS keep the desired number of tasks running.

A typical PHP web service uses either:

• One container with an app server such as FrankenPHP, RoadRunner, or Swoole.
• Two containers in one task: Nginx for HTTP and PHP-FPM for PHP execution.

The two-container pattern is close to traditional PHP hosting:

Application Load Balancer
  -> ECS service
    -> Fargate task
      -> nginx container
      -> php-fpm container

The PHP image should be explicit and reproducible:

FROM php:8.2-fpm-alpine

RUN apk add --no-cache icu-dev libzip-dev unzip \
    && docker-php-ext-install intl pdo_mysql zip opcache

COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

WORKDIR /var/www/html

COPY composer.json composer.lock ./
RUN composer install --no-dev --prefer-dist --optimize-autoloader --no-scripts

COPY . .
RUN composer dump-autoload --classmap-authoritative

Build it in CI, push it to ECR, and deploy a new ECS task definition revision.

What the ECS task definition owns

An ECS task definition is the deployment blueprint. For Fargate, it usually defines:

• requiresCompatibilities: ["FARGATE"]
• networkMode: "awsvpc"
• CPU and memory for the task.
• Container image names.
• Port mappings.
• Environment variables and secrets.
• Log configuration.
• Task role and execution role.

[IMAGE: Supporting visual 2 for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide, showing Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide decisions, examples, and PHP, AWS, EC2. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide visual 2]

Small excerpt:

{
  "family": "php-api",
  "requiresCompatibilities": ["FARGATE"],
  "networkMode": "awsvpc",
  "cpu": "512",
  "memory": "1024",
  "containerDefinitions": [
    {
      "name": "nginx",
      "image": "123456789012.dkr.ecr.eu-central-1.amazonaws.com/php-api-nginx:2023-02-20",
      "essential": true,
      "portMappings": [
        { "containerPort": 80, "protocol": "tcp" }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/php-api",
          "awslogs-region": "eu-central-1",
          "awslogs-stream-prefix": "nginx"
        }
      }
    },
    {
      "name": "php",
      "image": "123456789012.dkr.ecr.eu-central-1.amazonaws.com/php-api:2023-02-20",
      "essential": true,
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/php-api",
          "awslogs-region": "eu-central-1",
          "awslogs-stream-prefix": "php"
        }
      }
    }
  ]
}

The ECS service then keeps the desired number of tasks alive and replaces unhealthy tasks. Put the service behind an Application Load Balancer, use health checks that hit a real readiness endpoint, and configure deployment minimum/maximum healthy percentages so deploys do not drop all capacity at once.

[IMAGE: Supporting visual 2 for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide, showing Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide decisions, examples, and PHP, AWS, EC2. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide visual 2]

Fargate strengths and traps

Fargate is a strong default for modern PHP APIs and web apps because it makes the runtime artifact explicit. The image that passed CI is the image that production runs.

It also gives clean separation between processes:

• web service for HTTP traffic.
• worker service for queue consumers.
• Scheduled ECS tasks for cron-like commands.
• One-off tasks for migrations and maintenance scripts.

The traps are mostly container architecture problems:

• Do not bake .env files into images.
• Do not write user uploads to the container filesystem.
• Do not rely on local sessions.
• Do not run database migrations automatically in every web container boot.
• Do not log to files inside the container.
• Do not use mutable tags such as latest for production deploys.

Use Secrets Manager or SSM Parameter Store for secrets, CloudWatch Logs for logs, S3 for uploads, RDS for databases, and ElastiCache or DynamoDB for shared state.

Option 3: Lambda with Bref

AWS Lambda does not natively support PHP. Lambda supports custom runtimes, and Bref packages PHP runtimes for Lambda so PHP applications can run as web apps, event-driven functions, or console commands.

For a small HTTP app, current Bref configuration looks like this:

service: php-api

provider:
  name: aws
  region: eu-central-1
  environment:
    APP_ENV: prod

functions:
  web:
    handler: public/index.php
    runtime: php-84-fpm
    timeout: 28
    events:
      - httpApi: '*'

package:
  patterns:
    - '!node_modules/**'
    - '!tests/**'

plugins:
  - ./vendor/bref/bref

Install Bref and deploy:

composer require bref/bref
serverless deploy

Older tutorials often show runtime: provided.al2 plus explicit ${bref:layer...} entries. With Bref 3, the plugin can translate runtime: php-84-fpm into the underlying Lambda custom runtime and layer configuration. Check the runtime name against the Bref version you have installed.

Lambda architecture rules for PHP

Serverless PHP works best when the application already follows horizontally scalable rules:

[IMAGE: Supporting visual 3 for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide, showing Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide decisions, examples, and PHP, AWS, EC2. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide visual 3]

• Code is deployed as an immutable package.
• Uploaded files go to S3.
• Sessions live in Redis, DynamoDB, or the database.
• Logs go to stdout/stderr and are collected centrally.
• Database connections are reused carefully and protected from connection storms.
• Long jobs are split into smaller jobs.
• Cron work is modeled as scheduled events.
• Queues use SQS events instead of always-running worker daemons.

The filesystem is not shared between Lambda execution environments. Treat it as temporary. If a generated invoice, CSV export, image, or cache item must survive, store it outside Lambda.

Cold starts are real. They are often acceptable for internal tools, admin panels, APIs, webhooks, and background jobs. For latency-sensitive public endpoints, measure p95 and p99 before committing to Lambda.

[IMAGE: Supporting visual 3 for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide, showing Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide decisions, examples, and PHP, AWS, EC2. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide visual 3]

Cost model comparison

EC2 cost is mostly capacity-based. You pay for the instances, attached storage, load balancers, snapshots, and data transfer whether traffic arrives or not. Savings Plans and Reserved Instances can reduce predictable usage costs.

Fargate cost is task-based. You pay for requested vCPU and memory while tasks run. This is usually cleaner than EC2 when you want container orchestration without managing worker nodes, but an always-on service still has always-on cost.

Lambda cost is invocation-based. You pay for requests and execution time, plus connected services such as API Gateway, CloudWatch Logs, SQS, RDS, and data transfer. It can be very cheap for bursty workloads and surprisingly expensive for hot endpoints with heavy memory or long execution time.

Do not choose by headline pricing. Estimate the full system:

• Load balancer or API Gateway.
• NAT gateway.
• Logs and retention.
• RDS or Aurora.
• Redis or cache layer.
• S3 and CloudFront.
• CI/CD minutes and image storage.
• Monitoring and tracing.
• Engineering time spent operating the platform.

Deployment checklist

Before shipping any PHP app to AWS, answer these questions:

• How is the artifact built: AMI, Docker image, or Lambda package?
• Where do secrets live?
• Where do uploads live?
• Where do sessions live?
• Where do logs go?
• How are migrations run?
• How is rollback performed?
• What health check proves the app is ready?
• What happens when one instance, task, or execution environment dies?
• How are queue workers scaled and restarted?
• How are scheduled commands triggered?
• How are PHP, Composer dependencies, and base images patched?
• What alarms detect failed deploys, 5xx spikes, queue backlog, and database pressure?

[IMAGE: Supporting visual 4 for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide, showing Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide decisions, examples, and PHP, AWS, EC2. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide visual 4]

If the answer is "SSH into the server and check", the deployment process is not ready yet.

Migration path

For many teams, the safest path is incremental:

1. Move uploads from local disk to S3.
2. Move sessions from local disk to Redis or the database.
3. Centralize logs.
4. Split queue workers and scheduled commands from the web process.
5. Add health checks and readiness endpoints.
6. Containerize the app.
7. Deploy the container to ECS Fargate.
8. Move suitable jobs, webhooks, or low-traffic endpoints to Lambda with Bref.

This path avoids a rewrite. It also makes the app better even if you stop at EC2 or Fargate.

[IMAGE: Supporting visual 4 for Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide, showing Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide decisions, examples, and PHP, AWS, EC2. Alt: Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide deploying-php-apps-aws-ec2-ecs-fargate-lambda-runtimes-guide visual 4]

Practical recommendation

For a new PHP app in 2023 and later, start with Docker and ECS Fargate unless there is a strong reason not to. It gives a clear artifact, fewer server-management tasks than EC2, and fewer runtime constraints than Lambda.

Use EC2 when the app is legacy, stateful, or deeply tied to server-level behavior.

Use Lambda with Bref for workloads that naturally fit events: webhooks, APIs with uneven traffic, jobs, cron tasks, SQS consumers, file processors, and internal tools. Keep the app stateless first; then serverless becomes much easier.

FAQ

What is Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide?

Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide is a practical tooling topic that should be evaluated through implementation scope, production risk, testing, documentation, and long-term maintainability.

When should a team use Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide?

Use Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide when it solves a real project constraint, improves clarity, or reduces operational risk. Avoid it when it only adds novelty or hides behavior from future maintainers.

What is the biggest risk with Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide?

The biggest risk is copying a pattern without its context. Production systems need clear boundaries, rollback options, tests, and observability before a technique becomes dependable.

How do you test Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide?

Test the smallest unit that owns the behavior, then add integration coverage for the path users or systems actually rely on. Include failure cases, configuration differences, and regression checks.

How does Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide affect SEO and AI search visibility?

It improves visibility when the article gives a direct answer, expert context, structured headings, internal links, trustworthy references, and FAQ content that matches the visible page.

Conclusion

Deploying PHP Apps to AWS: EC2, ECS Fargate & Lambda Runtimes Guide is worth doing when the implementation improves clarity, reliability, or delivery speed. It is not worth doing when it hides ownership, increases operational risk, or makes the system harder to explain.

Use the framework above as a review checklist. Then connect this topic to the rest of the project documentation so readers can move from concept to implementation without losing context.