Connecting a database is only the first step. Once your database is available in DevScribe, you can explore its tables and inspect the data they contain without leaving your development workspace.

This becomes especially useful when you’re working with an existing database, debugging an application, or simply trying to understand how the data behind a project is organized.

In this guide, we’ll use the QuickCart MySQL database from the previous setup and explore what it contains.

From Connection to Exploration

In the previous guide, we connected our MySQL database to DevScribe.

Now, instead of immediately writing a query, we can first look at the database itself.

Open the Database Doc Tool and select the connection you created for QuickCart.

Once the connection is established, DevScribe gives you access to the database and its available tables.

This gives you a quick overview of what’s actually present before you start working with the data.

Browse the Available Tables

A database can contain many tables, each responsible for a different part of an application.

For example, a shopping application might have tables such as:

users
products
orders

From DevScribe, you can browse the tables available in your connected database and select the one you want to inspect.

This is particularly useful when you’re working with a database you didn’t create yourself. Rather than having to figure out its structure from the application code or existing documentation, you can start by exploring the database directly.

Inspect the Data

After selecting a table, you can view the records stored in it.

This gives you a quick look at the actual data your application is working with.

For example, while developing a user registration feature, you might want to check whether the newly created user appears in the users table.

Similarly, when debugging an order-related feature, you can inspect the relevant table and see what records are currently stored.

You can use this view to quickly check:

• What data is currently stored
• What fields are present
• What records exist
• Whether the data looks as expected

Useful During Development and Debugging

You don’t always know exactly what you’re looking for when working on a project.

Sometimes you’re debugging an API and need to check whether the corresponding data exists. Sometimes you’re working on a feature and need to understand which tables contain the information you need.

Being able to inspect the database directly makes these checks much quicker.

Instead of leaving DevScribe, opening another database client, finding the right connection, and then locating the relevant table, you can inspect the database from the same workspace where you’re already working on the project.

Database + The Rest of Your Project

This is where having the database inside DevScribe becomes useful beyond simply viewing records.

Your database is one part of a much larger development workflow.

You might have:

Docker configuration

Database

API

Code

Documentation

With DevScribe, these resources can live together in the same workspace.

So when you’re working on an API and need to check its data, you can move from the API resource to the database. When you need to investigate a record, you can inspect the relevant table. When you need something more specific, you can use the query resources we’ve covered earlier.

The database doesn’t have to be a separate part of the workflow.

When Is Database Exploration Useful?

This becomes particularly useful when:

• Joining an existing project and trying to understand its database
• Debugging application behaviour by checking the underlying data
• Verifying changes after creating or updating records
• Exploring unfamiliar tables before writing queries
• Checking application data while developing a new feature

It gives you a quick way to answer a very simple question:

“What’s actually in my database right now?”

Explore Before You Query

Queries are useful when you know what information you’re looking for. But sometimes, the first step is simply understanding what’s there.

With the Database Doc Tool, you can connect, browse, inspect, and then query your database as needed, all within the same development workspace.

And because the database sits alongside your code, APIs, documentation, and other project resources, you don’t have to break your workflow every time you need to look at your data.

Your database is no longer something you have to switch to. It’s part of the workspace you’re already working in.