Part 012 — Vertical Slicing, Workflow, Risk, Integration, Migration, and Rollout

Positioning

Story slicing adalah kemampuan memecah work besar menjadi increment kecil yang:

• end-to-end;
• testable;
• demonstrable;
• mengurangi uncertainty;
• dan tetap memberi value atau learning.

Slicing yang buruk menghasilkan fake progress:

• database selesai;
• backend selesai;
• frontend selesai;
• tetapi tidak ada behavior usable.

Core thesis: slice yang baik memperkecil batch tanpa memutus value stream.

1. Why Slicing Matters

Large work membawa:

• feedback latency;
• integration risk;
• estimation uncertainty;
• WIP;
• dependency;
• dan carry-over.

Semakin besar batch, semakin mahal perubahan.

Conceptual relationship

Batch size ↑
Feedback latency ↑
Integration risk ↑
Forecast error ↑

2. Vertical versus Horizontal Slice

Horizontal slice

Memecah berdasarkan layer:

• database;
• backend;
• frontend;
• QA.

Result:

• banyak component progress;
• no usable capability.

Vertical slice

Memotong seluruh layer untuk satu behavior kecil.

Satu slice menyentuh cukup layer untuk menghasilkan evidence.

3. Thin Slice

Thin slice adalah versi minimal yang tetap:

• coherent;
• usable;
• dan relevant.

Thin bukan incomplete.

Thin slice example

Full scope:

• approval by product category;
• multiple approver levels;
• delegation;
• timeout escalation;
• reporting.

Thin slice:

• one threshold;
• one approver group;
• one tenant;
• audit;
• no delegation.

4. MVP versus Incomplete Feature

MVP menguji value atau learning dengan capability minimum.

Incomplete feature:

• missing critical behavior;
• no integration;
• no safety;
• or no usable workflow.

Test

Can a real actor complete a meaningful behavior?
Can the team observe the result?
Can failure be contained?

Jika tidak, itu mungkin internal milestone, bukan MVP.

5. Slicing by Workflow Step

Contoh Quote lifecycle:

1. Create.
2. Price.
3. Validate.
4. Approve.
5. Submit.
6. Track.

Slice dapat fokus pada satu step dengan end-to-end behavior.

Risk

Jangan membuat step yang tidak dapat digunakan karena dependency berikutnya belum ada.

6. Slicing by Business Rule

Contoh:

• first support one threshold;
• then category-specific threshold;
• then customer override;
• then delegation.

Berguna ketika rule variation besar.

7. Slicing by Actor

Contoh:

• quote creator;
• approver;
• support analyst;
• administrator.

Pastikan cross-actor workflow tetap coherent.

8. Slicing by Data Variation

Contoh:

• one product type;
• one currency;
• one tenant;
• one region;
• one payload shape.

Useful for staged expansion.

Risk:

• first slice terlalu narrow dan menghasilkan architecture dead-end.

9. Slicing by Happy Path and Exceptions

Start dengan happy path hanya jika:

• failure can be safely prevented;
• exception volume low;
• dan rollout controlled.

Do not defer:

• authorization;
• data integrity;
• irreversible failure;
• or essential recovery.

10. Slicing by Risk

Prioritize slice yang menguji biggest uncertainty.

Examples:

• live integration contract;
• migration feasibility;
• performance under load;
• tenant isolation;
• duplicate handling.

Risk-first slice

Biggest risk:
Cheapest realistic evidence:
Smallest end-to-end path:
Containment:
Decision unlocked:

11. Slicing by Integration Boundary

Integration-heavy work should validate real boundary early.

Possible sequence:

1. Contract agreed.
2. Consumer/provider test.
3. One live path.
4. Failure handling.
5. Additional variants.
6. Scale.

Avoid building all internal logic before first integration.

12. Slicing by Data Migration

Migration slice:

1. compatible schema;
2. dual read/write;
3. small backfill;
4. validate;
5. expand;
6. cut over;
7. decommission.

Migration invariant

Every stage should have:

• verification;
• rollback or containment;
• and ownership.

13. Slicing by Rollout

Rollout dimensions:

• internal user;
• tenant;
• customer segment;
• geography;
• traffic percentage;
• configuration.

Feature flags can separate deployment from release.

Rollout slice example

• deploy disabled;
• enable internal tenant;
• inspect metrics;
• enable pilot customer;
• expand.

14. Slicing by Operational Capability

A feature may be sliced through operational maturity.

Example:

1. basic behavior + manual observation;
2. automated metric;
3. alert;
4. self-service recovery;
5. support dashboard.

Be careful: essential safety cannot be deferred.

15. Slicing by Interface

For complex product:

• API first for one consumer;
• then UI;
• then batch import;
• then external integration.

Only valid if first interface creates useful outcome.

16. Slicing by Performance Envelope

Example:

• small quote;
• medium quote;
• large quote;
• high concurrency.

Useful when performance uncertainty high.

But do not promise support outside tested envelope.

17. Slicing by Permission or Role

Start with:

• admin only;
• controlled user group;
• then broader roles.

Useful for risk containment.

18. Slicing by Automation Level

Example:

1. manual approval trigger;
2. automatic routing;
3. escalation;
4. delegation.

Manual first is valid only if it creates useful learning and manageable toil.

19. Spike versus Thin Implementation

Spike:

• answers question;
• may not be production quality.

Thin implementation:

• production-capable limited behavior.

Choose spike when uncertainty prevents responsible implementation.

Choose thin implementation when risk can be learned from real increment.

20. Slicing and Architecture

Architecture must support incremental change.

Warning signs:

• all-or-nothing release;
• coordinated deployment;
• one giant migration;
• no feature flag;
• no compatibility layer;
• shared state with unclear ownership.

Senior engineer should propose seams.

Seams

• interface;
• adapter;
• configuration;
• event version;
• routing;
• tenant flag;
• abstraction boundary.

21. Slicing and Testing

Each slice needs evidence.

Test layers may include:

• unit;
• contract;
• integration;
• end-to-end;
• exploratory;
• production verification.

A slice is not thin if validation remains large batch.

22. Slicing and Observability

Each slice should answer:

• did it run;
• did it succeed;
• did it fail;
• who was affected;
• and can we recover.

Observability enables safe incremental rollout.

23. Slicing and Compatibility

Additive change often supports slicing.

Example:

• new optional field;
• consumer ignores unknown;
• versioned behavior;
• dual support.

Breaking change creates coordinated batch.

24. Story Mapping

Story mapping organizes journey.

Backbone:
Create Quote -> Price -> Approve -> Submit -> Track

Slices:
Release 1: minimal path
Release 2: exceptions
Release 3: advanced roles

Useful to avoid random backlog decomposition.

25. Walking Skeleton

Walking skeleton adalah minimal end-to-end implementation yang proves architecture and flow.

It may include:

• basic UI;
• API;
• persistence;
• deployment;
• monitoring.

Walking skeleton should become production foundation, not throwaway demo.

26. Tracer Bullet

Tracer bullet validates uncertain path end-to-end.

Difference from prototype:

• integrated;
• production-oriented;
• intentionally narrow.

Useful for complex integration.

27. Fake Progress Patterns

Component completion

All layers separately “done”.

Stub dependency forever

Demo succeeds only on mock.

Feature flag without completion plan

Hidden unfinished code accumulates.

Partial migration

Old and new remain indefinitely.

Backend-only value claim

No consumer or operational use.

Story count inflation

Large story split into technical tickets.

28. Slicing Heuristics

Use SPIDR-like lens:

• Spike;
• Paths;
• Interfaces;
• Data;
• Rules.

Add enterprise dimensions:

• Risk;
• Integration;
• Migration;
• Rollout;
• Operations.

Heuristic table

29. Slicing Decision Framework

1. Define desired outcome.
2. Identify biggest uncertainty.
3. Map workflow.
4. Identify irreversible risks.
5. Select minimal actor behavior.
6. Include necessary safety.
7. Define evidence.
8. Define rollout.
9. Verify expandability.

30. Worked Example: Order Retry Capability

Full request

Support can retry failed order submission.

Risks

• duplicate order;
• wrong failure classification;
• unauthorized retry;
• no audit;
• concurrent retry.

Possible slices

Slice 1

• display retry eligibility;
• no execution.

Value:

• support diagnosis.

Slice 2

• retry transient timeout only;
• one order type;
• authorized role;
• idempotency;
• audit.

Slice 3

• additional transient errors;
• more order types.

Slice 4

• automatic retry policy.

This sequence reduces risk while creating value.

31. Worked Example: Quote Migration

Giant story

Migrate all quote data to new model.

Sliced plan

1. Add compatible schema.
2. Read legacy and new.
3. Write new for pilot tenant.
4. Backfill subset.
5. Validate parity.
6. Expand.
7. Cut over.
8. Remove legacy path.

Each stage has:

• evidence;
• owner;
• rollback;
• metric.

32. Anti-Patterns

Slice by team

Backend team, frontend team, QA team.

Slice by activity

Analysis, build, test.

Remove all edge behavior

Creates unsafe increment.

Build foundation first

No product feedback.

Over-slice

Too much coordination and no meaningful value.

Under-slice

Carry-over and late integration.

Temporary path without exit

Debt becomes permanent.

Ignore rollout

Deployment treated as finish.

33. Senior Engineer Operating Model

During refinement

• identify seams;
• propose risk-first slice;
• protect essential quality;
• expose migration and compatibility;
• and avoid giant foundation.

During planning

• sequence slices;
• make dependency explicit;
• ensure first slice can be Done.

During execution

• prevent horizontal handoff;
• integrate early;
• verify evidence;
• and reduce WIP.

During review

• show what is real;
• explain limits;
• capture learning;
• and adapt next slice.

34. Process Smells

• story spans multiple Sprints;
• most work finishes at Sprint end;
• integration always late;
• feature flag count grows;
• migration never decommissioned;
• happy path shipped without safe failure;
• technical subtasks marked done but parent remains;
• and review shows mock-only behavior.

35. Internal Verification Checklist

Slicing practice

• Bagaimana team biasanya split stories?
• Apakah vertical slice dipahami?
• Apa contoh good slice?
• Apa contoh carry-over besar?

Architecture

• Apakah feature flag tersedia?
• Apakah deployment independent?
• Bagaimana contract compatibility dijaga?
• Apakah walking skeleton/tracer bullet digunakan?

Migration

• Apa migration pattern?
• Apakah dual mode diperbolehkan?
• Bagaimana validation dan rollback?
• Siapa owner decommission?

Rollout

• Apakah tenant-based rollout tersedia?
• Apakah canary/pilot digunakan?
• Apa go/no-go criteria?
• Apa observability requirement?

Quality

• Edge case apa tidak boleh ditunda?
• Apa minimum operational readiness?
• Bagaimana test evidence per slice?
• Apa Definition of Done?

36. Practical Exercises

Exercise 1 — Vertical slice

Ambil one epic.

Buat:

• backbone;
• first thin slice;
• next three slices.

Exercise 2 — Risk-first split

Identifikasi biggest uncertainty.

Design slice yang menguji itu.

Exercise 3 — Fake progress audit

Pilih satu feature.

Tandai:

• component completion;
• real integration;
• usable behavior;
• operational evidence.

Exercise 4 — Migration slicing

Buat staged migration dengan:

• validation;
• rollback;
• owner;
• exit criteria.

Exercise 5 — Rollout plan

Definisikan:

• pilot;
• metric;
• alert;
• rollback;
• expansion.

37. Part Completion Checklist

Anda selesai jika mampu:

• membedakan vertical dan horizontal slice;
• menjelaskan thin slice versus incomplete feature;
• membedakan MVP, spike, walking skeleton, dan tracer bullet;
• slice berdasarkan workflow, rule, data, risk, integration, migration, dan rollout;
• melindungi essential quality;
• mendeteksi fake progress;
• dan membantu team menyelesaikan small usable increments.

38. Key Takeaways

1. Slicing memperkecil batch dan mempercepat feedback.
2. Vertical slice mempertahankan value stream.
3. Thin bukan incomplete.
4. Risk-first slicing mengurangi uncertainty lebih awal.
5. Integration harus divalidasi sebelum akhir.
6. Migration dan rollout dapat di-slice.
7. Feature flag membutuhkan completion plan.
8. Essential safety tidak boleh ditunda.
9. Senior engineer mencari seams dan sequencing.
10. Slicing practice internal harus diverifikasi.

39. References

Conceptual baseline:

• Agile story slicing and incremental delivery practices.
• User story mapping, walking skeleton, and tracer bullet concepts.
• General enterprise migration, compatibility, and rollout practices.

These concepts do not describe internal CSG processes.