Mobile app
development services
in Somerville

Many products eventually want something to move on the screen without a refresh. A chat with support. A driver dot crawling across a map. A status line that changes from preparing to on the way. These features look small in a mockup. Underneath, they change how the app talks to the server.

A normal screen asks the server for data and waits for the answer. A live screen keeps a connection open so the server can speak first. The common choices are WebSockets, server sent events and hosted services built on top of them. Each can work. The harder decisions are about what happens when the connection breaks, which on a phone happens constantly.

Phones switch from wifi to mobile data in a doorway. The operating system suspends apps a few seconds after they leave the screen. An open connection in the background drains battery, and both iOS and Android will shut it down. So a live feature needs two channels. The open connection serves the app while it is visible. Push notifications carry the news when it is not.

Chat adds its own list of questions. Messages must be stored on the server, with an order that every device agrees on. A message typed in a tunnel should sit in a local queue and go out when the signal returns, without being sent twice. Read receipts, typing indicators and attachments each add work. Decide which of them the first release really needs.

Support chat and chat between users are different products. Support chat connects a customer to an agent working in a desk tool, so the mobile side often embeds an existing service. Chat between users brings moderation, blocking, reporting and the store rules that require them. Both platforms expect apps with user generated content to offer a way to report and block abusive users.

Live status is often simpler than it looks. A delivery screen does not need a position every second. An update every few seconds while the screen is open, plus a push for the handful of moments that matter, reads as live to most people. Sending less data also costs less on the server bill.

On iOS, the lock screen can show a live status through Live Activities, updated by special pushes. On Android, an ongoing notification plays a similar role. Both have strict rules about what can appear and how often it may change.

Before the build starts, write down the events. Keep the list short. Which changes does the user need to see at once, and which can wait until the next time the screen opens? That list decides the architecture. Building everything as real time by default is expensive, and it rarely makes the product feel faster.

Test the ugly cases on purpose. Put the phone in airplane mode halfway through a message. Kill the app while an order changes state. Open the same chat on two devices. Let the battery saver switch on mid order. These are the moments users remember, and the ones a demo on office wifi never shows.

A surprising number of apps depend on the camera. An inspector photographs a damaged wall. A tenant uploads a lease. A courier proves a parcel reached the door. A patient sends a picture of a rash. In each case the photo is the evidence, and a lost or unreadable image means the whole task has to be repeated.

The first choice is how to open the camera. The system camera and the photo picker are quick to add and familiar to users. They also leave the app with little control. A custom camera screen can add a frame guide, lock the flash, force the rear lens and refuse blurry shots before the user moves on. It takes more work, and it pays off when image quality decides whether the job gets done.

Document capture is its own case. Modern phones can detect page edges, correct the perspective and flatten a crumpled sheet into something that looks scanned. Both platforms offer built in scanners for this. Using them is usually better than writing a scanner from scratch, unless the documents are unusual in shape.

Size is the next problem. A photo from a current phone can weigh several megabytes. Uploading it at full resolution over a weak mobile signal is slow and often fails. The app should resize and compress before sending, to a size agreed with whoever reads the images later. A claims assessor may need detail. A profile picture does not.

Uploads must survive interruptions. The user takes five photos in a basement, taps send and walks away. The app should keep the files in its own storage, upload them in the background, retry after a failure and show a clear status for each one. Large files are best split into parts, so a dropped connection costs one part instead of the whole file.

Metadata needs a decision too. Photos often carry location and the camera model in hidden EXIF fields. Sometimes that is exactly what the business wants, for example to prove where a job was done. Often it is personal data nobody asked for. Strip it by default, and keep only what has a clear purpose.

Permissions have changed as well. Recent versions of iOS and Android let the user share only selected photos instead of the whole library. The app has to work properly when access is limited, rather than nagging for full access.

On the server, uploaded images should go to object storage, not the main database, with private access and short lived links for viewing. Run a virus scan on documents before a person opens them. Generate small previews for lists, so the office team is not downloading full photos just to scroll.

Finally, decide how long images are kept and who can delete them. Put it in writing, and build the deletion job with the first release. Evidence for a dispute may need to stay for a set period. A selfie used once to check identity should not.

App stores take a commission on digital goods sold inside apps, and they require their own billing for them. That rule is widely known. Less well known is the other side of it. Physical goods and services used outside the app, such as a meal, a taxi ride, a haircut or a hotel room, are normally paid with ordinary card processing. The stores do not take their commission on those sales.

So the first job is classification. A fitness app selling a monthly video subscription is digital. The same app booking a personal trainer at a gym is a real world service. Mixed products have to route each kind of purchase correctly, and store review will check.

For physical sales the app talks to a payment provider through its mobile SDK. The provider supplies a card form that keeps raw card numbers away from the app code and the company servers. That matters. Handling card data directly brings heavy compliance duties that almost no product team wants to carry.

Apple Pay and Google Pay belong in the first release. They remove typing, they fill the address, and they rely on the biometric check of the phone for security. For many shoppers the wallet button is the checkout. The card form remains as a fallback.

Some cards need an extra step. The bank may ask the user to confirm the payment in its own app or with a code. The payment SDK handles the screen, yet the app must cope with the user leaving to approve and coming back later. The order should wait in a pending state, not fail.

Saved cards make repeat orders fast. The provider stores the card and returns a token that the backend keeps against the customer account. The app shows the last four digits and the card brand, never more. Deleting a saved card should be one tap away in the account screen.

Some businesses charge later than the order. A delivery total changes when an item is out of stock. A service ends up longer than booked. The usual pattern is to authorise an amount at checkout and capture the final figure when the job is done. Tipping after delivery works the same way. It is a common pattern.

Refunds, partial refunds and disputes arrive later. They belong in the admin tool as well as in the payment dashboard. Support staff should be able to see a payment, its status and its history next to the order, without switching systems.

Test with the provider sandbox cards that simulate declines, authentication prompts and network failures. The happy path is rarely where money gets lost. Declines, timeouts and double taps are. Each one deserves a clear message and a safe retry, so the customer is never charged twice for one order.