ServX
An infrastructure monitoring and incident-response project exploring deployment monitoring, incident detection, real-time telemetry, and developer tooling through a web application, CLI, and React SDK.
Infrastructure Visibility Beyond Simple Pings
Our team built ServX to explore how developer teams monitor distributed infrastructure, deployment health, and security postures without context switching between cloud consoles. Rather than just pinging server endpoints, we envisioned an integrated control plane covering hosting status across Vercel and Render, incident response, multi-database exploration, and emergency kill switches. While my teammates focused on hosting integrations and incident triage pipelines, I took primary ownership of the Attack Paths scanning engine, the pluggable database controller, and client-side performance engineering, contributing across the main repository while owning the Attack Paths engine end to end and over 90% of the Attack Paths codebase.
Building the Attack Paths Engine
Most vulnerability scanners produce disconnected lists of CVEs that developers ignore because they lack architectural context. I built the ServX Attack Paths engine to model how distinct, lower-severity security issues combine into exploitable compromise paths. The engine ingests repository codebases, parses dependency manifests using OSV databases, and runs Semgrep rules and secret scanners. By tracing data flows from untrusted HTTP parameters through middleware down to database queries or third-party API dispatches, the engine identifies structural risks such as insecure direct object references and unauthenticated administrative routes, surfacing clear vulnerability paths.
Mutual HMAC and Isolated Execution
Running static analysis scanners and dependency parsers requires significant compute and memory. Exposing scanner binaries directly to user-facing API servers creates unacceptable attack surfaces. I separated the Attack Paths executor into a standalone microservice hosted on an isolated Render worker. The executor shares no database credentials and accepts no public web traffic. Communication between the ServX API and the executor is authenticated using mutual HMAC signatures containing HTTP methods, path strings, timestamps, nonces, and body hashes. The executor processes lease-bound jobs sequentially in a temporary sandbox, posts signed progress callbacks to the ServX API, which streams them to the dashboard over Server-Sent Events, and wipes the filesystem upon completion.
Pluggable Databases and Emergency Kill Switches
Beyond security scanning, I developed ServX's universal database explorer and helped design our client emergency circuit breakers. To let developers query records without switching to external database GUI tools, I designed a pluggable adapter interface supporting MongoDB, PostgreSQL, MySQL, Redis, Supabase, and Firebase. For incident mitigation, we created the servx-cli and servx-react packages. If an active data breach or runaway API loop is detected, an engineer can flip the DEFCON maintenance switch in the ServX dashboard. Connected web applications wrapping their tree in the ServXProvider immediately render a full-screen takeover modal, blocking untrusted traffic within seconds.
Cutting Initial Bundle Size by Ninety-Seven Percent
As ServX expanded to include Three.js network visualizers, real-time Recharts dashboards, and iconography for dozens of database providers, our frontend bundle grew into a 2.62 MB monolith. Initial dashboard page loads suffered from noticeable rendering delays. I executed a comprehensive bundling audit across our Vite setup. I converted more than twenty feature routes into lazy-loaded components using React Suspense and configured Rollup manual vendor chunks to isolate heavy visualization libraries. These optimizations reduced the initial JavaScript load from 2.62 MB down to roughly 60 kB — a 97% reduction in initial load weight.
What Building Infrastructure Tooling Taught Me
Working on ServX taught me how to think about systems under failure. When building operational software designed to manage other applications, your tools must remain dependable precisely when everything else is breaking down. Designing isolated execution environments, implementing cryptographic HMAC handshakes, and decoupling background job queues showed me how to isolate failure domains. It also gave me practical experience in npm workspaces monorepo architecture, showing how shared types, custom cryptographic packages, and reusable React SDKs can be maintained cleanly across multiple independent services.