CLASSROOMPOSSIBILITIES

High school · Grade 10 / Engineering / 40 minutes

Bridge Lab

Design. Test. Revise. Defend the tradeoffs.

Plan your lesson

Teacher notes

Build a bridge under constraints. Compare cost, load capacity, and environmental impact as you improve your design.

The full guide below comes from the artifact’s original README. Its development and validation notes describe the original build.

Download teacher notes (.md)

Engineering Design Challenge: Bridge Lab

An offline Grade 10 engineering studio focused on iterative design under constraints.

Open the app

Open index.html in a current browser. Keep index.html, styles.css, config.js, model.js, and app.js in the same folder. On a Chromebook, extract the ZIP in Files, then open index.html with Chrome.

No backend, installation, account, API key, external fonts, libraries, or internet connection is needed. The optional local preview used during development is not required. Distribute the entire folder or ZIP, not just the HTML file.

The app saves settings, designs, test history, and reflections in this browser's local storage when available. File-URL storage policies vary by browser; a visible message warns if saving is unavailable. Use Export notebook to save a readable JSON record for submission or archiving. Exports contain the full designs, test conditions, predictions, vulnerability notes, results, and reflections; there is no import feature. Nothing is uploaded. Avoid sharing the same browser profile between student teams without clearing the app's local storage first. Moving the folder may change where the browser stores its notebook.

1. Learning objectives

Students will:

  • Define a design using geometry, material, member thickness, section count, reinforcement, and deck choice.
  • Make a prediction before testing, including an optional proposed weak point.
  • Distinguish carrying a load from meeting a required safety margin.
  • Use test evidence to explain failure, identify a limiting component, and revise a design.
  • Compare cost, mass, material usage, safety, and environmental impact without assuming that the strongest design is the best.
  • Respond to a changed constraint and defend tradeoffs using evidence.

The learning goal is engineering reasoning, not finding a hidden single answer. The estimates are visible deliberately: students can use them as evidence for their predictions. The test is deterministic, not an independent real-world validation of those estimates.

2. Suggested 40-minute lesson

Time Activity
0–5 min Read the brief. Identify the fixed constraints and the variables students can change. Ask why merely carrying the load might not be enough.
5–10 min Teams define their first design, predict its behavior, identify a possible weak point, and run a baseline test.
10–18 min Read What happened? / Why? / What could you change? Change one variable at a time, predict, and retest. Aim for at least three attempts.
18–25 min Compare two attempts in the notebook. Assign minimum cost, lightweight, or sustainability. Ask teams to preserve safety while improving the chosen objective.
25–32 min Switch to Surprise event, test a qualifying design, and reveal the change. Students must alter a design variable and retest. Discuss why a previously acceptable design may need revision.
32–38 min Complete the five required reflections with actual measurements. At least two different designs and a test of the current design under the current conditions are required to finish.
38–40 min Share defensible tradeoffs and export the notebook. Assess the reasoning and evidence, not just whether the final bridge passes.

Prompts: “What did this change buy you?” “Which requirement is limiting you now?” “Why did the cheapest member not create the cheapest safe bridge?” “What would you test in a physical prototype?”

3. Simplified engineering assumptions

This model must not be used for real structural engineering. All material strengths, prices, deck limits, and impact indices are deliberately selected classroom parameters, not engineering reference data or current market prices.

The bridge is represented as an equivalent frame and deck spanning between two supports. Frame self-weight and deck self-weight reduce its traffic capacity. Frame resistance and deck capacity form two independent limits. The animation's truck symbolizes the total traffic load, not an individual truck of that weight.

Design ranges

  • Geometry: Warren, Pratt, or Howe, with fixed educational efficiency and material-use multipliers.
  • Sections: 4–12. Benefits to resistance diminish; material and joint costs continue to increase.
  • Thickness: 0.60–2.20 in increments of 0.05, a relative member-size index, not centimeters.
  • Reinforcement: 0–3. More braces increase resistance, volume, cost, mass, and impact.
  • Deck: timber, composite, or concrete, each with its own traffic-capacity ceiling.
  • Truss height: 4–9 m in Advanced, fixed at 6 m otherwise.

Equations implemented in model.js

Let L be span in meters, n sections, t thickness index, r reinforcement level, h truss height, g geometry, and m material. Default constants below can be edited in config.js.

sectionFactor = 0.65 + 0.4 × (1 − exp(−(n − 3) / 3))
V = 12 × (L/40) × g.usage × (0.78 + 0.045n) × t
    × (1 + 0.13r) × (0.85 + 0.15h/6)                    [model m³]
mass = V × m.density + L × deck.mass                    [tonnes]
selfWeight = mass × 9.81                                [kN]
resistance = 6200 × m.strength × t^1.6 × g.efficiency
    × sectionFactor × sqrt(h/6) × (1 + 0.14r)
    × (40/L)^0.65                                      [kN]
frameTrafficCapacity = max(0, resistance − selfWeight)
deckTrafficCapacity = deck.capacity × (40/L)^0.35
trafficCapacity = min(frameTrafficCapacity, deckTrafficCapacity)
safetyFactor = trafficCapacity / requiredTrafficLoad
cost = 240000 × L/40 + V × m.cost + L × deck.cost + n × 22000
impact = V × m.impact + L × deck.impact

“Material usage” measures frame material only; mass, cost, and impact include the deck. Environmental points are not kilograms of CO₂ or lifecycle-analysis results. Foundation/joint terms represent classroom fixed costs rather than a detailed bill of materials.

The distinction between geometries is heuristic. This app does not solve node equilibrium, individual member forces, connections, buckling, fatigue, wind, earthquakes, soil behavior, bending moments, or dynamic vehicle loads. Deflection is visually exaggerated. Member colors scale with approximate utilization and position. The central failure marker identifies the model's limiting frame or deck schematically; it is not a predicted physical fracture location. Reinforcement drawings show representative braces rather than an exact quantity takeoff.

The traffic load ramps up over the first 65% of a crossing and remains at full load for the remainder. If load exceeds capacity, the test stops and marks the weak system. Otherwise it completes and reports the reserve above required traffic load. Reduced-motion settings shorten the animation.

Prediction feedback uses explicit classroom categories:

Prediction Model outcome
Fail immediately Capacity is less than 75% of required traffic load. “Immediately” means early in the load ramp, not time zero.
Bend significantly Capacity is 75% to less than 100% of the traffic load; the bridge bends and then fails.
Barely pass Capacity carries the traffic load, but safety factor is below the required minimum. This still fails the project safety constraint.
Comfortably pass Safety factor meets the required minimum. Budget and environmental constraints are checked separately.

History Pass/Fail means meeting all constraints for that challenge, not only avoiding structural failure. Every challenge requires safety and budget compliance; Sustainability additionally requires impact at or below the configured limit.

Multidimensional scores

All scores are clamped to 0–100, reported separately, and never summed:

Safety = 100 × safetyFactor / minimumSafetyFactor
Cost efficiency = 100 × (1 − cost / (1.4 × budget))
Material efficiency = 100 × (1 − V / (5 × baseVolume × L/40))
Environmental impact score = 100 × (1 − impact / (1.5 × impactLimit))

A higher environmental score means a lower impact. These are reference-normalized classroom indicators, not grades or universal engineering efficiencies. Safety earns no extra score above the required margin, which discourages “strongest at any cost.” Minimum-cost, lightweight, and sustainability modes identify a student's best qualifying tested attempt for their objective; they never reveal the global optimum. The impact limit is enforced only in Sustainability.

Surprise events are chosen deterministically from the number of passing surprise-mode tests: budget −15%, traffic load +20%, structural material prices +25%, or impact limit −25%. The environmental event activates Sustainability if necessary. A reveal begins a new constraint round and requires at least one design variable to change. Only one event is revealed per teacher-settings round. Apply teacher settings to begin another round. Old results keep their original conditions.

4. Exactly how teachers can customize the challenge

In the application

  1. Click Teacher settings in the header, or expand the panel at the bottom.
  2. Choose a difficulty preset first. It fills budget, load, safety factor, and mathematics visibility; you may then override those fields.
  3. Edit the title and scenario. Use {span} anywhere in the scenario to display the configured span automatically. Literal distances in a custom scenario must be updated manually.
  4. Set span (15–80 m), budget ($100,000–$10,000,000), traffic load (500–20,000 kN), minimum safety factor (1–3), and environmental limit (20–2,000 points).
  5. Check the permitted challenge modes. Keep at least one enabled.
  6. Check available materials. Keep at least one enabled. Edit each material's price, density, relative strength, and impact index. Field labels state the units; disabled materials also retain editable properties for later use.
  7. Choose whether to allow Show the Math.
  8. Click Apply teacher settings. The current design is normalized to available choices, its old prediction is cleared, and a new constraint round begins. Tests already in the notebook retain their previous conditions.

Presets:

Preset Budget Required load Minimum SF Experience
Introductory $2,400,000 3,000 kN 1.25 Conceptual prompts, mathematics hidden by default, fixed height
Standard $2,000,000 4,000 kN 1.50 Calculations and tradeoffs available, fixed height
Advanced $1,600,000 4,500 kN 1.60 Tighter constraints, mathematics available, adjustable truss height

Fill default settings fills the form; Apply teacher settings commits those defaults. Neither deletes the notebook. Teacher settings are an instructional panel, not a password-protected access control.

In the files

Open config.js in a text editor and edit window.BRIDGE_CONFIG. The top section contains the brief, constraints, difficulty, math visibility, active mode IDs, and material properties. The model section contains geometry/deck parameters and the base resistance, volume, gravity, foundation cost, joint cost, and reinforcement coefficients. Retain valid JavaScript syntax, positive finite values, and at least one enabled material and mode. UI numeric limits protect classroom edits; arbitrary malformed source edits cannot be validated before JavaScript loads.

For fresh defaults to take effect in a browser with an existing notebook, export its work first, then clear the bridge-lab-v1 local-storage entry using browser developer tools and reload. To change existing work without clearing it, use Teacher Settings. School-managed browser policies may disable file storage; export remains available.

Custom constraints may deliberately make the problem impossible. Try the settings before class. If no team finds a feasible design, consider whether revising the brief should itself be part of the engineering discussion. Do not treat the default solution counts as a guarantee for arbitrary teacher choices.

5. Adapting the architecture to other engineering problems

The app separates three responsibilities:

  • config.js: teacher-editable brief, constraints, material data, and model coefficients.
  • model.js: pure evaluate(design, config) function returning measurements, feasibility, limiting system, and scores.
  • app.js + index.html + styles.css: controls, visualization, prediction gate, test narrative, history, comparison, and reflection.

To adapt it, replace the model and diagram while preserving the predict–test–explain–revise cycle and immutable attempt snapshots. Examples:

  • Wind turbine: blade length, blade count, and tower height; trade energy against cost, noise, material use, and gust failure.
  • Water filter: filter layers, particle size, and flow rate; trade cleaning performance against throughput and cost.
  • Insulated shelter: materials, wall thickness, windows, and ventilation; trade temperature retention against cost, light, and embodied impact.
  • Bottle rocket: water fill, pressure, fin geometry, and mass; trade altitude, stability, resource use, and safety constraints.

Use a domain-appropriate simplified model with stated limitations. Preserve the difference between carrying out a test and interpreting evidence. Store a full configuration snapshot with every attempt so changing assumptions does not rewrite earlier results.

Verification

The delivered app was tested directly from a file:// URL in Chrome without external requests. Browser checks covered every design control, all four prediction outcomes, all five modes, all four surprise events, all three presets, teacher property edits, rejected empty mode/material selections, comparison, design reload, reflection completion gates, JSON export, persistence, blocked-storage fallback, and layouts from 390 to 1440 CSS pixels. The narrower 720-pixel layout also exercised the reflow expected at 200% desktop zoom.

Model checks enumerated 32,076 standard designs: 8,079 met the default safety and budget requirements, including designs in each of the three materials. The cheapest feasible design differed from the lightest/lowest-impact design. Checks verified finite nonnegative outputs, increasing cost and mass with thickness, nondecreasing traffic capacity with thickness across that grid, and 128 extreme parameter combinations. These checks validate software behavior and classroom tradeoffs, not structural accuracy. No finite test suite can cover arbitrary edits to source configuration.

Behind the activity

The original AI prompt

Generated in ChatGPT using 5.6 High, then run in ChatGPT Codex using GPT-6 Astra Medium. The text is preserved as supplied; it describes the requested build, rather than a guarantee that every requirement was implemented exactly.

Download original (.md)
Read the full creation prompt
Build a polished interactive high-school STEM web app called “Engineering Design Challenge: Bridge Lab.”
TARGET Grade 10.
GOAL Students should experience engineering as iterative design under constraints.
The core lesson is NOT simply calculating formulas.
Students should:
1. define a design,
2. predict its performance,
3. test it,
4. analyze why it succeeded or failed,
5. revise it,
6. optimize across competing objectives.
TECHNICAL REQUIREMENTS
- Create a self-contained browser-based web application requiring no backend, login, API key, installation, or internet access.
- Prefer index.html plus CSS and JavaScript.
- No external APIs.
- It should run smoothly on common student laptops/Chromebooks.
- Make the interface polished enough to look like an engineering design tool.
- Keep the code modular and clearly commented.
- Put teacher-adjustable assumptions and parameters in an obvious configuration section.
THE DESIGN CHALLENGEDefault scenario:
“A community needs a bridge across a 40-meter span. Your engineering team must design a bridge that safely carries the required load while staying within budget.”
Students should be able to design a simplified bridge by changing variables such as:
- bridge/truss type
- number of structural sections
- material
- beam/member thickness
- amount of reinforcement
- deck material
Possible materials might include:
- wood
- steel
- aluminum
Each should have simplified educational properties such as:
- cost
- mass
- strength
- environmental impact
Do not pretend this simplified model is suitable for real-world structural engineering.
DESIGN DASHBOARDContinuously display estimated:
- total cost
- bridge mass
- estimated load capacity
- safety factor
- material usage
- environmental-impact score
Use intuitive gauges or indicators.
Include clear project constraints such as:Budget: $2,000,000Required load: [teacher configurable]Minimum safety factor: [teacher configurable]
Do not immediately tell students what the optimal design is.
PREDICTIONBefore each test, require the student to predict:
“I think my bridge will:
- fail immediately
- bend significantly
- barely pass
- comfortably pass”
and optionally:“What part of your design do you think is most vulnerable?”
TEST THE BRIDGEInclude a prominent button:
TEST THE BRIDGE
Animate a load such as a truck or series of loads crossing the bridge.
Visually represent stress in structural components.
Show members becoming more stressed as load increases.
If the design fails:
- visibly indicate where the failure began
- stop or animate the failure
- explain the likely reason in age-appropriate engineering language
If it succeeds:
- show how much reserve capacity remains
- do NOT simply say “Perfect”
- encourage optimization:
  
  “Can you meet the same requirements using less material or lower cost?”
RESULT ANALYSISAfter every test, display:
WHAT HAPPENED?WHY?WHAT COULD YOU CHANGE?
Include relevant simplified calculations where appropriate.
Allow an expandable “Show the Math” panel explaining concepts such as:
- force
- tension
- compression
- load
- safety factor
- why geometry matters
Students who are less mathematically advanced should still be able to use the simulation.
More advanced students should be able to inspect the calculations.
DESIGN HISTORYMaintain a table of student attempts:
Design 1 | Cost | Mass | Capacity | Safety Factor | Pass/FailDesign 2 | ...Design 3 | ...
Let students compare iterations.
Highlight improvement rather than simply final performance.
OPTIMIZATION CHALLENGESInclude multiple challenge modes:
1. SAFE AND AFFORDABLEMeet the safety requirement under budget.
2. MINIMUM COSTFind the least expensive design that still satisfies safety constraints.
3. LIGHTWEIGHTMinimize mass while meeting the required load.
4. SUSTAINABILITYBalance cost, safety, and environmental impact.
5. SURPRISE EVENTAfter students finish a design, reveal a new constraint such as:
- material prices increase
- required traffic load increases
- environmental regulations become stricter
- budget falls by 15%
Require redesign.
This should demonstrate that engineering involves tradeoffs and changing constraints.
SCORINGDo not score simply on “strongest bridge.”
Create a multidimensional result showing:
- safety
- cost efficiency
- material efficiency
- environmental impact
Explain that different designs can be defensible depending on the objective.
TEACHER MODEInclude a collapsible Teacher Settings panel.
Teacher should be able to customize:
- title
- scenario
- span
- available materials
- material properties
- budget
- required load
- minimum safety factor
- difficulty
- whether mathematical details are shown
- which challenge modes are active
Include three difficulty presets:
INTRODUCTORYMostly conceptual.
STANDARDIncludes calculations and tradeoffs.
ADVANCEDMore variables, tighter constraints, and more explicit mathematics.
LEARNING REFLECTIONAt the end require students to answer:
“My first design ______.”“I changed ______ because ______.”“The data showed ______.”“My final design improved because ______.”“If the constraint changed to ______, I would ______.”
DESIGN QUALITYUse a clean technical visual aesthetic:
- blueprint/engineering feel
- bridge visualization as the centerpiece
- sliders and selectors around it
- dashboard metrics
- test animation
Avoid making it look like a spreadsheet with decorations.
The bridge itself should visibly respond to design decisions whenever possible.
TESTINGBefore finishing:
- run the complete application
- test every design control
- verify no configuration causes the application to break
- make sure obvious engineering relationships behave sensibly
- verify there are multiple viable solutions
- make sure the cheapest/strongest solution is not trivial
- test all challenge modes
- improve any confusing parts of the UI
Finally, create a README containing:
1. learning objectives,
2. a suggested 40-minute lesson,
3. the simplified engineering assumptions,
4. exactly how teachers can customize the challenge,
5. ideas for adapting the same artifact architecture to other engineering problems.

Your next experiment

Make it your own

Start with Teacher Settings inside the activity. For a larger change, copy the original prompt and change the grade, subject, learning goal, and scenario. Keep the prediction, evidence, explanation, and revision cycle.

Ask the AI to explain the changes and the model’s assumptions. Try the revised activity yourself before teaching with it, including unusual inputs and the classroom devices students will use.

These adaptation suggestions were added for this resource hub; they are not part of the original prompt.