Vectros vs. rolling your own
You can build all of this. Then you own all of it.
A vector DB, a separate records database, a sync pipeline between them, hand-authored tenant isolation, an embedding job, an audit trail you keep compliant. Every alternative hands you that pile — and then hands you the pager. The real cost is operational burden and risk, not a week of coding.
Start lean. Scale to compliance-grade without re-platforming.
The question isn’t whether you can assemble it. It’s what it costs to run for the next three years — and what happens the day your first real customer asks, “Is my data isolated, and can you prove it?”
The two bad trades
Every alternative forces one of two bad trades.
One is cheap to start and operationally expensive forever. The other is compliant, but only after an enterprise jump or a re-platform.
Trade 1 — Cheap to start, but you assemble and operate the security yourself
A bare vector DB, a general-purpose backend-as-a-service, a roll-your-own RAG stack: the entry price is low because you’re only renting the parts. Typed records, hybrid search, per-tenant isolation, an embedding pipeline, and an audit trail are separate things you wire together — and then operate forever. The dev-time cost everyone quotes is the smaller half. The real bill is operational.
- Glue that breaks quietly. A sync pipeline between your database and your vector index drifts. A record updates; its embedding doesn’t. Search returns stale or missing hits, and nothing throws an error — you own a background job whose failure mode is silent wrongness.
- The security surface you’re least equipped to get right. Tenant isolation hand-authored as row-level rules is one forgotten WHERE clause away from showing Customer A’s data to Customer B. You carry that risk on every new query, every refactor, every junior PR, for the life of the product.
- Re-running the parts. Re-embed when you change models. Reconcile the index when the pipeline hiccups. Prove isolation still holds after each schema change. This is operating cost, not build cost — and it never amortizes to zero.
- Three systems, none of them the product. A vector index is not your source of truth. Accept that, and you’ve signed up to run a database, an index, and the pipeline between them — one of them load-bearing for correctness.
Trade 2 — Compliant, but it arrives as an enterprise jump or a re-platform
The other class of tool gets you started cheaply too — until you land the customer who needs isolation, audit history, or a Business Associate Agreement. Then one of two things happens, and the cheap start hits a compliance wall that turns out to be a cliff.
- The price steps to an enterprise tier, and the controls you suddenly need are gated behind a plan built for a different company than the one you are.
- The layer you chose was never eligible for the regulated workload, so the auth or realtime piece can’t be covered — you rip it out and re-platform. Usually mid-flight. Usually with that first real customer watching.
- You don’t grow across the wall. You rebuild on the far side of it.
The real total cost
Operational burden and risk — not a week of coding.
The honest pitch isn’t “we save you a week of setup.” Anyone can stand up the pieces. The cost that matters is what you carry afterward — operating them, and proving they still hold, for the life of the product.
The back-end is the easy demo and the six-month nightmare. Vectros is the layer you don’t operate. The common case — store content, retrieve it, ground a model on it, isolated per customer, audited when you turn it on — is minutes instead of months. And it stays minutes, because the operating cost is ours, not yours.
The Vectros answer
One model. Structural isolation. Built-in RAG. Grown-into compliance.
One declared data model, not four systems to sync
Declare your record schemas once — fields, validation, references, search indexing, sensitivity. From that one model you get typed records, document ingest, and hybrid search over a unified records-and-documents index. There’s no separate vector DB to stand up and no sync pipeline to keep from drifting, because search and your source of truth are the same thing. Every write to an audited type accrues an immutable version, with optimistic concurrency.
Isolation as a platform property, not a WHERE clause
Per-customer isolation is structural — shaped by the data model and the data-access API, not a row-level rule a future change can quietly regress. Each application context is a fail-closed partition derived from the credential, never defaulting to a wildcard. Probe with another tenant’s id and you get exactly the same “not found” you’d get for an invented id. Hybrid search inherits the boundary, and filter inputs are allow-list validated.
Grounded RAG and in-perimeter inference, built in
Citation-grounded retrieval ships as the product, not a framework you assemble and maintain. Vectros runs the search, emits the matched results as a citation event before any text is generated, then streams the answer grounded on those results — so your UI can show exactly what it was built on. The model runs against AWS-hosted models from inside the Vectros AWS account: a prompt and its retrieved passages don’t cross out to a third-party model vendor’s API.
MCP-native — agent memory safe to point at customer data
Vectros ships an MCP server with twenty-one data-plane tools, so an agent can read and write your Vectros data directly over the Model Context Protocol — multi-tenant, isolated, scoped-key, auditable, hosted. Not a single-user local SQLite or pgvector memory toy on your laptop. By design, the agent surface exposes Vectros data-plane tools only — no web-search or external-fetch tools. Nothing auto-scrapes.
Grow into compliance
Grow into compliance — without re-platforming.
Compliance is a peak of the capability surface, not a tax on the entry price. The always-on substrate — per-customer isolation, encryption at rest, scope enforcement, edge security — is identical on every tier. You reach up into the regulated controls only when a customer makes them necessary, on the same platform, with no rewrite.
- Tamper-evident audit and version history — each retained record participates in a SHA-256 state-continuity chain, so an out-of-band modification to stored history is detectable. (Tamper-evident, not tamper-proof.)
- Three distinct sensitive-data mechanisms — sensitive fields are destroyed before they’re persisted to history (not reversibly masked — destroyed), masked on read unless the token carries the reveal scope, and excluded from the search index entirely.
- Per-customer and per-context hard-delete — decommissioning a customer’s context or an entire tenant runs a real owner-filtered cascade.
- Hardened through extensive adversarial security review.
Compliance specifics — Business Associate Agreement scope, attestation status — are available under NDA.
At a glance
The pattern each class of tool forces.
| Roll-your-own | Generic backend-as-a-service | Bare vector DB | Vectros | |
|---|---|---|---|---|
| Typed records + validation | You build it | Often, but separate from search | No — index only | One declared model |
| Hybrid search over your data | You wire DB + index + sync | Add-on or separate index | Vectors only; not your source of truth | One call over records + documents |
| Per-customer isolation | Hand-authored WHERE clauses | Row-level rules you author | Your responsibility | Structural, fail-closed platform property |
| Audit + version history when needed | You build and keep compliant | Rarely | No | Tamper-evident, on by default for audited types |
| Grounded RAG with citations | Assemble + maintain a framework | DIY | DIY on top | Built in, citations before generation |
| In-perimeter inference | You operate the path | Typically third-party model API | N/A | Partner data plane runs in-perimeter |
| Ops burden | Yours, forever | Partial; glue is yours | High — index + pipeline | The layer you don’t operate |
| Compliance path | Build it all, prove it all | Enterprise jump or ineligible layer | N/A | Grow into it — no re-platform |
Competitor columns describe the pattern each class of tool forces, not any one vendor’s specifics or pricing.
Start on the back-end you won’t outgrow
What it costs is what you turn on.
The cost story is architecture, not a billing promise. You only pay for the capabilities you turn on — turn off embedding on a record type and there’s no vector cost on it at all. An isolated per-customer index means you don’t pay for other tenants’ scale, and cost tracks the work you do. The same isolation that keeps it affordable at the bottom is what makes it defensible at the top.
For the tier shape and credit model, see the pricing page.
You can assemble the cheap version and operate it forever. You can buy the compliant version and re-platform into it later. Or you can start on the one back-end that begins at side-project scale and reaches regulated scale without changing platforms.
Start lean. Scale to compliance-grade without re-platforming.
Self-serve and a free tier are on the way as we open access. For now, the preview is invite-only.