Questions we get asked.

Startups pitch their idea through our pitch form. Businesses and agencies send a project brief instead. You can also email piyush@dhruvsutra.com. We reply within 48 hours with honest feedback, even if we're not the right fit.

If it looks like a fit, we get on a call. Then we write down the scope, design clickable screens and agree a price or equity split, all before the build starts.

No, pitching is free. A pitch isn't a contract either, so it doesn't commit you or us to working together.

Yes, before you share the details. A pitch sent through the form isn't covered by an NDA, so if you need one, say so in your pitch and keep it high level. We'll sign one before you tell us more.

We talk to many founders and build our own products, so we may already be working on something similar to your idea. Receiving a pitch doesn't restrict that.

Yes. Designs or a written plan help, but you don't need them to pitch. Our launch-ready product is built for non-technical founders.

Before we build, we go through each feature with you and ask why it exists. What customers will pay for ships first. Anything that can wait until real users ask for it goes on the list for a later release.

We don't take over another team's half-finished code or do rescue jobs. If your product is partly built, or live but in need of a rebuild, we start the code fresh. Your designs, your data and what you've learned from users all carry over into the new version.

We work this way so that every decision in the product is one we made and can stand behind. Adding a defined feature to a product your own team runs is different, and we take that on as a milestone project.

Yes. We're based in India and work with founders and businesses anywhere, remotely. During a project you talk to the team over email and Google Chat, see a demo every week and get a staging link to try the product yourself.

We don't publish client work. You can look at the products we build and run ourselves: Chamber Hours, GunaYog, Interview Kits and Unhatched Dragons.

It depends on what you're building, so we don't publish a price list. Once the scope is agreed in writing, you get a fixed price for each milestone before it starts.

The price only changes if the scope does, and we agree any change and its cost with you before we build it.

Hourly billing sets both sides against each other. The client squeezes scope, the builder has every reason to stretch the hours, and nobody ends up happy. With a fixed price per milestone, we both want the same thing: the work done well and on time.

Milestone by milestone. Each milestone has a deliverable you can see and test, a date and a price. You check the work against the agreed scope, we fix anything missing, and that milestone is paid before the next one starts, so you never pay far ahead of work you've seen and tested.

Timelines and requirements can move between milestones, and we'll work with you on that. We agree each change and its cost before building it.

Once a sprint starts, its core structure is locked, so a pivot waits for the next milestone.

Yes, if you're a startup. There are three ways to pay: all cash, a lower cash fee plus a small stake, or mostly equity. With mostly equity you pay a small base price that only covers our bare running costs, like the tools and subscriptions the build needs. The work is the same whichever way you pay.

We take equity when we understand the industry, believe in the product and trust you to take it from zero to a real business. If we see the market size or feasibility differently, we'll tell you, still help you build it, and ask for more of the fee in cash. Project work for businesses and agencies is cash only.

There is no fixed percentage. Every deal is negotiable, and equity is agreed case by case. Our stake always stays a minority one, because the company should stay yours to run.

A founder level stake is the kind of share a co-founder would hold. We never ask for that. Whatever we take stays a minority stake, and you stay the one running the company.

A SAFE (simple agreement for future equity) turns into shares later, usually at your first priced funding round. The equity part of a deal with us can be a SAFE, so nobody has to agree on a valuation this early.

Usually two weeks to three months, depending on scope and budget. Once the scope is agreed, so is the delivery date.

One person owns your product from plan to launch and is your point of contact. We don't send seniors to the sales call and hand the build to someone you've never met.

Our engineers have built products at Samsung, Palo Alto Networks, SentinelOne, Arista Networks, Okta and IBM. A second engineer reviews every change before it ships.

You get a demo every week, plus a staging link to try the product yourself between milestones. We explain tradeoffs in plain language and raise problems early, and every problem has a named owner.

Within 24 hours during a project. You talk to the team directly over email and Google Chat. A reply isn't always the fix, but you'll know where things stand. Pitches get a reply within 48 hours.

For the routine parts, yes: boilerplate, scripts and one-off tools, first drafts of tests, and searching docs. Our engineers decide the architecture and data model, what goes in the first release, and how security and compliance work. They review every line before it ships.

You do. The code lives in your GitHub, under your company's account, and the IP is yours. Cloud, domain, payment and email accounts are set up in your company's name too.

No. You get the code, written docs and the accounts, on mainstream tools a new engineer already knows. You can take it to another team the day after handover.

We choose it per project, based on what the product needs. It is always mainstream and well documented, so your own team or a future CTO can maintain it without us.

Yes. We build native Android and iOS apps when the product needs them, scoped up front. Every web app we build also works well on phones.

Everything on the screen works. You get logins, the one to three workflows that prove your idea, a real database, payments into your own account, an admin panel, emails from your domain and analytics in your own account. It launches on your domain, with separate staging and production.

It isn't your whole roadmap. We build what proves the idea and write down the rest as your next release. It's built for your first hundred customers, on a foundation that can grow past them.

Security and compliance are designed in from day one by people who've built security products, because they're hard to add later. That covers HTTPS everywhere, properly hashed passwords, access rules, backups and error monitoring, with tests on logins and anything that touches money. Consent and data privacy are part of the first release.

Yes. If something we built or agreed with you turns out wrong within the agreed period, we fix it at no extra cost. The length of that period depends on the project, and we agree it in writing along with the scope.

Yes, as a separate agreement after launch, sized to what your product needs.

Scaling up is usually a configuration change. If you started on the cheapest hosting that works, the next step might be a planned migration instead. We'll tell you which one you're looking at before you commit, and we leave the bigger scaling choices open for your future CTO or team.

Yes, and we build for that from the start. Your next engineer inherits the code in your GitHub, docs on how it runs, deploys and where things live, tests on the parts that handle logins and money, and mainstream tools they already know.

Yes. We take on defined projects in milestones: web apps and dashboards, APIs and integrations, mobile apps, a feature on your existing product, or the first version of a new venture inside your company. Each milestone has a clear deliverable and price.

Project work is paid in cash only, with no equity.

Yes, if it's a defined feature on a product your own team runs. We agree a plan first. A second engineer reviews the code, and it goes through tests and staging before release, the same way we treat our own code.

Yes. Hand us a well scoped piece of a client project and we'll deliver it to the agreed spec, milestone by milestone.

Yes. You can pause between milestones and keep everything delivered so far.