Advanced

Tutor model

i62 💰:9.4

i52 💰:7.9

🏆 i67 💰:62.5

i70 💰:125.0

i68 💰:125.0

🏆 i66 💰:75.0

i65 💰:125.0

i63 💰:62.5

i61 💰:75.0

i60 💰:9.4

i60 💰:37.5

i58 💰:62.5

i57 💰:22.5

i57 💰:37.5

i56 💰:45.0

⚡ i55 💰:11.25

i55 💰:37.5

i54 💰:62.5

i52 💰:35.0

i51 💰:37.5

i49 💰:15.0

i49 💰:62.5

i48 💰:11.3

i47 💰:7.5

i44 💰:25.0

i43 💰:37.5

i42 💰:187.5

i40 💰:5.0

i39 💰:100.0

i38 💰:37.5

i37 💰:11.0

i36 💰:187.5

i34 💰:12.5

i33 💰:37.5

i30 💰:1.0

i29 💰:1.5

i28 💰:150.0

i23 💰:20.0

i20 💰:4.0

i18 💰:1.0

i16 💰:25.0

i13 💰:1.5

Keep session private

What would you like to learn?

Override for the tutor's lesson content generation calls. Auto uses the system default (Claude Sonnet 5 for lesson text, Opus 5 for diagrams).

Lesson generation model

System default

i58 💰:18.8

i31 💰:11.0

i25 💰:31.3

Tutoring abilities

An amplifier that sounds crystal clear at $1\text{ kHz}$ might completely muffle higher frequencies or lose power entirely. Why does an op-amp's amplification change when frequency climbs?

In the 1930s at Bell Labs, engineer Hendrik Wade Bode developed a simple graphical method to visualize this exact behavior across massive frequency ranges without complex calculations.

How do we compress a frequency span from $1\text{ Hz}$ to $10\text{ MHz}$ onto a single sheet of paper?

We measure voltage gain in **decibels** ($\text{dB}$), which converts raw voltage ratios into a logarithmic scale: $A_{\text{dB}} = 20 \log_{10}(A_v)$.

A **decade** represents a $10\times$ increase in frequency, while an **octave** represents a $2\times$ doubling of frequency.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Gain to Decibels & Frequency Decades</title>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      user-select: none;
      -webkit-user-select: none;
    }

    body {
      background-color: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      gap: 12px;
      min-height: 100%;
    }

    .header-bar {
      display: flex;
      justify-content: space-between;
      align-items: center;
      background: #ffffff;
      padding: 8px 14px;
      border-radius: 8px;
      border: 1px solid #e2e8f0;
    }

    .formula-tag {
      font-size: 14px;
      font-weight: 700;
      color: #1e2945;
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .formula-tag span {
      color: #0284c7;
      background: #e0f2fe;
      padding: 2px 8px;
      border-radius: 4px;
      font-family: "Courier New", monospace;
    }

    .badge-rule {
      font-size: 13px;
      font-weight: 600;
      color: #0369a1;
      background: #f0f9ff;
      border: 1px solid #bae6fd;
      padding: 3px 8px;
      border-radius: 6px;
    }

    /* Main split layout */
    .main-grid {
      display: grid;
      grid-template-columns: 1fr;
      gap: 12px;
    }

    @media (min-width: 540px) {
      .main-grid {
        grid-template-columns: 1.1fr 1fr;
      }
    }

    /* Left panel: Gain to dB conversion */
    .panel {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 12px;
      display: flex;
      flex-direction: column;
      gap: 6px;
    }

    .panel-title {
      font-size: 12px;
      font-weight: 700;
      text-transform: uppercase;
      letter-spacing: 0.5px;
      color: #64748b;
      margin-bottom: 2px;
      display: flex;
      justify-content: space-between;
    }

    .gain-list {
      display: flex;
      flex-direction: column;
      gap: 5px;
      position: relative;
    }

    .gain-row {
      display: grid;
      grid-template-columns: 1fr 32px 1fr;
      align-items: center;
      padding: 6px 10px;
      border-radius: 6px;
      background: #f8fafc;
      border: 1px solid rgba(0,0,0,0);
      cursor: pointer;
      transition: background 0.2s, box-shadow 0.2s;
    }

    .gain-row:hover {
      background: #f1f5f9;
    }

    .gain-row.active {
      background: #e0f2fe;
      box-shadow: 0 0 0 1.5px #22b7ff;
    }

    .gain-val {
      font-size: 14px;
      font-weight: 700;
      color: #1e2945;
    }

    .gain-val small {
      font-size: 11px;
      font-weight: 500;
      color: #64748b;
      margin-left: 2px;
    }

    .arrow-icon {
      text-align: center;
      color: #94a3b8;
      font-size: 13px;
    }

    .gain-row.active .arrow-icon {
      color: #0284c7;
    }

    .db-val {
      font-size: 14px;
      font-weight: 800;
      color: #0284c7;
      text-align: right;
    }

    .decade-jump {
      font-size: 10px;
      font-weight: 700;
      color: #0369a1;
      background: #e0f2fe;
      border-radius: 4px;
      padding: 1px 4px;
      display: inline-block;
      margin-left: 4px;
    }

    /* Right panel: Decade axis visualizer */
    .freq-container {
      display: flex;
      flex-direction: column;
      justify-content: space-between;
      height: 100%;
    }

    .axis-wrapper {
      position: relative;
      margin: 15px 4px 10px 4px;
    }

    .axis-line {
      height: 3px;
      background: #cbd5e1;
      border-radius: 2px;
      position: relative;
      margin: 25px 0 15px 0;
    }

    .ticks-container {
      position: relative;
      display: flex;
      justify-content: space-between;
      margin-top: -8px;
    }

    .tick-node {
      display: flex;
      flex-direction: column;
      align-items: center;
      cursor: pointer;
      position: relative;
      z-index: 2;
    }

    .tick-dot {
      width: 13px;
      height: 13px;
      background: #ffffff;
      border: 3px solid #64748b;
      border-radius: 50%;
      transition: border-color 0.2s, background 0.2s;
    }

    .tick-node.active .tick-dot {
      border-color: #22b7ff;
      background: #0284c7;
      box-shadow: 0 0 0 3px rgba(34, 183, 255, 0.25);
    }

    .tick-label {
      margin-top: 6px;
      font-size: 11px;
      font-weight: 700;
      color: #1e2945;
      white-space: nowrap;
    }

    .tick-node.active .tick-label {
      color: #0284c7;
    }

    .decade-span-track {
      position: relative;
      height: 22px;
      margin-top: 4px;
    }

    .decade-arc {
      position: absolute;
      top: 0;
      height: 16px;
      border-top: 2px dashed #38bdf8;
      border-left: 2px solid #38bdf8;
      border-right: 2px solid #38bdf8;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 11px;
      font-weight: 700;
      color: #0284c7;
      transition: all 0.25s ease;
      opacity: 0.35;
    }

    .decade-arc.highlight {
      opacity: 1;
      border-top-style: solid;
      background: rgba(224, 242, 254, 0.4);
    }

    .insight-card {
      margin-top: auto;
      background: #f8fafc;
      border: 1px dashed #cbd5e1;
      border-radius: 8px;
      padding: 8px 10px;
      font-size: 12px;
      line-height: 1.4;
      color: #334155;
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .insight-card strong {
      color: #1e2945;
    }
  </style>
</head>
<body>

  
  <div class="header-bar">
    <div class="formula-tag">
      Gain in dB: <span>20 log₁₀(Aᵥ)</span>
    </div>
    <div class="badge-rule">
      ×10 Gain = +20 dB
    </div>
  </div>

  <div class="main-grid">
    
    <div class="panel">
      <div class="panel-title">
        <span>Voltage Gain (Aᵥ)</span>
        <span>Decibels (dB)</span>
      </div>
      
      <div class="gain-list" id="gainList">
        <div class="gain-row" data-idx="0" onclick="selectStep(0)">
          <div class="gain-val">1× <small>(Unity)</small></div>
          <div class="arrow-icon">→</div>
          <div class="db-val">0 dB</div>
        </div>

        <div class="gain-row" data-idx="1" onclick="selectStep(1)">
          <div class="gain-val">2× <small>(Double)</small></div>
          <div class="arrow-icon">→</div>
          <div class="db-val">+6 dB</div>
        </div>

        <div class="gain-row active" data-idx="2" onclick="selectStep(2)">
          <div class="gain-val">10× <span class="decade-jump">×10</span></div>
          <div class="arrow-icon">→</div>
          <div class="db-val">+20 dB</div>
        </div>

        <div class="gain-row" data-idx="3" onclick="selectStep(3)">
          <div class="gain-val">100× <span class="decade-jump">×10</span></div>
          <div class="arrow-icon">→</div>
          <div class="db-val">+40 dB</div>
        </div>

        <div class="gain-row" data-idx="4" onclick="selectStep(4)">
          <div class="gain-val">1000× <span class="decade-jump">×10</span></div>
          <div class="arrow-icon">→</div>
          <div class="db-val">+60 dB</div>
        </div>
      </div>
    </div>

    
    <div class="panel">
      <div class="panel-title">
        <span>Log Frequency Axis</span>
        <span>5 Decades</span>
      </div>

      <div class="freq-container">
        <div class="axis-wrapper">
          
          <div class="decade-span-track">
            <div class="decade-arc" id="arc1" style="left: 0%; width: 20%;">×10</div>
            <div class="decade-arc highlight" id="arc2" style="left: 20%; width: 20%;">×10</div>
            <div class="decade-arc" id="arc3" style="left: 40%; width: 20%;">×10</div>
            <div class="decade-arc" id="arc4" style="left: 60%; width: 20%;">×10</div>
            <div class="decade-arc" id="arc5" style="left: 80%; width: 20%;">×10</div>
          </div>

          
          <div class="axis-line"></div>
          
          <div class="ticks-container" id="ticksContainer">
            <div class="tick-node" data-f="0" onclick="selectFreq(0)">
              <div class="tick-dot"></div>
              <div class="tick-label">10 Hz</div>
            </div>
            <div class="tick-node" data-f="1" onclick="selectFreq(1)">
              <div class="tick-dot"></div>
              <div class="tick-label">100 Hz</div>
            </div>
            <div class="tick-node active" data-f="2" onclick="selectFreq(2)">
              <div class="tick-dot"></div>
              <div class="tick-label">1 kHz</div>
            </div>
            <div class="tick-node" data-f="3" onclick="selectFreq(3)">
              <div class="tick-dot"></div>
              <div class="tick-label">10 kHz</div>
            </div>
            <div class="tick-node" data-f="4" onclick="selectFreq(4)">
              <div class="tick-dot"></div>
              <div class="tick-label">100 kHz</div>
            </div>
            <div class="tick-node" data-f="5" onclick="selectFreq(5)">
              <div class="tick-dot"></div>
              <div class="tick-label">1 MHz</div>
            </div>
          </div>
        </div>

        <div class="insight-card" id="insightBox">
          <span style="font-size: 15px;">✦</span>
          <span id="insightText"><strong>10× voltage gain</strong> adds exactly <strong>+20 dB</strong> per decade step.</span>
        </div>
      </div>
    </div>
  </div>

  <script>
    const explanations = [
      "<strong>Unity gain (1×)</strong> equals <strong>0 dB</strong> (no amplification or loss).",
      "<strong>Doubling voltage (2×)</strong> adds approximately <strong>+6 dB</strong>.",
      "<strong>10× voltage gain</strong> adds exactly <strong>+20 dB</strong> (1 decade of gain).",
      "<strong>100× voltage gain</strong> equals <strong>+40 dB</strong> (+20 dB + 20 dB).",
      "<strong>1000× voltage gain</strong> equals <strong>+60 dB</strong> (+20 dB × 3 decades)."
    ];

    function selectStep(idx) {
      const rows = document.querySelectorAll('.gain-row');
      rows.forEach((r, i) => {
        r.classList.toggle('active', i === idx);
      });

      document.getElementById('insightText').innerHTML = explanations[idx];

      // Highlight matching frequency decade interval
      const arcs = document.querySelectorAll('.decade-arc');
      arcs.forEach((arc, i) => {
        arc.classList.toggle('highlight', i === Math.min(idx, 4));
      });

      const ticks = document.querySelectorAll('.tick-node');
      ticks.forEach((t, i) => {
        t.classList.toggle('active', i === Math.min(idx + 1, 5));
      });
    }

    function selectFreq(idx) {
      const ticks = document.querySelectorAll('.tick-node');
      ticks.forEach((t, i) => {
        t.classList.toggle('active', i === idx);
      });

      const arcs = document.querySelectorAll('.decade-arc');
      arcs.forEach((arc, i) => {
        arc.classList.toggle('highlight', i === Math.max(0, idx - 1));
      });

      const gainIdx = Math.min(Math.max(idx - 1, 0), 4);
      const rows = document.querySelectorAll('.gain-row');
      rows.forEach((r, i) => {
        r.classList.toggle('active', i === gainIdx);
      });

      const freqLabels = ["10 Hz", "100 Hz", "1 kHz", "10 kHz", "100 kHz", "1 MHz"];
      document.getElementById('insightText').innerHTML = 
        `Frequency tick <strong>${freqLabels[idx]}</strong> is spaced logarithmically by factor of 10.`;
    }
  </script>
</body>
</html>

What sets the limit on how fast our amplifier can operate before its gain begins to drop?

Standard op-amps have an internal compensation capacitor that enforces a constant **Gain-Bandwidth Product** ($f_T$ or $\text{GBWP}$).

The closed-loop **corner frequency** ($f_c$), also called the **-3dB bandwidth**, is calculated using the formula $f_c = \frac{f_T}{|A_{CL}|}$, where $A_{CL}$ is your circuit's midband gain.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Gain-Bandwidth Product Tradeoff</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      color: #1e2945;
      background: #ffffff;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      padding: 12px 10px;
      min-height: 100%;
      user-select: none;
    }

    /* Top Constant Badge */
    .constant-bar {
      display: flex;
      align-items: center;
      gap: 6px;
      background: #f1f5f9;
      padding: 6px 14px;
      border-radius: 20px;
      font-size: 14px;
      font-weight: 700;
      letter-spacing: -0.2px;
    }
    .gain-txt { color: #0284c7; }
    .bw-txt { color: #059669; }

    /* Seesaw Stage */
    .stage {
      position: relative;
      width: 100%;
      max-width: 440px;
      height: 180px;
      margin: 8px 0;
      display: flex;
      align-items: center;
      justify-content: center;
    }
    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
    }

    /* Switcher Controls */
    .controls {
      display: flex;
      gap: 10px;
      width: 100%;
      max-width: 440px;
    }
    .preset-btn {
      flex: 1;
      display: flex;
      flex-direction: column;
      align-items: center;
      padding: 8px 6px;
      background: #f8fafc;
      border: 2px solid #e2e8f0;
      border-radius: 10px;
      cursor: pointer;
      transition: all 0.25s ease;
      text-align: center;
    }
    .preset-btn.active {
      border-color: #22b7ff;
      background: #f0f9ff;
      box-shadow: 0 2px 8px rgba(34, 183, 255, 0.18);
    }
    .btn-title {
      font-size: 13px;
      font-weight: 700;
      color: #1e2945;
      margin-bottom: 2px;
    }
    .btn-metrics {
      display: flex;
      gap: 8px;
      font-size: 12px;
      font-weight: 600;
    }

    /* Seesaw Animation Transitions */
    .seesaw-plank {
      transform-origin: 200px 110px;
      transition: transform 0.5s cubic-bezier(0.34, 1.3, 0.64, 1);
    }
    .left-mass, .right-mass {
      transition: transform 0.5s cubic-bezier(0.34, 1.3, 0.64, 1), height 0.5s ease, y 0.5s ease;
    }
  </style>
</head>
<body>

  
  <div class="constant-bar">
    <span class="gain-txt">Gain (A<sub>CL</sub>)</span>
    <span>×</span>
    <span class="bw-txt">Bandwidth (f<sub>c</sub>)</span>
    <span>=</span>
    <span>1 MHz</span>
  </div>

  
  <div class="stage">
    <svg viewBox="0 0 400 180">
      <defs>
        <filter id="shadow" x="-8%" y="-8%" width="116%" height="120%">
          <feDropShadow dx="0" dy="3" stdDeviation="2" flood-color="#0f172a" flood-opacity="0.08" />
        </filter>
      </defs>

      
      <polygon points="200,105 182,148 218,148" fill="#64748b" />
      <circle cx="200" cy="110" r="5" fill="#334155" />
      
      <line x1="30" y1="148" x2="370" y2="148" stroke="#cbd5e1" stroke-width="3" stroke-linecap="round" />

      
      <g id="plankGroup" class="seesaw-plank" transform="rotate(-11 200 110)">
        
        <rect x="40" y="106" width="320" height="8" rx="4" fill="#334155" />

        
        <g id="gainGroup" transform="translate(60, 0)">
          <rect id="gainRect" x="-32" y="36" width="64" height="70" rx="8" fill="#22b7ff" filter="url(#shadow)" />
          <text id="gainVal" x="0" y="66" fill="#ffffff" font-size="16" font-weight="bold" text-anchor="middle">×10</text>
          <text id="gainDb" x="0" y="86" fill="#e0f2fe" font-size="11" font-weight="600" text-anchor="middle">20 dB</text>
          <text x="0" y="24" fill="#0284c7" font-size="12" font-weight="700" text-anchor="middle">GAIN</text>
        </g>

        
        <g id="bwGroup" transform="translate(340, 0)">
          <rect id="bwRect" x="-36" y="6" width="72" height="100" rx="8" fill="#10b981" filter="url(#shadow)" />
          <text id="bwVal" x="0" y="52" fill="#ffffff" font-size="15" font-weight="bold" text-anchor="middle">100 kHz</text>
          <text x="0" y="-6" fill="#059669" font-size="12" font-weight="700" text-anchor="middle">BANDWIDTH</text>
        </g>
      </g>
    </svg>
  </div>

  
  <div class="controls">
    <button id="btnA" class="preset-btn active" onclick="setPreset('A')">
      <span class="btn-title">Amplifier A</span>
      <div class="btn-metrics">
        <span class="gain-txt">×10</span>
        <span>•</span>
        <span class="bw-txt">100 kHz</span>
      </div>
    </button>

    <button id="btnB" class="preset-btn" onclick="setPreset('B')">
      <span class="btn-title">Amplifier B</span>
      <div class="btn-metrics">
        <span class="gain-txt">×100</span>
        <span>•</span>
        <span class="bw-txt">10 kHz</span>
      </div>
    </button>
  </div>

  <script>
    const plank = document.getElementById('plankGroup');
    const gainRect = document.getElementById('gainRect');
    const gainVal = document.getElementById('gainVal');
    const gainDb = document.getElementById('gainDb');
    const bwRect = document.getElementById('bwRect');
    const bwVal = document.getElementById('bwVal');
    const btnA = document.getElementById('btnA');
    const btnB = document.getElementById('btnB');

    let currentMode = 'A';

    function setPreset(mode) {
      currentMode = mode;
      if (mode === 'A') {
        // Amp A: Low Gain (10), High Bandwidth (100kHz) -> Right side heavy
        btnA.classList.add('active');
        btnB.classList.remove('active');
        plank.style.transform = 'rotate(-11deg)';

        gainRect.setAttribute('y', '46');
        gainRect.setAttribute('height', '60');
        gainVal.setAttribute('y', '74');
        gainVal.textContent = '×10';
        gainDb.setAttribute('y', '92');
        gainDb.textContent = '20 dB';

        bwRect.setAttribute('y', '6');
        bwRect.setAttribute('height', '100');
        bwVal.setAttribute('y', '58');
        bwVal.textContent = '100 kHz';
      } else {
        // Amp B: High Gain (100), Low Bandwidth (10kHz) -> Left side heavy
        btnB.classList.add('active');
        btnA.classList.remove('active');
        plank.style.transform = 'rotate(11deg)';

        gainRect.setAttribute('y', '6');
        gainRect.setAttribute('height', '100');
        gainVal.setAttribute('y', '54');
        gainVal.textContent = '×100';
        gainDb.setAttribute('y', '74');
        gainDb.textContent = '40 dB';

        bwRect.setAttribute('y', '56');
        bwRect.setAttribute('height', '50');
        bwVal.setAttribute('y', '87');
        bwVal.textContent = '10 kHz';
      }
    }

    // Calm auto-toggle every 4s to demonstrate the tradeoff
    let timer = setInterval(() => {
      setPreset(currentMode === 'A' ? 'B' : 'A');
    }, 4000);

    // Pause auto-rotation on user click
    [btnA, btnB].forEach(btn => {
      btn.addEventListener('click', () => {
        clearInterval(timer);
      });
    });
  </script>
</body>
</html>

What does this response look like when we sketch it as a Bode plot?

An **asymptotic Bode plot** simplifies the real frequency response into two straight line segments that meet at the corner frequency.

The **midband region** is a flat horizontal line at $A_{\text{mid(dB)}}$, while the **roll-off region** drops steeply at a slope of $-20\text{ dB/decade}$ (or $-6\text{ dB/octave}$).

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      color: #1e2945;
      background: transparent;
      padding: 8px 12px;
      user-select: none;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      min-height: 100%;
    }

    .toolbar {
      display: flex;
      gap: 8px;
      margin-bottom: 8px;
      flex-wrap: wrap;
      justify-content: center;
    }

    .btn {
      background: #f1f5f9;
      border: 1px solid #cbd5e1;
      color: #1e2945;
      padding: 6px 12px;
      font-size: 13px;
      font-weight: 600;
      border-radius: 6px;
      cursor: pointer;
      transition: background 0.15s ease, border-color 0.15s ease, color 0.15s ease;
    }
    .btn:hover {
      background: #e2e8f0;
      border-color: #94a3b8;
    }
    .btn.active {
      background: #0284c7;
      color: #ffffff;
      border-color: #0369a1;
    }

    .plot-container {
      position: relative;
      width: 100%;
      max-width: 580px;
      aspect-ratio: 16/10;
    }

    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
      display: block;
    }

    .grid-line {
      stroke: #e2e8f0;
      stroke-width: 1;
    }
    .grid-line-major {
      stroke: #cbd5e1;
      stroke-width: 1.2;
    }
    .axis-line {
      stroke: #64748b;
      stroke-width: 1.5;
    }
    .tick-label {
      font-size: 11px;
      fill: #64748b;
      font-weight: 500;
    }
    .axis-title {
      font-size: 12px;
      fill: #334155;
      font-weight: 700;
    }

    .asymptote-line {
      stroke: #22b7ff;
      stroke-width: 2.5;
      stroke-dasharray: 6,4;
      fill: none;
    }
    .actual-line {
      stroke: #1e2945;
      stroke-width: 2.5;
      fill: none;
    }

    .slope-label {
      font-size: 11px;
      font-weight: 700;
      fill: #0284c7;
    }

    .badge {
      background: #ffffff;
      border: 1.5px solid #22b7ff;
      border-radius: 6px;
      padding: 4px 8px;
      font-size: 11px;
      font-weight: 700;
      color: #1e2945;
      box-shadow: 0 2px 6px rgba(0,0,0,0.08);
      white-space: nowrap;
      display: inline-block;
    }

    .legend {
      display: flex;
      gap: 16px;
      margin-top: 6px;
      font-size: 12px;
      font-weight: 600;
      flex-wrap: wrap;
      justify-content: center;
    }
    .legend-item {
      display: flex;
      align-items: center;
      gap: 6px;
    }
    .legend-dash {
      width: 18px;
      height: 0;
      border-top: 2.5px dashed #22b7ff;
    }
    .legend-solid {
      width: 18px;
      height: 2.5px;
      background: #1e2945;
    }

    .readout {
      margin-top: 6px;
      font-size: 13px;
      font-weight: 600;
      color: #1e2945;
      text-align: center;
      min-height: 20px;
    }
  </style>
</head>
<body>

  <div class="toolbar">
    <button class="btn active" id="btn-fc" onclick="setFreq(100000)">f<sub>c</sub> (100 kHz)</button>
    <button class="btn" id="btn-pass" onclick="setFreq(10000)">Passband (10 kHz)</button>
    <button class="btn" id="btn-unity" onclick="setFreq(1000000)">Unity (1 MHz)</button>
  </div>

  <div class="plot-container">
    <svg id="plot" viewBox="0 0 540 330">
      
      <g id="grid"></g>
      
      
      <text x="45" y="18" text-anchor="start" class="axis-title">Gain (dB)</text>
      <text x="280" y="318" text-anchor="middle" class="axis-title">Frequency (Hz)</text>

      
      <path id="asymptote" class="asymptote-line" />
      <path id="actual" class="actual-line" />

      
      <g transform="translate(390, 218) rotate(48)">
        <rect x="-4" y="-12" width="94" height="16" fill="#f8fafc" rx="3" opacity="0.9" />
        <text x="0" y="0" class="slope-label">−20 dB/decade</text>
      </g>

      
      <g id="fc-marker">
        <line id="diff-line" stroke="#ef4444" stroke-width="2" stroke-dasharray="2,2" />
        <circle id="asymp-dot" r="4" fill="#22b7ff" />
        <circle id="actual-dot" r="5" fill="#1e2945" stroke="#ffffff" stroke-width="1.5" />
      </g>

      
      <g id="probe" style="display:none;">
        <line id="probe-v" stroke="#94a3b8" stroke-width="1" stroke-dasharray="3,3" />
        <circle id="probe-dot" r="5" fill="#0284c7" stroke="#ffffff" stroke-width="2" />
      </g>

      
      <foreignObject id="badge-obj" x="180" y="110" width="165" height="36">
        <div xmlns="http://www.w3.org/1999/xhtml" class="badge">
          −3 dB at f<sub>c</sub> (17 dB)
        </div>
      </foreignObject>
    </svg>
  </div>

  <div class="legend">
    <div class="legend-item"><div class="legend-dash"></div> Asymptotic Approximation</div>
    <div class="legend-item"><div class="legend-solid"></div> True Physical Curve</div>
  </div>

  <div class="readout" id="readout">f = 100 kHz | True Gain = 17.0 dB (Asymptotic: 20.0 dB)</div>

  <script>
    const padL = 45, padR = 25, padT = 30, padB = 60;
    const W = 540, H = 330;
    const plotW = W - padL - padR;
    const plotH = H - padT - padB;

    const minLog = 2; // 100 Hz = 10^2
    const maxLog = 7; // 10 MHz = 10^7
    const minDb = 0;
    const maxDb = 40;

    function xFromFreq(f) {
      const logF = Math.log10(f);
      return padL + ((logF - minLog) / (maxLog - minLog)) * plotW;
    }

    function yFromDb(db) {
      return padT + ((maxDb - db) / (maxDb - minDb)) * plotH;
    }

    function exactGain(f) {
      const A0 = 10; // 20 dB
      const fc = 100000; // 100 kHz
      const ratio = f / fc;
      const mag = A0 / Math.sqrt(1 + ratio * ratio);
      return 20 * Math.log10(mag);
    }

    function asympGain(f) {
      const fc = 100000;
      if (f <= fc) return 20;
      return 20 - 20 * Math.log10(f / fc);
    }

    // Build Grid
    const gridG = document.getElementById('grid');
    
    // Y Ticks (0, 10, 20, 30, 40 dB)
    for (let db = minDb; db <= maxDb; db += 10) {
      const y = yFromDb(db);
      const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
      line.setAttribute('x1', padL);
      line.setAttribute('x2', W - padR);
      line.setAttribute('y1', y);
      line.setAttribute('y2', y);
      line.setAttribute('class', db === 0 ? 'axis-line' : 'grid-line-major');
      gridG.appendChild(line);

      const txt = document.createElementNS('http://www.w3.org/2000/svg', 'text');
      txt.setAttribute('x', padL - 8);
      txt.setAttribute('y', y + 4);
      txt.setAttribute('text-anchor', 'end');
      txt.setAttribute('class', 'tick-label');
      txt.textContent = db;
      gridG.appendChild(txt);
    }

    // X Decades & Minor Ticks
    const freqLabels = { 2: '100', 3: '1k', 4: '10k', 5: '100k', 6: '1M', 7: '10M' };
    for (let d = minLog; d <= maxLog; d++) {
      const f = Math.pow(10, d);
      const x = xFromFreq(f);

      // Major line
      const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
      line.setAttribute('x1', x);
      line.setAttribute('x2', x);
      line.setAttribute('y1', padT);
      line.setAttribute('y2', H - padB);
      line.setAttribute('class', 'grid-line-major');
      gridG.appendChild(line);

      // Major Tick Label
      const txt = document.createElementNS('http://www.w3.org/2000/svg', 'text');
      txt.setAttribute('x', x);
      txt.setAttribute('y', H - padB + 18);
      txt.setAttribute('text-anchor', 'middle');
      txt.setAttribute('class', 'tick-label');
      txt.textContent = freqLabels[d];
      gridG.appendChild(txt);

      // Minor log lines
      if (d < maxLog) {
        for (let m = 2; m <= 9; m++) {
          const subF = m * f;
          const subX = xFromFreq(subF);
          const subLine = document.createElementNS('http://www.w3.org/2000/svg', 'line');
          subLine.setAttribute('x1', subX);
          subLine.setAttribute('x2', subX);
          subLine.setAttribute('y1', padT);
          subLine.setAttribute('y2', H - padB);
          subLine.setAttribute('class', 'grid-line');
          gridG.appendChild(subLine);
        }
      }
    }

    // Generate Asymptote Path
    const xStart = xFromFreq(100);
    const xFc = xFromFreq(100000);
    const x1M = xFromFreq(1000000);
    const y20 = yFromDb(20);
    const y0 = yFromDb(0);
    const asympD = `M ${xStart} ${y20} L ${xFc} ${y20} L ${x1M} ${y0}`;
    document.getElementById('asymptote').setAttribute('d', asympD);

    // Generate True Curve Path
    let actualD = '';
    const steps = 150;
    for (let i = 0; i <= steps; i++) {
      const logVal = minLog + (i / steps) * (maxLog - minLog);
      const f = Math.pow(10, logVal);
      const gain = exactGain(f);
      const x = xFromFreq(f);
      const y = yFromDb(gain);
      if (gain >= 0) {
        actualD += (i === 0 ? 'M ' : 'L ') + x.toFixed(1) + ' ' + y.toFixed(1) + ' ';
      }
    }
    document.getElementById('actual').setAttribute('d', actualD);

    // Update fc marker graphics
    const yExactFc = yFromDb(exactGain(100000));
    const diffLine = document.getElementById('diff-line');
    diffLine.setAttribute('x1', xFc);
    diffLine.setAttribute('x2', xFc);
    diffLine.setAttribute('y1', y20);
    diffLine.setAttribute('y2', yExactFc);

    document.getElementById('asymp-dot').setAttribute('cx', xFc);
    document.getElementById('asymp-dot').setAttribute('cy', y20);
    document.getElementById('actual-dot').setAttribute('cx', xFc);
    document.getElementById('actual-dot').setAttribute('cy', yExactFc);

    // Place badge to the upper-left of fc marker
    const badge = document.getElementById('badge-obj');
    badge.setAttribute('x', xFc - 150);
    badge.setAttribute('y', y20 - 42);

    function formatFreq(f) {
      if (f >= 1000000) return (f / 1000000) + ' MHz';
      if (f >= 1000) return (f / 1000) + ' kHz';
      return f + ' Hz';
    }

    function setFreq(f) {
      document.querySelectorAll('.btn').forEach(b => b.classList.remove('active'));
      if (f === 100000) document.getElementById('btn-fc').classList.add('active');
      else if (f === 10000) document.getElementById('btn-pass').classList.add('active');
      else if (f === 1000000) document.getElementById('btn-unity').classList.add('active');

      const x = xFromFreq(f);
      const yAct = yFromDb(Math.max(0, exactGain(f)));

      const probe = document.getElementById('probe');
      probe.style.display = 'block';
      
      const pv = document.getElementById('probe-v');
      pv.setAttribute('x1', x);
      pv.setAttribute('x2', x);
      pv.setAttribute('y1', padT);
      pv.setAttribute('y2', H - padB);

      const pd = document.getElementById('probe-dot');
      pd.setAttribute('cx', x);
      pd.setAttribute('cy', yAct);

      const actG = exactGain(f).toFixed(1);
      const asyG = asympGain(f).toFixed(1);
      document.getElementById('readout').textContent = 
        `f = ${formatFreq(f)} | True Gain = ${actG} dB (Asymptotic: ${asyG} dB)`;
    }

    // Initial state
    setFreq(100000);
  </script>
</body>
</html>

Why does the slope roll off at exactly $-20\text{ dB/decade}$ instead of any other number?

For frequencies well above the corner frequency ($f \gg f_c$), the first-order transfer function magnitude simplifies from $|A(f)| = \frac{A_0}{\sqrt{1 + (f/f_c)^2}}$ directly to $|A(f)| \approx \frac{A_0}{f/f_c}$.

When frequency multiplies by $10$, the ratio drops by a factor of $10$, giving $20 \log_{10}(0.1) = -20\text{ dB}$ of gain reduction per decade.

How do we draw an accurate Bode plot for a practical amplifier circuit from scratch?

## Worked Example: Non-Inverting Amplifier

Suppose we build a non-inverting amplifier with $R_f = 90\text{ k}\Omega$ and $R_1 = 10\text{ k}\Omega$, using an op-amp with unity-gain bandwidth $f_T = 4\text{ MHz}$.

First, find the midband voltage gain: $A_v = 1 + \frac{R_f}{R_1} = 1 + \frac{90\text{ k}\Omega}{10\text{ k}\Omega} = 10$, which equals $20 \log_{10}(10) = 20\text{ dB}$.

Next, calculate the corner frequency: $f_c = \frac{f_T}{A_v} = \frac{4\text{ MHz}}{10} = 400\text{ kHz}$.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #ffffff;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
    }

    .step-nav {
      display: flex;
      gap: 6px;
      width: 100%;
      max-width: 540px;
      margin-bottom: 8px;
    }

    .step-btn {
      flex: 1;
      border: 1px solid #cbd5e1;
      background: #f8fafc;
      color: #475569;
      padding: 8px 4px;
      font-size: 13px;
      font-weight: 600;
      border-radius: 6px;
      cursor: pointer;
      text-align: center;
      transition: background 0.2s, color 0.2s, border-color 0.2s, box-shadow 0.2s;
    }

    .step-btn.active {
      background: #2563eb;
      color: #ffffff;
      border-color: #2563eb;
      box-shadow: 0 2px 6px rgba(37, 99, 235, 0.25);
    }

    .svg-container {
      width: 100%;
      max-width: 540px;
      aspect-ratio: 540 / 270;
      position: relative;
    }

    svg {
      width: 100%;
      height: 100%;
      display: block;
      overflow: visible;
    }

    .grid-minor { stroke: #f1f5f9; stroke-width: 1; }
    .grid-major { stroke: #e2e8f0; stroke-width: 1.2; }
    .axis-line { stroke: #64748b; stroke-width: 1.5; }
    .axis-text { font-size: 11px; fill: #64748b; font-weight: 500; font-family: monospace, system-ui; }
    .axis-title { font-size: 12px; fill: #334155; font-weight: 600; }

    /* Animated plot elements */
    .plot-element {
      transition: opacity 0.35s ease, stroke-dashoffset 0.5s ease;
    }

    .hidden { opacity: 0; pointer-events: none; }
    .visible { opacity: 1; }

    .line-midband {
      stroke: #2563eb;
      stroke-width: 3.5;
      stroke-linecap: round;
    }

    .line-rolloff {
      stroke: #ea580c;
      stroke-width: 3.5;
      stroke-linecap: round;
    }

    .guide-line {
      stroke: #94a3b8;
      stroke-width: 1.2;
      stroke-dasharray: 4, 3;
    }

    .badge-bg {
      fill: #ffffff;
      stroke-width: 1.5;
      filter: drop-shadow(0 1px 3px rgba(0,0,0,0.1));
    }
  </style>
</head>
<body>

  
  <div class="step-nav">
    <button class="step-btn active" id="btn1" onclick="setStep(1)">1. Midband</button>
    <button class="step-btn" id="btn2" onclick="setStep(2)">2. Corner Pole</button>
    <button class="step-btn" id="btn3" onclick="setStep(3)">3. Roll-off</button>
    <button class="step-btn" id="btn4" onclick="setStep(4)">Finished Plot</button>
  </div>

  <div class="svg-container">
    <svg viewBox="0 0 540 270" id="bodeSvg">
      
      <g id="gridMinorGroup"></g>
      <g id="gridMajorGroup"></g>

      
      <line x1="50" y1="210" x2="520" y2="210" class="axis-line" />
      <line x1="50" y1="20" x2="50" y2="210" class="axis-line" />

      
      <text x="42" y="214" text-anchor="end" class="axis-text">0</text>
      <text x="42" y="150" text-anchor="end" class="axis-text">10</text>
      <text x="42" y="86" text-anchor="end" class="axis-text">20</text>
      <text x="42" y="24" text-anchor="end" class="axis-text">30</text>
      <text x="16" y="115" text-anchor="middle" class="axis-title" transform="rotate(-90 16 115)">Gain (dB)</text>

      
      <text x="50" y="226" text-anchor="middle" class="axis-text">10</text>
      <text x="128" y="226" text-anchor="middle" class="axis-text">100</text>
      <text x="206" y="226" text-anchor="middle" class="axis-text">1k</text>
      <text x="285" y="226" text-anchor="middle" class="axis-text">10k</text>
      <text x="363" y="226" text-anchor="middle" class="axis-text">100k</text>
      <text x="441" y="226" text-anchor="middle" class="axis-text">1M</text>
      <text x="520" y="226" text-anchor="middle" class="axis-text">10M</text>
      <text x="285" y="245" text-anchor="middle" class="axis-title">Frequency (Hz)</text>

      
      
      <g id="step1Group" class="plot-element visible">
        <line x1="50" y1="83.33" x2="410.2" y2="83.33" class="line-midband" />
        <rect x="70" y="55" width="130" height="22" rx="4" class="badge-bg" stroke="#2563eb" />
        <text x="135" y="70" text-anchor="middle" fill="#2563eb" font-size="11" font-weight="700">Midband: 20 dB</text>
      </g>

      
      <g id="step2Group" class="plot-element hidden">
        <line x1="410.2" y1="83.33" x2="410.2" y2="210" class="guide-line" />
        <line x1="50" y1="83.33" x2="410.2" y2="83.33" class="guide-line" />
        <circle cx="410.2" cy="83.33" r="6" fill="#e11d48" stroke="#ffffff" stroke-width="2" />
        <rect x="335" y="32" width="150" height="22" rx="4" class="badge-bg" stroke="#e11d48" />
        <text x="410" y="47" text-anchor="middle" fill="#e11d48" font-size="11" font-weight="700">Pole: (400 kHz, 20 dB)</text>
      </g>

      
      
      <g id="step3Group" class="plot-element hidden">
        <line x1="410.2" y1="83.33" x2="488.5" y2="210" class="line-rolloff" />
        <line x1="488.5" y1="83.33" x2="488.5" y2="210" class="guide-line" />
        <circle cx="488.5" cy="210" r="5" fill="#ea580c" stroke="#ffffff" stroke-width="2" />
        
        
        <rect x="420" y="132" width="95" height="20" rx="4" class="badge-bg" stroke="#ea580c" />
        <text x="467.5" y="146" text-anchor="middle" fill="#ea580c" font-size="10" font-weight="700">-20 dB / decade</text>

        
        <rect x="415" y="248" width="115" height="18" rx="4" fill="#f8fafc" stroke="#64748b" stroke-width="1" />
        <text x="472.5" y="261" text-anchor="middle" fill="#334155" font-size="10" font-weight="600">(4 MHz, 0 dB)</text>
      </g>
    </svg>
  </div>

  <script>
    // Draw mathematically precise semilog grid lines
    const minFreqLog = 1; // 10^1 = 10 Hz
    const maxFreqLog = 7; // 10^7 = 10 MHz
    const plotLeft = 50;
    const plotRight = 520;
    const plotTop = 20;
    const plotBottom = 210;

    const xForFreq = (f) => {
      const logVal = Math.log10(f);
      return plotLeft + (plotRight - plotLeft) * ((logVal - minFreqLog) / (maxFreqLog - minFreqLog));
    };

    const minorGroup = document.getElementById('gridMinorGroup');
    const majorGroup = document.getElementById('gridMajorGroup');

    // Horizontal grid lines (0, 10, 20, 30 dB)
    [0, 10, 20, 30].forEach(db => {
      const y = plotBottom - (plotBottom - plotTop) * (db / 30);
      const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
      line.setAttribute('x1', plotLeft);
      line.setAttribute('y1', y);
      line.setAttribute('x2', plotRight);
      line.setAttribute('y2', y);
      line.setAttribute('class', 'grid-major');
      majorGroup.appendChild(line);
    });

    // Vertical semilog grid lines
    for (let d = 1; d < 7; d++) {
      const decadeBase = Math.pow(10, d);
      // Major decade line
      const xMajor = xForFreq(decadeBase);
      const majLine = document.createElementNS('http://www.w3.org/2000/svg', 'line');
      majLine.setAttribute('x1', xMajor);
      majLine.setAttribute('y1', plotTop);
      majLine.setAttribute('x2', xMajor);
      majLine.setAttribute('y2', plotBottom);
      majLine.setAttribute('class', 'grid-major');
      majorGroup.appendChild(majLine);

      // Minor log intervals (2 to 9)
      for (let k = 2; k <= 9; k++) {
        const xMinor = xForFreq(decadeBase * k);
        const minLine = document.createElementNS('http://www.w3.org/2000/svg', 'line');
        minLine.setAttribute('x1', xMinor);
        minLine.setAttribute('y1', plotTop);
        minLine.setAttribute('x2', xMinor);
        minLine.setAttribute('y2', plotBottom);
        minLine.setAttribute('class', 'grid-minor');
        minorGroup.appendChild(minLine);
      }
    }

    // Step state controller
    const s1 = document.getElementById('step1Group');
    const s2 = document.getElementById('step2Group');
    const s3 = document.getElementById('step3Group');
    const buttons = [
      document.getElementById('btn1'),
      document.getElementById('btn2'),
      document.getElementById('btn3'),
      document.getElementById('btn4')
    ];

    function setStep(step) {
      buttons.forEach((btn, idx) => {
        btn.classList.toggle('active', idx + 1 === step);
      });

      if (step === 1) {
        s1.setAttribute('class', 'plot-element visible');
        s2.setAttribute('class', 'plot-element hidden');
        s3.setAttribute('class', 'plot-element hidden');
      } else if (step === 2) {
        s1.setAttribute('class', 'plot-element visible');
        s2.setAttribute('class', 'plot-element visible');
        s3.setAttribute('class', 'plot-element hidden');
      } else if (step === 3) {
        s1.setAttribute('class', 'plot-element visible');
        s2.setAttribute('class', 'plot-element visible');
        s3.setAttribute('class', 'plot-element visible');
      } else if (step === 4) {
        s1.setAttribute('class', 'plot-element visible');
        s2.setAttribute('class', 'plot-element visible');
        s3.setAttribute('class', 'plot-element visible');
      }
    }
  </script>
</body>
</html>

A common mistake is forgetting that the straight-line asymptotic plot predicts $20\text{ dB}$ at $f_c$, but the real circuit outputs exactly $17\text{ dB}$ ($3\text{ dB}$ lower).

Whenever you test your design in the lab, always measure gain at $f_c$ to verify that $3\text{ dB}$ drop and confirm your circuit's true physical bandwidth.

electronics

Constructing Bode Plots for Closed-Loop Voltage Amplifiers. Plot and interpret asymptotic Bode magnitude diagrams showing midband gain, -3dB corner frequency, and the -20 dB/decade roll-off region for negative feedback amplifiers.

Operational Amplifier Frequency Response and Gain-Bandwidth Product

Op-Amp Practical Considerations: Gain-Bandwidth Product and Bode Plots

Op-amp Frequency Response, Bode Plots, and -3dB Bandwidth

When teaching ELEC-8.7 to Year 13 (A2 Level) students, emphasize the geometric nature of the Bode diagram plotted on semi-logarithmic axes. Guide students to connect the physical trade-off between amplification and bandwidth: higher feedback stabilizes the circuit and widens bandwidth at the direct expense of midband voltage gain. Scaffold the drawing process systematically into three steps: (1) calculate midband gain and convert to dB to draw the horizontal plateau; (2) calculate $f_c$ via $\text{GBWP} / A_{CL}$ to mark the corner; and (3) project a straight line down at $-20\text{ dB}$ per decade to the unity-gain frequency $f_T$.

Constructing Bode Plots for Closed-Loop Voltage Amplifiers

Decibels and Logarithmic Scales

The Gain-Bandwidth Tradeoff