diff --git a/src/Tempest/Database/src/Builder/QueryBuilders/CountQueryBuilder.php b/src/Tempest/Database/src/Builder/QueryBuilders/CountQueryBuilder.php
new file mode 100644
index 000000000..f70e1ec0a
--- /dev/null
+++ b/src/Tempest/Database/src/Builder/QueryBuilders/CountQueryBuilder.php
@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Database\Builder\QueryBuilders;
+
+use Tempest\Database\Builder\ModelDefinition;
+use Tempest\Database\Builder\TableDefinition;
+use Tempest\Database\Exceptions\CannotCountDistinctWithoutSpecifyingAColumn;
+use Tempest\Database\Query;
+use Tempest\Database\QueryStatements\CountStatement;
+use Tempest\Database\QueryStatements\WhereStatement;
+use Tempest\Support\Conditions\HasConditions;
+
+/**
+ * @template TModelClass of object
+ */
+final class CountQueryBuilder
+{
+    use HasConditions;
+
+    private ?ModelDefinition $modelDefinition;
+
+    private CountStatement $count;
+
+    private array $bindings = [];
+
+    public function __construct(string|object $model, ?string $column = null)
+    {
+        $this->modelDefinition = ModelDefinition::tryFrom($model);
+
+        $this->count = new CountStatement(
+            table: $this->resolveTable($model),
+            column: $column,
+        );
+    }
+
+    public function execute(mixed ...$bindings): int
+    {
+        return $this->build()->fetchFirst(...$bindings)[$this->count->getKey()];
+    }
+
+    /** @return self<TModelClass> */
+    public function distinct(): self
+    {
+        if ($this->count->column === null || $this->count->column === '*') {
+            throw new CannotCountDistinctWithoutSpecifyingAColumn();
+        }
+
+        $this->count->distinct = true;
+
+        return $this;
+    }
+
+    /** @return self<TModelClass> */
+    public function where(string $where, mixed ...$bindings): self
+    {
+        $this->count->where[] = new WhereStatement($where);
+
+        $this->bind(...$bindings);
+
+        return $this;
+    }
+
+    public function andWhere(string $where, mixed ...$bindings): self
+    {
+        return $this->where("AND {$where}", ...$bindings);
+    }
+
+    public function orWhere(string $where, mixed ...$bindings): self
+    {
+        return $this->where("OR {$where}", ...$bindings);
+    }
+
+    /** @return self<TModelClass> */
+    public function whereField(string $field, mixed $value): self
+    {
+        $field = $this->modelDefinition->getFieldDefinition($field);
+
+        return $this->where("{$field} = :{$field->name}", ...[$field->name => $value]);
+    }
+
+    /** @return self<TModelClass> */
+    public function bind(mixed ...$bindings): self
+    {
+        $this->bindings = [...$this->bindings, ...$bindings];
+
+        return $this;
+    }
+
+    public function toSql(): string
+    {
+        return $this->build()->getSql();
+    }
+
+    public function build(array $bindings = []): Query
+    {
+        return new Query($this->count, [...$this->bindings, ...$bindings]);
+    }
+
+    private function resolveTable(string|object $model): TableDefinition
+    {
+        if ($this->modelDefinition === null) {
+            return new TableDefinition($model);
+        }
+
+        return $this->modelDefinition->getTableDefinition();
+    }
+}
diff --git a/src/Tempest/Database/src/Builder/QueryBuilders/QueryBuilder.php b/src/Tempest/Database/src/Builder/QueryBuilders/QueryBuilder.php
index e9fc0622e..750888951 100644
--- a/src/Tempest/Database/src/Builder/QueryBuilders/QueryBuilder.php
+++ b/src/Tempest/Database/src/Builder/QueryBuilders/QueryBuilder.php
@@ -47,4 +47,12 @@ public function delete(): DeleteQueryBuilder
     {
         return new DeleteQueryBuilder($this->model);
     }
+
+    public function count(?string $column = null): CountQueryBuilder
+    {
+        return new CountQueryBuilder(
+            model: $this->model,
+            column: $column,
+        );
+    }
 }
diff --git a/src/Tempest/Database/src/Exceptions/CannotCountDistinctWithoutSpecifyingAColumn.php b/src/Tempest/Database/src/Exceptions/CannotCountDistinctWithoutSpecifyingAColumn.php
new file mode 100644
index 000000000..ea2e9594e
--- /dev/null
+++ b/src/Tempest/Database/src/Exceptions/CannotCountDistinctWithoutSpecifyingAColumn.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Tempest\Database\Exceptions;
+
+use LogicException;
+
+final class CannotCountDistinctWithoutSpecifyingAColumn extends LogicException
+{
+    public function __construct()
+    {
+        parent::__construct('Cannot count distinct without specifying a column');
+    }
+}
diff --git a/src/Tempest/Database/src/QueryStatements/CountStatement.php b/src/Tempest/Database/src/QueryStatements/CountStatement.php
new file mode 100644
index 000000000..182cecb10
--- /dev/null
+++ b/src/Tempest/Database/src/QueryStatements/CountStatement.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Tempest\Database\QueryStatements;
+
+use Tempest\Database\Builder\TableDefinition;
+use Tempest\Database\Config\DatabaseDialect;
+use Tempest\Database\QueryStatement;
+use Tempest\Support\Arr\ImmutableArray;
+
+use function Tempest\Support\arr;
+
+final class CountStatement implements QueryStatement
+{
+    public bool $distinct = false;
+
+    public function __construct(
+        public readonly TableDefinition $table,
+        public ?string $column = null,
+        public ImmutableArray $where = new ImmutableArray(),
+    ) {}
+
+    public function compile(DatabaseDialect $dialect): string
+    {
+        $query = arr([
+            sprintf(
+                'SELECT COUNT(%s)',
+                $this->getCountArgument(),
+            ),
+            sprintf('FROM `%s`', $this->table->name),
+        ]);
+
+        if ($this->where->isNotEmpty()) {
+            $query[] = 'WHERE ' . $this->where
+                ->map(fn (WhereStatement $where) => $where->compile($dialect))
+                ->implode(PHP_EOL);
+        }
+
+        return $query->implode(PHP_EOL);
+    }
+
+    public function getCountArgument(): string
+    {
+        return $this->column === null || $this->column === '*'
+            ? '*'
+            : sprintf(
+                '%s`%s`',
+                $this->distinct ? 'DISTINCT ' : '',
+                $this->column,
+            );
+    }
+
+    public function getKey(): string
+    {
+        return "COUNT({$this->getCountArgument()})";
+    }
+}
diff --git a/src/Tempest/Database/tests/QueryStatements/CountStatementTest.php b/src/Tempest/Database/tests/QueryStatements/CountStatementTest.php
new file mode 100644
index 000000000..2e6682afa
--- /dev/null
+++ b/src/Tempest/Database/tests/QueryStatements/CountStatementTest.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace Tempest\Database\Tests\QueryStatements;
+
+use PHPUnit\Framework\TestCase;
+use Tempest\Database\Builder\TableDefinition;
+use Tempest\Database\Config\DatabaseDialect;
+use Tempest\Database\QueryStatements\CountStatement;
+
+final class CountStatementTest extends TestCase
+{
+    public function test_count_statement(): void
+    {
+        $tableDefinition = new TableDefinition('foo', 'bar');
+
+        $statement = new CountStatement(
+            table: $tableDefinition,
+            column: null,
+        );
+
+        $expected = <<<SQL
+        SELECT COUNT(*)
+        FROM `foo`
+        SQL;
+
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::MYSQL));
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::POSTGRESQL));
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::SQLITE));
+    }
+
+    public function test_count_statement_with_specified_column(): void
+    {
+        $tableDefinition = new TableDefinition('foo', 'bar');
+
+        $statement = new CountStatement(
+            table: $tableDefinition,
+            column: 'foobar',
+        );
+
+        $expected = <<<SQL
+        SELECT COUNT(`foobar`)
+        FROM `foo`
+        SQL;
+
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::MYSQL));
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::POSTGRESQL));
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::SQLITE));
+    }
+
+    public function test_count_statement_with_distinct_specified_column(): void
+    {
+        $tableDefinition = new TableDefinition('foo', 'bar');
+
+        $statement = new CountStatement(
+            table: $tableDefinition,
+            column: 'foobar',
+        );
+
+        $statement->distinct = true;
+
+        $expected = <<<SQL
+        SELECT COUNT(DISTINCT `foobar`)
+        FROM `foo`
+        SQL;
+
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::MYSQL));
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::POSTGRESQL));
+        $this->assertSame($expected, $statement->compile(DatabaseDialect::SQLITE));
+    }
+}
diff --git a/tests/Integration/Database/Builder/CountQueryBuilderTest.php b/tests/Integration/Database/Builder/CountQueryBuilderTest.php
new file mode 100644
index 000000000..19847807d
--- /dev/null
+++ b/tests/Integration/Database/Builder/CountQueryBuilderTest.php
@@ -0,0 +1,158 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Tempest\Integration\Database\Builder;
+
+use Tempest\Database\Builder\QueryBuilders\CountQueryBuilder;
+use Tempest\Database\Exceptions\CannotCountDistinctWithoutSpecifyingAColumn;
+use Tests\Tempest\Fixtures\Modules\Books\Models\Author;
+use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
+
+use function Tempest\Database\query;
+
+/**
+ * @internal
+ */
+final class CountQueryBuilderTest extends FrameworkIntegrationTestCase
+{
+    public function test_simple_count_query(): void
+    {
+        $query = query('chapters')
+            ->count()
+            ->where('`title` = ?', 'Timeline Taxi')
+            ->andWhere('`index` <> ?', '1')
+            ->orWhere('`createdAt` > ?', '2025-01-01')
+            ->build();
+
+        $expected = <<<SQL
+        SELECT COUNT(*)
+        FROM `chapters`
+        WHERE `title` = ?
+        AND `index` <> ?
+        OR `createdAt` > ?
+        SQL;
+
+        $sql = $query->getSql();
+        $bindings = $query->bindings;
+
+        $this->assertSame($expected, $sql);
+        $this->assertSame(['Timeline Taxi', '1', '2025-01-01'], $bindings);
+    }
+
+    public function test_count_query_with_specified_asterisk(): void
+    {
+        $query = query('chapters')
+            ->count('*')
+            ->build();
+
+        $sql = $query->getSql();
+
+        $expected = <<<SQL
+        SELECT COUNT(*)
+        FROM `chapters`
+        SQL;
+
+        $this->assertSame($expected, $sql);
+    }
+
+    public function test_count_query_with_specified_field(): void
+    {
+        $query = query('chapters')->count('title')->build();
+
+        $sql = $query->getSql();
+
+        $expected = <<<SQL
+        SELECT COUNT(`title`)
+        FROM `chapters`
+        SQL;
+
+        $this->assertSame($expected, $sql);
+    }
+
+    public function test_count_query_without_specifying_column_cannot_be_distinct(): void
+    {
+        $this->expectException(CannotCountDistinctWithoutSpecifyingAColumn::class);
+
+        query('chapters')
+            ->count()
+            ->distinct()
+            ->build();
+    }
+
+    public function test_count_query_with_specified_asterisk_cannot_be_distinct(): void
+    {
+        $this->expectException(CannotCountDistinctWithoutSpecifyingAColumn::class);
+
+        query('chapters')
+            ->count('*')
+            ->distinct()
+            ->build();
+    }
+
+    public function test_count_query_with_distinct_specified_field(): void
+    {
+        $query = query('chapters')
+            ->count('title')
+            ->distinct()
+            ->build();
+
+        $sql = $query->getSql();
+
+        $expected = <<<SQL
+        SELECT COUNT(DISTINCT `title`)
+        FROM `chapters`
+        SQL;
+
+        $this->assertSame($expected, $sql);
+    }
+
+    public function test_count_from_model(): void
+    {
+        $query = query(Author::class)->count()->build();
+
+        $sql = $query->getSql();
+
+        $expected = <<<SQL
+        SELECT COUNT(*)
+        FROM `authors`
+        SQL;
+
+        $this->assertSame($expected, $sql);
+    }
+
+    public function test_count_query_with_conditions(): void
+    {
+        $query = query('chapters')
+            ->count()
+            ->when(
+                true,
+                fn (CountQueryBuilder $query) => $query
+                    ->where('`title` = ?', 'Timeline Taxi')
+                    ->andWhere('`index` <> ?', '1')
+                    ->orWhere('`createdAt` > ?', '2025-01-01'),
+            )
+            ->when(
+                false,
+                fn (CountQueryBuilder $query) => $query
+                    ->where('`title` = ?', 'Timeline Uber')
+                    ->andWhere('`index` <> ?', '2')
+                    ->orWhere('`createdAt` > ?', '2025-01-02'),
+            )
+            ->build();
+
+        $expected = <<<SQL
+        SELECT COUNT(*)
+        FROM `chapters`
+        WHERE `title` = ?
+        AND `index` <> ?
+        OR `createdAt` > ?
+        SQL;
+
+        $sql = $query->getSql();
+        $bindings = $query->bindings;
+
+        $this->assertSame($expected, $sql);
+        $this->assertSame(['Timeline Taxi', '1', '2025-01-01'], $bindings);
+    }
+}