By ByteBot
At QCon London 2026 last week, Yinka Omole (Personio’s Lead Engineer) posed an uncomfortable question to a room full of developers: Should you master the latest trending framework, or invest in boring fundamentals like state machines and data modeling? The audience shifted nervously. Most knew the “right” answer—fundamentals compound, tools don’t. But here’s the truth nobody wants to admit: trending frameworks get you hired. Fundamentals make you valuable. And those two things aren’t the same. This isn’t a technical debate. It’s a coordination failure, and everyone’s trapped.
What “Boring Fundamentals” Actually Mean
Fundamentals aren’t abstract theory—they’re recurring patterns that have remained unchanged for 20-50 years and will persist for decades more. State machines, workflow orchestration, data modeling, distributed systems. These problems existed in 1980s telecom systems, exist in today’s microservices, and will exist in future edge computing.
PostgreSQL’s 20-year bet proves the point. In the early 2000s, PostgreSQL focused on ACID compliance, extensibility, and correctness over speed. The cost? Slower adoption than MySQL. The payoff? By 2023, PostgreSQL surpassed MySQL. The 2025 Stack Overflow survey shows PostgreSQL at 55.6% adoption (up 7 percentage points in a single year) versus MySQL’s 40.5% (barely moving). Among professional developers, PostgreSQL leads by 18.6 points.
Why did PostgreSQL win after 20 years? Its architecture could absorb JSON support, full-text search, and pgvector (for AI embeddings) without major rewrites. MySQL chose early adoption over architectural integrity and hit walls that required breaking changes. PostgreSQL bet on fundamentals. MySQL bet on features. Two decades later, the fundamentals won.
Across payments, banking, payroll, e-commerce, and customer support, the same patterns emerge. Workflow orchestration. State machines. Entities moving between states (initiated, processing, approved, rejected). As Omole noted in his QCon talk: “While tools change rapidly, underlying engineering problems persist across decades and technologies.” Learn these patterns once, apply them everywhere.
The Resume-Driven Development Trap
Here’s the uncomfortable data: 82% of developers believe using trending technologies makes them more employable. They’re not wrong. 60% of employers admit trends influence their job postings. The result? Job ads demanding “5 years Next.js experience” for problems that existed before Next.js.
This creates a self-perpetuating cycle. Companies post framework requirements. Developers learn those frameworks. Companies still can’t find experienced candidates because everyone’s chasing the same narrow skill set. Solution? Post more ads with the same requirements. Nobody questions whether the frameworks are actually necessary.
The cost is real. Years wasted learning frameworks that become obsolete—Angular 1, Backbone, Meteor, the graveyard is full. Missing fundamental knowledge that would compound over decades. “Resume-driven legacy code” where technical debt accumulates because engineers chose tech for career advancement, not project fit.
Real example: A job posting requires “5 years experience with framework X.” Framework X is 2 years old. The subtext? “We don’t know what we actually need, so we’re filtering by buzzwords.” ATS (Applicant Tracking Systems) make it worse, automatically rejecting candidates who lack specific keywords—regardless of their problem-solving ability.
The Coordination Failure: Why Both Camps Are Right
This isn’t a technical debate about what’s “better.” It’s a coordination problem where individually rational choices lead to collectively worse outcomes.
Developers are rational to chase trends. Fundamentals matter for long-term career growth, sure. But trending frameworks get you past initial screening. You can’t afford to bet on fundamentals if ATS filters by React keywords. Missing React on your resume means never getting the interview to demonstrate your brilliant problem-solving skills.
Employers are trapped too. Engineering managers want problem-solvers with fundamentals. But HR departments and recruiters filter by framework keywords. Good candidates get eliminated before engineers see them. And when competing employers demand the same frameworks, you’re forced into an arms race just to maintain your hiring pipeline.
The incentives are misaligned everywhere. Vendors profit from hype cycles—new frameworks mean new training, consulting, and tooling revenue. Bootcamps teach what job ads demand (React) instead of what matters (distributed systems). Developers optimize for interviews. Employers want depth but hire for breadth.
Survey data shows employers prioritize problem-solving skills. Hiring reality shows over 60% of recruiters filter by framework experience first. Nobody can unilaterally change this without losing competitive advantage. Stop blaming developers for “chasing shiny objects” or employers for “not knowing what they want.” Both are making rational choices given perverse incentives. The system is broken, not the players.
What Actually Works: The 20/80 Rule
Until incentives change industry-wide, you must play both games simultaneously.
For developers: The 20/80 rule. Spend 80% of learning time on trending frameworks that get you hired (React, Next.js, whatever job ads demand). Spend 20% on fundamentals that compound (distributed systems, databases, algorithms). Monday through Thursday evenings? Build that React project for your portfolio. Friday evening? Study “Designing Data-Intensive Applications” or implement a B-tree. You need both to succeed short-term AND long-term.
For employers: Test fundamentals with boring tech. Interview format: “Solve this problem with vanilla JavaScript and SQL. No frameworks.” This tests problem-solving, not framework recall. Benefit? You find candidates who can learn your specific stack instead of filtering for people who happen to know your exact toolchain. Example question: “Build a real-time notification system. Here’s a database. Here’s JavaScript. Go.”
For job postings: Create a “nice-to-have” section. Required: Problem-solving, learning ability, communication, computer science fundamentals. Nice-to-have: Specific frameworks (React, Next.js, etc.). This signals what actually matters and attracts stronger candidates who have fundamentals but may not know your exact stack.
The PostgreSQL model works. Build on fundamentals first (ACID, extensibility). Accept slower initial growth. Create architecture that adapts to trends (JSON, vectors, full-text search). Compound advantages over decades. Most importantly: Bet on problems that won’t change, not tools that will. As Dan McKinley wrote, you have limited “innovation tokens”—spend them on solving real problems, not chasing hype.
The 10-Year Test
Here’s a simple framework: Will you still be using React in 10 years? Maybe not. Will you still be solving state management? Definitely. Will you still be using Kubernetes? Uncertain. Will you still be debugging distributed systems? Yes.
Use trending tech as a vehicle to learn fundamentals. Building a React app? Study how virtual DOM works—data structures, tree diffing algorithms. Using Kubernetes? Study distributed systems, consensus protocols like Raft, state machines. Learning Next.js? Study server-side rendering, caching strategies, CDNs, edge computing.
Pattern recognition is the skill. Redux, MobX, Zustand? All implement state machines. React, Vue, Svelte? All solve reactivity with different approaches. MySQL, PostgreSQL, MongoDB? All face consistency versus performance tradeoffs (CAP theorem). Once you see the patterns, tools become interchangeable.
Master one boring fundamental per year. Year 1: Databases (SQL, indexing, transactions, ACID). Year 2: Distributed systems (consistency, CAP theorem, consensus). Year 3: Operating systems (processes, memory, I/O). Year 4: Data structures and algorithms (trees, graphs, dynamic programming). In a decade, you’ll have depth that survives any framework shift.
Key Takeaways
Fundamentals compound, tools don’t. But incentives reward trending tech. Play both games: 80% trending frameworks (get hired), 20% fundamentals (long-term value). Employers: hire for problem-solving with boring tech, not framework recall. Use the 10-year test: Will this still matter? If yes, it’s fundamental. If no, it’s a tool. Until the industry fixes coordination failure, optimize for both.
