14 Best Practices Software Developers Should Never (Ever) Skip

At Revelry, we believe – no matter the project type or development methodology – certain engineering best practices should always be upheld. These fundamental practices help assure the quality, efficiency, and maintainability of the software we create. And, while the specific implementation of these processes can vary based on team size, project complexity, and partner needs, we apply them each and every day.

Best Practice #1: Version Control

1. Use a version control system (VCS). Our Revelry team uses Git. 
2. Make regular commits with clear, detailed messages. Doing so makes collaboration easier.
3. Adhere to a branching strategy, so that multiple engineers can work together on the same codebase without causing conflicts or disrupting the application.

Best Practice #2: Code Review

1. Require peer review of all code changes before merging. We think of this as code quality assurance, where we check one another’s work.
2. Use pull/merge requests.

Best Practice #3: Automated Testing & Continuous Integration

1. Use unit testing for individual components, integration testing for system interactions, and end-to-end testing for full workflows. And don’t dismiss the value of manual testing throughout your project.
2. Use a CI service/tool to run tests automatically and continuously on every push to the main repository.
3. Integrate code changes regularly.

Best Practice #4: Documentation

1. Make sure all documentation is clear, concise, and easy to understand.
2. Maintain your documentation; treat it with the same importance as source code.
3. Documentation should always include: code documentation, system architecture documentation, API documentation, and user guides and README files.

Best Practice #5: Security Practices

1. Use only secure and reputable cloud service providers (e.g. AWS, Google Cloud, Fly.io, etc.). 
2. Always adhere to applicable regulations (e.g. HIPAA, PCI DSS, GDPR). 
3. Enforce secure coding practices (e.g. strong credentials management, VPNs for remote work, regular security reviews and training, etc.).
4. Regularly conduct security audits and dependency vulnerability scans/screenings.

Best Practice #6: Code Quality Monitoring

1. Adhere to agreed-upon coding standards (e.g. formatting, naming conventions, etc.).
2. Use static code analysis tools to help identify code issues without executing it.
3. Refactor code as needed to maintain code quality.

Best Practice #7: Performance Monitoring and Optimization

1. Conduct regular performance testing.
2. Profile and optimize critical paths to reduce latency and improve performance.
3. Monitor production performance metrics on an ongoing basis.

Best Practice #8: Error Handling and Logging

1. Utilize error handling strategies.
2. Log every detail. Doing so makes it easier to identify and address issues. 

Best Practice #9: Database Management

1. Use version control for database schemas.
2. Remember that data migration is much more than a copy / paste job; always rely on a data migration strategy.
3. Assure regular backups and recovery testing.

Best Practice #10: Deployment Processes

1. Utilize automated deployment pipelines and environment-specific configurations.
2. Use rollback strategies. They’re a critical safety net.

Best Practice #11: Configuration Management

1. Utilize separation of code and configuration, a.k.a. configuration as code (CaC).
2. Utilize environment-specific configuration handling.
3. Securely store and manage secrets (e.g. certificates, SSH keys, API keys, credentials, tokens, passwords, and sensitive data).

Best Practice #12: Code Reusability and Modularity

1. Design patterns for maintainable code.
2. Create reusable components and libraries.
3. Utilize clear separation of concerns in architecture, making it easier to understand, design, and manage complex systems.

Best Practice #13: Requirements Management

1. Clearly document requirements.
2. Ensure traceability between requirements and implementation.
3. Regularly review and update requirements.

Best Practice #14: Continuous Learning and Improvement

1. Conduct regular retrospectives / post-mortems. At Revelry, we do these bi-weekly, using the time to discuss what felt bad, what was awesome, and specific things we can do to improve upon those pain points as we move forward. 
2. Share what you know, including lessons learned the hard way. 
3. Ask questions.
4. Be open to constructive feedback.

To learn more about Revelry’s approach to software design and development, connect with our team or take a peek at our proven process.

---

Code Quality Code Review Culture Process Security