Ops

Uninterrupted service, global redundancy, multi-zone backups, rapid software delivery, powerful analytics six 9’s 99.9999% uptime target

  • JAVA
  • Python
  • Go
  • JavaScript
  • C/C++

Cloud architecture

  • Efficient — ensure you pay only for the resources you truly need and scale smoothly when the need arises.
  • Manageable — introduce a clear and well-structured software ecosystem that helps manage all stages of software development with ease.
  • Simple — the solutions that I build are with simplicity in mind and come with detailed instructions and team training.
  • Precise — harnessing the power of Kubernetes helps allocate resources and removes overhead while ensuring all software development operations have sufficient coverage.

CI/CD

Always following the main principle of DevOps, providing Continuous Integration and Continuous Deployment ensures customers benefit from a predictable, reliable workflow, with the product running well at all times and updates delivered without issue.

  • Fast — CI results in smaller, faster updates that can be reverted if anything goes wrong.
  • Error-proof — CI makes use of automated tests that run on every commit, which means errors can be detected and fixed at once.
  • Iterative — with CD, every successfully tested commit simulates the software release process. At any point in time, you have a working product and are able to evaluate the development progress  
  • Solid — when every commit is tested automatically, and the product is built at once, QA specialists receive a solid piece of software to lay their hands on. This helps them emulate the real customer experience, as there is no better testing than real-life usage.

Automation

Following the “infrastructure as a code” paradigm, time-consuming, routine tasks can be automated. This frees up resources to focus on what matters, like continuous product improvement and ensuring the best customer experience.

  • Consistency — when the majority of testing and deployment is automated, there is less room for human mistakes and much better system consistency, leading to more reliable workflow, software development, and deployment.
  • Accessibility — new team members can onboard and begin collaborating much faster when there is a necessary code infrastructure instead of separate hierarchical silos.
  • Ease of transition — an automated environment can be easily moved from on-prem cloud to public cloud and vice versa when needed; minimizes potential resource overhead and operational expenses.
  • Redeployability — automated deployment using Kubernetes to operate Docker containers allows launching or relocating complete environments in minutes and with merely a few clicks, without interacting with the rest of the ecosystem.

Testing

Provide automated unit testing for each commit to ensure new updates do not affect the existing feature set and do not impair the functionality of the deployed product. This builds the developer’s self-confidence while freeing up QA resources for extensive product testing overall, rather than testing each small unit individually.

  • Efficiency — when automated tests are successfully run against individual units of code, the resulting product build can be securely pushed to production within minutes, ensuring smooth and reliable feature addition within a tight schedule.
  • Quality — when developers know there is an automated QA system in place, they prefer smaller commits with simpler functions, resulting in better code quality and fewer errors overall.
  • Reusability — Instead of performing manual testing, the use of automated tests ensures high reusability of these tools, resulting in a drastic reduction in testing time and a subsequent increase in productivity.
  • Debugging ease — if errors occur, only the latest commits need to be debugged, greatly reducing debugging time and shortening the overall time to market.

Security

Ensure a high degree of automation across all processes in the software development pipeline, leaving little room for human-originated errors and potential security breaches. More to say: this helps document all the steps from the very first code commit through to the product release, making audit and compliance checks much easier.

  • Integrity — when the code is written with security in mind from the very beginning, and security checks after each commit become as common as other automated tests, the resulting code is breach-proof and solid.
  • Continuity — using testing automation makes all processes transparent and enables short-loop software development, where security concerns are addressed quickly throughout the entire code delivery process.
  • Rapidness — when security checks are an integral part of code approval that takes place after each code commit, appearing possible breach points are easily tracked and can be rapidly closed.
  • Authenticity — by creating transparent and traceable software environments, DevOps limits the number of potential security breach points and makes it easy to trace who gained access to which system and when.

Logging

Committed to detailed logging of all the events that occur within the software development pipeline. Having extensive, well-structured development documentation at hand ensures the ability to track progress and efficiency in the development process.

  • Debugging — detailed logs serve as excellent sources for debugging, enabling short loops of error discovery and fixing.
  • Correlation — logs of the system resources used for an operation allow correlating these figures with the estimated numbers and discovering possible bottlenecks much more easily.
  • Production troubleshooting — sophisticated logging tools enable real-time parsing of logs and troubleshooting performance issues on the fly.
  • Data structuring — modern logs are much more than they were a decade ago. They are not raw streams of data and can be structured from the very beginning to create invaluable insights on website traffic, app performance, and other business metrics that help evaluate the ROI and product efficiency overall.

Monitoring

Provide diligent monitoring of the staging and production environments to ensure an uninterrupted customer experience and stable, high-performing app operations.

  • Production monitoring — monitor the performance of multiple apps within separate environments and take action at once if a problem occurs, instead of dealing with the consequences.
  • Cost-effectiveness — in-depth monitoring helps visualize app usage patterns and scale the resource pool to ensure the most cost-effective allocation of resources.
  • Marketing research — configure various monitoring tools in order to extract valuable real-time data like average app usage time, funnel/conversion rates, typical app usage patterns, and provide invaluable insights regarding the ways of product improvement.
  • Application performance — stable performance is key to delivering a positive user experience. Monitoring app response times, the speed of key transactions, database query efficiency, and resource utilization helps identify new ways to improve app updates and areas for improvement.

Alerting

Waiting for a few hours for a response from the support team is a nightmare for any customer, whether an individual or a business. Timely alerts on key events help keep a hand on the pulse and make important decisions quickly.

  • Push notifications — set up a system to send SMS, email, or phone calls to ensure important events are escalated to the correct specialists quickly and minimize potential downtime.
  • Correct scheduling — compose schedules weeks in advance to ensure On-Call specialists are in place to act if needed.
  • Better collaboration — smart alerts already contain crucial information about the error’s origin and are directed to the specialists responsible for resolving such issues, which shortens error resolution times.

1. If I have to copy-paste the same piece of code in more than two places, then I will move it to a commonplace so that other functions can refer to this block of code.

2. If my function is doing more than 2 tasks or operations, or the size of this function is growing beyond a certain line of code, it is time to break it into smaller functions.

3. If I have to do the same mundane task manually multiple times, then I will take a break from the work, automate it using a script, and pat my own back.

4. All my class members are private by default. If a class function needs to be accessed externally, I will write detailed function-level docs and make them public.

5. My code will follow standard design patterns. Makes a predictable code construct and reduces the chance of bugs, too.

6. My functional coding task will only be deemed complete when it gets checked in with Code coverage and extensive unit tests.

7. All my classes except static Utility classes and Value Objects will be coded to the interface. Makes extensibility easy and follows O of SOLID.