All products
Web & mobile

Web & mobile applications

Websites, portals, e-shops and iOS and Android apps built to perform, stay accessible and last for years — with automated releases and store operations handled for you.

  • Next.js
  • React Native
  • Headless CMS
  • WCAG 2.2
  • Core Web Vitals
  • CI / CD

You need a website, a customer portal, an e-shop or a mobile app your business can lean on for years — not a prototype that looks right in a demo and then quietly becomes a liability. Maybe the one you have is slow, hard to change, or failing the people who actually use it; maybe there is nothing yet and the first version has to be right, because it will carry real traffic and real revenue.

ETEREO builds web and mobile products for established companies, where the thing being built is load-bearing from day one. The same senior team scopes the work, designs it and ships it — the people on the first call are the people who write the code and stand behind every release. We decide web, native or PWA on the merits of your case, treat accessibility and speed as requirements rather than polish, and hand you something you fully own and can keep running long after launch.

How we deliver it

Discovery & design

We start from how and where your product is actually used — on a warehouse floor with gloves on, on a commute with one hand, at a desk with a mandate to clear a hundred records a day. That context decides almost everything that follows, so we map it before we draw a screen. In usually about two weeks we work through your users, their tasks, your existing systems and the real constraints, and come back with a costed plan rather than a mood board.

This is where we make the honest platform call. Native earns its cost when you need reliable offline use, deep device features or the smoothest possible interaction; web wins on reach, instant updates and a single codebase; a PWA can bridge the two. We say plainly when two native platforms doubles the build, and when one well-built responsive site would serve you better. Accessibility to WCAG 2.2 and a concrete performance target are written into the brief here, not bolted on at the end.

OutputA costed plan, a platform decision and a design direction grounded in real use

Architecture

An app is rarely just the app. It needs a backend to hold data, enforce rules, authenticate users and integrate with whatever already runs your business, and getting that boundary right is what keeps the product fast and changeable later. We document the target architecture, the sequencing and the trade-offs up front, as decision records you can read.

Where it genuinely pays off, we build a shared domain core — the business logic and data models used by both iOS and Android — so a rule is written and tested once, not twice and then left to diverge. Content that marketing or operations will edit goes behind a headless CMS, so copy, images and campaigns change without a release.

OutputDecision records, the backend design and a content model you can edit

Build

We build in two-week iterations, each ending in a working release you can put in front of real users — not a slide about progress. Early feedback is cheaper than late rework, so we sequence the riskiest and most valuable slices first and keep the product shippable throughout.

Speed is a discipline, not a final pass. We set performance budgets — a fast first paint, healthy Core Web Vitals, a bundle that stays within its limit — and hold each release to them, because a page that is quick in week three and slow at launch has simply had its slowness hidden until it is expensive to fix.

OutputWorking releases every two weeks, held to explicit performance budgets

Launch & store operations

Shipping web is one problem; shipping to the App Store and Google Play is another, with its own review queues, metadata, signing, privacy declarations and rejection reasons. We handle submission and review, and set up automated releases so a build goes from merge to store or server through a pipeline, not a person following a checklist at midnight.

We roll out in stages — a small percentage first, watched, then widened — so a problem reaches a fraction of your users and is caught before it reaches all of them. Nothing goes to everyone on trust alone.

OutputA reviewed store listing, a release pipeline and a staged, monitored rollout

Maintain & grow

A web or mobile product is never finished at launch, and we are honest about that before you sign. Operating systems and browsers change every year, Apple and Google shift store policies, dependencies need security updates, and a feature that worked in one iOS version can break in the next. Left alone, an app slowly stops working.

So maintenance is treated as ongoing work, not an emergency: keeping up with platform changes, renewing certificates before they expire, acting on store requirements, and shipping the improvements real usage reveals. You can keep that with us or run it yourself — either way it is planned, not a surprise.

OutputA maintenance plan that keeps the product current, not a product that quietly rots

Handover & ownership

Whatever we build, you own outright — the code, the infrastructure, the store accounts and the knowledge to run them. We document how it fits together, train your team, and transfer operations gradually rather than in a single handover email.

If you want us to keep running it, that is a choice you make because the work is good, not because you were locked in. No proprietary black boxes, no key that only we hold.

OutputFull ownership — code, infrastructure, accounts and the know-how to operate them

What you get

  • A costed discovery plan with an honest web / native / PWA recommendation
  • Accessible, responsive interfaces built to WCAG 2.2
  • A backend and, where it fits, a shared domain core across iOS and Android
  • A headless CMS so your team edits content without a release
  • Working releases every two weeks, held to Core Web Vitals and performance budgets
  • App Store and Google Play submission plus an automated release pipeline
  • Full source code, documentation and ownership of every account

How we think about web and mobile

Most of what makes a web or mobile product good or bad is decided before the first screen is designed: which platform, what the data looks like, where the work happens on a slow connection. We spend our judgement there, because a wrong call at that level is the one you cannot style your way out of later.

We use Next.js for web and React Native for native, with a headless CMS behind the content — a mature, boring-in-the-best-sense stack with a deep talent pool, so you are never dependent on a framework only we understand. Accessibility and performance are not features we sell back to you; they are the baseline, because a site that excludes people or makes them wait is failing at the one job it has.

And we build for the second year, not the demo. The structure that lets you add a feature in a week, the tests that catch a regression before your users do, the release process a new engineer can run — that is the part that decides whether the product is still an asset long after we have moved on.

Common questions

Should we build a native app or a website?

It depends on how your product is used, and we work that out with you rather than selling you the more expensive option by default. If you need reliable offline use, deep device features or the smoothest possible interaction, native is worth its cost. If reach, instant updates and a single codebase matter more, a well-built responsive web app usually wins, and a PWA can cover a lot of the middle ground.

The honest caveat is cost: two native platforms, iOS and Android, is close to two builds. We will tell you when that is justified and when it is not.

How long until we have something to use?

You see working software within the first month. After a short discovery and architecture phase, we build in two-week iterations, and each one ends in a release you can put in front of real users. A full first version depends on scope, but in most engagements you are steering and reviewing real screens long before launch, not waiting for a big reveal at the end.

Who owns the code and the app store accounts?

You do — all of it. The source code, the infrastructure and the App Store and Google Play accounts are yours, in your name, from the start. We document everything and train your team, so you are never dependent on us to make a change. If you keep us on for maintenance, it is because the arrangement works, not because leaving is hard.

Do you keep maintaining it after launch?

Yes, if you want that. A web or mobile product needs ongoing care — operating systems and browsers change, store policies shift, and security updates keep arriving — so we offer maintenance that keeps the product current rather than letting it slowly stop working. You can also take it in-house; we set it up so your own team can run it, and we hand over cleanly either way.

How do you make sure it is fast and accessible?

By making both measurable requirements, not opinions. We set performance budgets early — a fast first paint, healthy Core Web Vitals, a bounded bundle — and hold every release to them, so speed does not quietly erode as features land. Accessibility is built to WCAG 2.2 from the design stage and checked as we go, rather than audited in a panic before launch, because retrofitting either one is far more expensive than building it in.

Planning a website, portal, e-shop or app?

Start with a short, fixed-fee discovery. We will map your users and systems, make an honest platform call, and give you a costed plan — before anyone writes a line of code.

Book a discovery call