Technical Architecture

01 Architecture philosophy

This document is the engineering-diligence companion to the investment memo. It exists to answer the technical questions an investor raises after the strategic ones: how is the product actually built, what is replicable, what is not, and where does the moat live in code. The product is one diagnostic on the surface, three layers of moat underneath. The decisions below trace directly to that architecture.

Five principles govern every implementation choice.

02 Stack

The stack is selected for shipping velocity in a single-founder window, with no bets that lock the company into a vendor. Every layer is replaceable with two days of plumbing work. The architectural decisions that matter (the three substrates, the scoring engine, the trace contract) live in the application code, not the infrastructure.

The monorepo enforces three packages with strict boundaries. shared imports nothing (pure TypeScript leaf). core imports only shared. web (Next.js) imports core, shared, and local lib. Client components never import from core. The boundary keeps native binaries out of the client bundle and keeps the type surface clean.

03 Three-substrate architecture

The three substrates are the technical expression of the moat. Each on its own is replicable. Fused, they produce a diagnostic that no single-substrate competitor can match.

The 54-provider count is not aspirational. The credential taxonomy below shows how the work splits across authentication patterns, and what is shippable inside the seed runway versus what waits for additional engineering.

The admin-handoff flow matters. Buyers without admin access (the senior PM persona is rarely the org admin) need a path that does not require a tap on the shoulder of someone in IT. The magic-link grant with scope-preview verify removes that friction. It is shipped, not aspirational.

Cross-source signals

The three substrates do not sit beside each other inertly. cross-source-signals.ts exports feedback_to_feature_lineage, a pure-logic compute that links feedback signals (from Linear comments, Slack messages, support tickets) to feature signals (from GitHub commits, Linear issues, deploy events). The compute uses a conservative substring-keyword heuristic, which is the right starting point for v1. Better signal-linkage models can replace the heuristic without changing the consumer surface, because the lineage primitive lives behind a typed interface.

The lineage compute is the technical proof point that fusion is not a slide. It is a function in core. Outputs from it feed the Translation Gap pattern detector, which is the first cross-substrate pattern shipped to production.

04 Scoring engine

The scoring engine is the production load. Three frameworks, 88 dimensions, all routed through the trace contract. Composite stage ladder uses verb forms (locked April 2026): React, Augment, Orchestrate, Lead, Compound. Per-framework stages are locked separately under Path C+ (Foundation/Building/Scaling/Leading/Compounding for Team Operations, Specify/Context/Orchestrate/Validate/Ship/Compound for Development Lifecycle, Wrapper/Augmented/Integrated/Native/Compounding for Product Assessment).

Scoring pipeline

Six steps, each independently testable, each captured in a trace.

Pattern detection

Pattern detection runs continuously, not as a separate pass. Three patterns are live in production. Translation Gap (high efficiency, low impact). Fragility Signal (engineering velocity outpacing product validation). Compound Ready (the team configuration that compounds rather than churns). A pattern-discovery candidate queue stores co-occurrences across 88 dimensions by archetype by outcome data, so new patterns surface from real customer telemetry rather than from a whiteboard. Realistic ceiling per current customer base: 8 patterns by Q4 2026, 12+ by Q2 2027 with growth.

05 The three-layer moat (technical view)

The investment memo describes the moat as a stack. Here is the same stack from the code side. Each layer corresponds to a code surface. None of the three is the product on its own. The composition is the product.

The reason platforms (Jira, Linear, Amplitude) cannot replicate this is not the surface. They can ship a scoring dashboard. They cannot ship the calibration pipeline, because the pipeline requires outcome telemetry from a continuously scored customer base. Without the engine, the surface is just another feature card. With it, the surface is a moat.

06 LLM observability contract

Observability is the foundation. Without it, the eval loop breaks, prompt drift goes undetected, and outcome attribution is impossible. The contract is non-negotiable.

The llm_traces table is the single source of truth for every production LLM call. The captureTrace() helper wraps every call site. It never throws, so it is safe to call from any code path including error handlers. It captures user, product, account, call type, model, provider, input and output tokens, latency, prompt text, and response JSON. Both success and failure paths are wrapped, because error traces are how prompt drift is debugged.

Call types tracked

• dac_chat
• dac_structured
• score
• pa_assessment
• lifecycle
• judge
• public_web_extract
• slack_classify
• milestone
• other

Adding a new call type requires extending the CallType union in packages/core/src/telemetry/llm-traces.ts. The other literal exists as a fallback and is flagged in review if it shows up in production traffic.

Outcome chain

traceId flows through the system end-to-end. When a coaching response is delivered, the traceId is passed to saveRecommendationFeedback. When a score is recorded, results.trace_id ties the score row to the LLM call that produced it. computeTraceOutcome() in packages/core/src/intelligence/trace-outcome.ts joins trace, feedback, and score-delta into a single computed view, used in dashboard aggregates and (eventually) in calibration reports.

Eval framework

16 categories, 75+ checks. Categories 15 (golden fixtures) and 16 (LLM-as-judge) gate coaching quality. The golden fixture set lives at packages/core/src/eval/golden-fixtures.ts. When the DAC system prompt changes, the judge cache must be refreshed before shipping (scripts/refresh-judge-cache.ts). The refreshed cache is committed alongside the prompt change. Adding a new primitive type requires adding at least one fixture that exercises it. Nightly cron caps at 50 judgments per day, capping eval cost at roughly $1/day max.

Privacy posture: full prompt text is stored for replay (not just a hash), to match the results table's treatment of crawled content. Clerk tokens, API keys, and secret material are never logged. If a field is suspect, it is redacted before captureTrace is invoked. Scope is per tenant boundary by product_id and account_id, the same boundary that scores follow.

07 Integration architecture

The integration architecture is the technical expression of the operational substrate. The contract is the ProviderAdapter interface in packages/core. Every provider implements it. The scoring engine never sees a provider identity, only a normalized signal type.

Sync architecture

Two sync paths, both feeding the same upsert flow.

• Manual. POST /api/integrations/[provider]/sync. Used during onboarding, debugging, and on-demand re-scoring.
• Automated. Vercel Cron daily at 6am. The path of record for ongoing customer signal capture.

Flow

Inside both paths, the same six-step flow runs.

1. Load config (credentials, scopes, last sync cursor).
2. Call adapter (provider-specific REST or GraphQL fetch).
3. Normalize signals (provider response into the SIGNAL_TYPES taxonomy).
4. Upsert (deduplicated, idempotent, rolled into the tenant boundary).
5. Recompute metrics (dimension scoring runs against the updated signal set).
6. Log (structured log lines, error capture in Sentry, trace if LLM calls fired).

Signal taxonomy

SIGNAL_TYPES contains roughly 178 predefined signal types, grouped into 11 categories surfaced in the /signals catalog. SIGNAL_DIMENSION_MAP holds roughly 347 entries mapping signal_type to the 27 Team Operations dimensions (the historical foundation, with extensions for Development Lifecycle and Product Assessment). Eight orphan signal types (not mapped to any dimension) are flagged inline and exported as ORPHAN_SIGNAL_TYPES. The taxonomy is the contract that lets the scoring engine stay provider-agnostic.

Scaling path

Today: direct REST and GraphQL adapters. Phase 1 GA-live with GitHub and Linear. Sufficient for the seed window. Future: Nango (open-source, 700+ APIs, TypeScript-first, MCP-ready) when adapter expansion outpaces direct implementation. Never Tray.io or Workato (overkill, not engineering-grade), never Fivetran or Airbyte (warehouse-focused, wrong shape for real-time scoring). Provider notes worth flagging. Attio has an official MCP server with 35+ tools (integration is direct, not adapter-style). Jellyfish exposes a public API including DORA metrics. LinearB requires a business conversation for API access. Dotwork is MCP-native and a partner, not a competitor.

08 AI cost model

Inference is in COGS, not opex. The cost discipline below is the reason blended margin holds at 78-82% today and projects to 92%+ post fine-tune.

COGS per score

A full diagnostic across 88 dimensions costs roughly $0.17. The breakdown:

Cost discipline

Prompt caching is applied to signal bundles, which is where the bulk of the inference cost lives. Repeated scoring against substantially similar signal contexts hits cache, dropping the marginal cost meaningfully on subsequent runs. Batch API is used for overnight scoring runs and full golden-fixture eval refreshes, which produces another step-down in unit cost on background workloads. Files API ingests board decks and research PDFs without re-tokenizing on every reference.

The pattern-discovery pipeline runs against snapshots, not live LLM calls. This is the architectural reason calibration costs scale sub-linearly with customer count. Adding the 1,000th customer does not 1,000x the calibration spend, because calibration reads the trace and outcome tables and runs the discovery analytics offline.

Fine-tuning at the 2,000-customer inflection

At roughly 2,000 customers, fine-tuning becomes economically rational. One-time cost: $50K-$100K. Payback: 3-6 months. Post-tune blended margin moves to 92%+. The fine-tune is on the scoring path specifically, where the prompt is tightest and the input distribution is most stable. The coaching path stays on frontier inference, because coaching benefits more from frontier capability than from cost optimization.

Eval cost

The eval loop has its own cost budget, kept inside a tight envelope. Roughly $1.20 per full golden-set refresh. Roughly $0.02 per prod sample. Nightly cron caps at 50 judgments. Roughly $1/day max. The eval loop is the foundation of every other quality investment, and the cost is well below the threshold where sampling at capture time would be needed.

09 Distribution surfaces

Distribution is a technical decision before it is a marketing one. The surfaces below are the API into Dacard from every relevant agentic-era endpoint.

Battery thesis

Battery Ventures published the agent-skills-are-the-new-SDK thesis in April 2026. Neon hit 80 percent agent-originated provisioning before its $1B Databricks acquisition. The thesis is that agent skills, distributed via git repos and discoverable inside coding-agent surfaces, will become the dominant integration surface for B2B SaaS. Dacard's agent skill is shipped today, well before the wave crests. Plan: 30 percent agent-originated by Q4 2027. If 30 percent misses, the GTM falls back to inside-sales motion at Business and PLG at Pro (both vectors tested).

10 Security posture

Security is treated as a 0-to-1 deliverable, not a Series A item. The founder shipped SOC 2 at Lexful in February 2026, so the playbook is recent and the muscle is current.

• SOC 2 Type II in motion. Plan target inside the seed window. Recency-and-rigor proof from Lexful informs the program.
• Tenant boundary. product_id plus account_id (nullable) on every row. User data follows the same boundary as scores. The boundary is not inferred from query context, it is explicit on the row.
• LLM trace privacy. Scoped by tenant boundary. Full prompt text is stored for replay (not just a hash), matching the results table's treatment of crawled content. Replay is a quality-engineering requirement, not a privacy compromise, because the boundary holds.
• Secrets. Clerk tokens, API keys, and secret material are never logged in promptText or requestJson. Suspect fields are redacted at capture time, before captureTrace is invoked.
• Auth surface. Clerk handles SSO and multi-tenant. The founder is not maintaining an auth layer, which removes a class of common security regressions.

The privacy posture is documented in the observability rule and is part of the eval contract. It is enforced in code review, not by policy alone.

11 Roadmap

The technical roadmap maps to fundraise milestones, not to feature trees. The two anchors are the seed-extension or pre-A close (Q4 2026) and the Series A close (Q2-Q3 2027).

Now to Q4 2026

• Slack adapter (the largest substrate unlock unbuilt). Tribal knowledge gets a real ingestion path.
• Claude Code plugin. Slash commands and skills packaged for the surface that is closest to the buyer's daily flow.
• Public live-scorecard share. Marketing-grade share surface for the diagnostic.
• First pattern-validity report. The empirical artifact that makes the calibration pipeline visible to investors and customers.

Q4 2026 to Q3 2027

• Archetype calibration. Pattern weights conditioned on archetype rather than on a global average.
• Fine-tuning at the 2,000-customer inflection. $50K-$100K one-time, 3-6 month payback, post-tune margin 92%+.
• Additional pattern surfacing. Realistic ceiling: 8 patterns by Q4 2026, 12+ by Q2 2027 with growth.
• Public quarterly validity reports. The Series A pitch is the layered moat backed by published reports.

Beyond Series A

• Portfolio view. Multi-product diagnostics for VC firms and multi-product enterprises.
• Custom benchmarks. Enterprise-tier comparative scoring across portfolios and peers.
• Programmatic platform. Dacard as a platform other tools build on top of, not just a destination customers visit.

12 Closing notes

Three engineering takeaways for diligence readers.

1. The moat is in code. Pattern Library lives in packages/core. Ranked Actions lives in packages/shared. Calibration Pipeline plan lives at plans/pattern-discovery-instrumentation.md. None of this is a slide.
2. The trace contract is the foundation. Every quality investment downstream (eval loop, calibration pipeline, outcome attribution, prompt-drift debugging) compounds on top of llm_traces. The contract is enforced in code review.
3. The cost curve bends down. Inference is in COGS. Prompt caching, Batch API, and the snapshot-based calibration pipeline produce sub-linear cost scaling. Fine-tuning at the 2,000-customer inflection moves blended margin to 92%+.

Companion documents: the investment memo (investor-memo.html) for the strategic thesis, the model document (investor-model.html) for full unit economics and the milestone-by-milestone build plan, and the appendix (investor-appendix.html) for additional reference material.

Engineering questions? Reach out to darren@dacard.ai.