Forem: Douglas Mor

When Does the Role of a Software Architect Truly Make a Difference in a Project?

Douglas Mor — Tue, 09 Dec 2025 22:51:49 +0000

If you've ever been part of a tech project that seemed to “run smoothly on its own,” chances are there was a sharp software architect behind the scenes — even if you never saw them. And when a project turns into a patchwork monster that becomes painful to scale… well, that’s usually when an architect was missing.

In today’s world, where AI accelerates development, digital products evolve in shorter cycles, and systems must be born scalable, the architect’s role isn’t a luxury. It’s an essential structural pillar for product survival.

Let’s explore where this role truly changes the game.

The current market demands architectures that keep up with business speed

Market pressure has never been stronger. Squads need to deliver fast, products change within weeks, and new features emerge before the old architecture has time to breathe.

This is where the architect shines:

They define the technical direction of the product, ensuring coherence between teams.

They choose architecture patterns (event-driven? modular? serverless?) that fit the company’s ambition and timing.

They reduce risks before they grow into major bottlenecks.

In startups, where speed is everything, the architect prevents products from growing like “apartments built without a blueprint.”
In large companies, the architect brings governance and scalability, balancing innovation with control.

AI does not replace architects — it amplifies them

With the boom of generative AI, many thought architecture would become automated. The truth? AI helps, but it doesn’t replace.

It speeds up tasks such as:

creating initial diagrams,

generating proofs of concept,

reviewing documentation,

conducting historical impact analyses.

But AI does not understand nuances such as:

trade-offs between cost and experience,

compliance constraints,

long-term product evolution strategy,

team culture and technical maturity.

The architect becomes a conductor, orchestrating AI + humans to create flows where critical decisions still rely on someone who sees the whole system, not just the code.

A modern workflow: from discovery to post-production

A software architect plays a role throughout the entire product lifecycle.

Discovery

Here, the architect helps turn problems into technically viable solutions:

mapping constraints,

selecting integrations,

estimating complexities,

defining the architectural MVP.

It’s like drawing the “skeleton” of the product before the muscles are attached.

Delivery

During development, the architect:

creates technical guidelines,

reviews high-impact decisions,

supports developers with systemic vision,

prevents the infamous architecture by accumulation (adding things sprint after sprint without direction).

They ensure the product evolves without turning into a stylish Frankenstein.

Operation and Evolution

Once the product is live, the game changes:

monitoring critical points,

suggesting refactoring strategies,

tracking cloud costs,

planning architectural evolution.

The architect ensures the product doesn’t age poorly.

Architecture aligned with product: where the magic happens

The biggest difference between an ordinary project and an exceptional one lies in the alignment of:

product vision,

technical viability,

user needs.

A software architect helps PMs, designers, and engineers speak the same language.

They turn scattered discussions into:

viable roadmaps,

trade-off–based decisions,

products built with intention rather than “polished hacks.”

When does it really make a difference?

The architect becomes a true differentiator when:

the product needs to scale quickly,

multiple teams work within the same ecosystem,

there’s risk of exponential technical debt,

the business requires high availability,

there’s strong integration with AI, APIs, or microservices,

the product is strategic and meant to last years, not months.

In short, the absence of an architect is only noticed when it’s already too late.

Conclusion

In today’s market — shaped by AI, competitive pressure, and fast cycles — a software architect is not just a technical role. They are the guardian of systemic vision, the bridge between business and engineering, and the one responsible for ensuring a product grows robust, healthy, and sustainable.

Where there is complexity, there is opportunity. And that is exactly where a software architect makes all the difference.

AI Trends for 2026: The Rise of Agents and the New Era of Architecture

Douglas Mor — Tue, 25 Nov 2025 13:38:05 +0000

If 2023 was the year of generative models and 2024–2025 solidified the copilots boom, 2026 will be—undeniably—the year of autonomous agents.
And I’m not talking about “cool bots that write text.” I’m talking about systems capable of operating products, coordinating micro-decisions, interacting with platforms, and massively amplifying the autonomy of teams and companies.

The line between “AI that answers” and “AI that acts” is disappearing.
Agents aren’t just influencing technology—they’re reshaping how we think, design, and run platforms.

Let’s explore what’s happening now and where we’re heading.

Agents: The New Engine Behind Modern AI

Intelligent agents have evolved from predictable automations into true cognitive orchestrators. In 2026, three movements stand out:

Agents as actual teammates

No exaggeration: in many companies, agents already participate in reviews, analyze logs, prioritize backlog items, and generate dashboards automatically.
In 2026, they begin to:

open PRs and suggest full architecture designs

identify pipeline bottlenecks

generate technical docs from real-world events

automate routines that currently require humans “in the loop”

Developers stop being operators and become curators and strategists.

Agents with advanced multimodal perception

They already understand text, audio, image, and video. In 2026, it becomes normal for agents to:

review meeting recordings and highlight forgotten decisions

detect visual degradation in product interfaces

analyze user behavior through video or screen captures

understand entire platform flows without needing documentation

It’s like having a senior analyst with superpowers.

Agents connected across the whole stack

Their influence grows because they’re starting to “see” everything:

infrastructure (K8s, VMs, clusters, cost)

data (lakes, mesh architectures, catalogs)

product systems (APIs, events, logs)

users (telemetry, UX signals)

The more they understand the ecosystem, the more they can act on it.

Platform Architecture Trends Shaping 2026

The rise of agents forces a deep redesign of modern platforms. If the mantra used to be “observability,” now it’s “agentability”—the ability for a system to be operated by agents.

These are the trends shaping the future:

Agent-friendly platforms

Systems now must be readable and actionable by machines—not just humans.

This introduces new design practices:

highly standardized, self-describing APIs

clear action surfaces (e.g., deploy, rollback, promote, diagnose)

rich, semantically complete events

operational metadata as a first-class citizen

If a platform can’t be operated by agents, it will be rebuilt.

Graduated layers of autonomy

Just like autonomous vehicles, platforms begin to expose levels:

Level 0: fully manual

Level 1: agent suggestions (assist mode)

Level 2: supervised execution

Level 3: execution with human override

Level 4: autonomous operation

Level 5: continuous self-optimizing operation

Most new products in 2026 will already start around Level 2.

Goal-driven architecture

Instead of executing deterministic pipelines, platforms expose objectives:

“Keep the service healthy with optimal cost.”
“Maintain SLA X with error rate Y.”
“Increase conversion rate in journey Z.”

This is very different from fixed workflows—it's AI making contextual decisions in real time.

Hybrid platforms: AI + classical engineering

The future isn’t AI replacing DevOps, SRE, or Platform Engineers.
The future is platforms that merge statistical intelligence with deterministic mechanisms.

Common structures in 2026 include:

hybrid control loops (agent decides, platform validates)

executable playbooks (YAML + AI behaviors)

bots acting directly on the service mesh

agent-native infrastructure (secure sandboxing + granular permissions)

It becomes a symphony: rigid automation and adaptive autonomy working side by side.

What This Means for Product Builders

If you’re a dev, architect, PM, or platform engineer, 2026 brings some inevitable realities:

✔ Agents will be active users of your APIs

It’s no longer just “developer-friendly,” it’s machine-friendly.

✔ Documentation becomes largely machine-generated

Models will update and maintain most of it automatically.

✔ Developers shift toward strategic thinking

The question moves from “what endpoint should I call?” to
“what objective should the system pursue?”

✔ Architects will design self-operating platforms

Human intervention becomes exception, not routine.

✔ Small teams will deliver like massive teams

Productivity will explode.

In Summary

2026 will be remembered as the year platforms became autonomous and agents became protagonists.
And us, humans? We stay essential—but operating at a higher level, designing, orchestrating, and supervising an intelligent ecosystem.

Technology is becoming more alive.
It’s up to us to shape what it grows into.

From Enchantment to Disenchantment - How companies are dealing with the new costs of AI

Douglas Mor — Wed, 24 Sep 2025 13:54:07 +0000

Over the past two years, the corporate market has plunged into a true state of enchantment with generative artificial intelligence. Tools like vibe-code and other agent-based solutions promised to revolutionize the way software is produced, drastically reduce teams, and boost productivity. For many companies, it seemed like the “perfect shortcut”: replacing entire teams with AI assistants capable of generating code, analyzing data, and even structuring entire workflows.

At the peak of the hype, several business models were redesigned. Lean startups, reconfigured departments, and even industry giants began experimenting with the idea of an “augmented developer,” capable of delivering double or triple the output with AI support.

The reality check: limits and costs

However, the 2025 landscape tells a different story. What once seemed unlimited now reveals the restrictions imposed by the very business models of AI platforms. A clear example is found in plugins that use agents: while they initially offered 25,000 tokens per session, today, in premium plans, they provide only 3,500 tokens.

This shortening of “computational breathing space” drastically changes the cost–benefit equation. What was once seen as a cheap substitute for larger teams now reveals itself as a strategic and limited service. In other words, companies must balance their expectations: AI is not an infinite production machine but a costly, finite resource that must be optimized.

Balance and a new perspective

This adjustment is likely to push the market out of the enchantment phase and into a stage of rational use of AI. The reduction in token limits means that projects will need to be better planned, demands more focused, and internal processes more optimized.

Instead of mass layoffs, a reskilling movement may emerge: using AI as support, accelerating stages, and enabling smaller teams to be more creative and strategic. The view that “AI will replace everything” begins to give way to a more mature perspective: “AI amplifies, but it doesn’t solve everything on its own.”

And the future of developers?

For the IT market, the impact is ambiguous. On one hand, professionals who relied solely on repetitive tasks risk losing ground. On the other, new opportunities arise for developers who master both coding and the intelligent orchestration of AI — knowing when to use it, how to break problems down into smaller prompts, and how to combine human and automated tools.

The near future is likely to increasingly value the hybrid professional: not only those who know how to code but also those who know how to direct AI to deliver real value within technical and financial constraints.

Conclusion

From the initial enchantment to the current disenchantment, what is unfolding is a collective learning curve. Companies and professionals are realizing that artificial intelligence is not a panacea but a sophisticated and expensive resource that must be managed carefully.

In the end, the greatest legacy of this phase may be the sector’s maturation: less euphoria, more strategy. And for developers, a clear message emerges — the market hasn’t ended, it has simply changed form.