Ultimate Bearing Capacity of Soil Formula: A Practical Guide

A comprehensive, engineer-focused guide to the ultimate bearing capacity of soil formula, including Terzaghi’s theory, parameter selection, step-by-step calculations, and safety considerations for footing design.

Load Capacity Team

February 15, 2026·5 min read

Load Capacity Soil Bearing Capacity Structural Safety Bearing Capacity

Soil Capacity Guide - Load Capacity — Photo by Mayur_Ankushevia Pixabay

Quick AnswerDefinition

The ultimate bearing capacity of soil is the maximum vertical load a footing can support before failure. It is commonly computed with Terzaghi’s formula, q_ult = c′N_c + γD_fN_γ + qN_q, where c′ is effective cohesion, γ is soil unit weight, D_f is footing depth, and N_c, N_γ, N_q are bearing capacity factors. This article explains how to apply the formula, select soil parameters, and adjust for soil type and depth. Load Capacity’s guidance helps engineers use the correct reductions and safety margins.

Terzaghi's fundamental formula and its components

Terzaghi's well-known bearing-capacity framework expresses the ultimate vertical load a footing can sustain before failure. The most widely used version for shallow foundations on a homogeneous soil layer is:

Python

# Terzaghi's nozzle-style, simplified ultimate bearing capacity
# q_ult = c' * N_c + γ * D_f * N_γ + q * N_q
# c': effective cohesion, γ: unit weight, D_f: footing depth, N_c/N_γ/N_q: bearing-capacity factors

def q_ult(c_prime, N_c, gamma, Df, N_gamma, q, N_q):
    return c_prime * N_c + gamma * Df * N_gamma + q * N_q

# Example values (SI):
c_prime = 25.0        # kPa
gamma = 18.0           # kN/m^3
Df = 2.0                 # m
N_c = 30
N_gamma = 18
q = gamma * Df           # overburden pressure at foundation base (kPa)
N_q = 1.0

print("q_ult =", q_ult(c_prime, N_c, gamma, Df, N_gamma, q, N_q), "kPa")

This snippet demonstrates the core calculation. The same structure applies across soil types with adjusted N-values and soil parameter substitutions. Proper units are essential; keep c′ in kPa, γ in kN/m^3, Df in meters. The Load Capacity team emphasizes verifying unit consistency and sourcing reliable soil data to avoid misinterpretation of results.

Parameters in practice: c′ (effective cohesion) vanishes for clean sands, while cohesion for clays can dominate the q_ult term. N_c, N_q, and N_γ are tabulated in geotechnical handbooks and depend on the soil friction angle φ′ and depth influence factors. The key is to map your soil class to the corresponding N-values accurately.

Code explanation: The function returns the sum of three terms: the cohesive term, the overburden term, and the horizontal passive resistance term. The overburden pressure q is typically γD_f, but you can supply a different value if you know the actual stress state.

Common variations: Terzaghi's formula is often adapted for shallow foundations on layered soils or for punching conditions with additional factors. In practice engineers apply correction factors for soil variability and drainage conditions, then compare q_ult to the design load.

Determining N-values from soil type and φ′

Correct N-values are critical. They are functions of the effective internal friction angle φ′ and depth-dependent factors. In code, you can model them as a lookup or a fit from standard charts. The following illustrates a simple lookup-based approach:

Python

# Simple lookup example for N-values (illustrative only)
N_values = {
  'sand': {'phi': 30, 'N_c': 30, 'N_q': 18, 'N_gamma': 16},
  'clammy_clay': {'phi': 25, 'N_c': 28, 'N_q': 16, 'N_gamma': 14},
}

def get_N_values(soil_type, phi_prime):
    entry = N_values.get(soil_type)
    if not entry:
        raise ValueError('Unknown soil type')
    return entry['N_c'], entry['N_q'], entry['N_gamma']

print(get_N_values('sand', 30))  # (30, 18, 16)

Notes on this approach: Real projects use standardized tables or software to map φ′ and soil type to N_c, N_q, and N_γ with depth corrections. The Load Capacity team recommends cross-checking multiple sources and, when possible, validating against field test results (e.g., Standard Penetration Testing SPT or CPT-based correlations).

Example: simple rectangular footing with flat selection of N-values

Using the simple lookup above, you can run a practical calculation for a rectangular footing. Assume soil type is sand, φ′ ≈ 30°, c′ ≈ 0, γ ≈ 18 kN/m³, and D_f ≈ 2 m. The overburden pressure q = γD_f = 36 kPa. With N_c, N_q, N_γ from the table (30, 18, 16), the calculation is:

Python

# Given values from the lookup
c_prime = 0.0
N_c, N_q, N_gamma = 30, 18, 16
gamma = 18.0
Df = 2.0
q = gamma * Df

print('q_ult =', q_ult(c_prime, N_c, gamma, Df, N_gamma, q, N_q))

Result interpretation: The computed q_ult represents the ultimate vertical stress the footing can carry. To translate to design load, apply a safety factor (see the Step-by-Step section). The example highlights how small changes in φ′ or c′ dramatically affect q_ult due to the N-values multiplying them.

Practical adjustments for depth and soil layering

Soils often vary with depth, requiring layered analyses. If a footing sits at depth where the soil profile changes, you can aggregate stresses or use an equivalent-soil approach. The code snippet below demonstrates a layered q_ult calculation by weighting each layer’s properties and depth:

Python

layers = [
  {'D': 1.0, 'c': 10, 'phi': 28, 'gamma': 17.5},
  {'D': 2.0, 'c': 0, 'phi': 32, 'gamma': 18.0},
]

def layered_q_ult(layers, N_values_lookup):
    total = 0.0
    depth_acc = 0.0
    for L in layers:
        depth_acc += L['D']
        N_c, N_q, N_gamma = N_values_lookup(L['phi'])
        q_base = L['gamma'] * depth_acc
        total += L['c'] * N_c + q_base * N_gamma + q_base * N_q
    return total

print(layered_q_ult(layers, lambda phi: (30,18,16)))

Why this matters: Layering can increase or decrease q_ult depending on the strength and thickness of different strata. The Load Capacity team emphasizes documenting the soil profile and using conservative assumptions in safety-critical designs. If you lack precise layer data, use worst-case combinations and include a sensitivity analysis in your report.

Verifying results with safety margins and design loads

Finally, you compare the computed q_ult against the intended design load with a factor of safety (FS). A common practice is FS = q_ult / Q_design, where Q_design includes live loads, environmental loads, and any dynamic effects. The following snippet demonstrates a simple FS check:

Python

Q_design = 150.0  # kPa (example design load)
FS = q_ult(c_prime, N_c, gamma, Df, N_gamma, q, N_q) / Q_design
print('Factor of Safety (FS) =', FS)

Interpretation guides: If FS is below a target (often 2.0 or higher for critical structures), you must revise soil parameters, adjust footing depth, or add ground improvement. The Load Capacity approach emphasizes documenting assumptions and establishing a defensible FS based on codes and project risk.

Steps

Estimated time: 40-60 minutes

1
Define soil and footing parameters
Collect c′, γ, φ′, and footing depth D_f. Decide whether to treat soil as homogeneous or layered. Ensure units are consistent before computation.
Tip: Double-check units and confirm D_f is measured from the ground surface to the footing base.
2
Select N-values from standard tables
Map φ′ and soil type to N_c, N_q, and N_γ using standard geotechnical references. If using a layered soil, identify layer-specific N-values.
Tip: When in doubt, use conservative N-values and document the source.
3
Compute q_ult using the Terzaghi formula
Plug the parameters into q_ult = c′N_c + γD_fN_γ + qN_q and compute the result. Validate with a quick Python script or spreadsheet.
Tip: Verify that q equals γD_f for overburden pressure unless a different q is justified.
4
Apply safety factors and compare with design load
Calculate the factor of safety FS = q_ult / Q_design. If FS is below the target, revise design or include ground improvement.
Tip: Document all assumptions and ensure compliance with local codes.
5
Document results and create a transparent report
Record parameter values, N-values, assumptions, and FS. Include sensitivity analysis for different soil scenarios.
Tip: Provide a clear summary table and explain uncertainties to stakeholders.

Pro Tip: Always verify soil layer continuity and reasonableness of N-values with field data.

Warning: Do not ignore pore-water pressure effects in quick sand or cohesive soils—adjust c′ and γ accordingly.

Note: Keep units consistent across all inputs to avoid arithmetic errors in q_ult calculations.

Prerequisites

Required

Python 3.8 or higher↗
Required
Basic soil mechanics knowledge (bearing capacity concepts)
Required
Consistent unit system (SI units preferred)
Required
Access to soil data (c′, γ, φ′, D_f) or in-situ test results
Required

Optional

NumPy or equivalent numerical library (recommended)
Optional
A code editor (e.g., VS Code, PyCharm)
Optional

Commands

Action	Command
Compute q_ult for a simple caseAssumes Terzaghi’s formula with q = γDf and conservative N-values from a standard table	`python bearing_capacity.py --type simple --c 0 --N_c 30 --N_q 1.0 --N_gamma 16 --gamma 18 --Df 2`
Plot n-values vs φ′ and saveGenerates a quick visual of how N_c/N_q/N_γ change with φ′	`python bearing_capacity.py --plot --phi 30 --soil sand --outfile n_values.png`
Layered q_ult calculationUses a layered soil profile to compute an effective q_ult	`python bearing_capacity.py --type layered --layers layers.json`

Quick Answers

What is the ultimate bearing capacity of soil formula and why is it important?

The ultimate bearing capacity formula estimates the maximum vertical load a footing can carry before failure. It guides safe foundation design by combining soil strength (c′), overburden pressure (γD_f), and soil resistance (N-values). Proper use reduces risk of settlement or failure.

Which soil conditions require special adjustments to Terzaghi’s formula?

Cohesive clays, dense sands, and soils with significant pore pressure require adjustments in c′, γ, and N-values. For layered soils or high water table, apply correction factors or use alternative formulations such as Meyerhof or Hansen variants.

How do I choose the N_c, N_q, and N_γ values?

N-values come from soil type, φ′, and depth. Use standard geotechnical tables or software, and consider consulting local codes. Where data are uncertain, use conservative values and document assumptions.

Can Terzaghi’s formula handle layered soils?

Terzaghi’s basic form assumes homogeneous soil. For layered soils, you should use layered analysis, equivalent soil properties, or switch to more advanced methods (e.g., Meyerhof, Brinch-Hansen) with appropriate weighting across layers.

What is a safe practice when the calculated q_ult is close to Q_design?

If q_ult is close to or only slightly above Q_design, increase the safety margin with a higher factor of safety, re-evaluate soil data, or add ground improvement techniques. Document decisions and uncertainties.