Serverless

The concept of serverless architecture was first popularized by AWS Lambda in 2014.

Google Cloud Run is a fully managed containerized computing platform provided by Google Cloud, belonging to the Serverless category, with per-request billing and scale-to-zero characteristics.

AI生成完整HTML页面的任务往往需要30秒到数分钟，与Serverless的设计假设存在根本性冲突

Serverless functions typically have a single-execution time limit of 5–15 minutes

Serverless architectures suffer from cold-start problems: after a function instance is reclaimed, a subsequent invocation requires re-initializing the runtime environment, potentially introducing latency of hundreds of milliseconds to several seconds.

In the context of this article, observability refers to the ability to infer a system's internal state from runtime signals such as alerts, edge requests, function invocations and error rate, and is especially applicable to serverless and edge computing architectures.

In Node.js, fluent-ffmpeg can be used to wrap the ffmpeg command line for audio transcoding, but ffmpeg must be installed separately in the deployment environment; serverless platforms usually need precompiled packages such as ffmpeg-static, and transcoding additionally consumes CPU time.

On Serverless, relying on in-memory storage for session state is unreliable; session state needs to be externalized to persistent storage (such as Postgres), reading the latest state from storage on each call and writing it back after execution.

Serverless environments (such as Vercel's function compute) have the characteristics of on-demand startup, idle reclamation and no guarantee of long-lived instances; function execution time usually has an upper limit, and processes may be terminated by the platform at any time.

Constructing Zod validation schemas at module load time lengthens the first response time in cold-start scenarios (such as Serverless functions and edge runtimes).

Serverless is not a fourth service tier of Azure SQL Database, but rather a compute option available for both General Purpose and Hyperscale.

In traditional Serverless architecture, function instances are treated as fully ephemeral execution environments; after a call ends the environment may be reclaimed immediately and cannot retain data in memory.

Stateless functions have an execution time limit and are terminated once they time out.

In a stateless function, the full context must be serialized and passed to the next round between each round of tool calls; the longer the call chain, the higher the overhead and the probability of errors.

In serverless architectures, the deployment process typically includes steps such as building, uploading, and canary release, taking anywhere from tens of seconds to several minutes.

A voice agent's session is stateful, but serverless functions are stateless, and externalizing state to Postgres lets the two work together.

Stateless functions plus external state storage is a general paradigm for serverless architectures handling stateful business: functions do not hold sessions, context is persisted to external storage such as Postgres, and horizontal scaling is not limited by instance stickiness, but each interaction incurs an extra database round trip, and concurrent writes to the same session require row locks or optimistic concurrency control.

In serverless architecture, functions have a cold start problem: the first execution after a function has not been called for a long time is slower, and the heavier the initialization logic, the more pronounced it is.

Serverless architecture requires functions to be stateless, as function instances may be destroyed at any time, so they cannot rely on in-process caches or local files, and all state must be externalized to a database or object storage.

In serverless architecture, if row-by-row Merkle verification is written as a single traversal of the entire table, it easily triggers execution timeouts or memory overflow, so it must be split into parallelizable batch processing units.