Sell Licencearchimate:businessprocess

Turn an interested reader of the free version into a paying customer: they download the free build, pick a plan, pay online, and receive an invoice and a signed licence file. Every step is logged so the accountant sees the same sale the customer does. Runs without anyone at b9 Solutions touching it, which is the entire point — the business has one person and cannot staff a sales desk.

↗ View process diagram

Financial Administrationarchimate:capability

Licence Deliveryarchimate:applicationservice

What the paying customer gets: an encrypted, signed licence file in their inbox that replaces the free one and lifts the element cap to whatever they bought. Delivery is by mail rather than by download so the entitlement reaches the customer even when the purchase was made by someone else in their organisation.

Plan Checkoutarchimate:applicationservice

Shows the customer what each plan costs and how many elements it allows, takes their choice, and hands them to the payment provider. Named for what the customer does, not for what the portal does internally.

Software Downloadarchimate:applicationservice

Free and unconditional access to the ArchMeta build, licence file included. The capped free version is the trial: nothing is disabled, the repository simply cannot grow past 30 elements, so the customer evaluates the real product rather than a demonstration of it.

ArchMeta Billing Portalarchimate:applicationcomponent

The public web application b9 Solutions runs to sell ArchMeta without a salesperson in the loop: it hands out the free build, presents the plans, takes the customer through checkout and orchestrates everything that follows. It is the only component that observes the sale end to end, which is why the transaction log is its responsibility rather than the invoicing service's.

Licence Filearchimate:dataobject

The entitlement itself: a file dropped next to the ArchMeta installation that states the maximum number of elements the repository may hold. Encrypted and signed, so it can neither be read nor edited into a larger allowance. The free build ships with one capped at 30 elements; a purchase replaces it.

Transaction Loggingarchimate:applicationservice

Writes down every commercially meaningful event in a sale — plan chosen, payment captured, invoice raised, licence issued — in a form the accountant can post without asking b9 what happened. Consumed by the Record Transaction business process.

The Company Is Financially Sustainablemotivation:goal

Revenue arrives on time and the books are correct, so that the company can keep building the product. Getting paid and being able to prove what was paid are the same goal seen from two sides.

Accounting and Invoicing Toolchainarchimate:resource

The bookkeeping and invoicing tools the company runs on, plus the chart of accounts and templates behind them. Small enough that the whole finance function costs a few hours a month.

Issue Invoicearchimate:businessprocess

Turn delivered work or an active subscription period into an invoice, and send it to the customer with terms attached.

Collect Paymentarchimate:businessprocess

Reconcile the provider's settlements back to open invoices, resolve what does not match, and chase what is overdue or failed. The capture of funds itself is outsourced; what stays in-house is knowing which invoices a batched payout actually cleared.

↗ View process diagram

Record Transactionarchimate:businessprocess

Post every invoice raised, payment received and cost incurred to the ledger, against the right account and in the right period. Reads the invoice and payment records the company produces; writes the ledger.

Close Accounting Periodarchimate:businessprocess

Reconcile the ledger at period end, resolve what does not balance, and produce the period accounts in the form the tax authority requires.

ArchMetaarchimate:applicationcomponent

ArchMetac4:softwaresystem

A platform for managing architecture documentation as code. Architects describe their organisation in a textual DSL stored in Git; the Kernel reads that repository into an in-memory graph and serves it over REST, the Viewer authors it, and the Publisher turns it into a static site. There is no database — Git is the source of truth, and the same commit always produces the same model.

ArchMeta Deploymentarchimate:node

How ArchMeta is run. Everything below is a technology-layer reading of the containers above: images, the runtime that executes them, and the volumes that carry state. The product itself is stateless — all state is the mounted Git working tree.

CLIc4:container

The command surface: archmeta init scaffolds a repository with its metamodel profiles, archmeta load reports the model and its diagnostics, archmeta build generates the site, archmeta daemon serves the Kernel and the Viewer. The only entry point in a CI pipeline.

Diagram Renderc4:container

The rendering primitives both renderers share: geometry, element shapes, orthogonal routing, status styling, relationship chips and the link indicator. One implementation per render boundary is an enforced rule — a diagram must look the same on the canvas and on the published site, and the only way to guarantee that is to give them one function.

Generated Sitec4:container

The deliverable: static HTML, CSS and JavaScript with a prebuilt search index. No server, no database, no API — it can be served from object storage, a CDN, an nginx container or a filesystem, which is the point.

Grammarc4:container

The Langium grammars for .arch, .data, .view, .cascade and .metamodel, plus the generated parsers and TextMate syntaxes. Depends on nothing else in the product — deliberately, so the language can be reasoned about without the Kernel.

Kernelc4:container

Reads the repository into an in-memory graph and serves it over REST on port 7777. Never throws on model content: unresolved references, malformed attributes and rule violations become diagnostics, and the load always completes. A pure function of the repository — no clock, no randomness, no network during a load — so the same commit produces the same model and the same diagnostics forever.

Kernel Clientc4:container

The wire contract: the types crossing HTTP, and the predicates that must not be re-implemented on either side of it. Shared so the Viewer and the generated site cannot disagree about what a relationship means.

Publisherc4:container

Generates the static site from a loaded model: element pages, view pages with interactive SVG diagrams, the BPMN gallery and the search index. The output has no back end and carries no diagnostic data — what an architect needs to fix the model is not what a stakeholder should read.

Viewerc4:container

The single-screen React SPA that is the primary authoring tool: model canvas, BPMN modeler, Markdown editor and Explore in one shell, flanked by a management pane and a docked Inspector. Never reads the whole graph — every instance read is a point read, a search or a bounded neighbourhood — and never touches the filesystem. Edits stage; only a commit sends them to the Kernel.

Docker Enginearchimate:node

The container runtime, on the architect's workstation for authoring or on a build agent for CI. Composed by a docker-compose file that wires the Kernel to the model repository volume and the site container to the generated output.

Container Imagesarchimate:node

What is actually shipped. Multi-stage builds: the workspace is compiled once, then only the built output and production dependencies are copied into a slim runtime layer.

Volumesarchimate:node

The only state in the deployment. Both are bind mounts rather than named volumes, because the architect works on these directories with their own editor and Git client at the same time.

The Customer Owns the Repositorymotivation:goal

The architecture repository is the customer's asset outright — readable, portable and usable without ArchMeta in the loop.

Custom Development Capabilityarchimate:capability

Our customers have their own development capability. ArchMeta extends it, linking enterprise architecture concepts to the capability the customer already has.

Customer Use Architecturearchimate:businessprocess

The architecture repository becomes an asset in the life cycle of the company.

AI-Assisted Product Engineeringarchimate:capability

Model Repository Volumearchimate:node

The Git working tree holding the .arch, .data, .view, .cascade, .metamodel, .bpmn and .md files, mounted read-write so the Kernel can commit. This is the database, and it is a directory.

Site Output Volumearchimate:node

Where the Publisher writes the generated site and the site container reads it from. Disposable: it is derived entirely from the model repository at a given commit.

archmeta/kernelarchimate:technologycomponent

Multi-stage image on node:22-alpine. Build stage installs the npm workspace and compiles every package; the runtime stage carries the Kernel, the CLI and the Viewer bundle. Entry point is archmeta daemon; the model repository arrives as a mount, never baked in.

archmeta/sitearchimate:technologycomponent

nginx:alpine with the generated site copied into the web root. Built per model repository rather than per product release, because its content is the customer's architecture, not ArchMeta's code.

archmeta-build (job)archimate:node

A one-shot container that runs archmeta build and exits. This is the CI shape: check the repository out, build the site, publish the artifact, tear everything down. Nothing persists between runs, which is safe precisely because the load is a pure function of the commit.

archmeta-kernel (container)archimate:node

Runs the Kernel daemon, publishing port 7777 and serving the Viewer bundle alongside the API. Stateless: kill it and nothing is lost, because everything it knows was read from the mounted repository and everything it changed was committed back to it.

archmeta-site (container)archimate:node

An nginx image serving the generated static site. It has no connection to the Kernel and no back end of its own — once the site is built, this container is interchangeable with any static host.

Git Repositoryc4:externalsystem

The model repository: .arch, .data, .view, .cascade, .metamodel, .bpmn and .md files. This IS the database. The Kernel reads it on load and commits to it on write-back; it never pushes, never pulls and never branches, and is silently inert when the directory is not a Git working tree.

LLM (Claude)c4:externalsystem

Where .arch files come from in practice. The authoring loop is AI-first, which is why the DSL keeps uniform, predictable shapes a model can emit reliably and why the diagnostics and report files matter — they are the feedback channel back to the generator.

Architectarchimate:businessactor

Describes the organisation in the DSL, usually by generating .arch files with an LLM and then adjusting them in the Viewer. Reloads the Kernel and reads the diagnostics to find out whether what they meant is what they wrote. The Viewer's edit mode is for curation, not bulk authoring.

Cheaper Than Building Your Ownmotivation:goal

Adopting ArchMeta costs less than specifying, building, testing and maintaining an in-house equivalent — while holding a quality bar an in-house build would not reach.

Do-It-Yourself AI Buildsmotivation:driver

AI has made it feasible for a customer to build their own modelling application. Any EA product is now priced against that alternative, not against other vendors.

Customer Organisationmotivation:stakeholder

The organisation that adopts ArchMeta and whose architecture repository it holds. Cares that the repository remains its own asset.

The Repository Is Directly Usable by AImotivation:goal

An AI agent can read, reason over and edit the repository with no adapter, no API and no training specific to this product.