English on Daniel Bonam

FIWARE: the heart of smart cities

Mon, 13 Apr 2026 12:01:02 +0000

What is FIWARE

FIWARE is an open-source platform that provides standardized components to accelerate the development of applications in the context of smart resources and services.

Born in 2011 as an initiative of the European Commission in partnership with major technology companies, the FIWARE ecosystem is now present in cities, farms, industries, ports, energy networks, and many other domains that depend on real-time data.

In a smart city, FIWARE acts as a “brain” that integrates data from traffic, parking, public lighting, environment, and safety into a unified, real-time context view. Instead of each system living in its own silo, everything starts speaking the same language, enabling faster decisions and smarter public services.

How FIWARE sees the city

For the FIWARE platform, a city (or any other smart environment) is broken down into abstractions. Each part of the real world becomes a digital context element that can be queried and updated in real time.

Entities: represent elements of the city, such as parking spots, streetlights, buses, bins, sensors, and so on. Each of these physical elements has a “digital copy” inside the platform, called an entity.
Attributes: describe the state of these entities. A parking spot may have attributes such as occupied/free; a streetlight may have attributes such as light intensity and energy consumption. In short, attributes are the pieces of information that characterize each entity at a given moment.
Verticals: are the major business domains in which entities are organized, such as mobility, public lighting, safety, environment, energy, sanitation, and others. Each vertical has its own types of entities, but they all share the same context language.
Context: is the digital representation of the current state of these entities. Put simply, it is the “snapshot of the moment” of the city, seen through its digital objects.

In this way, FIWARE can abstract real-world elements of the city into a standardized context model. This allows different solutions and vendors to see the same urban reality without depending on a single proprietary system.

The FIWARE architecture

From an architectural point of view, FIWARE is not a single system; it is a set of components that, combined, form a smart platform. Each solution uses only the building blocks needed for its use case, always built around a central element called the Context Broker.

Context Broker: the core of the platform

The Context Broker is the component responsible for maintaining and exposing the context in real time, that is, the up-to-date state of the entities that represent the city. It exposes the context API for creating, updating, querying, and subscribing to changes, acting as the central integration point for all other blocks.

Generic Enablers: building blocks around context

Around the Context Broker, FIWARE offers several components called Generic Enablers. They extend the capabilities of the platform by enabling the integration of devices and sensors through IoT connectors, processing and storing data for history, analysis, and insights, as well as handling identity, authentication, and authorization to protect the city’s APIs and resources.

Applications and systems consuming context

On top of this base, web and mobile applications, operational dashboards, open data platforms, and even legacy city systems can consume the context exposed by FIWARE. From there, each team or vendor can build smart services on top of the same city view, without having to reinvent the integration layer.

Conclusion

FIWARE was born as a concrete response to the chaos of isolated systems that exists in many cities: instead of each solution living in its own world, the platform proposes a common context language and a well-defined core, the Context Broker, around which everything connects.

By representing the city through standardized entities and attributes and providing pluggable blocks for IoT, data, and security, FIWARE creates a solid foundation for different teams, vendors, and startups to build smart services on top of the same urban reality.

In other words, FIWARE works as a common language for countless systems, allowing them to finally work together in building the connected future of smart cities.

Allowing an AI to Access My Browser (E2E Tests with Playwright MCP)

Wed, 02 Jul 2025 00:38:49 +0000

A major challenge in building quality software is ensuring that everything keeps working as expected — even as the codebase changes. That’s where end-to-end (E2E) tests come in. They help validate that your application behaves correctly from the user’s perspective.

E2E tests are great at catching bugs because they simulate real user interactions. They can detect issues that unit or integration tests might miss — like UI glitches, navigation problems, or broken user flows.

But let’s be honest: E2E testing isn’t always sunshine and rainbows. These tests can be slow, brittle, and hard to maintain. Writing and maintaining them is painful — especially in applications that change frequently or don’t have a solid testing foundation to begin with.

That’s where AI can help. It can assist in generating and maintaining E2E tests, freeing you to focus on designing high-impact scenarios that cover critical user paths and edge cases.

In this article, we’ll explore how to use AI with Playwright to generate E2E test code. You write the test scenarios, and AI handles the implementation.

Playwright + MCP

What is Playwright?

Playwright is a powerful open-source library for automating web browsers. It lets you interact with web pages, fill out forms, click buttons, and perform other actions — just like a real user would. Playwright supports multiple browsers (Chromium, Firefox, WebKit) and works with JavaScript, TypeScript, Python, Java, and .NET.

You can use it to simulate user interactions and verify your application’s behavior through automated tests.

And what is MCP?

MCP (Model Context Protocol) is a protocol that provides a standardized way to interact with AI models. It lets you send requests and receive responses from AI systems, abstracting away the complexity of the underlying implementation.

Think of it as an API for AI agents, where you define what tools it can use.

Using them together

Playwright enables browser automation. MCP enables seamless AI integration. Combined, they allow you to generate test scenarios and code using AI, giving the model the power to explore and test your application like a real human.

Setup

Let’s set up our project to use Playwright with MCP. We’ll install dependencies, configure the environment, and prepare everything to write AI-generated tests.

Prerequisites

Node.js installed
A code edittor (e.g. VS Code, Cursor)
Copilot installed and configured

Install and configure Playwright

Create a new Node.js project:

1

npm init -y

Install Playwright:

1
2


npm install -D @playwright/test
npx playwright install

Configure MCP in VS Code

Create a .vscode/mcp.json file with the following:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


{
 "servers": {
 "playwright": {
 "command": "npx",
 "args": [
 "@playwright/mcp@latest"
 ]
 }
 }
}

Then, create a prompt file called generate-tests.prompt.md with this content:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


---
tools: ['playwright']
mode: 'agent'
---

- You are a Playwright test generator.
- You are given a scenario and must generate a Playwright test for it.
- DO NOT generate test code based on the scenario alone.
- DO run steps one by one using the tools provided by Playwright MCP.
- When asked to explore a website:
 1. Navigate to the specified URL
 2. Explore one key feature of the site, then close the browser.
 3. Implement a Playwright TypeScript test using @playwright/test based on the message history, following best practices: role-based locators, auto-retrying assertions, and no unnecessary timeouts.
- Save the test file in the `tests` directory.
- Execute the test and iterate until it passes.
- Include appropriate assertions to validate expected behavior.
- Use clear, descriptive test titles and comments.

1
2
3
4
5
6
7



*That’s it! You’re all set*

## Writing Tests with AI
With everything configured, you’re ready to write tests using AI.

Open GitHub Copilot Chat in your VS Code editor and ask it to explore a website, like:

Explore https://google.com

1
2
3
4
5
6
7
8



Copilot will confirm before executing the command. Click “Yes”, and it will open a browser.

![](05-1-bdzksmsvulhvwwvcfyjyna.png)

![](06-1-kfcqkknlakx-aqj7hb8xeg.png)

With the browser open, describe the actions you want it to perform:

Click on the search input, type “Playwright e2e tests”, and press Enter. Then, click on the ‘News’ tab to view the latest updates.

1
2
3
4



![](07-1-jkrzbvjtqqc0mja4afm-5a.gif)

After performing the steps, ask it to generate the test:

Generate a Playwright test based on the actions performed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15



The AI will generate and save the test file, ready for execution!

![](08-1-srdqhh0wckubyhq-jidzlg.gif)

## Conclusion
Pretty cool, right? In this article, we saw how to use AI to create end-to-end tests with Playwright and MCP. We configured the environment, installed the necessary tools, and walked through writing tests with the help of AI.

![](09-1-3izghufr1sfkdf1gopjqdg.gif)

Of course, AI isn’t perfect. It can generate incorrect or incomplete test code. So, always review and validate the output before relying on it. But as a starting point, it’s incredibly helpful and can save hours of manual effort.

![](10-0-sl5zjl-92mypo1pr.gif)

And remember: AI is a **tool** for QA engineers, not a **replacement**. It helps you go faster, but quality still needs human judgment.