Wondering how to deploy DevOps for small teams? DevOps is a growing field of strategy and execution in companies of all sizes. It speeds up time to market, enables quicker rollouts, and makes for happier developers, operations managers, and customers.
We’re going to talk about what DevOps is, how large companies deploy it, and what lessons and tips small companies can glean and deploy right now.
What Is DevOps?
DevOps is a tricky term to define, mainly because it encompasses an array of practices. Basically, DevOps is a combination of two things for the purposes of better communication: “Dev” stands for “developers” and “Ops” for operations.
DevOps, then, is usually a group of both code developers and system operations managers who collaborate to break down knowledge silos — in essence, to make sure that they’re always on the same page when it comes to developing and deploying code effectively.
DevOps means effective communication between departments. It means working together to create strategies for one department that make life easier for the other department. It also generally means more code automation, smaller chunks of code, source control systems, and maybe a few more meetings.
But what happens without DevOps?
Why is DevOps needed?
Traditionally, operations managers maintain the production environment — that is, everything the customers and clients interact with.
Developers, on the other hand, work behind the scenes, creating code in the testing environment — an area walled off from the production environment. This development environment, ideally, simulates the production environment and how the code or app works in the real world.
In practice, this means developers write code in their bubble and send it off to deploy in the production environment, where operations managers have to figure out how to keep everything working and stable while integrating the new code. And developers are usually too busy with coding new features, and ops managers are too busy just trying to keep every plate spinning, so time for communication and environment rehaul is short.
And while DevOps takes a little time to set up and get going, the results can make any company — big or small — more agile and more competitive.
DevOps at Large Companies
DevOps is a slam dunk at large companies. With a high number of developers and a large enough codebase, development and deployment of code can be a titanic struggle.
Large companies have more customers. More customers mean more servers, often more features, and more strain on the network. This creates a larger codebase, which means even small tweaks can have a cascade effect in the environment. And since large companies are often trying to get out new features to stay competitive in the market, they need the development environment and the production environment to be in lockstep.
Companies like Netflix, Amazon, and Target have embraced DevOps to streamline their services. The integration of their development environment with their production environment (alongside heavy automation) allows Netflix and Amazon to deploy thousands of times per day.
Amazon uses a system of continuous deployment and automated source control to check revisions automatically, putting them through the build and test process without human interference.
NASA employs a similar system, using a combination of Amazon’s AWS service and containerized data systems to allow NASA data specialists to share telemetry data and analysis with their engineers at a constant pace.
But those companies and organizations are enormous. How can a small team even approach that level of organization and automation? How does DevOps for small teams work in the wild?
DevOps Solutions Small Teams Can Adopt
Small teams don’t have the same bandwidth as larger companies — both in the number of people, departments, and resources. However, that ends up being a double-edged sword because, in general, smaller teams already use many DevOps solutions. Even if it’s unintentional.
However, that doesn’t mean there isn’t work to be down. Right now, only 25% of the software industry is pulling off DevOps at a high level.
And other DevOps tools and strategies can be nabbed from larger companies and employed just as effectively.
1. Make a DevOps Team
If you don’t have a large team of developers, creating a stand-alone DevOps team is probably out of the question. If you have one developer and one systems manager, or those roles are filled by the same person, the idea of a “team” could even feel silly.
And that’s okay. It’s not necessarily about creating some kind of task force — it’s just about communication. Even if you have one developer and one IT manager, your form of a DevOps “team” might be a weekly meeting and daily asynch updates to keep each other informed of what’s going on.
The team’s primary goals should be to align the development environment with the production environment, write (and deploy) smaller chunks of code more often, and increase automation and source control.
Let’s talk about what those things mean and how they can be accomplished.
2. Align Practices and Environments
Even small teams can start aligning their environments by giving the developers more access to the production environment, even just for monitoring how revisions affect the final product.
Try giving your dev team a running feed of the network status, even if it’s just on a monitor in the corner. They can see immediately how their deployed code may be affecting traffic or note if there is a sudden drop that could be a major problem.
You’ll also need the DevOps team to create a strategy for making the development testing environment and the actual production environment as close as possible — identical, ideally. It will involve lots of meetings and a strong documentation project to not only get the environments in line but also keep them in line as changes happen over time.
Aligning the two environments means the operations team is spending less time trying to retrofit developer code into the realities of the final product.
3. Deploy Smaller Chunks of Code
The third step is to get out of the mindset of the big update. Large code revisions can take weeks or months to get tested, approved, and deployed. This slows down feature rollouts and generally makes you less competitive in the marketplace. It also makes you less agile in the event of a new, exciting trend or a catastrophic problem.
One of the keys to expanding DevOps for small teams at your company is to get into the mindset of writing smaller chunks of code and deploying them faster. These should be small enough that they can be tested and implemented in a matter of hours.
4. Embrace Automation and Source Control
The final path to successful DevOps for small teams is the heavy use of automation.
Why automation? For one, automation speeds up code testing and deployment. It also frees up time for both the developers and the operations managers to enact the DevOps strategies listed above. This extra time also allows your Dev and Ops teams to focus on things that improve the business instead of just putting out fires. And, lastly, it increases efficiency and accuracy of documentation, both of which have their own merits for onboarding, education, and compliance.
You’ll first need something that helps you build and test code all the time, at any time. An app like Jenkins or Bitrise can help facilitate continuous integration and delivery.
Then, you’ll need a source control platform to track and manage revisions in the code. Platforms like GitHub and SourceForge can aid you here.
The next step in the chain will be a configuration management system for keeping up consistency and quality across the board. Tools like Chef or SaltStack are great places to start.
New Relic creates a platform for observing all of your systems and is extremely useful for monitoring this kind of end-to-end code automation.
It may also be a good idea to look into dynamic configuration in case you do have to quickly pivot the entire automated system in a new direction.
Implementing DevOps for Small Teams and Small Organizations
Don’t worry that your team or company is too small to effectively implement DevOps. Instead, think of these tools as a buffet table from which you can pull organizational ideas.
No organization, no matter its size, is going to be hurt by more communication, more accountability, and greater and more granular revision tracking.
