Remote-first studio, working with teams across Europe

GENEX TECH

We build Android apps, put them on the store, and stay on the pager after launch.

  • Android only
  • Kotlin + Compose
  • Post-launch support

One platform, done properly

GENEX TECH does one thing: Android. We write the app, we prepare the release, we publish it, and we keep it working on the phones people actually carry — not just the flagship on the engineer's desk.

That narrowness is the point. An Android app is not a screenshot; it is a build that has to survive a four-year-old mid-range handset with 9% battery, a background process the system is keen to kill, a locale that writes dates backwards, and a store review queue that does not care about your launch date. Teams that treat Android as a port of something else discover all of this in the week they planned to celebrate.

So we start from the constraints. Install size has a budget. Cold start has a budget. Every permission the app asks for has to justify itself in a sentence a reviewer will accept. We build in two-week slices you can hold in your hand, on a real device, before anything is final — because a decision made against a running build is a decision you only make once.

What we actually do

Native Android in Kotlin and Jetpack Compose

One codebase, written the way the platform expects: Compose UI, coroutines, Room or DataStore for local state. No wrapper around a website pretending to be an app.

Offline-first behaviour

The app opens on the underground and on a dying signal. Local cache, queued writes, conflict rules we agree with you in advance instead of a spinner and an apology.

Release handling, start to finish

Signing keys, app bundles, staged rollouts, store listing text and screenshots, data-safety declarations, and the rewrite when a submission comes back rejected.

Crash and ANR triage

Monitoring wired in before launch, not after the first bad review. We read the stack traces, reproduce on the device model that threw them, and ship the fix.

In-app tooling that earns its weight

Push notifications, feature flags, remote config, subscriptions and analytics — added only where they change a number, and gated behind the consent the user gave.

Taking over somebody else's code

Old Java views, an abandoned repository, a build nobody can run. We get it compiling, document it, and update it without stopping the version that is live.

How people hire us

Four shapes of work. Scope is agreed in writing before anything is built.

Most asked

New app, from blank repository

An idea, a spreadsheet or a Figma file turned into a signed, installable Android build.

  • Architecture and data model
  • Compose UI against your brand
  • Signed release bundle
  • Store listing prepared with you

Rescue and modernisation

For an app that still works but nobody dares touch.

  • Build restored and documented
  • Dependency and SDK upgrades
  • Migration off dead libraries
  • Updates shipped without downtime

Release and store listing

You have the build; you want it live and surviving review.

  • Signing and bundle setup
  • Data-safety and permissions review
  • Listing copy and screenshots
  • Staged rollout and monitoring

Care plan

The app is live and needs to stay that way through every OS release.

  • Target-SDK updates each year
  • Crash and ANR watch
  • Small changes each month
  • A named engineer who knows the code

Every engagement is quoted after a scoping conversation — we do not publish a rate card for work we have not scoped.

How working with us goes

  1. Tell us what the app has to do

    One message is enough. Who uses it, what they do in it, and what already exists — code, designs, a back end, or nothing at all.

  2. Scoping call and a written estimate

    We ask the awkward questions early: offline behaviour, logins, payments, which Android versions you are willing to drop. You get a scope, a sequence and a range in writing.

  3. Build in two-week slices

    At the end of each slice there is an installable build on your own phone, a short note on what changed, and a decision point. Nothing is saved up for a big reveal.

  4. Release, then keep it alive

    Signed bundle, listing, staged rollout, monitoring switched on. Then the quieter half: crash fixes, OS updates, and the changes the first thousand users ask for.

What you end up holding

When the work ends, you should be able to walk away from us without losing anything. That is a deliberate part of how we hand over.

We are happy to stay on a care plan afterwards, and most clients do — Android moves every year, and target-SDK deadlines arrive whether or not anyone is watching. But staying should be a choice you make each renewal, not a lock-in you discover when you try to leave. If you ever hire someone else, the handover takes an afternoon.

Tell us about the app

Two lines about what it has to do is plenty to start — we will ask the rest.

  • An engineer reads it, not a sales desk.
  • The first reply is questions about scope, not a brochure.
  • If the work is not a fit for an Android-only studio, we will say so and tell you why.