Model-config web apps: describe the app in configuration instead of writing code. Built on Polars and DuckDB.
The Real Bottlenecks: What Actually Held Software Back
The Four Horsemen of Slow Software
1. Databases: The Original Sin
database_bottleneck:
traditional_dbs:
problem: "Designed for spinning rust (HDDs)"
assumptions:
- "Seeks are expensive (10ms)"
- "Sequential reads are king"
- "Cache everything in RAM"
- "Minimize disk touches"
result:
- Complex query planners
- Elaborate caching layers
- Index obsession
- "N+1 query" nightmares
the_lie: "Databases are slow"
the_truth: "Databases were designed for 1970s hardware"
2. Code Generation: The False Prophet
code_generation_disaster:
the_promise: "Write less code!"
the_reality:
- Generated code is unreadable
- Debugging is impossible
- Customization breaks everything
- Regeneration loses changes
- Version control nightmares
examples:
rails_scaffolding: "Generated 1000 lines nobody understood"
orm_mappings: "Generated SQL nobody could optimize"
gui_builders: "Generated code nobody could modify"
why_it_failed:
- Code is meant to be read by humans
- Generated code is written by machines
- Result: Worst of both worlds
3. Configuration: The Complexity Trap
config_hell:
xml_era:
- Spring: "1000 lines of XML"
- Maven: "Dependencies of dependencies"
- Enterprise JavaBeans: "Config bigger than code"
yaml_era:
- Kubernetes: "1000 lines of YAML"
- Ansible: "Config to configure config"
- Docker Compose: "YAML inception"
why_it_sucked:
old_config: "Too complex for humans"
old_code: "Only slightly easier"
result: "Everyone chose code"
what_changed:
ai_arrival: "AI understands patterns"
ai_generates: "Perfect config from description"
humans_tweak: "Small adjustments only"
result: "Config finally wins"
4. Hardware: The Hidden Bottleneck
hardware_reality:
hdd_era:
random_read: "10ms (100 IOPS)"
sequential_read: "100 MB/s"
database_design: "Minimize seeks at all costs"
ssd_arrival:
random_read: "0.1ms (10,000 IOPS)"
sequential_read: "550 MB/s"
change: "100x faster random access"
nvme_revolution:
random_read: "0.01ms (1,000,000 IOPS)"
sequential_read: "7,000 MB/s"
change: "10,000x faster than HDD"
what_nobody_realized:
- "All database assumptions were wrong"
- "Caching became unnecessary"
- "Indexes became less critical"
- "Random access is now FREE"
The SSD Revolution Nobody Talks About
Before SSDs: The Dark Ages
before_ssds:
every_query: "Carefully planned to minimize disk seeks"
every_cache: "Because disk was death"
every_index: "Because full scans were impossible"
architecture:
- Memcached everywhere
- Redis for everything
- Complex caching layers
- Cache invalidation hell
result: "50% of code was managing caches"
After SSDs: The Hidden Renaissance
after_ssds:
reality: "Disk is now fast enough"
what_became_possible:
- Full table scans: "Actually feasible"
- Random access: "No penalty"
- Simple queries: "Fast enough"
- Columnar storage: "Practical"
what_we_kept_doing:
- Building complex caches
- Optimizing for HDDs
- Using 1970s algorithms
- Pretending disk is slow
result: "We didn't update our assumptions"
NVMe: The Game Changer
nvme_changes_everything:
speeds:
samsung_980_pro: "7,000 MB/s read"
random_4k: "1,000,000 IOPS"
latency: "Microseconds, not milliseconds"
what_this_means:
- "RAM-like speeds from disk"
- "Database can live on disk"
- "No caching needed"
- "Direct queries work"
dbbasic_leverages:
- Polars: "Designed for modern hardware"
- DuckDB: "Assumes fast disk"
- Parquet: "Columnar for NVMe"
- Result: "402M rows/sec"
Why Config Finally Wins
The Old World: Config Was Hell
<!-- 2010: Spring Configuration -->
<beans>
<bean id="userService" class="com.example.UserService">
<property name="userDao" ref="userDao"/>
<property name="emailService" ref="emailService"/>
<property name="cacheManager" ref="cacheManager"/>
<!-- 500 more lines of this -->
</bean>
</beans>
<!-- Result: Everyone hated it -->
The New World: AI + Config
# 2024: DBBasic Configuration
user: "I need user management"
ai_generates:
tables:
users: [id, email, name, role]
auth: "jwt"
permissions: "role-based"
# Result: Perfect config in 1 second
Why Config Wins Now
config_advantages:
with_ai:
- AI generates perfect config
- Patterns from millions of examples
- No bugs from hand-coding
- Instant optimization
with_ssds:
- No complex optimizations needed
- Simple queries are fast enough
- Config can be declarative
- Performance is guaranteed
with_modern_cpus:
- Parsing is instant
- JIT compilation works
- Config becomes code at runtime
- Zero overhead
The Layers Problem
Death by a Thousand Abstractions
traditional_stack:
request_path:
1: "Browser JavaScript"
2: "React Virtual DOM"
3: "Redux State Management"
4: "Axios HTTP Client"
5: "Express.js Server"
6: "Middleware Stack"
7: "ORM Layer"
8: "Connection Pool"
9: "PostgreSQL"
10: "Disk I/O"
each_layer:
- Serialization/deserialization
- Memory allocation
- Context switching
- Error handling
- Logging
total_overhead: "100ms for 1ms of work"
The DBBasic Way: Direct Path
dbbasic_stack:
request_path:
1: "Browser request"
2: "DBBasic engine"
3: "Data (Parquet on NVMe)"
no_layers:
- No ORM (direct queries)
- No middleware (config handles)
- No caching (NVMe is fast)
- No serialization (columnar format)
total_overhead: "0.002ms for 1ms of work"
The Performance Revolution Timeline
2010: The HDD Era
performance_2010:
storage: "HDD @ 100 IOPS"
solution: "Cache everything"
complexity: "Enormous"
result: "Slow anyway"
2015: SSDs Arrive
performance_2015:
storage: "SATA SSD @ 10,000 IOPS"
solution: "Still caching everything"
complexity: "Still enormous"
result: "Faster but not reimagined"
2020: NVMe Mainstream
performance_2020:
storage: "NVMe @ 1,000,000 IOPS"
solution: "Still using HDD patterns"
complexity: "Still enormous"
result: "Hardware wasted on old patterns"
2024: The Awakening (DBBasic)
performance_2024:
storage: "NVMe @ 1,000,000 IOPS"
solution: "Redesign for modern hardware"
complexity: "None (just config)"
result: "402M rows/sec"
The Four Revelations
1. Databases Were the Problem
revelation_1:
old_thinking: "Optimize queries"
reality: "Databases assumed HDDs"
solution: "Redesign for NVMe"
result: "1000x speedup"
2. Code Generation Was Wrong
revelation_2:
old_thinking: "Generate code"
reality: "Unreadable, unmaintainable"
solution: "Generate config instead"
result: "Human-readable, AI-optimizable"
3. Config Needed AI
revelation_3:
old_thinking: "Config is too complex"
reality: "Humans couldn't write it"
solution: "AI writes config"
result: "Perfect patterns every time"
4. SSDs Changed Everything
revelation_4:
old_thinking: "Disk is slow"
reality: "NVMe is near-RAM speed"
solution: "Eliminate caching layers"
result: "Simplicity AND speed"
Why This Matters
The Old Assumptions Are Dead
dead_assumptions:
"disk_is_slow": False # NVMe killed this
"cache_everything": False # Unnecessary now
"indexes_critical": False # Full scans work
"code_generation_helps": False # Config generation better
"humans_write_config": False # AI does it better
"layers_needed": False # Direct access works
The New Reality
new_reality:
storage: "NVMe = near RAM speed"
config: "AI generates perfectly"
queries: "Direct access is fine"
complexity: "Not needed anymore"
result: "Everything we knew was wrong"
The Bottom Line
We spent 20 years optimizing for spinning rust.
We spent 10 years adding layers for problems that no longer exist.
We spent 5 years ignoring that SSDs changed everything.
DBBasic simply acknowledges reality:
- NVMe is fast enough for direct access
- AI can write better config than humans
- Columnar formats match modern hardware
- Simplicity beats complexity when hardware is fast
The revolution wasn't in new software patterns. It was in admitting the old assumptions were dead.
"The database wasn't slow. It was designed for the wrong hardware."
"Code generation failed because it generated the wrong thing."
"Configuration was too hard until AI could write it."
"SSDs were the revolution. We just didn't notice."
"Every optimization for HDDs is now pessimization for NVMe."
"We have 2024 hardware running 1970s algorithms. Until now."