Enterprise Engagement & Wellness App
One React Native app for recognition, goals, social connection and wellbeing — configurable per company, serving a platform used by 100+ enterprises, and built to ship 30% faster.
Anonymized under NDA — the client's name and in-app screenshots are omitted. The engineering is real.
An HR-tech company sells an employee-experience platform to large enterprises — a platform its public site reports serving 100+ companies and over a million employees. The product's thesis: engagement isn't one feature, it's five connected pillars — listening to employees, engaging them socially, caring for wellbeing, empowering growth, and recharging through challenges. Its iOS and Android app had to carry all five, configured differently for every customer. I led the mobile build: the OKR engine, the health integrations, and the modular architecture that let the team ship 30% faster.
15+
Feature modules on one UI architecture
30%
Shorter feature delivery cycles
100+
Enterprise customers on the platform
Platform-published figure
1M+
Employees served
Platform-published figure
- Role
- Senior Software Engineer & Team Lead (contract)
- Timeline
- Apr 2023 – Jul 2023
- Type
- Contract · Enterprise HR tech
- Scope
- Mobile architecture, OKR engine, health integrations, release pipelines
Stack
Chapter 01
Where it started
Inside most enterprises, the employee experience is scattered across five separate tools with five separate logins: a survey tool nobody opens, a recognition portal, a goals spreadsheet, a wellness-benefit app, and a social intranet. Each one sees a sliver of the employee; none sees the person. Adoption suffers everywhere, and HR gets five dashboards that don't agree.
The platform's answer was one app spanning all of it — pulse surveys and feedback, kudos and social feeds, mood and fitness, goals and OKRs, challenges and events. Which created the engineering problem: every enterprise customer wanted a different subset. One cared about OKRs and departments, another about wellness and steps challenges, a third about recognition culture. The app had to be genuinely configurable per company without forking the codebase.
Activity data made it harder. Steps had to come from Apple Health on iOS, Google Fit on Android, and from devices with neither — then feed challenges, tournaments and team leaderboards consistently enough that a cross-platform step challenge felt fair. Company-wide challenges at this scale are not a toy: platform case studies describe single customers logging tens of millions of steps in one program.
And the codebase was feeling its age: each module had grown its own UI patterns and state shapes, so every new feature paid a bespoke-integration tax. With 15+ modules live and more requested, that tax was compounding.
The brief: one app, five pillars, per-company configuration, first-party health data — and an architecture that makes the next module cheaper than the last.
Chapter 02
What I built
The system first, then the people it serves, then the build log of how it came together.
The system
Client
- React Native + Expo app (iOS / Android)
- Section-based configurable dashboard
- Modular UI component layer
- Passcode login, OneSignal push
Core
- Goal & OKR engine
- Standardized Redux (Thunk) state
- Challenges, tournaments, leaderboards
- Karma points and rewards
Services & data
- Apple HealthKit
- Google Fit
- Device pedometer fallback
- Company APIs (Axios)
- Expo AV for audio content
Each company's configuration decides which modules render; the code paths are shared.
One Expo codebase ships both stores. The home dashboard reads the company's configuration and composes itself from the module registry — every module built on the same component layer and the same Redux conventions, which is what keeps fifteen-plus features coherent. Health data is normalized at the integration edge (HealthKit, Google Fit, or the device pedometer) so challenges and leaderboards never care where a step came from. Company APIs sit behind environment-specific gateways, and audio wellbeing content streams through Expo AV.
Who uses it
Employee
- Give and receive kudos, share feedback and ideas
- Track goals and OKRs, see leaderboards
- Join coffee connects, challenges and events
- Use mood, steps, water, breathing and sleep tools
Manager
- Assign goals to members and departments
- Filter OKRs by department in real time
- Run surveys and view team participation
Company admin
- Switch dashboard modules on or off
- Configure holidays, announcements and hierarchy
- Manage karma points and gift redemption
The build log
- 01
A section-based home dashboard where every module — wellness, engagement, social network, goals, surveys — can be switched on or off per company; configuration decides what renders, the code paths stay shared.
- 02
A Goal & OKR engine built from scratch: multi-step target outcomes, leaderboards, multi-member assignment pickers and real-time department filtering, wired into recognition so progress is visible socially, not just in a report.
- 03
Health integrations through native Apple HealthKit and Google Fit APIs with an on-device pedometer fallback, normalized at the edge before feeding challenges, tournaments and team ranks.
- 04
A modular UI component layer and standardized Redux state so new modules follow one pattern — the change that cut duplication across 15+ modules and shortened delivery cycles by 30%.
- 05
The full wellbeing surface in the same app: mood check-ins, water intake, breathing exercises, yoga resources, podcasts, sleep stories and a seek-help flow — small daily touchpoints rather than an annual survey.
- 06
Enterprise plumbing done properly: company APIs behind multi-environment Dev/Prod gateways, passcode login, OneSignal push, and native edge-case fixes for clean App Store and Play publishing.
Chapter 03
Turning points
The moments that shaped the build, and the roads not taken.
Kudos, feedback, goals, coffee connects, events, surveys and wellness all competing for one navigation — and every company wanting a different mix.
- Challenge
- Combine many workplace modules into one navigable mobile experience that reconfigures per customer without diverging builds.
- Approach
- A section-based home with per-module toggles driven by company configuration, consistent module scaffolding, shared components, and standardized Redux underneath — plus multi-environment pipelines so every customer variation ships from the same code.
- Result
- Companies see only what they use, employees get one login instead of five, and the team ships new modules on a known pattern with clean store releases and high crash-free rates.
Steps came from Apple Health on iOS, Google Fit on Android and neither on some devices — and fed company-wide challenges where fairness is the whole point.
- Challenge
- Sync activity across sources without a separate fitness app, consistently enough that cross-platform leaderboards hold up.
- Approach
- Native HealthKit and Google Fit integrations with an on-device pedometer fallback, normalized at the integration edge before anything downstream sees a step count.
- Result
- Consistent step data across platforms powering challenges, tournaments and team ranks — the kind of infrastructure behind the platform's large-scale step programs.
Goals and OKRs had lived in spreadsheets, disconnected from the social fabric the app was building.
- Challenge
- Build a goals engine that handles real org structure — departments, multi-member assignments, cascading outcomes — and still feels like part of a social app.
- Approach
- Designed the engine from scratch: multi-step target outcomes, assignment pickers spanning members and departments, real-time department filtering, and leaderboards that surface progress in the same feeds as kudos.
- Result
- Goal progress became visible and social instead of buried in review meetings — managers filter by department live, and outcomes connect to the recognition loop.
Forks in the road
Multi-tenancy
Took this road
Section-based dashboard per company
Not this one
A fork or build flavour per customer
Configuration, not code, decides what a company sees. One codebase, one release train, every customer current — the alternative is a flavour per enterprise and a team that does nothing but merge.
Goals
Took this road
Build the OKR engine in-house
Not this one
Embedding a third-party goals tool
Goals needed to connect to recognition, leaderboards and department structures inside the app — progress on an OKR should be a social moment, not a form. An embedded tool can't reach any of that.
Activity data
Took this road
Native health APIs with a pedometer fallback
Not this one
Requiring a separate fitness app
Steps feed challenges and team ranks, so the data had to be first-party, consistent across platforms, and available on every device — including the ones with no health ecosystem at all.
Codebase
Took this road
Standardize Redux and a shared UI layer first
Not this one
Shipping features fast on bespoke code
The upfront cost paid back within the engagement: 15+ modules on one pattern and 30% shorter delivery cycles. As team lead, this was mostly about removing decisions — one state shape, one module scaffold, one release path.
Wellbeing design
Took this road
Small daily touchpoints
Not this one
Deep standalone wellness features
A mood check-in that takes four seconds gets used; a wellness portal gets visited once. Lightweight daily surfaces are also what generate the engagement signal the platform's analytics and culture scoring run on.
Chapter 04
Did it work?
What changed, what shipped, and the notes I kept for next time.
Five tools vs. one app
| Dimension | Before | After |
|---|---|---|
| Products | Separate tools for recognition, goals, wellness, social, surveys | One app with modules switched per company |
| Listening | An annual survey nobody trusts | Pulse check-ins and feedback woven into daily use |
| Goals | Spreadsheets and status meetings | OKR engine with outcomes, leaderboards, assignments, department filters |
| Steps and activity | Manual entry or a separate fitness app | HealthKit, Google Fit and pedometer fallback feeding challenges |
| New module cost | Bespoke UI and state each time | Shared component layer and standardized Redux; 30% faster delivery |
| Releases | Manual, environment mix-ups | Dev/Prod pipelines, store-ready builds |
The signal layer on top
The engagement data this app generates isn't just dashboards — the platform runs intelligence on top of it. Every pulse response, recognition event and participation signal feeds models that turn daily touchpoints into early warnings and a live read on culture. The mobile surfaces I built are where that signal originates.
~60 days
Earlier attrition-risk flags
The platform reports its AI flags employees at risk of leaving roughly two months before traditional indicators — from shifts in engagement, sentiment and participation patterns.
1
Culture score per company
Pulse surveys, recognition flow and participation roll up into a single live culture metric leadership can actually track, instead of an annual survey snapshot.
42%
Participation increase
Platform-published customer figure after consolidating engagement into the one-app experience — the adoption problem the five-tool world could never solve.
87%
Employees reporting they feel connected
Platform-published survey figure across customers — the pillar metrics the product is sold on, generated by the daily surfaces in this app.
AI in the build itself · The figures above are the platform's published numbers, not measurements I ran. My part was the instrumentation side of the loop: making the daily touchpoints lightweight enough that people actually use them — because the models are only as good as the signal the app collects.
Shipped and standing
- One app replaced separate recognition, goals, wellness, social and survey tools — one login, five pillars, per-company configuration.
- Goal & OKR engine with outcomes, leaderboards, assignments and real-time department filtering built from scratch.
- HealthKit and Google Fit integration with pedometer fallback feeding challenges and leaderboards consistently across platforms.
- Duplication cut across 15+ modules; feature delivery cycles shortened by 30%.
- Multi-environment pipelines and native fixes delivered smooth store publishing and high crash-free session rates.
- The daily-touchpoint surfaces feed the platform's analytics and AI layer — culture scoring and early attrition-risk signals run on the data this app collects.
Notes to self
Note 01
Configuration beats forks. Per-company toggles kept one codebase honest across 100+ very different customers.
Note 02
A shared component layer is the fastest feature you can build; everything after it is cheaper.
Note 03
Health data is messy across platforms; normalize at the edge and the rest of the app stays simple.
Note 04
Engagement features are secretly instrumentation. The four-second mood check-in matters because of the signal it generates, not the screen it shows.
Note 05
Leading a team is mostly removing decisions: one state pattern, one module scaffold, one release path.