Discovery is a structured process where we work together to understand your business, your users, and what you're actually trying to solve before committing to a build. It's the difference between building something that works and building something that works for you.

Most projects don't fail because of bad code - they fail because of bad direction. Discovery prevents that.

You might know what you want, but discovery helps us figure out why you want it and whether it's the right solution. We've seen plenty of clients come in asking for a feature that, after discovery, we realize is solving the wrong problem entirely.

Discovery gives you a second set of eyes - someone who's seen what works and what doesn't across dozens of projects.

Most agency "discovery" is an intake call disguised as strategy — gathering requirements to start billing faster. We don't collect requirements; we co-develop understanding. Our Discovery is a standalone engagement with its own deliverables, not a pre-sales activity.

We're not order-takers. We push back when something won't work, question assumptions, and surface the unknowns you didn't know you had. That requires honesty, even when it's uncomfortable.

Depending on the project type and complexity, you'll walk away with some combination of:

• A clear scope document defining what's in and what's out
• User journey maps showing how people will actually use what we build
• Wireframes or prototypes you can show to stakeholders or test with real users
• Technical recommendations on platform, architecture, and build approach
• A prioritized roadmap separating must-haves from nice-to-haves
• Risk assessment identifying what could go wrong and how we'll handle it
• Team structure and resource recommendations
• Timeline and budget clarity

It's designed to be transferable — you can execute with us, or hand it to any capable team.

It depends on complexity:

• Simple website or small app: 1-2 weeks
• Medium complexity (web app with integrations): 2-4 weeks
• Complex product (multiple user types, custom logic, sensitive data): 4-8 weeks

The rule of thumb: if your project could easily sprawl, discovery should be longer. We'd rather take an extra week upfront than waste months building the wrong thing.

Discovery is typically 10-20% of your total project budget. For a $50K build, expect $5-10K in discovery. For a $150K product, expect $15-30K.

Why pay for discovery? Because it's cheaper than rebuilding something that was scoped wrong. We've seen projects where skipping discovery cost 3-4x what proper discovery would have.

No. Every client starts with Discovery, regardless of experience level. The clients who think they don't need Discovery usually need it most.

Without discovery:

• Scope creeps because requirements weren't clear
• You build features users don't actually need
• Technical decisions get made reactively instead of strategically
• Timelines slip because nobody saw the dependencies coming

Discovery isn't overhead - it's insurance.

That's a successful Discovery. Learning your idea has fatal flaws in 2–3 weeks for a few thousand dollars is infinitely better than discovering it after 6 months and $100K+ in development.

If we discover your idea isn't feasible as scoped, we'll tell you why and what alternatives exist. You'll have clarity, not a failed project. We'd rather save you from a bad build than take your money to execute one.

You'll have everything you need to make a go/no-go decision:

• If you're ready to build: We move into a scoped engagement with clear milestones, typically via monthly retainer
• If you need to validate first: We build a prototype and test with real users
• If priorities shifted: You have documentation you can take to another team

Discovery protects you either way.

No. Discovery deliverables are yours. If you want to take them to another agency or build in-house, that's your call. No lock-in.

That said, most clients stick around because by the end of discovery, we've built trust and momentum.

Your time and honesty. Discovery is collaborative, not something we do to you. Plan for:

• 2-3 sync calls per week (30-60 min each)
• 48-hour turnaround on decisions and feedback
• Access to stakeholders, existing systems, and any relevant documents

If you can't commit that time, discovery will take longer and cost more. Your availability directly impacts the quality and speed of outcomes.

Yes. We call this "Foundational Discovery for Existing Products." It's common for teams with a live product that's grown chaotic, or when a significant pivot or rebuild is needed. We audit what exists, identify what's working, and map the path forward.

A website primarily displays information. A web app lets users do things - create accounts, input data, run calculations, manage workflows, interact with other users.

If your project involves user accounts, dashboards, custom logic, or data that changes based on user input, you're building a web app.

SaaS platforms, marketplaces, internal tools, dashboards, CRMs, ERPs, compliance platforms, and custom business applications. Our sweet spot is complex multi-user systems where understanding the workflows matters more than flashy UI.

We use a simple framework:

• Must-have: Features without which the app doesn't solve the core problem
• Should-have: Features that significantly improve the experience but aren't blockers
• Nice-to-have: Features that would be great but can wait
• Future: Features that are out of scope for this engagement entirely

During discovery, we'll force-rank everything together so there's no ambiguity. Every feature must earn its place.

Frontend: React/Next.js. Backend: Node.js or Django. Database: MongoDB or PostgreSQL. Infrastructure: AWS or GCP.

This stack is chosen for speed, scalability, and avoiding vendor lock-in — not because it's trendy.

Data sensitivity is one of the first things we assess in discovery. Key questions:

• What data will users enter?
• Where does it live - client-side (browser) or server-side (database)?
• Who can access it - just the user, or admins too?
• What compliance requirements apply?

We have experience building compliant systems. Compliance requirements are scoped during Discovery — they affect architecture, hosting, data handling, and audit trails. These aren't bolt-on features; they're built into the foundation.

During discovery, we map all the systems your app needs to talk to:

• What's the API like? Well-documented, or a black box?
• What data flows between systems, and in which direction?
• What happens if the integration fails?

We've integrated with Salesforce, Stripe, HubSpot, various ERPs, payment processors, and dozens of third-party APIs. We design integration points that work with your current workflows rather than forcing replacement.

Integrations are where projects often blow up. Discovery surfaces these risks early.

• Prototype: A clickable demo to test ideas and get feedback. Not production-ready. Used for validation before committing to a full build.
• MVP (Minimum Viable Product): A working product with the minimum features needed to solve the core problem. Production-ready, but intentionally limited in scope.

In discovery, we'll determine which you need first.

We break the project into phases and estimate each separately:

• Discovery: 2-8 weeks depending on complexity
• Design & Prototyping: 2-4 weeks
• Development: Varies widely - 4 weeks for a simple app, 12-20+ weeks for complex products
• Testing & QA: 1-2 weeks per phase
• Launch & Iteration: Ongoing

During discovery, we'll give you a realistic timeline with dependencies clearly mapped. Timelines depend heavily on scope discipline and client feedback speed.

Yes. Most web apps require an admin layer for user management, content moderation, analytics, and configuration. We scope these during Discovery and build them as part of the core platform — not as an afterthought.

Post-launch work follows a shared backlog, prioritized monthly via retainer. This lets us respond to real user feedback rather than guessing what features matter. The monthly model keeps delivery fluid and focused on outcomes.

We primarily build cross-platform using React Native or Flutter. This approach delivers near-native performance while cutting development time and cost significantly.

Usually not. We recommend launching on one platform first, learning from real users, then expanding.

How to choose:

• iOS first: If your target users skew higher income, US-based, or enterprise
• Android first: If your users are global, emerging markets, or price-sensitive

Discovery will help you identify where your users actually are.

Ask yourself:

• Do users need push notifications?
• Do users need offline access?
• Do users need camera, GPS, or other device features?
• Will users engage daily or weekly?

If you answered "no" to most of these, a responsive web app might be enough. Discovery will help you make the right call.

Apple and Google have strict guidelines that affect what you can build and how. During discovery, we'll flag any requirements that could impact your product:

• In-app purchase requirements (and Apple's 30% cut)
• Content restrictions and review process timelines
• Privacy policy and data handling requirements
• Accessibility requirements

We've seen apps get rejected for things that could have been caught in discovery.

If users need to use your app without internet, that's a significant architectural decision we need to make early. Discovery will answer:

• What features need to work offline?
• How does data sync when connectivity returns?
• What happens if there are conflicts?

Offline-first is doable but adds complexity. Better to know that in discovery than mid-build.

After Discovery, a focused MVP typically takes 3–4 months. Apps with complex features (real-time sync, heavy integrations, offline-first architecture) may take 4–5 months. App store review processes add 1–2 weeks at launch.

Very rough ranges:

• Simple app (MVP, single platform): $30K-75K
• Medium complexity (both platforms, integrations): $75K-150K
• Complex app (offline, real-time features, heavy integrations): $150K-300K+

Discovery will give you a real estimate based on your actual requirements.

Yes. Common integrations include POS systems, payment processors, loyalty platforms, CRMs, and custom backends. During Discovery, we map every integration point and define the data flow.

We primarily work with Shopify for most eCommerce needs. For complex or highly custom requirements, we build headless commerce solutions.

This is one of the first things we assess:

• How many SKUs?
• How many variants per product (size, color, etc.)?
• Do products have configurable options or bundles?
• Is inventory managed in another system (ERP, warehouse management)?

Complex catalogs need careful data architecture. Discovery surfaces this before it becomes a problem.

Common integrations we'll map during discovery:

• Payment processors: Stripe, PayPal, etc.
• Shipping: ShipStation, EasyPost, carrier-direct
• Inventory/ERP: NetSuite, TradeGecko, custom systems
• Marketing: Klaviyo, Mailchimp, Meta Pixel, Google Analytics
• Reviews: Yotpo, Judge.me
• Customer service: Gorgias, Zendesk

Each integration has its own quirks. Discovery identifies which ones are critical and how complex they'll be.

Checkout is where money is made or lost. During discovery, we'll discuss:

• Guest checkout vs. account creation
• Payment options (credit card, PayPal, BNPL, Apple/Google Pay)
• Shipping calculations (real-time rates vs. flat rate)
• Tax handling (especially for multi-state or international)
• Cart abandonment recovery strategy

We'll recommend a checkout flow based on your customer behavior and industry benchmarks.

• Simple Shopify store: 4-8 weeks
• Custom Shopify theme with integrations: 8-12 weeks
• Complex WooCommerce with custom functionality: 12-20 weeks
• Headless commerce (custom frontend): 16-24+ weeks

Discovery will give you a realistic timeline based on your specific requirements.

If you're moving from one platform to another, discovery will cover:

• What data needs to migrate (products, customers, orders)?
• How do we handle redirects for SEO?
• What's the cutover strategy (hard switch vs. parallel running)?
• What integrations need to be re-established?

Migrations are high-risk. Discovery is essential to do them safely.

Discovery is a fixed-price engagement (typically $3,000–$10,000 depending on complexity). Development runs on a monthly retainer ($12,000–$15,000/month for a standard team). This model keeps delivery fluid and focused on outcomes rather than ticket-counting.

Fixed-price contracts incentivize scope fights, change request games, and rushing to close. Retainers align incentives: we succeed when we deliver value monthly, not when we lock in the largest possible scope upfront.

A dedicated team: 2 full-stack developers, 1 UX designer, plus fractional Product Owner, Tech Lead, and QA coverage. All prioritized design, development, and project management for that month's agreed scope.

We typically work in one of three models:

• Discovery-only: Standalone engagement to define scope before committing to a build
• Fixed-scope project: Clear deliverables, fixed price. Best for well-defined work where Discovery has already been completed
• Flex-scope retainer: Monthly capacity, priorities set weekly. Best for exploratory or evolving projects

We'll recommend the right structure based on your project's certainty level.

Yes, with advance notice. If you anticipate low-activity periods, the retainer can be paused and resumed. This gives you budget control while maintaining team continuity.

Monthly invoices issued at month start, due by the 5th. Work proceeds once payment is received. All payments are non-refundable once the month's scope has commenced.

We define scope explicitly in discovery, so there's no ambiguity about what's in and what's out.

For changes during the build:

• If it's small, we'll accommodate it
• If it's significant, we'll discuss trade-offs (timeline, budget, or cutting something else)
• If it's a new project, we'll scope it separately

The key is transparency. No surprises.

If we're on a fixed-scope engagement and we underestimated, that's on us. We'll deliver what we scoped.

If scope changed because requirements changed, we'll have a conversation. Good discovery reduces this risk dramatically.

Our standard discovery flow:

• Kickoff call: Understand the business, goals, and constraints
• Research & analysis: Review existing systems, competitors, and relevant context
• Requirements workshops: Deep-dive sessions to map features, users, and workflows
• Synthesis: We document everything and identify gaps
• Deliverable review: Walk through findings and recommendations together
• Decision point: Go/no-go on build, with clear next steps either way

We're direct. If something won't work, we'll tell you. If you're asking for the wrong thing, we'll push back.

We're not order-takers - we're partners trying to get you to the best outcome. That requires honesty, even when it's uncomfortable.

We can share anonymized examples of:

• Scope documents
• Technical specifications
• Wireframes and prototypes
• Roadmaps and milestone plans

Ask us during your initial conversation and we'll share what's relevant to your project type.