Conventional Commits encourages focus on the wrong things
Conventional Commits (CC) have become increasingly popular in software development, aiming to standardize commit messages for automated versioning and release notes. The promise is alluring: clearer history, automated changelogs, and a more structured approach to development. But in the high-stakes, rapidly evolving world of finance technology (FinTech), rigidly adhering to Conventional Commits can be a detriment, focusing teams on how they document changes rather than what changes deliver business value. This article explores why, and proposes alternative approaches better suited for the unique challenges of finance tech.
The Allure of Order: What Are Conventional Commits?
Before diving into the downsides, let’s quickly recap what Conventional Commits are. At their core, CC is a specification for adding human-readable and machine-parsable meaning to commit messages. A standard CC message follows this structure:
<type>[optional scope]: <description>
Where:
<type>: Categorizes the change (e.g.,feat,fix,docs,style,refactor,perf,test,chore).[optional scope]: Specifies the area of the codebase affected (e.g.,(auth),(payments),(reporting)).<description>: A concise summary of the change.
For example: feat(payments): Implement support for Apple Pay.
The intention is to allow tooling to automatically determine the semantic version bump (major, minor, patch) based on the commit types and generate release notes without manual effort. Tools like semantic-release and conventional-changelog automate this process. It sounds fantastic, and in many projects, it is.
Why Conventional Commits Fall Short in Finance Tech
While seemingly beneficial, the rigid structure of Conventional Commits often clashes with the realities of building and maintaining financial applications. Here's why:
1. Speed and Agility: A Finance Tech Imperative
FinTech operates at an incredibly fast pace. Market opportunities are fleeting. Regulations change constantly. Competitors are relentless. Spending significant time meticulously crafting commit messages to adhere to a strict format slows everything down. The mental overhead of classifying every change according to CC guidelines distracts developers from solving real financial problems. In a world of rapid iteration, velocity is king, and CC can feel like unnecessary bureaucracy.
2. The Focus on How, Not What
Conventional Commits excel at classifying how a change was made (a new feature, a bug fix). However, in finance, the what—the business impact of a change—is far more crucial. Did this change reduce fraud risk? Improve transaction processing time? Enable a new revenue stream? CC doesn't inherently prioritize capturing this business context. Developers might perfectly categorize a commit as fix(trading): Resolved issue with order execution, but the message lacks detail about the financial impact of the execution issue.
Consider this: a small change to a risk calculation engine might not be a feat or a fix in the conventional sense, but it could prevent millions in potential losses. CC’s categorization feels inadequate.
3. Complexity & The Gray Areas of Financial Logic
Financial systems are inherently complex. Many changes aren't cleanly categorized as a feat or a fix. They are often nuanced adjustments to complex algorithms, risk models, or regulatory reporting logic. Forcing these changes into pre-defined categories can lead to inaccurate classifications or overly verbose and unhelpful commit messages. Trying to shoehorn complex financial calculations into a simple feat or fix can mask the subtleties of the change and hinder understanding for future developers.
4. Regulatory Compliance and Auditability – A Different Kind of Versioning
Financial applications are subject to stringent regulatory requirements. Audit trails are critical. While CC provides a version history, it doesn't necessarily provide the required version history for compliance. Regulations often require detailed documentation of changes related to risk models, accounting practices, and reporting mechanisms – details that go far beyond the scope of a CC commit message. You’ll likely need supplemental documentation and change management processes in addition to CC, making the latter feel redundant.
5. The Illusion of Automation – Changelogs Still Need Human Review
While CC aims to automate changelog generation, automatically generated changelogs often lack the crucial context needed by stakeholders (business users, auditors, etc.). They are often too technical and don’t highlight the business value of the changes. Human review and editing are always required, negating some of the purported benefits of automation. You’ll still end up needing to translate technical commits into something understandable for non-technical colleagues.
Alternatives to Conventional Commits for Finance Tech
So, what alternatives can FinTech teams adopt that prioritize agility, business value, and compliance?
1. Focus on Descriptive, Business-Focused Commit Messages
Instead of rigidly adhering to a specific format, prioritize clear, concise, and business-focused commit messages. Ask developers to answer these questions in their commit messages:
- What problem does this change solve?
- What is the business impact of this change?
- What are the key risks associated with this change? (Especially important in finance!)
- What areas of the system are affected?
For example: “Implements fraud rule update to reduce false positives on international transactions, projected to save $50,000 per month. Affects transaction processing and risk scoring modules.”
This approach may require more effort initially to train developers, but it results in a more valuable and informative commit history.
2. Embrace Feature Flags
Feature flags (or feature toggles) allow you to deploy code changes without immediately exposing them to users. This promotes continuous integration and delivery without the pressure to get every commit perfectly categorized. You can deploy changes incrementally and monitor their impact closely. This is hugely valuable in finance, where cautious rollouts are essential. https://example.com/ (Consider a book on Feature Flags for more in-depth guidance).
3. Supplement with Dedicated Change Management Processes
Don’t rely solely on commit messages for documenting changes. Implement dedicated change management processes, especially for critical financial systems. These processes should include:
- Change Requests: Formal documentation outlining the purpose, scope, and risks of a change.
- Peer Reviews: Thorough code reviews by experienced developers.
- Testing & Validation: Rigorous testing to ensure the change functions as expected and doesn’t introduce new vulnerabilities.
- Audit Trails: Detailed logs of all changes, including who made them, when, and why.
4. Leverage Branching Strategies (e.g., Trunk-Based Development)
A well-defined branching strategy can improve code quality and reduce the risk of integration issues. Trunk-based development, where developers commit frequently to a single shared branch (the "trunk"), encourages smaller, more manageable changes and reduces the need for long-lived feature branches.
5. Use a Robust Issue Tracking System
Linking commits to specific issues in a robust issue tracking system (like Jira or Azure DevOps) provides crucial context and traceability. This allows you to easily understand the reasoning behind a change and track its progress.
The Bottom Line: Prioritize Value over Convention
Conventional Commits aren’t inherently bad. They can be beneficial in certain contexts. However, in the fast-paced, highly regulated world of finance technology, their rigidity can be counterproductive. Prioritize agility, business value, and compliance over strict adherence to a commit message format. Focus on capturing what changes deliver value, not just how they were made. Invest in robust change management processes and embrace practices like feature flags to ensure that your development efforts are aligned with your business goals and regulatory requirements. A slightly less “tidy” commit history is a small price to pay for faster innovation and reduced risk.
Disclaimer: This article contains affiliate links. If you purchase a product through one of these links, I may receive a commission. This does not impact the price you pay and helps support this website. I am not a financial advisor, and this article is for informational purposes only. Always consult with a qualified professional before making any financial decisions.