Why I Prefer a Separate Edge Layer Over Hiding Routing in the App
The trade-off between fewer containers and clearer network responsibility.
architecture
Latency-Sensitive Work and Batch Work Should Not Share Every Knob
Why the presence of audio services and background workers argues for differentiated scaling and monitoring.
Git, Runtime State and Secrets Need Different Jobs
Operational confusion falls when desired configuration, mutable data and confidential values stop competing to be one source of truth.
Why the Backend and PBX Need an Adapter Boundary
Identity and parental policy should not be embedded inside SIP routing rules.
Content Is Not the Same Thing as Delivery State
The authoritative article text can remain stable while each destination has its own mutable publishing lifecycle.
Where Are You Drawing the Boundary of the System?
Before talking about a system, it helps to say where its boundary is. An application can be treated as the system, or the application, database, network, and user workflow can be considered together. Changing the boundary changes the explanation.
Three Caddy Instances Can All Be Healthy While Nobody Knows Which One Owns the Request
Multiple proxies are fine when each boundary has one explicit owner.
The pbx Application Name Inside the Celery Command Is an Architecture Clue
What process entrypoints reveal about how telephony logic and background work connect.
When to Reuse a Helm Template and When to Fork It
The boundary between common deployment structure and service-specific commands such as celery-low.
Why I Kept Audio, Workers, Redis, Nginx, and the Web App Separate
The operational reasons for not collapsing supporting services into one large deployment.
Why Voiceware Had Multiple Celery Worker Roles
Separating scheduled, high-priority, standard, and low-priority execution concerns.
A Secret Manager Is an Authorization System, Not Just Encrypted .env
OpenBao adds identity, policy, versioning, leases and audit around secrets instead of merely moving plaintext to a different file.
The audio-fork Service Deserved Its Own Deployment Boundary
Why audio-related processing should not be forced into the lifecycle of the web process.
One ArgoCD Application per Voiceware Service
The benefits and costs of independently reconciling each major workload.
The Real Architecture Work Was Finding Voiceware’s Runtime Boundaries
How I treated process boundaries as deployment boundaries instead of forcing the application into one monolithic unit.
What the Early Voiceware Manifests Do Not Yet Prove
Being precise about the difference between a working deployment model and production hardening.
Control Plane, Data Plane, and Queue Dependencies in Voiceware
A mental model for separating deployment control from application traffic and background work.
Redis in Voiceware: Small Manifest, Central Dependency
Why an internal Redis service deserves explicit operational attention.
The Biggest Voiceware Lesson: Platform Engineering Is Contract Engineering
The common thread connecting ports, images, values, commands, Services, ArgoCD paths, and queues.
Using Redis Beside Kamailio Without Making Redis the Whole Architecture
Redis was useful for fast shared state in a SIP lab, but the important decision was which state belonged there and how the proxy behaved when it disappeared.
The Edge Voice Device Architecture Finally Connected Firmware, SIP and Backend Work
By the end of the year the interesting problem was no longer a codec or PBX; it was the boundary between device identity, firmware, SIP and backend control.
The Voice Product Stack Was Finally One System, Not Three Projects
Firmware, backend and telephony stopped being separate workstreams once their failure states and deployment policies were designed together.
Background Jobs Are Part of the Product Latency Budget
Why asynchronous does not mean unimportant or invisible.
From YAML Files to an Operating Model: The Voiceware Shift
The broader change from manually thinking about containers to thinking about desired state, reconciliation, and service responsibility.
Ownership Needs Boundaries, Not Vagueness
Shared responsibility works only when teams also know which decisions they actually own.
What Port 5001 Tells Me—and What It Does Not
Reading infrastructure signal carefully without inventing application internals.
What Survives When a Static Site's Origin Goes Offline?
One attraction of static publishing is that the authoring server may not need to stay online for readers to receive already-published files. But the boundary of that independence needs to be clear.
Why Nginx Was Its Own Voiceware Application
The operational value of separating edge/proxy concerns from the application container.