Contractor and Vendor Access for a Hotel Property
The sections below set out contractor and vendor access hotel case in the order it actually has to happen on site. Hotels make contractor and vendor access unusually hard to design, because the door that has to open usually has a guest behind it. A door closer technician needs a room that is still occupied at eleven in the morning. A lift engineer needs a service corridor at midnight. A fabricator needs a ballroom while a conference is loading in. The access decision is therefore never only an access decision: it is also a decision about occupancy, housekeeping status, arrival times and who signs for the room.
Direct answer. This article takes the contractor and vendor access hotel case and sets four patterns side by side than arguing for one winner. The contenders are the ones integrators meet: a desk-issued key against a paper work order, a standalone lock with a locally programmed time-boxed code, a centrally managed lock fed by a property platform, and a controller-led estate where the access system holds the decision and the lock carries a governed local rule. Every one of them is defensible. Every one of them fails in a different place.
The output is a comparison you can run: criteria, a head-to-head job walkthrough, a failure pass, an ownership split and a scoring worksheet you weight yourself. Where the argument touches a product capability, this article points at the evidence you must obtain instead of asserting what a device does. Where it touches personal data, egress or a local rule, it names the authority you have to ask.
The four patterns that compete for the same door
A hotel door does two jobs at once. It is a security boundary and it is a customer interface, and any access scheme for tradespeople has to satisfy both. Four patterns keep recurring in hotel work, and they differ in where the decision is made rather than in the hardware bolted to the frame.
Pattern A — the desk issues a key against a paper work order. The contractor signs at reception, receives a physical key or a card cut at the desk, and returns it when the job closes. Identity lives on the sign-in sheet. Expiry is a human promise. If the key does not come back, the remedy is to change the cylinder or the key level, and the only clue about who held it is the handwriting on the sheet. Cheap to run, easy to audit for exactly as long as the paper survives.
Pattern B — a standalone lock with a locally programmed time-boxed code. Someone from the maintenance team programs a PIN or a fob at the door itself. The lock decides, on its own schedule, when that credential stops working, with no server involved. The record lives in the lock's own event memory and has to be collected at the door. This pattern suits one door or a small cluster with a stable set of trades, and it holds up when the network is not the point.
Pattern C — a centrally managed lock fed by a property platform. The platform issues a credential carrying a start time, an end time and a room list. The lock holds the state and enforces the expiry locally even when the platform is unreachable, so expiry and revocation live in the platform log while the lock buffer covers the gap between messages. This is the pattern that scales across a property and reaches housekeeping status and work orders, which is where the occupied-room problem is actually solved.
Pattern D — a controller-led estate where the access system decides. The controller holds the door's state and makes the call. Readers only report what is presented at them. A smart lock under the same policy set carries a governed local rule for the case where the controller or network is unavailable. Where a reader reaches the controller over a legacy Wiegand run, that wiring carries a data line and usually power and ground, and it says nothing about encryption or device identity. Where a specified, addressed, bidirectional protocol such as OSDP is used instead, whether a given product implements it is a per-SKU question. Confirm on the dated product page for the specific SKU before either arrangement enters a specification.
flowchart TD
A["Contractor is called out to the hotel property"] --> B{"Which pattern is in place"}
B -->|Pattern A| C["Desk issues a key against a signed work order"]
B -->|Pattern B| D["Technician programs a time-boxed code at the door"]
B -->|Pattern C| E["Platform issues a dated credential and a room list"]
B -->|Pattern D| F["Controller issues a scoped credential from the access system"]
C --> G["Key returned at the desk and signed back in"]
D --> H["Code stops working when the window closes"]
E --> I["Expiry enforced by the platform and mirrored in the lock"]
F --> J["Expiry enforced by the controller policy set"]
G --> K["Record reconstructed from the sign-in sheet"]
H --> L["Record read from the lock event memory"]
I --> M["Record held in the platform log"]
J --> N["Record held in the controller log and the local buffer"]
Read that diagram as a lifecycle rather than a hierarchy. The left-hand branch is where a credential comes from, the right-hand branch is where it ends up, and the bottom row is where you look afterwards. A pattern that cannot show you a record at the bottom row has not solved the hotel problem; it has only moved it. What the specification covers is in the hotel door locks.
What each side sends, and what happens when the message does
An integration is two systems that each assume the other is reliable. The question for the integrator is not how the happy path looks but what the door does on a bad afternoon: the message is late, the platform is down, the controller reboots, the credential was issued by hand and never registered. The four patterns answer differently, and the answers are not interchangeable.
| Pattern | Credential created | What crosses the boundary | Expiry enforced by | If the message never arrives | Where the record lives |
|---|---|---|---|---|---|
| A | Desk, from a work order | A key number against a signature | A promise in the sign-in log | Nothing arrives; absence is invisible | A paper sheet in the back office |
| B | At the lock, by an on-site technician | A code or fob held by the person | The lock's own clock and schedule | The lock keeps to its stored schedule | Lock event memory, read at the door |
| C | In the platform, mirrored to the lock | A dated credential and a door list | The server, mirrored in the lock | The lock enforces the last expiry received | Platform log plus the lock buffer |
| D | In the access system, held by the controller | A credential with a scope and an end time | The controller policy set | The controller falls back to the written local rule | Controller log plus the local buffer |
Two distinctions keep this table honest. First, the audit log is a record of an event with a time and a source; the event memory is the buffer a device keeps when it cannot reach the server. They are not the same, and the difference is exactly where events are lost. Second, in every row the lock reports the state and the system decides what the state means. A door position contact reports open or closed, not the cause of the opening, and a request-to-exit signal tells the system the exit device was operated from the escape side rather than commanding a release.
stateDiagram-v2
[*] --> Requested
Requested --> Issued
Issued --> Active
Active --> Revoked
Active --> Expired
Revoked --> Decommissioned
Expired --> Decommissioned
Decommissioned --> [*]
The diagram is worth holding in your head because the last two states are the ones hotels skip. Revoking a credential and decommissioning the device or the account behind it are separate recorded operations, and a scheme that handles the first while ignoring the second leaves a contractor account open in a platform that nobody is watching.
Nine criteria that separate the patterns in a hotel
The contractor and vendor access hotel case is easiest to judge when the same nine criteria are applied to all four patterns, because a hotel's pressure points are not spread evenly across the building. Back-of-house doors behave like any other building. Guest-room doors do not, and that is where the four patterns separate most sharply.
| Criterion | Pattern A | Pattern B | Pattern C | Pattern D |
|---|---|---|---|---|
| Scoping to one guest room | Desk judgement | Room by room, locally | Room list from the platform | Scope from the access system |
| Ending access without a visit | Return the key | Window closes on the lock | Revoke in the platform | Revoke at the controller |
| Handling an occupied room | Manual relocation | Manual relocation | Links to room status | Links to room status |
| Keeping contractors out of the master hierarchy | Depends on discipline | Depends on discipline | Policy-defined level | Policy-defined level |
| Surviving a network outage | Not applicable | Unaffected | Mirrored expiry holds | Written fallback rule |
| Answering who opened a door | Sign-in sheet | Event memory, if collected | Platform log | Controller log |
| Out-of-hours vendor callout | Key held overnight | Local code, local rules | Platform credential, night policy | Controller credential, night policy |
| Onboarding a one-off trade | Fast | Fast | Needs a platform account | Needs a controller role |
| Proving the arrangement later | Weak | Partial | Strong, if retained | Strong, if retained |
Three of those rows deserve a note from a hotel integrator's point of view. Occupied-room handling is the row that decides whether a scheme survives contact with a guest who checked in early. Master-hierarchy separation is the row that decides whether a copy of a master key ends up on a van. And the out-of-hours row is where most schemes quietly break, because the night callout is usually granted by whoever is on duty rather than by the person who owns the policy.
The same job, seen through four patterns
Consider one illustrative job in one illustrative property: a guest-room lock repair on an occupied floor, a plant-room fault behind the scenes, and an overnight vendor callout on the lift. Nothing about the job is unusual. The differences come entirely from the access pattern in place.
| Moment in the job | Pattern A | Pattern B | Pattern C | Pattern D |
|---|---|---|---|---|
| Before arrival | Desk prepares a key | Technician programs a code | Platform raises a dated credential | Controller issues a scoped credential |
| On the guest floor | Reception walks the technician up | Technician works to a memorized code | Code reflects only the listed rooms | Credential carries the listed scope |
| During the room work | Key stays in the technician's pocket | Code expires at the set hour | Platform shows the room as out of service | Controller enforces the same scope |
| End of window | Key collected and signed for | Code simply stops working | Expiry recorded in the platform log | Expiry recorded by the controller |
| After departure | One line on a sheet | Memory read only if someone goes and reads it | Full history for any door in scope | Full history from the controller |
Walking Pattern A through that job exposes the weakness quickly. The technician who carries a master key to an occupied room holds authority that the work order never intended, and nothing in the paper trail distinguishes the technician from the person who signed for the key. Pattern B is tighter in principle, but only if the code is scoped to that door and the event memory is actually collected afterwards, which is exactly the step most properties skip.
Pattern C handles the occupied room because the credential and the room status can be read from the same place, so a mismatch between "this room is occupied" and "this person can open it" becomes visible before the technician arrives rather than at the door. Pattern D adds the ability to treat the credential as one element in a broader policy set, but it also adds the most ways to get it wrong: a fallback rule that was never written down, a credential format that the controller and the reader disagree about, and a legacy reader run treated as if it carried identity.
The five integration questions, answered pattern by pattern
Every integration article in this cluster has to answer the same five questions, and a hotel project answers them badly more often than not because the questions are asked once, at specification time, and never again at handover.
| Question | Where the answer must live | Where it usually breaks |
|---|---|---|
| What does each side send, and what if it does not arrive? | A written interface description | One side assumes the other retries |
| Who owns the clock? | A named time source per device class | Local clocks drift from the server |
| What is written down, where, and who can read it? | A named system owner | Records split across systems with different identifiers |
| What happens when the network, controller or server is unavailable? | An approved degraded mode | "Fail locked" assumed without approval |
| Which side owns the fix? | A named party per boundary | Nobody owns the gap, so nobody fixes it |
On the clock, the practical answer in a hotel is that centrally held records use the property system's time, that door devices are synchronised from the same source, and that any device with only a local schedule carries its own clock and therefore its own drift. Where the requirement involves a platform rather than a device, the integrator should establish whether the requirement is about a local API or a cloud API, because the two produce different failure behaviour and different evidence.
On records, the answer that survives an audit is the one naming a system, a retention period and a reader list. On the degraded mode, the answer is not an engineering preference. If the stated behaviour is that the door fails locked when the network is down, that is an approval question for the people responsible for the building, not a decision the integrator takes alone.
Where each pattern breaks under hotel conditions
Pattern A breaks when a key is copied, which leaves no way to know which copy was used; when a key is not returned; when the desk is closed at the hour the engineer arrives; and when a cleaning schedule takes the sign-in sheet with it.
Pattern B breaks when the code is programmed wider than the job, so one PIN opens a floor of guest rooms; when nobody reads the event memory, so the record exists only until the device is powered down; and when the technician who set the code cannot be asked what window they chose.
Pattern C breaks when the platform does not know about a door that the lock controls, so the scope and the reality drift apart; when the mirrored expiry is stale; when the contractor's platform account is never closed after the job, which is the most common form of leakage; and when the integration was built against a local API when the requirement was actually a cloud one.
Pattern D breaks when the fallback policy for each door was never written down; when a legacy Wiegand run is assumed to carry identity or encryption, which it does not; when the reader and controller disagree about credential format; and when the reader reports a state and the integrator treats that report as a cause.
The recovery patterns behind these failures are covered in Contractor and Vendor Access Failure Patterns and How to Recover, which is worth reading before a test is scheduled rather than after one goes wrong.
The ownership split in practice
A hotel property has more than one party touching contractor and vendor access: the manufacturer of the hardware, the integrator who commissioned it, the property operator who runs the building, and the trade or vendor company whose people arrive. The table below is the split most projects settle on once the arguments have already happened.
| Task | Supplier | Integrator | Hotel operator | Trade or vendor |
|---|---|---|---|---|
| Publish credential capabilities | Owns | Reviews | Reads | Reads |
| Program and scope a credential | Supports | Owns | Authorises | Consulted |
| Set the access window | Consulted | Implements | Approves | Requests |
| Revoke early | Supports | Executes | Decides | Informs |
| Collect event records | Supports | Configures | Owns the reader list | May request |
| Answer who entered a room | Provides data | Configures | Answers | Answers for own staff |
| Maintain the fallback rule | Consulted | Writes | Approves | Informed |
| Close the account at the end | Supports | Executes | Owns | Provides the list |
| Update devices and policy | Supports | Governs | Approves | Informed |
Three boundaries decide most of the arguments. Access capability is a supplier question and must be answered on the dated product page for the specific SKU. The window and the scope are an operator decision, because only the property knows whether a room is occupied. And the residual rights on an expired credential are an integrator task, because a credential that was never closed is a live key in somebody's pocket.
The longer treatment of that split, including the cases where the supplier is also the integrator, sits in Who Owns Contractor and Vendor Access: Supplier, Integrator or Client.
A scoring worksheet you can finish in one sitting
Scores below are one worked example for a property with heavy guest-room turnover and a small back-of-house estate. Treat them as a worksheet, not as a verdict, and change the weights before you change anything else. A back-of-house-heavy service apartment will weight the outage row far more heavily.
| Criterion | Weight | A | B | C | D |
|---|---|---|---|---|---|
| Scoping to an occupied room | 20 | 2 | 3 | 5 | 5 |
| Ending access without a visit | 15 | 1 | 5 | 5 | 5 |
| Surviving an outage | 15 | 3 | 5 | 4 | 3 |
| Answering who entered | 20 | 1 | 3 | 5 | 5 |
| Out-of-hours callout | 10 | 2 | 4 | 4 | 4 |
| Onboarding a one-off trade | 10 | 5 | 4 | 3 | 2 |
| Proving the arrangement | 10 | 1 | 2 | 5 | 5 |
| Total | 100 | 15 | 26 | 31 | 29 |
Read the total row with care. A pattern that wins on the weighted total can still be the wrong choice for the property you are actually commissioning, and the two lowest rows for Pattern A are the two rows that generate the disputes a hotel spends the most time on afterwards.
What is written down — contractor and vendor access
And who may read it.
The integrator's job is to write down, before the system goes live, which system is the system of record, how long it keeps entries, who inside the property may read them, what happens to them at the end of a contract, and what a subject access request would pull back. None of those answers are technical, and none of them should be settled by default.
CONFIRM-WITH-LOCAL-PRIVACY-ADVISOR: confirm in the local jurisdiction which controller and processor roles apply to the contractor and visitor access log, what retention period is expected for a hospitality property, what a subject access request would return across locks, platform and video records, and what the position is where a brand, a management company and a franchisee each hold a copy.
Where the property sits inside a chain, the same question appears one level up: whether the platform is multi-tenant and who can see another site's doors. The questions to ask a supplier before a pilot goes live are set out in Security Questions to Ask About Contractor and Vendor Access, and the handover side of the same subject, including what a finished record set should contain, is covered in Documenting Contractor and Vendor Access for Handover and Audit.
The escape side, the fire panel and the approval nobody
Contractors on a guest floor change door behaviour temporarily and often without thinking about the escape side. A hold-open device fitted for a delivery, a strike disconnected for a frame replacement, a lock set to a different fail state while the door is worked on: each of these is small in isolation and significant in aggregate.
Two vocabulary points protect the conversation. Fail-safe and fail-secure describe the state a lock takes when power is removed, and that state is decided by the role of the door and by the approval that the building carries, not by the product on the door. A request-to-exit signal is a report that the exit device was operated from the escape side; it is not a release command, and release on the escape side is the default behaviour of the exit device.
CONFIRM-WITH-LOCAL-FIRE-AUTHORITY: confirm with the authority that signs off on the building which doors may be held in a fail-secure state while a contractor works, what evidence the fire panel needs about door configuration during that period, and who may authorise a temporary change and record it.
If the answer to any of those questions is unknown at the point where a technician is already standing at the door with a screwdriver, the answer will be improvised. That is the failure mode, and it belongs to whoever approved the work order, not to the lock.
When the network, the controller or the platform is not there
The offline case is the design, not the exception. A hotel has guest Wi-Fi, a guest-facing network and a lift that stops when something is wrong, so a scheme that assumes constant reachability to a cloud service is assuming away the building it operates in.
Centralised and standalone are the two ends of this decision. A standalone device decides for itself and keeps working when nothing else is reachable; it also keeps a record only as far as its own memory reaches. A centralised device defers its decision to a server or controller; it gains central visibility and loses autonomy exactly when the link drops. Neither is wrong. What is wrong is a property that has not chosen, and has therefore inherited whichever behaviour the vendor happened to ship.
For each door, write one sentence: what still works without the link, what stops working, and who carries the runbook that restores it. In a hotel, the sentence that matters most is usually the second one, because "what stops working" for a guest-facing door is a decision someone has to make in the first hour of an outage.
Running the comparison inside one property
The fastest way to settle the argument is to run a small, real trial rather than a tabletop exercise. The scope below keeps the contractor-and-vendor-access question to a single property, because the constraints described here stop being true the moment the same design is stretched across a portfolio.
- Pick one wing and one back-of-house cluster. A guest floor plus a plant area gives you both failure modes in a manageable scope.
- List every door the trades actually touch, including the ones nobody has ever thought to secure, such as a store room a vendor uses for deliveries.
- Survey the doors before deciding anything. Door fit, handing, frame condition and existing strikes decide more of the outcome than the credential model does; the Smart Lock Retrofit Site Survey and the Office Smart Lock Site Survey both exist for this step.
- Ask for written answers, not demonstrations. Capability questions go to the supplier and must be answered on the dated product page for the specific SKU; treat anything else as unconfirmed.
- Run one timed job end to end with a real trade, a real room list and a real end point, and watch where the record appears afterwards.
- Write the fallback and its owner on the same page as the room list.
CONFIRM-PER-SUPPLIER: obtain written confirmation for each capability a pattern depends on, including credential formats, expiry enforcement location, event record retention and local operation, and treat the dated product page for the specific SKU as the only authoritative source for the SKU being quoted.
The definition work in step one belongs in a written requirements document rather than in a supplier's scope of work, and the shape of that document is set out in Contractor and Vendor Access Requirements Document Template. The first stage of the exercise, before any of this, is to agree what the project actually is, which is covered in Contractor and Vendor Access for Smart Lock Projects: What Buyers Must Define First.
The request for proposal questions that settle the pattern
Put these in the request for proposal and require the answers in writing. They are ordered so that the first three kill the responses that cannot be delivered.
- Which side of the credential decision holds the state, and where is the expiry enforced when the platform is unreachable?
- What exactly is written down when a contractor opens a door, and how is that record retrieved later?
- How is a credential revoked before its scheduled end, and how is that revocation recorded?
- Which doors in our estate does your scheme cover, and which does it not?
- What is the degraded behaviour of each door during an outage, and who approved it?
- How does the scheme recognise an occupied guest room, and what does it do when occupancy and access conflict?
- Which interfaces are you integrating against, local or cloud, and what evidence do you need from us to build them?
- What must our own team be able to do without calling you?
- On handover, what documentation, credential list and access records do you leave behind?
- Which of these statements is confirmed on the dated product page for the SKU being quoted, and which are pending?
A supplier who answers all ten in writing has done more for the project than a polished demonstration, because the demonstration proves that the happy path works on the day and nothing about who owns the work afterwards. The effort behind answering them is set out in Contractor and Vendor Access Cost and Effort Drivers Without Quoting Prices, and the trial that proves the answers is described in Contractor and Vendor Access: The Test Plan a Buyer Should Demand.
Taking the next step
The next step is a scoped conversation rather than a catalogue request: bring one floor, one list of trades and one list of doors you already struggle with, and the pattern that fits becomes obvious from the answers. If the same design is also going into a wider estate, compare how the patterns behave across sites in Contractor and Vendor Access for a Multifamily or Office Portfolio. Send the room list, the trades list and the access policy you already run, and we will map them against the four patterns, the degraded modes and the ownership boundaries, with every product-level claim confirmed on the dated product page for the specific SKU being quoted.
The next step is to request a quote.

