Build something that works.

What to receive

Page inventory, working site and ownership handover.

What to clarify first

Which functions require custom code or paid services?

How to check it

Test the primary visitor journey and owner editing workflow.

Where the scope ends

Design mockups and a deployed working website are separate deliverables.

Reference context: Service taxonomy

What to receive

Configured site, plugin inventory and backup instructions.

What to clarify first

Who owns plugin licenses and handles future updates?

How to check it

Edit a page and verify restoration of files and database in staging.

Where the scope ends

Theme installation is narrower than custom development and maintenance.

Reference context: Service taxonomy · WordPress: backups

What to receive

Theme configuration, product setup and checkout test record.

What to clarify first

Which features depend on your current plan or paid apps?

How to check it

Test variants, shipping and an approved test purchase.

Where the scope ends

Store setup excludes app subscriptions and ongoing store operations unless listed.

Reference context: Service taxonomy · Shopify: store ownership and collaboration

What to receive

Editable pages, form setup and account handover.

What to clarify first

Which requested interactions need custom code or a paid plan?

How to check it

Edit mobile layouts and verify every form's delivery destination.

Where the scope ends

A visual prototype does not confirm that bookings or payments work.

Reference context: Service taxonomy

What to receive

Configured templates, page content and editing notes.

What to clarify first

Can the selected template and plan support the required layout?

How to check it

Check mobile navigation, forms and content editing in your account.

Where the scope ends

Template customization should be distinguished from unsupported platform changes.

Reference context: Service taxonomy

What to receive

Responsive pages, CMS fields and publishing instructions.

What to clarify first

What CMS limits, hosting terms and export needs affect the build?

How to check it

Add a new CMS item and inspect all responsive breakpoints.

Where the scope ends

Exported code and a hosted CMS workflow may have different scope.

Reference context: Service taxonomy

What to receive

Data model, workflows and deployment handover.

What to clarify first

How will privacy rules and workload costs be evaluated?

How to check it

Test different user roles and failed workflow paths.

Where the scope ends

A clickable screen set is different from a secure working application.

Reference context: Service taxonomy

What to receive

Catalog, payment configuration and order-flow documentation.

What to clarify first

Who owns extension licenses and handles update conflicts?

How to check it

Test checkout, stock changes and order emails on staging.

Where the scope ends

WooCommerce work includes store logic beyond ordinary WordPress page building.

Reference context: Service taxonomy

What to receive

Funnel pages, form integrations and test transaction notes.

What to clarify first

Which upsells, automations and third-party costs are included?

How to check it

Follow each branch from entry page through confirmation.

Where the scope ends

A funnel build does not include advertising traffic or conversion guarantees.

Reference context: Service taxonomy

What to receive

Source code, deployment configuration and maintenance documentation.

What to clarify first

Why is custom development preferable for these requirements?

How to check it

Build from the delivered repository and test agreed user flows.

Where the scope ends

Custom code ownership does not automatically include unlimited support.

Reference context: Service taxonomy

What to receive

Module scope, storefront changes and deployment instructions.

What to clarify first

Which version, hosting resources and extensions must be supported?

How to check it

Test catalog rules, checkout and rollback on a staging copy.

Where the scope ends

A theme change is different from upgrading core or integrating operations.

Reference context: Service taxonomy

What to receive

Editable pages, settings inventory and handover guide.

What to clarify first

Which vendor and product version does the seller mean by SiteBuilder?

How to check it

Verify the work inside your own account and test required functions.

Where the scope ends

The category name alone does not identify a specific platform.

Reference context: Service taxonomy

What to receive

Course structure, lesson uploads and enrollment configuration.

What to clarify first

Who provides lessons and verifies plan-dependent learning features?

How to check it

Enroll a test learner and check lesson access and completion behavior.

Where the scope ends

Platform setup is different from writing or accrediting a course.

Reference context: Service taxonomy

What to receive

Content types, permissions and deployment documentation.

What to clarify first

Which modules and version compatibility constraints govern the project?

How to check it

Create content under different roles and verify access boundaries.

Where the scope ends

Content modeling and editorial permissions require more than theme installation.

Reference context: Service taxonomy

What to receive

Working pages, product-specific settings and account handover.

What to clarify first

Is the work on the website builder or a separately hosted CMS?

How to check it

Test editing, domain routing and forms in the actual chosen product.

Where the scope ends

GoDaddy branding alone does not establish the site's technical platform.

Reference context: Service taxonomy

What to receive

Templates, content structure and extension inventory.

What to clarify first

Which Joomla version and upgrade path are supported?

How to check it

Test menus, user permissions and extension interactions.

Where the scope ends

An old extension dependency may change the scope of an upgrade.

Reference context: Service taxonomy

What to receive

Theme configuration, labels and publishing instructions.

What to clarify first

Will an existing blog, custom domain or template be migrated?

How to check it

Publish a test post and inspect labels, archives and mobile reading.

Where the scope ends

Blog configuration is different from a custom membership application.

Reference context: Service taxonomy

What to receive

Store configuration, extensions and handover documentation.

What to clarify first

Which OpenCart version and extension compatibility are required?

How to check it

Test product options, taxes configured by the owner and order emails.

Where the scope ends

An attractive storefront does not confirm checkout integration quality.

Reference context: Service taxonomy

What to receive

Platform-specific build, feature inventory and ownership notes.

What to clarify first

What limitations make this builder suitable or unsuitable?

How to check it

Test required functions in your own subscribed account.

Where the scope ends

Do not assume features available on one builder exist on another.

Reference context: Service taxonomy

What to receive

Storefront setup, catalog mapping and integration notes.

What to clarify first

Which plan, channels and integration limits affect the requirements?

How to check it

Check product synchronization and a full test order.

Where the scope ends

Storefront setup differs from building a custom headless frontend.

Reference context: Service taxonomy

What to receive

Store configuration, module list and maintenance instructions.

What to clarify first

Which module licenses and compatibility tests are included?

How to check it

Test multilingual products, checkout and order administration.

Where the scope ends

Module installation is not ongoing compatibility maintenance.

Reference context: Service taxonomy

What to receive

Channel configuration, storefront work and deployment notes.

What to clarify first

Which edition, extensions and external systems are in scope?

How to check it

Test channel-specific pricing and checkout with sample products.

Where the scope ends

A single-store theme task differs from multi-channel architecture.

Reference context: Service taxonomy

What to receive

Shop styling, product entries and purchase-flow setup.

What to clarify first

Does the selected plan accommodate the catalog and required options?

How to check it

Check product variants, mobile browsing and checkout settings.

Where the scope ends

A small-shop setup should not imply enterprise inventory integration.

Reference context: Service taxonomy

What to receive

Version inventory, store changes and upgrade notes.

What to clarify first

Which exact release and existing extensions must remain compatible?

How to check it

Test checkout and verify a recoverable pre-change backup.

Where the scope ends

Legacy customization may require separate migration work.

Reference context: Service taxonomy

What to receive

Responsive pages, form configuration and editing guide.

What to clarify first

Which existing account features and commerce needs must be retained?

How to check it

Change content yourself and verify mobile menus and submissions.

Where the scope ends

A builder redesign does not necessarily transfer custom integrations.

Reference context: Service taxonomy

What to receive

Pages, funnel sequence and connected form settings.

What to clarify first

Is the order for a website, a funnel or both?

How to check it

Follow each page path and verify submitted data destinations.

Where the scope ends

Website navigation and a sequential funnel serve different user behaviors.

Reference context: Service taxonomy

What to receive

Configured pages, domain settings and editing documentation.

What to clarify first

Which IONOS builder or CMS environment is actually being used?

How to check it

Test domain resolution, secure access and owner editing.

Where the scope ends

Hosting purchase and website production are separate costs and tasks.

Reference context: Service taxonomy

What to receive

Editable pages, form connections and publishing notes.

What to clarify first

Which custom blocks or integrations require additional work?

How to check it

Check mobile spacing and verify data from every form.

Where the scope ends

A visually customized page does not automatically include backend development.

Reference context: Service taxonomy

What to receive

Core pages, contact setup and owner instructions.

What to clarify first

Which Jimdo product and plan support your required features?

How to check it

Update business details and test contact paths on mobile.

Where the scope ends

A simple business site is different from a custom booking system.

Reference context: Service taxonomy

What to receive

Section structure, navigation and contact or signup setup.

What to clarify first

Will the content fit one page or require multiple pages?

How to check it

Test anchor navigation and forms on a narrow screen.

Where the scope ends

A one-page presentation may not suit a complex content library.

Reference context: Service taxonomy

What to receive

Page configuration, supplied content and editing instructions.

What to clarify first

Which layout and integration constraints should be accepted before ordering?

How to check it

Verify required pages and functions in the selected account plan.

Where the scope ends

Builder configuration should not be sold as unrestricted custom development.

Reference context: Service taxonomy

What to receive

Maintenance schedule, change log and incident process.

What to clarify first

What response window and update rollback process are included?

How to check it

Review evidence of updates, backups and representative workflow checks.

Where the scope ends

Maintenance is different from unlimited redesign or emergency coverage.

Reference context: Service taxonomy

What to receive

Scoped changes, affected-file notes and regression results.

What to clarify first

Which existing features must remain unchanged?

How to check it

Compare before and after behavior across affected screen sizes.

Where the scope ends

Customization requires a defined boundary, not an open-ended redesign.

Reference context: Service taxonomy

What to receive

Root-cause note, fix and reproduction-based verification.

What to clarify first

Can the seller reproduce the problem in a safe environment?

How to check it

Repeat the original failure and test adjacent functionality.

Where the scope ends

A cosmetic workaround is different from resolving the underlying defect.

Reference context: Service taxonomy

What to receive

Verified backup, migration plan and rollback instructions.

What to clarify first

Are both application files and relevant databases included?

How to check it

Restore a copy and compare content, URLs and key workflows.

Where the scope ends

Creating a backup is not the same as proving it can be restored.

Reference context: Service taxonomy · WordPress: backups

What to receive

DNS inventory, hosting setup and handover record.

What to clarify first

Who owns the registrar account and how is existing email protected?

How to check it

Check website access and email-related DNS before and after changes.

Where the scope ends

Domain registration does not include website development or perpetual hosting.

Reference context: Service taxonomy

What to receive

Installed package, license record and configuration notes.

What to clarify first

Is the package legitimate and compatible with the current site?

How to check it

Test the affected feature and check for conflicts in staging.

Where the scope ends

Installation alone does not include custom feature development.

Reference context: Service taxonomy

What to receive

Assessment, recommended actions and risk notes.

What to clarify first

Will the consultation include access-based inspection or a discussion only?

How to check it

Require recommendations tied to the observed site condition.

Where the scope ends

Consultation is not a completed repair or ongoing support contract.

Reference context: Service taxonomy

What to receive

Working installation, prerequisites and administrator handover.

What to clarify first

Which server dependencies and licensing costs are required?

How to check it

Complete first login and verify a sample page or transaction.

Where the scope ends

A fresh installation does not include migrating an existing site.

Reference context: Service taxonomy

What to receive

Baseline, implemented changes and comparable follow-up results.

What to clarify first

Which pages, devices and network conditions define success?

How to check it

Compare repeated measurements and check that features still work.

Where the scope ends

A single high score does not guarantee all visitors' performance.

Reference context: Service taxonomy

What to receive

Finding list, remediation notes and recovery recommendations.

What to clarify first

Is the scope hardening, incident cleanup or an assessment?

How to check it

Verify the stated fixes and review access and backup procedures.

Where the scope ends

Security work cannot guarantee that a site will never be compromised.

Reference context: Service taxonomy

What to receive

Event plan, implementation and verification record.

What to clarify first

Which events are necessary and what consent rules apply?

How to check it

Trigger test events and verify duplicates and sensitive-data exclusion.

Where the scope ends

Installing analytics is different from interpreting business performance.

Reference context: Service taxonomy

What to receive

Requirements, working code and deployment handover.

What to clarify first

What makes the first release complete and maintainable?

How to check it

Run acceptance scenarios and build from delivered source.

Where the scope ends

A prototype and a supported production system require different scope.

Reference context: Service taxonomy

What to receive

Data model, role workflows and integration documentation.

What to clarify first

Which existing system remains authoritative for each record?

How to check it

Test cross-module transactions and permission boundaries.

Where the scope ends

Custom business-system development differs from configuring an existing SaaS tool.

Reference context: Service taxonomy

What to receive

Application source, database changes and deployment instructions.

What to clarify first

Who owns authentication, migrations and operational monitoring?

How to check it

Test complete user journeys including errors and unauthorized access.

Where the scope ends

A frontend demonstration alone is not a full-stack deliverable.

Reference context: Service taxonomy

What to receive

Installable builds, source and update instructions.

What to clarify first

Which OS versions, permissions and offline behavior are required?

How to check it

Install on a clean target machine and test file access and uninstall.

Where the scope ends

A developer's local executable is not a complete distributable product.

Reference context: Service taxonomy

What to receive

Integration code, mapping rules and failure handling.

What to clarify first

How are rate limits, retries and credential rotation handled?

How to check it

Test duplicate requests, unavailable services and malformed records.

Where the scope ends

A successful happy-path request does not prove a reliable integration.

Reference context: Service taxonomy

What to receive

Root-cause explanation, patch and regression coverage.

What to clarify first

Which supported versions and environments exhibit the failure?

How to check it

Reproduce the original issue and verify adjacent behavior.

Where the scope ends

A bug fix is different from adding an unrelated feature.

Reference context: Service taxonomy

What to receive

Workflow code, permissions and exception handling.

What to clarify first

Which actions can run autonomously and which require approval?

How to check it

Test failures, repeated inputs and safe stopping behavior.

Where the scope ends

An agent should not receive unrestricted authority merely for convenience.

Reference context: Service taxonomy

What to receive

Extension source, packaged build and permission explanation.

What to clarify first

Which browsers and minimum permissions are required?

How to check it

Test install, update and behavior on supported websites.

Where the scope ends

Store submission and approval are separate from building an extension.

Reference context: Service taxonomy

What to receive

HTML template, editable content areas and rendering samples.

What to clarify first

Which clients, dark modes and sending platform must be supported?

How to check it

Send real test messages and check links and narrow-screen layout.

Where the scope ends

Email HTML behaves differently from an ordinary web page.

Reference context: Service taxonomy

What to receive

Responsive implementation, assets and interaction mapping.

What to clarify first

Which missing states and breakpoints need design decisions?

How to check it

Compare key screens and test interactions and keyboard use.

Where the scope ends

Visual matching alone does not include backend functionality.

Reference context: Service taxonomy

What to receive

Script, input format and execution instructions.

What to clarify first

How should the script handle missing files and partial failures?

How to check it

Run representative and invalid inputs in a safe test folder.

Where the scope ends

A one-off script may need extra work for unattended production use.

Reference context: Service taxonomy

What to receive

Decision notes, alternatives and next steps.

What to clarify first

Will the adviser inspect the code and constraints first?

How to check it

Check that recommendations address actual dependencies and tradeoffs.

Where the scope ends

Consultation does not deliver the proposed implementation automatically.

Reference context: Service taxonomy

What to receive

Plugin source, installation package and compatibility notes.

What to clarify first

Which host versions and extension APIs are supported?

How to check it

Install in a clean test environment and exercise update and removal.

Where the scope ends

A plugin depends on its host and is not a standalone application.

Reference context: Service taxonomy

What to receive

App source, test builds and release instructions.

What to clarify first

Which platforms, backend services and store submissions are included?

How to check it

Test core journeys on real target devices and poor connectivity.

Where the scope ends

An app prototype is different from a production store release.

Reference context: Service taxonomy

What to receive

Shared codebase, platform builds and device test results.

What to clarify first

Which features still require platform-specific implementation?

How to check it

Compare permissions, navigation and performance on both platforms.

Where the scope ends

Shared code does not eliminate separate platform testing.

Reference context: Service taxonomy

What to receive

App wrapper or adapted code, navigation and release notes.

What to clarify first

What native value and offline behavior will the app provide?

How to check it

Test authentication, external links and back navigation on devices.

Where the scope ends

A website wrapper is not equivalent to a fully native rebuild.

Reference context: Service taxonomy

What to receive

Android source, signed test build and release documentation.

What to clarify first

Who controls signing keys and which device versions are supported?

How to check it

Test permissions, lifecycle changes and key flows on target devices.

Where the scope ends

Development does not guarantee app-store acceptance.

Reference context: Service taxonomy

What to receive

App source, device build and submission materials.

What to clarify first

Which Apple account, capabilities and device targets are required?

How to check it

Test permissions, background behavior and supported screen sizes.

Where the scope ends

Submission preparation is different from approval by Apple.

Reference context: Service taxonomy · Apple: App Review Guidelines

What to receive

TV interface, platform build and playback or navigation tests.

What to clarify first

Which TV operating systems and remote inputs are supported?

How to check it

Navigate every screen without touch and test playback recovery.

Where the scope ends

A stretched mobile layout is not a usable TV interface.

Reference context: Service taxonomy

What to receive

Game build, source project and asset inventory.

What to clarify first

Which mechanics, content volume and hardware targets define completion?

How to check it

Play through agreed scenarios and check performance on target hardware.

Where the scope ends

A prototype does not include a finished content library or live operations.

Reference context: Service taxonomy

What to receive

Technical assessment, engine options and feasibility notes.

What to clarify first

Will the consultant review an existing project or only the concept?

How to check it

Check recommendations against team skills and platform constraints.

Where the scope ends

Game consultation does not include a playable implementation.

Reference context: Service taxonomy

What to receive

Restorable project copy, migration log and version notes.

What to clarify first

Are source assets, engine versions and external packages included?

How to check it

Open the restored project and build a representative level.

Where the scope ends

Copying exported game files is different from preserving editable source.

Reference context: Service taxonomy

What to receive

Updated project, change notes and compatibility results.

What to clarify first

Which existing levels, saves and plugins must remain compatible?

How to check it

Test changed mechanics with old saves and adjacent systems.

Where the scope ends

Customization is not a commitment to rebuild the entire game.

Reference context: Service taxonomy

What to receive

Playable prototype, controls and learning notes.

What to clarify first

Which hypothesis should the prototype answer?

How to check it

Play the core loop and assess the stated hypothesis.

Where the scope ends

Prototype art and architecture may be intentionally unsuitable for release.

Reference context: Service taxonomy

What to receive

Playable release, editable project and licensed-asset inventory.

What to clarify first

How many levels, modes and supported devices are included?

How to check it

Complete a structured playthrough and inspect release packaging.

Where the scope ends

Full creation needs explicit limits on content, multiplayer and postlaunch support.

Reference context: Service taxonomy

What to receive

Mod package, installation instructions and version support notes.

What to clarify first

Does the game permit this modification and distribution method?

How to check it

Test on the stated game version and verify clean removal.

Where the scope ends

Exclude cheating, bypassing protections or unauthorized copyrighted assets.

Reference context: Service taxonomy

What to receive

Patch, reproduction steps and regression results.

What to clarify first

Which game state, save and hardware trigger the issue?

How to check it

Repeat the failure scenario and test related mechanics.

Where the scope ends

Balancing a mechanic is different from fixing a technical defect.

Reference context: Service taxonomy

What to receive

Working integration, evaluation examples and operating documentation.

What to clarify first

What errors are unacceptable and when must a human review output?

How to check it

Test representative, ambiguous and adversarial inputs.

Where the scope ends

A persuasive demonstration does not establish dependable accuracy.

Reference context: Service taxonomy

What to receive

Mobile integration, model connection and fallback behavior.

What to clarify first

How will latency, data sharing and usage costs be controlled?

How to check it

Test slow networks, denied permissions and incorrect model output.

Where the scope ends

AI functionality does not remove ordinary app security and usability requirements.

Reference context: Service taxonomy

What to receive

Application code, evaluation set and deployment notes.

What to clarify first

Which outputs need citations, validation or human approval?

How to check it

Test realistic tasks and document unsupported cases.

Where the scope ends

A chat interface alone is not a validated business solution.

Reference context: Service taxonomy

What to receive

Deployment configuration, monitoring and rollback plan.

What to clarify first

How are model versions, data access and cost limits managed?

How to check it

Exercise failure recovery and compare production outputs with evaluations.

Where the scope ends

Deployment work is distinct from proving the model fits the use case.

Reference context: Service taxonomy

What to receive

Instructions, knowledge configuration and example evaluations.

What to clarify first

Which current product plan and sharing permissions are required?

How to check it

Try questions outside the knowledge scope and inspect access boundaries.

Where the scope ends

Customization is not the same as training a proprietary model.

Reference context: Service taxonomy

What to receive

Architecture options, limitations and pilot scope.

What to clarify first

What data and evaluation evidence support the recommendation?

How to check it

Check alternatives, expected operating costs and failure modes.

Where the scope ends

Consulting cannot establish performance without a relevant evaluation.

Reference context: Service taxonomy

What to receive

API integration, validation rules and error handling.

What to clarify first

How are sensitive data, rate limits and provider outages handled?

How to check it

Test malformed outputs and confirm safe fallback behavior.

Where the scope ends

Connecting an API does not make its outputs trustworthy automatically.

Reference context: Service taxonomy

What to receive

Source repository, working build and verification notes.

What to clarify first

Who reviews generated code and documents dependencies?

How to check it

Build from source and test the real user workflow.

Where the scope ends

Fast code generation is different from production readiness.

Reference context: Service taxonomy

What to receive

Diagnosis, code changes and regression evidence.

What to clarify first

Which architectural shortcuts need repair beyond visible errors?

How to check it

Re-run failed workflows and inspect configuration and secret handling.

Where the scope ends

Patching symptoms may not resolve an unsuitable underlying design.

Reference context: Service taxonomy

What to receive

Bounded MVP, source and known-limitations list.

What to clarify first

Which assumptions must the MVP test and what is excluded?

How to check it

Complete the core journey and review unfinished production requirements.

Where the scope ends

An MVP is not automatically ready for unrestricted public use.

Reference context: Service taxonomy

What to receive

Build pipeline, environment setup and rollback instructions.

What to clarify first

Can the project build independently of the original coding tool?

How to check it

Deploy to staging and verify secrets, logs and recovery.

Where the scope ends

Publishing a URL alone does not establish an operable system.

Reference context: Service taxonomy

What to receive

Guided exercises, review checklist and project notes.

What to clarify first

Will training cover debugging and verification of generated code?

How to check it

Modify a feature independently and explain how it was checked.

Where the scope ends

Tool fluency does not replace understanding security-sensitive code.

Reference context: Service taxonomy

What to receive

Conversation scope, channel integration and handoff behavior.

What to clarify first

Should responses follow fixed rules or use a language model?

How to check it

Test misunderstood requests and transfer to a human when needed.

Where the scope ends

A chatbot is not automatically a complete customer-support operation.

Reference context: Service taxonomy

What to receive

Decision tree, response copy and channel configuration.

What to clarify first

What happens when input does not match a defined option?

How to check it

Walk every branch including restart, cancel and fallback paths.

Where the scope ends

Rule-based flows do not freely reason about unseen questions.

Reference context: Service taxonomy

What to receive

Knowledge setup, evaluation cases and escalation rules.

What to clarify first

How are unsupported answers and stale information detected?

How to check it

Test ambiguous questions and requests outside the approved knowledge.

Where the scope ends

Fluent language is not evidence that an answer is correct.

Reference context: Service taxonomy

What to receive

Architecture, configuration and operational handover.

What to clarify first

Which availability, data-location and budget constraints matter?

How to check it

Deploy a test workload and inspect access and cost visibility.

Where the scope ends

Cloud setup does not automatically include ongoing operations.

Reference context: Service taxonomy

What to receive

Options comparison, cost assumptions and migration risks.

What to clarify first

What workload measurements support sizing recommendations?

How to check it

Check assumptions against actual usage and recovery needs.

Where the scope ends

A cost estimate is not a fixed future cloud bill.

Reference context: Service taxonomy

What to receive

Network diagram, access policies and verification results.

What to clarify first

Which services need public exposure and which should remain private?

How to check it

Test allowed and denied connections from representative locations.

Where the scope ends

Network configuration is different from a complete application security audit.

Reference context: Service taxonomy

What to receive

Resource inventory, monitoring and change procedures.

What to clarify first

What coverage hours and spending authority are included?

How to check it

Review alerts, changes and unresolved operational issues.

Where the scope ends

Cloud management does not imply unlimited emergency staffing.

Reference context: Service taxonomy

What to receive

Function code, event configuration and observability setup.

What to clarify first

How are retries, execution limits and duplicate events handled?

How to check it

Test repeated events, timeouts and downstream failures.

Where the scope ends

Serverless hosting still requires cost, access and reliability management.

Reference context: Service taxonomy

What to receive

Delivery workflow, environment configuration and runbooks.

What to clarify first

Which manual steps and failure risks should be removed first?

How to check it

Repeat a deployment and demonstrate recovery from a failed release.

Where the scope ends

DevOps is broader than installing a deployment tool.

Reference context: Service taxonomy

What to receive

Infrastructure definitions, state handling and execution guide.

What to clarify first

How will state, secrets and destructive changes be protected?

How to check it

Preview changes and recreate a safe test environment.

Where the scope ends

Infrastructure code needs review before it changes live resources.

Reference context: Service taxonomy

What to receive

Pipeline configuration, required checks and rollback path.

What to clarify first

Which events trigger deployment and which require approval?

How to check it

Run successful and intentionally failing changes through the pipeline.

Where the scope ends

A passing build does not substitute for meaningful application checks.

Reference context: Service taxonomy · GitHub: understanding Actions

What to receive

Build files, runtime configuration and image documentation.

What to clarify first

How are persistent data and secrets separated from images?

How to check it

Build cleanly and restart containers without losing required data.

Where the scope ends

Containerization is distinct from orchestrating a production cluster.

Reference context: Service taxonomy

What to receive

Workflow assessment, priorities and implementation roadmap.

What to clarify first

Which evidence shows the current deployment or recovery problems?

How to check it

Tie recommendations to measurable delivery and recovery outcomes.

Where the scope ends

Advice does not include migrating every team workflow.

Reference context: Service taxonomy

What to receive

Support scope, configuration notes and handover.

What to clarify first

Which systems may be accessed and what changes require approval?

How to check it

Verify the original task and document all changed settings.

Where the scope ends

General IT support does not authorize unrestricted account access.

Reference context: Service taxonomy

What to receive

Diagnosis, resolution steps and remaining limitations.

What to clarify first

Can troubleshooting use a temporary, supervised access session?

How to check it

Repeat the original task and remove temporary access afterward.

Where the scope ends

Remote support cannot guarantee repair of physical hardware faults.

Reference context: Service taxonomy

What to receive

Configuration inventory, update process and recovery notes.

What to clarify first

Who approves downtime and how are backups verified?

How to check it

Check service health, restricted access and a restoration exercise.

Where the scope ends

Server administration is separate from application feature development.

Reference context: Service taxonomy

What to receive

Mailbox setup, DNS records and migration notes.

What to clarify first

How will existing mail, aliases and account ownership be preserved?

How to check it

Send and receive test messages and verify migrated folders.

Where the scope ends

Email administration is different from writing marketing campaigns.

Reference context: Service taxonomy

What to receive

Call flow, device configuration and support documentation.

What to clarify first

Which numbers, regions and emergency-calling requirements need verification?

How to check it

Test inbound, outbound, voicemail and failover scenarios.

Where the scope ends

Telephony setup excludes carrier fees and regulatory assurances unless specified.

Reference context: Service taxonomy

What to receive

Installed application, configuration and license inventory.

What to clarify first

Are administrator rights and compatible hardware available?

How to check it

Open representative files and verify required integrations.

Where the scope ends

Installation does not include unauthorized license bypass or custom development.

Reference context: Service taxonomy

What to receive

Device map, secure access setup and retention configuration.

What to clarify first

Who verifies local privacy and installation requirements?

How to check it

Test recordings, access restrictions and a controlled connectivity failure.

Where the scope ends

System setup does not provide continuous monitoring or guarantee crime prevention.

Reference context: Service taxonomy

What to receive

Data mapping, migration runbook and reconciliation report.

What to clarify first

Which history, permissions and integrations cannot transfer directly?

How to check it

Compare record counts and test critical workflows before cutover.

Where the scope ends

A data export alone is not a completed migration.

Reference context: Service taxonomy

What to receive

Specification, test implementation and risk limitations.

What to clarify first

Who reviews custody, regulatory and security implications independently?

How to check it

Verify behavior on a test network before considering real assets.

Where the scope ends

Software delivery does not establish investment value or regulatory compliance.

Reference context: Service taxonomy

What to receive

Wallet code, key-handling design and recovery documentation.

What to clarify first

Who controls keys and what recovery model is intended?

How to check it

Test signing, rejected transactions and recovery without real funds.

Where the scope ends

A wallet UI and secure custody infrastructure are different scopes.

Reference context: Service taxonomy

What to receive

Token specification, contract source and deployment notes.

What to clarify first

Who can mint, freeze, upgrade or change the token's behavior?

How to check it

Verify privileged actions and supply rules on a test network.

Where the scope ends

Token creation does not establish value, liquidity or legal suitability.

Reference context: Service taxonomy

What to receive

Architecture, test platform and integration documentation.

What to clarify first

Who handles custody, compliance and independent security review?

How to check it

Test order matching, balances and failure recovery using simulated funds.

Where the scope ends

An exchange prototype is not a licensed or safely operated financial service.

Reference context: Service taxonomy

What to receive

Contract source, tests and deployment parameters.

What to clarify first

Which privileged roles, upgrade paths and irreversible actions exist?

How to check it

Review edge cases and obtain independent assessment before real-value use.

Where the scope ends

Contract deployment is not a security audit.

Reference context: Service taxonomy

What to receive

Architecture, implementation and operational limitations.

What to clarify first

Why does this use case need a blockchain rather than a conventional database?

How to check it

Test consensus or transaction assumptions relevant to the chosen design.

Where the scope ends

Blockchain technology does not make incorrect inputs truthful.

Reference context: Service taxonomy

What to receive

Query method, transaction references and uncertainty notes.

What to clarify first

How are address labels sourced and confidence expressed?

How to check it

Reproduce sampled findings and distinguish transfers from inferred identities.

Where the scope ends

An address relationship does not prove who controls it or unlawful conduct.

Reference context: Service taxonomy

What to receive

Protocol specification, node code and test-network results.

What to clarify first

Which consensus, networking and compatibility assumptions change?

How to check it

Test node disagreement, recovery and version interoperability.

Where the scope ends

A test network is not evidence of production economic security.

Reference context: Service taxonomy

What to receive

Diagnosis, configuration changes and recovery steps.

What to clarify first

Can investigation proceed without sharing private keys or seed phrases?

How to check it

Repeat the failed operation on a safe network and review changes.

Where the scope ends

Support should never require transferring control of personal wallet secrets.

Reference context: Service taxonomy

What to receive

Version-scoped findings, reproduction evidence and remediation review.

What to clarify first

What code commit, threat model and exclusions define the audit?

How to check it

Reproduce findings and verify fixes against the reviewed version.

Where the scope ends

An audit reduces uncertainty; it does not guarantee exploit-free software.

Reference context: Service taxonomy · OWASP Web Security Testing Guide

What to receive

Frontend, contract integration and transaction-state handling.

What to clarify first

How will users understand approvals, fees and failed transactions?

How to check it

Test rejected signatures, wrong networks and pending transactions.

Where the scope ends

A dApp interface does not validate the safety of its contracts.

Reference context: Service taxonomy

What to receive

Metadata structure, test minting flow and technical documentation.

What to clarify first

What rights, if any, accompany the token and underlying media?

How to check it

Verify metadata, ownership transfer behavior and authorized asset use.

Where the scope ends

A token does not automatically transfer copyright or guarantee resale value.

Reference context: Service taxonomy · US Copyright Office: copyright basics

What to receive

Generator code, trait configuration and output manifest.

What to clarify first

How are duplicate combinations and rarity constraints handled?

How to check it

Reproduce a sample run and inspect invalid or repeated combinations.

Where the scope ends

Generating media is distinct from minting tokens or selling a collection.

Reference context: Service taxonomy · US Copyright Office: copyright basics

What to receive

Marketplace code, listing rules and test transaction records.

What to clarify first

Who handles contract review, disputes and prohibited listings?

How to check it

Test listing, cancellation, purchase failure and ownership updates.

Where the scope ends

A marketplace build does not create liquidity or a buyer community.

Reference context: Service taxonomy · US Copyright Office: copyright basics

What to receive

Site pages, wallet integration scope and deployment files.

What to clarify first

Is minting functionality included or only project presentation?

How to check it

Verify displayed contract references and test wallet states safely.

Where the scope ends

A promotional website is different from audited minting infrastructure.

Reference context: Service taxonomy · US Copyright Office: copyright basics

What to receive

Maintenance scope, release notes and device regression results.

What to clarify first

Which OS changes and response windows are covered?

How to check it

Test critical journeys on the agreed device matrix.

Where the scope ends

Maintenance does not automatically include new feature development.

Reference context: Service taxonomy

What to receive

Updated source, test builds and change documentation.

What to clarify first

Which existing integrations and device versions must remain supported?

How to check it

Test modified flows and unchanged adjacent screens.

Where the scope ends

Customization is different from rebuilding the application architecture.

Reference context: Service taxonomy

What to receive

Diagnosis, patch and device-specific verification.

What to clarify first

Which device, OS version and steps reproduce the issue?

How to check it

Repeat the failing sequence and check lifecycle interruptions.

Where the scope ends

A simulator-only fix may not resolve a device-specific defect.

Reference context: Service taxonomy

What to receive

Code assessment, options and estimated work boundaries.

What to clarify first

Will the review inspect dependencies and store requirements?

How to check it

Check recommendations against the actual project and supported devices.

Where the scope ends

Consultation does not include implementing the recommended update.

Reference context: Service taxonomy

What to receive

Listing updates, submission records and release checklist.

What to clarify first

Who owns the developer account and approves published claims?

How to check it

Verify screenshots, version metadata and submission status in your account.

Where the scope ends

Store management cannot guarantee approval or rankings.

Reference context: Service taxonomy · Apple: App Review Guidelines

What to receive

Schematics, component choices and validation plan.

What to clarify first

Which safety, manufacturing and environmental requirements need specialist review?

How to check it

Check interfaces and require measured prototype results where specified.

Where the scope ends

Design files do not certify physical safety or manufacturability.

Reference context: Service taxonomy

What to receive

Control logic, interface documentation and commissioning plan.

What to clarify first

Who approves safety interlocks and on-site testing?

How to check it

Use a controlled test procedure and verify safe failure states.

Where the scope ends

Production machinery changes require qualified supervision beyond software delivery.

Reference context: Service taxonomy

What to receive

Firmware source, hardware interface map and update instructions.

What to clarify first

How are power loss, connectivity failure and credentials handled?

How to check it

Test on the actual board under representative operating conditions.

Where the scope ends

A desktop simulation does not validate physical device behavior.

Reference context: Service taxonomy

What to receive

Schematic, layout, manufacturing outputs and bill of materials.

What to clarify first

Which board stackup, assembly process and design rules apply?

How to check it

Run rule checks and obtain fabricator review before manufacture.

Where the scope ends

A rendered board image is not a verified manufacturing package.

Reference context: Service taxonomy

What to receive

Scope, findings and prioritized remediation evidence.

What to clarify first

Which assets and testing methods are explicitly authorized?

How to check it

Verify findings and confirm changes do not disrupt required services.

Where the scope ends

No engagement should imply unrestricted access or guaranteed security.

Reference context: Service taxonomy · OWASP Web Security Testing Guide

What to receive

Risk discussion, options and action plan.

What to clarify first

Will advice be based on actual configurations and business dependencies?

How to check it

Check that priorities address realistic threats and named owners.

Where the scope ends

Consultation is different from penetration testing or incident response.

Reference context: Service taxonomy · OWASP Web Security Testing Guide

What to receive

Control mapping, gap assessment and evidence checklist.

What to clarify first

Which framework version and organizational boundary apply?

How to check it

Trace controls to operating evidence and identify independent assessment needs.

Where the scope ends

Readiness support is not a regulator's or auditor's approval.

Reference context: Service taxonomy · OWASP Web Security Testing Guide

What to receive

Test plan, reproducible findings and retest results.

What to clarify first

What targets, timing and disruptive techniques are permitted?

How to check it

Review evidence, severity rationale and remediation verification.

Where the scope ends

Testing a bounded scope cannot prove the absence of vulnerabilities.

Reference context: Service taxonomy · OWASP Web Security Testing Guide

What to receive

Monitoring scope, incident procedures and reporting cadence.

What to clarify first

Who can contain incidents and what coverage hours apply?

How to check it

Exercise escalation paths and inspect resolved and unresolved alerts.

Where the scope ends

Managed security does not transfer all business risk to the provider.

Reference context: Service taxonomy · OWASP Web Security Testing Guide

What to receive

Integration scope, source or configuration and setup guide.

What to clarify first

Which streaming software and platform APIs are involved?

How to check it

Run a rehearsal with realistic scenes and connection interruptions.

Where the scope ends

Technical development differs from creating stream artwork or growing an audience.

Reference context: Service taxonomy

What to receive

Addon files, configuration and compatibility notes.

What to clarify first

Which events, permissions and software versions must be supported?

How to check it

Trigger sample events and verify that failed integrations degrade safely.

Where the scope ends

An addon is not a complete broadcast production service.

Reference context: Service taxonomy

What to receive

Scene setup, audio routing and operating checklist.

What to clarify first

Which capture devices, platforms and bandwidth constraints apply?

How to check it

Record a rehearsal and check audio synchronization and recovery.

Where the scope ends

Setup does not guarantee performance on every network connection.

Reference context: Service taxonomy

What to receive

Lesson plan, reviewed exercises and practice guidance.

What to clarify first

Will sessions teach debugging and reasoning rather than deliver assignments?

How to check it

Solve a new exercise independently and explain the solution.

Where the scope ends

Tutoring should not substitute for your own assessed academic work.

Reference context: Service taxonomy

What to receive

Device app, companion integration and test documentation.

What to clarify first

Which sensors, battery constraints and device versions are supported?

How to check it

Test real-device input, synchronization and interrupted connectivity.

Where the scope ends

Wearable software does not automatically qualify as a medical device.

Reference context: Service taxonomy

What to receive

Watch interface, data synchronization and device build.

What to clarify first

Which tasks belong on the watch versus the companion phone?

How to check it

Test readability, input and battery-sensitive background behavior.

Where the scope ends

A reduced phone screen is not necessarily a usable watch interface.

Reference context: Service taxonomy

What to receive

Interactive scene, tracking setup and performance results.

What to clarify first

Which headsets or phones and physical-space constraints apply?

How to check it

Test tracking loss, comfort and performance on target hardware.

Where the scope ends

A desktop 3D scene is different from a device-tested XR experience.

Reference context: Service taxonomy

What to receive

Converted files, conversion method and exception notes.

What to clarify first

Which formatting, metadata or editability must survive?

How to check it

Open samples in the destination software and compare critical content.

Where the scope ends

Changing an extension is not a genuine format conversion.

Reference context: Service taxonomy

What to receive

Form fields, validation rules and completed sample.

What to clarify first

Which reader applications and accessibility needs must be supported?

How to check it

Fill fields by keyboard, save and reopen the completed file.

Where the scope ends

A fillable PDF is different from an online data-collection system.

Reference context: Service taxonomy

What to receive

Editable output, reconstructed layout and uncertainty flags.

What to clarify first

How will OCR errors, tables and embedded graphics be handled?

How to check it

Compare difficult pages against originals and edit representative sections.

Where the scope ends

OCR output needs review; editability does not guarantee accuracy.

Reference context: Service taxonomy

What to receive

Target-format files and compatibility notes.

What to clarify first

Which features cannot be represented in the destination format?

How to check it

Open the output and inspect known high-risk elements.

Where the scope ends

Some conversions necessarily lose formulas, layers or interactive behavior.

Reference context: Service taxonomy

What to receive

Recruitment criteria, session evidence and usability findings.

What to clarify first

Do participants match the intended audience and consent to recording?

How to check it

Trace findings to observed behavior and retain contradictory evidence.

Where the scope ends

A few sessions reveal issues but do not establish population-wide rates.

Reference context: Service taxonomy

What to receive

Review scope, findings and prioritized issue list.

What to clarify first

Is the work focused on design, source code or runtime behavior?

How to check it

Require reproducible evidence for each actionable finding.

Where the scope ends

A broad QA label does not define adequate test coverage.

Reference context: Service taxonomy

What to receive

Annotated screens, usability issues and recommended changes.

What to clarify first

Which user tasks and accessibility criteria guide the review?

How to check it

Connect each issue to a task or documented criterion.

Where the scope ends

Aesthetic preferences should be distinguished from usability defects.

Reference context: Service taxonomy

What to receive

Version-scoped comments, risk findings and suggested remedies.

What to clarify first

Which languages, modules and security concerns are within scope?

How to check it

Trace findings to code locations and verify proposed fixes.

Where the scope ends

Code review alone does not demonstrate runtime correctness.

Reference context: Service taxonomy

What to receive

Test plan, execution evidence and reproducible defect reports.

What to clarify first

Which environments, edge cases and integrations are covered?

How to check it

Reproduce sampled defects and check unresolved test gaps.

Where the scope ends

A passing test suite only covers the scenarios it actually exercises.

Reference context: Service taxonomy

What to receive

Technical brief, deliverable format and completion criteria.

What to clarify first

What environment and observable behavior define success?

How to check it

Run the agreed acceptance scenario in the target environment.

Where the scope ends

An unspecified technical category should not imply unlimited engineering work.

Reference context: Service taxonomy

What to receive

Bot source, simulation results and risk-limit configuration.

What to clarify first

How are credentials, position limits and failed orders handled?

How to check it

Test with simulated funds, including outages and duplicate signals.

Where the scope ends

Backtests do not predict profits; software is not personalized investment advice.

Reference context: Service taxonomy

What to receive

Data inventory, access roles and retention responsibilities.

What to clarify first

Which datasets, jurisdictions and approval owners are in scope?

How to check it

Trace a sample dataset from collection through deletion responsibilities.

Where the scope ends

A governance document alone does not establish legal compliance.

Reference context: Service taxonomy

What to receive

Extraction script/data, field definitions and collection log.

What to clarify first

What permissions, source terms and rate limits apply?

How to check it

Sample-check records against sources and test missing-page handling.

Where the scope ends

Public visibility does not automatically authorize all collection or reuse.

Reference context: Service taxonomy

What to receive

Annotation guidelines, labeled files and quality samples.

What to clarify first

How are ambiguous cases and reviewer disagreements resolved?

How to check it

Review a blind sample against the agreed labeling rules.

Where the scope ends

More labels do not compensate for unclear definitions.

Reference context: Service taxonomy

What to receive

Mapped fields, formatted dataset and conversion notes.

What to clarify first

How should dates, encodings and missing values be represented?

How to check it

Import a sample and check identifiers and numeric precision.

Where the scope ends

Formatting changes structure, not the truth of source values.

Reference context: Service taxonomy

What to receive

Schema/operations plan and agreed implementation outputs.

What to clarify first

Which engine, workload and availability constraints apply?

How to check it

Test representative queries and backup/recovery steps.

Where the scope ends

A database design is separate from ongoing administration.

Reference context: Service taxonomy · PostgreSQL: backup and restore

What to receive

Findings, options and implementation priorities.

What to clarify first

Will the consultant inspect workload evidence and schema details?

How to check it

Check that recommendations address measured bottlenecks.

Where the scope ends

Consultation does not include production changes unless agreed.

Reference context: Service taxonomy · PostgreSQL: backup and restore

What to receive

Maintenance schedule, monitoring and incident procedures.

What to clarify first

Who authorizes changes and responds outside working hours?

How to check it

Review backup evidence and a controlled restore demonstration.

Where the scope ends

Administration responsibility must define availability and escalation limits.

Reference context: Service taxonomy · PostgreSQL: backup and restore

What to receive

Query files, parameter notes and expected sample results.

What to clarify first

What result semantics and performance constraints apply?

How to check it

Compare results with a manually checked sample.

Where the scope ends

A fast query can still answer the wrong business question.

Reference context: Service taxonomy · PostgreSQL: backup and restore

What to receive

Design changes, execution evidence and rollback notes.

What to clarify first

Which baseline workload and consistency rules must be preserved?

How to check it

Compare before/after behavior on representative data.

Where the scope ends

Optimization should not silently change query meaning.

Reference context: Service taxonomy · PostgreSQL: backup and restore

What to receive

Schema migrations, constraints and access configuration.

What to clarify first

How are permissions and invalid records handled?

How to check it

Test inserts, updates and constraint failures.

Where the scope ends

Database implementation does not automatically include the application interface.

Reference context: Service taxonomy · PostgreSQL: backup and restore

What to receive

Migration plan, reconciliation and recovery procedure.

What to clarify first

What downtime, compatibility and rollback window are acceptable?

How to check it

Compare row counts, sampled records and workload behavior.

Where the scope ends

Copying files alone may not produce a consistent migration.

Reference context: Service taxonomy · PostgreSQL: backup and restore

What to receive

Cleaned data, transformation rules and exceptions log.

What to clarify first

Who decides how duplicates and missing values should be treated?

How to check it

Trace changed records back to rules and preserve the original.

Where the scope ends

Cleaning should not invent unknown facts.

Reference context: Service taxonomy

What to receive

Enriched records, source mapping and confidence notes.

What to clarify first

Which identifiers and source licenses support matching?

How to check it

Sample-check matches and inspect ambiguous identities.

Where the scope ends

A possible match should not be represented as verified identity.

Reference context: Service taxonomy

What to receive

Processing steps, output data and validation report.

What to clarify first

How should invalid inputs and repeated runs be handled?

How to check it

Re-run a sample and compare expected totals.

Where the scope ends

Processing is distinct from interpreting business meaning.

Reference context: Service taxonomy

What to receive

Input/output specification and tool options.

What to clarify first

What volume, update frequency and error tolerance matter?

How to check it

Check that proposed steps cover exceptions and ownership.

Where the scope ends

A process recommendation is not an operating pipeline.

Reference context: Service taxonomy

What to receive

Workflow, scheduling instructions and failure handling.

What to clarify first

How are retries prevented from duplicating output?

How to check it

Run the workflow twice and test a malformed input.

Where the scope ends

Automation still needs monitoring and accountable owners.

Reference context: Service taxonomy

What to receive

Formulas/macros, input rules and usage notes.

What to clarify first

Which spreadsheet version and macro permissions apply?

How to check it

Test edge cases and compare results with known calculations.

Where the scope ends

A macro should not silently alter unrelated workbook data.

Reference context: Service taxonomy

What to receive

Pipeline code, schemas and operational documentation.

What to clarify first

What freshness, quality and recovery requirements apply?

How to check it

Test delayed, duplicate and missing source records.

Where the scope ends

A working demonstration is not a monitored production pipeline.

Reference context: Service taxonomy

What to receive

Source mappings, modeled tables and loading procedures.

What to clarify first

Which business definitions and history rules govern the model?

How to check it

Reconcile warehouse measures with authoritative source totals.

Where the scope ends

A warehouse should not conceal conflicting source definitions.

Reference context: Service taxonomy

What to receive

Architecture options, cost assumptions and delivery priorities.

What to clarify first

Which constraints require proof through a prototype?

How to check it

Check that recommendations cover operations and failure recovery.

Where the scope ends

Consulting diagrams do not implement infrastructure.

Reference context: Service taxonomy

What to receive

ETL code, mappings and reconciliation checks.

What to clarify first

How will schema changes and partial failures be handled?

How to check it

Interrupt a test run and verify safe recovery.

Where the scope ends

An initial load differs from a maintained recurring integration.

Reference context: Service taxonomy

What to receive

Analysis, reproducible steps and limitations.

What to clarify first

What decision will the analysis inform and how are metrics defined?

How to check it

Reproduce key figures and inspect excluded records.

Where the scope ends

Association in data does not establish causation.

Reference context: Service taxonomy

What to receive

Metric definitions, reports and source mapping.

What to clarify first

Who approves the business meaning of each KPI?

How to check it

Reconcile dashboard totals with source transactions.

Where the scope ends

A dashboard tool cannot resolve undefined business metrics.

Reference context: Service taxonomy

What to receive

Question framing, data assessment and method options.

What to clarify first

Is available data sufficient for the proposed conclusion?

How to check it

Check assumptions and identify what cannot be inferred.

Where the scope ends

Consultation is not a completed analysis.

Reference context: Service taxonomy

What to receive

Metric definitions, bottleneck analysis and scenarios.

What to clarify first

Which lead-time and inventory events are reliably recorded?

How to check it

Trace findings to operational records and test scenario assumptions.

Where the scope ends

Optimization proposals need operational validation before rollout.

Reference context: Service taxonomy

What to receive

Reconciled metrics, assumptions and sensitivity views.

What to clarify first

Who verifies accounting definitions and source quality?

How to check it

Trace outputs to approved records and period boundaries.

Where the scope ends

Analysis is not investment advice or an audit opinion.

Reference context: Service taxonomy

What to receive

Method rationale, code/results and uncertainty notes.

What to clarify first

What sampling limitations and model assumptions apply?

How to check it

Inspect diagnostics and reproduce a representative result.

Where the scope ends

Statistical significance does not establish practical importance or causation.

Reference context: Service taxonomy

What to receive

Event definitions, funnels/cohorts and analysis notes.

What to clarify first

Are user identity and event collection sufficiently reliable?

How to check it

Check funnel counts against sampled event histories.

Where the scope ends

Missing instrumentation can distort apparent user behavior.

Reference context: Service taxonomy

What to receive

Channel metrics, attribution caveats and source reconciliation.

What to clarify first

Which conversions and reporting windows are being compared?

How to check it

Reconcile spend and conversions across source systems.

Where the scope ends

Reported attribution is not proof that a channel caused a sale.

Reference context: Service taxonomy

What to receive

Charts/dashboard designs and underlying data mapping.

What to clarify first

What question should each visual answer?

How to check it

Check scales, labels and consistency with source values.

Where the scope ends

Visual polish cannot repair unreliable data.

Reference context: Service taxonomy

What to receive

Visual options, audience rationale and annotated examples.

What to clarify first

Which decisions and accessibility needs guide presentation?

How to check it

Check whether proposed visuals expose relevant comparisons.

Where the scope ends

Advice is separate from building the final dashboard.

Reference context: Service taxonomy

What to receive

Report template, source logic and refresh instructions.

What to clarify first

How are period cutoffs and commentary approved?

How to check it

Reproduce one reporting period from the documented inputs.

Where the scope ends

A one-off report differs from an automated reporting service.

Reference context: Service taxonomy

What to receive

Map layers, coordinate-system notes and data sources.

What to clarify first

What projection, accuracy and license constraints apply?

How to check it

Check known reference locations and layer alignment.

Where the scope ends

A thematic map is not a certified survey.

Reference context: Service taxonomy

What to receive

Dashboard, filter logic and refresh/owner instructions.

What to clarify first

Who owns credentials and ongoing data connections?

How to check it

Test filters, empty results and totals against known cases.

Where the scope ends

A dashboard is not automatically a real-time monitoring system.

Reference context: Service taxonomy

What to receive

Editable charts, labels and source notes.

What to clarify first

Which comparisons and output sizes matter?

How to check it

Check axes, units and proportional representation.

Where the scope ends

Chart design should not exaggerate differences through misleading scales.

Reference context: Service taxonomy

What to receive

Baseline, evaluation design, code and limitations.

What to clarify first

What data and test set will demonstrate useful performance?

How to check it

Review held-out results and compare with a simple baseline.

Where the scope ends

A model demonstration is not proof of production reliability.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Training pipeline, evaluation and inference example.

What to clarify first

How are leakage, imbalance and deployment conditions addressed?

How to check it

Test on unseen representative data.

Where the scope ends

High training accuracy does not establish generalization.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Training configuration, checkpoints and evaluation notes.

What to clarify first

What compute budget and simpler baseline are available?

How to check it

Compare performance and resource cost under the same evaluation.

Where the scope ends

Model complexity alone is not evidence of better results.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Labeled samples, model outputs and error examples.

What to clarify first

Which lighting, viewpoint and privacy constraints apply?

How to check it

Evaluate on varied scenes and inspect false detections.

Where the scope ends

A curated demo may not represent real-world image conditions.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Training data specification, adapted model and evaluation.

What to clarify first

Do model terms permit adaptation and intended deployment?

How to check it

Compare baseline and adapted outputs on held-out examples.

Where the scope ends

Fine-tuning is distinct from prompt adjustment or retrieval setup.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Text pipeline, label definitions and evaluated outputs.

What to clarify first

Which languages, domains and sensitive-data limits apply?

How to check it

Inspect ambiguous examples and domain-specific errors.

Where the scope ends

Generic language performance does not establish specialist accuracy.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Model/workflow, evaluation prompts and output controls.

What to clarify first

How are unsupported outputs and prohibited inputs handled?

How to check it

Test varied prompts and inspect failure cases.

Where the scope ends

Generated output still requires appropriate human review.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Time-aware model, forecasts and uncertainty notes.

What to clarify first

How are seasonality, missing periods and future leakage handled?

How to check it

Use chronological evaluation rather than random future mixing.

Where the scope ends

Historical fit does not guarantee future forecasting accuracy.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Feasibility review, data gaps and evaluation plan.

What to clarify first

What baseline would justify further model development?

How to check it

Check that success criteria are measurable before implementation.

Where the scope ends

A feasibility assessment is not a delivered production model.

Reference context: Service taxonomy · scikit-learn: common pitfalls

What to receive

Completed records and exception/correction log.

What to clarify first

Which fields need double-checking and how are ambiguities escalated?

How to check it

Sample-check source-to-entry accuracy.

Where the scope ends

Data entry does not validate the truth of the original source.

Reference context: Service taxonomy

What to receive

Structured findings with source links and dates.

What to clarify first

What qualifies as acceptable evidence for each field?

How to check it

Open sampled links and verify entity matches.

Where the scope ends

Research should not collect invasive personal information.

Reference context: Service taxonomy

What to receive

Transferred records and completion checklist.

What to clarify first

How should formatting, duplicates and missing fields be treated?

How to check it

Compare sampled records character-for-character.

Where the scope ends

Mechanical transfer is different from cleaning or interpreting data.

Reference context: Service taxonomy

What to receive

Typed files and marked illegible passages.

What to clarify first

Which formatting and verification level are required?

How to check it

Compare difficult names and numbers with the originals.

Where the scope ends

Unclear text should be flagged rather than guessed.

Reference context: Service taxonomy

What to receive

Input/output example, quality rules and exception handling.

What to clarify first

What exact transformation or decision support is needed?

How to check it

Approve a small representative sample before scaling.

Where the scope ends

Do not treat unspecified data work as automatic analytical expertise.

Reference context: Service taxonomy