■ DWG DT-10 // PROCESS_SPECSECTION 04 // PROTOCOL_PIPELINECADENCE: RIGID_1200PXSCALE 1:1
STATUS: SPEC_FROZENPLOT 89/2A-SRVDISPATCH: SRI LANKA
DevTenentv10.0
PROCESS // FOUR STAGES|SPEC SECTION

Survey, plan, build, maintain.

The same four stages on a one-page site and on a two-year application, because the stages are about decisions, not size.

GATES: STRICT CLIENT SIGN-OFF•ZERO ASSUMPTIONS IN CODE•REPLY WITHIN ONE BUSINESS DAY
SCHEMATIC // STAGE_LADDERILLUSTRATIVE UI
01 // STAGE
SURVEY
GATE 01
STAGE GATE — YOUR SIGN-OFF // BINDING SCOPE
02 // STAGE
PLAN
GATE 02
STAGE GATE — YOUR SIGN-OFF // FIXED QUOTE
03 // STAGE
BUILD
GATE 03
STAGE GATE — YOUR SIGN-OFF // STAGING REPO
04 // STAGE
MAINTAIN
ACTIVE CADENCE
DISPATCH CADENCE: SEQUENTIALZERO UNCHECKED RETRIES
STAGE 01// DISCOVERY & RECONNAISSANCE
TIMELINE: STAGE ONE // STRICT BOUNDS

We find out what is actually there.

Most engineering projects begin with optimism and end in negotiation because the initial state was guessed instead of measured. Before writing a line of code or drawing a component token, we inspect the current runtime, audit the database schema, trace existing API contracts, and evaluate your team's real operational constraints.

If you have an existing system, we read the server logs, benchmark your Core Web Vitals across actual devices, and uncover edge cases that marketing briefs omit. If you are starting fresh, we map the entity relationships, verify third-party service dependencies, and confirm compliance envelopes.

The survey produces clarity. It eliminates the phrase "we didn't know you needed that" by pinning every technical requirement down in writing before financial or structural commitments are made.

01 // VECTORDEV_TENENT

WHAT WE DO

  • 01Audit existing codebase, database schemas, and hosting infrastructure for bottlenecks.
  • 02Trace third-party APIs, webhooks, authentication flows, and latency vectors.
  • 03Benchmark Google Core Web Vitals and crawl accessibility against strict thresholds.
  • 04Document hard technical constraints, compliance boundaries, and editorial workflows.
02 // DELIVERABLEIN_WRITING

WHAT YOU GET

  • 01Written technical audit memo highlighting high-risk technical dependencies.
  • 02Entity relation diagram (ERD) detailing relational models and database structures.
  • 03Baseline performance telemetry report with zero synthetic metric padding.
  • 04Structured functional specification document ready for binding engineering sign-off.
03 // CLIENT_ACTIONSTAKEHOLDER

WHAT WE NEED FROM YOU

  • 01Read-only repository access or current production environment credentials.
  • 0230-minute introductory alignment session directly with the systems engineer.
  • 03List of critical third-party dependencies, API keys, and external vendor agreements.
  • 04Written confirmation of the core business metrics and user conversion targets.
EXIT: a written scope
TRANSITION CRITERIA: CLIENT_RECONCILIATION_COMPLETE
STAGE 02// SCHEMATICS & ARCHITECTURAL TOKENS
TIMELINE: WEEK 02–03 // FIXED ENVELOPE

Drawing before building.

In construction, you do not pour concrete while the client is still deciding whether the room is a kitchen or an office. In software, that error is committed constantly under the name of "agile." We draft complete, high-fidelity wireframes, token dictionaries, and responsive viewports before engineering starts.

Every interactive element is accounted for: loading states, validation error flags, empty states, and keyboard navigation rings. We map out database query budgets, deterministic edge routing tables, and server-side cache invalidation keys in ink.

Once approved, this schematic transforms into a legally binding specification. When the scope does not move, neither does the price.

DWG: SCHEMATIC_COREILLUSTRATIVE UI
VIEWPORT: 1200PX // RIGID
M01: INTAKE200 OK
M02: DISPATCHPASS
BRACKET // ZERO FIGSSECTION
01 // VECTORARCHITECT

WHAT WE DO

  • 01Draft high-contrast architectural wireframes for every viewport (desktop and mobile).
  • 02Define rigorous design tokens: strict semantic color scales, typographic hierarchy, and spacing grids.
  • 03Specify every component state: default, hover, active, empty, loading, disabled, and error.
  • 04Draft deterministic database queries and API boundary schemas.
02 // DELIVERABLESPEC_PACKAGE

WHAT YOU GET

  • 01Complete interactive wireframe prototype demonstrating navigation and logic flow.
  • 02Written token dictionary ready for immediate translation into Tailwind CSS variables.
  • 03Fixed-scope written contract specifying final cost, milestones, and deployment timeline.
  • 04One-year warranty commitment codified directly into the project scope.
03 // CLIENT_ACTIONAPPROVAL

WHAT WE NEED FROM YOU

  • 01Consolidated feedback from all internal stakeholders on the wireframe schematics.
  • 02Provisioning of real copy, asset vectors, or approval of content structure templates.
  • 03Formal sign-off on the architectural boundaries and screen catalogue.
  • 04Execution of the fixed-scope agreement and initial milestone clearance.
EXIT: a fixed-scope quote
IMMUTABLE SPECIFICATION SIGNED
STAGE 03// FABRICATION & CODE EXECUTION
TIMELINE: WEEK 04–07 // SPRINT ITERATIONS

Built in slices you can see.

We do not disappear into a dark cave for eight weeks to emerge with an unrecognisable black box. We engineer in vertical slices. A vertical slice is a complete, working section of the application—from the database query through the API endpoint to the rendered semantic HTML and interactive state.

You receive a live URL on a real staging domain every week. You can click through it, test edge cases on your actual phone, inspect the page speed in Google Lighthouse, and verify that the data flows as agreed.

Zero junior handoffs. The systems engineer who reviewed your survey and drafted your technical schematic is the same person writing your production code.

COMMERCIAL PROTOCOL // CHANGE_REQUEST_GOVERNANCE
ZERO AMBIGUITY // ZERO SURPRISE INVOICES

How changes are priced and approved during construction.

Software development is iterative, but unmanaged scope drift destroys timelines and budgets. When you need to alter a feature or introduce a new capability mid-build, we follow a strict three-step protocol:

STEP 01 // VECTOR PAUSE

Isolated Specification

Work on the unaffected core blueprint continues unimpeded. The new request is isolated and drawn as an independent architectural addendum with its own schema requirements.

STEP 02 // FIXED DELTA

Written Cost & Impact

We calculate the exact mathematical adjustment: additional engineering hours, third-party runtime fees, and milestone timeline impact. You receive a standalone, fixed-price quote.

STEP 03 // EXPLICIT SIGN-OFF

Informed Authorization

No billable code is written without your counter-signed authorization. If you decide not to proceed, the core timeline remains completely untouched. No surprises.

EXIT: staging you can click
STAGING DEPLOYMENT: CLOUDFLARE_EDGE_VERIFIED
STAGE 04// STEWARDSHIP & DEPLOYMENT LIFECYCLE
ONE-YEAR WARRANTY ON BUILDS

Then we keep it standing.

Building a website or internal tool is only half the work; keeping it performant, secure, and compatible with evolving browser engines is the other. We do not toss repositories over the fence and disappear. We monitor, patch, back up, and maintain every production deployment.

Discuss ongoing maintenanceREPLY: ONE BUSINESS DAY
SOVEREIGNTY PACT
100% Client-Owned

Every server credential, DNS record, Git repository, and API token is owned by your enterprise account directly. Zero proprietary hosting lock-in.

ROOT CREDENTIALS PROVISIONED IN YOUR NAME
MAINTENANCE SCOPE // PRODUCTION HARDENING MATRIX04 CONTINUOUS VECTORS
01 // MONITORING

Synthetic Uptime & Speed

Continuous HTTP edge probes check endpoint health every 60 seconds. Core Web Vitals telemetry tracks real user latency and layout drift.

02 // UPDATES

Security & Package Audits

Weekly vulnerability triage for npm, PHP, or Composer packages. Core framework upgrades deployed on staging before live deployment.

03 // BACKUPS

Deterministic Restores

Encrypted daily off-site database and asset snapshots stored in client S3/R2 buckets. Scripted monthly restore drills to verify disaster recovery.

04 // SUPPORT

Direct Engineer Desk

No ticketing queues or junior triage agents. Support emails connect directly to the systems engineer who engineered the deployment.

HONEST NOTE // ROOT CAUSE ANALYSIS
EMPIRICAL DRIFT REGISTER

Most projects go wrong at the scope, not the code.

In our experience, software failures rarely originate from algorithmic shortcomings or framework bugs. They originate from mismatched vocabulary, unstated expectations, and rushed handoffs. Here are the three primary failure modes this entire four-stage process is constructed to prevent:

FAILURE MODE 01

Unspoken Assumptions

A client imagines a feature will behave like a complex platform they use daily; an engineer builds the simplest MVP. We eliminate this in Stage 01 and Stage 02 by drawing every screen state, input validation rule, and error branch in visible wireframes before signing.

FAILURE MODE 02

Mid-Flight Spec Creep

Features get tacked onto an active sprint without calculating their effect on the database or delivery date, creating chaos and delayed deadlines. Our Change Protocol prices and scopes every addition in ink before any code is altered.

FAILURE MODE 03

Orphaned Handover

The agency launches the website, bills the final invoice, and abandons the client without operational runbooks, backups, or access credentials. We provide complete Git repository transfers, documented environment playbooks, and a one-year warranty on builds.

CADENCE // CONTINUOUS SEQUENCENO TIME ESTIMATES WITHOUT AUDIT
STAGE 01
SURVEY
DISCOVERY & AUDIT
STAGE 02
PLAN
SCHEMATICS & QUOTE
STAGE 03
BUILD
FABRICATION & TESTING
STAGE 04
MAINTAIN
WARRANTY & OPERATIONS
ORDER IS RIGID // NO CONCURRENT FABRICATION WITHOUT BLUEPRINT SIGN-OFF
SECTION 05 // SPEC_CLARIFICATIONSREPLY WITHIN ONE BUSINESS DAY

Frequently clarified specifications.

Why can we not skip the Survey stage if we already have a design?

+
Figma designs show visual layouts, not API response shapes, caching headers, or edge latency. Even when client designs are complete, the Survey stage inspects database schemas, hosting topologies, and third-party dependencies to ensure the architectural foundation holds up under actual web traffic.

How does the fixed-scope quote protect us from budget overruns?

+
We do not bill open-ended hourly retainers. The fixed-scope document commits all deliverables, milestones, and testing bounds in writing. If a feature requires additional engineering due to an architectural miscalculation on our part, we absorb the cost entirely.

What does the 1-year structural build warranty actually cover?

+
If any deployed code fails to execute as agreed in the signed specification within one year of handover, we rectify the defect at zero financial cost. It covers functional bugs, broken database schemas, and CSS regression caused by our code. It excludes third-party API outages or modifications made by unauthorized internal engineers.

Can our internal engineering team take over maintenance after build?

+
Yes. Handover is 100% complete and sovereign. You receive full Git repository administrative rights, migration documentation, deployment CI/CD scripts, and environment variable playbooks. You are never held hostage by proprietary vendor locks.

How quickly will we hear back after sending our brief?

+
We guarantee a direct written response within one business day. Your brief is reviewed by lead systems engineer Pubudu Dissanayaka—not an automated intake bot, sales liaison, or account coordinator.
COMMUNICATION_DISPATCH // INTAKE_PROTOCOL

Scope it with a call, not a form war.

Speak directly with a systems engineer who reviews your current product architecture, interfaces, and outlines a fixed-scope technical blueprint.

hello@devtenent.com• REPLY WITHIN ONE BUSINESS DAY • ONE-YEAR WARRANTY ON BUILDS
INTAKE PROTOCOLFIXED ESTIMATE
  • Direct technical dialogue with lead systems engineer.
  • Fixed-scope written quote within 48 hours.
  • Zero vendor lock-in; complete root access and IaC repository handover.
RESPONSE: < 24H GUARANTEEDSLOT: ACTIVE_02