Model-config web apps: describe the app in configuration instead of writing code. Built on Polars and DuckDB.
Config-Driven Development (CDD)
The Final Evolution of Software Development
The Journey Back to the Future
1990s Insight: "Non-programmers should build applications"
- Vignette StoryServer: $200K visual builder
- Symphony, BroadVision: Point-and-click development
- They had the right idea, wrong implementation
2000s Detour: "Real programmers write code"
- Rejected visual builders as "not real development"
- Built frameworks requiring 50,000 lines
- Made everything harder to prove we were "serious"
2020s Circle Complete: "Everyone using no-code again"
- Webflow, Framer, Notion, Airtable
- We came full circle but pretended it was new
2025 Revelation: "It was always just config"
The Evolution of Development Paradigms
1. Code-Driven Development (1950-2000)
for (int i = 0; i < users_count; i++) {
if (strcmp(users[i].email, email) == 0) {
// 500 more lines...
}
}
Problem: Everything manual, repetitive, error-prone
2. Test-Driven Development (2000-2010)
def test_user_can_login():
assert login(username, password) == True
# Now write 500 lines to make this pass
Problem: Writing tests for code that shouldn't exist
3. Domain-Driven Design (2003-2020)
public class User extends AggregateRoot {
private EmailAddress email;
private Password password;
// 1000 lines of "domain logic"
}
Better: Focused on the domain Problem: Still required translation to code
4. Config-Driven Development (2025+)
domain: "E-commerce"
entities:
users: "People who buy things"
products: "Things we sell"
orders: "Transactions between them"
# That's it. AI handles the rest.
Solution: Domain experts build directly
The Three Actors, Finally Aligned
HUMANS:
good_at: "Knowing what they want"
role: "Write config"
output: "domain.dbbasic"
AI:
good_at: "Implementing details"
role: "Generate services"
output: "Perfect code when needed"
COMPUTERS:
good_at: "Execution"
role: "Run at 402M rows/sec"
output: "Instant results"
Why Config-Driven Development Wins
It's Not Test-Driven
- TDD: Test imaginary code, then write code to pass
- CDD: Describe reality, system already works
It's Truly Domain-Driven
- DDD: Model domain → Write code → Hope it matches
- CDD: Describe domain → System reflects it perfectly
It's What We Always Wanted
- 1960s: "Make computers understand English"
- 2025: Config IS structured English
The Wisdom We Almost Lost
Vignette/Symphony were right: Business people should build business systems
They just had it backwards:
- Thought: Need visual GUI builders
- Reality: Need simple text config
Visual builders failed because:
- Proprietary lock-in
- Limited flexibility
- Expensive licenses
- Required consultants
Config succeeds because:
- Plain text (universal)
- Unlimited flexibility
- Free and open
- Self-documenting
Examples Across Industries
Old Way (10,000 lines)
# Django e-commerce
class Product(models.Model):
name = models.CharField(max_length=255)
price = models.DecimalField(max_digits=10, decimal_places=2)
# ... 100 more fields
class ProductView(APIView):
def get(self, request):
# ... 200 lines of logic
# ... 50 more files
New Way (10 lines)
model:
products: [id, name, price, stock]
views:
catalog: "SELECT * FROM products WHERE stock > 0"
The Three Development Modes
1. When Humans Code (rare)
custom_logic:
type: "python"
code: |
# Some specific algorithm only humans understand
2. When AI Codes (common)
ai_service:
calculate_tax:
description: "Apply regional tax rules to order total"
# AI generates the implementation
3. When Nobody Codes (default)
views:
dashboard: "SELECT COUNT(*) FROM orders WHERE date = TODAY"
# Config is sufficient
The Paradigm Shift
From: "How should we implement this?" To: "What do we want?"
From: "What framework should we use?" To: "What config describes this?"
From: "How do we test this?" To: "Does the config match reality?"
The Death of Traditional Roles
Before:
- Business Analyst → writes requirements
- Developer → translates to code
- Tester → verifies code works
- DevOps → deploys code
- Result: 6 months, $500K, bugs
After:
- Domain Expert → writes config
- Result: 5 minutes, $0, perfect
The Ultimate Irony
We went backwards to go forwards:
- 1990s: Visual builders (right idea, wrong approach)
- 2000s: Reject simplicity for complexity
- 2010s: Add more layers of abstraction
- 2020s: Realize abstraction was the problem
- 2025: Config was the answer all along
The Future
Year 1: "Config-driven is just for simple apps" Year 2: "Config-driven works for enterprise too" Year 3: "Why did we ever write code?" Year 5: "What's code?"
The Bottom Line
Test-Driven Development: Write tests for code that shouldn't exist Domain-Driven Design: Model domains then translate to code Config-Driven Development: Describe domain, done
We're not adding another development methodology. We're ending development methodologies.
Because when everything is config, there's nothing to develop.
"Almost domain driven design, not test driven development"
Actually, it's domain IS design. No development required.
The Final Word
Software development was a 75-year translation layer between human intent and computer execution.
Config removes the translation.
Intent → Config → Execution.
No development. Just description.
Welcome to the post-development era.