DEV Community

Domonique Luchin
Domonique Luchin

Posted on

How I built StructCalc AI to replace $500/month structural software licenses

#engineering #ai #webdev #fastapi

I was paying $6,000 per year for structural engineering software at my firm. RISA-3D, STAAD.Pro, ETABS - you know the drill. These tools work, but the subscription costs kept climbing while my needs stayed the same: calculate beam deflections, check steel member capacities, and generate quick reports.

So I built StructCalc AI. It handles 80% of my routine calculations and costs me $47/month to run on a Vultr VPS.

The problem with engineering SaaS

Most structural engineers accept these costs as "the way things are." But here's what bothered me:

  • RISA-3D: $2,400/year for features I use 20% of the time
  • STAAD.Pro: $1,800/year with clunky interfaces from 2005
  • ETABS: $1,200/year for seismic analysis I do quarterly

I needed basic beam analysis, column checks, and foundation sizing. Not advanced dynamic analysis or 3D modeling.

The math hasn't changed. Steel yield strength is still 50 ksi. Concrete compression strength formulas are still the same. Why rent software to do calculations I learned in college?

Building the MVP in 3 weeks

I started with FastAPI and PostgreSQL. The goal: replace my most common calculations.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import math

app = FastAPI()

class BeamInput(BaseModel):
    length: float  # feet
    load: float    # kips/ft
    material: str  # "steel" or "concrete"
    section: str   # "W12x26", etc.

@app.post("/analyze/beam")
async def analyze_beam(beam: BeamInput):
    # Simple beam deflection calculation
    if beam.material == "steel":
        E = 29000  # ksi
        I = get_section_properties(beam.section)["I"]

        max_deflection = (5 * beam.load * (beam.length * 12)**4) / (384 * E * I)
        max_moment = (beam.load * beam.length**2) / 8

        return {
            "max_deflection": round(max_deflection, 3),
            "max_moment": round(max_moment, 1),
            "l_over_deflection": round((beam.length * 12) / max_deflection, 0)
        }
Enter fullscreen mode Exit fullscreen mode

The first version handled:

  • Simply supported beam analysis
  • Steel column capacity checks
  • Concrete footing sizing
  • Wind load calculations per ASCE 7

No fancy UI. Just API endpoints that returned JSON.

Adding Claude for code generation

Here's where it got interesting. I connected Claude API to generate custom calculation scripts on demand.

import anthropic

client = anthropic.Anthropic(api_key=os.getenv("CLAUDE_API_KEY"))

@app.post("/generate/calculation")
async def generate_calculation(prompt: str):
    system_prompt = """You are a structural engineer. Generate Python code for 
    engineering calculations. Use only standard engineering formulas. 
    Return executable code with proper error handling."""

    response = client.messages.create(
        model="claude-3-haiku-20240307",
        max_tokens=1000,
        system=system_prompt,
        messages=[{"role": "user", "content": prompt}]
    )

    # Execute the generated code safely
    return execute_calculation(response.content)
Enter fullscreen mode Exit fullscreen mode

Now I can ask: "Calculate the required reinforcement for a 20x20 concrete column with 150 kips axial load" and get working Python code.

The economics work out

My current monthly costs:

Service Cost
Vultr VPS (8GB RAM) $24
Claude API calls $18
Database backup $5
Total $47

Compare that to my old software stack:

  • RISA-3D: $200/month
  • STAAD.Pro: $150/month
  • ETABS: $100/month
  • AutoCAD Structural: $80/month

I'm saving $483 per month. That's $5,796 per year back in my pocket.

What I learned about AI in engineering

The AI doesn't replace engineering judgment. It automates the grunt work.

Good for:

  • Standard beam/column calculations
  • Code lookups (AISC, ACI)
  • Generating boilerplate analysis code
  • Quick "what-if" scenarios

Not good for:

  • Complex seismic analysis
  • Non-standard connection design
  • Anything requiring engineering judgment

I still use ETABS for major seismic projects. But for 80% of my work, StructCalc AI handles it.

The self-hosting advantage

Running everything on my VPS means:

  • No vendor lock-in
  • Full control of my data
  • Custom integrations with my other tools
  • No surprise price increases

I host it alongside my other Load Bearing Empire applications: the AI phone system, property management tools, and client portals.

Start small, build what you need

You don't need to replace everything at once. Pick one expensive tool and build a targeted replacement.

Start with:

  1. Identify your most expensive, least-used software
  2. List the 3-5 features you actually use
  3. Build those features with basic Python/FastAPI
  4. Add AI for the complex stuff

The math is simple. If you're paying more than $50/month for software that does calculations, you can probably build a replacement.

Want to see the code? I'm open-sourcing parts of StructCalc AI on GitHub. Follow me here for updates on the Load Bearing Empire stack and more engineering automation projects.

Top comments (0)