ENGINEERING PROFAS / Application boundaries
One repository, separate applications and institutional backends
A small engineering team benefits from having the whole project in view. That does not require its website, business tools and institutional examination records to share a runtime or database.
In this article
Use the repository for context
PROFAS includes more than its examination workspace. There is a public website, a private business workspace and a research library, together with design documents, source provenance and delivery records. Keeping that material in one repository gives development a coherent view of the product and the decisions around it.
That context is particularly useful when working with agents. A recording change can be read alongside its design authority and handoff; a website statement can be checked against the actual implementation. The repository is a place to follow those connections directly, rather than reconstruct them from separate summaries.
The application boundary remains explicit. Each app owns its package and lockfile, dependencies, environment and deployment configuration. There is no root application package or shared runtime that every feature must pass through. The retained original fingerprint application remains a separate historical option rather than a dependency of the newer platform.
This arrangement accepts some duplication. A useful pattern may be deliberately ported into another application and owned there. That maintenance cost is preferable to a casual shared import that lets a change in one service alter the behaviour or release requirements of another.
Give every runtime an owner
The examination platform owns source material, observations, submitted stages and independent review. The website owns public content and selected product captures. It does not fetch examination records to render a marketing page, and a published screenshot does not provide a route into the examination backend.
The business workspace owns correspondence, contacts, projects, tasks and service records. It can record that an institution has a particular service and delivered release. That reference is useful operational context, but changing a service status does not provision a backend or grant access to the institution’s examinations.
The research library has another responsibility: searchable papers, source-linked reviews and attributable contributions. Its hosted database, private originals and access controls are independent of the examination and business systems. Local extraction and retained recovery assets have their own role without becoming a second live contribution authority.
These boundaries keep a request intelligible. Updating the public site means selecting its source, configuration and destination. It does not require a simultaneous examination release. A business feature does not need examination credentials merely because both products support the same organisation.
Shared source context, explicit runtime ownership
- Public website
Public content and selected captures; its own build and Worker.
- Examination platform
Source material, accepted records and review; separate institutional backend and app destinations.
- Business workspace
Mail, CRM and service references; no examination access from a service record.
- Research library
Source-linked reading and contributions; separate database, object storage and access controls.
Resolve the destination before sign-in
Institutional delivery introduces a different boundary from the separation between products. An institution receives the maintained examination interface against its own Convex backend, accounts, records and storage. Its frontend is built for an explicit address and instance configuration rather than letting a visitor choose a backend at runtime.
The instance manifest names the intended application origin, backend URLs, environment and enabled modules. The operator tooling checks their consistency and refuses institutional targets that reuse protected existing marketing, business or website resources. A deployment credential must match the backend selected by the manifest.
The frontend also checks the backend’s public instance identity before opening authentication. Its built configuration, current origin and returned identity must agree. This provides a deliberate destination check before credentials are used, rather than discovering a misdirected build after a person has begun work.
These are complementary controls. A build manifest makes the target reviewable; operator checks constrain execution; the runtime identity check catches a mismatch at the user boundary. None removes the need to select the right release and destination, but each makes that selection less dependent on an operator remembering a naming convention.
Separate institutional data deliberately
The reason for a separate institutional backend is straightforward: shared infrastructure convenience is a poor reason to couple examination records belonging to different institutions. Local accounts, invitations, agent grants and storage stay within the selected institutional service. A familiar email address does not establish cross-instance authority.
Within an institution, the ordinary resource and role checks still matter. A separate backend is not a replacement for ownership, source access or controlled disclosure. It sets the outer data boundary; the examination workflow establishes which person or agent can perform a particular action inside it.
The interface remains a maintained product, delivered as an identified release. Separately commissioned customer versions are possible, but they carry a maintenance decision rather than an assumption that every instance always runs identical code. Release identity and service history make that arrangement explicit.
Separation also creates work. Provisioning, configuration, upgrades, backup and recovery have to target the right instance repeatedly. Infrastructure operators may still have authorised access across resources. The design reduces shared data coupling; it does not claim that separate projects eliminate operator authority or establish a security certification.
Use narrow checks at real boundaries
A repository convention is useful only while changes continue to respect it. The architecture checker resolves imports within the selected application, rejects cross-app and private runtime imports, and flags recognised transport access from presentation components. It reports unsupported or unresolved constructs rather than treating them as established safe paths.
Those checks answer bounded source questions. They cannot infer a Convex relationship expressed as a string, prove a disclosure rule or establish that a release targets the right backend. The registered operation, its resource checks and its callers still need direct reading when behaviour changes.
Release work therefore remains explicit and application-specific. A Git push preserves source history; it does not deploy every product. Frontend configuration, backend changes and the selected destination belong to the owning application’s release procedure, with evidence reused when the checked artifact has not changed.
For a small team, this combination is practical: one place to understand the system, clear ownership where it runs and focused checks where a mistake would cross a boundary. The result is not an absence of operational responsibility. It is a structure in which that responsibility can be named and inspected.