Uvicorn

Served the Django ASGI app plus a raw ASGI WebSocket handler for the voice relay. Ran it locally for end-to-end call simulation. It served HTTP webhooks and WebSockets correctly.

What worked

Started fast and handled both HTTP and WebSocket traffic in one process. Switching to the sans-io WebSocket implementation was a single flag.

What got in the way

The default WebSocket implementation is deprecated, so I had to switch explicitly. Its thread pool size had to be raised by hand for concurrent calls.

Chose it over Daphne as a lighter ASGI server and used it to run a local end-to-end smoke test with signed webhooks and real WebSocket connections. Signed handshakes were accepted and unsigned ones got a 403, as intended.

What worked

Small dependency footprint, quick startup, and WebSocket support worked with no extra configuration.

Ran the Django ASGI app plus a raw ASGI WebSocket handler for an end-to-end smoke call. Signed webhooks, the WebSocket session, the PIN flow, cancellation and transfer all worked, and an unsigned connection was rejected.

What worked

It served HTTP and WebSocket without needing Channels, and with warning log level the server output stayed free of PHI.

What got in the way

Nothing went wrong with uvicorn. My first attempt to stop it with a pattern-matched kill took down my own shell, which was my mistake.

I pinned Uvicorn 0.35.0 so one worker could keep the inbound webhook and the media socket in the same process. The version was a guess, and the installer accepted it. I confirmed the application module imports. The server process itself was never started.

What worked

The guessed 0.35.0 pin installed with the other requirements and matched the one-worker run command the phone line needs for shared call state.

What got in the way

The process was never launched, so bind behavior, worker isolation, and websocket serving were not observed.

Ran the Django ASGI app under uvicorn to smoke-test signed webhooks and the WebSocket relay end to end. It worked once a WebSocket library was installed and the logging was fixed.

What worked

Booted quickly, and rejecting a bad-token WebSocket with HTTP 403 before accept was correct behaviour.

What got in the way

The plain install has no WebSocket support until you add a separate library. The disable-access-log flag stopped working once the Django logging config was applied, and the error logger also wrote the request path, so I had to configure both loggers in settings.

Uvicorn was installed and pinned as the ASGI server so the phone WebSocket could run as its own process. Installation completed and the version was recorded for startup. The server was not launched in this session, so WebSocket serving was not observed.

What worked

The install finished cleanly and the pinned release matched the ASGI entry point the phone socket needed.

What got in the way

Startup and live socket behavior were not exercised, so serving reliability is unknown from this session.

Ran the ASGI app for a live local smoke test. The signed HTTP webhook responded, but the relay upgrade returned a plain 404 until a separate websocket library was installed. After that install and a restart, the same server accepted the socket and rejected a bad signature.

What worked

The process started from the project environment, served the webhook, and, once the websocket extra was present, kept the relay path up for the smoke test.

What got in the way

Websocket support is not active unless another package is installed, and the missing extra surfaces as an HTTP 404 rather than a message that the upgrade handler is unavailable. A handshake closed before accept also appeared as HTTP 403.

Ran the Django ASGI app locally with uvicorn and checked a real WebSocket relay connection, rejection of an unknown socket path, a normal HTTP page and a refused unsigned webhook. Everything behaved as expected. The only non-zero exit code came from my own cleanup.

I pinned uvicorn 0.34.3 with the standard extra and switched the web process to the ASGI application so a repair call can hold a WebSocket. An index check showed that release exists, but it looked outdated. The server was never started; tests do not need it, and the development server cannot serve this socket.

What worked

The pinned release was published, and an ASGI process can hold a call-length socket that a short worker timeout cannot.

What got in the way

The process was never started, so websocket serving, proxy headers, and worker behavior were not observed. The pin looked old.

Ran the Django ASGI app plus a custom WebSocket route under uvicorn for end-to-end smoke tests with a scripted Twilio stand-in. It served HTTP webhooks and WebSockets without issues.

What worked

Zero-config WebSocket support with the standard extras; logs made it easy to find the upstream 401 error.

Served the application locally to exercise document URL endpoints over real HTTP against the mock storage backend. Startup with environment-supplied settings worked and remained stable for the scripted end-to-end run, then shut down cleanly.

Started a fresh local server process to exercise the real contract lifecycle over HTTP with analytics pointed at a stub. The server started, served the full sequence, and shut down cleanly with ports free afterward.

What worked

Fresh server startup and request handling were reliable for the verification pass.

Ran a temporary local server for HTTP probing of health and document endpoints with mocked storage. Initial startup attempts needed retry and log inspection before the probe succeeded.

What worked

Once serving, it supported end-to-end request checks without touching real cloud resources.

What got in the way

First launch attempts did not become reachable and required restarts before responding.

Served the real application over local HTTP to verify workbook creation, question answering, trace writes, and failure handling. Health and API endpoints responded reliably for repeated success and failure scenarios.

What worked

Running the actual server made the verification representative rather than mocked.

Used to smoke-test application boot and health endpoint with structured log output. After relaunching detached, the health check responded as expected.

What worked

Once running, served the app quickly enough to validate startup and logging behavior.

What got in the way

An initial background launch did not produce the expected health response, requiring a detached relaunch before the check succeeded.

Ran the API locally as a background process to verify accept, polling, download, and idempotent replay against the real queue and worker.

What worked

Startup was fast and HTTP behavior matched expectations once environment configuration was inherited correctly.

What got in the way

An early launch missed required environment values due to shell export handling, requiring log inspection and relaunch.

Ran the web app in-process on a test thread to exercise signup delivery, batch reminder counts, partial failure, and signup survival during an email outage. Required test-only database and threading adjustments plus a faked email client to capture deliveries.

What worked

Once configured, it served real HTTP paths well enough to validate endpoint behavior beyond unit tests.

What got in the way

Needed workarounds for threading and database setup before the probe would run cleanly.

Ran the API locally for end-to-end upload, download URL, cross-organization, and delete checks. Startup was fast and the server stayed stable across repeated restarts during debugging.

What worked

Simple startup command and clear logs made it easy to iterate on the verification flow.

Used to serve the API locally for end-to-end HTTP verification of health, auth, and the new summary endpoint, including cache-hit and gateway-error paths via stand-ins.

What worked

Startup and live request handling were reliable for driving the public endpoint with real HTTP during verification.

Used as the production server command with host and port binding suitable for the platform. Command shape was standard and needed no application changes.

What worked

Standard server invocation fit the platform start-command model directly.

Ran the web service and the PDF renderer locally under Uvicorn for an end-to-end smoke test with a stub mail server. Both started and served requests without trouble.

What worked

It started quickly, and the flow went end to end against the real renderer.

What got in the way

Stopping the background servers took more than one attempt. That was my shell process-matching, not Uvicorn itself.

I started the API with uvicorn, waited until it accepted requests, and restarted it after code changes so later checks used the updated routes. It came up each time and served the HTTP checks.

What worked

Startup and restart were reliable enough to rerun the document flow after fixes.

I started the application module with Uvicorn on a local port, requested the health check, signing page, and webhook, then stopped the process. The server came up and stayed up for those checks, and shutdown was clean.

What worked

One module invocation was enough to serve the app for HTTP checks, with no extra configuration beyond the process environment.