Thursday, 17 September 2026

Your Delivery Platform Is Tier-Zero Infrastructure

On 10 September, GitLab released critical patches for its Community and Enterprise editions. The most serious issue, CVE-2026-85706, was assigned a CVSS score of 10.0. Under certain conditions, an unauthenticated attacker could use the repository commits API to read arbitrary files from a GitLab server. One day later, the US Cybersecurity and Infrastructure Security Agency added the vulnerability to its Known Exploited Vulnerabilities catalogue based on evidence of active exploitation.

The immediate response is straightforward: affected self-managed installations should be upgraded to GitLab 19.1.8, 19.2.6, 19.3.2 or later, and potentially exposed systems should be investigated rather than treated as safe simply because a patch has now been applied.

The more important leadership lesson is broader. Source-control and delivery platforms are no longer developer tools at the edge of the estate. They are tier-zero infrastructure: systems whose compromise can provide a route into much of the organisation.

The development platform has become a control plane

A modern GitLab instance may hold source code, deployment credentials, CI variables, container-registry access, infrastructure definitions, release approvals and integrations with cloud platforms. Even where secrets are stored elsewhere, pipelines often possess the identity required to retrieve them. The platform also records architectural detail that can make subsequent attacks faster and more precise.

This concentration is intentional. Integrated delivery platforms reduce hand-offs, improve traceability and make secure defaults easier to standardise. But integration also changes the blast radius. A vulnerability in the platform is not equivalent to a defect in an internal productivity application; it can undermine the machinery used to build, verify and deploy everything else.

Engineering leaders should therefore stop classifying source control as ordinary SaaS or routine internal tooling. Its recovery objectives, access model, patching expectations and incident playbooks should resemble those used for identity providers and production cloud control planes.

Patch speed is an organisational capability

Critical advisories often expose the gap between a documented patch policy and the organisation’s real ability to act. Teams may know which version they run but still require days to identify owners, negotiate downtime, validate plugins, test runners and obtain change approval. During active exploitation, that operating model is the risk.

A mature response begins before the advisory arrives. Maintain an authoritative inventory of self-managed engineering systems, their public exposure, owners, versions, dependencies and recovery procedures. Define an emergency change path with named decision-makers and explicit authority to trade short-term availability risk for containment. Rehearse upgrades and restoration from backup. If the platform cannot be patched rapidly without organisational theatre, the problem is architectural and operational, not merely procedural.

Managed services alter this equation but do not remove responsibility. The vendor may patch the underlying service, while customers still own tokens, integrations, runner isolation, audit monitoring and the consequences of excessive privileges. The strategic choice between managed and self-hosted platforms should include patch latency and security staffing, not just licensing cost and data residency.

Assume compromise, not just vulnerability

Once a flaw appears in a known-exploited catalogue, upgrading is necessary but insufficient. Leaders should ask what an attacker could have read before remediation and what that information could unlock next.

That means reviewing relevant API and web logs, looking for indicators described by the vendor and security authorities, and preserving evidence before it ages out. Credentials accessible to the platform should be mapped and rotated according to exposure and privilege, rather than resetting everything indiscriminately or assuming nothing leaked. High-value secrets should be short-lived wherever possible, retrieved at runtime and scoped to the smallest useful set of repositories, environments and actions.

CI runners deserve particular attention. Shared, long-lived or broadly privileged runners can turn a repository-platform incident into a cloud incident. Ephemeral runners, restricted network egress, workload identity and environment-specific permissions make lateral movement harder. Protected branches and approval rules remain valuable, but they cannot compensate for a compromised control plane with access to the underlying secrets and automation.

Measure containment, not compliance

Executive dashboards frequently report patch compliance as a percentage. That is useful, but it can conceal the systems that matter most. Ninety-nine per cent compliance is unimpressive if the remaining one per cent includes the platform capable of deploying to production.

A better leadership view combines asset criticality with exposure and response time. Useful questions include:

  • How quickly can we identify every affected instance and accountable owner?
  • Can we patch tier-zero engineering systems within hours when exploitation is active?
  • Which credentials become reachable if the delivery platform is compromised?
  • Can we rotate those credentials without bringing delivery to a halt?
  • Do we retain sufficient logs to determine whether exploitation occurred?
  • Can we rebuild the platform from a trusted state rather than merely restore a potentially compromised backup?

These are not questions for the security team alone. Platform engineering owns much of the implementation, application teams own integrations, and engineering leadership owns prioritisation and risk acceptance. The response has to cross those boundaries before an incident forces it to.

The strategic conclusion

CVE-2026-85706 will be patched and eventually disappear from weekly engineering news. The architectural condition it exposes will remain: software organisations increasingly concentrate code, identity, automation and production authority in a small number of delivery platforms.

That concentration creates leverage, but leverage works in both directions. Treating the platform as tier-zero infrastructure does not mean slowing delivery with indiscriminate controls. It means engineering for rapid patching, limited privilege, observable access and credible recovery. Those capabilities protect the delivery system while allowing teams to move faster with justified confidence.


Source note: GitLab’s critical patch release was published on 10 September 2026. CISA added CVE-2026-85706 to its Known Exploited Vulnerabilities catalogue on 11 September based on evidence of active exploitation. The GitHub Advisory Database entry summarises the affected and patched versions.

AI Coding Agents Are Becoming an Engineering Management Problem

This week’s $200 million funding round for enterprise coding-agent company Factory, reportedly valuing the business at $5 billion, is another sign that AI-assisted development is moving beyond autocomplete. The emerging product is no longer simply a faster way to write a function. It is an agent capable of reading a codebase, planning changes, editing several files, running tests and preparing work for review.

For web developers, that shift is significant. Modern applications contain far more than JavaScript components: infrastructure configuration, analytics, accessibility rules, automated tests, deployment pipelines and security controls all sit within the same delivery system. An agent that can reason across those boundaries may remove hours of repetitive work. Dependency upgrades, test scaffolding, documentation, migration preparation and first-pass bug fixes are increasingly realistic candidates for delegation.

But the more interesting challenge belongs to engineering managers.

Productivity cannot be measured by lines of code or pull requests created. If agents increase the volume of proposed changes without improving outcomes, they merely move the bottleneck from development to review and quality assurance. Teams may appear faster while senior engineers spend more time checking unfamiliar code, QA faces a growing regression surface, and technical debt arrives at machine speed.

The management response should not be to ban agents or allow unrestricted experimentation. It should be to redesign the workflow around clear boundaries. Low-risk, reversible tasks can be delegated first. Every change should still pass the same tests, security checks and architectural expectations as human-written code. Draft pull requests are useful because they allow agents to prepare work without pretending it is ready to merge. Small changes remain easier to understand, validate and reverse.

Ownership also needs to stay human. An agent can produce an implementation, but it cannot carry organisational accountability for a production incident, an accessibility failure or a poor product decision. The engineer requesting the work must understand the change well enough to defend it. The reviewer must evaluate behaviour and intent, not simply accept a green pipeline. Managers should resist creating a two-tier environment in which generated code receives lighter scrutiny because it arrived quickly.

The best adoption metric is therefore not “how much code did AI write?” Better questions include: Did lead time fall? Did defects increase? Was review time reduced or displaced? Are developers spending more time on valuable decisions? Can the team recover safely when an agent makes the wrong assumption?

AI coding agents are becoming a serious part of software delivery, and the investment market is betting heavily on them. Their lasting value, however, will not come from replacing engineering discipline. It will come from amplifying teams that already have clear standards, reliable automation and strong technical leadership.

The competitive advantage will not belong to the company with the most agents. It will belong to the team that learns where autonomy helps, where judgement matters, and how to preserve both speed and trust.

Source context: Reuters, 15 September 2026.

Sunday, 13 September 2026

The road to CAIO

The Engineer Who Stops Owning Only the Code

For much of a software engineer’s career, progression appears straightforward.

Junior Developer. Developer. Senior Developer. Perhaps Staff or Principal Engineer. Engineering Manager. Head of Engineering. CTO.

Artificial intelligence has introduced another destination: Chief AI Officer — CAIO.

At first glance, it seems like a role intended for machine-learning researchers, data scientists and people who have spent their careers building neural networks.

That assumption misses what may become one of the most important aspects of the role.

A successful CAIO does not necessarily need to be the person who can build the best model.

They need to be the person who can answer a much bigger question:

How should this organisation use AI to become better?

That creates an interesting career opportunity for experienced software engineers.

The journey from Senior Developer to CAIO isn't about abandoning engineering. It is about repeatedly widening the boundary of what you consider your responsibility.


Stage One: Senior Developer — Make the Software Better

A Senior Developer is primarily responsible for execution.

You understand the system beyond the ticket in front of you. You recognise technical debt, challenge poor architectural decisions, mentor less experienced engineers and understand how changes affect production.

Your questions evolve from:

"How do I implement this?"

to:

"How should we implement this?"

You begin experimenting with AI in much the same way developers previously adopted Stack Overflow, IDE tooling, automated testing and CI/CD.

Perhaps you use an AI coding assistant.

Then you discover that it can generate tests.

Then documentation.

Then review code.

Then investigate failures.

Eventually, you stop thinking about AI as a chatbot.

You start thinking about it as another participant in the software-development lifecycle.

That shift matters.

The skill to develop

Become exceptionally good at AI-assisted engineering, while remaining sceptical enough to verify its output.

The goal isn't maximum AI usage.

The goal is better engineering outcomes.


Stage Two: Staff or Principal Engineer — Make the Engineering System Better

The next transition is subtle but important.

You stop optimising your own productivity and start asking why the entire team isn't benefiting.

Perhaps ten engineers all use AI differently.

One generates tests.

Another reviews pull requests.

Someone has built elaborate personal agents.

Another refuses to use AI entirely.

Nobody measures whether any of it actually works.

This is where technical leadership becomes important.

Instead of saying:

"Here's how I use Copilot."

you ask:

"Where should AI exist within our engineering lifecycle?"

You might identify repeatable stages:

Plan → Build → Test → Review → Deploy → Observe

Then determine where AI provides genuine leverage.

Perhaps an agent examines a draft pull request and identifies missing tests.

Another evaluates coverage.

Another checks implementation against acceptance criteria.

Humans remain accountable for the outcome, but increasingly repetitive cognitive work becomes automated.

Now you aren't simply using AI.

You're designing an AI-enabled engineering system.

The skill to develop

Learn AI workflow architecture.

Understand agents, context, evaluation, model limitations, security boundaries, human approval and observability.

Most importantly, learn when not to use AI.


Stage Three: Engineering Manager — Make the Team Better

Engineering management introduces another dimension: people.

An AI transformation fails surprisingly quickly if it is treated exclusively as a technology project.

Engineers worry that automation will replace them.

Some developers become dramatically more productive.

Others blindly trust generated code.

Some avoid AI because they don't understand it.

Management may hear extravagant productivity claims and assume development should suddenly become twice as fast.

The Engineering Manager has to establish sensible expectations.

That means introducing standards.

Which tools are approved?

What information may be supplied to models?

When must humans review output?

How do we measure whether an agent actually improves delivery?

What happens when an AI-generated change causes an incident?

You begin moving from AI tooling toward AI governance.

And you learn perhaps the most important lesson on the path to CAIO:

AI transformation is primarily organisational transformation enabled by technology.

The skill to develop

Learn change management and measurement.

Don't report:

"80% of developers use AI."

Report outcomes:

"Median pull-request cycle time fell 18%, while escaped defects remained unchanged."

Executives care about the second sentence.


Stage Four: Head of Engineering — Make Engineering Better

At Head-of-Engineering level, the boundary expands again.

You are no longer optimising one team.

You are looking across an engineering organisation.

Different teams have different workflows, technologies and risk profiles.

Individual AI experiments become organisational capabilities.

You establish principles rather than individual prompts.

You may create an AI engineering strategy covering:

  • approved tooling;
  • security and privacy;
  • SDLC integration;
  • agent architecture;
  • evaluation;
  • procurement;
  • training;
  • governance;
  • productivity measurement.

At this stage, another important change occurs.

Other departments become interested.

Product asks whether AI can accelerate discovery.

Customer service wants automated assistance.

Marketing wants content generation.

Finance wants document analysis.

HR wants internal knowledge tools.

The problem is no longer an engineering problem.

It is becoming a company problem.

The skill to develop

Learn to translate between technology and business value.

Every proposed AI initiative should eventually answer:

What improves if we do this?

Revenue?

Cost?

Speed?

Quality?

Customer experience?

Risk?

If none of those moves meaningfully, the organisation probably doesn't need the AI project.


Stage Five: AI Transformation Leader — Make the Organisation Better

This is the bridge many future CAIOs may cross.

The title could be Director of AI, Head of AI Enablement, VP of AI Transformation or something entirely different.

The title matters less than the scope.

Your responsibility now crosses organisational boundaries.

You begin building an AI portfolio.

Instead of approving every interesting experiment, initiatives can be assessed against common criteria:

Business value × feasibility × risk × strategic importance.

A flashy autonomous agent promising modest savings may rank below a boring document-processing workflow saving thousands of staff hours.

This is where technical judgement becomes commercial judgement.

You also work increasingly closely with security, legal, finance, HR and executive leadership.

Questions become harder.

Should customer data ever reach an external model?

Who owns AI-generated intellectual property?

How do employees challenge automated decisions?

What happens when a supplier changes its model?

Should the organisation build, buy or partner?

How dependent should the company become on one AI provider?

These aren't programming questions.

They are executive decisions requiring technical understanding.

The skill to develop

Learn enterprise AI strategy, economics, governance and risk.


Stage Six: Chief AI Officer — Make AI a Business Capability

Eventually the scope reaches the organisation itself.

The CAIO's job isn't:

"Introduce more AI."

It is:

"Ensure this organisation extracts sustainable value from AI while controlling the associated risks."

That distinction is critical.

Sometimes the correct CAIO decision will be to invest aggressively.

Sometimes it will be to experiment.

Sometimes it will be to wait.

And occasionally it will be:

Don't use AI here.

The CAIO owns the portfolio rather than every implementation.

They connect corporate strategy with technological capability.

They understand enough about models, agents, data and software architecture to challenge technical proposals.

But they also understand finance well enough to challenge an AI project without measurable returns.

They understand governance well enough to recognise unacceptable risk.

And they understand organisations well enough to know that issuing everyone an AI licence isn't transformation.

The progression is therefore not:

Developer → AI Expert → CAIO

It is closer to:

Developer → Systems Thinker → Technical Leader → Organisational Leader → Business Leader

AI is the domain.

Leadership is the progression.


The Career Ladder

A useful way of thinking about the journey is through the question you are responsible for answering.

Senior Developer

How can AI make my engineering better?

Staff / Principal Engineer

How can AI make our engineering system better?

Engineering Manager

How can AI make this team more effective without compromising quality?

Head of Engineering

How should engineering adopt AI consistently and safely?

AI Transformation / Director of AI

Where can AI create measurable value across the organisation?

Chief AI Officer

How should AI change the way this company operates and competes?

Each promotion expands the noun.

My code.
Our system.
My team.
Engineering.
The organisation.
The business.


Start Before You Have the Title

The most valuable part of this career path is that you don't need permission to begin it.

A Senior Developer can measure whether AI-assisted testing improves coverage.

A Staff Engineer can design an AI-assisted development workflow.

An Engineering Manager can establish team standards.

A Head of Engineering can coordinate adoption across teams.

Someone eventually notices that the person repeatedly answering the organisation's AI questions has effectively become its AI leader.

That creates a very different career strategy from chasing a title.

Don't wait to become Chief AI Officer before thinking like one.

Find one measurable problem.

Introduce AI where appropriate.

Establish safeguards.

Measure the result.

Document what happened.

Then increase the scope.

Do it for yourself.

Then your team.

Then engineering.

Then another department.

Then the organisation.

Because the journey from Senior Developer to Chief AI Officer isn't ultimately defined by how sophisticated your prompts become.

It is defined by how large a problem the organisation trusts you to own.


Friday, 12 December 2025

Record Number of Developers Adopting AI as Vibe Coding Surges

As AI adoption continues to rise across the tech industry, a record number of web developers are turning to vibe coding to build applications.

Nine out of ten workers in the tech sector are now using AI tools at work, up from around 76% in 2024. Generating code has become a major application, with vibe coding—where developers prompt AI models with natural language descriptions to create executable code—leading the charge.

Latest figures from industry reports suggest AI spending in enterprises jumped to $37 billion in 2025, a 3.2x increase from the previous year. Experts warn that traditional coding skills could face disruption as non-technical users increasingly "vibe code" complex features in seconds.

In recent months, major platforms like Google highlighted vibe coding tools in AI Studio, amid ongoing discussions on productivity and maintainability.

Tuesday, 21 October 2025

Headless CMS: Revolutionising Content Management for Modern Web Projects in 2025

Headless CMS has become a cornerstone of modern web development, decoupling content management from presentation for unparalleled flexibility. As a Principal Engineer, I have used platforms like Contentful and Strapi to streamline multi-platform content delivery. This article explores why headless CMS is essential in 2025 and how to implement it effectively.

What is Headless CMS?

Unlike traditional CMSs like WordPress, which tie content to a specific frontend, headless CMS focuses solely on content storage and delivery via APIs. This enables developers to use modern frameworks like React or Vue while content teams manage updates independently. In 2025, 44% of enterprises have adopted headless setups for their speed and scalability.

Benefits for Web Development

  1. Flexibility: Deliver content to web, mobile, and IoT devices without reengineering. In a Laravel project, I used Strapi to serve content to both a Next.js frontend and a mobile app.
  2. Performance: Paired with Jamstack, headless CMS enables static generation for sub-second load times.
  3. Collaboration: Content editors work in intuitive interfaces, while developers focus on code, improving workflows.

Implementing Headless CMS

Choose a platform like Contentful for enterprise needs or Strapi for open-source flexibility. Integrate with a static site generator like Next.js for optimal performance. In my experience, GraphQL APIs outperform REST for complex content models, reducing overfetching. Use CI/CD pipelines with Vercel or Netlify for automated deployments.

Addressing Challenges

The learning curve for API-driven workflows can be steep. Provide training on tools like Postman for API testing. Budget for API costs, as enterprise plans can be pricey. Clear documentation and modular content models prevent integration issues, as I learned in a multi-channel e-commerce project.

The Future of Content Management

Headless CMS is redefining content delivery in 2025, enabling omnichannel strategies and faster iterations. For developers and content teams, it offers freedom and efficiency. Start with a small project, like a blog, to experience its benefits and scale confidently.

Tuesday, 14 October 2025

Augmented Reality on the Web: Creating Immersive User Experiences in 2025

 


Augmented Reality (AR) is transforming web development, enabling immersive experiences directly in the browser. As a frontend engineer, I have leveraged AR to enhance e-commerce and educational platforms, delivering engaging user interactions. This article explores AR’s potential in 2025 and provides practical guidance for developers.

The Rise of Web-Based AR

Unlike virtual reality, AR overlays digital content onto the real world, accessible via smartphones or browsers without specialised hardware. In 2025, WebAR leverages WebXR APIs, supported by Chrome and Safari, to create seamless experiences. Retail giants like IKEA use AR for virtual product previews, boosting conversion rates by up to 30%.

Implementing AR in Web Applications

Start with WebXR, a W3C standard for AR and VR. Libraries like Three.js simplify 3D rendering, while AR.js enables marker-based AR for simpler projects. In a recent Vue project, I used A-Frame to create an AR product visualiser, allowing users to view furniture in their space via mobile browsers.

Key steps include:

  1. Set Up WebXR: Ensure browser compatibility and enable device motion permissions.
  2. Build 3D Models: Use Blender or glTF formats for lightweight assets.
  3. Test Across Devices: Validate performance on iOS and Android to ensure accessibility.

Performance and User Experience

AR is resource-intensive; optimise by compressing 3D models and using progressive loading. Ensure intuitive UX with clear prompts for camera access. In my projects, testing with Lighthouse helped maintain 60fps rendering, critical for smooth AR experiences.

Challenges and Solutions

Device compatibility and performance vary widely. Fallback to 2D views for unsupported devices to maintain inclusivity. Upskill your team with WebXR tutorials from MDN Web Docs. As an engineering manager, prioritise small-scale pilots to gauge AR’s impact before full adoption.

Why AR Matters

With 5G enabling faster data transfer, WebAR is poised to dominate in 2025, offering immersive experiences for e-commerce, gaming, and education. By integrating AR, developers can create engaging, competitive applications. Start experimenting to captivate your users.

Tuesday, 7 October 2025

Blockchain Integration: Empowering Decentralised Web Applications in 2025

Blockchain technology is no longer just about cryptocurrencies; it is revolutionising web development by enabling decentralised applications (dApps). As a Principal Engineer, I have explored blockchain integrations in frontend projects, leveraging tools like Ethereum and IPFS to enhance security and trust. This article examines blockchain’s role in 2025 web development and offers practical steps for implementation.

Why Blockchain Matters for Web Development

Blockchain’s decentralised ledger ensures tamper-proof data storage, ideal for applications requiring transparency, such as supply chain tracking or digital identity. In 2025, enterprise adoption is growing, with platforms like OpenSea using blockchain for secure NFT marketplaces. Blockchain also reduces reliance on centralised servers, aligning with edge computing trends for lower latency.

Integrating Blockchain into Web Apps

Start with a blockchain platform like Ethereum for smart contracts or Solana for faster transactions. For a React-based dApp, use libraries like ethers.js to interact with Ethereum nodes. In a recent project, I integrated IPFS for decentralised file storage, reducing hosting costs by 50% compared to traditional cloud solutions.

Key steps include:

  1. Set Up a Wallet: Use MetaMask for user authentication and transaction signing.
  2. Write Smart Contracts: Use Solidity for Ethereum-based contracts, ensuring rigorous testing with tools like Truffle.
  3. Connect to Frontend: Fetch blockchain data via APIs like Infura, integrating with frameworks like Next.js.

Security and Scalability Considerations

Blockchain’s immutability enhances security, but smart contract vulnerabilities require thorough auditing. Tools like Mythril can detect issues early. Scalability is another challenge; layer-2 solutions like Polygon reduce transaction costs and improve throughput. In my experience, testing on testnets like Ropsten prevents costly mainnet errors.

Getting Started

Begin with a small dApp, such as a decentralised voting system, to learn blockchain workflows. Resources like Ethereum.org offer comprehensive guides. Train your team on Web3 concepts to bridge the skills gap, as blockchain development differs significantly from traditional web stacks.

The Future of Decentralised Web

Blockchain is set to redefine web applications in 2025, offering unparalleled security and user trust. By integrating decentralised technologies, developers can build innovative, resilient solutions. Start exploring today to lead the Web3 revolution.

Your Delivery Platform Is Tier-Zero Infrastructure

On 10 September, GitLab released critical patches for its Community and Enterprise editions. The most serious issue, CVE-2026-85706, was ass...