Honoring
Our Industry Achievements
Industry
SaaSPlatform
Android Mobile Application
iOS Mobile Application
Technology Stack
Compose for Android application
Swift for iOS Application
ASP.NET for Backend Development
Overview
BioTime is a mobile application designed to streamline employee time tracking and attendance management. it offers a convenient and efficient way for employees to record their work hours, while providing employers with real time data and insights.
Ultimately, BioTime aims to enhance operational efficiency, improve workforce management, and provide valuable data for informed decision-making.
Key Features
- Users can conveniently record their punch-in and punch-out times with accurate location tracking to ensure reliable attendance records and transparency.
- The system provides flexible options to select job codes, add detailed comments, and indicate travel status so work activities are clearly documented and easy to review later.
- Employees can submit leave requests while tracking approval status in real time with clear indicators such as Approved, Declined, or Pending.
- The platform displays upcoming shift schedules along with total worked hours for the week, helping users manage time efficiently and stay informed about their workload.
- Punch-in and punch-out records are neatly organized for the current pay period, making it simple to review attendance summaries and verify logged hours.
- A complete activity history is maintained with date, time, and location details for every entry, providing full transparency and easy access for audits or reporting.
Challenges
- Capturing and Securely storing user facial data during enrolling and accurately matching it during punch in while ensuring reliability across environments and maintaining data privacy.
- Managing dynamic UI and app functionality fully controlled by Admin configuration, where enabling or disabling features like combine punch options, auto punch, custom fields, and punch types must instantly reflect inside the app without code changes.
- Ensuring all punch data is safely stored locally and properly synced with the server, especially when internet is unavailable, without losing data or creating duplicate records.
- Handling multiple login types such as single user, shared user, and combined user, where each login type requires different navigation flow, screen rendering, and punch behavior.
- Managing complex timer logic for face detection countdown, auto punch, break timing, and preventing duplicate punches while ensuring the app does not crash during camera switching or session changes.
- Handling push notification navigation where different notifications such as roster updates, time off approvals, and timesheet alerts must open the correct screen inside the app even when the application is closed, in background, or already running. Preventing duplicate screen navigation when the same screen is already open was also a challenge.
- Rendering dynamic punch forms based on custom fields provided by the backend, where each field can have different data types such as text, number, date, boolean, or dropdown values. The challenge was to build a flexible UI that adapts to these fields while maintaining correct order, validation, and user experience.
- Ensuring accurate geolocation data for each punch event while handling scenarios where GPS updates may be delayed or unavailable when the punch action occurs. The system needed to prevent invalid coordinates such as 0.0,0.0 from being sent to the server.
- Maintaining feature parity between Android and iOS applications while replicating complex business logic such as punch modes, pay code behavior, custom field filtering, and API request formatting so both platforms behave consistently.
- Maintaining a complete audit trail of all user activities while ensuring that every punch, configuration change, and important event is recorded locally. The system needed to store these activities reliably and later export them to the server for monitoring and reporting without impacting app performance.
Solution
- To make face recognition reliable and secure, we structured the full camera flow carefully. We implemented proper face detection before capture, added countdown logic, compressed image before upload, and handled match percentage with clear conditions. We also supported both offline and online punch logic. This ensured accurate matching and stable performance.
- We integrated a configuration API and stored the config locally. All UI rendering and navigation decisions were based on these config values. Whenever admin changes settings, the app automatically updates its behavior. This created a flexible and scalable system controlled completely by backend configuration.
- We implemented a local SQLite database structure with multiple related tables such as Punch, Audit, and Custom Fields. Every punch is first saved locally, then synced to the server. If API fails, data remains stored for retry. On success, status is updated. This ensures strong offline support and reliable data synchronization.
- We created structured flow management using enums and centralized punch mode handling. Based on login type and configuration API response, the app dynamically controls which screens open and which features are visible. This allowed one codebase to handle multiple complex user scenarios smoothly.
- We implemented safe timer handling by invalidating timers before reuse and managing camera session states properly. We ensured all timer operations run on the main thread and reset correctly when face is not detected or camera switches. This improved stability and prevented unexpected crashes.
- We implemented a centralized push notification handler that reads navigation parameters from the notification payload and routes the user to the correct screen. The system also checks the current navigation stack to avoid opening the same screen multiple times and ensures smooth navigation even when the app is launched from a background or terminated state.
- To support backend-driven custom fields, we built a dynamic form rendering system where UI components are generated based on field metadata received from the API. Each field type is mapped to a specific input component such as text field, number input, date picker, or dropdown selector. This allows administrators to add or modify punch fields without requiring mobile app updates.
- We implemented a layered location handling strategy where the app first attempts to use the latest GPS location and falls back to the previously captured coordinates when necessary. This prevents invalid location values and ensures every punch contains valid geolocation data.
- To maintain consistency between Android and iOS platforms, we carefully analyzed the existing Android implementation and replicated the same business logic in the iOS application. Shared behaviors such as punch modes, pay code handling, custom field filtering, and API request structure were implemented using equivalent logic to ensure identical functionality across both platforms.
- We implemented a structured local database system where all important activities such as punches, configuration downloads, and user actions are stored in dedicated tables like PunchEntity, AuditEntity, and CustomFieldEntity. Each activity is logged with timestamps, unique identifiers, and synchronization status. These records are periodically exported to the server to maintain a centralized activity log. This approach ensures traceability, improves debugging capability, and guarantees that no important event is lost even when the device is offline.
Transforming Ideas
into Stunning Designs:
From Wireframe to Wow!
Design Tools
- Figma
- Photoshop
3rd Party APIs/SDKs/Libraries
- Jetpack Compose UI
- MS App Center
- MS Oxford Face API
- Google ML Kit
- Google Play Services
What Our Client's Say
Testimonial
The team at AppGurus have been responsive and clear with there communications. They have gone above and beyond to get our app completed and in the Store. We look forward to future projects.
Paul Murphy
CTO, BioTime
With over 12 years of app development experience, we specialize in offering pertinent IT solutions for medium-sized businesses and corporations. We align with your goals, taking pride in our work and our clients.
Kristian W.
Business Consultant
