Developer Experience (DevEx)

We engineer our tooling to ensure frictionless onboarding and intuitive local orchestration. We invest heavily in our developer environments to maximize engineering velocity and creativity.

The Single Entry Point: ./dev

We manage the complexity of running a microservice platform entirely through our unified ./dev CLI integration.

• We expose simple, descriptive commands (./dev start, ./dev test, ./dev logs) to orchestrate the entire platform locally, hiding docker-compose complexities.
• Self-Healing Automation: We construct the CLI to autonomously validate local environments—checking dependencies and port alignments—to ensure that the local setup is consistently stable and identical across machines.

The Hybrid Model: Infrastructure in Docker, Services Native

We draw a hard line between infrastructure (databases, message brokers, emulators) and application services (the code engineers actively iterate on).

• We run infrastructure in Docker—it is stable, rarely changes, and painful to install natively. Engineers never need to install Postgres or Pub/Sub on their machines.
• We run application services natively by default. Native execution gives engineers instant feedback, rich IDE debugging, and zero rebuild overhead.
• We preserve Docker as an opt-in mode (--docker flag) for full-stack integration testing and CI environments where containerization is required.

Instant Feedback Loops

We treat the inner-development loop as a non-negotiable platform metric. Code changes must surface within seconds, not minutes.

• Go services use Air for automatic file-watching, recompilation, and restart. Engineers never manually restart a Go service during development.
• Python services use uvicorn --reload for automatic restart on file changes.
• Frontend clients use Hot Module Replacement (HMR) via Next.js, rendering changes instantly in the browser.
• We reject any workflow that requires a Docker image rebuild to validate a code change during local development.

Zero-Friction Authentication

We eliminate manual token configuration and credential juggling from the local developer experience.

• We implement Just-In-Time (JIT) provisioning so that Clerk-authenticated users are automatically created in the local database on first request—no webhook tunnels or manual database seeding required.
• We maintain a test-mode backdoor (APP_ENV=test) for headless CI/CD system tests that need to operate without a real identity provider.
• We share a single, well-documented SERVICE_AUTH_TOKEN across all services for deterministic machine-to-machine authentication.

Seamless IDE-to-Docker Handoff

We design our architecture so engineers can confidently step through and debug code natively.

• We support instantly pulling a specific service out of the localized Docker network, enabling engineers to run it directly inside their IDE for rich, immediate variable inspection.
• We enforce strict, localized port configurations so that traffic routes smoothly between host-level instances and Docker-level interfaces.