Log in
Internal engineering docs, generated from your code and synced to your wiki.

Self-updating internal docs. Never
lose engineering knowledge again.

Start free - takes 15 secondsSee what the docs look like
Code never storedAES-256 encryptedEU hosted (Frankfurt)DPA available

For product engineering teams

Internal docs that stay true to the code

Always up-to-date

Docs update automatically when code changes. No more stale documentation.

Faster onboarding

New engineers get productive faster with clear, structured, and searchable docs.

Prevent knowledge loss

Capture architecture, flows, and business logic before it lives in someone's head.

Understand the big picture

Auto-generated diagrams and dependency maps reveal your system architecture.

Save engineering time

Stop writing docs manually. Focus on building, not documenting.

Handoffs

Squad reorg or contractor wrap-up - the docs already exist, structured and current.

How it works

From code changes to docs in seconds

  1. Connect your repository

    Connect GitHub, GitLab, or Bitbucket.

  2. VizRepo scans & understands

    We analyze your code, structure, and dependencies.

  3. Docs are generated

    AI creates clear docs, diagrams, and references.

  4. Sync to your wiki

    Push to Notion, Confluence, or your internal wiki.

VizRepo documentation preview - module list on the left, generated section on the right.

What you get

Documentation written from the code, not from the file names

For every endpoint an AI agent reads the handler and everything it calls, then records what it does in plain language. Every file it cites is checked to exist in your repository. This is a real, shortened excerpt of VizRepo documenting its own backend.

DELETE/api/v1/auth/me

Lets a logged-in user permanently delete their own account, wiping every project they own and its related data, their team seats, and their Firebase identity.

Business rules

  • Only the authenticated user can delete their own account
  • Deleting the account cascades to every project the user owns and all its data
  • All account-level team seats the user owns are removed
  • The Firebase identity is deleted; if that fails, the deletion still proceeds

Errors

401Missing or invalid bearer token
404No user record for the authenticated caller

What happens

  1. Verify the caller's Firebase token and resolve the internal usersrc/common/middleware/auth.middleware.ts
  2. Find every project owned by the usersrc/modules/auth/auth.service.ts
  3. Delete each project with its diagrams, endpoints, scans, schemas, docs and git connectionsrc/modules/project/project.service.ts
  4. Remove all account-level team seats owned by this usersrc/modules/account-member/account-member.repository.ts
  5. Delete the user's Firebase Authentication accountsrc/modules/auth/auth.service.ts
  6. Delete the user record and respond with 204 No Contentsrc/modules/auth/auth.controller.ts

Writes

projectdeletethe project document itself
endpointdeleteall endpoints of each owned project
accountMemberdeletedelete-many by ownerId = user id
userdeletethe user document by id

External services: Firebase Authentication - delete the user's identity so they can no longer sign in.

Also generated per project: business logic overview, data-access matrix (which endpoint touches which table), user journeys, flow and sequence diagrams, onboarding, architecture and deployment sections.

Generate this for your own repo

Why it matters

Docs get outdated. We prevent that.

Without VizRepo

  • Swagger exists. But the service behaviour isn’t documented
  • A Confluence page nobody has touched in months
  • “Ask Mike, he knows how the payment flow works”
  • A new hire reading six-month-old docs on day one
  • “Where are our docs?” in every standup

With VizRepo

  • Always up-to-date - re-generated on every scan
  • Reflects what the code does, not what someone thought it did
  • Onboarding: 3 weeks → 3 days
  • Fewer knowledge-transfer meetings, more async answers
  • Outsourced and contractor teams get full context on day one

AST-parsed, not AI-guessed. Endpoints, schemas, and call graphs come from deterministic parsing of your source. AI writes the prose around verified facts. How we keep your code safe →

Notion
Confluence
GitHub Wiki
auto-refreshing
0manual updates needed
24/7docs stay current

Documentation that never goes stale

The biggest problem with documentation isn't writing it - it's keeping it current. Connect a webhook and VizRepo rescans on every push, syncing updated docs to every wiki you use - automatically, continuously, with no one remembering to press a button.

Azure Wiki
GitBook
SharePoint
checkout.ts
router.post('/checkout', async (req, res) => {
  const { cartId, userId } = req.body;

  const cart = await Cart.findById(cartId);
  if (!cart) throw NotFoundError();

  await inventory.reserve(cart.items);
  const order = await createOrder(cart, userId);
  await payment.charge(order.total);
  res.json({ orderId: order.id });
});
auto-generated diagram
Why teams trust us

Your code stays where it belongs.

VizRepo never stores your source. We pull, scan, and discard - keeping only the metadata that makes the docs work.

Code never stored

Each scan clones your repo to ephemeral storage, parses it, and deletes the working copy the moment it’s done. We retain only structural metadata - endpoints, schemas, diagram markup. No source code at rest, ever.

AES-256 encrypted

Access tokens for your Git provider, Notion, Confluence, and every other integration are encrypted at rest with AES-256-GCM. Decryption keys live in our secrets manager, never in the application database.

EU hosted (Frankfurt)

Our servers and database run in Frankfurt, Germany. Your repository is cloned there and deleted after each scan. To write the documentation, extracted code excerpts are sent to our AI model provider under a data processing agreement; they are not used to train models and are not retained by us. A DPA is available on Enterprise.

  • Read-only Git access by default - pushing docs into your repo is a per-project opt-in
  • No model training on your code, ever
  • Disconnect anytime - no lock-in
  • Minimal permissions requested
  • Private repositories fully supported
  • No shared data between customers
  • Analyzed only for what you requested
  • Sync manually after review, or turn on automatic sync per project
  • Encrypted in transit (TLS) and at rest
Read the full security overview

Built for product engineering teams of 10 to 200 people who run more than one service.

100%of cited files verified against your repo
Everyendpoint documented by reading its code
0 creditsfor unchanged endpoints on a rescan

The next time someone asks “where are the docs?” - you'll have an answer.

Connect your repo once. Every scan reads the code behind each endpoint and rewrites the internal docs your team actually opens.

Start free - takes 15 secondsAlready have an account? Log in