Manage

Manage

Learn to apply best practices and optimize your operations.

• 5 types of software architecture design worth knowing

  While it's impossible to identify any software design style as the 'most important' to know, there are five major patterns with which all architects should arguably become familiar. Continue Reading

• 4 enterprise architect skills you should never overlook

  While there's certainly plenty that goes into being an enterprise architect, what skills are the absolute 'must haves' to stay on top of the job? We examine a few. Continue Reading

• A quick look at the Carbon programming language

  Carbon is an experimental programming language built to stand on the shoulders of C++ -- but with a new outlook on memory safety, threading and functional programming. Continue Reading

• The enduring link between Conway's Law and microservices

  While Conway's Law is a decades-old concept, some would argue that the industry's rush to adopt microservices makes this take on development team structure more relevant than ever. Continue Reading

• The fundamentals of achieving high cohesion and low coupling

  It's easy to say, 'high cohesion, low coupling,' but is it as easy to put into practice? We examine some of the basics behind cohesion, coupling and the right balance between them. Continue Reading

• What developers need to know about open banking

  Open banking has made financial transactions easier and more secure for those with multiple banking accounts; however, vulnerabilities within open APIs raise security concerns.Continue Reading

• 5 ways to survive the challenges of monolithic architectures

  Those unable to make the jump to microservices still need a way to improve architectural reliability. Here are five ways software teams can improve a monolith's reliability.Continue Reading

• How architects can use napkin math to forecast performance

  Although modern software systems can be inordinately complex, architects can still use simple napkin math to glean quick overviews of system performance and architecture alignment.Continue Reading

• 10 training courses to prep for microservices certification

  While it's not necessarily easy to become certified in microservices architecture, there are plenty of courses you can take to prep for certification exams like the S90.MSA.Continue Reading

• Signs of a Golden Hammer antipattern, and 5 ways to avoid it

  The Golden Hammer antipattern can sneak up on a development team, but there are ways to spot it. Learn the signs, as well as some direct steps a team can take to avoid it.Continue Reading

• Why contract testing can be essential for microservices

  Developers face numerous struggles trying to perform traditional, end-to-end integration testing on microservices. Contract testing presents a potential alternative.Continue Reading

• 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