Manage

Manage

Learn to apply best practices and optimize your operations.

• 5 best practices for microservices authorization

  Authorization is a critical security component of a microservices architecture. Follow these five guiding principles to deploy and manage the microservices authorization process. Continue Reading

• Why and how to manage microservices without API gateways

  Managing microservices without API gateways might be uncommon, but not unheard of. Consider the benefits, downsides and available auxiliary tools before taking an alternate approach. Continue Reading

• When not to use microservices: 4 challenges to consider

  The switch from microservices to monolith could save costs and improve performance. Explore key considerations and questions to ask when deciding the right architecture for an app. Continue Reading

• An introduction to the RESTful API Modeling Language (RAML)

  The RESTful API Modeling Language, or RAML, can be a powerful tool for developers looking to create an efficient, standardized API management strategy. Continue Reading

• Using bounded context for effective domain-driven design

  Domain-driven design helps organizations develop software focused on key business needs. But to do so, architects need to understand the fundamentals of bounded context. Continue Reading

• Object-oriented vs. functional programming explained

  While plenty of developers entertain the idea of adopting a functional programming model, it's important to first know exactly how it differs from the object-oriented approach.Continue Reading

• How to make a strong business case for software projects

  Every software project proposal requires in-depth research into the technical aspects at play, but the business case for the project should tone down the tech talk.Continue Reading

• The pros and cons of a layered architecture pattern

  Layered architecture patterns provide a consistent and secure way to organize code when implemented correctly. However, the way those layers interact should remain a top concern.Continue Reading

• Comparing MERN vs. MEAN stacks for web app development

  While MERN and MEAN stacks share many common elements, their respective use of React and Angular is a defining factor in choosing one or the other.Continue Reading

• Elixir vs. Clojure for functional programming at scale

  While they don't have the prestige of JavaScript or Python, Elixir and Clojure are making a name for themselves when it comes to functional programming at scale.Continue Reading

• Serverless vs. containers: Which one for microservices apps?

  How do you know when microservices should run in containers vs. serverless functions? A big factor is what you plan to do with your microservices.Continue Reading

• Understanding the role of polymorphism in OOP

  Polymorphism is used in OOP to allow developers to write more efficient code and redefine methods for derived classes; however, it could raise real-time performance issues.Continue Reading

• Understanding protocol buffers vs. JSON

  Protocol buffers have some compelling advantages over JSON when it comes to sending data between internal services. But is it really a replacement for JSON?Continue Reading

• Scripting vs. programming languages: Where they differ

  Choosing a programming language is often dictated by the problem the programmer wants to solve and the compute goal that a language is designed to achieve.Continue Reading

• Kotlin vs. Scala: Which one is right for your project?

  As general-purpose programming languages, both Scala and Kotlin have a lot to offer. But that doesn't mean their uses cases are the same.Continue Reading

• Architecting beyond microservices and monoliths

  A recent architectural change tied to Amazon's Prime Video service could help enterprise application teams understand their own microservices vs. monolithic architecture choices.Continue Reading

• Rust vs. C++: Differences and use cases

  C++ was mature before Rust even existed. Does that mean developers should switch from C++ to Rust? Not always.Continue Reading

• 3 critical stops on the back-end developer roadmap

  When it comes to acquiring the skills needed to be a proficient back-end developer, there are no shortcuts. Some of the topics to know will be obvious, others might not be.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

• Techniques to gain control over unruly API sprawl

  A lapse in proper control over large portfolios of internal and external APIs can result in problematic sprawl. Here's what software teams can do to prevent that from happening.Continue Reading

• 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

• 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

• 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