Two Tables and a Question
More than thirty years ago, a colleague taught me SQL by giving me questions to solve instead of answers to copy. I still think about what those weekly challenges taught me about understanding a problem, sharing knowledge, and the choice AI makes easier to avoid.
Leadership Philosophy Series — 21 articles
- The Power of Lifelong Learning
- AI and Critical Thinking in Software Development
- Sidetracked by Sizzle: Staying Focused on True Value
- The Managed Transition Model: Leadership Promotion as Power Exchange
- When the Pressure is On - Late Sprint Hotfix Governance
- Accountability and Authority: Walking the Tightrope
- Turtling: When a Team Stops Looking for the Door
- Every Arm Is Still Searching: The Octopus Model of Agency
- The Dependencies I Never Upgraded
- The Beaver Builds a Pond
- The Shark Stops Evolving When It's Done
- The Engineering Zoo: When the Dashboard Gets Better but the Zoo Does Not
- Tactical Excellence, Strategic Truth: Who Checks Whom
- A Journeyman's Guide to Three-Week Sprints
- Momentum Is Not Propulsion
- The Last Generation of Masters?
- Confident Humility: Earning and Keeping Client Trust
- Solve the Problem, and Get Out of the Way
- Knowing When to Let My Creation Die
- The Developer Is Not an Order Taker
- Two Tables and a Question
Filed under Leadership and systems thinking
Topic cluster
Project Leadership and DeliveryProject Mechanics, leadership judgment, delivery accountability, and team operating models.
The problems usually started the same way: a couple of tables, a relationship between them, a small set of data, and a question.
Find the unique instances of something. Find the records that meet a tricky condition. Write the query that answers it — and then, once I had something that ran, make it correct, make it complete, and make it efficient. They were word problems, more or less, with SQL as the language of the answer, and they kept coming, week after week, from a colleague who had no obligation to give me any of them.
That was more than thirty years ago. I don't remember a single one of those queries. I remember exactly what they did to the way I think.
The Mentor Nobody Assigned
He wasn't my manager, and he wasn't on my team. His desk just happened to be near mine, and he and I fell into the kind of conversations people have when they share a room every day. Somewhere in those conversations he noticed that I wanted to get better at SQL, so he started handing me problems.
There was no mentoring program and no assignment. He saw someone who wanted to learn and decided to spend his own time on that. He could have handed me working snippets, which would have been faster for him. He gave me room to struggle with a question instead: come up with an answer, test it, improve it. If my first answer worked but there was a better way to think about the problem, that became the next conversation.
More than thirty years later, I still remember those weekly conversations, and I still miss them.
The Problem Before the Syntax
Those exercises quietly separated two things I'd been treating as one: understanding a problem, and writing the code for it. The syntax mattered, but it was the smaller lesson. The bigger one was learning to reason about what the data actually meant, what the question was really asking, and how to tell whether an answer was right rather than merely plausible. That's still how I think about software development — as problem solving that happens to produce code.
The problems were also unforgiving in a useful way. A query that was almost right was simply wrong. A query that quietly dropped the rows with no match hadn't answered the question. An inefficient one that happened to finish on a small dataset would fall over on a real one. Being new was never an excuse for a sloppy answer. Not knowing how yet was fine, as long as the next step was finding out. I've written separately about the difference between "it can't be done" and "I don't know how", and I suspect I first learned it at that desk.
Knowledge Shared Is Knowledge Multiplied
I've often said that knowledge hoarding is the sign of a weak developer, and those SQL problems are a big part of why I believe it.
I understand the temptation to become the only person who knows how something works. It feels like security. In practice it leaves the business exposed and traps the developer in the same recurring tasks, because nobody else can ever take them over. I made the career side of that argument in The Art of Making Yourself Replaceable. What the mentor showed me was the other side: sharing what he knew didn't make him one bit less valuable. It made someone else more capable, and his influence carried into everything that person went on to build.
I try to carry that forward in the ordinary parts of the job: documenting a system so the next person can change it, explaining why an architectural decision went the way it did, building training into an application so its users don't need to call me, and making time for anyone who asks how something works.
The Faster Path He Didn't Take
I think about him more now than I used to, because the choice he made has become harder to make.
With AI, I can often build the next piece of a project faster on my own than I could while teaching someone else to build it. I wrote about that pull in The Last Generation of Masters?, and I haven't fully resolved it. My mentor faced a smaller version of the same trade every week. Handing me the answer would have been quicker. Writing the query himself would have been quicker still. He chose the slower path because the point was never the query.
However I settle that trade-off, choosing to teach isn't something a tool can do for me. AI can generate a correct query and explain it fluently, and I use it that way every day. A learner who asks it for problems instead of answers will get those too. What it won't do is notice, without being asked, that someone wants to learn, and decide to spend an afternoon on them. Someone still has to choose to be the colleague at the next desk.
What Lasts
The technologies I used in those early years are almost all gone. Two tables and a question turned out to be more durable than any of them.
I hope some of the people I've worked with can say something similar about me someday: that they still use something I helped them learn, long after they stopped needing me to explain it.
Explore More
- The Last Generation of Masters? — why AI weakens the incentive to train the next generation, and what that costs
- The Art of Making Yourself Replaceable — why sharing what you know is how a career grows
- The Dependencies I Never Upgraded — the other influences that outlasted every technology
Related project evidence

Frogsfolly.com Main
Frogsfolly.com is the original website I created in 1999 when learning web technologies.

DevSpark: Constitutional AI Governance Framework
DevSpark is a standalone AI-assisted development framework that extends Specification-Driven Development with constitution-based PR reviews, codebase-wide compliance auditing, adversarial risk analysis, brownfield constitution discovery, and adaptive lifecycle management. DevSpark makes project constitutions valuable throughout the entire development lifecycle — from greenfield planning through continuous constitutional governance.
Used across most of my active repositories, including this site
Working through something similar?
If this maps to something you're working on, I'm glad to compare notes. Start with the system and the constraint that matters most.