Frequently Asked
Questions

Timeline scales with scope. Most projects land between 4 and 12 weeks — a focused marketing site moves faster, a custom platform with CMS, integrations, and bespoke interactions takes longer. We agree on a target timeline during scoping and you get continuous progress visibility along the way, no black-box delivery.

If you have a fixed deadline, we work backward from it and either scope to fit or flag the trade-offs honestly upfront. We'd rather decline a project than ship something we wouldn't be proud of to hit an unrealistic date.

There's a public version of this on the Process page with the full breakdown, but the high level: discovery (understanding goals, audience, constraints), scoping (defining what we're building and how we'll know it's working), design (visual direction, layouts, interaction patterns), build (the actual code, with frequent staging deploys you can review), testing & polish (cross-device, accessibility, performance), and launch + post-launch stabilization.

You're in the loop at every phase, not just at hand-offs. The goal is no surprises — you should never see something at launch you didn't see during the build.

Less than you'd think. We need a real conversation about what you're trying to accomplish, who you're trying to reach, and what success looks like. Specifics help — existing brand assets, content drafts, competitor sites you respect or want to differentiate from, examples of UX patterns you like — but we can also help generate or refine those during discovery.

The bigger blocker is clarity on goals and decision-making authority. If three stakeholders need to sign off on every change, that needs to be planned for upfront so we can structure feedback loops accordingly.

More involvement at the bookends, less in the middle. Discovery and design need your active input — we're aligning on direction, and your taste and business knowledge matter. The build phase is mostly heads-down execution where we surface decisions only when they need your judgment.

We typically run a weekly checkpoint (15-30 min) to review progress, plus async updates when blockers come up. If you'd rather be hands-off after scoping, we can structure for that. If you want to be in the trenches, we can structure for that too.

Bespoke work gets a bespoke quote. We don't sell packages because no two projects have the same requirements — pricing reflects actual scope, technical complexity, and timeline.

After a discovery conversation we provide a written proposal with either a fixed price or a tight range (if there's still scope ambiguity to resolve), broken down by phase so you see exactly what you're paying for and when. No hourly mystery rates, no project-management surcharges hidden in the line items.

Both, depending on what fits. Fixed-price works best for well-defined scopes — you know exactly what you're spending, we absorb the risk of execution. Time-and-materials works better for genuinely exploratory work or ongoing partnerships where the scope evolves naturally.

For most new client engagements we recommend fixed-price for the initial build, then T&M or a retainer for ongoing work. That gives you cost certainty when the unknowns are highest, and flexibility when the relationship is established.

Expected. Projects evolve as you see things on staging and react to them — that's healthy, not a problem. Small clarifications get absorbed into the existing budget without ceremony.

Larger changes (new pages, new features, significant design pivots) get a written change order with cost and timeline impact, and you decide whether to proceed before any work starts. We never do hidden scope-creep billing, surprise invoices, or 'this'll just be a quick fix' bait-and-switch.

Yes, typically a deposit upfront to lock the schedule and start work, with the balance milestone-based or split between mid-project and launch. Specific terms are in the proposal — we structure them so you're never paying significantly ahead of delivered work, and we're never delivering significantly ahead of payment. Both sides have skin in the game at all times.

For retainers and ongoing engagements, we typically invoice monthly with net-15 terms.

You do. Full stop. Once final payment clears, the code, designs, and all project assets are yours to do with as you please. We don't retain ownership, we don't license back to you, and we don't lock you into us as the only people who can touch your site.

The repository, the CMS, the hosting account — all under your name and your control. If you ever decide to switch developers or bring it in-house, the next person can pick up exactly where we left off.

You get everything we've built up to that point, with documentation of what's done and what isn't. We do a clean handoff: source code in a repo you own, design files exported, credentials transferred. There's no scenario where we hold work hostage.

Termination terms (notice period, payment for work-in-progress, asset transfer mechanics) are spelled out in the contract before either of us signs, so neither side is surprised if it comes to that.

Yes — all of it. Source code goes in a Git repository under your account from day one (typically GitHub, but we can use whatever you prefer). Design files are delivered in editable formats. All third-party service credentials — hosting, CMS, analytics, email, payment processors — are set up under your accounts from the start, not ours.

If you ever want to switch developers, the next person can pick up exactly where we left off. That's by design, not an accident.

No. Everything we build is on open-source, industry-standard tooling — Next.js, React, TypeScript, Tailwind, Sanity, Vercel, Resend, and similar widely-supported tools. There's no proprietary CIMLAS framework, no closed-source plugins, no DRM-style lock-in.

Any competent developer familiar with the modern web stack can pick up your codebase. We deliberately avoid exotic dependencies and bespoke abstractions that only we understand. Boring, well-documented technology choices outlast clever ones.

For most projects we build, Next.js is the right tool: server-side rendering for SEO, image optimization out of the box, full TypeScript support, edge-deployable serverless functions, and a mature ecosystem.

We're not religious about it. For static-only sites Astro can be a better fit. For app-shell-heavy products, Remix or vanilla React might be. The framework choice is part of scoping — we recommend what serves your goals, not what's trendy. If you have a strong preference or existing infrastructure, we'll work within it or tell you honestly why we'd push back.

Vercel by default — it's purpose-built for Next.js, offers global edge delivery, automatic HTTPS, instant preview deploys for every change, and pricing that scales sanely from hobby to enterprise.

If you have constraints (existing AWS commitment, regulatory requirements, on-prem mandates, specific compliance needs), we can host elsewhere — Cloudflare Pages, AWS Amplify, Netlify, self-hosted Node, etc. Hosting costs are typically pass-through: you pay the platform directly under your account, not us.

Both are baked in, not bolted on at the end. We target Lighthouse scores in the 90s for Performance, Accessibility, Best Practices, and SEO — anything less and we keep iterating until we get there.

Structured data (JSON-LD), proper meta tags, OG cards, sitemaps, robots.txt, semantic HTML, lazy loading, image optimization — all standard, not upsells. We measure and report scores at launch and can re-test after content changes if you want continuous monitoring as part of an ongoing engagement.

Sanity is our default. It's developer-friendly, has a great editing experience for non-technical users, supports structured content properly, and the studio runs free for small teams.

If you have an existing CMS (WordPress, Contentful, Strapi, Webflow), we can integrate with that or migrate off it cleanly. If you need no CMS at all — some sites are better served by Markdown files in a Git repo — we'll tell you that too. Adding a CMS that nobody uses is a cost without a benefit.

Launch isn't the end of an engagement, it's a transition. We typically include a stabilization period post-launch where any bugs, performance issues, or polish items found in production are addressed at no extra cost — exact duration is in your contract.

After that, you can stay on a retainer for ongoing work, do project-based engagements as new needs come up, or take it from there with your own team. Whatever fits your trajectory.

Yes. Retainers are a flexible monthly arrangement — we set aside a block of hours each month for content updates, new features, optimization work, or whatever else comes up. Unused hours can roll forward (within reasonable limits) so you're not penalized for a quiet month, and overflow is handled transparently with prior approval.

Retainer terms are in the proposal and we size them honestly based on what you actually need, not maximum upsell. A retainer that goes unused isn't a win for either of us.

Depends on the engagement. For standard projects we don't operate a 24/7 on-call rotation — that's a separate, pricier arrangement we set up only when business requirements truly justify it. For the typical site, we monitor uptime and respond during business hours.

For mission-critical platforms (e-commerce during peak season, lead-gen funnels with active campaigns, anything where downtime has direct revenue impact) we can structure SLAs with response-time commitments outside business hours, priced accordingly. Don't pay for an SLA you don't need.

Not dependent on us by design. Content edits go through the CMS — anyone on your team can update copy, swap images, add blog posts, manage portfolios, all without writing a line of code or asking us.

For deeper changes (new pages, new features, design changes) you'd typically come back to us or hand it off to another developer. The codebase is structured to be readable and maintainable, not deliberately obscure. We hand off documentation that explains how the site is wired together so any competent developer can pick it up.

CIMLAS is intentionally lean. Owner-operated, no junior staff bait-and-switch, no offshore team you didn't sign up for. When you hire CIMLAS, you work directly with the person who's actually building the thing.

For larger projects we bring in trusted specialists (designers, motion artists, copywriters) on a project basis — but they're vetted contractors, not random freelancers, and you know exactly who's on your project. No pretending to be bigger than we are.

A mix that respects your time. Weekly checkpoint call (15-30 min, video or audio) for high-level alignment. Async updates via email or your preferred channel — Slack, Notion, Linear, whatever you're already using — for day-to-day progress.

Staging URLs you can review on your own time, with comments-as-feedback. We aim for clarity over volume: short updates often beats long updates rarely. If something is blocking, you hear about it immediately, not at the next standing meeting.

We're based in Eastern Time (US). Day-to-day work happens during US business hours, but async-friendly clients can be anywhere — we've worked with people in Europe, LATAM, and West Coast successfully.

For real-time communication (calls, urgent decisions) we'll find overlap windows that work for both sides. We're not the right fit for clients who require constant same-timezone synchronous availability — say so early and we'll refer you to someone who is.

Few enough that yours gets real attention. We deliberately limit concurrent projects to avoid the agency trap of stretching one person across too many engagements simultaneously.

Practically, this means there's sometimes a queue — we might not be able to start your project tomorrow. The trade-off is that when work is happening on your project, it has actual focus, not 15-minute slices wedged between four other things. If your timeline is tight and we're booked, we'll tell you upfront rather than overcommit.