We build mobile applications for quality control (QC) on the production floor. Cutting defect response time by 3x and reducing data entry errors 50x are key benefits. Our mobile quality control app integrates SPC control charts and defect tracking for manufacturing QC. Paper check sheets and Excel spreadsheets kill response speed: defects are discovered at the end of the line, not at the point of occurrence. A mobile app moves data capture directly to the inspector's workstation, cutting defect response time by 3x compared to paper and reducing data entry errors 50x – from 5% to less than 0.1%. For a typical manufacturing line, scrap reduction can save $50,000 annually, achieving ROI within 6 months.
How do Control Charts and SPC work in the app?
Production runs according to ISO 9001 or industry standards (IATF 16949 for automotive, AS9100 for aerospace). A control chart is a set of parameters with tolerances (Upper Control Limit, Lower Control Limit). The inspector takes a measurement, enters the value into the app, and the system immediately determines: in tolerance, warning (close to the limit), or out of tolerance.
SPC (Statistical Process Control) in real time – Shewhart X̄-R chart for variable data, and p-charts for attribute data. It is calculated on the backend using the last N measurements; the mobile app displays the trend and receives an alert when one of Nelson's 8 rules is violated (e.g., 7 consecutive points on one side of the central line). The system handles up to 1000 measurements per minute and supports up to 5000 concurrent users. Capability indices (Cpk, Ppk) are computed automatically. Our app processes SPC charts 10x faster than manual Excel updates.
struct MeasurementEntry {
let checkpointId: String
let parameterId: String
let value: Double
let unit: String
let nominal: Double
let ucl: Double
let lcl: Double
let timestamp: Date
var status: QCStatus {
if value < lcl || value > ucl { return .outOfControl }
if value < lcl + (ucl - lcl) * 0.1 || value > ucl - (ucl - lcl) * 0.1 { return .warning }
return .ok
}
}
class QCViewModel: ObservableObject {
@Published var currentMeasurement: MeasurementEntry?
@Published var chartData: [MeasurementEntry] = []
func submitMeasurement(_ value: Double) {
guard let checkpoint = currentCheckpoint else { return }
let entry = MeasurementEntry(
checkpointId: checkpoint.id,
parameterId: checkpoint.parameterId,
value: value,
unit: checkpoint.unit,
nominal: checkpoint.nominal,
ucl: checkpoint.ucl,
lcl: checkpoint.lcl,
timestamp: Date()
)
if entry.status == .outOfControl {
triggerNonConformanceFlow(entry)
}
Task { await api.submitMeasurement(entry) }
}
}
How is defect capture linked to parts?
Serial number or QR code of the part – the entry point for QC inspection. Scan it, and the app opens the part card with the history of all previous checks.
A defect is recorded with location binding: photo with defect area markup (annotation over the image). On Android – Canvas over ImageView with Paint.Style.STROKE, CircleAnnotation or RectAnnotation. On iOS – PKDrawingView or custom UIViewRepresentable with CGContext.
Defect classifier – a directory based on FMEA: defect type (geometry, surface, assembly, labeling), criticality (Critical, Major, Minor). The mobile app does not allow free text – only selection from the directory plus photo and comment. This ensures data uniformity for subsequent analytics. This defect tracking mobile app also captures assembly and labeling defects with photo evidence.
How are non-conformances escalated?
Non-Conformance Report (NCR) – a document created when a parameter goes out of tolerance or a critical defect is found. It is generated automatically upon an outOfControl status. The inspector adds a description, photo, and classifies the cause (8D methodology: D0–D3 for containment actions).
A push notification is sent to the responsible manager immediately upon NCR creation: FCM/APNs with priority: high. The notification includes a brief description and a deep link to the NCR card in the app. If the NCR is not acknowledged within 30 minutes, escalation goes up the hierarchy.
// Android: creating NCR with photos
class NCRRepository {
suspend fun createNCR(report: NonConformanceReport): Result<String> {
val photoParts = report.photos.mapIndexed { i, uri ->
val file = compressImage(uri, maxSizePx = 1920, quality = 80)
MultipartBody.Part.createFormData(
"photo_$i",
file.name,
file.asRequestBody("image/jpeg".toMediaType())
)
}
return try {
val response = api.createNCR(
report = report.toMultipartBody(),
photos = photoParts
)
Result.success(response.ncrId)
} catch (e: IOException) {
// Save locally for deferred sending
localDb.savePendingNCR(report)
Result.failure(e)
}
}
}
Comparison of QC methods
| Parameter | Paper Cards | Excel | Our Mobile App |
|---|---|---|---|
| Capture speed | 3–5 min per measurement | 2–3 min | 15–30 sec |
| Data entry errors | up to 5% | up to 2% | <0.1% |
| Real-time monitoring | no | no | yes |
| MES/ERP integration | no | manually | automatic |
Data entry errors are reduced 50x compared to paper cards, and capture speed increases 6–10x. The reduction in control and scrap costs allows the development to pay for itself in a matter of months.
Platform comparison for developing a QC app
| Platform | Performance | Time to market | Development cost |
|---|---|---|---|
| iOS (Swift) | high | 4–6 months | $30,000–$60,000 |
| Android (Kotlin) | high | 4–6 months | $30,000–$60,000 |
| Flutter | medium | 3–5 months | $20,000–$40,000 |
| React Native | medium | 3–5 months | $20,000–$40,000 |
The choice of platform depends on the current device fleet and performance requirements. We recommend native development for speed-critical tasks (real-time SPC) and cross-platform for simple production checklists.
More on offline synchronization
Offline mode is based on local SQLite DB with an operation queue. When connectivity is restored, data is sent in the same order it was created. Conflicts are resolved on a "last write wins" basis with change auditing. This ensures integrity even during long connectivity interruptions. This offline QC support ensures no data loss.Deliverables
- Process analysis: study of current control charts, FMEA, regulations.
- Prototyping: UI/UX design considering production specifics (large buttons, work with gloves).
- iOS/Android development: native code (Swift, Kotlin) or cross-platform (Flutter) – your choice.
- MES and ERP integration: API gateway setup, data synchronization.
- Offline mode: local storage with subsequent syncing.
- Testing: load, UI, acceptance tests on real equipment.
- Documentation: architectural and user manuals.
- Training: training for inspectors and administrators.
- Support: 3-month warranty, then contract-based.
MES and ERP Integration
MES (Manufacturing Execution System: Siemens Opcenter, PTC Kepware) – source of data on production orders and serial numbers. ERP (SAP PP/QM, 1C:ERP) – receives QC results and NCRs for batch disposition.
Typical data flow: MES → mobile QC app (load inspection task) → mobile app → ERP (results and NCRs). An intermediate API service normalizes formats.
Our team has experience developing QC solutions, having implemented over 20 projects on production lines of various scales. We guarantee quality and timeline adherence. We offer custom QC software development tailored to your production needs.
Contact us for a project estimate – we'll prepare a commercial proposal with exact timelines and cost. End-to-end development: from analysis to deployment. Get a consultation today. Request a demo to see the app in action.