Berhenti Menunggu Backend: Bagaimana Kontrak API Membuka Pengembangan Paralel untuk Tim Kami
Beralih dari alur kerja yang saling “menunggu” ke eksekusi paralel sejati dengan pendekatan Design-First.
“API-nya sudah siap belum?”
Pertanyaan itu dulu paling sering muncul di daily stand-up kami.
Di awal karier, saya dan tim bekerja dengan cara yang terasa intuitif, tetapi ternyata tidak efisien. Saat desain fitur baru disetujui, kami langsung memecah pekerjaan. Tim Frontend mulai melakukan slicing UI, sementara tim Backend mulai membangun logika dan skema database.
Kami bekerja secara terpisah, hanya bermodalkan asumsi. “Saya asumsikan backend akan mengembalikan array di sini.” “Saya asumsikan nama propertinya adalah isVerified.”
Masalahnya? Pengembangan Frontend—khususnya slicing UI—sering kali jauh lebih cepat daripada membangun logika backend yang kompleks.
Jebakan “Permainan Menunggu”
Tim Frontend biasanya menyelesaikan slicing UI dalam dua hari. Namun, Backend masih berjibaku dengan logika bisnis yang rumit, optimasi database, atau integrasi pihak ketiga.
Hasilnya? Bottleneck.
Developer Frontend menganggur karena terblokir. Mereka belum bisa mengimplementasikan logika integrasi data karena API-nya belum ada. Mereka juga sulit berpindah ke tugas berikutnya karena tugas saat ini masih “setengah jadi”.
Dan bagian terburuknya muncul saat integrasi. Begitu API akhirnya siap, kami baru sadar asumsi kami keliru:
- Frontend mengharapkan
imageUrl, Backend mengirimavatar_url. - Frontend mengharapkan Boolean, Backend mengirim String
"true".
Kami membuang berjam-jam hanya untuk memperbaiki ketidakcocokan ini. Saya pun sadar bahwa kami sebenarnya bekerja dengan model Waterfall yang menyamar sebagai Agile. Kami butuh perubahan.
Solusinya: Kontrak di Awal, Kode Belakangan
Kami memutuskan membalik alur kerja. Kami memperkenalkan satu langkah wajib sebelum menulis satu baris kode pun: Diskusi Kontrak API.
Kini, sebelum sprint benar-benar berjalan, developer Frontend dan Backend duduk bersama (atau berdiskusi singkat) untuk menyepakati “Source of Truth”.
Kami mendefinisikan semuanya di awal:
- Endpoint: (misalnya
GET /api/v1/users/profile) - Method: (
GET,POST,PUT, dll.) - Response Body: Struktur JSON yang persis, nama key, dan tipe datanya.
- Error Codes: Apa yang dikembalikan jika terjadi kesalahan?
Kami mendokumentasikannya (menggunakan Swagger/OpenAPI, atau bahkan dokumen Notion sederhana). Begitu disepakati, dokumen ini menjadi aturan mutlak.
Keajaibannya: Pengembangan Paralel dengan Mocking
Dengan kontrak di tangan, bottleneck menghilang. Alur kerja berubah dari Serial (Menunggu) menjadi Paralel (Mengeksekusi).
Alih-alih menunggu API sungguhan, saya langsung membuat Mock Function berdasarkan kontrak yang disepakati.
Saya tidak sekadar mengembalikan objek statis. Saya memakai Promise yang digabungkan dengan setTimeout untuk menyimulasikan request jaringan nyata, termasuk latensinya.
Begini cara saya mengimplementasikan mock di codebase:
// user.service.mock.js
// Berdasarkan Kontrak API yang disepakati
const getUserProfile = () => {
return new Promise((resolve, reject) => {
// Simulasi latensi jaringan 1 detik
setTimeout(() => {
// Skenario A: Sukses
return resolve({
data: {
id: 'user-id123',
name: 'John Doe',
role: 'admin'
}
});
// Skenario B: Error (Uncomment untuk menguji error handling)
// return reject({
// response: { status: 500, code: 'INTERNAL_SERVER_ERROR' }
// });
}, 1000);
});
};
Pendekatan ini memberi saya kekuatan super sebagai Frontend Developer:
- Bisa menguji Loading State: Berkat
setTimeout, saya bisa memverifikasi secara visual apakah loading spinner atau skeleton loader bekerja dengan benar selama jeda 1 detik tersebut. - Bisa menguji Error Handling: Saya dapat menyimulasikan kegagalan dengan me-reject promise, sehingga UI error (seperti Toast atau Error Boundary) bisa dibangun tanpa perlu backend benar-benar crash.
- Bisa menuntaskan fitur: Secara logika, fitur sudah selesai. Saya bisa commit kode dan langsung lanjut ke tugas berikutnya.
Momen Pembuktian: Integrasi
Keindahan pendekatan ini terasa jelas pada fase integrasi.
Ketika tim Backend akhirnya berkata, “API-nya sudah siap,” integrasinya berjalan mulus. Karena kami sama-sama mengikuti cetak biru yang identik, saya cukup menukar Mock function dengan pemanggilan API asli.
- Tanpa error “Undefined”.
- Tanpa drama “Key mismatch”.
- Tanpa merombak ulang logika UI.
Semuanya langsung berjalan. Tinggal pasang dan pakai.
Kesimpulan
Jika tim Frontend Anda terus-menerus bertanya “API-nya sudah siap?”, berarti Anda punya masalah proses, bukan masalah coding.
Beralih ke pendekatan API Contract-First tidak hanya mempercepat pengembangan; pendekatan ini juga mengurangi stres. Kami bisa bekerja secara paralel, saling menghargai waktu, dan menjadikan integrasi sebagai verifikasi akhir—bukan sesi berburu bug.
Jangan menulis kode berdasarkan asumsi. Sepakati kontraknya, mock latensinya, dan berhentilah menunggu.