Discipline 04 · Capabilities

App
Development.

iOS · Android · Web The Owned Channel

"A great app is the most direct line you'll ever have to your customer — no algorithm in between, no platform tax, no rented audience. We build the one that becomes a habit."

07Sub-Disciplines
iOS+AndNative & Cross
99.9%Crash-Free Target
2 WksSprint Cycle
Why It Matters Now

An app is an owned channel.

Every other channel rents you attention. An app — earned its place on the home screen — gives you direct, push-notified, zero-CAC access to your customer for life.

The hardest part of any business is the next sale. An app installed and used weekly is the lowest-friction path back to that customer. No algorithm decides whether they see you. No platform charges you to message them. Loyalty becomes a system, not a campaign.

But most apps fail — not because they were badly coded, but because they were badly scoped. Built without a habit loop, shipped without analytics, launched without an acquisition plan. We design the product, not just the screens — and we engineer it on the same modern stack the best teams in the world use.

An app that someone installs onceA habit that earns home-screen real estate
A six-month build that becomes legacyAn MVP shipped in weeks, learned from, iterated
A black-box codebase only the agency understandsA clean, documented, transferable build
A launch with cricketsASO, push, lifecycle and growth from day one
The Capability Stack

Seven disciplines, end-to-end.

Strategy through shipping, native through hybrid, MVP through scale — everything we build apps with, documented in detail.

01
Build the Right Thing

Strategy & Product Discovery

Before code, the brief. What problem, for whom, in what context — and what's the smallest version of the app that proves it works.

Product Discovery Workshops

Structured working sessions with founders and stakeholders to align on problem, users, scope and success criteria — before a single screen is designed.

Problem-statement framing User & market research JTBD & persona mapping Competitor & teardown audit North-star metric definition Risk & assumption mapping Success-criteria writing Decision log
MVP Scoping & Roadmap

The hardest call in app building — what to ship in v1, what to defer, what to kill. A disciplined MVP scope that gets the product live in weeks, not quarters.

Feature-list prioritization MoSCoW / RICE scoring Phase-1 / phase-2 split Tech-stack recommendation Timeline & milestone plan Budget & resourcing model Pre-build assumption tests Roadmap document
Habit-Loop & Retention Design

The reason a great app keeps getting opened — designed in, not added later. Hook models, daily / weekly rituals, retention triggers.

Trigger / action / reward design Daily-active rituals Streak & gamification mechanics Push-notification taxonomy Re-engagement triggers Onboarding aha-moment design North-star retention metric Cohort & churn modeling
02
Designed to Be Loved

UX, UI & Prototyping

App design is its own craft — small screens, gesture-driven, platform-native, instantly judged. Designed and prototyped end-to-end before a line of production code.

App UX & Information Architecture

How the app is organised, navigated and learned. Tab vs drawer, gesture vs button, onboarding vs deferred discovery — these are revenue decisions.

App map & navigation model Onboarding flow design Empty / loading / error states Gesture & interaction patterns Permission & consent flows Offline / low-bandwidth states Accessibility considerations Usability testing
UI Design & Design Systems

Platform-native UI — Apple HIG and Material Design respected, not fought — with a token-driven design system that scales across screens, themes and modes.

Native iOS UI (HIG-aligned) Native Android UI (Material 3) Light & dark mode Dynamic type & accessibility Iconography & illustration Motion & transitions Component library (Figma) Theming & multi-brand
Interactive Prototypes

A clickable prototype that walks like the real app — tested with users, signed off by stakeholders, handed to engineers as spec.

Clickable Figma prototypes ProtoPie / Origami micro-interactions Lottie animation specs Moderated usability sessions Unmoderated remote tests Stakeholder review walkthroughs Engineering-handoff specs Component states & flows
03
Built Native

Native iOS & Android

When performance, platform integration or device features matter — Swift and Kotlin, written by engineers who know each platform's idioms cold.

Native iOS (Swift / SwiftUI)

Modern iOS apps using Swift, SwiftUI and the latest SDKs — built to feel like Apple's own apps, ship in days, and survive iOS updates without rewrites.

Swift 5 / SwiftUI / UIKit iOS 17+ feature support App Clips iPadOS & multitasking watchOS companion apps Widgets & Live Activities Sign in with Apple HealthKit / HomeKit / etc.
Native Android (Kotlin / Compose)

Modern Android in Kotlin and Jetpack Compose — Material 3, adaptive layouts, and the full Play Store feature set, supported back to the Android versions your users actually have.

Kotlin / Jetpack Compose Material 3 design Multi-device (phones, tablets, foldables) Wear OS companion apps Android Auto support Google sign-in Health Connect / Maps Backwards-compatibility targets
Platform Integrations & SDKs

Cameras, sensors, biometrics, NFC, AR, location, contacts, calendars, files — deep platform features wired into the product where they create value.

Camera & vision (ARKit, CameraX) Face ID / Touch ID / biometrics Geolocation & maps Bluetooth & BLE NFC / contactless AR experiences (ARKit, ARCore) Calendar / contacts / files Background tasks & alarms
04
One Codebase, Two Stores

Cross-Platform, Web Apps & PWAs

When time-to-market or shared codebase wins — React Native, Flutter, web apps and PWAs. We recommend the right stack for your stage, not the trendy one.

React Native

A single JavaScript codebase that ships near-native iOS and Android apps — with Expo, EAS Build, and the full native bridge when you need it.

React Native (Expo / bare) EAS Build & Submit TypeScript end-to-end Native modules & bridges Reanimated & Gesture Handler Over-the-air updates Code-sharing with web Performance profiling
Flutter

Dart-based, pixel-perfect cross-platform from Google — chosen when custom UI, animation density, or web+mobile parity matters.

Flutter 3+ / Dart Custom widget design Riverpod / BLoC state Flutter Web target Platform channels FlutterFlow advanced builds Internationalization Performance tuning
Web Apps & PWAs

Progressive Web Apps that install, work offline, and ship push notifications — sometimes the right answer over native, especially for B2B and India-tier audiences.

Next.js / React PWAs Service workers Add-to-home-screen install Offline-first architecture Web push notifications Background sync App-shell architecture Capacitor for store distribution
05
The Engine Under the Hood

Backend, APIs & Cloud

The app is the surface. The backend is the product. Built on managed cloud platforms for speed-to-market, on AWS / GCP for scale, always with security baked in.

Backend Architecture

From serverless functions for MVPs to event-driven microservices at scale — chosen for your stage, your team, and what's actually going to run in production.

Node.js / NestJS Python (FastAPI / Django) Go for performance-critical Serverless (Lambda / Functions) Containerized services Event-driven architecture Caching & queues Observability & logging
APIs & Data

REST and GraphQL APIs designed once and used everywhere — versioned, documented, and instrumented for the long haul.

REST API design GraphQL (Apollo, Hasura) API versioning & documentation OpenAPI / Swagger specs PostgreSQL & MySQL MongoDB & DynamoDB Real-time (WebSockets, SSE) Data migrations
Auth, Payments & Notifications

The plumbing that every consumer app shares — done right, once, on managed platforms so we focus on the product.

Email / OTP / social login Razorpay / Stripe / UPI Subscription billing In-app purchases (IAP) Push (FCM / APNs / OneSignal) Email & SMS notifications Webhooks & integrations Role-based permissions
Cloud, Security & Compliance

Cloud architecture, secrets management, encryption, and the compliance work that decides whether the app can ever serve a paying enterprise customer.

AWS / GCP / Azure Firebase / Supabase CI/CD pipelines (GitHub Actions) Secrets & key management Data encryption at rest & transit GDPR / DPDP compliance SOC 2 readiness Vulnerability scanning
06
From Code to Customers

Launch, ASO & Growth

A launch with no acquisition plan is a private app. We ship to the stores with ASO, install ads, push and lifecycle ready — so day one isn't crickets.

App Store Submission

All the gritty work of getting through Apple and Google review — done by hands that have shipped it many times before.

Apple Developer setup Google Play Console setup TestFlight & internal testing App review preparation Privacy nutrition labels Data-safety form (Play) Phased rollout strategy Rejection-handling support
ASO (App Store Optimization)

The SEO of app stores — keywords, titles, screenshots, ratings — built before launch, optimised every quarter after.

Keyword research & ranking Title & subtitle optimization Screenshot & preview design Promo video production Localized store listings Custom Product Pages (iOS) Reviews & ratings program Competitor ASO tracking
Install Ads & Growth Loops

Paid acquisition (Apple Search Ads, Google UAC, Meta App Install), referral programs and in-app virality — designed into the product, not bolted on.

Apple Search Ads Google App Campaigns (UAC) Meta App Install ads TikTok App Promotion Deep linking (Branch / AppsFlyer) Referral & invite mechanics In-app virality loops CAC & LTV modeling
Push, Lifecycle & In-App Messaging

The retention engine — push notifications, in-app messages, lifecycle campaigns and personalization — wired into a real CRM, not a generic one.

Push strategy & taxonomy OneSignal / CleverTap / MoEngage Onboarding & activation flows Re-engagement campaigns Behavioral triggers In-app messaging & nudges Personalization rules A/B testing campaigns
07
Apps Are Never Done

Maintenance, Analytics & Iteration

A v1 ship is the start. The real value of an app comes from the next twenty releases — analytics-led, sprint-paced, retention-obsessed.

Product Analytics & Cohorts

A real analytics stack from day one — Mixpanel, Amplitude, Posthog — instrumented to the events that matter, with cohort dashboards that tell the truth.

Mixpanel / Amplitude / PostHog Firebase Analytics & GA4 Event taxonomy & tracking plan Funnel & conversion analysis Cohort & retention curves Feature-usage heatmaps Session replay (FullStory) Custom dashboards
A/B Testing & Experimentation

A live experimentation platform built into the app — every release is a hypothesis, every feature ships behind a flag.

Feature flags (Statsig, LaunchDarkly) A/B & multivariate tests Server-side experimentation Statistical-significance review Holdout groups Personalization & targeting Test ideation backlog Quarterly experiment review
Maintenance & SLAs

Crash monitoring, performance budgets, OS-update support, and the unglamorous work of keeping a shipped app actually working.

Crash reporting (Sentry, Crashlytics) Performance monitoring (APM) OS & SDK upgrade support Security patches Bug fix SLAs Server uptime & scaling Customer-support tooling Quarterly health reports
Feature Sprints & Roadmap

Two-week sprints, quarterly roadmap, founder reviews — the operating cadence that turns an app into a product that compounds.

2-week sprint cycles Quarterly roadmap planning User-research-led features Release management Staged rollouts Founder / stakeholder reviews Tech-debt & refactor sprints App-version sunset strategy
The Tech Stack

Platforms we actually ship.

Working credentials, certified developers, and production setups across the modern app stack.

Native
Swift / SwiftUI / UIKit Kotlin / Jetpack Compose Xcode Android Studio Combine / Coroutines Room / Core Data TestFlight / Internal Test
Cross-Platform
React Native + Expo EAS Build & Submit Flutter / Dart Capacitor / Ionic FlutterFlow NativeBase / Tamagui Reanimated 3
Backend
Node.js / NestJS Python / FastAPI / Django Go PostgreSQL MongoDB Redis GraphQL (Apollo / Hasura)
Cloud & BaaS
AWS / GCP / Azure Firebase Supabase Vercel Cloudflare Workers Docker / Kubernetes Serverless Framework
Payments & Auth
Razorpay / Stripe UPI / NPCI Apple / Google IAP RevenueCat (subscriptions) Auth0 / Clerk Firebase Auth Supabase Auth
Push, Lifecycle & Messaging
OneSignal CleverTap MoEngage Braze Iterable FCM / APNs (native) Twilio (SMS / Voice)
Analytics & Experimentation
Mixpanel Amplitude PostHog Firebase Analytics + GA4 Statsig / LaunchDarkly FullStory AppsFlyer / Branch
Workflow & QA
GitHub Actions / CI Sentry / Crashlytics Linear / Jira Notion Detox / Maestro (E2E) BrowserStack / Lambdatest Bitrise / Codemagic
How We Build It

From idea to install to habit.

A five-step build cycle that ships an MVP in weeks and turns it into a product that compounds.

1
Step 01
Discover

Workshops, research, scope, north-star metric. Output: a written product brief and signed-off MVP scope.

2
Step 02
Design

UX, UI and a clickable prototype. Usability-tested before any engineering time is committed.

3
Step 03
Build

2-week sprints, weekly demos, staging from day one. CI/CD, crash & analytics live before code.

4
Step 04
Launch

Beta with TestFlight / Internal Test, store submission, ASO, install ads and lifecycle live on day one.

5
Step 05
Iterate

Analytics, A/B, sprint roadmap. Every release ships against a retention or revenue hypothesis.

What Lands & What Moves

Concrete deliverables. Measurable outcomes.

Every engagement commits to specific shippables and the metrics we'll move — agreed up front and reviewed every sprint.

What you receive

Deliverables

  • Product brief, MVP scope & roadmap document
  • UX research, IA & clickable prototype
  • High-fidelity UI designs (Figma)
  • Component library & design system
  • Production codebase (your repo, your IP)
  • Backend, APIs & admin dashboard
  • App Store / Play Store listings + assets
  • ASO research & keyword strategy
  • Analytics tracking plan + dashboards
  • Push, lifecycle & messaging program
  • Crash & performance monitoring
  • CI/CD pipeline & release workflow
  • Documentation, runbooks & team training
  • Post-launch maintenance plan
What we optimize for

Metrics & KPIs

Install → Activation
Onboarding
Day-1 / 7 / 30 Retention
Stickiness
DAU / MAU
Engagement
Session Length
Depth
Sessions / User
Habit
Crash-Free Rate
Quality
App Launch Time
Performance
Push Opt-In Rate
Channel
CAC
Acquisition
LTV
Revenue
In-App Revenue
Monetization
Store Rating
Reputation
Who This Is For

Three apps we build best.

Consumer & D2C Apps
Loyalty · Retention · Revenue

D2C brands, F&B chains, retail and lifestyle businesses building a customer-facing app — loyalty, repeat ordering, push-driven retention, store locator and personalisation.

Startups & Marketplaces
MVP · Validate · Scale

Funded and self-funded startups shipping a category-defining product — fast MVP, real instrumentation, and a roadmap that turns early traction into a fundable trajectory.

Enterprise & Internal Tools
Operations · Compliance · Scale

Enterprises and growing operations building internal apps for field teams, ops, sales and customer-success — security-grade, role-based, and engineered to last.

Engagement Models

Three ways to build with us.

From discovery sprint to v1 build to an ongoing product partnership — scoped to your stage and your runway.

Discovery Sprint
Project · 2–3 weeks
  • Workshops, research & scoping
  • UX flows + clickable prototype
  • Tech-stack & build recommendation
  • Phased roadmap & cost model
  • Goes / no-goes the build
Investment
Fixed sprint fee · de-risked discovery
Most Popular
MVP Build
Project · 10–20 weeks
  • Full design, build & backend
  • iOS, Android & admin in v1
  • Store submission & launch support
  • Analytics, push & CI/CD live
  • 60-day care period included
Investment
Fixed project fee · scoped to feature set
Product Partner
Retainer · Ongoing
  • Continuous design + engineering sprints
  • Roadmap, releases & experiments
  • Maintenance, SLAs & uptime
  • Fractional product / growth leadership
  • Acts as your in-house product team
Investment
Monthly retainer · scoped to capacity
Why Vijay

A product partner, not a code shop.

Most app shops build what you spec. We pressure-test the spec first — because the wrong app, beautifully built, is still the wrong app.

Product Thinking, Not Just Code

We start every engagement with discovery — research, JTBD, scope, success criteria. The build only begins after the brief is sharp.

Retention as the Default Metric

Anyone can ship features. We design for the metric that actually decides whether the app lives — D30 retention — from day one of architecture.

Senior Pod, Direct Access

A hand-picked, senior pod — designer, mobile engineer, backend engineer — led personally. You talk to the people building your product, not an account manager.

Wired to Marketing & Growth

ASO, install ads, push, lifecycle, brand — all part of the same growth stack. The day the app launches, the acquisition engine is already running.

FAQ

Common questions.

Native or cross-platform — which should we build? +

Default to React Native for consumer apps where time-to-market and shared codebase matter — which is most cases. Native (Swift / Kotlin) when the product depends on heavy device features, gaming-grade performance, or platform-specific UX. We recommend based on your stage and roadmap, not a tribal preference.

How long to build an MVP? +

A focused, single-platform MVP can ship in 8–12 weeks. A dual-platform consumer MVP with backend, payments and push is typically 12–20 weeks. We commit to a fixed timeline at scoping, with two-week sprints that have visible demos.

Who owns the code, design and accounts? +

You do, end-to-end. Repo in your GitHub, Figma in your workspace, Apple & Google developer accounts under your billing, all third-party SDKs under your contracts. If we ever part ways, your app keeps running and your team can pick it up.

What if Apple or Google reject the app? +

We've shipped many apps and know the review pitfalls. Most rejections are policy issues we catch in pre-flight. If a rejection still happens, handling the resubmission is part of the engagement — no extra fee.

Do you support the app after launch? +

Yes. Every project includes a 60-day care period. Beyond that, we offer maintenance retainers (SLAs, OS updates, crash fixes) and Product Partner retainers (continuous sprints, roadmap delivery, experimentation).

Can you take over an existing app or codebase? +

Often the strongest engagement. We start with a code & product audit — security, architecture, performance, retention metrics — then deliver a stabilisation plan and pick up the roadmap. No "we'd have to rebuild it" reflex.

Do you handle backend and DevOps too? +

Yes. Backend, APIs, cloud architecture, CI/CD, monitoring and security are core capabilities — we don't subcontract them. You get one team accountable for the full stack.

What does it cost? +

Project fees scale with scope — number of platforms, feature surface, backend complexity, integrations. Every engagement starts with a Discovery sprint and a written fixed-scope quote. No surprise invoices.

Let's Build

Turn an idea into a habit on your customer's home screen.

Book a Discovery session. We'll pressure-test the brief, recommend the right stack and scope, and ship an MVP your customers actually keep open.