A service website explains what a company can deliver. An operational platform has to translate that explanation into requirements, decisions, permissions, and actions that affect real systems. H-DCS is my ongoing work at that boundary.
The project combines a .NET 10 Blazor web application with service catalogs, customer requirement sheets, internal quoting, account workflows, storage, VPN management, device agents, communication, and usage accounting. The challenge is making those capabilities understandable and controllable while keeping a public information site safe to operate.
This article is based on a review of the working tree, tests, and deployment records on 4 November 2026. It describes an actively developed system, including work that is not enabled publicly. The latest operational records describe an informational-only foundation deployment; they do not establish general availability of customer accounts, provisioning, payments, or remote-control features.
Start with the service workflow
The original business problem is straightforward: a request for “hosting,” “a cluster,” or “an integration” rarely contains enough information to estimate or deliver the work.
H-DCS organizes services into a catalog with structured questions. A customer-facing requirement workflow can collect answers, urgency, budget context, and supporting attachments. The administrative side can review that information and develop a quote.
The quote calculator is deliberately an internal heuristic. Its current implementation starts from a service category, adjusts for populated answers and signals such as high availability or urgency, and returns price and timeline ranges. It is not evidence of a statistically calibrated pricing model, and its output is not a binding customer quotation.
That separation matters. A useful intake system should help an engineer ask better questions and make consistent decisions. It should not disguise an initial estimate as certainty.
The broader platform explores what happens after that conversation: establishing an account, granting access to a service, enrolling a device, exposing storage, and tracking resource usage. These are distinct workflows, even when they appear inside the same portal.
A modular application with explicit integration boundaries
The web application uses Blazor server rendering and interactive server components. EF Core persists application state in PostgreSQL. ASP.NET Core Identity provides account infrastructure, with optional OpenID Connect integration. Dedicated services handle business rules and external systems.
| Area | Main responsibility | Important boundary |
|---|---|---|
| Public and portal UI | Service presentation, requirements, customer and admin pages | A visible navigation item is not authorization |
| Application services | Catalog rules, estimates, leads, files, device commands, accounting | Business rules remain separate from page orchestration |
| PostgreSQL and EF Core | Accounts, workflow records, device state, ledger and metadata | Runtime access and schema changes have different privileges |
| Storage integrations | Attachments, profile assets, documents, remote files | Stored bytes, metadata, paths, and access checks need separate handling |
| Infrastructure adapters | Mail directories, VPN provisioning, identity services, host operations | An application request can have real external consequences |
| Agents and workers | Device polling, reconciliation, scheduled accounting and other background work | Activation is explicit and environment-dependent |
This is best understood as a modular application with integration adapters, rather than a collection of independently deployed business microservices. The source has clear service and domain areas, but the main web application still composes a substantial amount of behavior in its startup and endpoint configuration.
That choice makes it practical to evolve shared workflows. It also makes deployment modes, configuration review, and regression testing essential: a new service registration must not accidentally activate a worker or external integration in an environment that should remain informational.
Foundation mode is a deployment boundary
One of the most important design decisions is to separate the broader platform from the functionality currently exposed on the public site.
Foundation mode restricts the application to an allowlist of informational pages, selected assets, language controls, health endpoints, and the Blazor transport required by the public experience. Account, administrative, submission, storage, payment, and provisioning paths are blocked server-side.
The restriction also applies to component navigation inside an existing Blazor circuit. Hiding links would be insufficient: a user can request a URL directly, and interactive navigation does not always behave like a fresh HTTP page load.
Startup reinforces the boundary by disabling operational workers and external features, disabling email delivery, and clearing account-seeding and external-login configuration for that mode. Regression tests check rejected routes as well as the public pages, fingerprinted assets, and interactive transport that must continue to work.
The lesson is that a reduced deployment should be an enforced operating mode, not a smaller menu. It needs both negative tests—what must remain inaccessible—and positive tests—what the public site still needs to render and navigate correctly.
Infrastructure automation should require deliberate activation
The repository’s development setup disables external machine operations. Starting the web application locally should not provision an account, alter a VPN, create an object-storage bucket, send real email, or begin charging usage.
The checked-in configuration and dedicated tests encode disabled defaults. Some operations require both a parent external-operations gate and a feature-specific gate. This makes a missing setting a refusal to act rather than an implicit permission.
This is also where documentation needs continuous review. An older accounting document describes a charging default that the newer configuration safety tests explicitly reject. For current behavior, I need to inspect the startup path, deployed mode, and actual configuration contract together. An old setup example cannot override them.
The same reasoning applies to staging. Disabling foundation mode to exercise account workflows is not enough to create an isolated test environment. The authentication-readiness plan calls for separate database credentials, key storage, test identity-provider configuration, captured email, and disabled external integrations.
One flag can select a workflow; it cannot prove isolation from production dependencies.
Device management without a general remote shell
The Linux agent illustrates how the platform extends beyond the browser. Its design is a headless system service, with a one-time enrollment workflow and ongoing controls exposed through the portal’s Devices page.
The agent polls outward for work. The server checks both a per-device credential and the assigned VPN source address. Commands come from a fixed allowlist, and the enrollment profile is typed data rather than an arbitrary shell script. A separate privileged helper handles the integration work that requires elevation.
This creates several useful boundaries: the portal does not need an inbound management listener on every workstation; device identity is not reduced to a friendly display name; and a button in the web UI does not become a general command-execution interface.
The associated storage and media workflows still have their own platform dependencies and acceptance requirements. A passing enrollment-profile test cannot prove that every workstation’s VPN, filesystem mount, audio stack, or camera behaves correctly.
The design lesson is to make authority narrow before making automation convenient.
Accounting needs traceability as well as arithmetic
The accounting subsystem models usage, credit accounts, ledger entries, payment-related records, and background reconciliation. Resource measurements are grouped into hourly buckets, with separate treatment for CPU time, memory, stored data, and VPN traffic.
The ledger records a delta, the resulting balance, a reason, and links to the originating usage or payment record. Where a source type and identifier are supplied, the service checks for an existing entry before adding another. This supports repeatable processing, though the presence of that check alone is not a proof of concurrency safety under every possible transaction schedule.
Historical pricing is also a modeling concern: changing a current price should not reinterpret work already measured under an earlier one. The documented approach adds effective-dated price records instead of silently rewriting the meaning of past usage.
These structures help distinguish “what is the balance?” from “why is the balance this value?” That distinction is essential for debugging reconciliation and explaining adjustments. It does not imply that charging or payment collection is enabled in the public foundation deployment.
Schema initialization and runtime operation are different jobs
Development convenience often favors applying migrations during startup. Production needs a more deliberate contract, especially when historical migrations contain destructive transitions.
The deployment initializer in this project is explicitly for an empty database. It requires foundation mode, checks for existing application tables, and refuses to continue when they are present. It creates the current model and records a migration baseline rather than replaying the historical sequence against existing data.
That is a narrowly scoped bootstrap path, not a general migration strategy or an upgrade mechanism for an established database.
Deployment records describe separate runtime and initialization privileges, disabled startup initialization on application nodes, and retained snapshots. The useful principle is broader than the particular bootstrap implementation: serving a page should not require permission to redesign its database.
Multi-region deployment makes state visible
The foundation rollout records describe application nodes in Frankfurt, Virginia, and Sydney, with proxy health checks, affinity for server-side interaction, shared application key material, and a PostgreSQL dependency.
Blazor’s interactive server model makes routing continuity significant. A load-balanced HTML response and an ongoing interactive session are different operational cases. Shared Data Protection configuration helps keep protected application data interpretable across nodes, while affinity helps route session traffic consistently.
Neither shared keys nor sticky routing automatically makes in-memory circuit state portable. Process-failure recovery has to be tested as a separate behavior, with explicit expectations about what a reconnect can recover.
The deployment work therefore includes more than checking whether three services are running: private worker reachability, public routing, TLS, allowed pages, interactive transport, dependency readiness, rollback configuration, and preservation of the existing service environment all matter.
The records include sampled recovery checks and preserved release artifacts. Those are evidence of specific rehearsals, not a general availability guarantee or a load-capacity benchmark.
Observability: a failed probe is the beginning of a question
Recent monitoring work provides a particularly useful lesson. A binary readiness metric can tell me that a check failed, but it cannot tell me which part of the request failed.
The diagnostic follow-up records connection, TLS, first-byte, and total timings for failed checks while avoiding response bodies, cookies, and credentials. In the retained examples, connection establishment and TLS completed, but no first response byte arrived before the probe deadline.
That narrows the investigation. It does not identify a database fault, a stalled backend, or a network cause. Equally, a routine database log field named CommandTimeout is not evidence that a command actually timed out.
An outside observer also encountered a failure against an independent control target. That makes its view insufficient to establish a simultaneous application-wide outage. It does not invalidate the separate failures observed from the application infrastructure.
The operational lesson is to preserve diagnostic evidence before adjusting thresholds. Increasing a timeout may hide the symptom without explaining it. A later successful sample establishes recovery at that point; it does not fill an earlier monitoring gap.
The latest reviewed notes leave operational acceptance work open, including recurring readiness-timeout investigation and persistent independent monitoring. They also separate shared-account cost attribution from incremental project costs. A healthy response, an available backup, a passing test, and an acceptable operating cost are different decisions.
Testing the boundaries that matter
The test suite covers domain behavior and failure paths: quote ranges, service catalogs, lead validation and rate limiting, account policies, storage paths and archives, VPN policies, device control, accounting, and deployment-mode restrictions.
Some especially useful assertions are small and concrete:
- Urgent high-availability requirements increase an internal estimate relative to a simpler request.
- Invalid lead submissions fail validation, and excessive repeated submissions are limited.
- Storage-path normalization rejects parent traversal rather than treating it as an ordinary folder name.
- Foundation mode rejects privileged routes, including requests made directly instead of through navigation.
- Checked-in configuration keeps external and billable operations disabled.
These tests describe contracts. They complement staged browser checks, database permission checks, deployment rehearsals, and operational probes; they do not replace them.
For this article I reviewed the source and historical verification records without starting the application, applying migrations, contacting customer integrations, or rerunning infrastructure tests. The repository contains deployment evidence and unresolved acceptance items, so reporting a single blanket “production ready” result would be misleading.
What the project is teaching me
H-DCS has grown from presenting services into coordinating workflows that may eventually control accounts, machines, connectivity, and money. That changes the engineering standard required at each boundary.
The most useful lessons so far are to keep estimates separate from commitments, public presentation separate from operational authority, schema changes separate from routine execution, and observations separate from conclusions.
Daily development and testing make those distinctions practical. Each failure should leave behind a clearer state transition, a narrower permission, a reproducible regression, or a better diagnostic record. That is how a growing service platform becomes easier to operate as well as easier to extend.