Direct architect access · zero sales reps Surakarta, ID · UTC+7 · Remote worldwide

One senior engineer owns your platform, from schema to deploy.

You brief the lead architect, not an account manager. The first call ends with a database schema, an API contract and a fixed milestone schedule in writing, before you are asked for a deposit.

Build your scope spec View case deliveries
  • 13 years in production systems
  • Reply within 24 hours
  • No agency retainer
Engagement
Direct, one architect
Spec delivery
24 hours, written
Billing
Fixed price per milestone
Handover
Repository, keys, runbook
Telemetry dashboard in light theme showing 34.2 millisecond edge response, 12,480 catalogue queries per second, 99.98 percent availability and a tenant routing function written in TypeScript
  • 100 Lighthouse mobile
  • 41 ms TTFB, p50
  • 13+ Years engineering
  • 100% Code ownership

Built on the stack you can hire for tomorrow

  • Next.js
  • TypeScript
  • Python / FastAPI
  • PostgreSQL
  • Redis
  • Docker
  • Tailwind CSS
  • Cloudflare
Why direct

Agencies sell you a team. You need the person who designs the database.

Most custom software is quoted by a seller, specified by a manager and written by someone who never spoke to you. That gap is where deadlines and budgets go. One direct line removes it.

Dimension Agency model Direct architect
Communication

Every technical question travels through a person who cannot answer it, then returns days later, already stale.

You message the person holding the schema. Answers land in the same thread the same day, with the code attached.

Architecture

Decisions are made to fit the delivery template, not your traffic profile or the shape of your data model.

Schema, indexes and cache boundaries are argued against your real query volume before a screen is built.

Speed

Staging appears at the agreed demo dates, rebuilt from a branch you are never given access to.

Every working day ends with a URL you can click, on the milestone you are paying for.

Cost

Sales, account management and project coordination are billed into the same engineering rate you sign.

One senior rate, fixed per milestone. Added scope is quoted in writing before it is built.

Code quality

The senior who pitched you is booked elsewhere. Your build lands with whoever is free, undocumented at handover.

One owner writes, reviews and merges. Full commit history, keys and runbook transfer with the repository.

Effective rate

Senior rate × 3.0 coordination tax

One senior rate, zero coordination tax

Two column diagram comparing a four step agency chain with a four step direct architect engagement, showing day one against week twelve delivery timelines
Fig. 01 · Brief to deploy, agency chain against direct line
The commitment Three clauses, no exceptions

Written architecture in 24 hours.Working staging on day three.Your repository, your keys, your platform, at the end.

Core capabilities

Three things I build better than a generalist team

Each tier below is a fixed engagement shape with its own deliverables. If your project does not fit one, the specification step will say so before you pay anything.

  1. Product build

    High speed web applications and SaaS MVPs

    A complete product surface: tenant model, authentication, billing hooks and a server rendered front end. Built so the first hundred users do not require a rewrite for the first thousand.

    • Normalised data models with migration history from commit one
    • Server side rendering and route level caching for sub second navigation
    • Session auth with role based access control and audit logging
    • Automated test suite that gates every deploy
    • 3 to 4 weeks
    • Next.js + FastAPI
    • Fixed milestone price
    Database schema illustration showing tenants, sessions, orders and a replayable migration log with a covering index note
    Schema first
  2. Commerce

    Custom ecommerce and checkout engines

    Catalogue, cart and payment flow written as one system instead of glued plugins. The checkout survives retries, duplicate webhooks and abandoned carts without double charging anyone.

    • Catalog queries under 60 ms across a 20,000 item inventory
    • QRIS, Midtrans and Stripe in one payment abstraction with idempotent callbacks
    • Stock reservation that survives concurrent checkout attempts
    • Receipt generation and order state machine with replayable events
    • 4 to 6 weeks
    • Multi tenant ready
    • Live payment testing
    Checkout state machine diagram from cart pricing through payment intent, idempotent webhook handling and order confirmation, with a failure branch that releases stock
    Idempotent by design
  3. Rescue

    Platform rearchitecture and performance overhauls

    You have a system that works and a bill that keeps climbing. I measure first, then change the two or three things that actually cause the latency, rather than rewriting everything to look busy.

    • Query plan audit with index changes measured before and after
    • Cache boundaries placed at the layer that removes the most work
    • Lighthouse 100 on mobile with a documented performance budget
    • Incremental migration path, no big bang cutover weekend
    • 2 to 3 weeks
    • Audit first
    • Measured baseline
    Lighthouse gauge reading 100 for performance, with accessibility 100, SEO 100, TTFB 41 milliseconds and cumulative layout shift of zero
    Measured after, not claimed
Architecture

Every engagement starts with the diagram

Nothing is built until the request path is drawn and the latency budget is written down. This is the reference topology I start from, adapted to your traffic and your team.

Edge handoff
34.2 msCloudflare to origin, cached HTML
Service response
41 msFastAPI p50, read path
Catalogue read
12 msPostgreSQL with a covering index
Availability
99.98%Rolling 90 days
Reference architecture: browser to Cloudflare edge, Next.js application, FastAPI services, and a data layer of PostgreSQL, Redis and object storage, with delivery observability notes
Fig. 02 · Reference topology, edge to storage, with the latency budget annotated per hop
Process

Three milestones, each one clickable

No phase ends with a slide deck. Each milestone ends with something you can open in a browser or read in a repository.

  1. 01

    Spec and architecture lock

    Delivered in 24h

    One call, then a written specification. The data model, the API contract and the milestone dates are agreed before any code exists.

    • Entity diagram and table definitions
    • Endpoint list with request and response shapes
    • Fixed price per milestone
  2. 02

    Sprint staging and live previews

    Same day merge

    Each milestone closes with a deployed environment. You review the running product, not a screenshot, and comments land in the same repository.

    • Staging URL after every merged milestone
    • Weekly screen share plus async notes
    • Seeded demo data for realistic review
  3. 03

    Production hardening and full handover

    Full ownership transfer

    Load test, index review and a restore drill on the real backup. Then the repository, keys and runbook move to accounts you own.

    • Backup restore rehearsed once, on purpose
    • Deploy and rollback runbook
    • 30 day defect warranty included
Milestone schedule across four weeks: spec lock at 24 hours, build and staging for 10 to 14 working days, then hardening and handover for 3 to 5 days, with a 30 day defect warranty tail
Fig. 03 · The same three milestones on a calendar, so the schedule is inspectable before you commit
Spec builder

Build your scope spec in about 40 seconds

Select the shape of the work. The live summary assembles itself as you choose, and becomes the body of the reply I send you within 24 hours.

Configuration console Draft
Project type choose one
Timeline target window
Budget bracket USD, fixed price
Architecture modules select any
Enter your name, at least 2 characters.
Enter a valid email address, for example [email protected].
Keep this under 100 characters.
Enter the timezone you work in, for example Asia/Jakarta.
Minimum 20 characters. Traffic numbers and current stack help most. Add at least 20 characters so the reply can be specific.

No newsletter, no call required. A written reply within 24 hours.

Specification voucher AF-WEB-00000000-XXXX

Spec request received

Your answers are in. I read every request myself and reply with the architecture outline, the milestone split and the open questions I still need answered.

Client —
Work email —
Project type —
Timeline —
Budget bracket —
Modules —
Timezone —
Intake log — 
—
Keep this reference for follow up. Your details are used only to answer this request and are not added to any list.
Questions

The things clients ask before signing

Straight answers, including the parts that usually get buried in a proposal.

I do. Aditya Firmansyah designs the schema, writes the application and reviews every merge. There is no delivery team behind the contract, so a junior developer is never handed your build after signature.

Within 24 hours you get a written specification: entity diagram, table definitions, API contract, milestone list with dates, and a fixed price per milestone. It is yours to keep whether or not we proceed.

Fixed price per milestone, not hourly. A typical engagement bills the first milestone on start, the second at the staging review and the remainder at handover. Scope changes are priced in writing before any work begins.

Yes, in full. The repository transfers to your account with complete commit history, environment keys are issued to you, and the deployment runs on accounts you control. There is no licence fee and no vendor lock in.

I write a short change note describing the delta, the added hours and the revised milestone date. You approve or reject it before implementation. Nothing is billed without that written approval.

Next.js App Router and TypeScript on the front end, FastAPI with Pydantic on the service layer, PostgreSQL for transactional data, Redis for caching and queues, Docker for deployment, Caddy or Cloudflare at the edge. Any deviation is justified in the specification.

Yes. I run a three day audit first: dependency and security review, index and query analysis, then a written report of what blocks release. You can stop after the audit and keep the findings.

Every delivery includes a 30 day defect warranty at no extra cost, plus a runbook covering deploy, rollback and backup restore. Ongoing maintenance is optional and priced monthly, never bundled into the build.

Risk reversal

If the first milestone misses, you keep the specification and pay nothing further.

The terms are short on purpose: fixed price per milestone, code in your account from day one, and no retainer to escape.

Build your scope spec

Prefer email? [email protected]

01 · Ownership
100% IP ownershipRepository, commit history and keys transfer at handover.
02 · Price
Fixed milestone priceThe quoted number is the invoiced number, per milestone.
03 · Exit
Zero vendor lock inStandard stack, standard containers, your hosting accounts.