About PackageX

PackageX is building the Physical Logistics Execution Platform for enterprise teams operating across manufacturing sites, distribution centers, warehouses, retail locations, and logistics-heavy environments.

Our platform uses Vision AI, workflow automation, mobile execution, and integrations to help companies digitize, execute, and verify physical operations at the point of work, creating trusted evidence of what happened across their operations.

Our operating model is simple: Execution. Verification. Evidence.

Role Overview

PackageX is looking for a Forward Deployed Engineer - Mobile to work directly with customers, prospects, sales, product, engineering, AI, and implementation teams to understand complex physical operations, design PackageX workflows, and implement solutions that work in real-world environments.

We are looking for a highly skilled software engineer with strong native engineering fundamentals and experience building complex, performance-critical applications.

This role is focused on enterprise workflow design, solution configuration, customer operations, technical implementation, and go-live success. From pre-sales solution design through pilot, implementation, testing, rollout, and go-live, you’ll serve as a technical point of contact, translating customer requirements into validated, production-ready solutions.

You will work on architecting and developing cross-platform applications using Kotlin Multiplatform and Compose Multiplatform, solving complex engineering challenges across Android, iOS, and potentially desktop platforms.

This is a customer-facing, technical, and hands-on role. The right person can configure workflows in the platform and partner with Product and Engineering to close technical gaps. This is more than a pre-sales or solution design role. You’ll write code, configure workflows, provision devices, debug on the floor, and get customers live.

Key Responsibilities: 

• Join customer and prospect conversations during pre-sales to understand real operational workflows.
• Connect with customers for discovery, workflow mapping, operational walkthroughs, pilot support, readouts, and go-live activities.
• Design, architect, and develop scalable cross-platform applications using Kotlin Multiplatform and Compose Multiplatform.
• Design complex asynchronous workflows involving concurrent API requests, database operations, background processing, and computationally intensive tasks.
• Build efficient concurrency models that ensure application responsiveness, resource efficiency, and predictable execution.
• Identify and resolve performance bottlenecks involving CPU utilization, memory consumption, threading, and UI rendering.
• Design robust memory and resource management strategies for large datasets, image processing, and continuous data-processing workloads.
• Develop shared application infrastructure while handling platform-specific requirements and native integrations.
• Make architectural decisions around modularity, concurrency, state management, persistence, and resource ownership.
• Profile, debug, and optimize applications across Android, iOS, and other supported platforms.
• Establish engineering standards, review technical implementations, and contribute to architectural decisions.

Ideal Background

Kotlin & Language Fundamentals

• Strong proficiency in Kotlin, including advanced language features and type system concepts.
• Understanding of functional programming, generics, inline functions, delegation, extension functions, and higher-order functions.
• Strong understanding of immutability, state management, type safety, and API design.
• Ability to write allocation-efficient, maintainable, and testable Kotlin code.
• Understanding of JVM and Kotlin/Native execution differences.

Concurrency & Structured Concurrency

• Deep understanding of concurrency, parallelism, threading, and asynchronous execution models.
• Strong command of Kotlin Coroutines, structured concurrency, dispatchers, scopes, and cancellation propagation.
• Understanding of coroutine lifecycle management, exception propagation, supervision, and synchronization.
• Ability to design complex asynchronous workflows involving concurrent API calls, database operations, background processing, and UI updates.
• Strong understanding of race conditions, deadlocks, thread safety, shared mutable state, and synchronization primitives.
• Experience selecting appropriate execution contexts for CPU-intensive and I/O-intensive workloads.
• Understanding of backpressure, buffering, channels, flows, and concurrent data pipelines.
• Ability to manage long-running operations without blocking critical execution threads or degrading UI responsiveness.
• Understanding of threading constraints and concurrency differences across Android, iOS, and Kotlin/Native.

Memory Management & Performance Optimization

• Strong understanding of memory allocation, object lifetimes, garbage collection, and memory pressure.
• Experience identifying and resolving memory leaks, excessive allocations, and unnecessary object retention.
• Understanding of caching strategies, cache invalidation, memory constraints, and resource lifecycle management.
• Ability to profile and optimize CPU and memory consumption in production applications.
• Experience optimizing image processing, large data structures, serialization, and computationally expensive workloads.
• Understanding of buffer management, object reuse, allocation-efficient programming, and memory fragmentation.
• Ability to investigate performance degradation, memory spikes, and resource contention.
• Familiarity with Android Studio Profiler, Instruments, and platform-specific performance diagnostic tools.

Kotlin/Native & Runtime Internals

• Strong understanding of Kotlin/Native architecture, compilation pipeline, runtime behavior, and memory management.
• Understanding of Kotlin/Native garbage collection, object lifetimes, memory allocation, and runtime characteristics.
• Experience with Kotlin/Native interoperability with Objective-C and Swift, including memory ownership and lifecycle considerations.
• Understanding of Kotlin Multiplatform compilation targets, source sets, native binaries, linking, and platform-specific dependencies.
• Understanding of JVM versus Native execution models, garbage collection differences, startup performance, and memory characteristics.
• Familiarity with GraalVM, its runtime architecture, compilation models, and native-image capabilities.
• Ability to reason about runtime performance, compilation trade-offs, and platform-specific optimization strategies.

Application Architecture & System Design

• Strong understanding of modular architecture, separation of concerns, dependency management, and abstraction boundaries.
• Ability to design scalable systems involving networking, persistence, caching, background processing, and complex data flows.
• Understanding of reactive programming, state management, and unidirectional data flow.
• Ability to evaluate architectural trade-offs between shared and platform-specific implementations.
• Experience designing systems that handle large data volumes and continuous processing workloads.
• Ability to identify architectural bottlenecks and propose solutions that improve maintainability, scalability, and performance.

Compose Multiplatform & UI Engineering

• Strong experience with Compose Multiplatform and declarative UI development.
• Deep understanding of Compose state management, recomposition, snapshot state, and rendering performance.
• Experience building reusable UI components, custom layouts, animations, and navigation systems.
• Understanding of UI lifecycle, state restoration, and platform-specific UI behavior.
• Ability to diagnose unnecessary recompositions, UI jank, rendering bottlenecks, and memory inefficiencies.
• Experience integrating native platform capabilities into shared Compose applications.

Preferred Qualifications

• Production experience shipping Kotlin Multiplatform applications across Android and iOS.
• Strong native Android development fundamentals.
• Experience with Swift, SwiftUI, and iOS application architecture.
• Experience with Kotlin/Native and Objective-C interoperability.
• Familiarity with Ktor, Koin, SQLDelight, Room KMP, and other multiplatform libraries.
• Experience with Gradle, Kotlin Multiplatform build configuration, and CI/CD pipelines.
• Experience with desktop development using Compose Multiplatform.
• Familiarity with GraalVM and JVM performance optimization.
• Experience with computer vision, image processing, or other computationally intensive mobile workloads.

What We Look For

• Strong communication skills with both business and technical stakeholders.
• Comfortable working on customer sites and creating structure in fast-moving, ambiguous environments.
• Understand how software works beyond the abstractions provided by frameworks.
• Can independently investigate and resolve complex concurrency, memory, and performance problems.
• Can make and defend architectural decisions based on technical reasoning.
• Understand the trade-offs between shared code and platform-specific implementations.
• Approach problems analytically rather than relying on trial-and-error implementations.
• Communicate technical concepts, decisions, and trade-offs clearly.
• Take ownership of systems from architecture and implementation through production.