توی یکی از تجربههایی که داشتیم، با مشکلی مواجه شده بودیم که شاید در نگاه اول خیلی ساده به نظر میرسید: کاربر اطلاعاتی رو ثبت میکرد، روی دکمهی ذخیره میزد و بعد باید حدود ۱۵ ثانیه منتظر میموند تا نتیجهی درخواست مشخص بشه.
مشکل اینجا بود که بعد از چند ثانیه، کاربر مطمئن نبود که اصلاً دکمه رو زده یا نه!

مسئله از کجا شروع شد؟
بخشی از پردازشهای سیستم به ارتباط با سرویسهای خارجی وابسته بود. این ارتباطات در لایهی بیزینس و سمت بکاند پیادهسازی شده بودن و در بعضی از عملیاتها، زمان پاسخگویی به حدود ۱۵ ثانیه میرسید.
برای اینکه کاربر متوجه بشه سیستم در حال انجام کاره، یک لودینگ نمایش میدادیم و تا زمان دریافت پاسخ، امکان ادامهی کار رو هم ازش میگرفتیم.
از نظر فنی، سیستم داشت کارش رو انجام میداد؛ اما از نظر تجربهی کاربری، عملاً ۱۵ ثانیه از وقت همکارمون رو گرفته بودیم. زمانی که میتونست صرف ادامهی کارش بشه و بعد از بررسی بازخوردها و نظرسنجی بین حدود ۴۰۰۰ کاربر فعال سازمانی، متوجه شدیم که این انتظار طولانی واقعاً آزاردهنده است.
پس تصمیم گرفتیم لودینگ رو حذف کنیم!
تصمیمی که نتیجهی غیرمنتظرهای داشت
ایده ساده بود: بهجای اینکه کاربر رو تا پایان پردازش معطل کنیم، اجازه بدیم به کارش ادامه بده.
اطلاعات ثبت بشه و کاربر بتونه سراغ کار بعدی بره، بدون اینکه منتظر پاسخ سرویسهای خارجی بمونه.
نتیجه از یک جهت امیدوارکننده بود؛ رضایت همکارها بیشتر شد. اما از طرف دیگه، تعداد ثبتهای تکراری بالا رفت و هزینههای کسبوکار رو تحت تأثیر قرار داد.
کاربر اطلاعات رو ثبت میکرد، اما چون نتیجهی عملیات رو بهموقع نمیدید، احتمال میداد درخواستش ثبت نشده باشه. بعضی وقتها دوباره روی ذخیره کلیک میکرد، بعضی وقتها صفحه رو رفرش میکرد و گاهی هم همون اطلاعات رو از اول وارد میکرد.
ما مشکل انتظار رو حل کرده بودیم، اما مسئلهی مهمتری رو به وجود آورده بودیم: کاربر نمیدونست چه اتفاقی برای درخواستش افتاده.
راهحل، جلوی چشممون بود
وقتی دوباره مسئله رو بررسی کردیم، متوجه شدیم که پاسخ این مشکل تا حد زیادی در الگوهایی وجود داره که هر روز ازشون استفاده میکنیم؛ اما بهشون توجه نکرده بودیم.
برای مثال، وقتی توی یک پیامرسان پیامی ارسال میکنیم، لازم نیست تا رسیدن پیام به مقصد، منتظر بمونیم و بعد سراغ پیام بعدی بریم بلکه پیام بلافاصله توی صفحه نمایش داده میشه. یک علامت کوچک کنار اون نشون میده که هنوز در حال ارساله. اگر ارسال موفق باشه، وضعیتش تغییر میکنه و اگر خطایی اتفاق بیفته، میتونیم متوجهش بشیم و دوباره تلاش کنیم.
چرا همین رفتار رو برای عملیات ثبت اطلاعات نداشته باشیم؟
اینجا بود که با استفاده از الگوی Optimistic UI میتونستیم مسئله رو به شکل بهتری حل کنیم.
Optimistic UI؛ نمایش نتیجه قبل از تأیید سرور
ایدهی اصلی Optimistic UI اینه که وقتی کاربر عملیاتی رو انجام میده، لازم نیست برای نمایش نتیجهی اولیه بهش منتظر پاسخ سرور بمونیم.
فرض کنیم کاربر فرمی رو تکمیل کرده و روی ذخیره کلیک میکنه. بهجای اینکه جدول رو تا پایان پردازش در حالت انتظار نگه داریم، اطلاعات واردشده رو بلافاصله به جدول اضافه میکنیم و وضعیت اون رو «در حال پردازش» قرار میدیم.
در همین زمان، درخواست واقعی به بکاند ارسال میشه و بعد از دریافت پاسخ، فقط وضعیت همون ردیف رو تغییر میدیم:
Pending: درخواست در حال پردازشه و هنوز نتیجهی نهایی مشخص نیست.
Success: سرور ثبت اطلاعات رو تأیید کرده و شناسهی واقعی رکورد در اختیارمونه.
Failed: عملیات با خطا مواجه شده و کاربر میتونه وضعیت رو ببینه و در صورت امکان دوباره تلاش کنه.
به این ترتیب، کاربر همون لحظه نتیجهی اولیهی کارش رو میبینه، میتونه به عملیات بعدی برسه و در عین حال، از وضعیت درخواست قبلیش هم باخبره.
نکتهی مهم اینه که نمایش فوری اطلاعات به معنی ثبت قطعی اونها در سرور نیست. وضعیت Pending دقیقاً برای همین طراحی شده که این تفاوت رو به کاربر نشون بدیم.
پیادهسازی چقدر پیچیده بود؟
نمونه ای که در سیستم ما پیادهسازی شد کامل شده یک ایده بود ولی در سادهترین حالت، به یک شناسهی موقت و یک وضعیت برای هر ردیف نیاز داریم.
وقتی کاربر اطلاعات رو ثبت میکنه، یک رکورد موقت با شناسهای مثل optimistic-1 به جدول اضافه میکنیم. بعد از دریافت پاسخ موفق، رکورد موقت رو با شناسهی واقعی سرور جایگزین میکنیم. اگر درخواست شکست بخوره، وضعیتش رو به Failed تغییر میدیم تا کاربر بتونه خطا رو ببینه و در صورت امکان دوباره تلاش کنه.
برای مثال، منطق کلی عملیات میتونه چیزی شبیه این باشه:
const insert = async (person: Person) => { const optimisticId = `optimistic-${optimisticIndex++}` // نمایش فوری اطلاعات در جدول data[optimisticId] = { ...person, id: optimisticId, status: "PENDING", } try { const response = await insertPeople(person) if (!response.success) { throw new Error("Failed to insert person") } // جایگزینی رکورد موقت با شناسه واقعی delete data[optimisticId] data[response.data] = { ...person, id: String(response.data), status: "SUCCESS", } } catch { // حفظ رکورد و نمایش وضعیت خطا data[optimisticId] = { ...data[optimisticId], status: "FAILED", } } }
این کد صرفاً منطق اصلی رو نشون میده و برای استفاده در یک کامپوننت واقعی، باید تغییرات State هم متناسب با فریمورک انجام بشه. همچنین بهتره اطلاعات اولیهی فرم در صورت شکست درخواست حفظ بشه تا کاربر مجبور نباشه همهچیز رو از اول وارد کنه.
در عمل، لازم نیست برای هر عملیات یک لودینگ تمامصفحه نمایش بدیم. میتونیم وضعیت هر ردیف رو مستقل مدیریت کنیم و با یک آیکون کوچک، رنگ یا متن کوتاه، نتیجهی عملیات رو مشخص کنیم.
درست مثل همون علامت ساعت یا علامت خطایی که کنار پیامهای یک پیامرسان میبینیم.
اما چرا جلوی ثبت تکراری رو در بکاند نگرفتیم؟
شاید این سؤال پیش بیاد که چرا برای حل این مشکل، از همون ابتدا سراغ بکاند نرفتیم و جلوی ثبت تکراری اطلاعات رو نگرفتیم.
واقعیت اینه که در پروژهی ما، بخشی از فرایند ثبت و پردازش به سرویسهای خارجی وابسته بود. منطق اصلی این عملیاتها بهطور کامل در اختیار بکاند خودمون نبود و به همین دلیل، امکان پیادهسازی یک راهکار قابلاتکا برای جلوگیری از تمام حالتهای ثبت تکراری رو نداشتیم.
در چنین شرایطی، صرفاً بررسی درخواستها در بکاند خودمون کافی نبود؛ چون منشأ ثبت تکراری میتونست در فرایندهایی باشه که خارج از کنترل مستقیم ما اجرا میشدن.
به همین خاطر، تصمیم گرفتیم مسئله رو از جایی حل کنیم که کنترل بیشتری روش داشتیم: تجربهی کاربر.
با استفاده از Optimistic UI، کاربر بلافاصله بعد از ثبت اطلاعات، نتیجهی اولیه رو میدید و وضعیت درخواستش هم مشخص بود. دیگه لازم نبود برای اطمینان از ثبت اطلاعات، چند بار روی دکمهی ذخیره کلیک کنه یا صفحه رو مرتب رفرش کنه.
البته این راهکار تضمین نمیکرد که ثبت تکراری غیرممکن بشه؛ اما کمک میکرد یکی از دلایل اصلی این اتفاق، یعنی بیاطلاعی کاربر از وضعیت درخواست، برطرف بشه.
این تجربه به من نشون داد که همیشه امکان اصلاح تمام محدودیتهای معماری یا وابستگیهای خارجی رو نداریم. گاهی باید راهکاری پیدا کنیم که در محدودهی اختیارمون باشه و در عین حال، اثر واقعی روی مسئله داشته باشه.
رفتار پیامرسانها چه چیزی بهمون یاد میده؟
وقتی پیامی رو در یک پیامرسان ارسال میکنیم، معمولاً چند وضعیت مشخص داریم: پیام در حال ارساله، ارسال شده یا با خطا مواجه شده.
همین الگو رو میشه برای ثبت اطلاعات هم پیاده کرد.
برای مثال، وقتی اطلاعات یک رکورد به جدول اضافه میشه، میتونیم یک علامت کوچک کنار اون نمایش بدیم. تا زمانی که نتیجهی درخواست مشخص نشده، علامت ساعت یا وضعیت Pending رو میبینیم. بعد از تأیید سرور، وضعیت تغییر میکنه و در صورت شکست درخواست، علامت خطا نمایش داده میشه.
اگر امکان تلاش مجدد وجود داشته باشه، کاربر میتونه بدون ورود دوبارهی اطلاعات، همون عملیات رو تکرار کنه. در صورت موفقیت هم میتونیم زمان ثبت نهایی رو نمایش بدیم.
به این ترتیب، بهجای اینکه کاربر رو منتظر نگه داریم، اطلاعات لازم برای تصمیمگیری رو در اختیارش قرار میدیم.
در واقع، مسئله فقط حذف یک لودینگ نیست؛ مسئله اینه که کاربر در تمام مراحل بدونه چه اتفاقی برای درخواستش افتاده.
چیزی که از این تجربه یاد گرفتم
اول اینکه نباید تصور کنیم چون یک عملیات در بکاند در حال انجامه، کاربر هم الزاماً باید منتظر پایان اون بمونه. خیلی وقتها میشه زمان انتظار رو از تجربهی کاربر حذف کرد، بدون اینکه زمان واقعی پردازش رو کاهش داده باشیم.
دوم اینکه نباید به دریافت پاسخ از سیستمهای بیرونی، حتی بکاند خودمون، بهعنوان تنها راه مدیریت وضعیت رابط کاربری نگاه کنیم. ممکنه پردازش طول بکشه، شبکه قطع بشه یا پاسخ به کلاینت نرسه. فرانتاند باید بتونه این وضعیتها رو بهدرستی مدیریت کنه، بدون اینکه وانمود کنه عملیات قطعاً موفق شده.
البته این به معنی بیاعتمادی مطلق به بکاند نیست. سرور همچنان مرجع نهایی تأیید ثبت اطلاعاته؛ همون چیزی که در طراحی سیستم بهعنوان Source of Truth میشناسیم.
سوم اینکه شفاف بودن وضعیت عملیات یکی از سادهترین و در عین حال مؤثرترین راهکارها در طراحی سیستمه. وقتی کاربر نمیدونه سیستم چه کاری انجام میده، احتمال اینکه دوباره همون عملیات رو اجرا کنه بیشتر میشه. اما وقتی وضعیت درخواست مشخصه، میتونه با اطمینان بیشتری کارش رو ادامه بده.
و در نهایت، به نظرم همیشه لازم نیست برای حل یک مشکل، زمان پردازش رو کاهش بدیم یا معماری سیستم رو تغییر بدیم. گاهی میشه با تغییر نحوهی نمایش نتیجه و مدیریت وضعیت درخواست، تجربهی خیلی بهتری ساخت.
شاید مسئله از ابتدا این نبود که چرا ذخیره کردن ۱۵ ثانیه طول میکشه؛ مسئله این بود که در تمام این ۱۵ ثانیه، کاربر نمیدونست سیستم چه کاری انجام میده و آیا باید منتظر بمونه یا نه.