A shared database is still an anti-pattern, no matter what the justification (22 February 2013)

A simple (yeah, right...) guide to using Redux with React.js (12 February 2017)

Agile metrics. You get what you measure. In a bad way. (12 August 2019)

Agile velocity is not a measure of productivity (12 August 2013)

AI and the hype cycle: oversold, overlooked, then... eventually indispensable? (10 December 2022)

API gateways and the dangers of creeping middleware scope (23 March 2016)

API management and the return of the enterprise service bus (16 May 2017)

Architectural governance can be used to foster innovation. No, really. (3 April 2017)

Architecture governance is a spectrum: exploring styles of enterprise architecture (8 January 2024)

Architecture without documentation is incomplete (17 October 2020)

Are CRUD methods what we really want from a repository? (6 November 2012)

Are microservices just “SOA done properly”? (12 June 2014)

Are OpenAPI and Swagger trying to turn REST into SOAP? (14 August 2017)

Autonomous bubbles and event streams: Pragmatic approaches to working with legacy systems (29 July 2018)

Azure Data Factory and the myth of the code-free data warehouse (4 July 2019)

Build vs Buy decisions and the importance of context (8 January 2013)

Building Twelve Factor Apps with .Net Core (12 August 2018)

Building your own in-house technology radar (20 November 2020)

Can APX help in developing usable and accessible APIs? (19 October 2013)

Can consumer-driven contracts manage breaking change in microservice integrations? (4 June 2017)

Can cross-cutting concerns really exist between services? (25 July 2015)

Can internal developer platforms really be optional? (14 November 2022)

Can TOGAF and Agile really go together? (27 January 2018)

Comparing Gartner’s cloud integration leaders: Informatica, Dell Boomi and Mulesoft (2 July 2015)

Comparing nServiceBus and MassTransit: Do we still need .Net integration frameworks? (26 November 2015)

Comparing serverless C# and .Net development using Azure Functions and AWS Lambda (26 May 2017)

Custom token authentication in Azure Functions (18 December 2018)

Data design for event-driven architecture: autonomy, encapsulation and ordering (1 February 2016)

Data meshes and microservices - the similarities are uncanny (10 January 2022)

Data Vault 2.0: the good, the bad and the downright confusing (12 December 2020)

Deploying a Windows Service remotely with Powershell (12 June 2015)

Designing an event store for scalable event sourcing (29 July 2016)

Do you really need Kubernetes? (22 April 2020)

Does code quality matter? Using SonarQube with legacy code bases (22 July 2019)

Don't use test coverage as a target (19 February 2020)

Don’t assume message ordering in Azure Service Bus (16 December 2014)

Enterprise architecture anti-patterns (14 April 2024)

Entity services: when microservices are worse than monoliths (13 December 2017)

Establishing a new architecture practice in agile organisations (2 September 2023)

Estimation pitfalls: Why software development estimates are so difficult (3 February 2011)

Event stores and event sourcing: some practical disadvantages and problems (7 January 2017)

Events, sagas and workflows: managing long-running processes between services (4 November 2017)

Eventual consistency and the trade-offs required by distributed development (4 May 2014)

Finding service boundaries: more than just the bounded context (6 January 2019)

Forget code coverage – test design should be driven by behaviours (19 December 2016)

Generative AI does not mean the “end of programming” (12 December 2023)

GraphQL will not solve your API design problems (20 March 2018)

Hackable URIs may look nice, but they don’t have much to do with REST and HATEOAS (21 April 2014)

Handling Protocol Buffers backwards compatibility between versions 2 and 3 using C# (13 November 2016)

Here's the truth about CMS selection: It doesn't really matter... (27 March 2014)

Hosting .Net Core containers in Service Fabric (12 September 2018)

How big is a microservice? (9 March 2015)

How can architecture improve agility and delivery flow? (2 March 2023)

How can Domain Driven Design help with large scale agile development? (20 September 2017)

How do you foster technical excellence in an agile development culture? (22 May 2016)

How I learned to love the “Agile Industrial Complex” (30 August 2018)

How not to run a technology selection process (28 October 2021)

How not to use dependency injection: service locators and injection mania. (2 July 2012)

How should architects collaborate with development teams? (6 February 2022)

How to decompose that monolith into microservices. Gently does it… (8 May 2018)

How to make architecture decisions (28 March 2024)

How to manage down the payments on your technical debt (3 September 2012)

How to write useful .NET and C# coding standards (15 October 2010)

If “Enterprise Architecture” is failing, what should architects be doing instead? (11 March 2020)

In defence of the Scaled Agile Framework (and other 'branded agile' variants) (17 May 2022)

Informatica Cloud development best practices (18 January 2016)

Inner source is more of a cultural shift than a technical change (12 June 2022)

Internal developer platforms and the cult of Kubernetes (13 April 2023)

iPaaS and the return of the Enterprise Service Bus (3 October 2024)

Is “Serverless” architecture just a finely-grained rebranding of PaaS? (2 June 2016)

Kafka on Azure Event Hub – does it miss too many of the good bits? (10 July 2018)

Layers, onions, hexagons and the folly of application-wide abstractions (3 June 2018)

Lean development’s “last responsible moment” should address uncertainty, not justify procrastination (21 February 2014)

Machine learning models in production: the maths is the easy part (15 May 2019)

Managing and throttling serverless scaling with Azure Functions (3 October 2017)

Managing change and version control for service interfaces (16 July 2013)

Managing services that don't have clear code ownership (5 May 2016)

Memory leaks in .Net applications. Yes - they happen all the time… (23 September 2013)

Messaging anti-patterns in event-driven architecture (12 October 2018)

Messaging shouldn’t be used for queries (21 August 2014)

Microservice preconditions: what needs to be in place before you decompose that monolith... (9 March 2018)

Microservices, REST and the distributed big ball of mud (20 April 2015)

Migrating .Net framework applications to .Net Core (9 August 2016)

Minimal Viable Architecture and the case for up-front design (13 November 2023)

Monoliths and the microservices backlash (22 May 2023)

Monorepos. For when life isn't already complicated enough. (22 June 2019)

Most software architecture diagrams are useless (11 August 2015)

Naming things is easy. Abstraction is much harder. (13 June 2020)

Netflix has abandoned OData – does the standard have a future without an ecosystem? (17 June 2013)

Now that Kubernetes is on Azure, what is Service Fabric for? (9 February 2019)

Optimising bulk inserts with Entity Framework (26 June 2014)

Orchestration vs choreography for microservice workflows (5 December 2021)

PolyBase import and export between Azure SQL Data Warehouse and Blob Storage (13 August 2016)

Pragmatic REST: APIs without hypermedia and HATEOAS (12 December 2015)

Prototypes and the myth of disposable code (3 August 2021)

Refactoring monoliths to microservices: the pragmatic reality (5 May 2015)

Relax. There's no conflict between architecture and agile. (16 February 2018)

REST APIs don’t need a versioning strategy - they need a change strategy (27 September 2015)

REST services may not have standards, but they should follow conventions (17 December 2012)

Running a .Net Core console application as a Windows Service (3 September 2017)

Running serverless containers in AWS Fargate, Google Cloud Run and Azure (26 January 2020)

Setting an appetite instead of making an estimate for epic-level work (8 January 2021)

Sharing APIs in an organisation: challenges and pitfalls (4 June 2013)

Sharing code between geographically distributed development teams (15 January 2013)

Sharing libraries between .Net Core and .Net Framework applications (10 March 2017)

Sharing microservices across large organisations (8 March 2019)

Should microservices share technologies and platform capabilities? (28 June 2016)

Should teams choose their own languages and tools? (24 February 2019)

Splitting up shared databases (6 October 2019)

Technical debt is an overused and lazy metaphor (18 November 2017)

Ten myths about Quality Assurance in software development (29 December 2011)

The case against maturity models (8 June 2019)

The code reuse myth: why internal software reuse initiatives tend to fail (11 April 2012)

The generic repository is just a lazy anti-pattern (21 May 2013)

The poor man's Cassandra: scaling Azure Table Storage to maximise throughput. (22 July 2017)

The problem with GUIDs… (3 October 2014)

The problem with the .Net Standard compatibility shim… (12 January 2018)

The problem with tiered or layered architecture (9 July 2014)

The REST flame wars – common disagreements over REST API design (22 November 2014)

The shared code fallacy: Why internal libraries can be an anti-pattern (15 July 2023)

There's more to publishing external APIs than choosing an API management vendor (17 November 2019)

Using a tolerant reader for web service integrations in .Net (22 July 2014)

Using architectural “fitness functions” as a guide to system design (18 June 2018)

Using asynchronous log4net appenders for high performance logging (16 March 2013)

Using Azure Data Factory with the Application Insights REST API (28 October 2019)

Using Docker to build and deploy .Net Core console applications (12 April 2017)

Versioning doesn't make it any easier to manage change in APIs (11 August 2024)

What do we actually mean when we say business logic? (14 April 2016)

What makes a good test automation suite? (3 August 2022)

What makes a REST API mobile-friendly? (25 April 2018)

What role do architects have in agile development? (12 March 2014)

What should a Scaled Agile “architectural runway” look like? (12 October 2017)

What we talk about when we talk about “legacy” systems (22 July 2020)

What's in a name? Three-lettered acronyms and their impact on development culture (20 September 2016)

What's so bad about monoliths anyway…?! (3 October 2016)

When does refactoring become rewriting? (19 June 2017)

When is an event not an event? (8 February 2020)

When should you write your own message endpoint library? (14 December 2019)

When to use serverless architecture... and when not to (9 February 2023)

Why agile software architects should write code (28 January 2017)

Why building AI-powered agents is so challenging. For now. (3 February 2024)

Why is loose coupling between services so important? (14 April 2019)

Why isn't WCF supported in .Net Core? (28 October 2018)

Why refactoring code is almost always better than rewriting it (30 April 2012)

Why REST is not a silver bullet for service integration (4 January 2015)

Why the developer experience matters to architecture (17 April 2021)

Why the Scaled Agile Framework (SAFe) can be agile kryptonite (23 March 2019)

Why trunk-based development isn't for everybody (9 September 2019)

Why you shouldn’t create asynchronous wrappers with Task.Run() (3 November 2014)

Why “low code” and “no code” platforms are like Japanese knotweed (18 July 2021)

Writing a brokered messaging client for Azure Service Bus that is production-ready (22 April 2013)

Writing architectural design principles that scale decision making (13 June 2021)

Writing ArchUnit style tests for .Net and C# to enforce architecture rules (27 November 2018)

“Goldilocks” governance and agile architecture: balancing team autonomy and alignment (24 August 2020)