# What Database Does the VoiceStudio Backend Use? SQLite Implementation Guide

> Discover VoiceStudio's backend database choice: SQLite. Learn about its WAL journaling and foreign-key implementation with this guide.

- Repository: [Palash Debnath/VoiceStudio](https://github.com/debpalash/VoiceStudio)
- Tags: how-to-guide
- Published: 2026-09-11

---

**The VoiceStudio backend uses SQLite as its sole persistent data store, implementing WAL journaling and foreign-key enforcement through a custom connection manager in [`backend/core/db.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/core/db.py).**

The VoiceStudio project by `debpalash/VoiceStudio` relies on a lightweight, serverless database solution for managing voice profiles, generation history, and application state. Understanding what database the VoiceStudio backend uses is essential for developers contributing to the codebase or deploying the application locally. The backend implements SQLite with specific performance and integrity optimizations configured at the connection level.

## SQLite as the Primary Data Store

SQLite serves as the embedded database engine for all persistent storage needs in VoiceStudio. Unlike client-server databases such as PostgreSQL or MySQL, SQLite operates as an in-process library that reads and writes directly to disk files. This design choice eliminates separate server configuration while maintaining ACID compliance for voice profile data, job tracking metadata, and user settings.

The database file path is determined by the `core.config.DB_PATH` configuration variable, allowing flexible deployment across development and production environments without modifying connection logic.

## Core Database Implementation in [`backend/core/db.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/core/db.py)

The database layer is centralized in [`backend/core/db.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/core/db.py), which exposes two primary interfaces for database access: a direct connection factory and a transactional context manager.

### Connection Initialization with `get_db()`

The `get_db()` function establishes raw SQLite connections with production-ready pragmas enabled. According to the VoiceStudio source code, this function configures the connection with **Write-Ahead Logging (WAL)** mode for improved concurrency and enables **foreign key enforcement** to maintain referential integrity across tables.

```python

# Obtain a raw SQLite connection

from backend.core.db import get_db

conn = get_db()
cursor = conn.cursor()
cursor.execute("SELECT COUNT(*) FROM voice_profiles")
print("Number of profiles:", cursor.fetchone()[0])
conn.close()

```

### Safe Transaction Handling with `db_conn()`

For production code, VoiceStudio provides the `db_conn()` context manager, which guarantees that transactions are properly committed or rolled back and that connections are always closed, even when exceptions occur. This pattern prevents database locks and resource leaks during voice generation operations.

```python

# Use the provided context manager for safe transactions

from backend.core.db import db_conn

with db_conn() as conn:
    conn.execute(
        "INSERT INTO voice_profiles (id, name, created_at) VALUES (?, ?, ?)",
        ("profile-123", "My Voice", 1700000000.0),
    )

# Transaction is committed automatically; connection is closed afterwards.

```

## Alembic Migration Configuration

Schema versioning is handled through Alembic, configured in [`backend/migrations/env.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/migrations/env.py) to target the same SQLite database used by the application runtime. When no explicit `sqlalchemy.url` is provided in the environment configuration, the Alembic environment constructs the database URL as `sqlite:///<DB_PATH>`, ensuring migration scripts execute against the correct file.

This integration allows VoiceStudio to manage schema evolution for tables storing voice profiles, generation history, and application settings through standard Alembic revision files located in `backend/migrations/versions/`.

## Working with the VoiceStudio Database

Developers interacting with the VoiceStudio backend database should use the provided abstractions rather than instantiating raw SQLite connections directly. The `db_conn()` context manager is the recommended approach for all write operations, while `get_db()` is available for read-only queries or custom transaction logic.

All persistent data—including voice synthesis jobs, audio generation history, and configuration settings—resides within this single SQLite file, making backup and migration straightforward for self-hosted deployments.

## Summary

- **SQLite** is the exclusive database engine used by the VoiceStudio backend for all persistent storage.
- The [`backend/core/db.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/core/db.py) module provides `get_db()` for connections and `db_conn()` for transactional safety.
- Database connections enable **WAL journaling** and **foreign key constraints** by default.
- **Alembic** handles schema migrations via [`backend/migrations/env.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/migrations/env.py), targeting the same SQLite file defined by `core.config.DB_PATH`.

## Frequently Asked Questions

### What database does the VoiceStudio backend use?

The VoiceStudio backend uses **SQLite** as its sole database system. All voice profiles, generation history, job tracking data, and application settings are stored in a single SQLite file defined by the `DB_PATH` configuration variable.

### Where is the VoiceStudio database file located?

The database file location is controlled by `core.config.DB_PATH`, which is typically set to a local path within the project directory. For development environments, this often resolves to a `.db` file in the backend root or a dedicated `data/` directory.

### Does VoiceStudio support PostgreSQL or MySQL?

No. According to the source code in [`backend/core/db.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/core/db.py) and [`backend/migrations/env.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/migrations/env.py), VoiceStudio is architected specifically for SQLite. The connection logic and Alembic configuration hardcode SQLite-specific pragmas and URL schemes, making migration to other database engines require significant code modification.

### How are database migrations handled in VoiceStudio?

VoiceStudio uses **Alembic** for schema migrations. The migration environment in [`backend/migrations/env.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/migrations/env.py) automatically constructs a `sqlite:///` URL pointing to the configured `DB_PATH`. Migration scripts stored in `backend/migrations/versions/`—such as [`0001_phase1_settings_table.py`](https://github.com/debpalash/VoiceStudio/blob/main/0001_phase1_settings_table.py)—execute DDL operations against this SQLite database to create and modify tables.