Choosing an ecommerce application development company means trusting its integrations with revenue, inventory and customer data. A polished storefront cannot prove that trust is deserved. The stronger test is whether the team can show what happens when a payment times out, an inventory update arrives twice or a customer requests someone else’s order.
Before signing, ask for evidence you can inspect and tests you can reproduce. This guide turns API due diligence into a practical review of contracts, security, checkout behavior, operational ownership and exit readiness.
Begin with a traceable integration map
Ask the proposed technical lead to map one complete purchase journey, from product discovery through payment, fulfillment and refund. The diagram should name each system, identify its owner and show where data crosses organizational boundaries.
For every connection, establish which system is authoritative. A storefront might display cached stock while an order management system controls reservations. Without that distinction, “real-time inventory” is an ambiguous promise rather than an acceptance criterion.
Request a small evidence pack before the technical review:
- An integration map covering storefront, commerce platform, payments, inventory and fulfillment.
- API specifications with representative requests, responses and errors.
- A sandbox using synthetic customer and order data.
- Sanitized operational evidence from comparable work, where client permissions allow.
- A responsibility matrix covering the agency, retailer and third-party providers.
These artifacts complement the broader questions to ask an ecommerce agency before signing. They reveal whether the proposed architecture has clear boundaries and accountable owners.
Inspect the contracts an ecommerce application development company will deliver
An API contract describes how systems communicate. It should be precise enough for another developer to implement a client without relying on undocumented conversations.
For HTTP APIs, request a machine-readable specification where appropriate. The OpenAPI Specification provides a standard format for describing operations, parameters, schemas and responses. GraphQL implementations need equivalent clarity through their schema, authorization rules and operational limits.
Inspect details that routinely create retail defects:
- Money and currency: Amounts must have explicit units, currency codes and rounding rules. Do not assume every currency uses two decimal places.
- Inventory states: Distinguish available, reserved and sellable quantities, including when each value becomes stale.
- Pagination and filtering: Confirm limits, stable ordering and how clients retrieve large catalogs without missing records.
- Errors and changes: Require documented error codes, compatibility rules and a deprecation process for breaking changes.
Ask the team to validate a real response against its published schema. Then change a required field in the sandbox and inspect whether automated checks catch the incompatibility.
Documentation generated from code is useful, but it does not establish that the business meaning is correct. Someone must still explain whether “order created” means a draft exists, payment succeeded or fulfillment can begin.
Run a sandbox test through checkout and returns
Ask the ecommerce application development company to demonstrate a complete transaction using test credentials. Include product variants, a promotion, shipping, tax, payment authorization and a partial refund. Select scenarios that match your business rather than accepting a generic demo store.
The critical test is duplicate submission. Send the same order or payment request twice using the agreed idempotency mechanism. The intended outcome is one business operation, not two charges or duplicate orders. Confirm the scope of the key, its retention period and the behavior when the same key accompanies a different payload.
Do not accept “the payment provider handles it” as the complete answer. Provider protections do not automatically prevent duplicate order creation, repeated inventory reservations or duplicate fulfillment messages elsewhere in the workflow.
Also test two customers attempting to buy the last available unit. The team should explain where stock is reserved, when the reservation expires and how failed payments release it. Some businesses permit backorders, but that must be an explicit policy.
Keep a short record for each test: preconditions, request, expected outcome, actual outcome and affected system identifiers. A screen recording helps explain the journey, while request traces and resulting records establish what the integration actually did.
Prove authorization and protect customer data
Security review should test business boundaries, not just confirm that HTTPS is enabled. Ask the ecommerce application development company to demonstrate that one customer cannot retrieve another customer’s order by changing an identifier. For multi-brand or marketplace systems, repeat the exercise across tenant boundaries.
The OWASP API Security project identifies API-specific risks, including broken object-level authorization and unrestricted resource consumption. Use that guidance to structure testing, not as a badge that substitutes for evidence.
A useful review covers customer sessions, administrative access and service-to-service credentials separately. Check where secrets are stored, how credentials are rotated and whether production permissions are narrower than development permissions. A private service credential must not be embedded in browser code or a mobile app bundle.
Inspect logs as well. Authorization headers, payment details and unnecessary personal data should not appear in routine diagnostics. Ask for retention rules and an explanation of how support staff receive appropriately restricted access.
If AI tools can query orders or initiate returns, verify authorization at the underlying API action. A model’s interpretation of a conversation is not an access-control mechanism. Retrieved product content and customer messages must not be able to grant privileges or bypass transaction policies.
Break the connection and inspect recovery
A reliable integration has a defined response to partial failure. Ask the ecommerce application development company to interrupt a downstream connection after a request has been sent but before its result reaches the caller.
For payments, this creates an uncertain outcome: the charge may have succeeded even though the storefront received a timeout. The implementation should reconcile against provider records using stable identifiers rather than blindly retrying a potentially successful operation.
Webhooks need their own demonstration. Replay an event, deliver events out of order and temporarily make the receiving service unavailable. Ask how the system authenticates messages using the provider’s supported mechanism, prevents duplicate processing and recovers failed deliveries.
Where processing continues asynchronously, acknowledge receipt only after the event has been durably accepted. Otherwise, a successful response can hide an event lost before any business action occurs.
The review should also expose the recovery workflow. Failed jobs need an identifiable owner, useful diagnostic context and a controlled replay process. Replaying an event must not create another shipment or refund.
Finally, ask for reconciliation beyond webhook delivery. A periodic comparison between orders, payments and fulfillment records can detect gaps that retries alone miss. Agree which discrepancies trigger alerts and who resolves them, especially during promotions and high-volume trading periods.
Measure performance against retail traffic
An ecommerce application development company should define API performance against an agreed workload, not show a fast response from an empty sandbox. Establish the catalog size, request mix, concurrency, geographic assumptions and third-party limits before interpreting results.
Request latency percentiles such as p95 and p99 alongside error rates and throughput. An average can conceal the slow checkout requests that customers actually notice. Separate measurements for product browsing, cart updates and payment-related operations because their dependencies differ.
For example, a useful acceptance statement specifies the operation, workload, percentile, measurement window and permitted error rate. The numerical thresholds should come from your customer experience goals and dependency constraints, not a universal benchmark.
Inspect caching rules carefully. Product descriptions may tolerate caching that personalized pricing, cart contents or availability cannot. Ask how cache keys separate users, currencies and customer groups, and how changes invalidate stale responses.
Rate limits also affect architecture and cost. Have the team explain its request budget during catalog synchronization and peak checkout traffic. Excessive fan-out, unbounded GraphQL queries or repeated per-item requests can exhaust provider quotas even when individual endpoints appear fast.
Record the test configuration so another team can reproduce it after a release.
Check accessibility beyond the API response
When an ecommerce application development company proposes conversational or voice commerce, test whether the underlying APIs support equivalent text and touch journeys. A successful voice demonstration does not establish that every customer can complete the purchase.
Providers such as Bridges Speech Center offer speech and language therapy for children and adults with varied communication needs. That diversity is a practical reminder not to make spoken interaction the only route to shopping or support.
At the API boundary, require structured validation errors that the interface can associate with the relevant field. Raw provider messages or a single generic failure string often leave the interface unable to explain a problem clearly.
Check that cart state survives a handoff from an assistant to a conventional checkout or support agent. Customers should be able to review the selected product, quantity, delivery details and total before authorizing a consequential action. Accessibility testing still requires interface-level evaluation; an API review supports it but cannot replace it.

Verify the team’s claims with references
Ask an ecommerce application development company to connect its portfolio claims to specific integration responsibilities. A live storefront proves that something was delivered, but not who designed the APIs, maintained the payment integration or resolved production incidents.
Choose references with comparable operational complexity. Similar order volume is useful, but shared challenges such as multiple warehouses, subscription billing or marketplace sellers may be more revealing.
During reference calls, ask what happened after launch. Which integration failed first? How did the team detect the problem? Could the client access logs and repositories without agency intervention? What happened when a platform provider changed an API?
Request a walkthrough by the people proposed for your project. A senior salesperson’s explanation cannot establish the delivery team’s competence. Have the technical lead trace one request across systems and explain an actual design trade-off, using sanitized materials where necessary.
Respect confidentiality. Another client’s production credentials or identifiable customer records are not appropriate proof. Redacted incident reports, authorized demonstrations and reference conversations can establish experience without exposing someone else’s data.
Put operational ownership and exit terms in writing
The ecommerce application development company’s proposal should explain who owns each integration after launch. “Support included” is too vague when a payment provider changes its authentication requirements or an inventory job stops overnight.
Separate responsibilities for monitoring, incident triage, application fixes and third-party escalation. Define severity levels, coverage hours, response commitments and escalation contacts. A response commitment is not the same as a restoration commitment.
Price the operating model as well as the build. Request an itemized estimate covering hosting, integration middleware, monitoring, provider usage, routine maintenance and planned API upgrades. For mobile apps, include supported operating-system updates and app-store release work where relevant. Ask how peak traffic and higher event volumes change costs.
Ownership should be explicit. Establish contractual rights to custom code and documentation, subject to clearly identified third-party licenses. The retailer should control appropriate production accounts, with agency access granted through named roles rather than shared credentials.
Exit provisions should cover repository access, deployment instructions, infrastructure configuration, data exports, outstanding incidents and credential rotation. These are part of the broader deliverables an ecommerce software development partner should provide, not optional favors at termination.
Finally, require a handover exercise. Another authorized engineer should be able to deploy a change and investigate a failed integration using the supplied materials.
Use a pass-or-remediate scorecard
Compare each ecommerce application development company against the same evidence requirements. Avoid letting an attractive total score conceal a critical failure, such as cross-customer data access or duplicate charges.
Use three statuses: demonstrated, remediation required and not demonstrated. Record the evidence location, accountable owner and retest date for every unresolved item.
| Review area | Evidence to inspect | Acceptance decision |
|---|---|---|
| API contracts | Specifications, schemas and compatibility checks | Required operations and business meanings are documented |
| Transaction safety | Duplicate requests, stock contention and refund tests | Results match agreed payment and inventory policies |
| Authorization | Cross-account and cross-tenant negative tests | Unauthorized access is blocked consistently |
| Recovery | Timeout, webhook replay and reconciliation results | Failures are detectable and recoverable without duplicate actions |
| Performance | Reproducible load results and provider quota assumptions | Agreed latency, throughput and error targets are met |
| Ownership | Access records, support terms and handover exercise | The retailer can operate and transition the integration |
Security and financial-integrity failures should block acceptance until resolved or formally addressed through an approved scope change. Lower-risk documentation gaps can have dated remediation plans.
Attach the agreed criteria to the statement of work. That turns the review from an informal sales discussion into a delivery obligation with a clear retest process.
Frequently asked questions
Do we need source-code access before choosing a vendor? Not necessarily. Specifications, a controlled sandbox and authorized evidence can support initial selection. Before launch, establish the repository access, licensing rights and deployment materials your agreement requires. Do not request another client’s proprietary code as a reference sample.
Can a nontechnical retailer vet an ecommerce application development company? A retail leader can define business outcomes, verify ownership and check references. Use an internal engineer or independent reviewer for authorization tests, failure injection and architectural assessment. Ask that reviewer to report business consequences alongside technical findings.
Should every integration test happen in production? No. Start with synthetic data and isolated test accounts in a sandbox. Production verification should be separately authorized, narrowly scoped and designed to avoid real customer impact. Some provider behaviors differ between environments, so document any remaining uncertainty.
How much API review belongs in the proposal stage? Require enough evidence to establish competence and expose major risks. A paid discovery engagement can produce deeper specifications and test plans, provided its deliverables, ownership and acceptance criteria are defined before work begins.
Make API evidence part of your next agency conversation
Bring one revenue-critical workflow, one failure scenario and the scorecard to your next review. Ask the proposed delivery team to demonstrate the behavior rather than describe it.
Space Dinosaurs combines retail-focused engineering, UX, analytics and performance optimization. Use these same criteria when discussing your project with us: clear integration boundaries, reproducible tests and explicit operational ownership.

