Building a great engineering culture isn't just a concern for developers -- it's essential for founders and product owners too.
These days, it feels like we've moved beyond just writing better code. The real question is: "What kind of environment helps great developers grow and teams thrive?"
What Is a Great Engineering Culture?#
A great engineering culture doesn't end with swapping out your tech stack or adding a few automation tools.
When team members feel psychologically safe to share their opinions and support each other's growth, technical skills naturally improve too.
An environment like this tends to have these characteristics:
- A culture of transparently sharing information and concerns
- An attitude of honestly surfacing problems and improving together
- Valuing collaboration quality just as much as code quality
- An atmosphere that permits experimentation and failure
Commits, Issues, Tests -- The Basics of Collaboration#
Automatically linking commit messages and issues makes managing development history much easier.
For example, you can set patterns in GitLab's config/gitlab.yml, or use special phrases in GitHub commit messages to auto-close issues.
When the system helps facilitate development communication, collaboration efficiency goes way up.
It's becoming standard to rigorously apply test code and linting from the commit-push stage and automatically manage code quality.
Adopting automated security testing like SAST, DAST, and IAST also boosts service reliability.
Thanks to test automation and consistent case management, handoffs between team members and collaboration become easier, and service stability improves.
An Environment for Continuous Growth#
Flow and growth are at the heart of a great engineering culture.
Organizations that consistently provide onboarding education and town-hall style information sharing can significantly boost the whole team's engagement.
By focusing on information sharing rather than approval processes, you create an environment where everyone can work autonomously.
The Role of Leadership and Teams#
A team leader should be more than just a manager -- they should be someone who identifies and helps with the problems team members face.
Rather than hiding issues, it's important to share them transparently, find alternatives together, and support the entire team's growth.
People's Growth Matters as Much as Good Code#
Clean code, logically designed architecture, well-maintained tests, and clear commit management are ultimately means for better collaboration and growth.
I believe a truly great engineering culture is naturally built in an atmosphere of "trusting each other and growing together."
Practical Tips for Auto-Linking Commits to Issues#
If you set issue-closing patterns in GitLab's config/gitlab.yml, commit messages like Fixes #123 will automatically close issues, boosting project management efficiency.
On GitHub, you can easily handle issues with close #number, resolve #number, etc. -- definitely a habit worth building.
Test Automation and Code Quality Management in Practice#
Test automation significantly increases code reliability, making it practically essential in modern software development.
The essence of testing isn't just running tests -- it's about creating "code that doesn't break when you maintain or restructure it later."
Security automation (SAST/DAST/IAST) and linting at the commit-push stage (flake8, pylint, etc.) are becoming increasingly common too.
Tips for Designing and Managing Test Cases#
- For key features, create multiple cases focused on valid values from specs, boundary testing, and edge cases by type.
- Practices vary by team, but many keep test cases around (not deleting them unless they're temporary code) since they're important for documentation and handoffs.
- Supporting independent test pipelines per branch makes both parallel work and quality management smoother.
- CLI conflicts and auto test file scanning issues can usually be resolved using test tools like jest.
- Modifying scripts in
.gitlab-ci.ymlshould follow team rules rather than individual preferences -- this helps with both management and quality.
Recommended Test Automation Tool: Robot Framework#
If you want to lower the barrier to test automation, I'd recommend Robot Framework.
You can define cases in human-readable syntax, and it works well with various languages, interfaces, and UI testing.
Testing Fundamentals: ISTQB Certification#
If you want to build a foundation in test design and quality management, studying for the ISTQB certification is an effective approach.
It bridges the gap between theory and practice and really helps upgrade your team's testing process culture.
Real-World Examples of Engineering Culture from Companies#
SOCAR, with the mission of "a world where everyone moves freely and happily," started with 100 cars in 2012 and reached 19,000 cars and 8.5 million members by 2023.
Going beyond simple car sharing, they've invested in expanding into a comprehensive platform including streaming mobility. They support team-wide growth through flow-focused environments, onboarding education, company-wide information sharing, and sharing-centered decision-making.
Living as a Programmer -- SOCAR CTO Seokmon Ryu's Story#
He emphasized that skill comes from repetition and consistency, and that it's essential to stop the habit of just copying legacy code and instead make the effort to understand the fundamentals.
- Clean code
- Sound logical thinking
These two are the keys to growth, and he said that for a service to be one customers actually use, the whole team needs to share the meaning of the code through approaches like ATDD (Acceptance Test-Driven Development).
Testing follows the TDD principle of repeating the Red (fail) -> Green (pass) -> Clean (refactor) cycle.
The Mindset for Surviving as a Developer#
Instead of obsessing over things you can't control (customers, requirement changes, deadlines, your boss, health, etc.),
focusing on what you can change -- your beliefs, work habits, reactions, and tools -- helps with growth and resilience.
Try building a habit of having honest conversations with yourself through journaling and retrospectives.
Ultimately, the essence of great engineering culture "starts with people and mindset, not code or tools."
Test automation, commit-issue linking, clean code habits, collaboration tools -- these are just "languages for communicating better and growing toward higher quality."
Where does your team's culture stand right now? Start with small changes.
The greatest minds are capable of the greatest vices as well as of the greatest virtues.
— Rene Descartes
