What actually happens between 'I want to build an app' and your customers downloading it. A practical look at how Code Workshop takes a project from idea through to launch.

Most people who come to us with an app idea have never been through the process before. They know what they want the app to do — but they don't know what happens next.

This is a straight account of how we work, from first conversation to launch.

Stage 1: Discovery

Before any code gets written, we need to understand the problem.

A discovery session is a structured conversation — sometimes two or three of them — where we ask a lot of questions:

What problem does this app solve, and for whom?
Who are the different types of users? What does each of them need to do?
What does success look like six months after launch?
Are there existing systems this needs to connect to?
What's the simplest useful version of this?

That last question matters more than people expect. The instinct is to describe the app you eventually want — after years of iteration, with every feature you've imagined. But the app you launch first should be the smallest thing that genuinely solves the problem. Everything else comes later.

Discovery can take a day or a week depending on complexity. For a Highlands business, it might mean coming to your office in Bowral or Moss Vale. For interstate clients, a video call works fine.

The output is a shared understanding of what we're building.

Stage 2: Scoping and estimating

Once we understand the problem, we scope the solution.

A scope document covers:

Features list: what goes in, what's deferred, what's out
User types: the different people who'll use the app and what each can do
Technical dependencies: third-party integrations, APIs, backend requirements
Milestones: the phases of development and what each delivers
Estimate: time and cost, broken down by phase

Estimates for custom software are honest ranges, not fixed prices. We'll tell you the assumptions behind the numbers. If scope changes — and it usually adjusts somewhat — we'll tell you the cost impact before we proceed.

Scoping is also where we tell you if there are ways to reduce cost without reducing value. Often there are.

Stage 3: Design

Design is not just how the app looks. It's how it works.

We start with wireframes — simple, low-fidelity representations of each screen and how users move between them. This is where we catch problems early, before any code exists. It's much cheaper to change a wireframe than to refactor developed features.

Once wireframes are approved, we move to visual design — actual screens with colours, typography, and UI components. For clients with a brand identity, we build on it. For those starting from scratch, we help establish it.

Design sign-off is a real milestone. It means everyone is aligned on what we're building before a single line of code gets written.

Stage 4: Development

Development happens in sprints — usually two weeks each.

At the start of each sprint, we agree on what we're building. At the end, we show you working software. Not a progress report, not a screenshot — the actual app, on a device, doing what we said it would.

This cadence matters. It means problems surface early. It means scope adjustments happen when they're cheap, not at the end. And it means you're never left wondering what's going on for months at a time.

We build native apps in Swift (iOS) and Kotlin (Android), or cross-platform in React Native when that's the right call. The technology choice is driven by what the app needs, not by what's convenient for us.

Backend infrastructure — APIs, databases, authentication, push notifications — gets built alongside the app. It's all part of the same project.

Stage 5: Testing

Testing is not a formality at the end of development. It's built into every sprint.

We write automated tests for critical flows. We test manually across devices and screen sizes. We test edge cases: what happens when the network drops? What happens with unexpected input? What happens when the user does something you didn't anticipate?

Before launch, you test the app yourself — in your actual workflow, with your actual data. This is called user acceptance testing (UAT), and it's essential. You know your business better than we do. Things look different when they're real.

We fix everything that needs fixing before we submit.

Stage 6: App Store submission

Submitting to the App Store and Google Play is a distinct phase with its own requirements.

Apple App Store:

Requires an Apple Developer account ($149/year)
Each submission goes through Apple's review process — typically 1–3 business days
Apple has detailed guidelines around UI, privacy, and functionality that must be met
Rejection is possible; we handle the response and resubmission

Google Play:

Requires a Google Play Developer account (one-time $25 fee)
Review typically takes a few hours to a couple of days
Less strict than Apple in some areas, but has its own compliance requirements

We manage the entire submission process: preparing store listings, screenshots, app descriptions, privacy policies, and all required metadata. We've been through it many times and know how to get things through without unnecessary delays.

Stage 7: Launch and beyond

Launch day is not the end of the project.

The weeks after launch are important: real users behave differently than expected, edge cases appear, performance under real load looks different from testing. We stay close during this period and fix things quickly.

After that, the relationship shifts to ongoing maintenance and support. iOS and Android both release major updates annually and minor updates throughout the year. Some of these break things. Security vulnerabilities get discovered. Your business changes and the app needs to keep up.

We offer ongoing support arrangements that make sense for your usage and budget — from light-touch availability to proactive monitoring and regular improvement cycles.

The whole process, from initial conversation to App Store approval, typically takes three to six months for a mid-complexity app. Simpler projects can move faster; more complex ones take longer.

If you're starting to think about a project, the best first step is just a conversation. We can give you a rough sense of scope and cost after a 30-minute chat — no commitment required.

Code Workshop is based in Bowral, Southern Highlands, NSW. We work with businesses across the Highlands and throughout Australia.