Smart eyewear OEM/ODM manufacturer · Shenzhen, China +86 19835872450 sales@cynrin.com
OEM & ODM

Engineering Customization: App Integration Questions

An app integration request in a smart glasses OEM programme looks small on paper. You ask the factory to rename the menu, change the pairing screen, add a…

By CYNRIN Engineering & Sourcing Team/ Jul 17, 2024/ 17 min read
Engineering Customization: App Integration Questions

An app integration request in a smart glasses OEM programme looks small on paper. You ask the factory to rename the menu, change the pairing screen, add a language, wire the firmware to your own cloud. Then the quotation comes back, the sample arrives, and the phone app behaves in ways nobody wrote down.

The reason is structural. Firmware and app work is not a feature request that can be appended to a product that already exists. It is a requirement that has to be frozen like any other requirement, verified against a golden sample like any other requirement, and carried into the compliance file like any other requirement. When a buyer treats the app side as a late-stage convenience, the programme stalls at the samples gate.

This article sets out what an app integration request can and cannot change, which changes are engineering work and which are configuration choices, what the buyer has to supply before any app work begins, and how the app-side change is verified when samples are built and verified. It is written for brand-side engineering leads and channel procurement managers who need to ask precise questions of a supplier before a purchase order is issued.

If you are still comparing programme models in general, start with the pillar overview at /oem-odm and then the engineering customisation framework at /oem-odm/engineering-customization. The framework does not change across categories: requirements frozen, feasibility reviewed, engineering and tooling, samples built and verified, compliance file closed, pilot run before mass production. Each stage ends when it produces a document.

Engineering customization for app integration across six gates

Engineering customization and app integration: what changes

The honest way to think about an app integration request is to sort every line of it into one of two buckets. The first bucket is configuration: a change that the factory can apply from an existing build, without new firmware engineering, new tooling, or a new test cycle. The second bucket is engineering work: a change that requires new code, a new build, a new verification cycle, and a new statement about what the shipped product does.

Configuration in the first bucket includes the Bluetooth device name shown during pairing, the menu language set, the default volume limit, the units used in a settings screen, and the pairing sound or haptic cue, provided the underlying capability already exists in the base firmware. These are typically parameter changes carried into a build that has already been validated for the hardware it runs on. They still need to be written into the frozen requirement document, because a parameter that is not written down is a parameter nobody has agreed to.

Engineering work in the second bucket includes any change that alters what the firmware does rather than how a label is written. A new pairing flow, a changed control mapping, a camera function that must trigger from a different gesture, a firmware change that must hand data to a different server, or a change that must survive a firmware update path your brand will own later all sit in this bucket. They are not harder because they are software; they are harder because they change what verification must prove.

There is a third category that buyers frequently misplace. Some requests are neither configuration nor engineering at the factory — they are decisions the buyer has to make about the ecosystem around the product. Which app store the application ships through, whether the buyer ships a mobile app at all or configures an existing one, who operates the backend that the firmware calls, and how an end user obtains firmware updates are all answers the buyer owns. The factory can implement against a specification, but it cannot decide the specification. We will put those questions in front of you before the requirement document is signed, because a missing answer here is what turns a straightforward integration into a delayed one.

The sorting itself is worth doing in writing, because the answer decides who carries the risk. A configuration change is low effort, but it still lands in a build, and a build that contains an unreviewed parameter change still needs to be identified by its version so it can be traced back to what was approved. An engineering change carries a different risk: it alters behaviour, and behaviour is what the verification record makes a promise about. When you sort the request, you are not deciding what is easy, you are deciding what has to be proven. Two suppliers can agree on the same feature list and still produce completely different verification scopes, and the difference shows up later as an argument about whether the samples are acceptable.

A useful test for the second bucket is to ask what would be observably different on the device after the change, and then to ask whether the supplier can describe the check that would detect the difference. A change you cannot describe a check for is not yet specified. Conversely, if you can describe the check, you have most of the engineering work already written, and the quotation becomes far easier to compare across suppliers. Buyers who arrive with a written acceptance criterion usually negotiate better than buyers who arrive with a feature wish list, because the trade-off conversation becomes concrete: either this behaviour is verified, or it is not in the release, and both positions are defensible in a purchase order.

It also helps to record explicitly what is out of scope. Software customisation programmes tend to expand because there is no written boundary, so each new idea is treated as a small addition. A short list of things the release will not do — no cloud sync in this generation, no third-party health integration, no multi-account support — prevents the verification record from growing after the golden sample is signed, and prevents the pilot run from failing on a feature nobody scoped. Scope written down as exclusions is the cheapest control in the whole programme.

A useful discipline is to describe each requested change in one sentence that starts with "after pairing, the user can..." or "when the device is charged, the application shows...". If the sentence cannot be finished without naming a service, an account, or a policy that nobody owns, the request is not yet ready to be quoted. It is still an idea, not a requirement.

Sorting app requests into configuration, engineering and buyer decisions

One more thing belongs here, because it changes the cost and the schedule of everything above. App and firmware work is coupled to the hardware it runs on. A change to the firmware that affects power draw, radio behaviour, or memory footprint can push the product back through the verification steps that were already closed for the hardware. A brand that treats the app request as orthogonal to the hardware plan will discover this at the worst possible moment, which is usually the sample stage when the golden sample is already signed.

AI-generated photograph illustrating engineering customization: app integration questions — image 1 of 3

What you have to supply before the app work starts

An integration cannot be built against assumptions. Before the engineering and tooling stage opens, the buyer has to hand over a specific set of inputs, and it is reasonable for a supplier to say that work cannot start until these exist. Asking for them early is not supplier stalling; it is the only way a build can be matched to a frozen requirement rather than to a guess.

The first input is the account and credential set. This means developer accounts for any platform the application or firmware must register with, test accounts for the backend the device will talk to, and test credentials for the store distribution channel. Whether these sit with the buyer or the factory is a commercial decision and an incoterms question in practice, because it decides who can hold a signing key and who can ship an update at the end of the programme.

The second input is the backend specification. The firmware will make network calls, and each call needs an endpoint, a payload shape, an authentication method, an error response and a timeout expectation. A vendor saying "send data to our server" without these is not a specification. Ask for a written interface document, and ask what happens when the server is unreachable, because the failure behaviour of a wearable is very visible to end users and it must be a decision, not an accident.

The third input is the server-side behaviour. If your backend interprets, filters, or stores what the device sends, that behaviour has to exist and be testable before the device is trusted with real data. If it does not exist yet, it belongs on the critical path, and it belongs on your side of the programme, not the supplier's. This is worth raising early because it is the most common cause of a sample that pairs but cannot demonstrate the full flow.

The fourth input is the app-side decision set. Does the brand ship a proprietary mobile application, or does it configure a factory-supplied application? Which screens exist, and what does each one say? Which controls are exposed on the device itself, and which live only in the app? What happens on first pairing, on firmware update, and on factory reset? Who writes the copy in each supported language?

The fifth input is the distribution and update model. Which store or channel does the application go through, what does the review and release path look like, and does the factory hold the ability to push firmware updates, or does the brand? A product that depends on a mobile application for a core function has a different risk profile if the application is in the brand's own store account than if it depends on a single factory build.

The fifth input carries a subtlety that is worth naming. Who holds the signing key decides who can ship a fix when a defect appears in the field. If the key is on the brand side, the brand controls timing but carries the operational load of every update cycle. If the factory holds it, the factory controls the fix but the brand has less visibility over when it lands. Neither is wrong, but it must be a decision with a name against it, and it belongs in the agreement rather than in an email thread. The same question applies to the backend credentials, the store account and the test accounts — ask whether the factory needs production credentials at all, and prefer a test environment with separate credentials wherever the platform allows it.

The sixth input is the evidence set: which behaviours will be demonstrated, in what order, by whom, and recorded how. That is the subject of the next section.

There is a practical order to all of this that experienced programme buyers follow without being told. Requirements are written in the buyer's own language first, then translated into testable statements, and only then handed over. A requirement written as "the app should feel premium" is untestable; the same requirement written as "the app shows the battery level of the glasses within two seconds of connecting" is testable and can be verified on the production sample. We will push for that rewrite during the requirements stage, because every hour spent sharpening the statement is cheaper than a sample cycle that comes back with a dispute.

One handover point that saves trouble later: version the input documents themselves. Freeze the interface document, the copy deck and the screen list under a revision number, and record which revision the firmware build was made against. Integration projects tend to accumulate small copy edits and small endpoint changes, and without a revision marker nobody can tell later whether a behaviour difference is a regression or an intended change. A short change log attached to the requirement document is enough.

We will treat these inputs as a single freeze event. When they are all present, they become part of the frozen requirement document alongside the hardware configuration, the packaging and the allowed claims, and the firmware build produced in the engineering and tooling stage is matched to that document rather than to a series of verbal instructions. Buyers who want a reference for the kind of feature scope that sits behind these requests can look at the AI feature overview at /tech/ai-features, but the acceptance method matters more than the feature list.

Sequence of buyer-supplied inputs before firmware build and app work begin

AI-generated photograph illustrating engineering customization: app integration questions — image 2 of 3

How the app change is verified at the sample gate

Verification at the samples-built-and-verified gate is where app work either holds up or quietly fails. The gate produces two outputs: a signed golden sample and a verification record. The golden sample is the single unit that represents the approved product; the verification record is the evidence that the sample behaves as the frozen requirement says it should.

For the app and firmware side, the verification record has to cover pairing, audio, charging, any camera function and control behaviour. For an integration specifically, the following checks belong in it and should be read line by line before a golden sample is signed.

  1. Pairing behaviour: the device presents the name defined in the requirement, pairs with the specified application on a specified operating system version, and the pairing experience matches the described flow, including the re-pairing path after a reset.
  2. Application-to-device mapping: every control exposed in the app produces the documented device behaviour, and every device-side control produces the documented app state, with no undocumented side effects.
  3. Network behaviour: the device connects to the specified endpoint, transmits the specified payload, handles the specified error response, and shows the specified behaviour when the service is unavailable.
  4. Update and recovery: the documented upgrade path completes, and the documented reset or recovery path restores the agreed state.
  5. Language and label content: every user-visible string matches the frozen copy for every supported language.

Each check should be repeatable by a person who was not present during development, using the golden sample and a written procedure. That is the point of the golden sample: it removes the need for a memory of what the engineer saw during integration.

Two practical warnings. First, sign the golden sample against a specific firmware build identifier, not against "the latest build". Firmware versions drift, and a golden sample that is only meaningful in the builder's head is not a reference. Second, verify on the hardware configuration that will actually ship. An integration proven on a development board tells you very little about a production unit, and the audio path, the radio behaviour and the power budget are all affected by the hardware.

The failure patterns at this gate are consistent enough to be worth naming, because each one has a cheap preventive answer. The most common is a verification that only proves the happy path: pairing works once, in one network, with one phone model, and the record says "pairing verified". The second is a copy mismatch, where the frozen copy deck was written in the buyer's language and the firmware shipped with default strings in some screens. The third is a backend difference between the test and production environments, so the device behaves correctly against a mock and fails against the real service. The fourth is an update-path gap, where the initial build works and the documented upgrade path was never exercised on a real unit.

Each of these is prevented by a written procedure rather than by a better engineer. Ask for the verification record before the golden sample is signed, not after, and ask whether each check was executed on production-representative hardware and against a named environment. We will put the verification record in front of you for review before the golden sample is signed, because a gate that cannot fail is not a gate, and an unsigned record is not evidence. If the answer is that a check was done once informally, that check is not yet evidence, and it is far cheaper to find that out at the sample gate than at the pilot run. Where a buyer wants independent confidence, an agreed third-party inspection at the gate is a legitimate commercial arrangement to price into the quotation.

Also treat the golden sample as a physical asset with a defined lifecycle. Where is it stored, who may handle it, does it wear out through use, and what happens to it when the programme ends? A golden sample that gets dropped, scavenged or lent out to a customer loses its meaning, and the programme quietly starts comparing production units against a memory instead of a reference. Keep one signed unit, keep it identified, and keep the verification record beside it.

If the app is distributed through a store, the store release is part of the verification set and it has its own review path, so plan for it rather than discovering it. Likewise, any behaviour that depends on the backend belongs in the verification record with the backend in its test state, because a passing test against a live production endpoint tells you about the endpoint, not about the firmware.

Verification matrix mapping integration checks across devices and backends

Once the sample gate closes, the app and firmware configuration has to be carried forward unchanged into the compliance file and into the pilot run. A pilot run on production tooling at production volume, inspected against the golden sample, is what proves the app behaviour is repeatable in a manufacturing context and not just in the integration lab. If the pilot units behave differently from the golden sample on the app side, the golden sample was not the right reference and the requirements were not frozen tightly enough.

AI-generated photograph illustrating engineering customization: app integration questions — image 3 of 3

Questions to ask about an app integration scope

Use these as the core of a supplier questionnaire. They are written so that the answer has to be specific, not so that the answer sounds supportive.

  1. Which parts of our app integration request are configuration changes to an existing firmware build, and which require new engineering work? Please answer per feature, not per project.
  2. What do you need from us before the firmware build starts: accounts, credentials, endpoint documentation, test backend, copy, or distribution arrangement?
  3. Which server-side behaviour must exist in our system before you can verify the device end to end, and who in our organisation owns that work?
  4. What exactly does the golden sample for this project verify on the app side, and how is it recorded so a third party can repeat it?
  5. Which firmware build identifier will the golden sample be signed against, and how do you prevent drift between the golden sample and later production units?
  6. If the app is distributed through a store, which step of our verification plan depends on the store review, and what happens to the programme timeline if that review is delayed?
  7. If the project stops after tooling is completed, what happens to the tooling cost, and what do we own or receive at that point?
  8. What evidence will the pilot run produce that the app behaviour matches the golden sample, and at what quantity will that pilot run be performed?
  9. Which of the marketing claims we want to make about the app experience require evidence beyond the verification record, and are those claims included in the declaration of conformity for the shipping model string?
  10. What is the warranty position on the application and firmware, given that a failure in our backend appears to the end user as a device fault?

Question 7 deserves particular attention. Tooling is the least reversible step in the whole programme, and the written agreement about tooling cost if the project stops should be signed before the tooling is committed, not after. Question 9 is where a lot of buyer-side assumptions meet a hard compliance line: a declaration of conformity covers the exact model string that will ship, and the underlying reports behind it. A claim about app behaviour that is not covered by that evidence should not appear on the packaging.

One more question that deserves a place on the list: what is not published and therefore needs to be asked rather than assumed. In our catalogue we publish what the product is and what the published specification contains, and we keep unpublished items unpublished, including production capacity figures, stage durations, prices, minimum order quantity, and certification status per model. So ask the supplier directly for the commercial terms behind the quotation, the lead time for the tooling and the pilot order, and the certification evidence for the shipping model string. The right answer is a document, not a promise.

When you use these questions, use them to compare rather than to interrogate. The list below is the what to ask the supplier set for an app integration scope, and it is worth reading alongside the commercial frame: quotation basis, MOQ, lead time, incoterms, packaging and spares, warranty, and the pilot order. Every one of those is a what to ask the supplier item rather than a number carried over from an earlier programme, and we will answer them with the documents that exist rather than with figures we do not publish.

A supplier who answers every one of them with a document, even a short one, is telling you how the programme will run. A supplier who declines the commercial questions has told you something useful as well, even if the answer is not the one you wanted. In a negotiation the valuable position is usually the one where the requirement document, the verification record and the compliance file are already written, because those documents constrain cost far more effectively than a specification email ever did. The buyer who arrives with a frozen requirement can negotiate on price, incoterms, spares and warranty; the buyer who arrives with a wish list can only negotiate on the price of discovering what the wish list meant.

That is also why the app work belongs inside the same six-gate sequence as everything else. A firmware build that is matched to a frozen requirement is reproducible. A firmware build matched to a conversation is not, and no amount of good relationship management repairs it when the end customer reports a fault. Write the requirement, freeze it, build against it, verify it on a signed golden sample, carry it into the compliance file for the shipping model string, and prove it again on production tooling at the pilot run.

To go deeper on the commercial and programme side, the customisation options overview at /blog/customization-options-overview sets out the range of programme shapes, and /blog/customization-options-lead-time-impact explains why the shape of a request changes the order of work rather than the number of weeks. The engineering customisation framework at /oem-odm/engineering-customization remains the reference for how the six gates fit together.

In short: an app integration request is a requirement, not a wish. Sort it into configuration and engineering, hand over the inputs the factory cannot invent, freeze it in writing, verify it against a signed golden sample on shipping hardware, and carry it unchanged through the compliance file and the pilot run. That sequence is what separates an integration that scales from one that keeps producing surprises.

Chat on WhatsApp
Your experience on this site will be improved by allowing cookies.