A tide prediction app presents about as little as an app can. A location, a date range, the height and time of high and low water, and the sun and moon events for the same dates. Nobody has ever been impressed by the screens. The interface is the least of it.

The predictions are not a forecast

This is the part that surprises people who have not built one. Tide heights are not fetched from a weather service. They are computed from harmonic constituents published for each station, which means the calculation is deterministic and can run entirely on the device with no network involved.

That sounds like a gift. Offline by default, no API bill, no rate limit. It is also the whole problem, because a deterministic calculation does not fail. It produces an answer. If the inputs or the frame of reference are wrong, it produces a wrong answer with total confidence and nothing in the log.

Two inputs decide whether the answer means anything

The vertical datum. A height of 1.4 metres is 1.4 metres above something. Chart datum, mean sea level, lowest astronomical tide, they are not interchangeable. An app that renders the number without stating the reference has rendered decoration. Datum labelling is a correctness requirement that happens to look like a label.

The station time zone. The device clock is sitting right there, it is already correct for the user, and it is usually close to the station. Usually is doing a lot of work in that sentence. A station keeps its own time zone and its own daylight saving transitions. Assume the device matches it and you ship high water times that are an hour out, in the direction that matters, on the dates people are actually paying attention.

Neither of these is a presentation detail, and both of them get filed as one during planning.

Where these apps are used is where the network is not

The shoreline is where connectivity fails. An app that needs a request to tell you when the water turns is useless at the exact moment it is needed. So bundled or synced constituent sets, cached station metadata and previously retrieved results all have to remain usable with no signal, and that has to be designed in rather than bolted on as a cache layer later.

Why the rebuild requests arrive

Almost none of them are about the mathematics. They are about the container.

An app built some years ago on Cordova or a similar web container was not badly written. It is just carrying a maintenance burden that compounds. Minimum and target platform versions, privacy manifests, data safety declarations, permission justifications and signing requirements all move on a schedule the plugin ecosystem does not follow. Advertising SDKs move faster still, and an outdated integration either stops filling inventory or fails policy review outright. Meanwhile the web view rendering path starts producing layout defects on newer devices, blank regions, mis-sized panes, inconsistent safe area handling, and those are genuinely hard to fix from inside the container.

Eventually the patching costs more than the rewrite.

What the rebuild looks like

Flutter renders its own widget tree, so the class of layout defect caused by web view differences goes away rather than getting worked around. A model view controller split with a state management library such as GetX keeps three things apart that want to tangle: the prediction engine, the station data layer, and the presentation.

The structure that tends to fall out of it:

  • Station data layer with a versioning scheme, so a station correction can ship as data rather than as a store release.
  • Prediction engine in pure Dart, deterministic, unit tested against known reference values, with the solar and lunar calculations alongside.
  • Selection flow as region, area, zone and site, because station lists are long and geographically clustered, plus saved favourites for the three places a given user actually checks.
  • Offline behaviour as a first class requirement.
  • Correctness surface: explicit datum labelling and real station time zone handling.
  • Compliance surface: current advertising SDK with consent collection, a reachable privacy policy, tracking transparency where the platform demands it.

The order matters more than the stack

Port the prediction and data layers first. Then validate the new output against the old implementation across a broad sample of stations and dates, before any serious work on the interface.

If the predicted heights change, the rewrite is a defect. It does not matter how much better the new screens look. Existing users have been reading those numbers for years and some of them are standing on a boat ramp while they do it.

The interface gets rebuilt screen by screen against existing behaviour after that, with layout tuning rather than redesign wherever users already know the flow. Store submission artefacts and advertising consent get handled during development, not at release, because either one can block a build outright. Source history gets carried through the migration so prior revisions stay traceable.

The part worth taking to other domains

Any time a calculation runs on the device and returns a confident number, the frame of reference is load bearing. Units, datum, time zone, coordinate system. None of them throw. All of them are correctness. If your test suite only checks that a number came back, it is not testing the thing that breaks.

Full write up on the engagement shape: rebuilding hybrid tide prediction and coastal apps in Flutter