Actuaries today are entrusted with building and maintaining models that influence a multitude of critical business decisions. As models become more complex, an important question emerges: How to manage model changes transparently, collaboratively and reliably.
Many actuaries have often relied on shared drives, naming conventions, and perhaps even a “changelog tab” in Excel to track formula changes or assumption updates over time. This can often lead to a familiar confusion of files such “Model_Final_v23.xlsm” and uncertainty about which version is truly authoritative. With the tools available in today’s environment, there’s a more robust pattern actuaries can follow.
The software world solved this problem decades ago through version control systems (VCS)—tools designed to track and manage changes to files. The most widely used of these today, Git, has been spreading into actuarial teams and offering a structured way to govern models and meet rising expectations for transparency and accountability.
What Is Git?
Git is not a programming language. It does not calculate reserves or run projections. Instead, it is a distributed version control system (VCS)—a tool that records every change to files over time and allows multiple people to work together without overwriting one another’s work.[1]
- Technical definition: Git is a distributed VCS that manages files and tracks changes, typically operated through either command-line applications or integrated graphical interfaces.
- Plain language: Git is a tool that keeps track of changes to files, making it easy for people to work together on the same project without losing or overwriting work.
The Origins of Git
Git was created in 2005 by Linus Torvalds, best known as the author of the Linux operating system kernel. When Linux developers needed a different tool for collaboration on development, Torvalds designed Git to be free, open source, and capable of supporting distributed collaboration[2]. He is quoted in a 2016 Ted Talk stating, “So Git is my second big project, which was only created for me to maintain my first big project [Linux].”
What started as a solution for one of the largest open-source projects quickly became the global standard. Today, Git underpins almost all modern software development and, increasingly, actuarial modeling.
Why Version Control Matters to Actuaries
Version control addresses issues that actuaries already recognize as part of model governance:
- Traceability: Every change is logged—who made it, when, and why—creating a built-in audit trail [3].
- Reproducibility: Past results can be recreated, even years later.
- Collaboration: Multiple team members can contribute without overwriting each other’s work [4].
- Error Recovery: Mistakes can be undone by rolling back to prior versions [5].
- Transparency: Peer review of assumptions, logic, and documentation becomes straightforward.
In short, version control helps actuaries meet both professional standards and auditor expectations for accuracy and documentation.
Other Version Control Systems: Context for Git
Outside of Git, several other VCS systems are available:
- Subversion (SVN): A centralized version control system long popular in the early 2000s; still retains usage in some engineering and legacy software teams[6].
- Mercurial (Hg): A distributed system valued for simplicity and ease of learning, though its adoption has declined relative to Git[7].
These systems laid the groundwork, but today Git has become the de facto standard in the software world—adopted by over 85% of developers globally [8].
GitHub and the Actuarial Profession
Part of Git’s success is due to platforms like GitHub, GitLab, BitBucket, and others, which layer collaboration tools and an easy-to-use website on top of Git repositories. These tools allow teams to:
- Propose changes via “pull requests” for peer review.
- Track issues, bugs, or enhancement ideas.
- Store documentation alongside models in a transparent, versioned way.
- Provide auditors with a single, authoritative source of truth.
The Society of Actuaries Research Institute maintains GitHub repositories for public actuarial research [9] and the Casualty Actuarial Society has launched its own CAS GitHub organization [10].
Common Use Cases in Insurance and Consulting
Actuarial teams are starting to use Git in several practical ways:
- Model Development: Storing Python, R, or even Excel-based models in repositories, with version tags enhancements and customized comments.
- Assumption Management: Tracking changes to lapse, mortality, or expense assumptions with clear commit messages and supporting documentation.
- Peer Review: Using pull requests to encourage collaborative review of models before changes go live.
- Audit Preparation: Providing regulators with complete history logs instead of manual memos and email chains.
- Training & Research: Encouraging junior actuaries to learn Git as part of a broader technical upskilling.
Tangible Examples
- Imagine a Python model for calculating a reserve for a life insurance product that needs two separate updates—the mortality table and the lapse assumption. Using a tool like git, two separate individuals can both make a change separately, and they can be brought together for testing and sign-off.
- Imagine a SQL Query that your team runs every month to extract a list of policyholders to perform a particular control. While you can have this tracked on a network drive, placing it along with other business-critical queries inside a Git repository and hosting in a secure location at your company can provide robust documentation for future changes to the monthly or quarterly process.
- Imagine you have a complex Excel model used to calculate Disabled Life Reserve for a disability product. Git can be used to track quarterly assumption updates. Desktop tools like spreadsheet compare can help highlight the differences between larger commits of more complex Excel files.
Challenges to Adoption
Adopting Git does require overcoming hurdles:
- Learning Curve: Command-line tools can seem intimidating to actuaries used to Excel. Graphical tools (like GitHub Desktop or VS Code integration) help bridge the gap.
- Legacy Models: Converting large spreadsheet models into version-controlled environments takes time and requires some additional configuration, such as large file storage (LFS).
- Governance Standards: Teams need conventions for commit messages, branching strategies, and review protocols.
- Data Security: Sensitive data should not be stored directly in repositories; only code and metadata belong there.
The Path Forward
As the profession embraces more programming, analytics, and data science, Git is becoming an essential skill and practice for actuaries. The path forward includes:
- Making Git the default for new projects.
- Incorporating version control into model governance policies.
- Providing training and mentorship to build comfort across actuarial staff.
- Using Git-based repositories to meet requirements for audit trails and reproducibility.
Adopting Git is not about turning actuaries into software developers—it is about applying proven tools to the unique challenges of actuarial modeling.
Conclusion
The actuarial profession is evolving. Models are bigger, more complex, and more collaborative than ever before. Regulators, management, and auditors demand transparency and reproducibility. Git provides a practical, proven way to meet those demands.
By embracing version control, actuaries strengthen the integrity of their work, align with global best practices, and prepare the profession for the data-driven future ahead.
AI Disclosure
This article was developed by the author with editorial and language support from ChatGPT-5, an artificial intelligence tool, to enhance clarity and readability. All final content, conclusions, and viewpoints are those of the author.
This article is provided for informational and educational purposes only. Neither the Society of Actuaries nor the respective authors’ employers make any endorsement, representation or guarantee with regard to any content, and disclaim any liability in connection with the use or misuse of any information provided herein. This article should not be construed as professional or financial advice. Statements of fact and opinions expressed herein are those of the individual authors and are not necessarily those of the Society of Actuaries or the respective authors’ employers.
Edward Cody, FSA, CERA, is corporate vice president & actuary at New York Life. Edward can be contacted at Edward_M_Cody@newyorklife.com.
Endnotes
- Microsoft. “What Is Git?” Microsoft Learn. https://learn.microsoft.com/en-us/devops/develop/git/what-is-git (accessed September 23, 2025).
- Torvalds, Linus. 2016. The Mind Behind Linux. TED Talk, filmed February 2016, posted February 2016. Available at: https://www.ted.com/talks/linus_torvalds_the_mind_behind_linux (accessed September 23, 2025). Video Time for quote: 8 minutes 41 seconds.
- Chacon, Scott, and Ben Straub. 2014. Pro Git. 2nd ed. New York: Apress. Full text available at: https://git-scm.com/book/en/v2 (accessed September 23, 2025).
- Ibid., 3.
- Ibid., 3.
- Stack Overflow Blog. 2023. “Beyond Git: The Other Version Control Systems Developers Use.” Stack Overflow Blog, January 9, 2023. https://stackoverflow.blog/2023/01/09/beyond-git-the-other-version-control-systems-developers-use/(accessed September 23, 2025).
- Ibid., 6.
- JetBrains. “Team Tools — State of Developer Ecosystem 2023.” JetBrains, 2023. https://www.jetbrains.com/lp/devecosystem-2023/team-tools/ (accessed September 23, 2025).
- Society of Actuaries Research Institute. GitHub Organization. https://github.com/Society-of-actuaries-research-institute (accessed September 23, 2025).
- Casualty Actuarial Society. GitHub Organization. https://github.com/casact (accessed September 23, 2025).