ביום שבו מוצר B2B2C יוצא לאוויר העולם, בפעם הראשונה, מהגראז', התחושות מעורבות. יש קוד שעובד, חוויית משתמש טובה, פונקציונליות שנבנתה אחרי שעות של חשיבה ולמידה, ואם מתמזל מזלנו - גם שותף אמיתי שמוכן לצאת איתך למסע הזה.

דקה אחרי ההשקה: גאווה, אופוריה. הולכים לישון עם חיוך על הפנים, תחושת מאניה. אבל אז, למחרת בבוקר, מגיעים למשרד - והשקט לוקח פיקוד. לא שקט של הצלחה, לא שקט של כישלון - אלא שקט של חוסר מידע.

כשהמוצר מוטמע אצל צד שלישי, מתווך בינך לבין המשתמש הסופי, נוצר פער עמוק: מצד אחד, אתה אמור לספק ערך אמיתי למשתמש הקצה. מצד שני, אתה לא תמיד רואה אותו. לא תמיד יודע מיהו, מה הוא עשה, מה הוא הבין או למה הוא נטש.

במילים אחרות: אין דאטה. או שיש, אבל לא את הדאטה שצריך כדי להבין.

וכאן נולדת ההבנה שמוצר - במיוחד בעולמות ה- B2B2C - הוא יותר ממקבץ של פיצ'רים, מיוחדים ומדהימים ככל שיהיו. מוצר הוא מערכת לומדת. תהליך. שמטרתו אינה רק לספק ערך - אלא לגלות מהו ערך, למי, ואיך יודעים שהוא התרחש.

אבל תהליך כזה דורש משהו שלמוצר B2B2C אין תמיד: שליטה על חוויית השימוש, על הדאטה, על המסלול שהמשתמש עובר. ולכן, בניגוד למוצרי B2C, כשעובדים במודלים דרך שותפים נדרשת מחשבה עמוקה לא רק על מה לבנות - אלא על איך ללמוד בתוך מגבלות. איך למדוד כשלא שולטים בכל הנקודות. איך להבין התנהגות דרך מדדי פרוקסי.

וזו נקודת הפתיחה של המאמר הזה.

כשאתה לא זה שמחזיק את הדאטה

במודלים של B2B2C, השליטה בידיים של מישהו אחר. אתה בונה את המוצר, משקיע בתוכן, חושב על כל מקרה אפשרי - אבל כשמגיע הרגע שבו מישהו באמת משתמש, אתה לא שם. לא יכול ללוות אותו, או אפילו לצפות בו.

השקת את המוצר לתוך מערכת של שותף, במקרה שלנו: אפליקציה של בנק, פלטפורמת מסחר, אתר של גוף פיננסי גדול - יוצרת נתק. כי הדאטה לא אצלך. הוא עובר דרך פילטרים. חלקו נחתך בגלל רגולציה, חלקו נשמר אצל השותף, חלקו בכלל לא נאסף. ומה שמגיע לידיים שלך - אם מגיע - לעיתים דל, לא עקבי, ובעיקר: לא מספר סיפור שלם.

ואם אין סיפור - אין למידה.

במצב כזה, הרבה יזמים עושים את הטעות המתבקשת: הם מתחילים לבנות עוד. להוסיף פיצ'רים, לשכתב תהליכים. אבל הבעיה לא תמיד במוצר - אלא בזה שאין דרך קלה לאסוף פידבק.

ולכן השאלה שצריכה להישאל היא: איך בונים מוצר שלא חי בוואקום, אלא מתארח כחלק ממערכת גדולה יותר - ובכל זאת מצליח ללמוד, גם בלי לראות את כל התמונה?

מוצר הוא מערכת לומדת, לא רק מבצעת

אם מקבלים את זה שמוצר B2B2C פועל מתוך מגבלות של שליטה, נראות ודאטה - צריך לעצב אותו בהתאם. לא כקופסה סגורה שמבצעת פעולות, אלא כמערכת לומדת. כזו שנבנית לא רק כדי לפעול - אלא כדי להבין מה קורה סביבה, גם כשהמידע חלקי.

וזה משנה את כל ההגדרה של "פיצ'ר טוב". פיצ'ר טוב הוא לא רק כזה שמספק ערך - אלא כזה שגם מסוגל לאותת אם הערך הזה התרחש בפועל. אם אי אפשר לדעת מה קרה בעקבות השימוש, אם אי אפשר ללמוד ממנו - הפיצ’ר אולי יפה, אולי חשוב - אבל הוא עיוור.

וזה בדיוק ההבדל בין "מערכת פועלת" ל"מערכת לומדת": הראשונה עושה. השנייה שואלת.

במודל B2B2C, אתה לא יכול להרשות לעצמך לפעול על אוטומט. אתה לא במצב שבו אפשר להריץ A/B testing עם אלפי משתמשים ולראות גרפים משתנים. אתה עובד עם שותפים, בממשקים מורכבים, עם משתמשים שאתה בקושי רואה.

אז המערכת שלך חייבת להיות חכמה יותר. לא ברמה הטכנית - אלא ברמה התהליכית.

היא צריכה לשאול את השאלות הבאות בכל פעם שמשהו נבנה:

1. מה נרצה ללמוד מהפיצ'ר הזה?
2. איזו התנהגות תעיד שהוא עובד?
3. מה יקרה אם לא נראה כלום - ואיך נדע אם זו בעיה בתוכן, במיקום או בכלל בשותף?

מוצר טוב, במודל כזה, הוא כזה שמבין שהוא לא רואה הכול - ובכל זאת מוצא דרכים להבין.

ללמוד מתוך מגבלה

כשאין לך שליטה מלאה על הדאטה - אתה חייב להיות יצירתי. אי אפשר לסמוך על כך שהשותף יעביר את כל האיוונטים, שיאפשר לך גישה לכל הפרטים, או שיבנה עבורך דוחות. הרבה פעמים הוא לא מסוגל - לפעמים הוא לא רוצה.

אז מה כן עושים?

לא בונים מערכת שדורשת שליטה - בונים את המוצר כך שיוכל לייצר הבנה. 

זאת אומרת שגם אם המידע שמגיע לא שלם, גם אם הוא עובר דרך פילטרים. מתכננים את החוויה כך שחלק מהתובנות ייווצרו מתוך ההתנהגות עצמה. מחפשים רגעים ברורים שמרמזים על ערך. תנועות חוזרות. מסלולים שחוזרים על עצמם. לא שואלים “האם הלקוח רכש את הנייר ערך?”, אלא “מה המשתמש ניסה להשיג - והאם הוא הצליח”.

המטרה היא ליצור תהליכים שאפשר להבין דרכם כוונה - גם כשלא רואים פנים, ולא שומעים פידבק ישיר.

והמוצר, אם נבנה נכון, יודע לא רק לבצע - אלא גם לרמוז, להציע, ולספר סיפור גם כשהמידע חלקי.

אתה לא רק מפתח רק יכולות ללקוח - אתה בונה שכבת בקרה לעצמך. שכבה שיכולה לעבוד גם בלי שליטה מלאה. ולפעמים, דווקא בגלל שאתה עובד עם מגבלות - אתה לומד למדוד את מה שחשוב באמת. כי כשאין אינסוף דאטה, אתה נאלץ לבחור:

1. מה המדד שאם לא יקרה - הפיצ’ר לא שווה את זה?
2. מה הפעולה הקריטית שאם לא נזהה - אנחנו עיוורים?

השאלות האלה הן לא רק טכניות. הן שורש האסטרטגיה שלך.

כשאי אפשר למדוד ישירות - עובדים עם פרוקסי

במודל B2C, המדדים ברורים: משתמש נרשם, ביצע פעולה, שילם - אתה רואה הכול.
אבל במודל B2B2C, אתה לא תמיד יודע אם המשתמש הבין את הערך. אתה לא רואה את התגובה שלו, לא יודע אם הוא חזר כי אהב - או כי נלחץ בטעות.

אז מה כן מודדים? לא את מה שאתה רוצה לדעת - אלא את מה שאתה יכול לדעת, ושמנבא את מה שחשוב.

במילים אחרות: פרוקסי.

פרוקסי הוא מדד עקיף שמסמן לך מגמה אמיתית.

למשל:

1. לא כמה משתמשים שיתפו את המוצר - אלא כמה הגיעו לעמוד מסוים שאופייני לשיתוף.
2. לא אם מישהו שילם - אלא אם הוא ביצע פעולה שמזוהה עם משתמשים משלמים בהמשך.

פרוקסי טוב לא נמדד לפי כמה הוא מדויק - אלא לפי כמה הוא מייצר למידה.

ולפעמים, דווקא בגלל שאתה לא מקבל תשובה חד־משמעית - אתה מפתח רגישות. אתה לומד להקשיב לאיתותים קטנים, לזהות דפוסים חוזרים, ולבנות תובנה מתוך רעש.

זה אולי פחות נוח, פחות מדויק - אבל הרבה יותר עמוק. כי אתה לא מודד את מה שאתה רואה - אתה בונה הבנה על סמך מה שאתה מצליח לזהות.

וזה ההבדל בין מוצר שפועל - לבין מוצר שלומד.

המוצר לא רק יוצר פתרונות - הוא מחפש הבנה.

בעולם שבו אתה לא שולט בחוויית הקצה, לא מקבל את כל הדאטה, ולא תמיד יודע אם בכלל השתמשו בפיצ'ר שבנית - נולדת משימה חדשה: לנהל מוצר לא רק כדי לספק, אלא כדי להבין.

זה משנה את כל אופן החשיבה.

המוצר כבר לא מונחה לפי מה שהלקוח ביקש או מה שהמשתמש “אמור לרצות” - אלא לפי מה שניתן ללמוד ממנו. כל פיצ’ר, כל שינוי, כל רכיב בממשק - הוא שאלה בתחפושת.

השאלה האמיתית היא לא "האם זה עובד" - אלא "איך נוכל לדעת אם זה עובד". האם בנינו משהו שגם יאפשר תובנה?, גם ייצר תנועה? וגם יאותת לנו אם אנחנו בכיוון?

בניהול מוצר B2B2C, אתה צריך להפוך להיות פרשן של איתותים חלשים. ללמוד לחשוב כמו חוקר: לנסח הנחות, לתכנן מהלך קטן, לצפות לסוג מסוים של התנהגות - ואז לבדוק אם משהו מזה קרה. לפעול בזהירות, אבל לא בפחד. לבנות לאט יותר - אבל להבין מהר יותר.

כי בסוף, במודל B2B2C שבו אין לך את כל השליטה - דווקא הדיוק המחשבתי הוא זה שמייצר יתרון.

לא רק בביצוע - אלא ביכולת שלך לראות מה באמת עובד.

מוצר כזה - שמבין את מקומו בתוך מערכת גדולה, שלא נבהל ממגבלות אלא מתרגם אותן לדיוק - הוא לא רק יוצר ערך. הוא יוזם למידה. וזה בדיוק ההבדל בין "מערכת פועלת" ל"מערכת לומדת": כשהראשונה עושה, והשנייה שואלת.