Beam design complete guide covering RC steel timber and prestressed beams with Python code and software tools

Most beam design guides tell you what to calculate. This one tells you how to actually do it — in Python, with real numbers, across four beam types, with working code you can drop into your next project. We'll cover the engineering behind each check, show you what the output means, flag the common errors that fail peer review, and tell you which software to use and when.

A beam, at its core, resists two things: bending (flexure) and shear. Everything else — deflection, cracking, lateral torsional buckling, torsion — is a serviceability or stability check on top of that fundamental load path. Get those two right, verify the serviceability checks, and your beam works. The question is how efficiently and how repeatably.

1. Beam Types and When to Use Each

Comparison of RC beam steel I-beam prestressed beam and glulam timber beam types
Figure 1: Four main beam types — properties, typical spans, governing codes, pros and cons

The most expensive beam design mistake is choosing the wrong beam type for the application. Here's the decision logic engineers actually use:

ScenarioPreferred BeamReason
Residential floors, spans 4–10mRC beam or flat plateCost, fire resistance, no maintenance
Commercial floors, spans 8–18mSteel UB or composite beamSpeed of erection, span capability, lighter
Bridge deck, spans 20–40mPrestressed concreteLong spans, slim depth, crack-free service
Exposed roof structure, spans 6–16mGlulam (GLT)Aesthetic, low carbon, light
Industrial portal, spans 15–40mSteel fabricated plate girderSpan range, haunch efficiency, economy
Transfer beam, heavy point loadsRC or steel, deep sectionHigh shear and moment demands, rigidity

2. RC Beam Design: Full Python Worked Example (EC2)

RC beam design flowchart showing K-factor check bending reinforcement shear and deflection
Figure 2: RC Beam Design Flowchart — follow this sequence every time

This complete Python script designs a simply supported rectangular RC beam to Eurocode 2 (BS EN 1992-1-1) for bending, shear, and deflection. Every variable is named to match the code notation. Run it in any Python environment (Jupyter, VS Code, or paste into an online IDE like repl.it).

# ============================================================
# RC BEAM DESIGN TO EC2 (EN 1992-1-1)
# ============================================================
import math

# --- INPUTS ---
fck = 30 # Concrete char compressive strength (MPa)
fyk = 500 # Steel yield strength (MPa)
b = 300 # Beam width (mm)
d = 500 # Effective depth (mm) - cover + bar/2 deducted
h = 550 # Overall depth (mm)
L = 7.0 # Span (m)
M_Ed = 180e6 # Design bending moment M* at ULS (N.mm)
V_Ed = 120e3 # Design shear force V* at ULS (N)

# --- MATERIAL FACTORS ---
gamma_c = 1.5 # Concrete partial factor
gamma_s = 1.15 # Steel partial factor
fcd = fck / gamma_c # Design compressive strength
fyd = fyk / gamma_s # Design steel yield strength
alpha_cc = 0.85 # Long-term effects factor
fcd_eff = alpha_cc * fcd

# --- FLEXURAL DESIGN ---
K = M_Ed / (b * d**2 * fck) # K-factor (dimensionless bending parameter)
K_bal = 0.167 # EC2 limit for singly reinforced section
print(f"K = {K:.4f} (limit = {K_bal})")

if K > K_bal:
    print("WARNING: K exceeds Kbal. Compression steel or increase d required.")
else:
    print("Singly reinforced section OK.")

# Lever arm z (EC2 Cl 6.2.3)
z = d * (0.5 + math.sqrt(0.25 - K / 1.134)) # mm
z = min(z, 0.95 * d) # EC2 upper limit on z
print(f"z = {z:.1f} mm ({z/d*100:.1f}% of d)")

# Required tension steel area
As_req = M_Ed / (fyd * z) # mm2
print(f"As,req = {As_req:.0f} mm2")

# Minimum and maximum steel checks (EC2 Cl 9.2.1.1)
As_min = max(0.26 * (fck**0.5 / fyk) * b * d, 0.0013 * b * d)
As_max = 0.04 * b * h
print(f"As,min = {As_min:.0f} mm2 | As,max = {As_max:.0f} mm2")

# Bar selection (pick from standard bar table)
bars = {"N12":113, "N16":201, "N20":314, "N25":491, "N32":804}
n_bars = 4
bar_size = "N20"
As_prov = n_bars * bars[bar_size]
print(f"Provided: {n_bars} x {bar_size} = {As_prov} mm2")
print(f"Utilisation (req/prov) = {As_req/As_prov*100:.1f}%")

2.1 Shear Design (EC2 Variable Strut Inclination Method)

# --- SHEAR DESIGN (EC2 Cl 6.2) ---
rho_l = As_prov / (b * d) # Longitudinal steel ratio

# Shear resistance without shear reinforcement (VRd,c)
k = min(1 + math.sqrt(200 / d), 2.0) # Size effect factor
CRd_c = 0.18 / gamma_c
v_min = 0.035 * k**1.5 * fck**0.5
VRd_c = max(CRd_c * k * (100 * rho_l * fck)**(1/3), v_min) * b * d # N
print(f"VRd,c = {VRd_c/1000:.1f} kN (no links needed if V_Ed < VRd,c)")

if V_Ed > VRd_c:
    print("Shear links required.")
    # Variable strut inclination: choose theta = 21.8deg (cot=2.5) for efficiency
    cot_theta = 2.5 # EC2 range: 1.0 to 2.5
    z_shear = 0.9 * d
    # Required Asw/s (link area per unit spacing)
    Asw_s = V_Ed / (z_shear * fyd * cot_theta) # mm2/mm
    print(f"Asw/s required = {Asw_s:.3f} mm2/mm")
    # Try R10 links @ 200mm spacing (2 legs)
    Asw_prov = 2 * 78.5 / 200 # 2 legs x 78.5mm2 / 200mm spacing
    print(f"Provided: R10@200 (2 legs) = {Asw_prov:.3f} mm2/mm")
    print(f"Shear link utilisation = {Asw_s/Asw_prov*100:.1f}%")

2.2 Deflection Check (EC2 Span-to-Depth Ratio)

# --- DEFLECTION CHECK (EC2 Cl 7.4.2 - span/depth ratio method) ---
rho_0 = fck**0.5 * 1e-3 # Reference reinforcement ratio = sqrt(fck)/1000

# Basic L/d ratio for simply supported beam (EC2 Table 7.4N)
if rho_l <= rho_0:
    ld_basic = 11 + 1.5 * fck**0.5 * rho_0/rho_l + 3.2 * fck**0.5 * (rho_0/rho_l - 1)**1.5
else:
    ld_basic = 11 + 1.5 * fck**0.5 * rho_0/(rho_l) + fck**0.5 / 12 * (0)**0.5

# Modification factor for steel stress (EC2 Eq 7.17)
sigma_s = fyk / gamma_s * (As_req / As_prov) # actual steel stress at SLS
F1 = 500 / (fyk * As_req / As_prov) # EC2 multiplier
ld_limit = ld_basic * F1
ld_actual = L * 1000 / d
print(f"L/d actual = {ld_actual:.1f} | L/d limit = {ld_limit:.1f}")
if ld_actual <= ld_limit:
    print("Deflection check PASS")
else:
    print("Deflection FAIL - increase d or As,prov")

What These Numbers Mean in Practice

  • K = 0.167 (Kbal limit): Above this and your section needs compression steel or a deeper beam. Most residential beams run K = 0.06–0.12. If K is above 0.14, consider increasing depth before adding comp. steel.
  • z/d ratio: Typically 0.85–0.95 for efficient sections. If z/d approaches 0.95 (the cap), your beam is lightly loaded and depth-efficient. If z/d is near 0.80, the neutral axis is high and bending is dominant.
  • As utilisation 80–95%: Ideal range. Below 70% means you've overspecified (or can reduce depth). Above 100% means you need more bars or larger diameter.
  • VRd,c: If your V_Ed is less than VRd,c, minimum links only. This is often the case for lightly loaded slabs and shallow beams. Don't over-design shear reinforcement — it's expensive to fix and often incorrect.

3. Steel Beam Design: Python + AS 4100 / EC3

Steel beam design is simpler in terms of material constitutive behaviour (elastic-perfectly plastic), but the failure modes are more subtle: local flange buckling, web shear buckling, and lateral-torsional buckling (LTB) govern long unrestrained beams. The Python script below covers the complete section capacity and LTB check to AS 4100-2020.

# ============================================================
# STEEL BEAM DESIGN TO AS 4100-2020
# ============================================================
import math

# --- SECTION PROPERTIES (UB 460x190x74 example) ---
# Source: OneSteel / InfraBuild section tables
d = 457 # Overall depth (mm)
bf = 190 # Flange width (mm)
tf = 14.5 # Flange thickness (mm)
tw = 9.0 # Web thickness (mm)
Zx = 1460e3 # Elastic section modulus (mm3)
Sx = 1660e3 # Plastic section modulus (mm3)
Ix = 335e6 # Second moment of area (mm4)
Iy = 16.0e6 # Minor axis (mm4)
J = 645e3 # Torsion constant (mm4)
Iw = 922e9 # Warping constant (mm6)
ry = math.sqrt(Iy / (74*1000/7850)) # Approx radius of gyration (mm)

# --- MATERIAL ---
fy = 300 # Yield strength (MPa) - Grade 300
fu = 440 # Tensile strength (MPa)
E = 200e3 # Elastic modulus (MPa)
G = 80e3 # Shear modulus (MPa)
phi = 0.9 # Capacity reduction factor (AS 4100 Cl 1.6)

# --- SECTION CLASSIFICATION (AS 4100 Cl 5.2) ---
lambda_ef = (bf/2/tf) * math.sqrt(fy/250) # Flange slenderness
lambda_ew = (d - 2*tf)/tw * math.sqrt(fy/250) # Web slenderness
print(f"Flange lambda_ef = {lambda_ef:.1f} (compact limit = 9)")
print(f"Web lambda_ew = {lambda_ew:.1f} (compact limit = 82)")

# --- SECTION MOMENT CAPACITY (AS 4100 Cl 5.1) ---
# Compact section: phi*Ms = phi*Sx*fy
phi_Ms = phi * Sx * fy / 1e6 # kN.m
print(f"phi.Ms (section capacity) = {phi_Ms:.1f} kN.m")

# --- LOADS ---
M_star = 280 # Design bending moment (kN.m)
V_star = 160 # Design shear force (kN)
L_seg = 4.0 # Unrestrained segment length (m)

# --- LATERAL TORSIONAL BUCKLING (AS 4100 Cl 5.6) ---
# Reference buckling moment (Mo)
L_e = L_seg * 1000 # mm
Moa = (math.pi/L_e) * math.sqrt(E*Iy * (G*J + (math.pi/L_e)**2 * E*Iw)) / 1e6 # kN.m
print(f"Moa (reference buckling moment) = {Moa:.1f} kN.m")

# Slenderness reduction factor (AS 4100 Eq 5.6.1.1)
Ms = Sx * fy / 1e6 # nominal section moment capacity kN.m
lambda_s = math.sqrt(Ms / Moa) # member slenderness
alpha_m = 1.0 # moment modification factor (uniform = 1.0)
lambda_ms = math.sqrt(Ms / (alpha_m**2 * Moa))
gamma = (Ms/Moa)**0.5 if Moa > 0 else 0
alpha_s = 0.6 * ( (Ms/Moa)**0.5 + 3 )**0.5 - math.sqrt(Ms/Moa) + 3
alpha_s = 0.6 * (math.sqrt((Ms/Moa) + 3) - math.sqrt(Ms/Moa))
alpha_s = min(alpha_s, 1.0)
phi_Mb = phi * alpha_m * alpha_s * Ms # kN.m
print(f"alpha_s = {alpha_s:.3f} | phi.Mb (member capacity) = {phi_Mb:.1f} kN.m")
print(f"M* / phi.Mb = {M_star/phi_Mb*100:.1f}% {'PASS' if M_star <= phi_Mb else 'FAIL'}")

# --- SHEAR CAPACITY (AS 4100 Cl 5.11) ---
Aw = d * tw # Web area (mm2)
phi_Vv = phi * 0.6 * fy * Aw / 1e3 # kN
print(f"phi.Vv (shear capacity) = {phi_Vv:.1f} kN")
print(f"V* / phi.Vv = {V_star/phi_Vv*100:.1f}% {'PASS' if V_star <= phi_Vv else 'FAIL'}")

Interpreting Steel Beam Results

  • alpha_s (LTB reduction factor): This is the critical number. alpha_s = 1.0 means no LTB reduction — your beam is fully restrained or short enough. alpha_s < 0.6 means LTB is governing — consider adding intermediate restraints rather than going to a heavier section.
  • Moa vs Ms ratio: If Moa >> Ms, the section fails in yielding before buckling — you're in a stocky beam regime. If Moa << Ms, LTB dominates — add restraints or use a deeper section with wider flanges (better Iy).
  • Section classification: lambda_ef > 9 (AS 4100) or 10 (EC3 Class 1) means local flange buckling reduces capacity. Your section becomes non-compact and you must use Ze < Sx. Standard rolled UBs are typically compact at Grade 300.
  • Shear utilisation > 80%: Common in transfer beams. If phi_Vv is close to V_star, check web local buckling (AS 4100 Cl 5.11.2) and consider a thicker web plate or welded stiffeners.

4. Timber Beam Design (AS 1720.1)

# ============================================================
# TIMBER BEAM DESIGN TO AS 1720.1
# Glulam GL13c (structural glulam, 13 MPa bending)
# ============================================================

# --- SECTION AND MATERIAL ---
b_t = 90 # Width (mm)
h_t = 360 # Depth (mm)
L_t = 6.0 # Span (m)
f_b = 13 # Characteristic bending strength (MPa) for GL13c
f_s = 1.6 # Characteristic shear strength (MPa)
E_t = 10500 # Mean MOE (MPa)

# --- MODIFICATION FACTORS (AS 1720.1 Cl 2.4) ---
k1 = 1.0 # Load duration factor (1.0 for live load)
k4 = 1.0 # Partial seasoning factor (dry service)
k6 = 1.0 # Temperature factor (standard)
k9 = 1.0 # Strength sharing factor (single member)
k12 = 0.9 # Stability factor (accounting for LB, conservatively)
phi_t = 0.85 # Capacity factor for bending (Table 2.1)
phi_s = 0.75 # Capacity factor for shear

# --- SECTION PROPERTIES ---
Z_t = b_t * h_t**2 / 6 # Section modulus (mm3)
A_t = b_t * h_t # Cross-section area (mm2)

# --- DESIGN CAPACITY ---
M_d = phi_t * k1 * k4 * k6 * k9 * k12 * f_b * Z_t / 1e6 # kN.m
V_d = phi_s * k1 * k4 * k6 * f_s * (2/3) * A_t / 1e3 # kN
print(f"Bending capacity phi.Md = {M_d:.1f} kN.m")
print(f"Shear capacity phi.Vd = {V_d:.1f} kN")

# --- LOADS AND CHECKS ---
w = 12.0 # Design UDL (kN/m)
M_t = w * L_t**2 / 8 # kN.m
V_t = w * L_t / 2 # kN
print(f"M* = {M_t:.1f} kN.m | M*/phi.Md = {M_t/M_d*100:.1f}%")
print(f"V* = {V_t:.1f} kN | V*/phi.Vd = {V_t/V_d*100:.1f}%")

# --- DEFLECTION (SLS) ---
I_t = b_t * h_t**3 / 12 # mm4
w_sls = 8.0 # SLS UDL (kN/m) - typically 0.7*ULS or SLS load combo
delta = 5 * (w_sls/1000) * (L_t*1000)**4 / (384 * E_t * I_t) # mm
delta_lim = L_t * 1000 / 300 # L/300 for floors (AS 1170.1)
print(f"Deflection = {delta:.1f} mm | Limit (L/300) = {delta_lim:.1f} mm")
print(f"Deflection {'PASS' if delta <= delta_lim else 'FAIL'}")

5. Prestressed Beams: Key Concepts and Checks

Prestressed beam design is a post-graduate topic in full — but the core concepts and quick checks every engineer should understand are accessible. The fundamental idea: apply a compressive force to the concrete beam (via high-tensile tendons) that pre-offsets the tensile stresses caused by loading. Result: the beam behaves as though it is much stronger in tension than plain concrete allows.

CheckFormulaLimitConsequence if Failed
Transfer stress (top fibre)sigma = -P/A + Pe*yt/I0.6 fci at transferCrushing at top at transfer
Service stress (bottom fibre)sigma = -P_eff/A - Pe*yb/I + M*yb/I0 to 0.45fck (no tension)Cracking, Class 2 or 3
Ultimate bending (ULS)Mu vs M* checkMu >= M*Structural failure
Prestress lossesElastic shortening + creep + shrinkage + relaxationTypically 15-25% totalEffective prestress too low
Anchorage zoneBursting force Fbst = 0.25 Pi (1 - sqrt(a/b))Tie bars in zoneSplitting at anchor

When to use prestressed vs RC: Rule of thumb — spans above 12m start making prestressed attractive for slabs and above 18m for beams. Below these thresholds, the construction complexity and specialist contractor requirement rarely pay back against deeper RC sections. For highway bridges specifically, see our Seismic Design of Highway Bridges guide.

6. Software Comparison and Python Integration

Beam design software comparison ETABS Robot SkyCiv RFEM Tedds Python
Figure 3: Software comparison with Python API support and honest ratings

Python API access is now the critical differentiator. Here is what you can automate per tool for beam design specifically:

What to AutomateToolTime Saved per Project
50 span variations in one scriptETABS COM API or Robot REST4-8 hours
Auto-export beam results to ExcelETABS API and openpyxl1-2 hours
PDF calculation sheets automaticallyPython handcalcs and pdfkit2-4 hours
Check 200 beam sections against tablesPure Python with pandas3-5 hours

7. Practical Demo: SkyCiv API Beam Analysis in Python

SkyCiv offers the most accessible beam API for Python. Fully documented REST interface returning structured JSON. Here is a working script pattern:

# SkyCiv REST API - RC beam analysis in Python
# Full docs: https://skyciv.com/api/v3/
import requests

API_KEY = "your_api_key"
payload = {
  "auth": {"username": "your_email", "key": API_KEY},
  "functions": [
    {"function": "S3D.session.start", "arguments": {}},
    {"function": "S3D.model.set", "arguments": {
      "model": {
        "nodes": {"1":{"x":0,"y":0,"z":0}, "2":{"x":7,"y":0,"z":0}},
        "members": {"1":{"start":1,"end":2,"section_id":1}},
        "sections": {"1":{"name":"RC300x500","material_id":1,"rect":{"width":300,"height":500}}},
        "supports": {"1":{"node":1,"restraint_code":"FFFFRR"},"2":{"node":2,"restraint_code":"RFFFRR"}},
        "distributed_loads": {"1":{"member":1,"x_mag_A":-20,"x_mag_B":-20,"type":"UDL_GLOBAL_Y"}}
      }}},
    {"function": "S3D.analyze", "arguments": {}},
    {"function": "S3D.results.members.get", "arguments": {}}
  ]
}
response = requests.post("https://api.skyciv.com/v3/functions/run", json=payload)
data = response.json()
# Extract results and feed into your EC2 design script
print(data["response"][-1]) # moment and shear arrays

Full docs at skyciv.com/api/v3. The free tier is enough for design checks on standard projects. Combine this API call with the EC2 script from Section 2 to go from span and load inputs to a complete checked design in under 2 minutes of automated execution.

8. Common Beam Design Errors and How to Avoid Them

⚠ Errors That Fail Peer Review

ErrorWhy WrongFix
Using h instead of d for flexureOverestimates lever arm, underestimates Asd = h - cover - stirrup - bar/2
Not checking As,minBrittle failure with no ductilityAlways verify As,prov >= As,min
Skipping LTB for steel beamsphi_Mb can be 40-60% below phi_MsCheck alpha_s for every unrestrained segment
Using ULS loads for deflectionDeflection is SLS - no load factorsUse SLS characteristic load combo only
Forgetting k1 in timber designk1=0.57 for permanent loads halves capacityApply k1 per governing load duration
Not capping z at 0.95d (EC2)Underestimates As for shallow beamsz = min(calculated z, 0.95d)

9. What to Prefer: Honest Decision Framework

SituationRecommended ToolReason
Learning beam design fundamentalsPure Python in JupyterForces you to understand every step
Production RC beam on a projectETABS and Excel or PDF outputCode-compliant, peer-reviewable
Quick steel check, small firmSkyCiv or Python scriptFast, cheap, API-ready for automation
Batch checking 200 beam sizesPython with pandasNothing else scales this way
Complex frame with many beamsETABS or RFEM with Python APIGlobal analysis with member design integrated
Documenting calcs for submissionTedds or Python handcalcsProfessional sheets direct from code
Timber or GLT beamsPython or RFEM timber moduleMost RC tools handle timber poorly

The Python-first bottom line: Build your own beam library in Python. Start with the RC script in Section 2, add steel and timber functions. Version-control it. Every new project becomes a 5-minute parametric check. The initial 2-3 days of setup pays back within a month on any active practice. For seismic load combinations that govern beam design in many regions see our Seismic Design guide. For BIM and automation context see AI in Structural Engineering.

References

More in Beam Design