Cross-platform and native apps
React Native when your team already works in JavaScript, Flutter for highly custom interfaces, Swift and Kotlin when the app depends on device features. We choose by who will maintain the code.
PN Scripts 路 Mobile app development
iOS & Android apps.
We design, build and publish iOS and Android apps, and the API behind them. The code, the store accounts and the documentation are in your name from day one.
The standard
Built for real phones and patchy networks
We design for mid-range phones and unreliable connections: screens open quickly, navigation is obvious, and sign-in stays secure. PN Scripts can also build the API behind the app, so both change together.
- Screens that follow the iOS and Android conventions your users already know.
- An API that returns clear errors and loads long lists in pages, so the app stays fast.
- A release checklist, updated whenever Apple or Google change their policies.
- An admin panel for your staff, with roles and permissions, when the app needs one.
- One company is responsible for the app, the API and the store releases, so there is no dispute between suppliers when something breaks.
What we build
What mobile app development includes
From the first prototype to the maintenance release after the next OS update.
APIs built for mobile
Versioned APIs that page long lists, return errors the app can show, and keep older app versions working. Built by the same company in Laravel or the stack you already run.
Store releases
Submission to the App Store and Google Play under your own developer accounts, with a release checklist kept current as store policies change.
Push, deep links, analytics
Push notifications, deep links and analytics events limited to what you approve, and documented for the store privacy forms.
Speed on real devices
Fast start-up, clear navigation, logins kept in secure storage, and offline mode where the product needs it.
Maintenance releases
We track Apple and Google policy changes and plan maintenance releases, so the app and its API stay compatible.
Release process
How an app version reaches the stores
The path every build takes before it reaches a home screen.
-
01 路 Critical flows
Prototype
We prototype the flows that carry the product first and hold back nice-to-have screens.
-
02 路 API
Contract
Pagination, error formats and API versions are agreed with the server side before any screen depends on them.
-
03 路 One codebase
Build
iOS and Android builds from a shared codebase, with build pipelines in your own accounts.
-
04 路 Real devices
Test
Internal and TestFlight builds on mid-range devices and real mobile networks.
-
05 路 Store submission
Review
Store descriptions, privacy answers and replies to Apple and Google reviewers.
-
06 路 Regular releases
Maintain
Crash reports and planned maintenance releases after launch, for as long as you want.
How we work
From prototype to store listing
-
A first version scoped for store review
We prototype the critical flows early and hold back nice-to-have screens until the core of the app has proven itself with users.
-
An API the app can rely on
Clear errors, safe retries and monitoring, so a problem in production can be traced from day one. Automated tests cover logins, payments and data.
-
Published in your name
The developer accounts, store listings, signing certificates and build pipelines are yours from day one, and every release step is documented.
Ways to work
Three ways to build your app
iOS and Android from one codebase when that suits the product. Each option is planned around store review, unreliable connections and an API the app can depend on.
-
MVP
Test the core idea with users
Pricing model Fixed sprint
- Scope
- The core feature only
- Platforms
- One shared codebase
- Release
- Internal / TestFlight
- Support
- Handover documentation
-
Recommended
Product
Launch in both stores
Pricing model Milestones
- Scope
- Store-ready app
- Growth features
- Push and analytics
- Release
- App Store and Google Play
- Support
- Crash reports, planned releases
-
Scale
Ongoing development
Pricing model Monthly
- Scope
- Several app variants
- Growth features
- Feature switches and A/B tests
- Release
- Regular store releases
- Support
- Agreed response times, policy watch
| Need a prototype first? Ask about a short discovery sprint. | MVP | Product | Scale |
|---|---|---|---|
| iOS and Android from one codebase | Included | Included | Included |
| Push notifications, deep links, analytics events | Not included | Included | Included |
| App Store and Google Play submission | Not included | Included | Included |
| Offline mode where the product needs it | Not included | Included | Included |
| Crash reporting and planned releases | Included | Included | Included |
| Several versions of the app, including white-label | Not included | Not included | Included |
| Remote feature switches and A/B tests | Not included | Not included | Included |
| Agreed response times and store policy monitoring | Not included | Not included | Included |
Technology
Mobile app technology we use
Chosen because developers for them are easy to find and the code stays maintainable for years.
- React Native iOS and Android from one codebase
- Flutter Highly custom interfaces
- Laravel APIs, logins, roles and admin panels
- Push and deep links Bringing people back to the right screen
- Crash reporting Release health after launch
- TestFlight Internal builds before the stores
Questions
Mobile app development questions
What clients ask before they commit to building an app.
What happens after the app is live?
We keep maintaining it for as long as you want. Apple and Google change store policies and OS versions every year, so we track those changes, plan maintenance releases around them, and update the app and its API together. You get scheduled updates instead of emergency fixes.
React Native, Flutter or native code?
It depends on your team and the app. React Native fits when your developers already work in JavaScript or TypeScript. Flutter suits heavily custom interfaces. Swift and Kotlin make sense when the app relies on device features or you need only one platform. We recommend based on who will maintain the code and how easy it is to hire for.
Can you publish under our developer accounts?
Yes, and we recommend it. The Apple and Google developer accounts, signing certificates and store listings stay in your name from day one. We prepare the builds, the store metadata and the answers to review questions.
Do you build the API too?
Yes, and it usually saves time. When the same engineers build the app and the API, logins, payments and admin tools fit together sooner, and you have one contact when something breaks. We can also connect the app to an API you already run.
How do you handle analytics and privacy?
We track only the events you approve and document what the app collects and why. That document answers the App Store privacy labels and the Google Play data safety form.
How is an app priced?
You get a written scope and estimate before anything is agreed, and work begins only after you say yes. An MVP is usually a short sprint on a fixed scope, a store-ready app is billed in milestones, and ongoing work runs monthly.
Start
Tell us what your app has to do first. We reply within one business day.
Ready to plan your app?
Apple and Google update their operating systems and store rules every year. We plan maintenance releases around those changes, so updates do not catch your users out.
Describe your app