BillEase

In this key role, you’ll work closely with our development group leader and collaborate with the broader engineering team to build and maintain high-quality iOS applications.

Key Responsibilities

• Develop and maintain iOS applications using Swift and SwiftUI
• Manage the full technical lifecycle of iOS apps — from design and development to testing, deployment, and ongoing support
• Collaborate with cross-functional team members to deliver new features and improve user experience
• Troubleshoot issues, optimize performance, and ensure application reliability
• Contribute to architectural decisions and code reviews

Requirements

• 7+ years of professional experience in native iOS development
• Strong expertise in Swift and SwiftUI
• Solid understanding of Apple’s design principles and iOS Human Interface Guidelines
• Familiarity with Git, CocoaPods, and popular third-party frameworks (e.g., Firebase, MoEngage)

Join the senior team behind the Billease Android app — a Kotlin & Jetpack Compose fintech product that millions rely on for payments, credit, and secure account access. You'll own features end-to-end, raise the engineering bar alongside other senior developers, and help keep a fintech-grade codebase fast, secure, and a pleasure to work in.

 

What you'll do

• Own features end-to-end — from the networking and data layers through to pixel-accurate Jetpack Compose UI, verified in production.
• Help uphold and evolve the architecture: a clean, layered flow (data → domain → presentation), clear module boundaries, and reactive single-source-of-truth state.
• Raise the bar through rigorous code review, shared standards, and mentoring — contributing to a strong senior team, not working in isolation.
• Keep the app crash-resilient, performant, and secure — careful recomposition, disciplined null-safety, and sensitive data encrypted at rest.
• Investigate and drive production issues to root cause, then ship the fix and the regression guard.
• Help shape conventions, module design, and technical direction together with the team as the product scales.
  
  What we're looking for
  These are the bar for the role — a strong senior should meet essentially all of them, with real depth (not just exposure) in the core engineering areas.
   
  • 7+ years of professional Android development, including meaningful time in a senior or lead role owning architecture and technical decisions — not just closing tickets.
  • Expert-level Kotlin — structured concurrency with coroutines, Flow / StateFlow, strict null-safety, and a feel for clean, stable public API design.
  • Deep production Jetpack Compose: state hoisting, recomposition and performance tuning, custom layouts, and type-safe Compose Navigation at scale.
  • Command of MVVM / clean architecture and DI (Hilt/Dagger) — able to shape and uphold layering and patterns across a large codebase, not just follow them.
  • Fluent in a multi-module Gradle codebase and a disciplined Git / MR-based workflow with thorough reviews.
  • Solid REST networking (Ktor/Retrofit) and JSON serialization, local persistence (Room), and a proven security-first instinct for auth, sessions, and data at rest.
  • Fluent working from Figma — reading designs, specs, and a design-token system, and turning them into faithful, reusable Compose components in close partnership with designers.
  • Effective, judgment-driven use of AI coding tools (e.g. Claude Code, Copilot) — using them to move faster while critically reviewing and validating everything they produce to a senior's standard.
    
    The way you show up
     
    • Actively drive technical and feature discussions — asking sharp questions, weighing trade-offs, and helping the team land on the right approach.
    • Lead the charge when it counts: investigate and triage production issues, trace root causes, and drive them to resolution.
    • Take ownership end-to-end — you plan before you build, flag risks early, and see work through to verified-in-production.
    • Collaborate well in a cross-functional, fast-moving team and are comfortable with ambiguity.
      
      Nice to have
       
      • Fintech or payments experience at scale — with a security-first mindset.
      • Hands-on with data-at-rest encryption (Keystore / Tink), auth/session handling, biometrics, or KYC / liveness flows.
      • Feature-flagged delivery, analytics instrumentation, and crash monitoring.
      • Static analysis and quality gates (detekt / ktlint) and E2E UI testing.
      • Experience migrating legacy XML/Fragment screens to Compose, and contributing to a shared design system.
        
        What you'll work with
        Language & UI
        - Kotlin
        - Jetpack Compose
        - Compose Navigation
        - Coroutines + Flow
        - Figma / Design tokens
        
        Architecture & data
        - MVVM / Clean
        - Hilt
        - Ktor
        - kotlinx.serialization
        - Room
        - Multi-module Gradle
        
        Quality & security
        - JUnit + MockK
        - detekt
        - Keystore / encryption
        - Feature flags
        - AI-assisted dev

WHAT YOU'LL DO:
Discovery & requirements
- Engage business stakeholders directly to elicit, clarify, and document business requirements.
- Turn ambiguous problems into clear, testable requirements — using AI to accelerate research, drafting, and gap analysis.

Solution design & specification
- Produce technical solutions and specifications: data models, API contracts (OpenAPI), service boundaries, sequence and architecture diagrams.
- Make sound architecture decisions aligned with our microservices, event-driven, and security-first principles, and document the trade-offs.

Build (backend / frontend / mobile)
- Implement backend services in Python and/or Golang on PostgreSQL, with appropriate messaging (Kafka) and caching.
- Build web frontends (Vue/Nuxt or React) and, where needed, mobile features (Android/Kotlin, iOS/Swift).
- Write reusable, testable, efficient code, using AI coding agents to move fast while keeping the codebase clean and reviewable.

Test & quality
- Design and execute meaningful test coverage — unit, integration, API, and end-to-end — leveraging AI-assisted test generation and review.
- Own quality end to end: you are the developer *and* the tester, and "done" means verified.

Ship & operate
- Deliver through our CI/CD pipelines and infrastructure as code.
- Build observability in at design time (metrics, logs, tracing) and support what you ship.
 

• 
  HOW WE WORK
  - Stack: AWS, Kubernetes, Python & Golang, PostgreSQL, Kafka, Vue/Nuxt & React, Android/iOS, Terraform/Ansible, GitLab CI/CD.
  - Principles: clear and maintainable architecture, security-first, scalability and reliability, high observability and automation, cloud-native and microservices-oriented design, and a strong focus on performance, resilience, and operational excellence.
  - AI-native by default: we expect AI to be part of how you think, design, build, and test — used deliberately and responsibly.
  
  WHAT SUCCESS LOOKS LIKE:
  Within your first few months, you independently take a real business need through the full cycle — requirements, spec, implementation across the relevant layers, tests, and a production release with observability — at a speed and quality that would traditionally have required a small team, and you help the rest of engineering raise its AI fluency along the way.