AIYAO is an IT development and consulting company. We build and maintain web and software projects, cloud infrastructure, and internal systems for businesses that need things to actually keep working.
Service 01
Custom builds and existing-codebase work — whichever your project actually needs.
What’s Included
Best For
A new product from scratch, a stalled internal tool that needs finishing, or an existing app that needs a developer who’ll actually document what they changed.
How It Starts
If there’s an existing codebase, we review it before quoting anything. If it’s a new build, we start from what the product actually needs to do — not a generic feature list.
What We Watch For
A steady stream of “just one more small thing” is how timelines quietly slip. We’ll flag when a request actually changes the scope, rather than absorbing it silently and letting the deadline move without you noticing.
Service 02
Infrastructure that’s set up once, correctly, instead of patched every time something breaks.
What’s Included
Best For
If deploying currently means someone SSHing in and hoping for the best, or your cloud bill doesn’t match your actual usage, this is the fix.
How It Starts
Before changing anything, we map what’s currently deployed, what it costs, and where the fragile points are — so the plan is based on your real setup, not assumptions.
What We Watch For
A cloud bill rarely goes down on its own. We build in a review point after setup instead of assuming the initial configuration stays optimal as usage changes.
Service 03
A second opinion before you commit budget, or a diagnosis when something’s clearly not working.
What’s Included
Best For
Evaluating a vendor’s proposal, deciding whether to rebuild or patch, or getting an outside read on a system before you inherit it.
How It Starts
We ask about the decision you’re facing and what’s already been tried, then give you a specific, written recommendation — not a generic best-practices deck.
What We Watch For
A recommendation that ignores your actual budget, team size, or timeline isn’t useful, however sound it looks in a report. We check advice against your real constraints before it’s final.
Consulting engagements start with an honest read on your situation — including telling you if you don’t need us at all.
Service 04
Making the tools you already pay for actually talk to each other.
What’s Included
Best For
If someone’s still copy-pasting between two tools every week, that’s usually a sign this is the service you need.
How It Starts
We start by tracing the current manual process end to end, so the integration replaces exactly what’s slow — not a reimagined version of it.
What We Watch For
An integration that fails quietly is worse than one that fails loudly — nobody notices until the data’s already wrong. Alerting on failure is part of the scope, not an afterthought we add later.
Integration work is easy to get wrong quietly — we document what’s connected to what, so nobody’s guessing six months later.
Every Engagement Includes
These don’t change based on which service or how big the project is.
→
Included
Deliverables and price agreed in writing before any work starts — no surprise add-ons.
→
Included
You see work in progress, not just a finished result handed over at the end.
→
Included
What we build comes with enough documentation that someone else could pick it up.
→
Included
Everything built is yours — no code, accounts, or infrastructure licensed back to us.
Written scope, regular check-ins, real documentation — the same baseline shows up on every engagement, not just the ones that go smoothly.
Deliverables
Not just “a solution.” These are the actual artifacts that end up in your hands, and it’s the same list on every engagement.
01
Pushed to your own git remote throughout the build, not handed over as a zip file at the end. Full ownership, nothing licensed back to us.
02
How to run it, how to deploy it, and how to roll it back if something goes wrong — written for someone who wasn’t in the room when it was built.
03
What was agreed at the start, plus a record of anything that changed along the way and why — so there’s no ambiguity in hindsight.
04
Any accounts or access we needed during the engagement are transferred to you or revoked at the end — nothing of ours stays connected to anything of yours.
05
A call walking your team, or whoever maintains it next, through what was built and why — not just what the code does.
06
A short period after delivery where questions about the handoff are answered at no extra charge — a handover that ends the moment the invoice is paid isn’t really a handover.
Scroll for all six →
How Long It Actually Takes
Every project is scoped individually, so treat these as the general shape, not a quote — the binding timeline is the one in your written scope.
Usually a few days
A real conversation about the project, and for existing systems, a review of what’s already there before we quote anything.
Usually a few days
Written deliverables, timeline, and pricing model land in your inbox for review — nothing starts until you’ve approved it.
Varies by project
A focused fix might be days; a full build is weeks. Work happens in sprints with regular check-ins, not a single silent stretch until the deadline.
A defined point, not a moving target
Deployment, a final walkthrough, and the deliverables above — handed over, not just demoed.
Ongoing, optional
Available on an as-needed or retainer basis after launch, for whichever fits how the system actually gets used.
Platforms & Tools
You’re not migrating to some proprietary system. If it’s a mainstream platform, tell us on the first call and we’ll confirm fit.
Languages & Frameworks
JavaScript/TypeScript, Node.js, Python, PHP, and the usual front-end frameworks — we’ll confirm your exact stack fits before quoting.
Cloud & Infrastructure
AWS, Google Cloud, Azure, and common hosting platforms — plus containerization and CI/CD tooling where it fits the project.
Data & Integration
SQL and NoSQL databases, REST and GraphQL APIs, and the webhook/queue tooling that connects systems together.
What’s listed under Platforms & Tools is what actually runs in production for our clients — not a technology wishlist we’ve never shipped.
Out of Scope
Every one of these has come up before. Saying no here upfront saves an awkward conversation later.
We’re not a body shop placing a developer into your team by the month. Engagements are scoped to an outcome, because that’s the arrangement where our incentives actually match yours.
We’ll commit to what we build and how it performs. We won’t promise revenue or growth numbers that depend on factors outside the work itself.
No exceptions, regardless of how small the request seems — verbal agreements are how projects quietly grow past what anyone actually agreed to.
If a targeted fix solves the real problem, that’s what we’ll scope. A full rewrite isn’t the answer just because it’s more billable.
Credentials and access are handed back or revoked at the end of an engagement, not kept around “just in case” we’re needed again.
We’re a technical partner. When a question needs a different kind of expertise, we’ll tell you rather than guess at an answer outside our lane.
Questions
Yes — most engagements start with one service. We’ll only recommend adding another if it genuinely fits your situation.
Regularly. We’ll review what exists first and give you an honest read on whether to continue with it or start fresh before quoting anything.
Tell us your stack on the first call — we’ll confirm fit directly rather than listing every technology here, since what matters is whether it fits your specific project.
Fixed scope for well-defined projects, hourly for open-ended consulting or ongoing support. We’ll recommend the model that fits once we understand the work.
Yes, if it’s relevant once we’re scoping something specific — not usually needed just for an initial conversation.
Yes — a store setup often pairs with cloud infrastructure, or a consulting review leads into a build. We’ll scope the combination as one project with one timeline, not two separate invoices.
We flag it as soon as we see it, explain why, and get your sign-off before doing anything beyond the agreed scope. No surprise line items at the end.
Yes. Most of our communication happens asynchronously in writing, so time zones aren’t usually a blocker — we’ll agree on overlap hours for calls if needed.
Yes — work is pushed to your own repository throughout, not delivered as a single handoff at the finish line. You can watch progress happen in real time if you want to.
Anything we needed during the engagement is handed back or revoked when we’re done. We don’t hold onto standing access “just in case” we’re needed again later.
Yes, to the extent that’s proportionate for the project — we’ll agree what level of test coverage makes sense as part of the written scope, rather than assume one answer fits every build.
Yes, and it usually makes the handover smoother. We’re comfortable working inside your existing repository and following your team’s conventions.
Since nothing is proprietary or locked to us, that’s a normal handover — not a migration project. Everything you need to do it is already covered under Deliverables above.
The price in your written scope is fixed for that scope. If requirements genuinely change partway through, we’ll tell you what that does to the price and timeline before doing the extra work — never after.
Our Commitment
If a smaller fix solves your problem instead of a full rebuild, we’ll say so — even if it means a smaller invoice.