What Happens After You Email a Dev Studio (Our Process Explained)

You have an idea for a product. Or maybe you have an existing product that needs a rebuild. You have done some research, found a few dev studios, and you are about to send that first email.

What happens next? For most studios, it is a black box. You send an email, wait a few days, get a vague response asking for a call, sit through a sales pitch, wait two weeks for a proposal, and then wonder if the number on the last page was pulled out of thin air.

We think that process is broken. Here is exactly what happens when you email us at Threshline — from first contact to signed scope — and why we built our process to move faster.

Day 0: You Send the Email

You email [email protected] (or fill out the contact form on our site). Your email might be two sentences or two pages. Both are fine.

Here is what we are looking for in that first message:

• What you are building (or what you want to change about an existing product)
• Who it is for (your users, your customers, your team)
• Where you are now (idea stage, existing product, have designs, have a prototype)
• Any constraints (budget range, timeline, specific technology requirements)

You do not need to have all of this figured out. “I want to build an app for X and I have Y budget” is enough to start a conversation. We are not expecting a product requirements document at this stage.

What we are not looking for: messages that are clearly copy-pasted to fifty studios. We can tell, and it signals that you are price-shopping rather than looking for a partner. We respond to those too, but the conversation usually does not go far.

Day 0-1: The First Response

We respond within 24 hours, usually faster. Our first response is not a template — it is a real reply from one of our engineers who read your message and has initial thoughts.

That first reply typically includes:

• Acknowledgment of what you described and any clarifying questions
• A quick assessment of whether this is the kind of project we do well (and honest feedback if it is not)
• A calendar link for a 30-minute discovery call

If your project is clearly outside our expertise — you need a machine learning pipeline, a blockchain protocol, or a team of twenty engineers — we will tell you in this first email and suggest studios that are a better fit. We would rather lose the deal than waste your time.

Day 1-3: The Discovery Call

The discovery call is 30 minutes. We keep it focused. Here is our agenda:

First 10 minutes: You talk. Tell us about your business, your users, and what you need built. We listen and take notes. We are not preparing counterarguments or mentally drafting a proposal — we are genuinely trying to understand the problem you are solving.

Next 15 minutes: We ask questions. These are the questions we ask every client:

• What does success look like in 6 months?
• Who are your users and what are they doing today without this product?
• What is the one feature that makes or breaks the product?
• Do you have existing designs, branding, or a prototype?
• What is your budget range? (More on this below.)
• When do you need to launch?
• Who on your team will we work with day-to-day?

Last 5 minutes: Next steps. We tell you what happens next (a written scope within 48 hours) and set expectations for timeline and communication.

The Budget Conversation

We ask about budget on the first call. This makes some people uncomfortable, but it is the most respectful thing we can do for your time.

Here is why: if you have a $10K budget and the project realistically requires $50K of work, no amount of calls or proposals will change that math. We would rather know that on day one so we can either adjust the scope to fit your budget, recommend a phased approach, or honestly tell you that we are not the right fit.

We are not asking so we can charge you the maximum you can afford. We are asking so we can design a scope that delivers real value within your constraints.

Our typical project ranges:

• MVP / Proof of Concept: $15K-$40K (4-8 weeks)
• Full Product V1: $40K-$100K (8-16 weeks)
• Ongoing Development: $8K-$20K/month (retainer)

These are ranges, not quotes. The actual number depends on complexity, which we assess during scoping.

Day 2-4: The Written Scope

Within 48 hours of the discovery call, you receive a written scope document. Not a flashy PDF with stock photography — a clear, structured document that covers:

Problem Statement. A two-paragraph summary of what we understand you need and why. This is our check that we actually listened. If we got it wrong, this is where you tell us.

Proposed Solution. What we would build, at a high level. Not wireframes or detailed specs — those come later — but a clear description of the product’s core features and how they connect.

Technical Approach. The technology stack we recommend and why. For most projects, this is our standard stack: SvelteKit or Astro for the frontend, Flutter for mobile, Supabase for the backend (see why we use Supabase). If the project needs something different, we explain why.

Scope Breakdown. A list of features grouped into phases, with time estimates for each. This is the most important section. It tells you exactly what you are paying for and in what order.

Here is what a simplified scope breakdown looks like:

Phase 1: Foundation (Weeks 1-3)
- Authentication (email + Google OAuth)          8 hours
- User profiles and onboarding flow              12 hours
- Core data models and database setup            8 hours
- Base component library and design system       16 hours

Phase 2: Core Features (Weeks 3-6)
- Booking flow (search, select, confirm)         24 hours
- Provider dashboard                              20 hours
- Notification system (email + push)             12 hours
- Payment integration (Stripe)                    16 hours

Phase 3: Polish and Launch (Weeks 6-8)
- Testing and bug fixes                          16 hours
- Performance optimization                        8 hours
- App store submission (iOS + Android)            8 hours
- Launch support                                  4 hours

Total estimated hours: 152

Timeline. When each phase starts and ends, accounting for review cycles and feedback loops.

Investment. The total cost, broken down by phase. We use fixed-price contracts for defined scopes and hourly retainers for ongoing work.

What Is Not Included. Equally important as what is included. We explicitly list things the scope does not cover — ongoing maintenance, content creation, third-party service costs, app store fees — so there are no surprises.

Day 4-7: Revisions and Agreement

You review the scope. Inevitably, there are adjustments — a feature we overscoped, a feature we missed, a phase that should come earlier. We revise the scope based on your feedback, usually in one or two rounds.

Once the scope is agreed on, we send a contract. Our contract covers:

• The scope of work (by reference to the scope document)
• Payment schedule (typically 30% upfront, 30% at midpoint, 40% at delivery)
• Timeline and milestones
• IP ownership (you own everything we build)
• Communication expectations (weekly updates, async by default)
• What happens if the scope changes (change order process)
• Termination terms (either party can exit with 14 days notice)

We use plain language contracts. If you need to involve a lawyer, the contract is simple enough that it should not take them long to review.

What We Watch For (Red Flags on Both Sides)

We are evaluating fit during this process, and you should be too. Here are the red flags we watch for:

Red flags from our side (reasons we might not be the right fit):

• The project requires deep expertise in a domain we do not cover (ML/AI infrastructure, embedded systems, low-level networking)
• The timeline is unrealistic for the scope (launching a complex product in 3 weeks)
• The client wants to manage implementation details rather than outcomes (dictating specific database schema or code architecture without technical context)
• Communication signals a difficult working relationship (unresponsive for days, then demanding immediate turnaround)

Red flags you should watch for from any studio (including us):

• They cannot explain their technical choices in plain language
• They do not ask about your budget or timeline
• The proposal takes more than two weeks
• They cannot show you similar projects they have built
• They resist a fixed-price contract or clear scope
• They do not talk about what happens after launch

After the Signature: How We Work

Once the contract is signed, here is what the working relationship looks like:

Kickoff meeting (1 hour). We walk through the scope together, set up communication channels (usually Slack or Discord), and establish the review cadence.

Weekly updates. Every Friday, you get a written update: what was completed, what is in progress, any blockers, and what is planned for next week. No fluff, just status.

Review sessions. At the end of each phase, we do a live review where you see the product running and can give feedback. This is not a demo — you are using the actual product in a staging environment.

Async by default. We do not do daily standups or frequent sync meetings. We communicate primarily through written messages and screen recordings. If something needs discussion, we schedule a call. This respects both your time and ours.

We have refined this process across every project we have shipped — from the MindHyv all-in-one business platform to the SpotsMexico photography directory to the VincelIO creator marketplace. The process scales from a four-week MVP to a six-month engagement.

Why Speed Matters

Our entire process — from first email to signed agreement — takes less than a week. Most studios take three to four weeks for the same journey.

We move fast not because we cut corners, but because we have done this enough times to eliminate wasted steps. There is no reason a discovery call needs to be scheduled two weeks out. There is no reason a scope document needs ten days of internal review. There is no reason a contract needs three rounds of legal negotiation for a standard project engagement.

Every day between your first email and the start of development is a day your product is not getting built. We take that seriously.

For a look at the technical decisions we make once development starts, see our posts on choosing between Astro and Next.js and our honest review of Flutter for cross-platform mobile.

If you are ready to start that conversation, email us at [email protected]. We will respond within 24 hours with a real reply, not a template.