There is a particular kind of silence after you open your first pull request on a big open-source project. You have read the contributing guide twice, run the checks three times, and now your one small change is sitting in a queue next to work from people who have been shipping to this codebase for years. You refresh the page more often than you would admit.

Mine landed on 14 October 2026. It was merged into Kestra, the open-source orchestration platform with 30,000+ stars on GitHub. The diff was one line.

One line. And it still taught me more about contributing to open source than any tutorial I had read.

The issue: a table with no left margin

It started with a good first issue, which is exactly the label it sounds like. Issue #19915, filed 29 September 2026, was titled "[Concurrency Limits] Table needs left margin and should match the other table pages."

The problem was plain to see. On the Tenant > Concurrency Limits page, the table's first column started hard against the sidebar, with no gap at all, and the table ran to the right edge of the window. Every other table page in the app had a comfortable gutter. This one did not.

What made the issue genuinely good for a first-timer was not the bug itself. It was the write-up. The reporter had included reproduction steps, a screenshot, and a "Where to look" section pointing at the page component (ui/src/components/admin/ConcurrencyLimits.vue) and at the standard gutter definition in ui/src/styles/app.scss. It even flagged a related follow-up issue, #16564, about page gutters in general, and made clear this issue only needed the fix on this one page.

That scoping mattered. A first contribution should have edges you can see. This one did.

Finding the real cause: not the page, the shared component

My first instinct was the obvious one: patch the Concurrency Limits page itself, add the margin there, done. But before writing anything I read how the other table pages got their gutter, and that is where the interesting part was.

The pages that looked right did not each carry their own margin. They got it from the shared table component, KsDataTable, which applies a no-selection-gutter class to its first column. The Concurrency Limits page rendered its table through KsDataTable's custom #table slot, and that slot's wrapper never received the class. The page was not broken. The shared component had a gap, and this page was the one that fell through it.

So the fix belonged in one place, not on one page:

- <div v-if="hasTableSlot" class="ks-data-table-content ks-data-table-content--slot"> + <div v-if="hasTableSlot" class="ks-data-table-content ks-data-table-content--slot" :class="{'no-selection-gutter': !hasSelectionColumn && !noFirstColumnGutter}"> <slot name="table" /> </div> 

in ui/packages/design-system/src/components/Data/KsDataTable/KsDataTable.vue.

The two guards are the whole point of the fix. The class only applies when the table has no selection column, and it respects the component's existing noFirstColumnGutter opt-out. I was not inventing a new spacing rule. I was plugging the slot path into the rule the component already had, with its own escape hatches intact.

That is the lesson I keep coming back to: in a mature codebase, the best fix usually already exists somewhere. Your job is to find it and extend its reach by the smallest amount possible.

What confirmed the diagnosis was the sibling code sitting a few lines below. The component has two rendering paths: one for pages that pass their table through the custom #table slot, and one for the default path where the component renders its own KsTable. The default path already carried the class binding. The slot path did not:

<!-- custom slot path: the gutter was missing here --> <div v-if="hasTableSlot" class="ks-data-table-content ks-data-table-content--slot"> <slot name="table" /> </div> <!-- default path: the gutter was already applied here --> <div v-else ref="container" class="ks-data-table-content" :class="{'no-selection-gutter': !hasSelectionColumn && !noFirstColumnGutter, ...}"> <KsTable ... /> </div> 

Two adjacent branches, one with the treatment and one without. Once you see that, the fix writes itself, and you can be confident it is the right fix rather than a workaround, because it makes the two paths consistent instead of adding a special case. (I checked the develop branch while writing this: the merged fix is still there, in exactly this spot.)

The part that took longer than the fix

Writing the line took minutes. Everything around it took the rest of the afternoon, and that is the part nobody warns you about.

Kestra's PR template has a frontend checklist, and I treated it as a gate, not decoration:

  • Type checking passes (npm run check:types)
  • Code builds without errors (npm run build)
  • Unit tests pass (npm run test:unit)
  • Screenshots or video attached showing the UI change

I ran all three commands, attached before/after screenshots of the Concurrency Limits page in light mode, and described the root cause in the PR body instead of just pasting the diff. The screenshots were the most useful part. A reviewer can approve a one-line class change in seconds when they can see the gutter appear; without them, they have to check out the branch and look for themselves, which is a much bigger ask.

The review came from maintainer @elevatebart on 5 October: "That will improve style by a wide margin." Approved, no changes requested. Nine days later, on 14 October, the PR was merged.

I will not pretend I stayed calm through the wait. But the wait itself was instructive. A merged PR is not just code that works. It is code a maintainer was willing to own after you. The checklist, the screenshots, the root-cause write-up: all of that is how you lower the cost of saying yes.

(And yes, the PR body contained a cat joke about keeping an eye on the gutter. Reviewers are people. A little personality in a PR description costs nothing.)

What I would tell anyone doing their first one

1. Pick an issue that tells you where to look. A good good first issue has reproduction steps, a screenshot, and a pointer to the relevant files. If an issue has none of those, it is not a good first issue, whatever the label says.

2. Read the shared component before you touch the page. The bug you see on one page often lives one layer down, in the component every page shares. Fixing it there fixes the class of bug, not the instance. Fixing it on the page just moves the inconsistency somewhere else.

3. Reuse the existing pattern. My fix added no new CSS and no new class. It applied a class the codebase already had, guarded by conditions the component already understood. Small diffs that reuse existing machinery are the easiest diffs to review, and reviewability is a feature.

4. Treat the PR template as the real work. Checks, screenshots, and a root-cause description are not admin. They are the difference between a PR a maintainer merges in a spare minute and one that sits for a month.

5. Small is a strategy, not a failure. A one-line fix that ships teaches you the whole pipeline: issue, fork, branch, checks, review, merge. A 500-line feature attempt that stalls teaches you mostly frustration. Start with the pipeline.

The honest limits

Let me be straight about what this was and was not.

It was a cosmetic fix: one class binding, one file, one line changed. It was not a feature, not a performance win, and not an architectural decision. The good first issue label and the reporter's excellent write-up did a lot of the hard work before I arrived; I found the right layer and applied the existing pattern.

One merged PR does not make me a Kestra contributor in any meaningful sense. The related issue #16564, about page gutters across the app in general, is still open, and that is the bigger, messier job. If I go back, that is where the real contribution sits.

But the pipeline is no longer theoretical for me. I know what a maintainer's approval looks like, what a merge feels like, and how much of the work happens before and after the code itself. That is worth a one-line diff.

Over to you

What was your first merged open-source PR, and what did it teach you that the code itself did not? If you have been circling a good first issue for weeks, what is stopping you from opening it?

Links: Issue #19915 · PR #20224 · Kestra on GitHub