What Is Database Index Inspector?
Database Index Inspector is a free online tool by TechnSols that analyses pasted DDL and queries for missing indexes and index problems, and suggests the CREATE INDEX statements to add. It runs entirely in your browser: nothing is uploaded, nothing is stored on a server, and there is no account to make. Everything you type or paste stays on your own computer, and the result is ready to download when you are done.
An index is the difference between a query that reads ten rows and a query that reads ten million. The wrong index, or no index at all, is the most common reason a database slows down as it grows. The inspector reads your schema and your queries and points at the gaps: the foreign key with no index, the filter column nobody indexed, and the duplicate index wasting space. The PostgreSQL indexes guide explains the index types the suggestions use, from plain B-tree to covering indexes.
Paste the DDL, and optionally paste the queries the app actually runs. The inspector checks a fixed rule set: foreign keys without indexes, WHERE and JOIN columns without indexes, tables without a primary key, duplicate and redundant indexes, and leading-wildcard LIKE patterns that no index can serve. Each finding carries a severity, the rule that fired, and a ready-to-run CREATE INDEX statement. If a plan already shows the slow step, the SQL Explain Plan Viewer tool reads the EXPLAIN output first.
How To Use Database Index Inspector?
Here is how to use Database Index Inspector online in three quick steps. Paste the DDL, add the queries, and read the findings. If the queries are still being written, the SQL Query Playground tool runs them against sample data first.
Step 1: Paste Your DDL
Copy the CREATE TABLE statements and any CREATE INDEX statements from the schema, and paste them into the DDL box. The parser reads the tables, the columns, the primary keys, the foreign keys, and the indexes that already exist, so it never suggests an index you already have. The sample schema button fills in a small shop schema with a deliberate gap to try first.
Step 2: Add The Queries You Run
Paste the SELECT statements the app actually runs into the queries box, one per line or as a block. The inspector pulls the WHERE, JOIN, and ORDER BY columns out of each query, because those are the columns an index can serve. A schema without queries still gets findings, but the findings are stronger with real queries behind them.
Step 3: Read And Apply The Findings
Press Inspect Indexes and read the findings newest-first by severity: high first, then medium, then low. Each finding names the table and column, explains the rule in one line, and shows the CREATE INDEX statement to run. Copy the statements you agree with into your migration, and skip the ones that do not fit. If a suggested index needs checking against a real plan, the SQL Explain Plan Viewer tool reads the EXPLAIN output.
The whole job takes a minute. A schema with the right indexes is a database that stays fast as it grows.
Why Database Index Inspector?
Indexes are invisible until they are missing. A table with a thousand rows runs fine without them, so nobody notices the gap, and then the table grows to a million rows and the same query takes a hundred times longer. The inspector finds the gaps while the tables are still small, when adding an index is a one-line migration instead of an emergency. Indexes serve the queries, and the Database Seed Data tool builds the rows those queries run against.
Foreign Keys Need Indexes Too
A foreign key guarantees the value exists in the parent table, but it does not make the lookup fast. Every join on that key scans the child table unless the key is indexed, and every delete on the parent scans the child table too. The inspector flags every foreign key column without an index, because it is the most common gap in a new schema.
Queries Say What Indexes Are Needed
The schema alone cannot say which columns get filtered: only the queries know. The inspector reads the WHERE and JOIN columns from the queries you paste and matches them against the indexes that exist, so the suggestions follow the real workload instead of guessing. An index on a column nobody filters is wasted space; an index on a column every query filters is essential.
Duplicates Waste Space And Time
Two indexes that start with the same columns do the same work, and every INSERT pays to maintain both. The inspector flags exact duplicates and indexes covered by a wider one, so the schema can be trimmed. Fewer indexes mean faster writes and a smaller database, with the same read speed.
The MySQL CREATE INDEX reference documents the statement the suggestions write, including the index name, the table, and the column list. The suggestions follow that form exactly, so they run as written.
What Can You Do With Database Index Inspector?
The inspector fits any job where a schema needs a check before it grows or ships.
Check A New Schema Before Launch
A new schema is about to ship, and the queries are written. Paste the DDL and the queries, and read the findings before the launch: the missing index on the status column, the foreign key nobody indexed, the table with no primary key. The Database Schema Visualizer tool draws the same schema as a diagram while you are there.
Triage A Slow Query
A query is slow and the plan shows a sequential scan. Paste the schema and the query, and the inspector says whether an index would serve it and which columns the index needs. The suggestion is a starting point, not a verdict: test it in staging and re-run the plan before it ships.
Clean Up An Old Schema
An old schema has indexes nobody remembers adding, some duplicated, some on columns the app stopped filtering years ago. The inspector lists the duplicates and the redundant indexes, so the cleanup can drop them with confidence. The Database Documentation Generator tool writes the docs for the schema that remains.
Quality And Settings
The inspector is pure JavaScript with a fixed rule set, and every finding says which rule fired. Suggestions are heuristic only: they come from the DDL and the pasted queries, not from live statistics, so they must be tested before they ship. Once the indexes are settled, the Database Documentation Generator tool writes the docs for the finished schema.
- Rule 1: every foreign key column without an index is flagged as high severity.
- Rule 2: WHERE, JOIN, and ORDER BY columns without an index are flagged with the query.
- Rule 3: tables without a primary key, and duplicate or redundant indexes, are flagged.
- Rule 4: leading-wildcard LIKE patterns and SELECT star notes are flagged as low severity.
- Rule 5: every finding carries a ready-to-run CREATE INDEX statement for its dialect.
There are no settings beyond the DDL box, the queries box, and the dialect picker, because the rule set is fixed and public. Paste the schema honestly, read the findings, and test the suggestions in staging.
How Database Index Inspector Works
The inspector parses the pasted DDL with the same reader the visualizer uses: tables, columns, primary keys, foreign keys, and existing indexes, including composite indexes and their column order. It then scans the pasted queries for WHERE, JOIN ON, and ORDER BY columns, and matches each one against the index list. A column used in a filter with no index that starts with it becomes a finding, and the suggested CREATE INDEX names the table and the column. The SQL Explain Plan Viewer tool shows whether the plan actually uses the suggested index once it exists.
Two limits are worth knowing. The suggestions are heuristics, not measurements: the inspector cannot see row counts, selectivity, or real execution times, so a suggestion can be wrong for a tiny table or a rarely run query. And only the pasted text is read: the inspector never connects to a database, so it cannot check the indexes that actually exist on a server, only the ones in the DDL you pasted.
Privacy
Everything you type stays in your browser. Database Index Inspector runs on your own computer, and nothing you enter is uploaded to a server, stored, or shared with anyone. Closing the tab clears the form, so your work never leaves your device.
Because no account is needed, there is no name, email, or history tied to what you check. Closing the tab ends the session, and the browser clears the input from memory. That is the same protection on every tool here: your work stays yours, and nothing about it is kept, shared, or sold.
Tips
A few habits make Database Index Inspector work smoother, whether you are using it once or every day.
- Paste the real queries the app runs, not guesses: the suggestions follow the workload.
- Fix high severity findings first: foreign keys and filtered columns without indexes.
- Test every suggested index in staging and re-run the plan before it ships.
- Do not index every column: each index slows writes and costs disk space.
- Re-run the inspector after a migration, so the findings match the new schema.
When the findings are fixed, download the report and keep it with the migration, so the next review starts from the same list. If the schema needs a diagram too, the Database Schema Visualizer tool draws the tables and their foreign keys from the same DDL.
More Tools For The Same Job
These tools handle the same kinds of jobs: working with databases, SQL, and the data that lives in them.
- SQL Explain Plan Viewer: turns pasted EXPLAIN output into a readable plan tree.
- Database Schema Visualizer: draws tables and foreign keys from pasted DDL.
- SQL Query Playground: runs SQL against an in-browser SQLite database.
- Database Seed Data Generator: builds INSERT statements with fake rows for any table.
- SQL Query History Viewer: finds any query you ran before, with search and re-run.
- SQL Query Library Manager: saves named queries locally and exports them as JSON.
- Database Documentation Generator: turns pasted DDL into tables, columns, and relations docs.
- MySQL to PostgreSQL Translator: converts MySQL SQL into PostgreSQL SQL.
- SQLite to SQL Dump Converter: exports a SQLite database as SQL text.
- JSON to SQL Insert Converter: turns JSON rows into INSERT statements.
FAQ
Common questions about Database Index Inspector, answered plainly.
Is Database Index Inspector by TechnSols Free?
Yes, Database Index Inspector by TechnSols is completely free to use, with no account, no sign-up, and no usage limit. You can use it as often as you like, and everything you type stays in your browser, so nothing is uploaded or stored anywhere.
Are The Suggestions Guaranteed To Help?
No, the suggestions are heuristics from the DDL and the pasted queries, not measurements from a live database. The inspector cannot see row counts, selectivity, or execution times, so a suggestion can be wrong for a tiny table or a rarely run query. Test every suggestion in staging and check the plan before it ships.
Why Is A Foreign Key Flagged?
A foreign key guarantees the value exists in the parent table, but it does not make the lookup fast. Joins on the key and deletes on the parent both scan the child table unless the key is indexed. The rule flags every foreign key column without an index, because it is the most common gap in a new schema.
What Counts As A Redundant Index?
An index is redundant when another index starts with the same columns in the same order, so the wider index can serve every query the narrower one serves. The inspector flags exact duplicates and covered indexes, but a unique index is never flagged as redundant, because uniqueness is a constraint, not just a lookup.
Does It Read My Live Database?
No, the inspector reads only the DDL and the queries you paste. It never connects to a database, never sees your data, and never checks the indexes on a server. Paste a fresh schema dump when the server schema changes, so the findings match the real schema.
Open Database Index Inspector and try it with the sample first, then bring your own work. It is free, it runs entirely in your browser, and nothing you type is uploaded or stored.