Database

I keep running into the same bug report: a dashboard looks right for most days, then a filter silently drops rows because a column is a date while a predicate expects a datetime. That mismatch feels small, but it spills into logic, joins, and even indexes. When you convert date to datetime correctly, you stop […]

Last quarter I reviewed a subscription system that occasionally billed the wrong customer. The bug was not in the payment API; it was in the table design. The customers table had email, phone, and a membership number, but none were enforced as unique. Two rows ended up sharing the same email after a manual import,

Last quarter I was helping a product team ship a reporting endpoint for HR. The data already lived behind a stored procedure that Finance trusted, but the web API needed to join those rows with a feature flag table. The moment I tried SELECT * FROM GetEmployeesByDepartment(…) in SQL Server, the database reminded me that

Last quarter I inherited a MySQL cluster that had grown for years without a clear offboarding process. An access review found 180 user entries, many created for vendors and short-term projects. The real risk wasn’t just unused accounts; it was that nobody could say who still needed them. That moment reminded me that removing accounts

Last month I was wiring a nightly export for a finance team. Their accounting system still consumed a fixed-width text file, and the loader rejected any line that didn’t line up. I first tried CAST, but the numbers came back at variable widths: 2, 20, and 2000 all produced different string lengths, and negative values

Last year I helped a team recover from a Friday-night outage caused by a single unreviewed schema change. The data itself was intact, but a missing index made every checkout query crawl and the API timeouts piled up. That incident reminded me that database languages in a DBMS are not textbook categories; they are the

A few quarters ago I was debugging a permissions table where each record could delegate access to another record. The data was correct, yet the report showed every person twice and some managers attached to the wrong staff. The issue wasn‘t in the business logic; it was in the query. The table had been joined

Last spring I sat with a payments team that had just split a monolith into twelve services. The code separation was clean, but a single shared database kept dragging them back into old habits. A coupon change in the loyalty service broke checkout tables, a reporting query locked the order tables for seconds, and a

At 9:07 a.m. during a product drop, our order service slowed to a crawl. The app servers looked fine, but the database was a parking lot of read locks. Analytics jobs were scanning the orders table while checkout tried to update the same rows. Every new write waited, and response times climbed from tens of

I still remember a late Friday when a Windows laptop refused to shut down because MySQL kept showing ‘Stopping…‘ for ten minutes. My teammate clicked End Task in Task Manager, and the next boot spent half an hour in crash recovery. That small incident changed how I treat start and stop operations. MySQL is one

Last year I helped a retail startup that tracked orders in a shared spreadsheet. A midnight bulk update overwrote formula columns, and by morning they couldn’t tell which items had shipped. We rebuilt their order system on a real database in a week. The fix wasn’t fancy; it was about reliable storage, rules that prevent

Last quarter I helped a fintech team trace a permissions bug that only showed up for a handful of supervisors. The data looked fine until we realized the user table stored both employees and managers, and the report had joined to the table only once. We needed the same rows to play two roles. That