HomeCase studiesA Multi-Sensor Consumer Privacy Application for Detecting...

Case study · Munich, Germany

A Multi-Sensor Consumer Privacy Application for Detecting Concealed Recording Devices

Consumer privacy and personal security utilities

Most apps in this category implement one detection method, present it as a spinning dial, and alarm at every metal fixture — which teaches users to ignore them. Our team built a native iOS application that applies three genuinely independent detection techniques, so findings can corroborate one another rather than resting on a single ambiguous reading. It combines magnetic sensing, camera-based optical analysis with performance-critical processing in C++, and local network host discovery, wrapped in an interface built for an anxious non-technical user and monetised through a hybrid advertising and subscription model.

Industry
Consumer privacy and personal security utilities
Solution
A self-contained native iOS application with on-device sensor processing, hosted content services, and freemium monetisation.
Platforms
iOS
Stack
Objective-C
Location
Munich, Germany · delivered remotely
Role
Engineering, with the team behind for mobile and QA

Delivered remotely for a business based in Munich, Germany. Names withheld by agreement.

Project Overview

Industry: Consumer privacy and personal security utilities.

Type of solution: A self-contained native iOS application with on-device sensor processing, hosted content services, and freemium monetisation.

Business context: Concern about concealed recording devices in rented accommodation, hotels and changing facilities is a real and growing consumer anxiety, and a category of apps has grown up to serve it. Most of them are not useful. They implement a single detection approach — typically a magnetometer readout — and present it with enough theatre to feel convincing until the user notices it reacts identically to a door hinge. That gap between the anxiety and the quality of the available tools was the commercial opportunity.

General users: Consumers checking a space they are occupying — travellers, renters, and anyone with reason to be concerned about privacy in an unfamiliar room.

General purpose: To give a non-technical person several independent ways to check a space, and enough interpretation to know what the results mean.

The Business Challenge

One detection method is not enough to be trustworthy. Any single sensor reading in this domain is ambiguous. Magnetic readings respond to any ferrous object; optical reflection responds to any shiny surface. Without corroboration, a positive result carries almost no information.

False positives destroy the product. A tool that alarms constantly trains its user to disregard it — which means it fails precisely in the case it exists for. Restraint matters more than sensitivity.

The user is anxious and not technical. Someone using this application is already uneasy. Presenting raw sensor values would be both unhelpful and distressing. The interpretation layer is as important as the detection itself.

Modern cameras are network devices. A concealed camera that is optically hidden and magnetically unremarkable may still be connected to the local network — a completely different detection surface that most competing products ignore entirely.

Real-time frame analysis is demanding. Analysing camera frames as they arrive, on the device generations this category needs to support, is at the edge of what an interpreted layer can do comfortably.

Occasional-use utilities are hard to monetise. People use a tool like this a few times a year. Subscription alone would not convert; advertising alone would not sustain. The model had to accommodate both usage patterns.

Sustained sensing drains batteries. Scanning uses camera, motion sensors and networking simultaneously, in a situation where the user may be away from a charger.

Our Approach

Build three independent detection paths, deliberately. The product's entire credibility rests on corroboration. Magnetic sensing, optical analysis and network discovery have uncorrelated failure modes — a metal fixture that triggers one will not trigger the others — so agreement between methods carries real information in a way that any single reading cannot. This was the founding decision and everything else followed from it.

Treat network discovery as a first-class method. Because many concealed cameras are network-connected, host discovery across the local network was built as a full detection modality rather than an afterthought. It finds a class of device the other two methods cannot see at all, and it is the capability most competing products omit.

Drop into C++ where performance requires it. The optical analysis path processes camera frames as they arrive, which is not a workload to leave in a higher-level layer on older hardware. The analysis is implemented in C++ with a bridging layer into the interface code — a deliberate, contained use of a lower-level language exactly where it earns its complexity.

Make interpretation part of the product. Onboarding, information content and guidance were built as core features rather than help-screen afterthoughts, because a reading the user cannot interpret is not a result. The product's job is to help someone decide what to do, not to display a number.

Let users record what they find. Photo capture with a review view turns a momentary reading into something durable — evidence a user can keep, show to someone, or act on. That is the difference between a scanner and a tool.

Monetise for both usage patterns. Advertising covers the occasional user who scans a hotel room twice a year; subscription serves the frequent user who wants an uninterrupted experience. Neither model alone fits a utility used sporadically.

Keep the backend footprint minimal. With no server-side business logic — all detection runs on the device — remote content and configuration are served from a hosted realtime database rather than bespoke infrastructure, keeping operating cost proportionate to a consumer utility.

The Solution

Magnetic field detection. Device motion sensing identifies magnetic characteristics associated with electronic devices, giving the user a first, fast way to sweep a space.

Optical lens detection. The camera pipeline feeds custom image analysis that looks for the distinctive optical signature a lens produces — a method that finds devices with no meaningful magnetic signature at all.

Local network discovery. Host discovery across the local network identifies network-connected devices present in the space, covering the increasingly common case of a camera that is neither visible nor magnetically detectable but is quietly connected to the same Wi-Fi.

Guided onboarding. A walkthrough introduces the detection methods and how to use them, because the techniques are only effective when applied properly — sweep speed and proximity both matter.

Interpretation and guidance content. In-app information explaining what each method detects, what a result does and does not mean, and what to do next.

Photo capture and review. Users photograph anything they find, with a detail view for reviewing captures — turning a transient reading into a durable record.

Progress and feedback during scanning. Custom animated indicators and audible feedback give the user clear, continuous signalling during a scan, which matters when their attention is on the room rather than the screen.

Subscription and advertising. A subscription removes advertising and unlocks the full experience, while advertising supports free use — accommodating both the occasional and the frequent user.

Content and communication. Remotely served content, email capture with mailing-platform integration, and push notification support for reaching users after installation.

Key Features

Three independent detection modalities Magnetic, optical and network-based detection with uncorrelated failure modes, so results can corroborate one another instead of resting on a single ambiguous reading.

Local network host discovery Detection of network-connected devices present in the space — a class of device invisible to both magnetic and optical methods, and one most competing products do not attempt.

Camera-based optical analysis with C++ processing Per-frame analysis of the camera feed implemented in a lower-level language for throughput on older hardware, bridged cleanly into the native interface layer.

Magnetic field sensing Device motion sensing providing a fast initial sweep of a space for magnetic signatures associated with electronic devices.

Interpretation-first design Onboarding, guidance and explanatory content treated as core features, because a sensor reading a user cannot interpret is not a usable result.

Photo capture and review Findings can be photographed and reviewed, turning a momentary detection into a durable record the user can act on.

Clear in-scan feedback Custom animated progress indicators and audible cues providing continuous signalling while the user's attention is on the room rather than the screen.

Hybrid monetisation Advertising for occasional users and subscription for frequent ones, matched to the sporadic usage pattern of a utility application.

Minimal backend footprint All detection runs on the device, with only content and configuration served remotely — keeping operating cost proportionate to a consumer utility.

Technical Architecture

Detection layer. Three independent pipelines, each reading a different sensor surface: device motion for magnetic sensing, the camera capture pipeline for optical analysis, and platform networking for local host discovery. Each produces results independently, and the interface presents them together.

Image analysis layer. Camera frames are processed through custom analysis implemented in C++ with supporting data-structure utilities, bridged into the application through Objective-C++ so the performance-critical path stays out of the interface layer.

Presentation layer. Native interface code composing scanning, results, capture, review, information and subscription flows, with custom animated indicators providing continuous scan feedback.

Media layer. Camera capture, image handling and photo review, with audible feedback for capture events.

Content and configuration layer. A hosted realtime database serving remote content and configuration, avoiding bespoke backend infrastructure for an application with no server-side business logic.

Monetisation layer. Platform in-app purchase handling behind a purchase wrapper with a dedicated subscription interface, alongside an advertising integration for non-subscribed use.

Instrumentation layer. Analytics, crash reporting and push notification support for understanding real-world usage and reaching users after installation.

Flow: Device sensors (motion / camera / network) → Three independent detection pipelines → C++ analysis on the optical path → Interpretation and presentation → Photo capture and review → Hosted content and configuration

Technology Stack

Category Technology
Platform Native iOS
Languages Objective-C, Objective-C++, C++
Motion sensing Core Motion
Camera & media AVFoundation, Core Video, Core Media, Image I/O
Image analysis Custom C++ processing with supporting data-structure utilities
Networking Platform networking with ping-based local host discovery
Remote data Hosted realtime database
Monetisation Platform in-app purchase behind a purchase wrapper; mobile advertising SDK
Media loading Remote image loading with caching
Interface Custom animated activity indicators, progress components, keyboard management
Audio AudioToolbox for capture feedback
Instrumentation Analytics, crash reporting and push notification SDKs
Dependencies CocoaPods, with some SDKs vendored into the repository

Technical Challenges & Solutions

Challenge Our Approach
A single detection method producing ambiguous, untrustworthy results Three independent detection modalities with uncorrelated failure modes, so corroboration between methods carries real information — the founding architectural decision, and the product's entire differentiation.
Network-connected cameras being invisible to sensor-based detection Local network host discovery built as a full detection modality, covering a class of device that magnetic and optical methods cannot detect at all.
Per-frame camera analysis on older hardware The analysis path implemented in C++ and bridged into the interface through Objective-C++, keeping the performance-critical work out of the higher-level layer while containing the lower-level code to where it is justified.
False positives training users to ignore the tool Multiple corroborating methods rather than a single sensitive alarm, combined with interpretation content that explains what a result does and does not indicate.
An anxious, non-technical user faced with sensor output Onboarding, guidance and explanatory content built as core product features rather than help screens, because interpretation is what turns a reading into a decision.
A transient reading having no lasting value Photo capture with a review view, so a finding becomes a durable record the user can keep, show or act on.
Monetising a utility used a few times a year A hybrid model — advertising supporting occasional free use, subscription serving frequent users — because neither model alone fits sporadic usage.
Sustained camera, sensor and network use draining the battery Scanning implemented as bounded operations with lightweight interface work during scans, rather than continuous background sensing.

Security & Reliability

Permission-scoped sensor access. Camera, motion and local network access are requested through the platform permission model, each intrinsic to a specific detection method rather than requested speculatively.

On-device processing. All detection and analysis runs locally on the device. Sensor data and camera frames are processed on the handset rather than transmitted for server-side analysis, which is the appropriate design for an application used in private spaces.

Minimal data footprint. With no server-side business logic and no user account model, the application holds no meaningful personal dataset — remote services carry only content and configuration.

Measured presentation of results. The interface is built to communicate what each method indicates rather than to present findings as definitive, because a detection tool that overstates its certainty misleads users in both directions.

Instrumentation. Crash reporting and analytics provide visibility of real-world failures and usage across a wide range of device generations.

Platform-managed purchases. Subscription entitlement is handled through the platform's own in-app purchase infrastructure behind a dedicated purchase wrapper.

Scalability & Performance

On-device detection. Because all processing happens on the handset, the application's capacity is not bounded by server infrastructure and its operating cost does not scale with usage.

Native and lower-level processing. Per-frame image analysis in C++ keeps the optical detection path viable on older devices, where an interpreted implementation would not sustain the frame rate.

Bounded scan operations. Scanning runs as discrete bounded operations rather than continuous background sensing, limiting battery and thermal impact.

Lightweight scan-time interface. Custom lightweight animations provide feedback during scanning without competing with the detection pipelines for processing capacity.

Cached remote content. Remote imagery loads through a caching loader, keeping content responsive without repeated fetching.

Minimal backend dependency. A hosted realtime database for content and configuration means there is no bespoke infrastructure to scale, monitor or maintain.

Business Outcomes

  • Results can be corroborated, because three independent methods with uncorrelated failure modes replace a single ambiguous reading.
  • A whole class of device is detectable that sensor-only competitors cannot find, through local network discovery.
  • Users can interpret what they are seeing, because guidance and explanation were built as product features rather than help content.
  • Findings become durable, through photo capture and review rather than a reading that disappears when the screen changes.
  • The application performs on older hardware, because the demanding analysis path was implemented at the right level.
  • Both usage patterns are monetised, with advertising for occasional users and subscription for frequent ones.
  • Operating costs stay proportionate, since detection runs entirely on the device and the backend footprint is minimal.

Why it worked

Utility applications look simple from the outside and are frequently where engineering judgement matters most, because there is nowhere to hide. There is no feature list to distract from the fact that the core function either works or does not.

Our team built this one around a single honest observation: any one sensor reading in this domain is ambiguous, so a product resting on one method cannot be trustworthy however well it is presented. Three independent methods with uncorrelated failure modes is a harder engineering commitment — three pipelines, three sets of failure characteristics, three things to explain to the user — and it is the only version worth building. We then put the demanding work where it belonged, dropping into a lower-level language for per-frame analysis while keeping that code contained rather than letting it spread.

We also treated interpretation as engineering scope. For a product whose users are anxious and non-technical, the difference between a number on a screen and a decision the user can make is the entire value of the application. Our teams work across native mobile with direct sensor, camera and networking integration, performance-critical processing, and platform monetisation — and, importantly, know when a product's real challenge is not the code but what the code is asking the user to understand.

Final Summary

Concern about concealed recording devices in unfamiliar spaces is real, and the applications addressing it are mostly theatre — one sensor, one dial, and an alarm that reacts to the nearest door hinge. Users work that out quickly, and the category's credibility suffers for it.

Our team built a native iOS application on the opposite premise: that a single reading in this domain is ambiguous by nature, so trustworthiness has to come from corroboration. Three independent detection methods run in the product — magnetic sensing through device motion, optical analysis of the camera feed, and local network host discovery — chosen specifically because their failure modes do not correlate. The network method matters disproportionately, because it finds connected cameras that are invisible to both of the sensor-based approaches and that most competing products do not attempt to detect at all.

The optical path processes camera frames through analysis implemented in C++ and bridged into the native interface, keeping it viable on older hardware. Around the detection core sit the things that make the results usable: onboarding and guidance that explain what each method indicates, photo capture so a finding becomes a durable record, and clear feedback during scanning for a user whose attention is on the room rather than the screen. A hybrid advertising and subscription model matches the sporadic way a utility like this is actually used, and with all detection running on the device, the backend footprint — and the operating cost — stays proportionate to what the product is.

01 — Questions

asked about this kind of project

How do you build a mobile app that uses device sensors?

Access the sensor through the platform's motion, camera or networking frameworks, and design around the fact that raw sensor data is noisy and ambiguous. The engineering effort in a sensor application is rarely in reading the sensor — it is in filtering, in deciding what constitutes a meaningful signal, and in presenting a result the user can act on. Products in this space fail on interpretation far more often than on data capture.

When should you use C++ in a mobile application?

When there is a genuinely performance-critical path, most commonly per-frame image or signal processing, and particularly when older hardware must be supported. Bridge it cleanly into the native layer and keep it contained to the section that needs it. Using a lower-level language across the whole application costs maintainability for no benefit; using it precisely where throughput matters is a sound trade.

Can a mobile app scan the local network?

Yes, though platform rules have tightened considerably. Host discovery across the local subnet is achievable, and current platform versions require explicit local network permission and present the user with a clear disclosure. Any application relying on this should verify its compliance against current platform policy, because the requirements in this area have changed more than once.

How do you avoid false positives in a detection application?

Use more than one method, and choose methods whose failure modes do not correlate. A single sensitive detector produces constant alerts that train the user to dismiss them — which means it fails in the one case it exists for. Corroboration between independent methods is what makes a positive result meaningful, and restraint is worth more than sensitivity.

How do you monetise a utility app that people use infrequently?

Hybrid. Subscription alone fails because occasional users will not commit to a recurring charge for a tool they open twice a year; advertising alone rarely sustains development. Combining them — advertising supporting free occasional use, subscription removing it for frequent users — matches revenue to the two genuinely different usage patterns a utility attracts.

How do you design an app for a user who is anxious or under stress?

Reduce what they have to decide, and explain what they are seeing. Guidance and interpretation should be product features rather than help screens, because a stressed non-technical user presented with a raw reading is left worse off than before. Giving them a clear next step matters more than giving them precise data.

Does an app like this need a backend?

Not necessarily. Where all processing happens on the device and there is no user account or shared state, a hosted service for content and configuration is sufficient — no bespoke infrastructure to build, scale or maintain. Matching backend investment to what the product genuinely requires is a significant cost decision, and over-building it is one of the more common early mistakes.

How do you keep an older native codebase viable?

Assess dependencies regularly, because third-party SDKs are the usual point of failure — vendors discontinue products, platforms raise minimum requirements, and permission rules change beneath applications that were compliant when written. Native code itself ages comparatively well; the ecosystem around it does not. Periodic dependency and platform-policy review is what keeps an otherwise sound application shippable.

03 — Similar project?

describe what is different about yours

Build yours.

Tell me what exists, what you need and the deadline. Fixed price for a defined scope, or hourly from $10 with a written estimate first.

Ahmedabad, India · IST (UTC+5:30) · --:-- IST · Mon–Fri 09:00–18:00 IST · US & EU overlap daily

No newsletter, no CRM. Just a reply.