שיעור פרטי בתכנון מערכות (System Design) עם AI
לומדים לתכנן מערכות צעד אחר צעד: משרת אחד ועד מערכות מבוזרות והכנה לראיון System Design
המורה: נועם
- התוכנית עודכנה 11.2026
- עברית, ועוד 5 שפות
- 4 רמות: מתחילים · ממשיכים · מתקדמים · הכנה למבחן
- 48 שיעורים · כ־27 שעות של שיעורים
תכנון מערכות (System Design)
לומדים לתכנן מערכות צעד אחר צעד: משרת אחד ועד מערכות מבוזרות והכנה לראיון System Design
12 שיעורים · 4 פרקים · שיעור חי פרטי עם המורה על הלוח
מה תדעו לעשות בסוף
- לצייר את המסלול המלא של בקשה מהדפדפן דרך DNS לשרת ולמסד הנתונים
- להסביר מבנה של בקשת HTTP ולהבחין בין latency ל־throughput
- לתכנן API בסגנון REST עם endpoints, methods וקודי סטטוס נכונים
- לפתוח שאלת תכנון בשאלות הבהרה ולכתוב דרישות עם מספרים מדידים
- להעריך QPS ממוצע ושיא, אחסון לחמש שנים ורוחב פס, ולהכריע אם שרת אחד מספיק
- לתכנן סכמה רלציונית עם מפתחות ראשיים וזרים, ולבחור אילו עמודות לאנדקס
- לזהות race condition בהזמנת המקום האחרון ולהסביר איך טרנזקציה מונעת אותו
- לתכנן מקצר קישורים מקצה לקצה ולנמק כל החלטה במספרים
- להפוך שרת אפליקציה ל־Stateless ולהעביר את ה־state ל־session store משותף
- לבחור סוג Load Balancer (L4 או L7) ואלגוריתם חלוקה, ולהסביר איך Health Check עובד
- לתכנן Rate Limiter עם token bucket ולהחליט מה מחזירים ללקוח שחרג
- לשים Cache-Aside מול DB ולחשב hit ratio וגודל זיכרון נדרש
- למנוע נתונים ישנים ו־cache stampede בעזרת TTL, eviction ו־invalidation
- להוסיף Read Replicas, להתמודד עם replication lag ולתאר failover
- לבחור shard key, להשוות range מול hash ולהסביר איך consistent hashing מזיז מעט מפתחות
- להוציא עבודה כבדה לתור ולבנות consumer אידמפוטנטי שמטפל בהודעות שנכשלות
- להסביר למה אי אפשר להבחין בין שרת איטי לשרת מת, ולתכנן Timeouts ו־Retries בטוחים
- לסווג מערכת כ־CP או AP ולהוסיף את פשרת ה־latency של PACELC
- לבחור N, R ו־W ב־Quorum שמבטיחים את רמת העקביות הדרושה
- להסביר איך Raft בוחר מנהיג ואיך Fencing Token מונע Split Brain
- לבחור בין 2PC ל־Saga ולשלוח אירועים אמינים בעזרת Transactional Outbox
- לתכנן Consumer אידמפוטנטי ולהבחין בין At-least-once ל־Exactly-once אפקטיבי
- לחשב זמינות של שרשרת תלויות, להגדיר SLO ולעצור כשלים מתגלגלים עם Circuit Breaker
- לתכנן פיד, צ'אט, אפליקציית מוניות ו־Key-Value Store ולהגן על כל רכיב במספרים
- לחלק ראיון של 45 דקות לארבעה שלבים עם תקציב זמן
- לשאול בחמש דקות את שאלות ההבהרה ולהפיק QPS ואחסון במספרים עגולים בקול רם
- לבחור צוואר בקבוק להעמקה ולהכריע בין שתי חלופות בנימוק מספרי
- לתכנן מחולל מזהים ייחודיים וממוינים ולהשוות בין UUID, טבלת DB ו־Snowflake
- לתכנן שירות Typeahead שמחזיר Top-K הצעות בפחות מ־100ms
- לתכנן מערכת התראות, Web Crawler ושירות וידאו עם עיבוד אסינכרוני
- לתכנן מערכת כרטיסים שמונעת מכירה כפולה של מושב בזמן עומס שיא
- להוביל בעצמכם ראיון מלא ולהפעיל רשימת בדיקה להתאוששות כשנתקעים
בסוף כל רמה המורה בודק שזה באמת ברור, לא רק שעברנו על החומר
נושאים קשורים
הקורס כולל
- שיעורים חיים 1:1 עם מורה פרטי AI על לוח
- 27 שעות של שיעורים חיים אחד על אחד
- 48 שיעורים על לוח משותף, כל אחד עם יעד ברור
- תרגול ובדיקת הבנה בכל שיעור
- סיכום אחרי כל שיעור, שנשמר בהיסטוריה
- הכנה לראיון System Design
- תעודת סיום לכל רמה
- מחשב, טאבלט או טלפון
- עברית, ועוד 5 שפות
תוכנית הקורס
4 רמות · 16 פרקים · 48 שיעורים · 27 שע׳ 5 דק׳ בסך הכול
מתחיליםמתחילים: משרת אחד ועד מערכת עובדת4 פרקים • 12 שיעורים • 6 שע׳ 25 דק׳
הלומד/ת מבין/ה איך בקשה עוברת מהלקוח לשרת ולמסד הנתונים, מגדיר/ה דרישות, מעריך/ה עומסים במספרים ומתכנן/ת מערכת פשוטה על שרת ומסד נתונים אחד.
ממופה למבחן: ראיון System Design
לקוח־שרת: איך בקשה עוברת ברשת3 שיעורים • 1 שע׳ 35 דק׳
- 1מה זה System Design ומודל השרת האחדלצייר את המסלול המלא של בקשה מהדפדפן דרך DNS לשרת ולמסד הנתונים ובחזרה, ולהסביר מה כל רכיב עושה.שיעור ניסיוןכ־30 דק׳
- 2HTTP, בקשה־תשובה וזמני השהיהלהסביר מבנה של בקשת HTTP, את ההבדל בין latency ל־throughput, ומאיפה מגיע הזמן של בקשה.כ־30 דק׳
- 3תכנון API: REST, קודי סטטוס ו־Idempotencyלתכנן API בסגנון REST למערכת פשוטה, עם endpoints, methods וקודי סטטוס נכונים, ולזהות פעולות idempotent.כ־35 דק׳
דרישות והערכת עומסים3 שיעורים • 1 שע׳ 35 דק׳
- 4דרישות פונקציונליות ולא־פונקציונליותלפתוח שאלת תכנון בשאלות הבהרה ולכתוב רשימת דרישות פונקציונליות ולא־פונקציונליות עם מספרים מדידים.כ־30 דק׳
- 5מספרים שכל מהנדס צריך לדעתלעבוד בחזקות של 2 ו־10 ולהשוות בסדרי גודל בין זיכרון, דיסק ורשת כדי להחליט מה מהיר ומה איטי.כ־30 דק׳
- 6הערכת עומסים: QPS, אחסון ורוחב פסלחשב מתוך מספר משתמשים QPS ממוצע ושיא, אחסון לחמש שנים ורוחב פס, ולהסיק אם שרת אחד מספיק.כ־35 דק׳
מסד נתונים אחד4 שיעורים • 2 שע׳ 5 דק׳
- 7המודל הרלציוני ותכנון סכמהלתכנן סכמה רלציונית למערכת פשוטה עם טבלאות, מפתחות ראשיים וזרים וקשרים, ולהחליט מתי לנרמל.כ־35 דק׳
- 8אינדקסים וביצועי שאילתותלהסביר איך אינדקס הופך סריקה מלאה לחיפוש מהיר, ולבחור אילו עמודות לאנדקס לפי השאילתות.כ־30 דק׳
- 9טרנזקציות ו־ACIDלהסביר מה מבטיחה טרנזקציה, לפרק את ACID לדוגמאות, ולזהות race condition בפעולה כמו הזמנת המקום האחרון.כ־30 דק׳
- 10SQL או NoSQL: איך בוחריםלהשוות בין מסד רלציוני לסוגי NoSQL העיקריים ולנמק בחירה של מסד נתונים לפי דפוס הגישה והדרישות.כ־30 דק׳
מחברים הכול: מערכת על שרת אחד2 שיעורים • 1 שע׳ 10 דק׳
- 11גבולות השרת האחד: צווארי בקבוק ו־Vertical Scalingלזהות צוואר בקבוק (CPU, זיכרון, דיסק, רשת) במערכת על שרת אחד, להעריך מתי הגדלת השרת מפסיקה לעזור, ולזהות single point of failure.כ־30 דק׳
- 12תכנון מלא ראשון: מקצר קישוריםלתכנן מקצר קישורים מקצה לקצה: דרישות, הערכת עומסים, API, סכמה ובחירת מסד נתונים, ולנמק כל החלטה במספרים.כ־40 דק׳
ממשיכיםממשיכים: Scaling — Load Balancer, Caching, שכפול, Sharding ותורים4 פרקים • 12 שיעורים • 6 שע׳ 35 דק׳
לקחת מערכת של שרת אחד ולהרחיב אותה ל־web scale: Load Balancer, CDN, Cache, Replicas, Shards ותורים, ולהצדיק כל רכיב במספרים.
ממופה למבחן: ראיון System Design
יוצאים מהשרת האחד: Horizontal Scaling4 שיעורים • 2 שע׳ 5 דק׳
- 1Horizontal Scaling ושרתים Statelessתדע/י להפוך שרת אפליקציה ל־Stateless ולהעביר state ל־session store משותף כדי שאפשר יהיה להוסיף שרתים.כ־30 דק׳
- 2Load Balancer: L4 מול L7, אלגוריתמים ו־Health Checksתדע/י לבחור סוג Load Balancer ואלגוריתם חלוקה, ולהסביר איך הוא מזהה שרת תקול ומוציא אותו.כ־35 דק׳
- 3DNS ו־CDN: לקרב את התוכן למשתמשתדע/י להסביר איך DNS ו־CDN מורידים latency ועומס, ולהחליט מה לשים ב־CDN ולכמה זמן.כ־30 דק׳
- 4Rate Limiting ו־API Gatewayתדע/י לתכנן Rate Limiter עם token bucket, להחליט איפה הוא יושב ומה מחזירים ללקוח שחרג.כ־30 דק׳
Caching2 שיעורים • 1 שע׳ 5 דק׳
- 5Cache-Aside ושכבות ה־Cacheתדע/י לשים Cache-Aside מול DB, לחשב hit ratio ולהעריך כמה זיכרון ה־cache צריך.כ־30 דק׳
- 6כתיבה, Eviction ו־Invalidationתדע/י לבחור מדיניות כתיבה, TTL ו־eviction, ולמנוע נתונים ישנים ו־cache stampede.כ־35 דק׳
שכפול וחלוקה של מסד הנתונים3 שיעורים • 1 שע׳ 40 דק׳
- 7Replication: Primary, Replicas ו־Failoverתדע/י להוסיף Read Replicas, להתמודד עם replication lag ולתאר failover כשה־primary נופל.כ־35 דק׳
- 8Sharding: בחירת מפתח ו־Hot Spotsתדע/י לבחור shard key, להשוות range מול hash, ולזהות hot spots ושאילתות שחוצות shards.כ־35 דק׳
- 9Consistent Hashing והוספת Shardsתדע/י להסביר למה mod N נשבר בהוספת שרת ואיך consistent hashing עם virtual nodes מזיז מעט מפתחות.כ־30 דק׳
עיבוד אסינכרוני ותורים3 שיעורים • 1 שע׳ 45 דק׳
- 10Message Queues: Producer, Queue ו־Workersתדע/י להוציא עבודה כבדה לתור, לבנות workers עם consumer אידמפוטנטי ולטפל בהודעות שנכשלות.כ־35 דק׳
- 11Pub/Sub ו־Event Streamsתדע/י להבחין בין תור עבודה ל־event stream, ולהסביר partitions, consumer groups ושמירת סדר.כ־30 דק׳
- 12מחברים הכול: מקצר הקישורים ב־Web Scaleתדע/י להרחיב תכנון של שרת אחד לארכיטקטורה מלאה עם LB, CDN, cache, replicas, shards ותור, ולהצדיק כל רכיב במספרים.כ־40 דק׳
מתקדמיםמתקדמים (מקצועי): מערכות מבוזרות, עקביות ותכנון מערכות מוכרות4 פרקים • 12 שיעורים • 7 שע׳ 5 דק׳
הלומד/ת מבינ/ה את הכשלים והפשרות של מערכות מבוזרות (CAP, מודלי עקביות, קונצנזוס, טרנזקציות מבוזרות, אמינות ו־Multi-Region), ומתכנן/ת מערכות מוכרות כמו פיד, צ'אט, אפליקציית מוניות ו־Key-Value Store, ומגן/ה על כל רכיב במספרים.
יסודות המערכות המבוזרות4 שיעורים • 2 שע׳ 10 דק׳
- 1כשלים חלקיים: רשת לא אמינה, Timeouts ו־Retriesלהסביר למה במערכת מבוזרת אי אפשר להבחין בין שרת איטי לשרת מת, ולתכנן Timeouts ו־Retries בטוחים.כ־30 דק׳
- 2משפט CAP ו־PACELCלהסביר מה CAP באמת אומר בזמן Partition, לסווג מערכות כ־CP או AP, ולהוסיף את פשרת ה־latency של PACELC.כ־30 דק׳
- 3מודלי עקביות ו־Quorumלהבחין בין עקביות חזקה, Eventual ועקביות סשן, ולבחור N, R, W ב־Quorum שמבטיחים את הרמה הדרושה.כ־35 דק׳
- 4קונצנזוס, בחירת מנהיג ו־Split Brainלהסביר איך Raft בוחר מנהיג ומשכפל לוג ברוב, למה צריך מספר אי־זוגי של צמתים, ואיך Fencing Token מונע Split Brain.כ־35 דק׳
נתונים והודעות בין שירותים2 שיעורים • 1 שע׳ 5 דק׳
- 5טרנזקציות מבוזרות: 2PC, Saga ו־Outboxלבחור בין 2PC ל־Saga עם פעולות מפצות כשפעולה עסקית חוצה כמה שירותים, ולשלוח אירועים אמינים בעזרת Transactional Outbox.כ־35 דק׳
- 6סמנטיקת מסירה, Idempotency וסדר הודעותלהבחין בין At-most-once, At-least-once ו־Exactly-once אפקטיבי, ולתכנן Consumer אידמפוטנטי ששומר על סדר במקום שבו הוא נחוץ.כ־30 דק׳
אמינות בייצור ו־Multi-Region2 שיעורים • 1 שע׳ 10 דק׳
- 7אמינות: SLO, Circuit Breaker ו־Graceful Degradationלחשב זמינות של שרשרת תלויות, להגדיר SLO ו־Error Budget, ולעצור כשלים מתגלגלים בעזרת Circuit Breaker, Bulkhead והורדת יכולות.כ־35 דק׳
- 8Multi-Region: התאוששות מאסון ופתרון קונפליקטיםלבחור ארכיטקטורת Multi-Region לפי RPO ו־RTO, ולהסביר איך פותרים קונפליקטי כתיבה ב־Active-Active.כ־35 דק׳
תכנון מערכות מוכרות4 שיעורים • 2 שע׳ 40 דק׳
- 9תכנון News Feed: Fan-out on Write מול Readלתכנן פיד חדשות של רשת חברתית, לבחור אסטרטגיית Fan-out היברידית לפי מספרים ולטפל במשתמשי סלבריטי.כ־40 דק׳
- 10תכנון אפליקציית צ'אט בזמן אמתלתכנן אפליקציית צ'אט עם WebSockets, מסירה אמינה, סדר הודעות, אישורי קריאה ונוכחות, ולהעריך את מספר שרתי החיבורים.כ־40 דק׳
- 11תכנון אפליקציית מוניות: אינדקס גיאוגרפי והתאמהלתכנן מערכת הזמנת מוניות שמאתרת נהגים קרובים עם Geohash, קולטת עדכוני מיקום בקצב גבוה ומונעת שיבוץ כפול של נהג.כ־40 דק׳
- 12תכנון Key-Value Store מבוזר: הכול ביחדלתכנן Key-Value Store מבוזר בסגנון Dynamo, ולהגן במספרים על כל החלטה: חלוקה, שכפול, Quorum, זיהוי כשלים ופתרון קונפליקטים.כ־40 דק׳
הכנה למבחןהכנה לראיון System Design4 פרקים • 12 שיעורים • 7 שע׳
להוביל ראיון System Design של 45 דקות: להבהיר דרישות, להעריך עומסים בקול רם, לשרטט ארכיטקטורה, להעמיק בצוואר הבקבוק ולהגן על כל החלטה במספרים.
ממופה למבחן: ראיון System Design
שיטת הראיון: איך מובילים 45 דקות3 שיעורים • 1 שע׳ 40 דק׳
- 1מבנה הראיון ומה המראיין באמת בודקלחלק ראיון של 45 דקות לארבעה שלבים עם תקציב זמן, ולדעת אילו סיגנלים המראיין מחפש בכל שלב.כ־30 דק׳
- 2הבהרת דרישות והערכת עומסים בקול רםלשאול בחמש דקות את השאלות שמגדירות את המערכת, ולהפיק QPS ואחסון במספרים עגולים תוך כדי דיבור.כ־35 דק׳
- 3Deep Dive ו־Trade-offs: להגן על החלטה במספריםלבחור את צוואר הבקבוק הנכון להעמקה, להציג שתי חלופות ולהכריע ביניהן בנימוק מספרי, ולהגיב ל־Pushback בלי להתגונן.כ־35 דק׳
שאלות חימום ממוקדות2 שיעורים • 1 שע׳ 5 דק׳
- 4תכנון מחולל מזהים ייחודיים מבוזרלתכנן מחולל מזהים ייחודיים וממוינים בזמן ללא תיאום מרכזי, ולהשוות בין UUID, טבלת DB ו־Snowflake.כ־30 דק׳
- 5תכנון השלמה אוטומטית (Typeahead)לתכנן שירות השלמה אוטומטית שמחזיר Top-K הצעות בפחות מ־100ms, כולל איסוף נתונים ועדכון תקופתי.כ־35 דק׳
מערכות Pipeline ועיבוד אסינכרוני3 שיעורים • 1 שע׳ 50 דק׳
- 6תכנון מערכת התראותלתכנן מערכת ששולחת Push, SMS ומייל במיליונים ביום, עם Retries, מניעת כפילויות והעדפות משתמש.כ־35 דק׳
- 7תכנון Web Crawlerלתכנן Crawler שסורק מיליארד דפים בחודש, מכבד נימוס לכל אתר ומונע סריקה כפולה.כ־35 דק׳
- 8תכנון שירות וידאו: העלאה, Transcoding ו־Streamingלתכנן שירות וידאו מהעלאה ישירה ל־Object storage, דרך Pipeline של Transcoding ועד הזרמה אדפטיבית מ־CDN.כ־40 דק׳
עקביות תחת לחץ וסימולציות ראיון4 שיעורים • 2 שע׳ 25 דק׳
- 9תכנון מערכת הזמנת כרטיסיםלתכנן מערכת כרטיסים שמונעת מכירה כפולה של מושב בזמן עומס שיא, כולל החזקה זמנית ותשלום Idempotent.כ־35 דק׳
- 10סימולציית ראיון 1: Leaderboard בזמן אמתלהוביל בעצמך ראיון מלא על Leaderboard למשחק, בתקציב זמן, ולקבל משוב לפי מחוון ההערכה.כ־40 דק׳
- 11סימולציית ראיון 2: סנכרון קבצים בענןלהוביל ראיון מלא על שירות סנכרון קבצים, כולל עדכוני Delta וקונפליקטים, ולשפר את מה שזוהה בסימולציה הראשונה.כ־40 דק׳
- 12סיכום: טעויות נפוצות ורשימת בדיקה ליום הראיוןלזהות את הטעויות הנפוצות בראיונות, להפעיל רשימת בדיקה אישית ולהתאושש כשנתקעים באמצע.כ־30 דק׳
מה צריך
- אין צורך בידע קודם ברמת המתחילים
- היכרות בסיסית עם תכנות או עם אתרים תעזור, אבל היא לא חובה
- מחשב, טאבלט או טלפון עם מיקרופון, ודפדפן
על הקורס
קורס בארבע רמות: מתחילים, ממשיכים, מתקדמים והכנה לראיון. מתחילים משרת ומסד נתונים אחד, ממשיכים ל־Load Balancer, Cache, שכפול ותורים, עוברים למערכות מבוזרות ולתכנון מערכות מוכרות, ומסיימים בסימולציות ראיון. כל החלטה מנומקת במספרים, ופותרים יחד על לוח משותף.
למי הקורס
- מפתחים ומפתחות שנערכים לראיון System Design
- מי שרוצה להבין איך מערכות גדולות בנויות ולמה כל רכיב נמצא שם
- מי שעובדים עם קוד ורוצים לעבור מכתיבת פיצ'רים לתכנון מערכת שלמה
מבחנים והסמכות
- ראיון System Design
- מתחילים: ראיון System Design
- ממשיכים: ראיון System Design
- הכנה למבחן: ראיון System Design
קורסים נוספים במסלול
המורה שלך
נועםמורה AI פרטי, בשיעור חי על לוח משותףמורה AI פרטי שמלמד בשיחה חיה: שואל, מקשיב, מצייר על הלוח ונותן לפתור לבד עם רמזים. זוכר מה למדתם ומתחיל כל שיעור מהמקום שעצרתם.
איך נראה שיעור?
הילד מדבר עם המורה בקול, כמו בשיחת וידאו, ושואל מה שלא ברור.
המורה מסביר, כותב ומצייר על לוח משותף, והילד פותר איתו על אותו לוח.
אפשר לצלם דף עבודה או שיעורי בית וללמוד ממנו, תרגיל אחרי תרגיל.
ההורה מקבל דוח: זמן לימוד, מה הצליח ומה כדאי לחזק.
כללי השיעור
- רק לימוד
שאלות נפוצות
- איך עובד שיעור פרטי בתכנון מערכות (System Design)?
- בוחרים תכנון מערכות (System Design) ורמה, ומדברים עם המורה בקול. המורה שואל מה כבר ידוע, מסביר, כותב ומצייר על הלוח, ונותן לפתור לבד עם רמזים עד שהעניין ברור.
- כמה זמן לוקח הקורס תכנון מערכות (System Design)?
- 12 שיעורים של כ־32 דקות ברמה הראשונה, בקצב שלך. אפשר לעצור, לחזור ולדלג על מה שכבר ידוע.
- צריך ידע קודם?
- לא ברמת המתחילים. בתחילת השיעור הראשון המורה בודק מה כבר ידוע ומתאים את הרמה, ואפשר להתחיל ישר מרמה מתקדמת.
- איך מתחילים בחינם?
- נכנסים עם חשבון Google או עם קוד שנשלח למייל, כותבים שם וכיתה של הילד, והשיעור מתחיל מיד. כל משפחה מקבלת 45 דקות שיעור חינם, בכל מקצוע, לפי זמן השיעור בפועל, בלי כרטיס אשראי. אחר כך בוחרים מנוי בתשלום, ומבטלים בכל עת.
- על איזה מכשיר לומדים?
- בכל מחשב, טאבלט או טלפון עם דפדפן ומיקרופון. אפשר גם להתקין את האתר כאפליקציה במסך הבית.
רוצים לנסות?
נכנסים, כותבים שם וכיתה של הילד, והשיעור מתחיל. 45 דקות שיעור חינם, בלי כרטיס אשראי.
להתחיל בחינםשיעור פרטי עם AI: מה זה ואיך זה עובד







