Get started

Get started

Bring yourself up to speed with our introductory content.

• REST (REpresentational State Transfer)

  REST (REpresentational State Transfer) is an architectural style for developing web services. Continue Reading

• Webhooks explained simply, and how they differ from an API

  Webhooks and APIs seem to both accomplish the same goal. So what's the difference? We review what a webhook does, how it differs from an API, and where it is the right design choice. Continue Reading

• The 4 rules of a microservices defense-in-depth strategy

  Learn the four must-follow rules when introducing defense-in-depth to a distributed microservices architecture, especially when services traverse numerous networks and apps. Continue Reading

• Two simple ways to create custom APIs in Azure

  Learn how to create custom APIs in Azure through both Azure Portal and Visual Studio Code, and review some post-deployment best practices that add value and security to those APIs. Continue Reading

• The CAP theorem, and how it applies to microservices

  Learn the fundamentals of the CAP theorem, how it comes into play with microservices and what it means for your distributed architecture design choices. Continue Reading

• Definitions to Get Started

  • REST (REpresentational State Transfer)
  • software stack
  • API testing
  • REST API (RESTful API)

  • API economy
  • Remote Procedure Call (RPC)
  • object-oriented programming (OOP)
  • data dictionary

  View All Definitions

• software stack

  A software stack is a collection of independent components that work together to support the execution of an application.Continue Reading

• How to master microservices data architecture design

  Microservices have data management needs unlike any other application architecture today. You'll need the right set of knowledge, mechanisms and design principles to succeed.Continue Reading

• Microservices logging best practices every team should know

  Creating a log system for distributed microservices is a task much easier said than done. Joydip Kanjilal offers a few best practices to shore up microservices logging processes.Continue Reading

• How to create an effective software architecture roadmap

  For large-scale initiatives that span the enterprise, a well-planned software architecture roadmap allows development teams to navigate projects safely and efficiently.Continue Reading

• API testing

  API testing is a type of software testing that analyzes an application program interface (API) to verify it fulfills its expected functionality, security, performance and reliability.Continue Reading

• Understanding the modular monolith and its ideal use cases

  While it isn't always the right fit, a modular monolith can often provide a happy medium between the simplicity of a traditional monolith and the complexity of microservices.Continue Reading

• The non-tech skills of software development project managers

  Teams are key to the success of any enterprise software project, but development teams don't run themselves. Managers need the right skills to keep their employees on track.Continue Reading

• How to start managing software development teams like a pro

  Team performance is vital to a software project's success. Avoid these common management challenges and learn about the key metrics that help monitor your team's effectiveness.Continue Reading

• Book details API design best practices

  APIs are designed for people you've never met to solve problems you didn't know existed. With that in mind, how do you design and build them well?Continue Reading

• A basic overview of micro front ends

  Microservices enable independent app-dev teams, asynchronous app updates and precise troubleshooting. If these benefits sound good for your UI, consider a micro front end.Continue Reading

• The basics of software coupling metrics and concepts

  To move toward a distributed, modular architecture, development teams need to carefully investigate software coupling concepts and learn how to measure dependency complexity.Continue Reading

• REST API (RESTful API)

  A RESTful API is an architectural style for an application program interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data.Continue Reading

• A lesson on how to test microservices locally

  Microservices are small pieces of a big picture, so they're difficult to test in isolation. Use these tips to run unit and integration tests locally on microservices.Continue Reading

• A breakdown of object-oriented programming concepts

  Object-oriented programming has set a dominant example of proper data management for complex software and web apps. Learn about the basics of this approach and its role in Java.Continue Reading

• A primer on the clean architecture pattern and its principles

  Stability is a crucial aspect of application architecture. Learn how clean architecture can straighten out your dependencies and make an app that is built to last.Continue Reading

• API economy

  The API economy refers to the set of business models and practices designed around the use of APIs in today's digital economy.Continue Reading

• A developer guide to software localization

  Software has become as multilingual and multicultural as the world itself. Localizing your code can keep your company from a potentially disastrous cultural blunder.Continue Reading

• 10 of the best programming languages to learn in 2020

  Different jobs call for different programming languages, and the wrong choice could cause your project to fail. Add these tools to your must-learn list so you are prepared for any assignment.Continue Reading

• 4 must-have API management components

  APIs don't manage themselves. Get to know these key API management components to ensure your applications perform as intended.Continue Reading

• Craft an application integration strategy and pick the best tool

  Application integration is easier said than done. Learn how to navigate this challenging process -- particularly, if you're integrating legacy applications with new applications.Continue Reading

• Synchronous vs. asynchronous communications: The differences

  While asynchronous communications does not wait around for a reply, synchronous execution requires parties or components to work simultaneously in real time.Continue Reading

• If software architects' soft skills fail, so does the business

  Mark Richards and Neal Ford, authors of 'Fundamentals of Software Architecture,' share real-life examples of why architects must communicate well, and explain how to do it.Continue Reading

• Test your knowledge of iPaaS tools and strategies

  Do you understand everything you should about iPaaS? This quiz will test your knowledge of iPaaS tools and fundamental capabilities.Continue Reading

• Key strategies to help migrate to microservices

  Microservices adoption is no easy feat. In addition to the technical process of transitioning from a monolith, enterprises must also look at team structure and common migration mistakes.Continue Reading

• Why COBOL modernization matters, and how devs can react

  With COBOL expertise in high demand and low supply, it may be time for devs to think about how much they really know about this language. We explore why COBOL skills still matter.Continue Reading

• What is the strangler pattern and how does it work?

  The strangler pattern allows software teams to retire legacy systems incrementally and avoid the pitfalls of major rewrites. We examine this pattern and detail the steps involved.Continue Reading

• 4 best practices for creating architecture decision records

  An ADR is only as good as the record quality. Follow these best practices to establish a dependable ADR creation and maintenance process.Continue Reading

• The guide to landing an enterprise architect job

  Interested in becoming an enterprise architect? This guide reviews the essential responsibilities of architects and how you can master the application process.Continue Reading

• A five-point primer on event-driven design

  More apps are moving away from request-driven models in favor of event-driven architecture. But are you ready for this design? Find out with these five quick tips.Continue Reading

• An enterprise architect's guide to the data modeling process

  As volumes of both business and application data grow, organizations need a strict, three-phase data modeling process that keeps that data contained and manageable.Continue Reading

• 5 application performance metrics all dev teams should track

  You've deployed your application, now what? To keep your application performing well, you need to track various metrics. Take a look at these five critical KPIs.Continue Reading

• How to start using a BDD framework

  Why bother with behavior-driven development? Learn how this Agile-focused development framework can help bolster application quality, and explore tooling that can help.Continue Reading

• Get started with API versioning and URIs

  Applications change, and the APIs they depend on need to be updated and upgraded accordingly. Developers who know the value of versioning and the basics of numbering improve APIs.Continue Reading

• How to fuse domain-driven design and microservices

  Domain-driven design helps organizations create business capabilities with the architecture that microservices need. Here's how to merge DDD into your development process.Continue Reading

• 2020 conferences for software developers and architects

  Fortunately, you can't lose your badge at a virtual conference. Check out our list of both online and in-person conferences, including DockerCon, API World and Microsoft Build.Continue Reading

• 5 stages of an API lifecycle explained

  APIs are not just a component you can set and forget. Developers need to plan, create, deploy and monitor APIs to keep them aligned with business needs, as well as know when it's time to retire them.Continue Reading

• Remote Procedure Call (RPC)

  Remote Procedure Call (RPC) is a protocol that one program can use to request a service from a program located in another computer on a network without having to understand the network's details.Continue Reading

• 5 best practices for remote development teams

  More developers than ever now work from home and must quickly adapt to remote life. Our experts explain how to proactively support the isolated members of your development team.Continue Reading

• The 5 essential elements of an RPA strategy

  RPA's benefits can be wiped out by an improper implementation. Give your business a sound RPA strategy and roadmap before you rush in.Continue Reading

• Getting to know the API proxy

  Explore the capabilities and practical uses for an API proxy, as well as examine the relationship between an API proxy and an API gateway.Continue Reading

• Use tokens for microservices authentication and authorization

  Independent and interoperable microservices require a permissions rethink, or you'll drive users crazy. Examine how tokens come into play for authentication and authorization.Continue Reading

• object-oriented programming (OOP)

  Object-oriented programming (OOP) is a computer programming model that organizes software design around data, or objects, rather than functions and logic.Continue Reading

• data dictionary

  A data dictionary is a collection of descriptions of the data objects or items in a data model for the benefit of programmers and others who need to refer to them.Continue Reading

• The 7 crucial RPA developer skills

  As enterprises move in on RPA, they need developers who can juggle both the business and technical sides of automation. Here are seven essential RPA developer skills.Continue Reading

• 5 core components of microservices architecture

  Before you build a microservices application, take a closer look at the components of the architecture and their capabilities.Continue Reading

• software

  Software is a set of instructions, data or programs used to operate computers and execute specific tasks.Continue Reading

• API management

  API management is the process of overseeing application program interfaces (APIs) in a secure, scalable environment.Continue Reading

• open API (public API)

  An open API, also known as a public API, is an application programming interface made publicly available to software developers.Continue Reading

• How to plan and execute a migration to microservices

  Ready for a migration to microservices? Here are the steps your development team can take to gradually transition your existing monolithic applications.Continue Reading

• The 3 tenets of microservice messaging patterns

  In a microservices architecture, there's no question that it's tricky to ensure effective service communication. Review these three tenets of microservice messaging patterns.Continue Reading

• 5 key software testability characteristics

  How do you design the software components for comprehensive testing? Start with these fundamentals of software testability -- from mocks and stubs to infrastructure-as-code.Continue Reading

• Get started with a hybrid microservices model

  Enterprises don't always have to choose between a microservices and monolithic architecture -- take a hybrid approach to experience the best of both worlds.Continue Reading

• middleware

  Middleware is software that is used to bridge the gap between applications and other tools or databases.Continue Reading

• What is a microkernel architecture, and is it right for you?

  Apps aren't limited to monolith and microservices architecture. Discover the benefits of a microkernel, common plugins and the apps best suited for this type of architecture.Continue Reading

• Break monoliths into microservices with 3 steps

  To decompose a monolith into microservices, you could take the application offline or halt all updates and rewrite everything. Or you could follow this practical approach.Continue Reading

• service-oriented architecture (SOA)

  Service-oriented architecture (SOA) is a software development model that allows services to communicate across different platforms and languages to form applications.Continue Reading

• 4 fundamental microservices security best practices

  Despite the benefits, microservices will introduce profound security issues. We review the biggest microservices security challenges and four strategies used to combat them.Continue Reading

• Fundamental patterns for service discovery in microservices

  Service discovery is a huge part of managing a microservices-based application. We examine helpful service discovery patterns developers can use for clean service interaction.Continue Reading

• 5 big microservices pitfalls to avoid during migration

  Too many development teams make these failure-inducing mistakes during a switch to microservices. Learn where things go wrong, and the best ways to avoid problems.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

• OAuth

  OAuth (Open Authorization) is an open standard authorization framework for token-based authorization on the internet.Continue Reading

• state management

  Application state management is the process of maintaining knowledge of an application's inputs across multiple related data flows that form a complete business transaction -- or a session -- to understand the condition of the app at any given ...Continue Reading

• A few fundamental microservices team structure strategies

  A microservices architecture can be quite a culture shock to unprepared enterprises. Here's how you can prepare your team to make microservices part of development processes.Continue Reading

• Experts explain how AWS Lambda works internally

  AWS Lambda introduces its fair share of benefits and problems. In case you missed it, here are three expert tips to help serverless functions find a comfortable place within your software systems.Continue Reading

• The 3 fundamentals of hybrid cloud architecture management

  When an enterprise chooses hybrid cloud, it needs to ensure the application harmonizes between the two environments. Review these three tips on architecture, integration and APIs.Continue Reading

• Follow these 10 fundamental microservices design principles

  The right design principles enable microservices adopters to build an application from autonomous, cohesive components that can scale seamlessly. Here are 10 to follow.Continue Reading

• How to improve API documentation with Swagger and OpenAPI

  Discover why developers should take advantage of Swagger tooling and the OpenAPI specification to streamline API design, documentation and management, especially for RESTful APIs.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

• How to test microservices for functionality and compliance

  If you're new to microservices testing practices, understand that traditional techniques won't work anymore. We examine how to approach four critical microservices tests.Continue Reading

• A guide to open source technology in application development

  The open source community continuously adapts to address the latest application development and deployment needs of organizations large and small. What can these tools do for you?Continue Reading

• WSO2

  WSO2 is a middleware vendor that sells open source application program interface (API) management software.Continue Reading

• An introduction to combining CQRS and event sourcing

  Combining CQRS and event sourcing is a powerful way to maintain data speed and consistency for web-scale applications. Learn about the pros and cons of pairing these two processes.Continue Reading

• The enterprise architect's guide to application state management

  If your project is caught in a state-related conundrum, keep this guide handy when you need to untangle complex stateful and stateless app design and management predicaments.Continue Reading

• dependency injection

  In object-oriented programming (OOP) software design, dependency injection (DI) is the process of supplying a resource that a given piece of code requires.Continue Reading

• 6 quick facts about a Java microservices architecture

  Building microservices in Java may not be as simple as it seems. Here are six quick facts and tips that will help you with Java-based microservices development.Continue Reading

• The right (and wrong) way to think about code refactoring

  Code refactoring keeps code clean, sharp and efficient -- ideally without changing any of its functionality. Learn how to refactor code without interrupting your deployment pipeline.Continue Reading

• Scala: Lightweight functional programming for Java

  Scala provides a lightweight code option for Java development, but there could be a steep learning curve. Learn a little about Scala and if it's worth adopting.Continue Reading

• 3 ways to implement a functional programming architecture

  Functional programming, which came about as a highly theoretical, mathematical way to build software, has a place in APIs and other components of applications.Continue Reading

• The vital guide to modern programming languages and their uses

  Get to know programming languages that match modern development styles and architectures like mobile dev, serverless computing and microservices.Continue Reading

• Compare microservices deployment patterns for best strategy

  To solve pesky deployment woes, match your app to a microservices deployment pattern, like single service instance per host, multiple service instances per host or even serverless.Continue Reading

• Choose an event-processing architecture for an application

  Sift through the state control methods that exist for event-driven applications and see which architecture type is the best fit.Continue Reading

• Elixir functional programming enables concurrency, fault tolerance

  Developers can combine features of Erlang functional programming with a newer language, Elixir, which promises simplicity and fault-tolerant operations for distributed applications.Continue Reading

• To succeed with containerized applications, nail the details

  Containers can help an organization smoothly deploy applications, but the design aspects are complicated. Follow best practices to size and package app components.Continue Reading

• Challenge your wits on stateful and stateless concepts

  It's essential to understand the differences between stateful and stateless application characteristics, especially as distributed architectures grow in popularity. Test your knowledge on state concepts with this quiz.Continue Reading

• source code

  Source code is the fundamental component of a computer program that is created by a programmer. It can be read and easily understood by a human being.Continue Reading

• Serverless architecture diagram shows a new side of server-side

  Examine this serverless architecture diagram to see how development processes and the lifecycle of code differs from traditional server- and client-side development.Continue Reading

• Serverless testing in CI eliminates surprises in production

  Writing in a functional language without intuitive unit test coverage? Don't have control over resources or scaling? Here's how to make serverless testing work anyway.Continue Reading

• Think carefully about API language standards

  API language standards were few and far between in the past, but now cloud has made API standardization more important than ever. Learn what you need to know about these standards.Continue Reading

• user interface (UI)

  The user interface (UI) is the point of human-computer interaction and communication in a device.Continue Reading

• How to design APIs for hybrid cloud architecture

  Hybrid cloud is complex, particularly because it's the application -- not the server -- that manages API flows. Review some strategies for API management in a hybrid scenario.Continue Reading

• A serverless architecture tutorial for development teams

  Still emerging serverless technology offers some big advantages for development teams. This serverless architecture tutorial can help clarify the basics on where to start.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

• What key messaging patterns should enterprise architects know?

  An unknowable number of interactions occur to enable digitization. Applications must pass these messages according to a design pattern, and these two categories suit enterprise-scale apps.Continue Reading

• class diagram

  A class diagram is an illustration of the relationships and source code dependencies among classes in the Unified Modeling Language (UML).Continue Reading

• application program interface (API)

  An application program interface (API) is code that allows two software programs to communicate with each other.Continue Reading