Manage

Manage

Learn to apply best practices and optimize your operations.

• 3 common CQRS pattern problems, and how teams can avoid them

  While CQRS can provide a lot of value when it comes to structuring an event-driven architecture, improper practices can cause this pattern to be more of a burden than a blessing. Continue Reading

• A quick glance at the history of C programming languages

  Since C hit the scene in 1972, the language has continuously evolved to stay relevant in modern development. We examine C's history and why it's still relevant. Continue Reading

• A 7-point language comparison of Ballerina vs. Golang

  This comparison takes a look at both Ballerina and Golang, including their support for high-level programming, libraries, built-in management features and community support. Continue Reading

• How viable is it to create microservices in Python?

  Python offers microservices developers access to advanced scripting, embedded testing and plugin tooling. But is it a good fit for you? And what are the alternatives if it isn't? Continue Reading

• 9 steps to implement in an observability strategy

  As distributed software systems grow in scale and complexity, things like monitoring and debugging can become a tangled mess. Here are nine ways to bolster your observability plan. Continue Reading

• Can you really use a shared database for microservices?

  Since its emergence as a mainstream development style, experts have debated the wisdom of using a shared database for microservices versus providing a database per service.Continue Reading

• 5 fundamental strategies for REST API authentication

  There are various authentication methods for REST APIs, ranging from basic credentials and token encryption to complex, multilayered access control and permissions validation.Continue Reading

• 6 ways cloud-native and cloud-agnostic architecture differ

  While development teams should carefully weigh the tradeoffs between cloud-native and cloud-agnostic architectures, they don't necessarily have to commit to just one.Continue Reading

• The deep-rooted relationship between REST and microservices

  The REST paradigm can be a natural fit for microservices architectures, but it also presents potential challenges for development teams.Continue Reading

• The management approach for internal vs. external APIs

  While internal and external APIs don't differ much mechanically, there are some important contrasts when it comes to certain API design and lifecycle management issues.Continue Reading

• The role of sidecars in microservices architecture

  Sidecars can do a lot for microservices when it comes to communication with distributed application components, though they also present some precarious management challenges.Continue Reading

• The basics of working with declarative programming languages

  While imperative programming is often a go-to, the declarative approach has proved useful in the face of demands for complex, feature-heavy business applications.Continue Reading

• Micro apps vs. microservices: What developers should know

  On the surface, the contrast between micro apps and microservices simply seems a matter of front-end vs. back-end concerns. But this isn't the only difference worth knowing.Continue Reading

• WebStorm vs. Visual Studio, and how to choose the right IDE

  WebStorm and Visual Studio represent two ends of a wide spectrum when it comes to the IDE platform market. However, their true differences go well beyond their pricing structures.Continue Reading

• Should software architect responsibilities include coding?

  There are many variations to the role of the software architect in today's IT teams, and a lingering debate is over whether they should all be hands-on with code.Continue Reading

• The 4 Golden Signals, and how to put them into practice

  There's nothing easy about monitoring distributed systems, but the right metrics can help. Here's how to put the Golden Signals of software reliability to work.Continue Reading

• Resilient software strategies all developers should know

  Failures are unavoidable. However, the right software design and development choices can help minimize their impact, isolate problems and speed recovery times.Continue Reading

• The 5 essential HTTP methods in RESTful API development

  Review these five common RESTful API HTTP methods that developers need to know. Use this guide to understand the differences and uses for each of the methods.Continue Reading

• To master software design patterns, perspective is everything

  Elisabeth Robson and Eric Freeman, authors of 'Head First Design Patterns,' outline their quest to teach software design patterns and show developers the right way to learn them.Continue Reading

• IPaaS vs. API management: Why the enterprise needs both

  Enterprise iPaaS and API management integrate applications and data, but it's not a choice of one or the other. Here's why you probably need both, and why planning is necessary.Continue Reading

• 3 ways to maximize business process automation benefits

  As business automation continues to take the enterprise by storm, there are a few ways software teams can better prepare themselves to confidently kick-start BPA initiatives.Continue Reading

• Frameworks, libraries and languages for machine learning

  While some developers may find the complex algorithms and processes intimidating, these frameworks, libraries and languages for machine learning can help get you started.Continue Reading

• A quick rundown of multi-runtime microservices architecture

  Learn the basics about a multi-runtime architecture, and the two-component approach it takes to provide a standard for abstracted microservice-messaging processes.Continue Reading

• Feature toggles: A simple fix for complex release cycles

  While development teams should always strive to improve app functionality, unchecked collections of feature releases can quickly cause trouble. Feature toggles may be the answer.Continue Reading

• Using a business rules engine to streamline decision-making

  Get to know some of the details behind a business rules engine, particularly the automated approach it takes to handling critical, rules-based decisions.Continue Reading

• 5 tips for stronger development team management

  Being a competent manager and leading a successful software development team isn't as easy as it looks. Explore the skills, tools and best practices that can strengthen your current workforce.Continue Reading

• Using the saga design pattern for microservices transactions

  We explore how the saga design pattern can support complex, long-term business processes and provide reliable rollback mechanisms for multistep transaction failures.Continue Reading

• 4 mobile app security threats all developers must face

  Mobile apps carry their own set of code-based vulnerabilities and entry points, meaning developers need to step up their secure development, coding and deployment practices.Continue Reading

• Styles, protocols and methods of microservices communication

  As application architectures grow in complexity, messaging must become a priority. Review the two types of microservices communication and the primary protocols involved.Continue Reading

• Decomposing a monolithic database for microservices

  When breaking up a monolith, it's critical to decompose your database alongside your new distributed services. We explore how to do this and avoid creating a distributed monolith.Continue Reading

• Navigate service discovery in a microservices architecture

  Microservices move rapidly, making streamlined service discovery a must. Learn more about the specific types of discovery approaches and how to determine a strategy.Continue Reading

• Explore API documentation basics and best practices

  API documentation should be easy to understand -- but how do you accomplish this? Use this quick guide to learn key API documentation components, noteworthy tools and best practices.Continue Reading

• 3 lessons microservices developers can learn from SOA

  Microservices developers can learn from past SOA mistakes to build more resilient and high-performance applications today. Take a look at three major lessons for microservices projects.Continue Reading

• Microservices availability tips for pandemic's scaling challenge

  Surges in app user activity caused by the COVID-19 pandemic have forced architects to make immediate decisions around service availability and performance, especially for distributed architectures.Continue Reading

• 14 top mobile app KPIs that advance development

  No matter its purpose, a mobile application must meet expectations from users and corporate stakeholders. Here are 14 mobile app KPIs that you need to know.Continue Reading

• 3 microservices resiliency patterns for better reliability

  The flipside of microservices agility is the resiliency you can lose from service distribution. Here are some microservices resiliency patterns that can keep your services available and reliable.Continue Reading

• Popular microservices testing tools developers should know about

  Testing microservices gets messy as services are independent and communicate often. Here are tests necessary for microservices, and popular tools developers use to perform them.Continue Reading

• Rethinking change control in software engineering

  The traditional method of application change control won't fly in a modern, DevOps environment. Here's how we can rethink the process in a time where rapid app development rules.Continue Reading

• How the .NET Core platform advances cloud-based app deployment

  The capabilities of .NET Core keep developers interested. We break down the reasons why that's the case.Continue Reading

• Finding the right fit for business process automation

  Identify the right tasks for your company's workflow automation initiative. Not every process should be automated, so it's important to choose wisely.Continue Reading

• Business process automation software requires a strategy

  Organizations of all sizes can benefit from automation, but they need to move beyond tactical deployments. To really make use of BPA software, a strategic approach is needed.Continue Reading

• Why workflow automation isn't really about cost cutting

  BPA can reduce expenses and boost efficiency. Its real value, though, is in how it can drive innovation throughout a company and provide a competitive advantage.Continue Reading

• When business process automation benefits the whole company

  Here's what you need to know about BPA tooling, from how it works, how it helps and how to consider potential providers.Continue Reading

• Scaling microservices takes conceptual skills and good tooling

  Independent scalability is a major benefit of microservices, and simultaneously a complex and challenging thing to implement. Scale microservices with a focus on users' priorities.Continue Reading

• The best Agile architects write code

  To be a better software architect, brush up on programming skills and write code. See how Agile architects help developers and make projects better when they dabble in coding.Continue Reading

• Use an API mapping tool to demystify complex API integrations

  Whether a simple diagram or more complex model, an API mapping tool can bring order to loosely coupled application components, speed up debugging and simplify application updates.Continue Reading

• Tips to use for microservices in mobile app development

  With mobile apps dominating enterprise customer interactions, developers must dig into microservices architectures, brush up on programming skills and decipher business requirements.Continue Reading

• Container image size makes a difference

  IT teams ready to embark on container deployment should look closely at how developers break down and package application components. Little details will be important.Continue Reading

• Invoke these 3 commandments of microservice applications

  Unlock a microservice app's potential with a three-pillared approach centered on a thorough component directory, absolute service flexibility and reliable backwards compatibility.Continue Reading

• Match market shifts with a lightweight enterprise architecture

  Lightweight EA can streamline and refine how IT software meets business needs. See which lightweight EA toolkit route fits your team: one focused on an EA model or workflows.Continue Reading

• Digital business upends the CIO and enterprise architect role

  IDC analyst Mike Rosen explains how new digital business pursuits amplify enterprise architects and CIOs into newly amplified roles that put business goals and requirements first.Continue Reading

• ICYMI: How to select and manage serverless APIs effectively

  Explore how API selection and API management in a serverless architecture can make all the difference between getting results and having your project fall flat.Continue Reading

• Implement and manage an event-driven microservices architecture

  Learn the basics of event-driven architecture as they apply to microservices, with the help of real-world examples and three main architecture patterns.Continue Reading

• Quiz yourself on smart API gateway management

  Did you know that API gateways are multipurpose? Compare your knowledge of API gateways and API management in this quiz.Continue Reading

• 4 practical methods to increase service resilience

  Resiliency refers to the ability of your architecture to quickly predict, detect and mitigate potential performance failures. Here are four ways to fortify your software.Continue Reading

• 3 distributed tracing tools perfect for microservices

  Distributed tracing is a critical part of the microservices monitoring processes. Here are three tools that can help provide the view you need to identify strangling bottlenecks.Continue Reading

• Streamline CI/CD with the Jenkins Blue Ocean tool

  Organizations that run Jenkins may find that plugins complicate their CI/CD pipeline. Here's how the continuous delivery tool Blue Ocean can help keep things on track.Continue Reading

• Use event processing to achieve microservices state management

  What good are stateless microservices for stateful processing? Bring complex event processing into the mix to manage microservices state through scaling and failures. Here's how.Continue Reading

• 4 fundamental practices for serverless architecture security

  Are you ready for serverless security? Learn about four critical planning considerations software teams need to focus on if they plan to adopt serverless.Continue Reading

• Discover practical serverless architecture use cases

  While architects and developers were slow to find practical use cases for serverless, numerous enterprise trends should drive the need for this architecture style.Continue Reading

• ICYMI: 6 tips to master Kubernetes performance and management

  The more skilled the team, the better a Kubernetes implementation can be. Learn how to get the most out of service discovery, infrastructure management, CI and more.Continue Reading

• Continuous architecture combats dictatorial EA practices

  To thrive today, Agile businesses must outgrow the architecture review board and enterprise silos to create an integrated culture of continuous planning and management.Continue Reading

• The key differences between stateless and stateful microservices

  Not all services are the same. Learn about the fundamental differences between a stateful and a stateless microservice and the appropriate scenarios for each.Continue Reading

• For API-based integration, a gateway is your friend

  Gateway technology makes API-based integration and microservices more secure, more efficient and more manageable. But beware API management pitfalls.Continue Reading

• The value of APIs and microservices gateway tools

  Make API gateways actually work for you. To deliver the right applications to the right places, you'll need a management layer that ties everything together.Continue Reading

• Take a quiz on integration platform as a service fundamentals

  Many IT teams turn to integration platform as a service when they face integration challenges unique to their combination of technology. How much do you know about iPaaS?Continue Reading

• Analyst: Form a hybrid integration plan for your architecture

  App integration is complex, and since every enterprise has a unique mix of apps and platforms, there's no blueprint for success. Analyst Massimo Pezzini explains how architects should craft a plan.Continue Reading

• 5 key management practices for a hybrid cloud architecture

  Workload bottlenecks easily arise between legacy and modern apps in a hybrid cloud. Coordinate integration with these five steps to prep a microservices application for hybrid cloud.Continue Reading

• Practical ways to automate microservices' CI/CD processes

  Development teams need to make applications extensible and agile. Microservices bring those goals in sight, but an automated CI/CD pipeline is the key to success.Continue Reading

• 5 ways to manage multiple data sources for high-performance apps

  Applications can pull from and work with data from multiple sources, as long as the app design incorporates these five fundamental data management and mapping techniques.Continue Reading

• How serverless works to usher in a new era of applications

  Dive into this architecture-centric guide on serverless computing that includes API management tips and advice on when to implement serverless microservices designs.Continue Reading

• Enable an antilatency cloud event processing architecture

  Event-based applications cannot tolerate unreliable networks or latency. Consider an architecture that puts some event processing local to the source to alleviate cloud traffic.Continue Reading

• Expect microservices implementation to break down IT norms

  No role is safe during a transition to microservices. JP Morgenthal, distributed architecture expert, enumerates the ways in which a microservices implementation shakes up IT teams.Continue Reading

• Three keys to cloud API management success

  Document and authenticate your way to API management success. Here are key elements of a sensible strategy to help you get the benefits of APIs without the headaches.Continue Reading

• These tools help build microservices in Java

  Depending on the mission, developers need to align their tool choices with one of two paths for Java microservices. Here's what you need to know.Continue Reading

• Monolith to microservices case study proves maintainability matters

  See how microservices have changed one retail rewards tech company's development team makeup as it worked to leave monolithic apps behind.Continue Reading

• The 2 fundamental approaches to hybrid cloud integration

  Organizations that want to create a hybrid cloud environment need to develop a strategy. Consider these two approaches.Continue Reading

• How to prepare your own container development kit

  A container development kit helps confederate containerized application development and transition developed components between clusters. Here's how to create your own.Continue Reading

• How to build microservices with Spring Boot and Spring Cloud

  Spring Boot and Cloud can certainly help developers tackle microservices, but it's not for everybody and, unfortunately, there are a few important limitations to consider.Continue Reading

• 3 ways to minimize critical container vulnerabilities

  Containers are complex, and it takes some work to keep your container components and images safe from attack. Here are three critical container development security practices.Continue Reading

• 5 tips to help effectively manage container components

  The layered approach is commonly used with Docker containers, but it's important to keep container components under control. Here are five crucial tips.Continue Reading

• How to use microservices to manage serverless APIs

  Monolithic applications may be a little bit heavy for development of serverless APIs, but microservices can make all the difference. Here's how to make it work.Continue Reading

• 5 fundamental steps of managing APIs

  API management is undeniably essential, but it requires a comprehensive plan. Here are the five steps of an API management strategy and advice on how to complete each one.Continue Reading

• Test yourself on the challenges of microservices security

  Think you know what complicates microservices security and what precautions to take to maximize protection? Challenge yourself, and take this quiz to find out.Continue Reading

• A quick primer on microservices load balancing

  Work distribution in microservices is tricky; without the right strategy, you risk that workloads won't scale effectively. Here's how to nail down load balancing for microservices.Continue Reading

• Some tricks to help manage load balancing in microservices

  Load balancing is a critical, and potentially thorny, part of cloud-native microservices management. Consider these methods and tools that can help address these challenges.Continue Reading

• How to make automation part of your microservices security

  It's not ideal to manually test and secure a microservices environment. Consider automation tools when you need to fortify your microservices security plan.Continue Reading

• 3 ways to prep microservices applications for big data

  It's easy for the expansion of big data to spin out of control in a distributed architecture. Think carefully about database management to avoid performance-killing bottlenecks.Continue Reading

• Unlock distributed analytics with a microservices approach

  Mobility creates distributed computing environments, which lead to a scenario where some of the older analytics processes are no longer useful. Distributed analytics with microservices can help.Continue Reading

• Kubernetes service discovery tactics boost microservices

  Customize or automate a containerized application's service discovery exactly to your preference by mastering a collection of Kubernetes features.Continue Reading

• How to combat complexity in microservices data management

  Architects who shift from a monolith to microservices need to consider a critical component: data. Learn how microservices affect data management, and discover tools that can help.Continue Reading

• Modern deployment models put a new spin on componentization

  Developers can use containers, serverless and microservices to strengthen app composability, but there are tradeoffs to consider. Discover the brave new world of componentization.Continue Reading

• How to ease the pain of Kubernetes upgrades with automation

  Although Kubernetes aims to automate container management, Kubernetes upgrades are still a tedious, manual process. Learn about the tooling that helps automate this task.Continue Reading

• How to adapt API management for serverless architecture

  It's critical to understand what will happen to legacy APIs when you transition to a serverless architecture. Discover how to properly adapt API management for this new paradigm.Continue Reading

• Unpacking the event-driven microservices approach

  Event-driven applications can be beneficially combined with microservices architectures, and finding the best method to merge them relies on analyzing orchestration options.Continue Reading

• Think practically about software modernization

  Does your software modernization project have the wrong goals? This blog post takes a look at common drivers for modernization and how software teams should deal with legacy apps.Continue Reading

• A brain teaser to plan for, design and manage APIs

  As organizations shift toward the use of distributed architectures, an increased use of APIs is bound to follow. Take this quiz and test your knowledge on how to plan, design and manage APIs.Continue Reading

• The pros and cons of serverless architecture

  The serverless trend may hold advantages for developers, but consider the trade-offs. There are many aspects of serverless computing that developers should understand.Continue Reading

• How a SaaS provider made microservices deployment safely chaotic

  Remind was blindsided by performance issues with its microservices-based SaaS, until the company decided to sabotage its own product -- at scheduled times, in staging -- with a different kind of test.Continue Reading

• How proper networking supports microservices security

  Security shouldn't be an afterthought when it comes to microservices. Learn about the challenges of microservices security and how strong network management can help.Continue Reading