How AccelOne rebuilt a failing safety app in two structured phases, restoring every feature and returning the platform to subscription growth.
In brief: A personal safety app's legacy backend had degraded to the point where core features, including video processing and user sign-up, were failing. AccelOne overhauled the platform in two phases: first running a parallel Node.js + Express backend to restore features without disrupting users, then completing a full backend rewrite, building a dedicated Node.js media server, and migrating iOS to Swift 5. All features restored. The platform is now gaining new subscriptions weekly.
2
Structured delivery phases
Swift 5
iOS app fully migrated
100%
Features restored and working
Weekly
New subscriptions gained post-launch
New
Dedicated Node.js media server built
What was wrong with the original safety app?
The client's personal safety app had been built on an aging architecture that had not kept pace with changes in iOS, modern backend standards, or its own feature requirements. What had started as isolated issues had compounded into a platform that was failing its users at the moments they needed it most.
The app's core safety feature (video recording and processing) was unreliable. Videos failed to process, leaving a gap in the product's most critical capability.
User registration was failing, making it impossible for new users to create accounts. Subscription growth had stalled as a direct result.
The iOS app was built on an older Swift version with outdated libraries, causing compatibility failures on the latest iPhone models and iOS versions.
The legacy infrastructure was expensive to run and difficult to maintain, costs were rising while reliability was declining. The architecture did not scale.
The app also had an undocumented legacy: critical backend components had no documentation, and the back-office website and events page contained additional components that needed to be understood before anything could be safely rebuilt. This is the condition that makes legacy modernization genuinely difficult, not the technical work, but the absence of a map.
How did AccelOne approach rebuilding without breaking a live app?
A personal safety app cannot have a gap in service. Users depend on it. The modernization strategy had to be sequenced to restore functionality incrementally, never leaving the platform in a worse state than before.
AccelOne's Phase 1 approach was to run the new Node.js + Express backend in parallel with the legacy system, using the same existing database. This meant the old system remained live while the new one was validated against real data, no big-bang cutover, no extended downtime, no risk of losing data that existed in the legacy database.
Only after the new backend had been validated, features restored, and the media server built did the team complete the full switch in Phase 2. This phased approach is a standard risk-mitigation technique for legacy modernization, but executing it well requires the team to understand the legacy system deeply enough to run both in parallel without conflict.
What happened in each phase of the modernization?
→ Library and framework updates: iOS and Android app libraries updated to current versions to restore basic stability and compatibility.
→ Parallel backend creation: New Node.js + Express backend built and run alongside the legacy system, sharing the same database to enable incremental validation.
→ Feature restoration: Several core app features restored to working order. Video processing and sign-up issues persisted, requiring Phase 2 work.
→ Reverse engineering: Legacy backend components mapped and understood through code review. Back-office website and events page components documented for Phase 2.
→ Complete backend rewrite: Legacy backend fully replaced with a modern Node.js + Express architecture. No legacy dependencies remaining in the core system.
→ Media server creation: Dedicated Node.js media server built specifically for video processing, separating this workload from the main application backend for reliability and performance.
→ iOS Swift 5 migration: Full migration of the iOS app to Swift 5, updating all libraries and ensuring compatibility with the latest iPhone models and iOS versions.
→ Video and sign-up resolution: Most video sections rewritten for improved performance. Sign-up issues fully resolved. Both features now working reliably.
→ Crash and bug monitoring: Monitoring implemented across all devices to track app stability and surface performance issues before users encounter them
Why did the safety app need a dedicated Node.js media server?
Video is not just a feature in a personal safety app, it is the feature. When a user records a safety incident, that video needs to be received, processed, stored, and accessible immediately. A failure in video processing is a failure in the product's core promise.
✘ Video processing handled by the general backend
✘ Processing frequently failed or timed out
✘ No dedicated capacity for media workloads
✘ Failures affected other app functionality
✘ No performance monitoring for video pipeline
✔ Dedicated server for video processing workloads only
✔ Faster processing with dedicated capacity
✔ Always available, independent of main backend
✔ Media failures isolated from core app functions
✔ Purpose-built for the safety app's video requirements
What does migrating an iOS app to Swift 5 involve?
The iOS app's outdated Swift version was causing two distinct categories of problems: compatibility failures with current iOS versions and the latest iPhone models, and a codebase that was increasingly difficult to maintain as Apple's frameworks evolved.
AccelOne's Swift 5 migration covered the full scope of what a version migration requires in a production app:
-
Source code updated from the legacy Swift version to Swift 5 syntax and APIs
-
Third-party libraries and frameworks updated for Swift 5 compatibility
-
Breaking API changes from newer iOS versions identified and resolved
-
Most video-related code sections rewritten for improved Swift 5 performance
-
Compatibility verified against the latest iPhone models in use
-
Crash and bug monitoring implemented to catch regressions post-migration
The video code required the most significant rewrite, it was both the most outdated and the most critical section. AccelOne treated this not as a migration but as a rebuild of the video layer, which ultimately produced more stable and performant behavior than the original code had ever achieved.
How does AccelOne handle legacy modernization without documentation?
The most common assumption about legacy modernization is that the hard part is writing new code. It isn't. The hard part is understanding the old code well enough to know what the new code needs to do, especially when the original developers are unavailable and documentation was never written.
01. Preparation before any development
AccelOne's first phase established a complete understanding of the app before writing a line of new code. This included reviewing legacy backend components, the back-office website, and the events page to understand all existing functionality and dependencies.
02. Identifying critical points
Beyond understanding what the code did, the team identified which components were most fragile, most business-critical, and most likely to cause problems during migration. This informed the sequencing of all subsequent work.
03. Parallel validation before cutover
The parallel backend approach meant the new system could be validated against the legacy system using real data before the old system was decommissioned. Any behavioral differences were identified and resolved before users were exposed to the new backend.
04. Rigorous testing throughout
Rather than a single test phase at the end, AccelOne tested continuously through development and migration, with the QA engineer embedded in the team, not engaged separately at the end of the project.
What technology stack was used for the modernization?
Node.js + Express, full backend rewrite replacing the legacy system
Node.js, dedicated server for video processing, independent of the main backend
Swift 5, full migration with updated libraries and latest iPhone compatibility
Existing database retained, new backend built to use the same data without migration risk
Crash and bug monitoring, implemented across devices for stability tracking
Phased delivery, parallel build before full cutover; continuous QA throughout
How was AccelOne's team structured for this project?
Swift 5 migration, library updates, video code rewrite, iPhone compatibility, crash monitoring implementation.
Node.js + Express backend development, media server build, legacy reverse engineering, parallel system architecture.
Phase planning, client coordination, team integration, timeline management across both delivery phases.
Continuous testing through development and migration, stability verification, regression testing across iOS and backend.
The team embedded directly with the client's internal teams, working within their existing workflows while bringing the external perspective needed to evaluate the legacy architecture objectively. This integration also meant that knowledge built during the project stayed within the combined team rather than leaving with AccelOne at handoff.
What were the results?
✔ All features restored and working as expected
✔ Video processing faster and always available
✔ Sign-up issues fully resolved
✔ Backend stable, scalable, and modern
✔ iOS app compatible with latest iPhones
✔ New subscriptions gained every week
✔ Operational costs reduced
✔ Codebase future-proofed on current frameworks
The result that matters most is the simplest: the platform is gaining new subscriptions weekly. For a safety app that had lost market competitiveness due to reliability failures, subscription growth is not just a business metric. It's evidence that users trust the product again, that it works when they need it.
Frequently asked questions
What was wrong with the personal safety app before AccelOne's involvement?
The app's legacy backend had degraded to the point where core features were failing, including video processing and user sign-up. The outdated iOS codebase was causing compatibility failures on the latest iPhone models. High operational costs and poor user experience had eroded market competitiveness and stalled subscription growth. The codebase was also largely undocumented, requiring reverse engineering before rebuilding could begin.
How did AccelOne approach rebuilding a legacy app without breaking existing functionality?
AccelOne used a two-phase parallel build approach. Phase 1 ran the new Node.js + Express backend alongside the legacy system using the same database, restoring features incrementally without disrupting active users. Phase 2 completed the full rewrite, built the media server, and migrated iOS to Swift 5. Running the new system in parallel before cutover allowed validation against real data before the legacy system was decommissioned.
What does migrating an iOS app to Swift 5 involve?
Migrating to Swift 5 involves updating source code to current Swift syntax and APIs, updating third-party libraries for Swift 5 compatibility, resolving breaking API changes in newer iOS versions, and verifying compatibility with the latest iPhone models. In this project, most of the video code sections required a full rewrite, not just migration, because the legacy video implementation was both outdated and the primary source of instability.
What is a Node.js media server and why did the safety app need one?
A Node.js media server is a dedicated backend service for receiving, processing, and delivering video. The safety app's legacy system had video processing failing regularly because it ran on the general backend without dedicated capacity. AccelOne built a purpose-built media server to handle this workload separately, making video processing faster, always available, and isolated from the main application backend so media failures can't affect other app functions.
How does AccelOne handle legacy app modernization without documentation?
AccelOne begins with a thorough preparation phase: reverse-engineering legacy backend components, reviewing code for the back-office website and events pages, and identifying critical testing and development points before writing any new code. The parallel build approach, running new and old systems simultaneously, then allows the team to validate behavior against real data before switching users over, catching any behavioral differences that weren't visible from the legacy code alone.
What were the results of AccelOne's personal safety app modernization?
All app features were restored and working as expected. Video processing became faster and consistently available. Sign-up issues were fully resolved. The new backend and media server are stable and scalable. iOS users on the latest iPhone models see significantly improved performance. The codebase is now on current framework versions, ensuring ongoing support for modern iOS releases. The platform is gaining new subscriptions weekly.
What team does AccelOne use for mobile app legacy modernization?
AccelOne deployed a four-person nearshore team: a Senior iOS Engineer, a Senior Backend Engineer, a Technical Project Manager, and a QA Engineer. The team embedded directly with the client's internal teams, working within existing workflows while bringing the external perspective needed to assess and rebuild the legacy architecture objectively.