DEV Community: Iugor Sette Pereira

How to Keep Your Work Commits on Your Personal GitHub Profile

Iugor Sette Pereira — Fri, 16 Oct 2026 12:22:56 +0000

How to Keep Your Work Commits on Your Personal GitHub Profile

Around 2018, when I started college, I created my GitHub account.

In 2022, when I got my first job as a software developer, I had to create my first professional account. That's when I started wondering:

How could I keep my work contributions on my personal GitHub profile?

The answer was simpler than I expected.

Your work commits can show up on your personal profile

Since I started working, I've used my professional email address for my Git commits.

By associating that email address with my personal GitHub account, my contributions can appear on my personal profile, even when I'm working on repositories owned by different companies.

I've worked at two companies so far, and my contributions from college also show up on my profile.

Of course, this doesn't mean I can access the source code of every repository I've contributed to.

Private repositories remain private. You can't inspect their code, check whether they have a README, or evaluate their implementation without the necessary permissions.

Even I can lose access to a company's repositories when I leave the organization.

But my contribution history can still be part of my personal GitHub profile.

Does an inactive GitHub profile mean an inactive developer?

I recently came across a discussion on LinkedIn about evaluating developers based on their GitHub activity, particularly when hiring senior engineers.

I don't think commit frequency on a personal GitHub profile is a reliable way to measure someone's experience.

Not every developer can publish their work publicly. Many contribute primarily to private company repositories, and some companies use different platforms for version control.

A developer might have years of experience building production systems without having a single public repository that reflects the complexity of their work.

And let's be honest: every company has its own way of working.

Some teams prioritize extensive documentation. Others follow the philosophy of "if it works, it works."

There are also programming principles that encourage writing code that communicates its intent clearly, reducing the need for unnecessary comments.

And what about README files?

I'll save that discussion for another day.

How to set it up

If you want your work contributions to appear on your personal GitHub profile, start by checking which email address you're using for your Git commits.

You can inspect it with:

git config user.email

If you're using your professional email, make sure that address is also associated with your personal GitHub account.
You can manage your email addresses in your GitHub account settings.

A few things to keep in mind:

Email association matters. GitHub uses the email address associated with a commit to link it to your account.
Private contributions can be displayed. GitHub lets you choose whether to show anonymized contributions from private repositories on your profile.
Not every commit necessarily counts. Contributions must meet GitHub's eligibility criteria, so simply associating an email address doesn't guarantee that every commit will appear in your contribution graph.

You can find more details in the GitHub documentation about contributions.

If you're unsure how to configure everything, you can also ask an AI assistant to walk you through the process.

Final thoughts

I'm not suggesting that GitHub activity is irrelevant when evaluating a developer. Personal projects can be great ways to demonstrate technical skills, problem-solving abilities, and architectural decisions.

My point is simply that an inactive-looking GitHub profile doesn't necessarily tell the whole story.

Before assuming a developer has stopped learning or contributing, remember that much of their work might happen behind private repositories and company accounts.

Sometimes, the contributions are there. You just need to understand how GitHub tracks them.

Have you ever had to deal with multiple GitHub accounts for personal and professional work? How do you manage your contributions?

What Sartre and Plato Taught Me About Software Architecture

Iugor Sette Pereira — Mon, 13 Jul 2026 16:26:54 +0000

A long time ago, after I finished high school, I enrolled in a Social Sciences program. I spent quite some time studying philosophy and philosophers such as Jean-Paul Sartre and Plato. I always had a great interest in that field, but I eventually changed paths and moved into Systems Analysis and Development. Interestingly, today I realize that many of those concepts are still present in the way I think about software.

When I was studying Sartre, one idea that always caught my attention was that existence precedes essence. Bringing this into software development (by adapting the idea), I like to think that a system exists because someone has a problem that needs to be solved. The architecture, the patterns, and even the choice of technologies should emerge as a consequence of that need, not as the starting point. Very often I see discussions beginning with "let's use microservices" or "let's use this framework," when perhaps the first question should be: what problem are we trying to solve?

Plato also makes me think about this when he talks about the World of Ideas. Before there is code, a database, or APIs, there is already a business domain, with its own rules, processes, and needs. Our job as developers is not to invent that domain, but to understand it and represent it as faithfully as possible in software. Maybe that's why concepts like Domain-Driven Design make so much sense to me.

From that perspective, DDD's Strategic Design reminds me precisely of this search for Plato's "World of Ideas." Before writing any code, we try to understand the essence of the domain: what the truly important concepts are, how they relate to one another, and what language best represents that reality. It's as if we were trying to see the "ideal form" of the business before materializing it in software.

Tactical Design, on the other hand, is the moment when that idea takes shape in the real world. Entities, Value Objects, Aggregates, and Repositories don't exist simply because DDD says we should use them; they are the concrete representation of the understanding built during Strategic Design. Just as, for Plato, the objects of the sensible world are imperfect manifestations of the Ideas, our code is also an attempt to represent, as faithfully as possible, the essence of the business domain.

In the end, I find it interesting to realize that ideas written more than two thousand years ago still help us understand modern problems. Perhaps software architecture has less to do with choosing frameworks and more to do with understanding the essence of the problem before thinking about the implementation. And, for me, that continues to be one of the most interesting aspects of software development.

Finally decided to stop just reading and start posting here

Iugor Sette Pereira — Thu, 19 Feb 2026 14:00:06 +0000

Hey! 👋

Finally decided to stop just reading and start posting here.

I’m a fullstack developer who spends most of the time building things, breaking them, fixing them, and learning along the way.

Currently working at Smart Leilões and gradually evolving as a software engineer, one project at a time.

Planning to share some projects, lessons, and real dev experiences here.