Project FAQ: cost, timeline and who owns the code.

Because you do not have to rely on us staying involved. We are a new studio, so the protection is in the terms: you receive the complete source code and documentation, and the accounts pass to you at final payment. If we stopped working together tomorrow, any competent developer could maintain the system.

Technically: we build on Next.js, deploy to Vercel or your own infrastructure, and structure every project so another developer can read it without us. No proprietary framework, no private tooling.

Nothing you own depends on us. Source code, databases, configuration and accounts pass to you at final payment, and the repository lives in an account you control. The handover includes:

• Complete source code, as it runs in production
• Database schema and migration history
• A guide to environment variables and secrets
• Deployment documentation: how to redeploy or move the infrastructure

Nothing is held back to make leaving difficult.

You do. The domain and hosting accounts pass to you with the code at final payment, and the repository lives in an account you control.

Domain, hosting and business email are billed at what we pay plus a stated margin, each on its own line of the proposal - never folded into the project total. After handover you can keep them where they are or move them; the deployment documentation explains how.

Yes. That is why we build the way we do.

The handover package lets any competent full-stack developer take over. It covers:

• The technology choices (Next.js, database, deployment)
• The business logic (why workflows are structured as they are)
• The operational side (monitoring, error tracking, scaling)

When you switch, we can walk your developer through the system. It is your decision.

Live work you can inspect, each written up as a case study:

• Altruvex.com - this site: built on Next.js, with native right-to-left layout and a public cost estimator.
• NewLight Lighting Store - NewLight's first online store: a custom storefront with product management and a structured checkout.
• Art Lighting Store - a custom Next.js store for a lighting retailer: high-resolution product zoom, one inventory source and fast page loads.

Read each case study on our work page.

In three milestone payments, not by the hour:

• Deposit (50% of the total): secures your build window
• Development milestone (30%): due at a development milestone, named in your proposal
• Final (20%): before production launch

The estimator gives an indicative range. Your proposal fixes the price for the scope it describes and stays valid for 30 days. Applicable tax treatment will be confirmed in the final proposal and contract. If you start with the technical audit, the full audit fee (12,000 EGP) is credited toward the build.

No hidden fees: domain, hosting and business email are billed at what we pay plus a stated margin, each on its own line, and third-party services appear only if your project uses them. Read the full payment terms.

That is what a custom quote is for. The published ranges are reference points, not ceilings.

Common custom cases:

• A multi-tenant SaaS platform (different from a single-business dashboard)
• Integration with an existing internal system or business software
• A real-time analytics or reporting engine
• API-first architecture for third-party integrations
• A combined mobile and web system

These are scoped in discovery, then quoted on engineering complexity, timeline and infrastructure. If it is genuinely custom, the price is built for it.

Yes. That is the point of a modular architecture.

For example: start with a contained website, then add the next layer later (a CMS, integrations, dashboards). The codebase is structured so an expansion does not require a rebuild.

Each expansion is scoped and quoted on its own, so you decide on the next step with a fixed figure in hand.

The terms are written down before you start:

• Before work starts: the deposit is refunded, minus any costs already incurred.
• After work starts: the deposit is non-refundable, and the work completed to that point is due.
• If you cancel mid-project: you receive the code and documentation in their current state.

The full wording is in the Terms of Service.

You have three options:

1. Maintenance plan: the Essential plan is 2,500 EGP/month or 25,000 EGP/year, the Professional plan is 5,000 EGP/month or 50,000 EGP/year. Each plan includes monitoring, security updates and a monthly allowance of edit requests; requests beyond it are billed at 800 EGP an hour.
2. As-needed support: no monthly commitment. Changes and fixes are quoted and billed hourly at the rate in your proposal.
3. Your own team: the handover documentation lets you, or a developer you hire, maintain the system independently. A consultation is available if you need one.

A plan suits a system where someone should be watching for performance or security issues.

2–8 weeks, depending on scope. Every project moves through the same five phases - discovery, wireframe, design, development and launch - and the project phases page shows how long each takes.

The estimator gives an indicative range in weeks; your proposal sets the delivery window once scope is reviewed.

What moves the date: scope first, then how ready your content is and how quickly each phase is signed off. Content written from scratch adds time to the early phases; a flexible deadline can stretch a quote to 12 weeks, never further.

Three things, at known points:

• Context in discovery: the goal, the constraints, and what exists today - systems, accounts and brand material.
• Content: the copy and assets for the pages. If they are not ready, we structure the key messages with you; that adds time to the early phases.
• Sign-off at the end of each phase: the structure, the design, the preview and the launch.

Each phase starts only after the previous one is approved, so the speed of your sign-off is part of the timeline.

One named contact, set in your proposal, from discovery to launch. You reach us by call or WhatsApp.

During development you also get a live preview link to review the work in progress. The full working terms are on the how we work page.

3 revision rounds are included, written into your statement of work with the features, the timeline and the acceptance criteria, so they are settled before you sign.

Revisions happen at the review point of each phase: you approve the structure before design starts, and the design before development starts. Revision work beyond the agreed rounds is billed at 800 EGP an hour, and you approve it first.

Changes are expected, so the process handles them in writing:

• Minor changes - within 5% of the agreed effort - are included.
• Moderate changes (5-25%) get a written change order, with its price and the adjusted timeline, before work starts - a fixed price or an hourly rate you approve first.
• Major changes (over 25%) are quoted as new work or a second phase.

Nothing reaches the final invoice that you did not approve in writing - a verbal request is not a change order.

After launch, the 30-day warranty covers critical fixes. Larger changes move to a maintenance plan or a new quote, depending on size. The same rules are summarised in how we work.

Yes. The completed build is delivered for your review on our staging environment, with the same functionality it will have in production.

Deployment to your own domain follows once the final payment clears - stated here so it is never a surprise at launch. The code and accounts pass to you at that payment.

We measure what the system can be held to:

• Performance: Core Web Vitals and Lighthouse targets (listed on our quality standards page)
• Availability: uptime monitoring under a maintenance plan
• Function: forms work, integrations process correctly, customers can complete what they came to do
• Maintainability: strict typing, documentation and a structure another developer can follow

We do not promise traffic or sales. We commit to a system that works, performs and can be maintained.

Templates trade flexibility for speed. They suit specific cases - Shopify for a straightforward store, WordPress for a blog. When a business has its own workflows, local payment methods, or growth that does not fit a plugin, the template becomes the limit.

A custom build means:

• Performance: speed is designed into the architecture and built to the published performance targets (see our quality standards).
• Integration: payment providers and other services are connected through their own APIs, not through a plugin that approximates them.
• Ownership: no platform subscription or plugin vendor between you and your own code.
• Growth: the architecture follows your business logic, not a plugin's limits.

When the product makes the business work around it. If the team keeps a spreadsheet beside the software, types the same data twice, or has to ask one person where things stand, the tool no longer fits the work.

Custom software is not always the answer:

• If an off-the-shelf product already fits how you work, use it. It costs less to start, and someone else maintains it.
• If the problem is not yet clear, start with the free initial consultation call before anything is built.
• If what you need is for customers to find and contact you, a website may be enough.

On the call we say which of these applies. If it is not custom software, we say so.

Often, but it depends on the other system. A connection can only do what that system allows: a documented API, a webhook, or a data export.

In discovery we check each system you name: what it exposes, what access it needs and what it takes to keep the connection working. The proposal then lists which connections are in scope and how each one works.

If a system offers no reliable way in, we say so before you sign, not during development.

Multilingual by design, not mirrored.

Most sites are built in one language, then translated. We design and engineer every language together:

• Right-to-left is part of the structure, not a CSS flip.
• Every language is an equal experience, not a late translation.
• Forms, dashboards and workflows handle every language without breaking layouts.
• Every language is built to the same performance targets.

This matters if your customers or staff read right-to-left. A weak right-to-left experience costs credibility.

Local requirements are scoped in discovery, not found at launch. Typical examples:

• Local payment providers and bank transfer flows
• Delivery and logistics services
• Multilingual content and right-to-left workflows

Each provider's own requirements - local ID checks, per-message SMS costs, data residency - are reviewed before the integration is quoted. They are part of the architecture from discovery, not an afterthought.

Yes. The work is remote, so the process is the same wherever you are: a 30-minute initial project consultation call, a live preview link during development, and your sign-off at the end of each phase.

Local clients are invoiced in Egyptian pounds and international clients in US dollars. Invoices are due within 7 days.