Viewpoint Mapping

This page cross-references the four architectural viewpoints — Context, Functional, Sources/Development, and Artifacts — and connects them to the Runtime. It is the primary navigation aid for a developer who wants to move from a functional concept to the code that implements it, or from a running component back to its source and design.

For definitions of the viewpoints themselves, see Design Framework.

Functional to Source Mapping

Each row identifies a functional domain and module, the repository that owns the implementation, and the relevant source path within that repository. Paths follow the Kotlin package convention src/main/kotlin/cards/arda/….

Functional Domain	Module	Repository	Source Path
System — Identity and Access	User Account, Tenant, Invitation	`accounts-component`	`src/main/kotlin/cards/arda/accounts/system/`
System — Identity and Access	Domain model (cross-repo)	`accounts-component`	`src/main/kotlin/cards/arda/domain/`
Reference Data	Items	`operations`	`src/main/kotlin/cards/arda/operations/reference/item/`
Reference Data	Business Affiliates	`operations`	`src/main/kotlin/cards/arda/operations/reference/businessaffiliates/`
Resources	Kanban Cards	`operations`	`src/main/kotlin/cards/arda/operations/resources/kanban/`
Resources	Facilities	`operations`	`src/main/kotlin/cards/arda/operations/resources/facility/`
Resources	Stations	`operations`	`src/main/kotlin/cards/arda/operations/resources/station/`
Procurement	Purchase Orders	`operations`	`src/main/kotlin/cards/arda/operations/procurement/orders/`
System — Batch Operations	CSV Upload	`operations`	`src/main/kotlin/cards/arda/operations/system/batch/`
System — Shop Access	PDF / Label Rendering	`operations`	`src/main/kotlin/cards/arda/operations/shopaccess/pdfrender/`
Application — Frontend Shell	Next.js App Router pages	`arda-frontend-app`	`src/app/`
General — UI Components	Storybook component library	`ux-prototype`	`src/components/`
—	Shared Kotlin library	`common-module`	`lib/src/main/kotlin/cards/arda/common/lib/`
—	Cloud infrastructure (CDK)	`infrastructure`	`src/main/cdk/`
—	Protobuf schema contracts	`system-proto`	See repository README
—	Database initialization	`postgres-database-initializer`	See repository README

Notes

The operations repository is a monolithic Ktor service. Its internal package structure mirrors the functional decomposition: reference/, resources/, procurement/, system/, and shopaccess/.
The accounts-component repository separates runtime entry points (accounts/runtime/) from domain logic (accounts/system/) and a cross-cutting domain model (domain/).
The common-module library is not a functional domain. It provides the shared implementation substrate — bitemporal persistence, service layer, API layer, error handling — that all backend services depend on.

Source to Artifact Mapping

Repository	Language / Build Tool	Artifact Type	Registry
`operations`	Kotlin / Gradle	Docker image + Helm chart	GitHub Packages (GHCR + Helm OCI)
`accounts-component`	Kotlin / Gradle	Docker image + Helm chart	GitHub Packages (GHCR + Helm OCI)
`postgres-database-initializer`	SQL / Docker	Docker image	GitHub Packages (GHCR)
`common-module`	Kotlin / Gradle	Gradle library (jar)	GitHub Packages (Maven)
`arda-frontend-app`	TypeScript / Next.js	Next.js application	AWS Amplify (deployed directly)
`ux-prototype`	TypeScript / Vite	npm package (`@arda-cards/ui-components`)	GitHub Packages (npm)
`infrastructure`	TypeScript / AWS CDK v2	CDK application	Deployed via `cdk deploy` (no registry)
`system-proto`	Protobuf	Generated stubs (jar / npm)	GitHub Packages (Maven / npm)
`api-test`	TypeScript / Bruno	Test collections	Not published; run locally or in CI

Artifact to Runtime Mapping

The Runtime Platform uses a five-level containment hierarchy: Root Services, Infrastructure, Partition, Component, Resource. See Platform Structure for definitions.

Artifact	Runtime Level	Component / Partition	Infrastructure	Notes
`operations` Docker image	Component (Helm chart)	`operations` component	Alpha002 (dev/stage/demo), Alpha001 (prod)	Deployed as an EKS pod via Helm
`accounts-component` Docker image	Component (Helm chart)	`accounts` component	Alpha002 / Alpha001	Deployed as an EKS pod via Helm
`postgres-database-initializer` Docker image	Component (init job)	Per-partition DB initialization	Alpha002 / Alpha001	Run as a Kubernetes Job on deploy
`arda-frontend-app` Next.js app	Component	Amplify hosting	AWS Amplify (per partition URL)	Deployed via `amplify publish`; no EKS involvement
CDK stacks (`infrastructure`)	Infrastructure + Partition + Root	VPC, EKS, RDS, S3, Cognito, API Gateway, Amplify	Alpha002 / Alpha001	`cdk deploy` synthesizes CloudFormation and applies it

Environment Naming

Following the FQN convention from Platform Structure: {Infrastructure}-{Partition}. Examples:

Alpha002-dev — active development and integration testing
Alpha002-staging — pre-production validation
Alpha002-demo — customer demonstrations
Alpha001-prod — live production (revenue-generating)

The table below shows the entry point in each viewpoint for the main system capabilities.

Capability	Context viewpoint	Functional viewpoint	Source viewpoint	Artifact viewpoint	Runtime viewpoint
Identity and access	Personas	System domain	`accounts-component`	GHCR image + Helm chart	`accounts` component
Reference data (items, affiliates)	Tenant data API	Reference Data domain	`operations` `reference/`	GHCR image + Helm chart	`operations` component
Kanban card lifecycle	Shop operator flows	Resources domain	`operations` `resources/kanban/`	GHCR image + Helm chart	`operations` component
Purchase orders	Procurement API	Procurement domain	`operations` `procurement/orders/`	GHCR image + Helm chart	`operations` component
Frontend application	Browser / mobile	—	`arda-frontend-app` `src/app/`	Amplify deployment	AWS Amplify
UI component library	—	—	`ux-prototype` `src/components/`	npm package	`arda-frontend-app` dependency
Cloud infrastructure	AWS	—	`infrastructure` `src/main/cdk/`	CDK application	CloudFormation stacks

Design Framework — Definitions of all viewpoints and their key concepts.
Repository Catalog — Full repository list with descriptions.
Platform Structure — Runtime hierarchy, naming conventions, and environment model.
Functional Overview — Functional decomposition of the system into domains and modules.