You can add a working voice assistant to your mobile app in a single day. Not a six-month research project, not a team of speech engineers — one developer, one afternoon, a real voice-to-actions layer shipping to users. That sounds like a marketing line, so let me be precise about why it's true now and exactly how you do it.
The old way of building voice was a stack: a wake-word engine, a speech-to-text model, an intent parser, a dialog manager, a text-to-speech voice, and a pile of UI to glue it together. Each piece was its own project. That's why "add voice" used to mean a quarter of roadmap. The new way is a drop-in SDK that ships all of that as one component. You add a button, you tell it what your app can do, and the assistant turns spoken language into actions inside your product. That collapse — from a stack you assemble to a component you install — is the whole reason a day is realistic.
This guide walks the universal steps, platform-agnostic. The same shape applies whether you're on iOS, Android, React Native, or Flutter. Code here is illustrative; for exact signatures see the docs.
What "voice-to-actions" actually means
Before the steps, the concept — because it changes how you scope the work. A traditional voice assistant answers questions: you talk, it reads something back. A voice-to-actions assistant does things: it understands the request, calls the function in your app that performs it, confirms, and shows a result. "Send 50 to Ahmed," "show me last week's orders," "book the 3pm slot" — those are actions, not search queries. If you want the deeper background, we wrote a primer on what a voice-to-actions SDK is.
The practical consequence: your job isn't to build speech recognition. Your job is to map your app's existing capabilities to spoken intents. You already wrote the function that sends money or fetches orders. Voice is just a new way to trigger it. That reframing is what makes the timeline a day instead of a year.
Step 1: Pick the platform SDK
Start by matching the SDK to your stack. Voqal ships native and cross-platform options, so you install the one that fits the app you already have:
- iOS — add the Swift package,
importit, done. - Android — add the Gradle dependency.
- React Native — install the npm package and link. We have a full walkthrough for voice control in React Native.
- Flutter — add the pub dependency. Same here — see the Flutter voice guide.
The principle across all four: you're adding a dependency, not a subsystem. No model files to bundle, no native audio pipeline to hand-roll. Pick one, install it, move on. This is usually a 10-minute step.
Step 2: Add credentials and a delegate
Every SDK needs two things to talk to the backend: a key that identifies your project, and a delegate (or callback object) that lets the SDK ask your app for live information.
The publishable key resolves your configuration server-side — it's safe to ship in the client. The delegate is where the real integration happens. It's a small interface your app implements so the SDK can, at runtime, ask: Who is the current user? What's their auth token? Which screen should I present from? You answer those live, on every request, so the assistant always acts as the signed-in user — never with stale credentials.
Conceptually:
// Illustrative — see /docs for the exact interface per platform
Voqal.setup(apiKey: "pk_live_your_key")
class MyVoiceDelegate: VoqalDelegate {
func getToken() -> String { session.currentAuthToken } // fresh, every call
func getMetaData() -> String? { "{\"user_id\":\"\(user.id)\"}" }
func getViewController() -> UIViewController { self }
func didComplete(result: String) { /* refresh your UI */ }
func didFail(error: Error) { /* log it */ }
}The shape is the same on Android/RN/Flutter — a config key plus a handful of callbacks. Return a fresh token every time; don't cache it. This step is where most of your real wiring lives, and it's still small.
Step 3: Drop in the voice button
This is the part that used to be a UI project and is now one line. The SDK ships its own interface — the mic button, the listening animation, the transcript, the result cards. You don't build any of it. You add the component, hand it your delegate, and theme it to match your brand.
// Present the assistant from any screen
Voqal.presentChat(from: self, delegate: myVoiceDelegate)Because the UI is drop-in, you skip the entire design-and-build cycle for voice states (idle, listening, thinking, speaking) and for rendering results. You get a polished surface immediately and spend your time on what's actually unique to your app — the actions.
Step 4: Map your actions
This is the high-leverage step, and it's mostly declarative. You're telling the assistant what your app can do so it can route a spoken request to the right function.
In practice you expose your existing capabilities as named actions with a short description and parameters — the same functions your buttons already call. The assistant matches natural language to them, fills in the parameters from what the user said, and triggers the action. For anything sensitive (moving money, deleting data), mark it as requiring confirmation so the user taps or authenticates before it runs.
The mental model: you are writing a menu of verbs, not a grammar of sentences. You don't enumerate phrasings — "send money," "transfer cash," "pay him" all resolve to the same action. You describe the capability once; the language understanding is the SDK's job. Most apps have 5–15 core actions, which is an afternoon of mapping.
Step 5: Test the round-trip
Run the app, tap the button, speak a request, and watch it execute. Test the three cases that matter:
1. Happy path — a clear request triggers the right action with the right parameters. 2. Confirmation — a sensitive action stops and asks before doing anything. 3. Failure — your delegate's error callback fires and your UI recovers gracefully.
Watch latency here too. Modern voice stacks target sub-second responses; vertically integrated ones report sub-200ms audio round-trips ([Telnyx](https://telnyx.com/resources/voice-ai-agents-compared-latency)) and around 450–600ms end-to-end ([Retell AI](https://www.retellai.com/blog/best-ai-voice-assistants)). Voqal is built for the sub-1s band so the assistant feels like a conversation, not a form submission. If your first request feels slow, it's almost always a cold connection — warm the assistant at app launch (the SDK exposes a prewarm call) so the first real turn is fast.
Step 6: Ship it
Once the round-trip is solid, ship it the way you ship any dependency-backed feature: behind a flag if you want a staged rollout, then on by default. There's no server for you to operate — the SDK talks to the managed backend. You bumped a dependency, implemented a delegate, themed a button, and declared your actions. That's a releasable feature.
The one-day checklist
- [ ] Install the SDK for your platform (iOS / Android / RN / Flutter)
- [ ] Add your publishable key
- [ ] Implement the delegate — return a fresh user token on every call
- [ ] Drop in the voice button and theme it
- [ ] Map your 5–15 core actions with descriptions and parameters
- [ ] Mark sensitive actions as confirm-required
- [ ] Test happy path, confirmation, and failure
- [ ] Add a prewarm call at app launch for first-turn speed
- [ ] Ship behind a flag, then roll out
A note on scope
The reason this fits in a day is that you're not building voice — you're connecting it. The hard, slow parts (speech recognition, language understanding, the conversational UI, the low-latency infrastructure) are the SDK's problem. Your job is the part only you can do: deciding which of your app's actions are worth speaking to. Keep that first release tight — a handful of high-value actions beats a sprawling menu nobody discovers.
When you're ready to go deeper on multilingual or region-specific behavior, the complete voice SDK guide covers the harder cases. And if you want to build with us, join the waitlist or jump straight into the docs.
FAQ
How long does it really take to add a voice assistant to an app? For a developer already familiar with their codebase, a working voice-to-actions integration with a handful of mapped actions is a one-day task. The install, key, and button are minutes each; mapping your actions is the bulk of the time, and it's declarative.
Do I need machine learning or speech expertise? No. The SDK handles speech recognition, language understanding, and text-to-speech. You only need to describe what your app can do and implement a small delegate. If you can wire a button to a function, you can ship this.
Which platforms are supported? iOS, Android, React Native, and Flutter. The integration shape — install, key, delegate, button, actions — is the same across all four, so the steps in this guide transfer directly.
Is it fast enough to feel conversational? Yes. Voqal targets sub-1s responses. The main thing to watch is the very first request after launch (a cold connection); prewarming the assistant at startup keeps that first turn fast.
Do I have to build the voice UI myself? No. The UI is drop-in — the mic button, listening and thinking states, transcript, and result cards all ship with the SDK. You theme it to your brand; you don't build it.
Sources: Telnyx — Voice AI latency, Retell AI — Best AI voice assistants 2026, Prodinit — Sub-300ms voice architecture