Everything we get asked.Sıkça karşılaştığımız sorular.

Both. About a third of our work is scoped sprints (2–6 weeks) — usually a discovery, a redesign, or a single product feature shipped end-to-end. The rest is ongoing retainers.

What we don't take: tiny one-off logo jobs, vague "modernize our website" briefs without ownership, or anything where the client wants us to also run their marketing. Specialists, not generalists.

Send the brief. We respond within one business day with a yes, a no, or a "let's talk." If we're not the right fit we'll tell you, and we'll try to point you somewhere better — usually a studio we've worked alongside or an in-house team we trust.

Honest signals it's a fit: you have a real customer problem, you can dedicate a single decision-maker to the project, and you'd rather ship something rough than discuss something perfect.

Happily. Send us yours, or we'll send you a one-page mutual NDA — the kind that protects both sides equally and doesn't try to claim ownership of our pre-existing methods.

We never publish anything about your project without explicit written consent. Some clients stay anonymous on our portfolio entirely — that's fine, and it doesn't change the work.

The studio is in Bursa, Türkiye. Most of the build happens here. For discovery and the first kickoff workshop we strongly prefer in-person — we'll fly to you (Europe / Middle East / North Africa included in standard travel). After kickoff, weekly cadence is remote.

If your team is fully distributed: no problem. We've shipped projects without ever sitting in the same room — it costs a week of extra discovery, not a project.

Project conversation: English or Turkish. Internal documentation can be in either, depending on the client. Code and commit messages: always English. The product UI: whatever your customers speak — we localize as a first-class concern, not an afterthought.

Honestly: it depends on what you need built. We price each engagement against the actual scope, not against a tier card — vague numbers waste both our time, but published price-per-page numbers tend to lie even more.

What we can tell you up front is the shape:

• Sprints · 2–6 weeks, one discovery / one redesign / one feature shipped end-to-end
• Builds · 3–6 months, a product MVP shipped to production
• Retainers · embedded pod, two-week sprints, three-month minimum

Tell us the brief, the timeline, and — if you have one — the budget you're working with. We'll come back with a scope that fits, or we'll say honestly that it doesn't and point you somewhere it might.

Rarely — and only when scope is genuinely small and frozen (a marketing site, a brand identity, a one-feature ship). For anything where the product can learn during the build, fixed-price punishes good discovery and rewards corner-cutting. Both sides lose.

Our default is time-and-materials with a not-to-exceed cap: predictable for you, sustainable for us.

You commit to a monthly cadence — typically one designer + one engineer embedded part-time, or a full pod (two engineers, one designer, one PM) for bigger products. We plan two-week sprints. The roadmap is yours; the velocity is contracted.

Three-month minimum, then month-to-month. Cancel any time on 30-day notice.

Sometimes — as a top-up, not as a replacement for cash. If you're an early-stage founder with a clear product thesis, real users, and a fundraise in motion, we're open to discounting cash for warrant coverage. We don't work for equity alone. No exceptions.

You do — fully, from the first commit. Source goes to your GitHub / GitLab org. Figma files transfer to your workspace at any milestone you ask. We retain rights only to (a) anonymized excerpts in our portfolio (with your consent) and (b) generic patterns and tooling we built before the project started.

The price covers our team, our tooling, and our discovery. It does not include third-party services billed to you directly: hosting (Vercel, AWS), data infrastructure (Supabase, Neon), error tracking (Sentry), analytics, transactional email, SMS gateways, or paid model APIs (OpenAI, Anthropic). We set them up; you own the accounts.

Discovery typically starts within one to two weeks of signing. The build kicks off the week after that. We slot work in around current retainers, so timing depends on the quarter — the status pill at the top of About always reflects current availability.

Tight deadlines: tell us. We'll say honestly whether they're realistic. We don't take projects we can't ship on time.

Four steps:

• Discover · We sit with the problem. Interviews, audits, a written architecture brief.
• Architect · One week of design and technical scoping. You see the schema, the wireframes, and the deployment plan before we ship the first feature.
• Ship · Two-week sprints. Demoable build at the end of every sprint, in production by the end of every other one.
• Operate · 30-day stabilization included on every engagement. Retainers continue beyond that.

Weekly demo + plan, 30 minutes, Friday afternoons. A shared Slack / Discord channel for async during the week. Standups are internal — you don't need to attend, but the digest goes to you every Friday.

Phone calls are fine for actual conversations. We don't take meetings to set agendas for other meetings.

A small pod: one lead engineer, one designer, and (for retainers) a PM who runs cadence. The same people, for the whole engagement — we don't rotate, and we don't quietly subcontract.

The studio principal is the escalation point on every project. If something is off, you get a real person on the phone within an hour.

Yes — about a third of our work is rescue or refactor. We don't trash what's there. We read it. We audit it. We write a one-page plan with the things we'd change and the things we'd leave alone. Then we ship against the plan.

The plan is delivered as a paid two-week discovery, separate from the build commitment. You can take it and shop it elsewhere — many clients do, and we still get hired most of the time.

Default stack, picked because it ships well and recruits well:

• Web · Next.js · Nuxt · Tailwind v4 · shadcn/ui · TanStack Query
• Backend · NestJS · TypeScript · Prisma · PostgreSQL · JWT
• Mobile · React Native · Flutter
• AI · provider-agnostic, with RAG and agent patterns
• Infra · Vercel · Fly.io · Neon · Supabase · AWS when needed

We're opinionated but not religious. If you already have a stack and we agree it's sensible, we'll build on yours.

If it's sensible, yes. We've shipped on AWS, GCP, Azure, on-prem Kubernetes clusters, and one notable Hetzner box in a Düsseldorf data center. We have no incentive to push you onto a platform you don't already pay for.

What we'll push back on: stacks where the security or maintainability cost is so high it'd cripple your team after we leave. We'd rather lose the contract than ship into a hole.

Standard practice on every build: secrets management via your platform of choice, role-based access baked into the schema, audit logging on every write-shaped event, and encrypted-at-rest for personal data. PRs require review; nobody commits to main.

Compliance audits (KVKK, GDPR, SOC2, ISO 27001) are scoped separately — we have partners we trust, and we'll bring them in if your project needs them.

Your GitHub or GitLab org — never ours. We push to a branch we control during sprints, you have full read on main, and the PR review process is shared. The repository transfers to you at any milestone; we never hold a project hostage.

Yes. Copilot and Cursor are part of the daily workflow — every senior engineer here uses them. The output is reviewed line-by-line, by a human, before merge. We don't ship code we can't explain.

What we don't do: outsource the actual product thinking to a model. Architecture, schema design, UX decisions — those are human, deliberately.

Yes — and we treat that as a primary deliverable, not a bonus. Three habits enforce it:

• A short README that actually works — a fresh engineer should clone, install, and run within 15 minutes
• An architecture decision log — every notable choice is written down, with the alternatives we rejected
• A 30-day handover window at the end of every engagement — your team pair-programs with ours until they own the codebase

Always. The first month after launch is when the work actually begins — the bug nobody saw coming, the alert that fires at 3 a.m., the user behavior nobody predicted. Every engagement includes a 30-day stabilization window at no extra charge.

After that, you can transition to a retainer, hire in-house and we hand off, or close the engagement entirely. Up to you.

Within the stabilization window: 1-hour response to a real incident during business hours, 4-hour response after hours. Inside a retainer we can extend to 24/7 with a paging rotation — scoped and priced as an add-on to the base engagement.

What counts as an "incident": production is down, data is at risk, or revenue is blocked. Everything else goes into the normal sprint queue.

Great — that's a healthy outcome, not a loss. We've onboarded in-house teams in two days, two weeks, and two months depending on size. The handover includes architecture walk-throughs, paired sprints, and a written runbook for the first 90 days.

We've even helped a couple of clients recruit their first in-house engineering hire — for free, when we like the project.

Inside a retainer, yes — for as long as it makes sense for your business. We've had retainers run six years and counting, and we've also had them run six months. Whichever the product needs.

What we won't do: keep an unhealthy retainer alive because it pays well. If your build is in maintenance mode and you don't actually need us, we'll say so and step back.