Professional Experience

TokoFood Integration

Retrospective reconstruction based on memory. No original company artifacts were used.

Case Brief

Initiative
Food delivery integration into the Tokopedia app, following the GoJek–Tokopedia merger.
My Role
Test Engineer: Tokopedia / GoTo ecosystem, 2021-2022
Scope
Cross-functional · Two organizational structures · Multiple backend systems · Separate release processes
Focus Areas
Release readiness · Risk tracking · Stakeholder communication · Cross-team coordination
Outcome
Launched on schedule · No critical post-launch incidents

At Tokopedia, test engineers participated in cross-functional planning from the beginning of an initiative (not only at validation). In practice, this role carried real coordination responsibility. I contributed to and influenced decisions across this project; I did not own them. This page documents the coordination work behind the launch.

Artifact · Retrospective Reconstruction

Launch Readiness Risks

A sample of the launch risks I tracked and helped mitigate while supporting the TokoFood integration. Reconstructed from memory (original tracking documents were not retained.

  • QA Capacity Insufficient for Integration Scope
    HighResolved
    Identified
    Testing scope expanded beyond available QA bandwidth.
    Mitigation
    Escalated capacity concerns and supported hiring and onboarding of four additional QA engineers.
    Resolution
    Expanded validation coverage without delaying launch readiness.
  • Different Release Processes Across Organizations
    MediumResolved
    Identified
    Teams operated with different deployment practices, approval flows, and readiness criteria.
    Mitigation
    Tracked progress across organizations and surfaced coordination gaps early.
    Resolution
    Launch milestones remained aligned despite differing processes.
  • Critical Defect Backlog Before Launch
    HighResolved
    Identified
    Launch readiness depended on resolving high-priority defects across multiple systems.
    Mitigation
    Coordinated triage, ownership tracking, prioritization, and follow-ups.
    Resolution
    Critical launch blockers were addressed before release.
  • Production Validation With Limited Remediation Time
    MediumResolved
    Identified
    Some integration behaviors could only be validated close to launch.
    Mitigation
    Organized production dry runs and tracked findings through resolution.
    Resolution
    Reduced uncertainty before go-live and avoided major launch issues.
  • Bug Ownership Ambiguity Across Teams
    HighResolved
    Identified
    Integration defects often crossed organizational boundaries, making ownership unclear.
    Mitigation
    Facilitated triage discussions, tracked accountability, and escalated stalled issues.
    Resolution
    Kept issue resolution moving and reduced ownership-related delays.

Artifact · Retrospective Reconstruction

Launch Readiness Bug Review

Retrospective reconstruction based on memory. This reflects the types of issues tracked during launch preparation rather than the original working document. Bug IDs, dates, and ETAs are not reproduced.

StageIssueOwner
ATCAdd-on selection used radio buttons instead of checkboxes. Users could only select one add-on when multiple selections should have been allowed.Tokopedia FE
ATCProduct images displayed with incorrect aspect ratio. Images appeared stretched.Tokopedia FE
ATCProduct images failed to load.

Root cause involved a connectivity gap between both backend systems. Action items assigned to both teams.

Shared (Tokopedia BE + GoJek BE)
ATCProducts could not be added to cart.

An unrelated GoJek backend deployment had overwritten the required behavior. Highlighted differences in deployment practices between the two organizations.

GoJek BE
CheckoutInvoice generation failed after successful order creation.Tokopedia BE
CheckoutOrder status skipped an intermediate state. Orders were interpreted as fraudulent and automatically cancelled.Tokopedia BE
CheckoutDriver allocation never triggered after order creation. Orders remained unassigned.GoJek BE
Production Dry RunEligible Plus merchants were not appearing. Filtering logic was incorrectly excluding valid merchants.

Discovered during production dry run, not internal testing. The test used production merchants, which surfaced a filtering rule that had not been caught in staging.

GoJek BE

Artifact · Retrospective Reconstruction

Integration Ownership Map

Retrospective reconstruction based on memory. Shows ownership boundaries and handoff points, not a complete technical architecture.

TokopediaGoJekApp / FrontendRenders PDP, cart UICart + PaymentAdd-to-cart, payment processingOrder CreationCreates order, structures payloadInvoice GenerationTokopedia-owned, post order creationOrder Status APIExposes endpoint for GoJek callbacksMerchant + Product DataServed directly to Tokopedia FEOrder FulfillmentReceives order struct from TokopediaDriver AllocationAsync, triggered after order acceptedStatus UpdatesPushes transitions to Tokopedia APIdirect fetchorder struct (sync)status push (async)Image load failure (shared BE issue)ATC regression (unrelated GoJek deployment)Invoice generation failureDriver allocation failure
Integration boundary crossingDirect FE call to GoJekAsync callbackLaunch issue location

Coordination Challenges

The hardest problems were not technical. When a defect crossed both organizations, who owned resolution was rarely obvious. The work was less about finding answers than making the cost of not finding them visible.

Reporting lines created a secondary complication. Teams working on the same integration reported into different organizations, which meant there was no single decision-maker who could resolve cross-team disagreements unilaterally. Escalations needed to be constructed carefully: presenting a clear picture of the situation, the options, and the tradeoffs, rather than simply surfacing a problem and waiting for a directive. Escalating well is its own skill.

One dynamic I hadn't fully anticipated: different functions needed to hear different things. Engineers needed precise defect descriptions and reproduction steps. Senior stakeholders needed risk assessments and confidence signals. PMs needed clarity on what was blocking their milestone. Writing the same status update for all audiences (which is what happens when you rely on a single shared tracker) serves none of them well.

Communicating upward required its own adjustment. As an associate-level contributor making regular direct contact with VP-level stakeholders, the most important thing I learned was that at that level, leaders are not looking for exhaustive detail. They are looking for three things: what is the situation, what is at risk, and what needs their decision or attention. Everything else is noise. Structuring communication that way (and resisting the instinct to over-explain) made those interactions substantially more effective.

The broader pattern: in complex cross-organizational initiatives, the coordination work is often harder than the technical work. Technical problems have a ground truth: you can run a test and get an answer. People problems are ambiguous, involve competing interests, and rarely have clean resolutions. The most useful thing to develop is the ability to hold that ambiguity without either forcing premature resolution or letting it drift.

Technical Landscape

The two organizations had evolved independently, which meant they had also evolved independently in how they thought about the same concepts. "Order" meant different things on each side of the integration. "Logistics" referred to different operational realities. These weren't naming conventions that could be resolved with a glossary. They reflected genuinely different domain models: different assumptions about how food delivery and marketplace commerce worked, encoded into years of independent development.

Before any defect could be triaged, before any ownership question could be resolved, the teams involved had to agree on what they were talking about. The work of establishing shared language was not a preliminary step that preceded the real work. It was the real work: or at least as important as it.

The clearest lesson from working across this boundary: in a cross-organizational integration, organizational and conceptual problems tend to arrive first in technical costume. Debugging the technical symptom without addressing the underlying model mismatch only moves the problem downstream.

Outcome

The integration launched on schedule with no critical post-launch incidents. For a project of this complexity, that result was not guaranteed. It required sustained coordination across teams that had no prior working relationship and no shared process.

Rollout was intentionally gradual: Jakarta first, then expansion to major cities, then nationwide. The gateway scope held through each phase. No substantial feature iteration was required before expansion, which suggests the decision to constrain initial scope rather than attempt full feature parity was directionally correct. The order flow functioned as intended after launch. Users could discover and place food orders through the Tokopedia app, and no critical failures surfaced during rollout that would have required pulling back the feature or halting expansion.

After Launch

I don't have post-launch metrics I can cite from this project. My role ended at launch, and I didn't have visibility into the product analytics that followed.

If I had been defining success criteria, I would have tracked three things: total orders placed through the integrated experience, as the primary adoption signal; order completion rate, as the clearest proxy for reliability and user trust; and complaint ticket volume related to the food ordering flow, as an early warning signal for experience failures the team hadn't anticipated. Together, these answer the question that actually matters: are users successfully ordering food through our app, and are they running into problems when they do? The first two measure whether the integration worked. The third measures how well it worked at the edges.

The absence of metrics here is a real limitation of this case study, and I'd rather acknowledge it directly than work around it. What I can say is that the gradual rollout proceeded without reversal, and the initial scope proved sufficient to support nationwide expansion. For a first integration across two post-merger organizations, that is a meaningful signal: even without numbers attached to it.

Retrospective

What I Would Do Differently Today

Written from the perspective of someone who has had time to sit with what worked, what didn't, and what the role was actually asking for (whether or not that was visible at the time).

  1. Introduce a dependency tracker before the first sprint, not after the first blocker.

    The dependency map I built came too late. It emerged as a response to blockers rather than as a tool to prevent them. A structured tracker, built and shared in the first week of coordination, would have surfaced several integration risks earlier and given teams more time to address them before they became critical-path problems. Starting reactive is common; staying reactive is avoidable.

  2. Establish a formal risk register at project kickoff, not mid-flight.

    Risk tracking happened informally for too long. Risks were discussed in meetings and captured in scattered notes, but not systematically classified, owned, or tracked to resolution. A structured register (with severity, owner, and resolution criteria defined from the start) would have made the risk landscape visible to everyone and made escalations evidence-based rather than intuition-based.

  3. Run end-to-end design reviews before implementation begins.

    QA was often working from individual requirement documents rather than a holistic picture of the system being integrated. Bringing QA into design reviews before implementation starts (not after) would have surfaced integration boundary risks earlier and produced better test coverage. It also would have eliminated a class of surprises that consistently surface late in testing: behaviors that are technically by design but break user expectations across the integration.

  4. Overcommunicate with intent, not volume.

    "Overcommunicate" as a principle is incomplete. The important word is intentional. The instinct to assume that critical information has been absorbed because it was posted to a shared tracker is consistently wrong. I would be more deliberate about confirming receipt and understanding, not just delivery. And I would invest earlier in tailoring communication to audience: what engineers need to hear, what senior stakeholders need to hear, and what PMs need to hear about the same situation are almost never the same thing.

  5. Treat ownership alignment as a prerequisite, not a side task.

    Before any technical coordination, the question of who owns what (and who resolves disputes when ownership is ambiguous) needs to be explicitly agreed upon. Ownership gaps discovered mid-integration are significantly more expensive than ownership agreements established at the start. In cross-organizational initiatives, the absence of this clarity is often the root cause of delays that look like technical problems on the surface.

  6. Audit meeting load deliberately, not reactively.

    Meeting proliferation is a coordination tax. Syncs that were useful at peak uncertainty often stayed on the calendar long after their purpose had been served. A regular explicit audit (which meetings are still generating value, which have become rituals) would have freed up capacity for the work that actually required focused attention. The cost of unnecessary recurring meetings compounds over a long project.

Want to discuss this further?

I'm happy to walk through the work in more detail.