Submitted:
08 November 2026
Posted:
10 November 2026
You are already at the latest version
Abstract
A shared computing quota took two applications offline simultaneously after a code change intended to reduce dashboard polling. The available evidence identifies the scope of the suspension and the routines that changed, but cannot establish CPU savings. This technical note compares four deployment arrangements for enterprise systems serving multiple organizational units: shared commercial cloud hosting, centralized institutional infrastructure, per-unit installation, and local operation with central consolidation. It follows a record update from the initial write to the display, identifying authority over the data, limits on visibility across units, and the components needed during an outage. Two UML diagrams illustrate deployment boundaries and recovery after a lost acknowledgment. A third figure shows how local installations exchange data with a central service. The note proposes criteria for assessing polling costs, release distribution, fault diagnosis, and provider substitutability. The evaluation scenarios are analytical proposals.
Keywords:
software architecture
; multi-unit deployment
; data isolation
; operational continuity
; dashboard displays
; distributed maintenance
1. Introduction
1.1. From Prototype to Shared Service
A team develops a dashboard, deploys its first release, and opens it in a browser on a wall display. A second unit asks for access. Creating another account looks straightforward. The architectural decision is more consequential. Someone must decide who may see each record, which components serve both units, and what happens to both when the hosting account reaches its contractual limit.
This paper examines that transition. How should an institution begin scaling a prototype across units, given its chain of command, access permissions, and the extent to which processes and requirements are uniform? Which resources should the units share, and which should each retain? The question is especially relevant when people use the system intermittently while displays remain open and poll the server throughout the working day.
Consider two units that record the same operation at different stages. Before sizing the server, the team must decide whether both can contribute to the same indicator. If one department counts a delivery at dispatch and the other at receipt, technically correct totals represent different events. The proposed starting point is to identify a common process, define the meaning of each state, and specify which local variations can be configured. The team then assigns each role the authority to read, correct, and consolidate records. These decisions establish the basis for estimating component workloads.
This note extends the author’s research on information continuity in Brazilian Army logistics. The earlier paper on MCL [1] examined how information passes between stages of work in supply organizations. Extending the prototype to a second unit raises a question of deployment governance: who is accountable for the record, who may consult it, and who restores service when shared infrastructure fails?
1.2. Contributions
The comparison follows the same record update through four deployment arrangements. It provides three instruments for deciding whether to expand:
- An allocation of responsibilities identifying the unit authorized to change each record and the organizational level authorized to consolidate it.
- Continuity criteria for individual operations: displaying the last available screen, querying records, committing an entry, and incorporating it into a higher-level report.
- An evaluation protocol (Section 11) linking deployment decisions to observable costs, isolation between units, recovery, and maintenance effort.
2. The Incident and the Limits of the Evidence
Two Applications Under One Quota
The author operated two distinct applications under a single Vercel team, designated here as applications A and B. On November 5, 2026, a suspension notice reported consumption equivalent to 123% of the free allowance of four active CPU hours. The outage was noticed the following Friday. Billing and suspension both applied to the team to which the applications belonged.
Four CPU hours represent accumulated processing time. A display can remain on for hours while consuming little CPU, or it can repeatedly ask the server to rebuild an unchanged response. The provider accounts separately for active CPU, provisioned memory, and function invocations [2]. The reported figure applies to that account and billing cycle.
Before suspension, application A received a code change to reduce polling. According to the author’s maintenance account, the client began checking a content revision before requesting the full payload. The change also removed a routine that could reprocess documents when the playlist was read. The first intervention affected transfer frequency. The second removed a class of computation from the read path.
The records link the interruption to the shared quota. Comparable before-and-after CPU series by application and route are unavailable. The displays’ share of total consumption and the savings from the intervention therefore remain unknown. The experience motivates the research question and documents a shared failure. The scenarios that follow are analytical constructions.
3. Four Deployment Arrangements
Where the Application and Data Reside
In shared commercial cloud hosting, the units access a common application. The central team deploys a fix once and manages aggregate capacity. A restriction on the account, however, can affect several applications. Separate accounts or instances provide independence only for the resources they actually separate.
With centralized institutional infrastructure, the organization operates or procures the environment hosting the shared service. Users may see the same interface as in the commercial cloud. For the prototype developer, deployment depends on who authorizes production use and assumes responsibility for support. Intranet access indicates how a service is reached. Identifying which organizational level maintains the database, its location, or its redundancy requires separate documentation.
In a per-unit installation, a package deploys the application and database to a server on the local network. Operators at the unit access the same database through their browsers. The team must plan for replacing equipment and reconnecting a restored installation. Installing autonomous copies on each workstation would introduce another architecture and require reconciliation among operators within the unit.
In the hybrid arrangement, each unit retains authority over local entries and sends events to a central service. Supervisors see a consolidated view that may lag behind local activity. Independent instances dedicated to a customer or group are also described by the deployment stamps pattern [3]. A stamp may reside in a single data center. Logical and geographic distribution are separate choices. Choosing a server location also assigns physical custody. A flood or fire can destroy equipment and backups stored in the same building. Following a change of personnel, disks may be intact while recovery credentials are unavailable. If remote administration is inaccessible or requires external approval, repairs may entail travel and on-site access. NIST contingency guidance connects alternate sites, recovery, and operational responsibilities [4]. The comparison should examine actual protections: a recoverable off-site copy, replacement equipment, a designated alternate, and time to reach the site. An institutional data center can also provide these safeguards.
Table 1.
Deployment decisions. The central service column covers commercial and institutional hosting.
Table 1.
Deployment decisions. The central service column covers commercial and institutional hosting.
| Decision | Central service | Per-unit package | Local with consolidation |
| Execution | Shared infrastructure | Unit server | Local operations and central oversight |
| System of record | Central database partitioned by unit | Each installation’s database | Entries at source and common catalog at the center |
| Link failure | Operations requiring the center stop | Work continues if authentication and storage are local | Local writes continue and the central view reports its age |
| Support | Central team manages capacity and recovery | Each installation needs backups, updates, and recovery | Institution maintains installations and synchronization |
| Failure to examine | Account suspension or central outage | Loss and restoration of a unit server | Reconnection after a day of local transactions |
4. Logical Isolation Between Units
Authorization, Storage, and Caching
Suppose units A and B use the same address and both call their wall display “Dashboard 1.” When an operator from A signs in, she should see A’s records. If someone forwards her the address of B’s dashboard, the server must check her permissions before delivering its contents. A regional supervisor may be allowed to see the combined total while still requiring separate authorization to open or correct an individual entry.
The units can share a database. Each entry carries the identifier of the responsible unit, which the server uses when retrieving authorized records. PostgreSQL supports policies restricting which rows a role may read or change. The application’s account must be subject to these rules, since some administrative roles can bypass them [5].
Another issue arises when the server keeps a ready-made response in a cache to serve the next request faster. If the cached copy is labeled only “Dashboard 1,” B’s request might retrieve A’s screen. The cache key must distinguish the unit, dashboard, and authorized audience. When a person changes roles, the system must check the current permission even before serving an existing copy.
Figure 1 identifies two boundaries. The deployment boundary shows which components may go offline together. The logical boundary identifies the records an operator may read. These boundaries partly coincide in local installations and can be entirely separate in a central service. The diagram uses UML notation for nodes, artifacts, and communication paths [6].
5. Interpreting the Deployment Diagram
Tracing a Record Update
Consider unit B in Figure 1. In the first arrangement, a write by A and a read by B pass through the same application. Checking permissions at sign-in addresses only part of the problem. The query, cached response, and content sent to the display must all preserve the scope assigned to the session.
In the second arrangement, the physical boundary prevents a local query from directly reaching the other unit’s database. Support staff must now determine which release exhibited a fault. The different versions in the figure make that cost visible. The package repository may be offline while installed applications continue serving their local networks.
6. Polling by Dashboard Displays
The cost of Checking for Change
Before the intervention, each display requested a full refresh every thirty seconds. The revised code checked the content version once per minute during configured daytime hours and once every ten minutes outside that window or when the browser tab was hidden. The client requested the full payload when the version changed. Another part of the application increased its polling interval from ten seconds to five minutes.
A simple count illustrates the change. Ten visible screens running for one hour make approximately 1,200 periodic requests at thirty-second intervals, or 600 at one-minute intervals, excluding startup, failures, and retries. If each version check executes six database queries, as reported for the revised routine, 600 checks can generate 3,600 queries. These counts are calculated for a hypothetical workload. CPU time per query remains unknown.
A third implementation would store a revision for each unit and dashboard. A write updates the data and the affected revision in one transaction. A read compares the client’s revision with the current revision of the authorized representation. HTTP supports validators such as ETag and conditional requests using If-None-Match, including a 304 response where appropriate [7]. Savings depend on how much computation it takes to make that decision.
This alternative shifts work to the write path. The system must identify which dashboards depend on each record, including after deletions, permission changes, and batch imports. A global revision is easy to maintain, but a change at A could invalidate B’s dashboard. A revision scoped too narrowly could leave a legitimate change invisible. The appropriate granularity depends on relationships among the displayed data. Removing computation from the read path can reduce CPU consumption and make a cheaper hosting tier viable. The pilot served a single unit, yet the shared account reached suspension after the intervention. Because another application used the same quota, the incident cannot establish the cost of one unit in isolation. It does establish that the free configuration could not sustain that cycle’s aggregate workload.
Expansion therefore requires a decision about who will fund additional capacity if projected consumption exceeds the plan. Commercial hosting may require a larger allowance. Institutional infrastructure can absorb the load if capacity and deployment authorization are available. Per-unit installation shifts some costs to local infrastructure and maintenance. Comparing budgets requires knowing how many displays poll, how much work each request triggers, and how much refresh delay is acceptable.
7. Local Operation and Central Consolidation
Identifying the Authoritative Record
A local installation can sustain an operation during a network outage only if its required components remain available at the unit. Displaying the last saved screen, reading past records, and committing a new entry are distinct levels of continuity. A cached screen may support the first while remote authentication blocks the other two.
In the hybrid arrangement, the package is installed on a unit server. Workstations and displays reach it through the internal network. A synchronization process initiates outbound connections to a configured central endpoint. The receiving application programming interface (API) authenticates the installation, verifies which records it may submit, and stores accepted changes. The endpoint may be hosted on Vercel or on an institutional server reachable through the intranet. Figure 2 shows both directions of exchange.
On each connection, the client can submit a batch of pending entries and request catalog changes since the last revision received. A write acknowledgment allows the event to leave the local queue. While disconnected, the queue remains on disk and locally authorized work continues. Writing the entry and its event together follows the transactional outbox pattern [8]. A central processing queue can smooth bursts when many units reconnect at once [9]. In that design, acceptance into the queue and incorporation into the report require distinct statuses.
Under the proposed allocation of authority, the unit owns its entries and the center maintains the common catalog. The local server confirms a write to the operator after recording the change and a pending event in a single transaction. Delivery can thus resume after an interruption between writing and transmission. The event identifier remains stable across attempts.
The center applies the change and records the received identifier atomically. If acknowledgment is lost, the unit can resend the event. The receiver recognizes the duplicate and acknowledges the completed operation. Idempotent retries require retaining identifiers for the retry window and distinguishing different requests that improperly reuse a key [10].
Event order also matters. A cancellation may reach the center ahead of the original entry. A per-record sequence or an explicit dependency on the preceding revision allows the center to detect the gap and wait for the missing update. The supervisory screen should indicate the revision or time through which each unit’s changes have been consolidated. The last connection time alone cannot establish whether all pending changes were incorporated.
8. A Write During an Interruption
Acknowledgment and Retry Sequence
Figure 3 follows an event received by the center whose acknowledgment is lost. From the unit’s perspective this is indistinguishable from a failure before receipt. The first commitment visible to the operator is local confirmation. Availability in the institutional report is a second commitment that depends on communication and central processing.
A local indicator can show how many events await acknowledgment and the age of the oldest. At the center, each unit can be associated with its latest incorporated revision. Together these indicators distinguish a backlog from a unit that recorded no changes that day. Staff can then judge whether the report is current enough for its intended use.
9. Customization and Distributed Maintenance
One Release, Multiple Configurations
On first launch, an administrator associates the installation with a unit and configures departments, roles, dashboards, and display preferences. The unit’s permanent identifier should survive changes to its name or abbreviation. Entries refer to this identifier, while the interface resolves the current name for display. An administrative change can then be made without migrating historical records.
Customization is easier to sustain when local differences fit a common configuration schema. One unit may have three departments and another fifteen, while both use the same authorization routine. An exceptional rule requiring custom code increases the combinations the maintenance team must support. Its adoption should specify who uses it, what behavior it changes, and how long compatibility will be maintained.
A rollout begins with a pilot group. The package identifies its application release, supported database versions, and required migrations. The unit verifies package authenticity, creates a recoverable backup, applies the migration, and checks a read and a write. Rolling back the executable alone can fail after an incompatible schema change. Recovery planning must account for entries committed since the backup.
In an installer-based model, illustrated by the author’s experience as a MiND user, an update may depend on someone accepting a prompt, holding installation privileges, and choosing a maintenance window. The proposed architecture records the version offered, the installed version, and the date of the last confirmation. Planned patch management includes identifying, prioritizing, installing, and verifying updates [11]. The effect of postponing or declining an update on outgoing data compatibility should be known.
Suppose an older release counts returns as deliveries while a newer release deducts them. Adding the totals conceals a difference in meaning. Each submission should identify the schema version and, when an indicator’s meaning changes, the calculation rule version. The center may convert compatible records or present incompatible series separately, indicating coverage and last update. Readers can then judge whether the consolidated report supports that day’s decision.
Diagnosing a defect requires reconstructing its original environment. The proposed installation exports a local diagnostic package containing versions, applied migrations, the operation identifier, and the error category. An operator can forward it even if the site was disconnected during the fault. Record payloads, credentials, and document contents are excluded. Support staff should be able to distinguish a release-wide defect from a configuration issue or local infrastructure failure.
10. Cost, Scale, and Provider Dependence
Who Pays and Who Can Restore Service?
For a monthly costing period, let F denote shared fixed cost, variable cost for the resource consumption vector q, infrastructure cost attributable to unit i, its administrative hours, and the corresponding hourly rate. An initial model is
Central team labor should be included in F or identified as an additional cost. Local hardware enters at its equivalent monthly cost. The same accounting conventions should apply to electricity, incremental connectivity, backups, and replacements across alternatives.
Existing hardware may require little immediate expenditure yet consume maintenance hours at every site. Cloud hosting may have a low marginal cost until usage reaches an allowance and a larger tier becomes necessary. In the incident, the relevant consequence was service interruption. Pricing it would require data on lost working hours. Availability can be reported as a separate measure.
Provider dependence has an observable operational dimension. Who holds administrative credentials? Can the database be exported and the application rebuilt elsewhere? Do authentication, package distribution, or backup recovery require the same account? A provider’s nationality describes an institutional relationship, while the feasibility of replacement depends on specific technical and contractual ties.
A portability exercise would give a team the installation package, a backup, and documentation while withholding access to the original account. Recording which functions could be restored and which still required external authorization would characterize residual dependence. This exercise is a proposed comparison criterion and was not conducted for this paper.
11. Proposed Architecture Evaluation Protocol
What to Observe in each Deployment
The protocol addresses a concrete decision: under what conditions should the next unit be brought online? The tests below are proposals. None was carried out for this note.
Preparation. Select an operation with the same meaning at each unit. Before comparing deployments, the process owner specifies which roles may perform it, how much delay is acceptable on the display and in the consolidated report, and how long writes must remain possible without external connectivity. Record the software version, synthetic dataset, number of displays, and costing period. Apply the same workload to each comparable architecture.
Table 2.
Proposed protocol for comparing implementations with synthetic data.
| Test | Measures and observations |
| Simulate 1, 10, and 50 units, varying display count and write frequency | CPU, database queries, traffic, latency, and projected monthly cost per unit |
| Run displays for eight hours with unchanged content | Cost of full refreshes, version checks, and serving precomputed content |
| Interrupt one unit’s link and the central service in separate trials | Units able to read, write, and consolidate, and outage duration by function |
| Reconnect a unit and suppress an acknowledgment | Time to consolidation, missing records, and duplicates |
| Roll out a migration while keeping different versions in use | Support hours, compatibility, and recovery after migration failure |
Interpreting measurements requires recording load and observation interval. Site reliability engineering distinguishes latency, traffic, errors, and saturation [12]. Here, the response latency of a route and the time for a change to appear on a display are separate quantities. Both should be recorded.
Display load. Distribute ten displays across two units for one hour. Keep records constant for the first half, then change one record at A in the second half. Compare full refreshes, revisions computed at read time, and stored revisions. Record queries, bytes, CPU, and time to display. Check whether a display at B received A’s data or repeated a full read despite having no dependency on the changed record.
Connectivity loss. In separate trials, interrupt a unit’s external link and the central service. Attempt authentication, reads, writes, and consolidation. For each operation, record the last valid response, interruption duration, and outcome after reconnection. Include a new session, since a valid existing session can mask a dependency on external authentication.
Lost acknowledgment. Suppress the central response after the write commits. Resend the pending event. Count the resulting records and compare revisions. The criterion is a single effective change followed by an acknowledgment the unit recognizes. Repeat the reasoning for two successive events delivered out of order.
Fault in a distributed release. Keep one unit on the previous release and another on the new one. Report the same symptom using each installation’s diagnostic package. Record staff time to identify the relevant difference, compatibility with consolidation, and actions required for recovery. Administrative costs can be counted even when the software is free. Decision rule. For each deployment, record the observed condition, affected function and unit, recovery time, and person responsible for intervention. Assess mandatory requirements first. If B’s dashboard displays an entry restricted to A, the fault requires correction before expansion, even in the least expensive deployment. Among deployments meeting the requirements, compare monthly cost per unit, support effort, and consolidation lag. Record any unexamined recovery capability as an open issue.
12. Discussion and Conclusion
Choosing a Deployment by the Operations It Preserves
The case suggests beginning the deployment decision with the function most sensitive to interruption. A display that tolerates a few minutes of lag permits a different polling policy from the one needed by two people editing a record concurrently. A supervisory report that permits end-of-day consolidation leaves room for local writes and later transmission. The architecture can then be justified against the commitments the organization actually needs to meet.
Central hosting simplifies administration of a common release when the team has authority to sustain it and unit isolation extends to every read path. Local deployment supports continuity within a unit when essential dependencies are also local. Hybrid operation requires explicit handling of lag, retries, and event recovery. In every arrangement, responsibility for administration, funding, and restoration must be assigned.
The main limitation concerns the empirical material: one hosting suspension and an earlier code change. CPU savings were not measured, and deployments were not compared under field conditions. The contribution lies in specifying the decisions and observable criteria by which their consequences could be assessed.
Describing a dashboard refresh policy requires knowing the cost of checking for a change and which consumers the change invalidates. Likewise, a claim of local independence requires identifying who can recover the installation and which version of the data it will serve. These conditions make it possible to discuss scale before a second institutional user inadvertently inherits every dependency of the first.
Use of Artificial Intelligence
The author supplied the operational account and defined the scope of the note. ChatGPT assisted with manuscript organization and drafting, diagrams, LaTeX sources, and English translation.
References
- Melo, E.J.d.S. Da fragmentação à continuidade informacional: MCL nos órgãos provedores do Exército Brasileiro. https://ebrevistas.eb.mil.br/RGM/article/view/14501, 2026.
- Vercel. Fluid compute pricing. https://vercel.com/docs/functions/usage-and-pricing.
- Microsoft. Deployment Stamps pattern. https://learn.microsoft.com/en-us/azure/architecture/patterns/deployment-stamp.
- Swanson, M.; Bowen, P.; Phillips, A.W.; Gallup, D.; Lynes, D. Contingency Planning Guide for Federal Information Systems. Technical Report SP 800-34 Rev. 1, National Institute of Standards and Technology, 2010. [CrossRef]
- PostgreSQL Global Development Group. PostgreSQL 18 Documentation: Row Security Policies. https://www.postgresql.org/docs/18/ddl-rowsecurity.html.
- Object Management Group. Unified Modeling Language, Version 2.5.1. https://www.omg.org/spec/UML/2.5.1, 2017.
- Fielding, R.; Nottingham, M.; Reschke, J. HTTP Semantics. RFC 9110. 2022. [CrossRef]
- Richardson, C. Pattern: Transactional Outbox. https://microservices.io/patterns/data/transactional-outbox.html.
- Microsoft. Queue-Based Load Leveling Pattern. https://learn.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling.
- Featonby, M. Making retries safe with idempotent APIs. https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/.
- Souppaya, M.; Scarfone, K. Guide to Enterprise Patch Management Planning: Preventive Maintenance for Technology. Technical Report SP 800-40 Rev. 4, National Institute of Standards and Technology, 2022. [CrossRef]
- Beyer, B.; Jones, C.; Petoff, J.; Murphy, N.R., Eds. Site Reliability Engineering: How Google Runs Production Systems; O’Reilly Media, 2016.
Figure 1.
Central and per-unit deployments. Dashed arrows in panel B indicate release distribution. Version numbers are illustrative.
Figure 1.
Central and per-unit deployments. Dashed arrows in panel B indicate release distribution. Version numbers are illustrative.

Figure 2.
Hybrid synchronization. Each unit initiates communication. Dashed arrows show acknowledgments and catalog revisions returned by the center.
Figure 2.
Hybrid synchronization. Each unit initiates communication. Dashed arrows show acknowledgments and catalog revisions returned by the center.

Figure 3.
UML sequence diagram. Local confirmation precedes central acknowledgment. The identifier of event E remains stable on retry.
Figure 3.
UML sequence diagram. Local confirmation precedes central acknowledgment. The identifier of event E remains stable on retry.

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.