Establish a basic integration test suite if you don't already have one. There is not going to be continuous anything without automated integration testing. With automated integration testing, you can have confidence that changes, whether they are big fixes or feature enhancements, don't accidentally introduce new defects. Often legacy code bases aren't written to be easily testable at a unit level. Concentrate on integration testing the application at its consumption points. For web UIs, that means automated functional testing of the UI or at least the REST web service resources. For APIs consumed by other applications, it means integration testing the service endpoints.
Unit testing is always important, and I never discourage it. Integration testing is more important as it tests end-user functionality, not just small sections of code. If you have no automated tests, start with integration testing first. You can implement unit tests for new features along the way.
Ideally, the environment for integration testing should be established by infrastructure code before the tests and eliminated after. That said, I'm concentrating on the initial steps in this post and don't want to deviate.
Management support is needed for funding automated testing. That funding is both labor and tooling. Initial setup for automated testing has an upfront cost. Remember that there is a broad range between 0% and 100% coverage. The higher the percentage, the better. That said, higher percentages have diminishing returns. Don't let perfection be the enemy of progress.
Establish a continuous integration pipeline (CI) for the main/master source code branch of you don't already have one. Continuous integration is a firm requirement to continuous delivery. The CI pipeline should run automatically on check-in of code changes. Continuous integration identifies defects immediately after changes are checked in by executing all available unit and integration tests. The objective is to identify defects as early in the development process as possible.
If continuous integration (CI) reveals an error, fixing the error is the highest priority. Many pundits would say that this type of breakage should result in an "all hands on deck" type of emergency and should enlist all members of the team to fix it. As a practical matter, the developer who checked in the change that broke CI is usually the best person to fix it. They know what they did and are closer to the problem. The developer's tech lead can follow up with the developer at some point to identify any additional resources needed to fix the issue.
Adopt trunk-based development and eliminate long-lived feature branches. Trunk-based code management is a requirement for continuous anything. Trunk-based development ensures that developers are using the newest and most current code base. This minimizes the chances of "merge hell" and keeps all team members up to date and working on the current code.
Depending on your CI/CD tooling, it might be easier to use a short-term feature branch and initiate CI on merge. These feature branches must be short-lived or you're not really adopting trunk-based development. As long as the short-term branch gets deleted after the merge, this isn't a bad tactic.
Only start changes that can be completed in four hours or less. Two hours is better. Break the change up into smaller pieces if it's longer than that. This reduces merge issues later. This also reduces the chance that another team member introduces a conflicting change. This practice provides an incentive to keep changes small and only make one change at a time. This is in keeping with the objective of delivering new features to users faster. All good.
Eliminate the practice of reviewing pull requests. Allow automated testing to catch defects. If a junior developer checks in code that isn't optimal, a more senior member of the team can refractor that change later and hopefully take the opportunity to educate the junior team member on the issue. Either way, if it didn't break CI, not much damage was done.
Encouraging automated test coverage will change developer behavior. If developers "know" they will be expected to produce automated tests for changes they make, they will code to make testing easier. It's enlightened self-interest. That also makes the code base cleaner and increases its quality.
Continuous delivery is an ongoing, neverending process. The beginning tactics I list here are just a start.