A pms integration ownership split names the party that answers for a disputed door, and fixes what each handover between the four parties must leave behind.

Veröffentlicht am: Aug 12, 2026

Who Owns PMS Integration: Supplier, Integrator or Client

Who Owns PMS Integration: Supplier, Integrator or Client

Pms integration ownership split is what this piece addresses for the system that has to work on a real door. Between a property system and an electronic lock there is always a distance, and the distance is never occupied by software. It is occupied by organisations. One wrote the property system, another wrote the lock platform, a third built the seam joining them, and a fourth lives with the consequences: the operator who must answer at a door at eleven at night with a guest behind them.

Direct answer. The one-line answer — pms integration ownership split is the working record for pms integration ownership split. pms integration ownership split is worthless until pms-integration is attached to it as evidence. A pms integration ownership split is an integration guide. Every component has an obligation to the next. pms integration ownership split is the first one tested for pms integration ownership split.

  • Trace the interface — write down what hands over between lock, door and system at pms integration ownership split
  • Verify the handover — record the sequence that proves pms-integration works end to end
  • Preserve the trail — store the commissioning evidence with the file for fault is never
  • Treat this as the pms integration ownership split sequence, with pms integration as the reference.

This guide is not about how to build that seam; the technical shape of the interface is set out in Hotel Smart Lock PMS Integration Guide. What follows is the pms integration ownership split: which party holds which part of the integration, what each may change, and what every handover must leave behind so the next person can tell, from the record rather than from recollection, which side of the line a fault belongs to.

That split is decided early — at the point where four organisations sign four different documents and each assumes the others are handling the middle. By the time a guest is standing at a door that will not open, it is already made. It is merely invisible, and it becomes visible only as an argument.

The argument is always the same with a different surface. Something did not happen, or happened twice, or happened on the wrong door, and two organisations are each certain the other did it. The fix is not a better diagnostic routine but a written allocation, made before the hardware is ordered, that says which party changes the data.

The situations below are illustrative composites. No property, operator, supplier, contract or fault named here exists, and nothing in this guide states what any particular product does.

The fault is never where the argument starts

A useful discipline for anyone holding a property system integration is to separate the observation from the ownership. The observation is what a person saw. The ownership is the question of which organisation would have to change something in order to make the observation untrue.

Those are not the same thing, and conflating them is what turns a fault into a fortnight. A front desk clerk reports that a guest's card will not open a door on the fourth floor, and the observation is a refused presentation. The ownership is not obviously the desk, because the desk did not decide which doors the credential carries — it encoded what it was handed. Nor is it obviously the property system, which may have sent the instruction correctly while the lock platform applied it to the wrong door. Nor is it obviously the lock supplier, which cannot see which room the guest was moved to. The range this procurement eventually buys from is the smart door locks.

Each of the four parties can be blameless and the fault still real, which is why a shared model of blame fails: the fault belongs to none of them, and the guest is still at the door.

Ownership here is neither a moral category nor a commercial one. It is a technical category: it names the party whose change would resolve the condition, and therefore the party that can resolve it.

Ask not only who owns the fault but who owns the baseline — the state of the integration that everybody agrees is correct. If the door schedule, the mapping, the entitlement and the clock are all right, any deviation is a change made by somebody, and the baseline tells you who. Without a written baseline, every incident becomes an investigation rather than a correction.

That is why this guide spends its length on artefacts rather than architecture. Ownership is not a diagram drawn in a kick-off meeting. It is a set of records, each with one owner, each versioned, each signed for as it changes hands.

Four organisations, four different powers

The parties are usually described loosely as the supplier, the integrator and the client. That is too coarse to allocate anything, because each label can cover two organisations with different powers. The working set for this guide is four.

The lock supplier builds the hardware and the platform that holds the door's state and makes the access decision. Its power runs over the lock, the lock-side firmware, the interface it exposes and the documentation describing both. It has no authority over the property system, the building, the staffing, or the approvals that belong to the building's owner.

The property system vendor owns the business truth on the other side: who is entitled to be in the building, from when, until when, and under which room assignment. Its power runs over the emission of instructions, the entitlement's semantics, and the encoding surface at the desk.

The systems integrator owns the seam: the connector configuration, the room-to-door mapping, the commissioning, the health monitoring, first-instance fault triage, the handover documentation and the training of operating staff. The integrator is frequently the only party that can see both sides at once, and that visibility is why it accumulates risk: an organisation that sees everything is the one everybody calls, whether or not it can fix what it sees.

The client owns the building, the business, the approvals and the money. It decides the fail state of each door, who may authorise a manual override at three in the morning, what a door event record means for the people in it and how long it is kept.

The rule for allocating work between the four is short: ownership follows the change, not the data. If resolving a condition requires the property system vendor to alter what it emits, the property system vendor owns it, whatever server the artefact sits on. The party that cannot change it does not own it and should not be handed an obligation it can never discharge. An obligation with no named owner is not shared; it is unheld, and it surfaces as a telephone call nobody can close.

What each party owns and what it leaves behind

The allocation table is the working document of this guide, and it is the pms integration ownership split expressed as rows that must exist at the end of the project. Each row names the owner, the party that decides where that differs, and the artefact that remains.

Item in the integrationOwnsDecidesArtefact left behind
Room-to-door mapping and door scheduleSystems integratorIntegrator, client confirms the surveyVersioned mapping register with change log
Lock-side interface and firmwareLock supplierLock supplierInterface description and release notes
Entitlement and stay windowProperty system vendorProperty system vendorSpecification of the emitted fields
Credential issued at the deskProperty system vendorDesk supervisorEncoding record and discard note
Provisioning a deviceSystems integratorIntegratorEntry naming identity, door and owner
Decommissioning a deviceSystems integratorClientDated removal record
Reader-to-controller path and addressingSystems integratorIntegratorPath schedule with addressing convention
Exit-side release and exit indicationSystems integratorClient approvesCommissioning record per exit device
Fail state on loss of powerClientClient, approver namedApproval minute per door class
Fire interface arrangementClientThe building's approving authorityInterface schedule and test record
Authoritative clock and drift allowanceSystems integratorIntegrator, client acceptsTime policy record with tolerance
Event export and the audit trailBoth platform vendorsIntegratorExport specification with sample file
Retention period and reader listClientClientRetention decision record

Two patterns in that table are worth stating.

First, several rows have an owner and a decider who are not the same organisation. The fail state of a door is decided by the client and implemented by the integrator, and the approval is worthless unless it is written down with a name against it. Leaving the supplier's default in place is not a decision; it is an absence, discovered during a power cut.

Second, the mapping row is the only one whose artefact is built rather than received. It is built by the integrator from two sources that do not agree, and it is the artefact most likely to be wrong, silently wrong, and blamed on somebody else. The survey method behind a reliable door schedule is in Hotel Smart Lock Site Survey, and room assignment as an ongoing discipline in Hotel Smart Lock Room Assignment.

The four mis-allocation errors

Most ownership disputes are caused not by carelessness but by four recurring errors, each of which looks reasonable when it is made.

The first error is allocating ownership of an instruction instead of ownership of its application. The property system vendor is made responsible for issuing access instructions and everyone relaxes. But the instruction is a message, and it can arrive, arrive late, arrive twice, arrive with a stale room reference, or be applied to a door the mapping does not name. Each outcome has a different owner, and a row saying the vendor owns instructions cannot assign any of them. The allocation that works is narrower: the vendor owns the correctness and the emission, the lock platform owns the application, the integrator owns the reconciliation.

The second error is treating the desk as a party. The desk encodes the credential and is therefore assumed to own it. But the desk is instructed, not deciding: it is handed a profile and an encoder and asked to perform an operation, while the template, the personalisation and the rules on what may be issued are held elsewhere. When a card goes out with the wrong name on it, the useful question is which party supplied the template. The desk belongs in the allocation as a responder, not as an owner of data.

The third error is giving the clock to nobody. Time appears in every interface and in almost no contract. Both systems stamp events, the stamps come from different sources, and the difference between them is the difference between a correct reconciliation and an unarguable one. The clock has one owner and one written tolerance, chosen by the party that has to defend a reconciliation, which is the client.

The fourth error is leaving the degraded mode to the installer. What the door does when the link drops is treated as a technical default rather than a business decision. The answer sits between the two architectures the market offers — the centralised arrangement in which the door's behaviour is determined by a server it cannot reach, and the standalone arrangement in which the device holds its own state and the link matters for reporting. The comparison is in Centralized vs Standalone Hotel Locks. Whichever is chosen, the behaviour under failure is the client's approval to record, not the installer's preference to document.

The handover pack and its six artefacts

The ownership split becomes real at the moment responsibility changes hands, and that is where most projects are weakest. The mechanism for a safe handover is a small set of artefacts that travel with the work, each with an owner, a version, a signature and a stated expiry condition.

RefArtefactContents in one lineOwnerMissing it means
H1Door register and mapping registerEvery physical door, its identity, controller, logical room and mapping versionSystems integratorNo baseline, so deviations become investigations
H2Connector configuration recordWhich interface is in use, what it emits, how retries and duplicates are handled, what happens when a message does not arriveSystems integratorThe degraded mode is discovered in production
H3Time policy recordThe authoritative clock, the tolerance, and the action when the tolerance is exceededSystems integratorTwo clocks, and no reconciliation possible
H4Event and export specificationThe fields, the format, the delivery method and a sample exportBoth platform vendorsRecords cannot be produced when asked for
H5Provisioning and decommissioning registerEvery device with its identity, door, owner and a dated removal entrySystems integratorStale devices remain open with no proof of closure
H6Triage and escalation matrixSymptom, first owner, evidence required, escalation route, client action meanwhileSystems integratorA fault at the door becomes a search for blame

The relationship underneath the pack is simple enough to draw, and it is the part most often left implicit. A party holds artefacts, a handover carries them, every artefact has versions, and a version exists because somebody signed for it.

erDiagram
 PARTY ||--o{ ARTEFACT : "holds"
 HANDOVER ||--o{ ARTEFACT : "carries"
 ARTEFACT ||--o{ VERSION : "revisions"
 PARTY {
 string role
 string can_change
 }
 ARTEFACT {
 string artefact_id
 string owner_party
 string expiry_condition
 }
 HANDOVER {
 string trigger
 string from_party
 string to_party
 }
 VERSION {
 string version_ref
 string signed_by
 }

Two of these are more often missing than the rest, and they are the two that matter most in a dispute.

H1 is the baseline. Without the mapping register there is nothing to compare a complaint against, and the two organisations in the argument will each produce their own idea of which door the room refers to. H4 is the record that survives the argument. A trail that cannot be exported to somebody who was not present when the event happened is not a trail; it is a hope, and the export format, retention control and reader list belong to the integration. The published treatment is in Hotel Smart Lock Audit Log Management.

The handover itself is a moment with a trigger, and the trigger should be written down: a party leaves, scope is added, the mapping version changes, an interface is upgraded, or a contract ends. H1 carries the mapping version, H2 the interface version, H5 the device population. Any version change is a trigger, and the pack is reissued rather than annotated.

flowchart TD
 A["Lock supplier delivers hardware, lock-side interface and dated release notes"] --> B["Integrator commissions doors, builds the mapping, issues the door register"]
 B --> C["Property system vendor emits entitlements against that mapping"]
 C --> D["Client accepts the configuration and takes the operating decisions"]
 B --> E["Handover pack issued: registers, time policy, export spec, triage matrix"]
 D --> F["Operating record held by the client"]
 E --> F
 F --> G["Any version change triggers a reissue of the pack"]

The diagram reads as a sequence because the sequence is the easy part. The last arrow is the one that gets skipped: a pack issued once and never reissued is a snapshot of a system that has since changed, and a snapshot that has drifted is worse than none.

Who owns the clock

Events with two clocks cannot be reconciled, and most property system integrations have more than two: the property system server, the lock platform server, the controller on the floor and the device. Each stamps what it observed, and those stamps are different facts.

The ownership question is not which machine is most accurate but which stamp the record is built from. The allocation that works names one source as authoritative, states a drift tolerance, and states the action when the tolerance is exceeded — flag the event rather than accept it silently, because a flagged event is a question and an unflagged one a number nobody will revisit. The tolerance is not a technical constant: ordering a check-in against a checkout needs a tight value, while proving a room unoccupied at a given moment needs one that will withstand an argument. The integrator proposes it, the client signs it.

There is a second clock question that ownership makes visible. The device keeps a buffer of events it could not deliver — the event memory — while the server keeps the audit log, a record of an event with a time and a source. They are not the same thing, and the difference is exactly where events are lost. A device that holds four hundred events through a network fault and delivers them afterwards has behaved correctly; one that drops them has failed, and only a staged test tells them apart. Who owns the event memory during a fault is a real ownership question: the supplier owns the mechanism, the integrator owns the proof that it works, the client owns the consequence of a record that never arrives.

The same separation applies to the controller, which holds the door's state and makes the decision while the reader only reports. The supplier owns what the device does, the integrator owns what the controller was configured to do, and the client owns the approval that made that configuration legitimate.

Who owns the record

The third of the five standing questions is: what is written down, where does it live, and who can read it? If nobody can answer, the integration has not been specified. The answer is almost always a split, and the split is where the privacy exposure sits.

Three record families exist with different readers. The lock's own event stream is operational. The property system's guest and reservation records are business records that already exist for other reasons. The combined record — who presented what, at which door, at which time — is new, because the integration creates it and it identifies people.

That last family is where a CONFIRM-WITH-LOCAL-… line belongs, because the period, the reader list and the handling of a request are set by the operator in the jurisdiction where the building stands, not by any hardware in the corridor.

CONFIRM-WITH-LOCAL-DATA-PROTECTION-REVIEW — whether a record of which credential was presented at which door at which time attracts a defined retention period at this property in this jurisdiction, who inside the operator may read it, whether it is disclosed to guests, and what is owed on a request. The integration creates that record by joining two systems that were not previously joined, so the question belongs to the operator and is answered before the join, not after.

Ownership follows from the answer. The client owns the retention decision and the reader list, because the client can change them and bears the consequence. The integrator owns the implementation, and therefore the proof that the setting matches the decision. The lock supplier owns the export mechanism and the field list; the property system vendor owns what it retains on its own side.

The record ownership settles a recurring fault: the manual override. An override is a change to the door's state made by a person, and its record must exist in a system that will still be readable after the person has left. If it leaves a trace only in the shift logbook, the record is lost with the shift. If it leaves a trace in the access system's own history with an author, a time and a reason, it can be produced later. Who owns that trail belongs with the retention decision rather than with the hardware.

The degraded mode is an ownership document

The fourth standing question asks what happens at the moment the network, the controller or the server is unavailable. The answer is not one thing, and it is not an engineering fact. It is the place where the four organisations meet, and it is where the split either works or does not.

There are three distinct failures and each one has a different owner for the first call.

The network between the two systems goes. What matters for ownership is whether the integration boundary is a local API on a server inside the building or a cloud API on somebody else's service. A local interface makes a building network fault an integration fault, and the integrator owns the diagnosis. A cloud interface puts a third party's availability into the critical path, and the escalation route crosses an organisational boundary nobody in the room controls. The distinction is not an architectural preference; it is a statement about who gets telephoned at two in the morning. Both are covered in Hotel Smart Lock API Integration Guide and Hotel Smart Lock API Requirements for Integrators.

The controller goes. The door stops being a controlled door, and the question becomes which state it holds. Fail-safe and fail-secure name the state a lock takes when its power is removed, but which state applies is settled by the door's role and by the approval the building carries — a product cannot decide it, and neither can the installer. A door on an escape route and a door protecting a server room can reasonably answer differently. The allocation: the client owns the decision, the integrator the implementation, and the approver is named in the record.

The connector goes. Both systems may be perfectly healthy while the thing that ties them together is not. This failure crosses an organisational boundary, and the specification should say who is notified, by what means, and within what window. A connector that dies quietly for a night does more harm than one that dies loudly, because the drift builds up unnoticed and is discovered by a guest.

Two hardware signals are frequently misdescribed in ownership terms. A door position contact reports whether the door is open or closed and nothing more; it reports a state rather than a cause, so a log line concluding the door was forced has gone further than the contact can carry. A request to exit carries the fact that the door was operated from the escape side, and nothing more; it is not an instruction to release, because the escape-side release is built into how the exit device works. The rule that governs the fire interface follows: releasing an opening is not a decision the lock can take, and the fire arrangement belongs to the building's approval route.

CONFIRM-WITH-LOCAL-FIRE-AUTHORITY — for each opening in this building, identify the body that signs off the fire-alarm interface, decide whether that interface sits inside the commissioning scope of the fire system rather than the access system, and state what proof the commissioning has to produce. It is a per-opening question the client obtains; the integrator cannot assume it.

CONFIRM-WITH-LOCAL-BUILDING-CONTROL-BODY — which fail state each opening takes on loss of power, and whose written approval records it as part of the building's classification rather than as a product setting.

The practical point for ownership is that a degraded mode is never written by one party. The client writes it as a decision, the integrator implements it as a behaviour, the supplier enables it as a capability, and the operating staff make it survivable as a procedure. The design belongs in the hands that hold it before the first fault, because the fault will not wait for a meeting. The offline case belongs in the design rather than in an exception list, written before anything ships.

Three delivery models and what each one transfers

There are three ways this work is usually arranged, and the choice is rarely made explicitly. It is made by default, by whoever is willing to start, and the consequences arrive later.

Supplier-ledIntegrator-ledClient-operated
Who holds the connector configurationThe supplier's engineersThe integrator's engineersThe client's own team
Where first-line triage landsThe supplier's support deskThe integrator's helpdeskThe client's IT team
What the client can change aloneAlmost nothing in the seamThe mapping, configuration and schedulesEverything in the seam
What tends to be hiddenThe boundary and its degraded modeThe supplier's behaviour under failureThat the seam was never designed
Which handover is weakestSupplier to integratorIntegrator to clientClient to client, on a departure
What the client is really buyingAvailability of other people's staffOne accountable technical partyThe absence of a dependency

The supplier-led model is attractive where the lock supplier already maintains a connector for that property system. It moves people off the client quickly and leaves the client with no visibility into the boundary. What it hides is the degraded mode, because the party that knows it is not the one the client can call at midnight.

The integrator-led model is the most common and the most durable, because it puts one organisation across the seam and gives that organisation both views. Its weakness is concentrated at a single point: the handover from the integrator to the client's own staff. If the integrator has held the configuration in its own head rather than in the handover pack, the handover transfers a responsibility without transferring the knowledge, and the client finds this during its first serious fault.

The client-operated model removes the seam from the contract and puts it inside the client's organisation. It works where the client has a team that will still be there in three years. It fails quietly when the client has no such team, and the failure is an undocumented integration nobody wants to own. The signal that the model has failed is not a support call; it is the absence of a document.

The choice is not about capability and not about cost, which this guide does not treat. It is about where the knowledge will live in three years, and the test is simple: if the party that operates the system leaves tomorrow, can the next party rebuild the picture from what was left behind?

A fault arrives at a door: the escalation ladder

The fifth standing question is which side owns the fix, and behind it sits the question of who owns the PMS integration once four contracts are signed. The allocation table answers it in principle; the ladder answers it at the moment a person is standing in a corridor with a guest.

The rule that makes the ladder work is that the first owner is not the most likely culprit but the party that can most cheaply establish or eliminate the cause. The escalation path for integration faults is a document, not a phone tree. The party that owns the change follows from the finding, and the ladder is a sequence of cheap eliminations, not accusations.

Symptom observedFirst ownerFirst checkEscalates toClient does meanwhile
Credential refused at a door the desk believes is assignedProperty system vendorWas an entitlement emitted, and with which room referenceIntegrator if the instruction was correctDesk issues a temporary credential
Credential accepted at a door it should not openLock platform ownerAuthority attached to that door against the mappingProperty system vendor if the entitlement was over-scopedDoor supervised, override recorded
Door opens the wrong room after a renumberingSystems integratorMapping register version against the door schedule—Floor walk-round to confirm doors
Events present but with unusable timestampsSystems integratorTime policy record and the drift checkClient if the tolerance is breachedRecords marked as disputed
Records missing for a known periodLock platform ownerEvent memory depth and delivery stateIntegrator for the staged testPeriod recorded as unverified
Override with no trace in the systemClientDelegated authority matrix and the shift recordLock platform owner for the release traceOverride re-recorded with author
Nothing happens at the door after a fire testIntegratorExit-device and interface commissioning recordFire authority, per the building's routeDoor out of service until inspected

The last row is the one that most often gets misrouted. A fire test that releases a door and then produces a fault in the access system looks like an access fault and is treated as one, but the release is not the lock's decision and the fault belongs with the interface the building's authority approved. Ownership here is a matter of record, not of blame.

stateDiagram-v2
 [*] --> Observed
 Observed --> Unowned
 Unowned --> Owned
 Owned --> UnderInvestigation
 UnderInvestigation --> Fixed
 UnderInvestigation --> NotAFault
 Owned --> NotAFault
 NotAFault --> Owned
 Fixed --> Verified
 Verified --> Closed
 Closed --> [*]

The state that matters is Unowned, and a mature project is one in which Unowned is short-lived. It is short-lived when the triage matrix exists and the handover pack is current, because both give the person taking the call something to work from. It is long-lived when the answer to who owns this requires a meeting, and by then the guest has gone.

The Tuesday afternoon the seam was never handed

Here is a composite, and it is included because it is the failure the ownership split exists to prevent.

A property has been running for eight months with a property system integration in place. The original integrator was an outside firm, and it has just been replaced by the client's own two-person IT team, with a handover that lasted a week and consisted of a folder of drawings and a demonstration of the web interface. Nothing in it describes how a refused credential is supposed to be investigated.

On the Tuesday afternoon a guest returns to a room, presents the card issued at the desk, and is refused. The IT team can see that the card is valid in the property system, that the room is assigned and that the lock platform shows the door online. They can also see that the mapping register is not in the folder, because the mapping lived in the departing firm's own tooling.

The first hour is spent looking for the mapping. The second is spent calling the lock supplier, who can confirm the lock is healthy and has no view of the room assignment. The third is spent calling the departing integrator, who asks for a week to respond because they are not the owner any more. By the end of the shift the guest has been re-keyed, the door opened with a mechanical override, and the override written in the shift book because the access system has no field for it.

Nothing here is anybody's fault, and the systems are healthy. But every step of the three hours was caused by one missing thing: no handover pack. There was no door register, so no baseline against which the refusal could be interpreted. There was no connector configuration record, so nobody could say whether the entitlement was emitted with a stale room reference. There was no triage matrix, so the first call went to a supplier rather than to the party that could have eliminated the cause in ten minutes. And there was no override record, so the night's action exists only in a book on a desk.

Run the same afternoon with a handover pack in place and the sequence changes shape. The IT team reads the door register, sees which physical door the room maps to, walks the corridor and reads the door's identity. The connector record shows that the entitlement was emitted with a room reference that does not match the current register. The conclusion is reached by the party that can reach both sides, because the pack told them both sides could be reached from here.

That is the argument for writing ownership down. The difference between the two afternoons is not competence, budget or product quality. It is whether a handover left behind a record the next party could act on without calling anybody.

The five questions with an owner against each

An integration that cannot answer the five standing questions has not been designed. Ownership makes them answerable, because each one has a party that can give the answer and a document in which the answer can be found.

Standing questionThe party that owns the answerThe artefact that carries itThe evidence a reviewer asks for
What does each side send, and what happens when it does not arriveVendor owns emission, lock platform owns application, integrator owns the reconciliationConnector configuration recordThe behaviour when a message is late, duplicated or absent
Who owns the clockIntegrator owns the configuration, client accepts the consequenceTime policy recordThe named time source, the tolerance, the action on breach
What is written down, where does it live, who can read itPlatform vendors own the exports, client owns retention and readersExport specification and retention recordA sample export and the signed retention decision
What happens when the network, controller or server is unavailableClient approves, integrator implements, staff operateDegraded mode statement in the handover packA staged fault test with a recorded observation
Which side owns the fixThe integrator holds the triage matrix, every row names an ownerTriage and escalation matrixA recent fault worked end to end from the first call

Read as a column, the right-hand one is the test of an integration that is genuinely specified. If a reviewer cannot produce the evidence, the answer is owned by nobody, and the table is where that shows up before it becomes an incident.

The cases that prove the behaviour afterwards are set out in PMS Integration: The Test Plan a Buyer Should Demand. Failure modes are in PMS Integration Failure Patterns and How to Recover, and the stages to define before a single door is specified are in PMS Integration for Smart Lock Projects: What Buyers Must Define First.

Written evidence, and the names that need one

The allocation is worth nothing if it rests on what somebody said in a meeting. Each handover-pack row needs a document with a signature. The questions to ask a supplier are in PMS Integration Requirements Document Template, and the format the handover file should take is in Documenting PMS Integration for Handover and Audit.

Some of the hardware described in this market is described against consumer ecosystems — Matter, Thread and Zigbee, each of which must be verified and confirmed on the dated product page for the specific SKU before it is treated as an available path for a property. Others are described against Z-Wave, Apple Home Key, HomeKit and UWB, and the same discipline applies: confirm on the dated product page for the specific SKU, and obtain a written statement naming that SKU and that interface.

What to demandAcceptable form of answerWhat disqualifies the answer
The interface the supplier exposesLocal API or cloud API for the named platform, with the behaviour of each under failure"We integrate with most property systems"
Protocol implementation per modelA written statement naming the model and the interface, datedA statement covering every model in the family
The reader-to-controller pathThe addressing convention, and whether the specified protocol is implemented for that modelA photograph of a wiring diagram
Event and audit exportA field list, a format, a delivery method and a sample exportA list of features written in prose
Instruction identityThe business reference carried, and how a retry is recognisedAn incrementing transport counter alone
Update and rollbackWho may change the interface, when, and how a bad change is withdrawnA note that the supplier manages it
Ownership inside the supplierA named contact who can repeat the answer in writingA general support address

The last row is worth dwelling on. An ownership split that names an organisation but not a person inside it becomes an argument about who was authorised to say what. The supplier that wrote the interface description can extend it; the party that merely sells the hardware cannot, and the difference matters the first time the property system vendor asks for a field that was not in scope.

One more written artefact is routinely missing, and no testing substitutes for it: the specification of what the property system vendor's interface emits. The field list, the room-reference semantics, the behaviour of the acknowledgement and the handling of a duplicate are what a reader-to-controller seam depends on. Whether a product implements a specified protocol is a per-model question, and the path carries its own vocabulary — a Wiegand arrangement is a wiring convention that says nothing about encryption or device identity, while OSDP is a written specification with addressed two-way messages. The controls on that path are in RFID Hotel Lock System Architecture and Hotel Smart Lock Installation Guide.

The boundary that survives a change of team

This guide has boundaries, and they are worth stating so that it is used for what it is good at.

It states nothing about what any product does. Every statement about a product's capability, interface, protocol implementation or conformity route is a question to be answered in writing, on a dated page, for the model concerned. A design decision cannot be taken against an answer that has not arrived, and the ownership split is where that rule bites hardest, because a boundary assigned to a party that cannot discharge it will be crossed at the worst possible moment.

It answers nothing that belongs to the jurisdiction where the building stands. How long a door record is kept, who may read it, how the fire interface is signed off, how an opening is classified and how much force a door demands are settled by the property and the authorities governing it, and this guide carries each as a question with an owner rather than an answer it invented.

It describes no property, operator, supplier or contract. The Tuesday afternoon is a composite, written so that a reader can recognise an afternoon from their own building, and its inclusion is not a claim that any organisation operates this way.

It does not replace the design work. The allocation table has to be filled in against a real door schedule, a real desk procedure, a real staffing pattern and a real estate of interfaces, and none of those can be borrowed from a guide.

What survives all of that is the three-part test every handover has to pass: a versioned artefact, a signature from the party accepting it, and a named owner on the other side. If all three are present, a change of team costs a week. If any one is missing, it costs a guest, a night shift and a morning argument — and the argument will be about who owns it rather than how it works. Samples can be raised through Order Samples so the questions above are asked against hardware. When the allocation, the registers and the triage matrix are written down, the commercial conversation is much shorter, because nobody is buying an outcome whose owner is still undecided — and that belongs at Request a Quote.

Ihr Warenkorb
Ihre Erfahrung auf dieser Website wird verbessert, wenn Sie Cookies zulassen. Cookie-Richtlinie
Chat on WhatsApp