Ops

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

Microservices / Serverless in a polyglot environments

  • Cloud Architecture
  • Deploy
  • Maintain

stoneric
2 repositories, 14 followers.

Cloud architecture

I build scalable and resource-efficient cloud solutions, both for public cloud entities like AWS and on-prem instances for internal usage.

  • Efficient — ensure you pay only for the resources you truly need and scale smoothly when the need arises.
  • Manageable — introduce 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 makes sure customers benefit from a predictable and reliable workflow, ensuring that the product runs well at all times and updates are delivered without issue.

  • Fast — CI results in updates that are smaller chunks developed faster and 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 of time you have a working product and 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 “infrastructure as a code” paradigm, time-consuming, routine tasks can are automated. This frees up resources to work on the things that matter, 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 and 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 hierarchic silos.
  • Ease of transition — automated environment can be easily moved from on-prem cloud to public and vice versa when the need arises; minimizes possible 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 several clicks, without interacting with the rest of the ecosystem.

Testing

Provide automated unit testing at each commit, which ensures the new updates do not affect the existing feature set and do not impair the functionality of the deployed product. This grows the developer’s self-confidence while freeing up the QA resources for extensive product testing as a whole, instead of 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 the developers know there is an automated QA system in place they prefer smaller commits with simpler functions, which results in better code quality and fewer errors overall.
  • Reusability — instead of performing manual testing, usage of automated tests ensures high reusability of said tools, which results in drastic testing time reduction with subsequent growth of productivity.
  • Debugging ease — if some errors occur, only the latest commits need to be debugged, greatly reducing the time for bug fixing and shortening overall time to market.

Security

Ensure a high degree of automatization in all processes of software development pipeline, so there is little room for human-originating error and possible security breaches. More to say, this helps document all the steps from the very first code commit and up to the product release, thus making the 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 the processes transparent and forms a short-loop software development, where security concerns are addressed quickly throughout the whole 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 numbers of possible security breach points and makes it easy to trace who gained access to what system and when did it happen.

Logging

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

  • Debugging — detailed logs serve as excellent debugging sources that enable short loops of error discovery and fixing.
  • Correlation — logs of the system resources used for an operation allow correlate these figures with the estimated numbers and discover possible bottlenecks much easier.
  • Production troubleshooting — sophisticated logging tools, allow parsing the logs real time and troubleshooting the performance issues on the fly.
  • Data structuring — modern logs are much more than they used to be 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 uninterrupted customer experience and stable app operations with good performance.

  • Production monitoring — monitor the performance of multiple apps within separate environments and take action at once if the problem occurs, instead of dealing with the consequences.
  • Cost-effectiveness — in-depth monitoring helps visualize the patterns of app usage and scale the resource pool to ensure maximum cost-effectiveness of resource allocation.
  • 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 application performance is the key to providing the positive user experience. Monitoring the app response times and the speed of key transactions, the efficiency of database queries and resource utilization helps discover the new ways of app updates and room for improvement.

Alerting

Waiting for a few hours to get a response from the support team is one of the nightmares of any customer, be it an individual or a business. Timely alerts on key events help keep the hand on the pulse and make important decisions quickly.

  • Push notifications — setup a system of push notifications via SMS, email or phone calls to ensure important events are escalated to correct specialists quickly and possible downtimes are minimized.
  • Correct scheduling — compose the schedules for weeks in advance to make sure On-Call specialists are in place to take action if the need arises.
  • Better collaboration — smart alerts already contain crucial info on the error origin and are directed to the specialists responsible for solving such issues, which shortens the 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 outside, I will write the detailed function level docs and make it public.

5. My code will follow standard design patterns. Makes 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 test.

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.