Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance

SEO Metadata

SEO Title Options

1. Laravel Eloquent Relationships: HasManyThrough, MorphMany
2. Laravel Laravel: Practical 2026 Guide
3. Laravel Playbook: Laravel Laravel

Meta Description Options

1. Learn Laravel Laravel with a practical Laravel framework, expert mistakes, implementation steps, examples, FAQ, and schema-ready guidance.
2. Deep-dive into complex Eloquent relationships, N+1 problem detection with Telescope, eager loading strategies, and query optimization.

URL Slug

laravel-eloquent-relationships-hasmanythrough-morphmany-performance

Focus Keyword

Laravel Laravel

Additional LSI Keywords

• Laravel
• Eloquent
• Relationships
• Database
• Performance
• Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance
• production checklist
• implementation guide
• best practices
• architecture decisions
• testing strategy
• performance impact

Table of Contents

• Article overview
• What Laravel Laravel means
• Why it matters now
• Implementation framework
• Practical comparison
• Expert workflow
• Common mistakes
• Media and link plan
• Original technical deep dive
• FAQ
• Structured data
• Conclusion

Article overview

Laravel Laravel is the kind of topic that looks simple until it reaches production. Teams usually discover the real cost late: unclear boundaries, weak defaults, hidden maintenance work, and decisions that seemed harmless when the codebase was small.

The problem gets worse when the article, tutorial, or implementation guide only explains the happy path. This guide closes that gap with a practical framework, a comparison table, common mistakes, and a deep technical section you can use while planning real work.

Keep reading for the non-obvious part: the safest implementation is rarely the most impressive-looking one. It is the one your team can debug, test, document, and evolve without turning every future change into archaeology.

Key Takeaways

• Laravel Laravel should be evaluated as a production decision, not only as a syntax or tooling choice.
• The best implementation keeps responsibilities visible, with clear ownership, tests, documentation, and rollback paths.
• Search visibility improves when practical depth, structured answers, and expert examples live on the same page.

[IMAGE: A mobile-first technical article layout showing the main concept, decision table, implementation checklist, and FAQ blocks. Alt: Laravel Laravel expert guide for Laravel]

What Laravel Laravel means

Laravel Laravel means applying laravel knowledge to a concrete engineering decision, then turning that decision into reliable code, documentation, and operational behavior. In practice, it combines the topic's core concepts with trade-off analysis, implementation boundaries, testing strategy, and maintenance discipline.

This is the definition worth optimizing for featured snippets because it avoids hype. It tells the reader what the topic does and what a professional implementation must include.

Why it matters now

The technical web is more crowded than it was a few years ago. Thin tutorials can still get indexed, but they rarely earn trust from senior developers, buyers, AI answer systems, or teams that need production guidance.

For laravel topics, the strongest content now has three layers:

• a clear answer for fast scanning
• a practical framework for implementation
• expert context that explains what breaks later

That same structure helps search engines understand the page. It also helps readers decide whether the advice fits their project.

Implementation framework

Use this framework before adopting the approach described in this article.

1. Define the user problem and the production risk.
2. Identify the smallest reliable implementation boundary.
3. Keep configuration, secrets, and environment-specific behavior outside the article's core logic.
4. Add tests for the behavior that would hurt if it regressed.
5. Document the trade-off, not only the final code.
6. Measure the result with logs, metrics, or user-facing outcomes.
7. Revisit the decision after real usage exposes edge cases.

The sequence is deliberately conservative. It keeps the work grounded in outcomes instead of novelty.

[IMAGE: A seven-step implementation framework with discovery, boundary design, configuration, tests, documentation, measurement, and iteration. Alt: Laravel Laravel implementation framework]

Practical comparison

This table is intentionally practical. It gives a reviewer something to check before the implementation becomes expensive to change.

Expert workflow

Expert tip: "Treat Laravel Laravel as a system boundary. If the next developer cannot find where the decision lives, how it is tested, and when it should be avoided, the implementation is not finished."

A useful workflow is simple:

• Start with the smallest working example.
• Add the constraints that exist in your real project.
• Remove anything that only demonstrates cleverness.
• Write down the failure modes.
• Add links to related decisions so future readers can navigate the topic cluster.

That last point matters for both humans and search systems. A single article can answer a question; a cluster proves authority.

Common mistakes

Mistake 1: Copying a pattern without its context

A pattern that works in a small demo can fail in a real application. The missing context is usually data volume, team experience, deployment process, security requirements, or observability.

Before copying the pattern, ask what assumption made it safe in the original example.

Mistake 2: Putting business logic in the wrong layer

This is the fastest way to make future debugging expensive. In Laravel, PHP, and server-rendered websites, presentation should receive prepared data, not discover rules on its own.

Keep decision logic in models, actions, services, policies, requests, jobs, or documented helpers where it can be tested directly.

Mistake 3: Optimizing for novelty instead of maintainability

Newer tools and language features can be valuable. They can also hide simple behavior behind unfamiliar syntax.

Use the option that makes the next production incident easier to understand.

Mistake 4: Publishing without a measurement plan

If the article describes a performance, SEO, security, or architecture improvement, define how success will be checked. Logs, tests, crawl diagnostics, analytics, and user behavior are all stronger than assumptions.

[IMAGE: A common-mistakes board with context loss, wrong layer, novelty bias, and missing measurement highlighted. Alt: Laravel Laravel common mistakes]

Media and link plan

Image placeholders

• [IMAGE: A concept diagram for Laravel Laravel with input, decision boundary, implementation, tests, and production feedback. Alt: Laravel Laravel concept diagram]
• [IMAGE: A mobile screenshot-style checklist for Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance. Alt: Laravel Laravel mobile checklist]
• [IMAGE: A comparison table visualization for strong versus weak implementation choices. Alt: Laravel Laravel comparison table]

Video placeholder

[VIDEO: Insert a 5-8 minute YouTube walkthrough that demonstrates the main decision, the implementation boundary, the test strategy, and the production caveats for Laravel Laravel.]

Trustworthy outbound links

• Laravel official documentation - use this as the trust reference for current framework behavior.
• Google Search quality guidance - use this as the trust reference for people-first content and E-E-A-T alignment.

Internal linking opportunities

• Internal guide: Laravel Pulse: Real-Time Application - use this when readers need a related Laravel follow-up.
• Internal guide: Laravel Octane: Turbocharged PHP With Swoole - use this when readers need a related Laravel follow-up.

Original Technical Deep Dive

The useful mental model

Eloquent relationships are query builders with conventions. They are not magic object graphs.

That distinction matters when a page gets slow. Most relationship performance problems come from one of these:

• A loop accesses a lazy relationship.
• A relationship loads too many rows.
• A relationship loads too many columns.
• A count loads full models.
• A polymorphic relationship stores unstable class names.
• A through relationship is missing the indexes its join needs.
• A serializer or API resource touches relationships the controller did not load.

The fix is rarely "stop using Eloquent." The fix is to make the relationship explicit, load only what the request needs, and measure the SQL that actually runs.

Example domain

Use a small project management domain:

accounts
  id
  name

projects
  id
  account_id
  name

tasks
  id
  project_id
  title
  status
  due_at

comments
  id
  commentable_type
  commentable_id
  user_id
  body
  created_at

An account has many projects. A project has many tasks. A task and a project can both have comments.

This gives us two useful relationship types:

• Account -> tasks through Project.
• Project|Task -> comments through a polymorphic morphMany.

Schema first

Good relationship performance starts in the migration.

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('accounts', function (Blueprint $table): void {
            $table->id();
            $table->string('name');
            $table->timestamps();
        });

        Schema::create('projects', function (Blueprint $table): void {
            $table->id();
            $table->foreignId('account_id')->constrained()->cascadeOnDelete();
            $table->string('name');
            $table->timestamps();

            $table->index(['account_id', 'created_at']);
        });

        Schema::create('tasks', function (Blueprint $table): void {
            $table->id();
            $table->foreignId('project_id')->constrained()->cascadeOnDelete();
            $table->string('title');
            $table->string('status', 32)->index();
            $table->timestamp('due_at')->nullable();
            $table->timestamps();

            $table->index(['project_id', 'status']);
            $table->index(['project_id', 'due_at']);
        });

        Schema::create('comments', function (Blueprint $table): void {
            $table->id();
            $table->string('commentable_type');
            $table->unsignedBigInteger('commentable_id');
            $table->foreignId('user_id')->constrained()->cascadeOnDelete();
            $table->text('body');
            $table->timestamps();

            $table->index(['commentable_type', 'commentable_id', 'created_at']);
            $table->index(['user_id', 'created_at']);
        });
    }
};

The indexes match the relationships and common filters:

• projects.account_id for account project lookups.
• tasks.project_id for project task lookups.
• tasks.project_id, status for filtered task dashboards.
• comments.commentable_type, commentable_id, created_at for polymorphic comment timelines.

Do not add indexes because they look professional. Add them because a real query needs that lookup or ordering path.

HasManyThrough

hasManyThrough is for one intermediate model.

In this domain, an Account has many Task models through Project.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasManyThrough;

final class Account extends Model
{
    public function projects(): HasMany
    {
        return $this->hasMany(Project::class);
    }

    public function tasks(): HasManyThrough
    {
        return $this->hasManyThrough(Task::class, Project::class);
    }
}

With Laravel's conventions, Eloquent expects:

projects.account_id -> accounts.id
tasks.project_id    -> projects.id

If your keys are different, pass them explicitly:

public function tasks(): HasManyThrough
{
    return $this->hasManyThrough(
        Task::class,
        Project::class,
        'account_id',
        'project_id',
        'id',
        'id',
    );
}

The arguments are:

Current Laravel also supports fluent through syntax when the intermediate relationships already exist:

public function tasks(): HasManyThrough
{
    return $this->through('projects')->has('tasks');
}

That version reuses the key conventions from projects() and Project::tasks(), which is easier to maintain when the relationship names are already clear.

Through relationship constraints

Do not define a second relationship for every dashboard variant.

Keep the broad relationship simple:

public function tasks(): HasManyThrough
{
    return $this->hasManyThrough(Task::class, Project::class);
}

Add request-specific constraints at query time:

$overdueTasks = $account->tasks()
    ->where('tasks.status', 'open')
    ->where('tasks.due_at', '<', now())
    ->orderBy('tasks.due_at')
    ->limit(50)
    ->get();

[IMAGE: Supporting visual 1 for Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance, showing Laravel Laravel decisions, examples, and Laravel, Eloquent, Relationships. Alt: Laravel Laravel laravel-eloquent-relationships-hasmanythrough-morphmany-performance visual 1]

[IMAGE: Supporting visual 1 for Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance, showing Laravel Laravel decisions, examples, and Laravel, Eloquent, Relationships. Alt: Laravel Laravel laravel-eloquent-relationships-hasmanythrough-morphmany-performance visual 1]

Use table-qualified columns in complex relationships. It prevents ambiguous column errors once joins enter the query.

For a list of accounts with counts, do not load every task:

$accounts = Account::query()
    ->select(['id', 'name'])
    ->withCount([
        'tasks',
        'tasks as open_tasks_count' => fn ($query) => $query->where('tasks.status', 'open'),
    ])
    ->orderByDesc('open_tasks_count')
    ->paginate(25);

withCount() adds count attributes without hydrating every related row.

MorphMany

Use morphMany when one child table belongs to more than one parent model type.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphOne;

final class Project extends Model
{
    public function comments(): MorphMany
    {
        return $this->morphMany(Comment::class, 'commentable');
    }

    public function latestComment(): MorphOne
    {
        return $this->morphOne(Comment::class, 'commentable')->latestOfMany();
    }
}

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphMany;

final class Task extends Model
{
    public function comments(): MorphMany
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

The child owns the inverse:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\MorphTo;

final class Comment extends Model
{
    public function commentable(): MorphTo
    {
        return $this->morphTo();
    }

    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}

Then both parents can create comments:

$task->comments()->create([
    'user_id' => $request->user()->id,
    'body' => (string) $request->string('body'),
]);

Use a morph map

By default, Laravel stores fully qualified class names in the polymorphic type column. That makes the database depend on PHP class names.

Use a morph map before the table fills with class strings:

<?php

namespace App\Providers;

use App\Models\Project;
use App\Models\Task;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Support\ServiceProvider;

final class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Relation::enforceMorphMap([
            'project' => Project::class,
            'task' => Task::class,
        ]);
    }
}

This stores stable values such as project and task. If you add this to an existing app, migrate old commentable_type values in the database before enabling strict enforcement everywhere.

The hidden MorphMany N+1

This looks safe:

$tasks = Task::with('comments')->latest()->limit(50)->get();

foreach ($tasks as $task) {
    foreach ($task->comments as $comment) {
        echo $comment->commentable->title;
    }
}

It is not safe. You eager loaded comments, but inside the inner loop you walk back from each Comment to its parent commentable. Without parent hydration, that can query the parent again for each comment.

Current Laravel supports chaperone() for this:

public function comments(): MorphMany
{
    return $this->morphMany(Comment::class, 'commentable')->chaperone();
}

Or opt in per query:

$tasks = Task::with([
    'comments' => fn ($comments) => $comments
        ->chaperone()
        ->latest(),
])->get();

If your Laravel version does not support chaperone(), avoid child-to-parent traversal in that loop. Use the parent you already have:

$tasks = Task::with('comments.user')->latest()->limit(50)->get();

foreach ($tasks as $task) {
    foreach ($task->comments as $comment) {
        echo $task->title;
        echo $comment->user->name;
    }
}

Do not assume "I used with()" means every path inside the loop is loaded.

Eager loading strategy

Start from the response shape.

For a project dashboard that renders project, account, open task count, and the latest comment:

$projects = Project::query()
    ->select(['id', 'account_id', 'name', 'created_at'])
    ->with([
        'account:id,name',
        'latestComment:id,commentable_type,commentable_id,user_id,body,created_at',
        'latestComment.user:id,name',
    ])
    ->withCount([
        'tasks as open_tasks_count' => fn ($query) => $query->where('status', 'open'),
    ])
    ->latest()
    ->paginate(20);

Include the keys Eloquent needs:

• Parent primary key.
• Foreign key on child.
• Polymorphic type and ID columns.
• Any key needed by nested relationships.

This is wrong:

Project::with('comments:id,body')->get();

Eloquent cannot match those comments back to projects without commentable_type and commentable_id.

This is usable:

Project::with([
    'comments:id,commentable_type,commentable_id,user_id,body,created_at',
    'comments.user:id,name',
])->get();

For list pages, prefer a count or one latest related model over loading an unbounded comment timeline. Put the full comments list behind its own paginated endpoint.

Use relationship existence queries

Do not filter in PHP after loading too much data.

Bad:

$projects = Project::with('tasks')->get()
    ->filter(fn (Project $project) => $project->tasks->contains('status', 'blocked'));

Good:

$projects = Project::query()
    ->whereHas('tasks', fn ($query) => $query->where('status', 'blocked'))
    ->withWhereHas('tasks', fn ($query) => $query->where('status', 'blocked'))
    ->get();

whereHas() filters parents by related rows. withWhereHas() filters and eager loads the matching related rows using the same condition.

[IMAGE: Supporting visual 2 for Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance, showing Laravel Laravel decisions, examples, and Laravel, Eloquent, Relationships. Alt: Laravel Laravel laravel-eloquent-relationships-hasmanythrough-morphmany-performance visual 2]

For polymorphic parents, constrain each type explicitly:

use Illuminate\Database\Eloquent\Relations\MorphTo;

$comments = Comment::query()
    ->with(['commentable' => function (MorphTo $morphTo): void {
        $morphTo->constrain([
            Project::class => fn ($query) => $query->where('archived', false),
            Task::class => fn ($query) => $query->where('status', '!=', 'done'),
        ]);
    }])
    ->latest()
    ->paginate(50);

Eloquent runs separate queries for each morphTo type when eager loading. That is expected. The mistake is letting each type load unconstrained when the page only needs active records.

[IMAGE: Supporting visual 2 for Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance, showing Laravel Laravel decisions, examples, and Laravel, Eloquent, Relationships. Alt: Laravel Laravel laravel-eloquent-relationships-hasmanythrough-morphmany-performance visual 2]

Lazy loading guardrail

In development and test, lazy loading should be noisy.

<?php

namespace App\Providers;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\ServiceProvider;

final class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Model::preventLazyLoading(! $this->app->isProduction());
    }
}

If throwing exceptions is too disruptive during cleanup, log violations first:

Model::handleLazyLoadingViolationUsing(function (Model $model, string $relation): void {
    logger()->warning('Lazy loaded Eloquent relationship.', [
        'model' => $model::class,
        'relation' => $relation,
    ]);
});

Do not enable this and ignore the logs. The whole point is to make accidental relationship access visible before it becomes production traffic.

Telescope query watcher

Telescope does not magically fix N+1 queries. It records the raw SQL, bindings, and execution time for queries, and it tags slow queries.

Install and publish it in a non-production environment:

composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate

Then lower the query watcher threshold while profiling:

// config/telescope.php

'watchers' => [
    Watchers\QueryWatcher::class => [
        'enabled' => env('TELESCOPE_QUERY_WATCHER', true),
        'slow' => 50,
    ],
],

Use it like this:

1. Open the route or API endpoint.
2. Go to Telescope's request entry.
3. Read the query list.
4. Look for repeated SQL with different bindings.
5. Fix the controller query.
6. Reload the request and compare query count and total time.

The N+1 smell usually looks like this:

select * from `users` where `users`.`id` = ? limit 1
select * from `users` where `users`.`id` = ? limit 1
select * from `users` where `users`.`id` = ? limit 1
select * from `users` where `users`.`id` = ? limit 1

Fix by loading the relationship once:

$comments = Comment::query()
    ->with(['user:id,name'])
    ->latest()
    ->paginate(50);

If the query is slow but not repeated, eager loading is not the fix. Add or change an index, reduce selected columns, change the predicate, or review the query plan in the database.

Lightweight query logging

For focused debugging, DB::listen() is often enough:

use Illuminate\Database\Events\QueryExecuted;
use Illuminate\Support\Facades\DB;

DB::listen(function (QueryExecuted $query): void {
    if ($query->time < 50) {
        return;
    }

    logger()->debug('Slow SQL query.', [
        'time_ms' => $query->time,
        'sql' => $query->toRawSql(),
    ]);
});

For a request-level budget, use cumulative query time:

use Illuminate\Database\Connection;
use Illuminate\Database\Events\QueryExecuted;
use Illuminate\Support\Facades\DB;

DB::whenQueryingForLongerThan(300, function (Connection $connection, QueryExecuted $event): void {
    logger()->warning('Request exceeded database query budget.', [
        'connection' => $connection->getName(),
        'last_query_ms' => $event->time,
        'last_query' => $event->toRawSql(),
    ]);
});

This catches the endpoint that runs 80 fast queries. Telescope will show the detail; the budget alert tells you a request crossed the line.

API resources can reintroduce N+1

This resource can trigger lazy loading:

public function toArray($request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'account' => [
            'id' => $this->account->id,
            'name' => $this->account->name,
        ],
        'open_tasks' => $this->tasks()->where('status', 'open')->count(),
    ];
}

The resource is now making relationship decisions after the query has already run.

Make the controller own the load plan:

$projects = Project::query()
    ->select(['id', 'account_id', 'name'])
    ->with('account:id,name')
    ->withCount([
        'tasks as open_tasks_count' => fn ($query) => $query->where('status', 'open'),
    ])
    ->paginate();

Then the resource only reads loaded data:

public function toArray($request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'account' => AccountResource::make($this->whenLoaded('account')),
        'open_tasks' => $this->open_tasks_count,
    ];
}

If an API resource calls a relationship method with (), it is probably issuing a new query. If it reads a loaded relationship property, it is using loaded data.

Pagination before relationships

Avoid loading a huge parent set and then slicing it in memory.

[IMAGE: Supporting visual 3 for Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance, showing Laravel Laravel decisions, examples, and Laravel, Eloquent, Relationships. Alt: Laravel Laravel laravel-eloquent-relationships-hasmanythrough-morphmany-performance visual 3]

Bad:

$projects = Project::with(['tasks', 'comments'])->get()->take(20);

Good:

$projects = Project::query()
    ->with(['tasks', 'comments'])
    ->latest()
    ->paginate(20);

Pagination limits the parent rows before eager loading related rows. That keeps memory and query result sizes bounded.

For exports or background jobs, process chunks:

Project::query()
    ->with('account:id,name')
    ->where('archived', false)
    ->chunkById(500, function ($projects): void {
        foreach ($projects as $project) {
            // Export one chunk at a time.
        }
    });

Never export a million-row relationship graph into memory because the first test database had 300 rows.

Relationship checklist

Before merging a relationship-heavy endpoint:

• Does the controller define every relationship the view/resource touches?
• Are nested relationships loaded with dot syntax or nested arrays?
• Are constrained relationships filtered in SQL, not PHP collections?
• Are counts done with withCount() or loadCount()?
• Are aggregate values done with withSum(), withAvg(), withMin(), or withMax()?
• Are selected columns limited without dropping required keys?
• Are polymorphic type values stable via a morph map?
• Are commentable_type and commentable_id indexed together?
• Are through relationship join keys indexed?
• Does Telescope show repeated SQL?
• Is lazy loading prevented or logged outside production?
• Does the test assert query count for important endpoints?

[IMAGE: Supporting visual 3 for Laravel Eloquent Relationships: HasManyThrough, MorphMany & Performance, showing Laravel Laravel decisions, examples, and Laravel, Eloquent, Relationships. Alt: Laravel Laravel laravel-eloquent-relationships-hasmanythrough-morphmany-performance visual 3]

The query count matters more than the relationship type. hasManyThrough and morphMany are fine when the database can answer the query and the application loads only the graph it actually renders.

FAQ

What is Laravel Laravel?

Laravel Laravel is a practical laravel topic that should be evaluated through implementation scope, production risk, testing, documentation, and long-term maintainability.

When should a team use Laravel Laravel?

Use Laravel Laravel when it solves a real project constraint, improves clarity, or reduces operational risk. Avoid it when it only adds novelty or hides behavior from future maintainers.

What is the biggest risk with Laravel Laravel?

The biggest risk is copying a pattern without its context. Production systems need clear boundaries, rollback options, tests, and observability before a technique becomes dependable.

How do you test Laravel Laravel?

Test the smallest unit that owns the behavior, then add integration coverage for the path users or systems actually rely on. Include failure cases, configuration differences, and regression checks.

How does Laravel Laravel affect SEO and AI search visibility?

It improves visibility when the article gives a direct answer, expert context, structured headings, internal links, trustworthy references, and FAQ content that matches the visible page.

Conclusion

Laravel Laravel is worth doing when the implementation improves clarity, reliability, or delivery speed. It is not worth doing when it hides ownership, increases operational risk, or makes the system harder to explain.

Use the framework above as a review checklist. Then connect this topic to the rest of the project documentation so readers can move from concept to implementation without losing context.