Building a Private Tool Fleet: 14 Internal Applications in 45 Days

About the author: I'm Charles Sieg, a cloud architect and platform engineer who builds apps, services, and infrastructure for Fortune 1000 clients through Vantalect. If your organization is rethinking its software strategy in the age of AI-assisted engineering, let's talk.

Between late February and early April 2026, I built 14 internal applications from scratch. Not prototypes. Not demos. Production systems with PostgreSQL backends, React frontends, full test suites, CI/CD pipelines, and MCP servers that let Claude Code operate them directly. The total codebase across all tools exceeds 60,000 lines of code.

The tools cover every operational function a software company needs: issue tracking, time tracking, invoicing, accounting, marketing, newsletters, analytics, monitoring, content management, calendaring, email, list management, task management, and leverage measurement. Every one of them is designed to run independently with its own database, its own deployment, and its own API surface. They integrate through APIs, not shared databases. They share an auth service and design conventions, not schemas.

This post explains why I built them instead of buying them, what the integration advantages are, and what happens when you own every line of code in your operational stack.

Why Build When You Can Buy

The standard advice is to buy commodity software and build only what differentiates you. That advice assumes three things that no longer hold.

First, it assumes building is expensive. With AI-assisted development producing 40-80x leverage factors, the cost of building a full-featured application is measured in hours, not months. Trellis (our accounting system with double-entry bookkeeping, Plaid bank feeds, AI-powered transaction categorization, and 40+ financial reports) was built in a single afternoon. The human equivalent would have been six weeks.

Second, it assumes SaaS tools integrate well with each other. They do not. Every SaaS vendor exposes a different API, uses different authentication, structures data differently, and rate-limits differently. The "integration tax" of connecting 14 different vendors exceeds the cost of building unified tools that speak the same language.

Third, it assumes you do not need AI-native workflows. This is the biggest miss. When you own the code, you control how AI interacts with every tool. You decide which operations to expose via MCP, which cross-tool workflows to enable, and how deeply AI agents can operate your infrastructure. SaaS vendors expose what they choose to expose. You get their integration, on their timeline, with their limitations. When you own the code, the AI capabilities are limited only by your imagination: automated bug fixing, content generation pipelines, cross-tool orchestration, predictive analytics. You define the use cases.

The Integration Advantage

The real payoff is not any single tool. It is what happens when all 14 share conventions and talk through APIs.

Shared authentication. One auth service (RS256 JWT) secures every tool. A user logs in once. Every tool trusts the same token. No password sprawl, no SSO federation headaches, no per-vendor identity mapping.

API-first integration. Each tool exposes a complete REST API. Cross-tool communication happens through well-defined HTTP endpoints, not database shortcuts. Beacon (69 MCP tools) queries Pulse for conversion data through its API. Vigil checks every tool's health endpoint. Cadence reads campaign dates from Beacon's scheduling API. The tools are loosely coupled by design so they can be deployed, scaled, and operated independently.

MCP servers everywhere. Every tool exposes its functionality through Model Context Protocol servers, ranging from 8 tools (Fulcrum, Narrative) to 69 tools (Beacon). This means Claude Code can operate the entire fleet without switching between vendor dashboards. "Create an invoice for this client" or "check the newsletter open rates" or "what is the uptime for the auth service this week" are all natural language commands.

Autonomous issue resolution. The most powerful integration is the /work-issues skill running in a loop against Docket boards. Claude Code polls for new issues, reads the defect description, navigates to the relevant codebase, writes the fix, runs the tests, commits, pushes, and marks the issue as resolved. Fully autonomous. No human in the loop for routine bug fixes. This is only possible because we own both the issue tracker and the codebase, and both are accessible through MCP. No combination of Jira and GitHub can replicate this workflow because they do not share a protocol that lets an AI agent operate both simultaneously.

Claude Code autonomously fixing issues from a Docket board, committing, and deploying.

The Fleet

Here is the complete list, organized by function.

Development and Operations:

• Docket (issue tracking, 29 MCP tools): Kanban boards, hierarchical projects, WebSocket real-time updates, public bug submission API.
• Vigil (monitoring): Health check polling, latency sparklines, incident lifecycle management, audible alarms, uptime summaries.
• Fulcrum (leverage metrics, 8 MCP tools): Tracks AI productivity with leverage factor calculation, decision fatigue assessment, predictive analysis. We invented this category.
• Narrative (content management, 8 MCP tools): Multi-site static site generator with incremental builds, AI content detection, semantic search, infrastructure provisioning.

Marketing and Communications:

• Beacon (marketing, 69 MCP tools): AI-powered content generation with dual LLM strategy, campaign orchestration, social media scheduling, landing page A/B testing.
• Herald (newsletters, 49 MCP tools): Multi-tenant subscriber platform replacing Buttondown. Double opt-in, automation sequences, Jinja2 templates, SendGrid delivery.
• Pulse (analytics, 37 MCP tools): Privacy-first web analytics with zero cookies, GDPR compliant by design, conversion funnels, A/B testing, webhook ingestion. Sub-2 KB tracking script.

Finance and Administration:

• Meridian (time tracking, 20 MCP tools): Day/week time entry, expense management, PDF invoice generation, accounts receivable reporting.
• Trellis (accounting, 20 MCP tools): Double-entry bookkeeping, Plaid bank feeds, AI transaction categorization, Stripe payments, 40+ financial reports. Integer cents precision.

Productivity:

• Cadence (calendar): Natural language event parsing, multi-provider sync (Google, Microsoft, iCloud, CalDAV), calendar sets, scheduling proposals.
• Courier (email): Proxy architecture supporting Gmail, Fastmail, Exchange, and IMAP. Markdown composition, rules engine, LLM classification.
• Slate (tasks, 35 MCP tools): Daily command center with master list templates, real-time collaboration, Things 3 import, Packed integration.
• Packed (lists, 24 MCP tools): Reusable list templates that generate working copies. Weight tracking, nested containers, real-time collaboration via SSE.

What SaaS Cannot Do

The deepest advantage is not cost or integration. It is control over how AI operates your business.

When Vigil detects that the auth service is slow, it can query Fulcrum's API to see if a heavy batch job is running, check Docket's API for related open issues, and create a new incident with full cross-tool context. No SaaS monitoring tool can do that because no SaaS monitoring tool has API access to your issue tracker and your productivity metrics simultaneously.

When Beacon generates marketing content, it can call Pulse's API for which landing pages are converting, query Herald's API for subscriber engagement patterns, and adjust the content strategy. No SaaS marketing platform has native API access to your analytics and newsletter data simultaneously.

The /work-issues skill is the most striking example. Claude Code runs in a loop, polling Docket for new issues on a board. When it finds one, it reads the defect description, locates the relevant code, writes the fix, runs the test suite, commits and pushes, then marks the issue as resolved in Docket. It does this continuously, processing multiple issues per cycle. The human role is supervisory: create the issues, review the commits. The AI does the rest. This collapses the feedback loop from days (write issue, assign developer, developer reads issue, developer fixes, developer tests, developer deploys, developer updates issue) to minutes.

The Numbers

Across the full fleet: over 300 MCP tools, one auth service, and one deployment pipeline. Total build time for all 14 tools: under 200 hours of Claude time, representing over 3,000 human-equivalent hours of engineering work.

The marginal cost of adding tool number 15 is near zero. The auth patterns, CSS design system, and MCP conventions are all established. A new tool is a FastAPI backend, a React frontend, an Alembic migration, and a buildspec. The pattern is proven.

When you own the code, every tool gets better when any tool gets better. A shared diagnostics library benefits all 14 tools simultaneously. A CSS design system update propagates everywhere. An auth improvement secures everything at once. And every new MCP tool you expose becomes immediately available to every AI agent working on every other tool in the fleet.

That is the compound interest of owning your operational stack.