CorTeX-1: What a Closet Server Actually Delivers

Money is a tool. You deploy it where it compounds. Hardware, software, domains, API keys, cloud services — the investment returns production infrastructure, sovereign AI capability, and the kind of engineering understanding that managed services are specifically designed to hide from you.

I spent twenty years telling other engineers how infrastructure works. VMware, NetApp, Twilio — I could explain the layers of a virtualization stack in my sleep. But I’d never built one from scratch where every failure was mine to fix.

CorTeX-1 changed that. It’s a home server running in my closet that handles actual production traffic for two live services. Not a lab. Not a demo. Production.

The moment that made it real: DeskFlow went down at 11 PM on a Tuesday. I didn’t file a ticket. I walked to the closet, checked the Docker logs, found PostgreSQL hitting its memory ceiling, bumped the container limit, and had it back up in twelve minutes. That feedback loop — symptom to root cause to fix, no middleman — is worth more than any certification.

That’s the principle I keep coming back to: money is always a tool. Not a constraint. Not a scoreboard. A tool — like a wrench or a Docker container. You pick the right one for the job. The question isn’t “how cheap can I build this?” The question is “what does this investment give me access to that I can’t get any other way?”

IMAGE CONCEPT: Overhead shot of CorTeX-1 with the case open — labeled callouts pointing to CPU, RAM, storage, and the tangle of Ethernet cables running to the router. Clean cable management is aspirational, not actual.

What It Delivers

Two production services and a development stack, all containerized. Each one a capability that didn’t exist before the investment:

DeskFlow — A multi-tenant helpdesk SaaS built with Supabase and Next.js. Organizations create tickets, agents manage them, API handles routing. Live at support.digifender.net. Real users, real tickets, served from the closet. Value delivered: a live product generating real-world operational experience that no tutorial provides.

Voice Agent — An omnichannel AI assistant that picks up phone calls, answers Telegram messages, handles Discord, SMS, and WhatsApp. Claude does the thinking. Deepgram transcribes the speech. ElevenLabs generates the voice. LiveKit moves the audio. All of it runs here. Value delivered: sovereign AI infrastructure — no vendor can throttle, deprecate, or reprice the core capability.

Ollama — Local LLM inference for development. When I’m iterating on prompts at 2 AM, I don’t want API rate limits or per-token costs. I want instant responses from a model running ten feet away. Value delivered: unlimited iteration speed at the moment when creativity is highest and patience is lowest.

TOOL SPOTLIGHT: Ollama Open-source local LLM runner. Pulls models like Docker pulls images. ollama run llama3 and you’re running inference locally in under a minute. Zero API keys. Zero cost per token. The iteration speed difference between local and cloud inference is the difference between thinking and waiting.

The Stack, Piece by Piece

Docker Compose — The Orchestrator

Everything runs in containers. PostgreSQL, Redis, Ollama, LiveKit, DeskFlow, Voice Agent — each one isolated, each with memory limits, each independently restartable. One YAML file defines the entire topology.

I chose Compose over Kubernetes deliberately. Single node, moderate traffic, no need for cluster orchestration. Compose gives me health checks, restart policies, and resource limits. If I need Kubernetes later, the containers are the same containers. The migration path stays open.

The thing about containers that nobody tells you until you run them yourself: isolation isn’t just a security feature. It’s a diagnostic feature. When something breaks, you know exactly which box it broke in. docker logs deskflow-api tells you more in five seconds than twenty minutes of grepping system logs.

IMAGE CONCEPT: Terminal screenshot showing docker stats output — all containers listed with CPU%, memory usage, and network I/O. DeskFlow API at 2.3% CPU, PostgreSQL at 340MB RAM, Ollama idle at 0.1%. The mundane reality of production infrastructure: mostly quiet.

Caddy — The Front Door

Caddy handles every HTTP request that reaches the server. It terminates TLS, routes subdomains to containers, and manages certificates automatically. That last part matters more than it sounds.

I’ve watched production outages caused by expired TLS certificates. At VMware. At NetApp. At companies with dedicated ops teams. Caddy eliminates that entire failure mode. It provisions Let’s Encrypt certificates on first request and renews them before expiration. No cron jobs. No calendar reminders. No 3 AM pages because someone forgot to rotate a cert.

Each service gets its own subdomain under digifender.net. Caddy’s config reads like plain English — you point a domain at a container port and it handles the rest.

QUICK TIP: If you’re self-hosting anything with HTTPS, start with Caddy instead of Nginx. The automatic TLS alone saves you hours of setup and eliminates a recurring operational risk. You can always migrate to Nginx later if you need specific features. You probably won’t.

PostgreSQL + pgvector — The Memory

PostgreSQL stores everything structured: DeskFlow tickets, organization records, user accounts, Voice Agent conversation history, user profiles, knowledge base documents. One engine, multiple databases, proper isolation between services.

The pgvector extension is what makes it interesting for AI work. It adds vector similarity search directly inside PostgreSQL — no separate vector database needed. When Voice Agent needs to find relevant knowledge base entries for a conversation, it runs a cosine similarity query against embeddings stored in the same database as the user profile. One connection pool. One backup strategy. One thing to monitor.

Redis — The Nervous System

Redis handles the fast, ephemeral stuff: session tokens with TTL expiration, pub/sub messaging between services, cached query results. It’s the connective tissue that lets DeskFlow and Voice Agent talk to each other without direct coupling.

I run PostgreSQL and Redis on the same physical disk. At enterprise scale, you’d separate them onto dedicated storage to reduce I/O contention. At my traffic volume, the contention is unmeasurable. Know your actual constraints before optimizing for theoretical ones.

Cloudflare Tunnel — The Magic

This is the piece that makes the whole thing possible. Without it, self-hosting means port forwarding, dynamic DNS, and your home IP address in every DNS record. With it, none of that.

Cloudflare Tunnel runs a daemon (cloudflared) on the server that opens an encrypted outbound connection to Cloudflare’s edge network. Outbound — the server calls Cloudflare, not the other way around. No inbound ports open. No IP address exposed. Cloudflare handles DDoS absorption, CDN caching, and routes requests through the tunnel to Caddy, which routes them to the right container.

The security properties are hard to overstate: my home network is invisible. There is no port to scan, no IP to target, no firewall rule to misconfigure. The entire attack surface is Cloudflare’s edge, and defending edges is what they do.

IMAGE CONCEPT: Network diagram showing the request path: User → Cloudflare Edge (DDoS protection, CDN, TLS) → Encrypted Tunnel → CorTeX-1 → Caddy reverse proxy → Docker container. Arrows show only outbound connections from the server. No inbound ports. The home network boundary drawn as a dashed line with “No ports open” label.

The Value Ledger

Here’s what the investment actually looks like when you measure it correctly:

The deployment: Server hardware, networking gear, domains, API subscriptions, cloud services, development tools. The total investment is in the low thousands — real money, deliberately spent. Electricity runs $15-20/month on top. Cloudflare Tunnel is free. Docker is free. Caddy is free. PostgreSQL is free. But the things that matter cost what they cost, and I paid it because the alternative was renting capability I’d never own.

What it replaced: The cloud equivalent — PostgreSQL + Redis + compute for two apps + LLM inference + LiveKit + API keys for Anthropic, Deepgram, ElevenLabs — runs $300-400/month on AWS or GCP when you add it all up. But cost comparison is the wrong metric. I didn’t build this to save money. I built it to own every layer.

What it delivered that money can’t rent:

The diagnostic feedback loop. When DeskFlow breaks at 11 PM, I don’t file a ticket and wait. I walk ten feet and fix it. That twelve-minute incident taught me more about PostgreSQL memory management than a year of reading documentation. Managed services sell you uptime. They don’t sell you understanding.

Sovereign capability. No vendor can decide to deprecate my infrastructure, change the pricing, or sunset the API. The models run locally. The data stays local. The architecture belongs to me. In an industry where “the platform giveth and the platform taketh away” is the default operating model, ownership is the ultimate risk mitigation.

Career convergence. CorTeX-1 isn’t a hobby project wearing a production costume. It’s twenty years of enterprise experience compressed into a single box. VMware taught me virtualization — that’s the containers. NetApp taught me storage diagnostics — that’s the PostgreSQL tuning. Twilio taught me real-time communication — that’s the Voice Agent. The hardware is the catalyst. The value is the synthesis.

The principle holds: money is a tool. The investment wasn’t a cost. It was a deployment — of capital into capability. The returns are compounding.

TOOL SPOTLIGHT: Cloudflare Tunnel Free tier handles most self-hosting needs. Install cloudflared, authenticate with your Cloudflare account, create a tunnel, map subdomains to local ports. Setup takes under fifteen minutes. The alternative — port forwarding, dynamic DNS, exposed IP — takes longer and is permanently less secure.

What I Learned

The diagnostic feedback loop is the point. Not the cost savings, not the bragging rights. The loop. Symptom → logs → root cause → fix → verify. When you own every layer, that loop is direct and fast. When you rent layers, the loop includes “file ticket, wait for response, explain your environment, wait again.” Twenty years of enterprise support taught me which loop produces better engineers.

Everything converges. CorTeX-1 isn’t a new skill — it’s every old skill in one box. VMware taught me virtualization. NetApp taught me storage and cluster diagnostics. Twilio taught me real-time communication and WebRTC. Docker, Caddy, and Cloudflare provided the modern glue. The server is a career artifact.

Know your acceptable risk. Self-hosting on residential hardware means single point of failure on everything. Power goes out, server goes down. Hard drive fails, services stop. That’s acceptable for my workload — low traffic, no enterprise SLA. It would be unacceptable at scale. The architecture is designed so that when scale demands it, the same containers move to cloud infrastructure with minimal changes.

Money buys access, not outcomes. The investment bought hardware, API access, and infrastructure. The outcomes — the diagnostic skill, the architectural understanding, the production experience — came from the work. Capital opened the door. Walking through it was the hard part. This is true of every tool purchase, every course, every conference ticket: the money is the enabler, never the deliverable.

What’s Next

Monitoring. Grafana and Prometheus for dashboards and alerting. Right now I check docker stats manually. That works at this scale. It won’t work at the next one.

Automated backups. Scheduled PostgreSQL dumps to cloud object storage. The data is more valuable than the hardware. If the server dies, I want to be back up on a new box in under an hour.

CorTeX-2. A second node for redundancy. Because the only thing better than owning every layer of your infrastructure is owning two of every layer. The investment thesis is the same: deploy capital where it compounds into capability.

QUICK TIP: If you’re considering self-hosting, start here: Docker Compose + Caddy + Cloudflare Tunnel. Containerize everything from day one. The learning curve is the entire point — the operational understanding you get from owning every layer can’t be acquired any other way. Start small. Break things. Fix them yourself. That’s the feedback loop that matters.