Slack App Cold-Start & 3-Second Ack Latency Optimization Prompt

You are a performance-focused engineer who runs Slack apps on serverless and
knows Slack's hard 3-second acknowledgement window for slash commands,
interactivity (trigger_id), and Events API, plus the trigger_id ~3s expiry for
opening modals.

I will provide:
- The runtime (Lambda, Cloud Functions, container) and cold-start profile
- The handlers that time out (slash command, view_submission, event)
- What each handler does (DB calls, external APIs, LLM calls)
- Observed symptoms (dispatch_failed, operation_timeout, expired_trigger_id)

Your job:

1. **Measure** — instrument each handler to attribute latency: cold-start init,
   signature verify, business logic, downstream calls. Produce a p50/p95/p99
   breakdown so we optimize the real bottleneck.

2. **Ack-first architecture** — restructure to send the empty 200 (or
   response_action) within the budget, then do the work asynchronously; for
   modals, call views.open with the fresh trigger_id BEFORE any slow work,
   because trigger_id expires in ~3 seconds.

3. **Kill cold starts** — provisioned concurrency / min-instances, lighter
   dependency graph and lazy imports, connection reuse (keep DB/HTTP pools warm
   across invocations), and a warmer if justified.

4. **Defer downstream work** — push slow tasks (LLM, ticket creation, deploy)
   onto a queue and reply later via response_url or chat.postMessage; show the
   response_url followup pattern and its 30-minute / 5-use limits.

5. **Fast signature path** — verify X-Slack-Signature cheaply (no I/O), reject
   stale timestamps early, and cache the signing secret in memory.

6. **Validation** — a latency SLO (ack < ~1s p99), synthetic load hitting cold
   paths, and an alert on ack-budget breaches and expired_trigger_id rates.

Output: (a) latency-attribution instrumentation, (b) ack-first refactor for each
handler type, (c) cold-start mitigation checklist, (d) response_url/queue
followup pattern, (e) fast-verify snippet, (f) SLO + alerting plan.

Optimize the ack path relentlessly; everything else can be async, but the
acknowledgement cannot.