Most small businesses don't run on software they chose. They run on software they accumulated.
QuickBooks for invoicing. Trello for tasks. A shared Drive for contracts. A spreadsheet someone built three years ago for tracking clients. Email for everything in between. It works — right up until the person who built the spreadsheet leaves, or you hire your tenth employee and nobody can answer a simple question: where does this actually live?
That's the moment most owners go looking for a real system. And that's the moment they discover the market has nothing built for them.
The gap in the middle
Business software splits into tiers, and small businesses fall straight through the crack between them.
Enterprise ERP — NetSuite, Dynamics, SAP — is built for companies with full-time IT, finance, and operations teams. Implementations run four to six months and cost more than most small businesses clear in profit. The complexity is the point for the companies it's built for. For everyone else it's a wall.
Mid-market SaaS — Zoho, Salesforce, Odoo — solves the price problem and replaces it with a worse one. These platforms are built for everyone, which means they're built for no one in particular. You get an enormous surface area of features that don't apply to you, and the platform expects your business to change to fit its screens. A dental practice, a plumbing company, and a fabrication shop don't run the same workflows. Generic SaaS makes all three use the same ones anyway.
The DIY stack — QuickBooks plus a handful of tools held together by spreadsheets and memory — is where most small businesses actually live. It's cheap and it's fragmented, and the fragility is invisible until the bookkeeper goes on vacation and work stops.
Arc is a fourth tier. Custom software, scoped to exactly how one business operates, priced like a SaaS subscription, and delivered in weeks instead of months. Not a platform you bend yourself around. A system shaped to the way you already work.
Pick a lane, own it
Here's the part that matters more than the feature list: Arc isn't aimed at "small businesses." That's not a market — it's a size. It's millions of organizations that have nothing in common except headcount.
Arc is built one vertical at a time. Take field services — HVAC, plumbing, electrical, landscaping. Those businesses share a real spine: dispatch and scheduling, job costing, recurring maintenance contracts, mobile techs entering time from the field, invoicing tied to completed work. Learn that spine once and you can serve the next ten companies that share it.
This is a deliberate constraint, and it's where the economics come from. The second HVAC deployment starts at roughly 70% of the first one's codebase. The third gets there faster still. Discovery calls get sharper because you already know the questions. Proposals get faster because you've scoped this shape before. Marketing converts better because you're speaking to one industry's actual problems instead of "small business" in the abstract.
The honest version of the pitch isn't "we serve everyone cheaply." It's "we go deep in a few industries and the depth compounds."
What you actually get
Arc covers the operational surface a service business runs on, in one system instead of eight.
Work and projects. Milestones, sprints, jobs, and tasks on a Kanban board or a Gantt timeline. Estimates versus actuals. Time entries logged against tasks and flagged billable, so the hours your team works flow straight into what your customers get invoiced.
CRM. Company and contact records, a deal pipeline that moves through defined stages, and activity logging in one place. A health score flags which accounts are going quiet before they churn.
Finance. Invoices that auto-number and track from draft to paid, estimates, expenses, and recurring billing on monthly, quarterly, or annual cycles. Stripe for collecting payment online. This isn't a replacement for QuickBooks or Xero — Arc integrates with those for formal accounting. It's the day-to-day money visibility you currently piece together from three places.
Contracts. Templates, status tracking from draft through signature to active or expired, e-signature, and expiration alerts before renewals sneak up on you.
Client portal. Customers log in to see their invoices and estimates, check project progress, submit tickets, and pay outstanding balances. It replaces the "I'll email you a PDF" loop most service businesses are still stuck in.
Calendar, messaging, and a dashboard that pulls KPIs from every module into one view you can rearrange to match how you think.
Everything is governed by roles — owner, admin, lead, contributor, viewer, customer — enforced on both the server and the screen. A contributor logs time and updates tasks but can't touch finance. A customer pays an invoice but never sees your pipeline.
The build, in plain terms
A few technical choices are worth explaining, because they're the ones a careful buyer asks about.
A document database, for a real reason. Arc runs on MongoDB, and the reason isn't that "a task is different from a deal" — a relational database handles different entities fine. The reason is per-customer variation. An HVAC company's job record carries fields a dental practice's never will, and the workflow metadata differs deployment to deployment. A document model absorbs that variation in the data layer instead of forcing every customer onto one rigid schema or a forest of mostly-empty columns.
The fair question this raises is schema evolution: if every customer's data can differ, how do changes roll out safely? The answer is that shape changes are handled in the application layer with version-tolerant readers, not by pretending schema change doesn't happen. New fields are additive and optional; readers tolerate old and new shapes during a transition; structural changes ship behind a deployment's version flag. It's a discipline, not a free lunch — but it's a discipline that scales across many small customers better than coordinated migrations across one shared database would.
Sessions, not tokens, for auth. Arc uses signed, HTTP-only session cookies backed by a server-side store. When someone's role changes or they leave a workspace, the change is immediate — you destroy the session record. Stateless tokens carry a revocation lag that's a poor fit for a multi-tenant business app where roles change all the time.
No charting library. Every chart — donuts, funnels, P&L bars, Gantt, burndown — is hand-rendered as SVG. That's more work up front and zero maintenance after: nothing to break on upgrade, nothing to bloat the bundle, no security advisory to chase because a charting package shipped a vulnerability. The charts render identically on the server and the client and export cleanly to PDF.
A module system built for reuse. New features package as self-contained modules — routes, nav, permissions declared in a manifest. Turning one on is a config change and a restart, not a refactor. That's what lets vertical-specific features (dispatch for field services, inventory for distribution) get built in isolation and switched on per customer without destabilizing the core.
The stack underneath — SvelteKit on the front, Fastify on the API, Docker Compose for deployment — was chosen to keep a small team's operational load low. A new customer deployment is a config copy and a container start, not a fresh build.
Where this is actually going
It's tempting to describe Arc as "custom software priced like SaaS." That undersells it, and it anchors to the wrong valuation.
What Arc really is, is a vertical SaaS factory that starts as custom work. The progression is the whole point:
- Build custom deployments for real customers in one vertical.
- Watch which workflows recur across every customer in that vertical.
- Package the recurring ones as standard modules.
- Productize the strongest vertical into a repeatable platform.
- Become a vertical SaaS company in that industry — with paying customers and proven workflows already in hand.
Custom-software shops get valued on consulting multiples. Repeatable products get valued on SaaS multiples. The closer Arc moves along that progression, the more it's worth — and every custom deployment is funding the move while teaching you exactly which product to build.
The AI part, honestly
Arc is built with AI-assisted development, and that deserves a straight answer rather than a slogan.
The leverage is real: a scope that historically meant a $200k engagement over twelve months can be delivered for $25k–$50k in four to eight weeks. That's the mechanism that makes the price point possible. But the judgment stays human — architecture, scope discipline, integration debugging, customer discovery, and anything touching money or personally identifiable information are owned by a person, not generated and shipped unread. AI compresses the labor; it doesn't replace the engineering decisions. That's the part worth paying for, and it's the part that doesn't get cheaper.
No lock-in, on purpose
Arc is built with documented data export from day one. A customer who wants to leave can leave cleanly. That's not a weakness to hide — it's a selling point. Businesses that know they can walk are more comfortable committing, and a clean exit produces referrals instead of resentment.
The whole position sits in a gap that's real across a lot of industries: too small for enterprise ERP, too specific for generic SaaS, too important to keep running on spreadsheets and memory. The model works at single-operator scale today and compounds the moment a vertical is owned rather than chased.
Arc is available for demonstration. Technical documentation, API specifications, and full schema details are available under NDA.