It is a common misconception that the QA role is limited to “finding bugs at the end of development.” After three years of experience across different areas of Quality Engineering, I have proven that our work is actually the common thread ensuring a project’s success from inception to launch.

Throughout my career, I have experienced validation from three distinct perspectives, each teaching me why testing is non-negotiable:

1. The Power of Consistency and Maintenance

During my time working with major clients like SEAT, I learned that in highly organized environments, the real challenge isn’t just creating tests—it’s keeping them alive.

• The Takeaway: An outdated test is just as dangerous as no test at all. Ensuring existing tests remain functional while designing new ones for upcoming features is what allows a product to scale securely without breaking what already works.

2. From Paper to Prototype: Alignment and System Testing

When I shifted my focus to System Testing, the game changed. This is where I learned the critical importance of “Phase Zero”: receiving a prototype, analyzing specifications, and, most crucially, ensuring that we and the client are 100% aligned before production begins.

• The Takeaway: Physical testing demands precision and versatility. I moved into manual and industrial validation, operating equipment such as dataloggers, thermal cameras, centrifugal pumps, and climate chambers/ovens. Furthermore, I realized the immense value of automation by programming and controlling systems to execute long-duration or fatigue tests that would be impossible to perform manually.

3. Versatility in Software Validation

In my most recent role, focusing on the company’s proprietary software product, I have seen how validation must be fluid and adapt to the context.

• The Takeaway: Tackling a greenfield product from scratch is entirely different from validating an upgraded version with new features, or running regression tests to ensure recent changes haven’t disrupted the system’s core. A QA’s adaptability directly dictates how agilely a company can ship improvements to the market.

In conclusion: Testing is not a bottleneck; it is a confidence accelerator. It ensures that what the client envisioned is what gets built, that what is built withstands the real world, and that the software controlling it evolves without a hitch.

–JM. Flores

Until now, AI-driven automation has focused on creating specialized “assistants”: a chatbot for customer service, a model that generates reports, another one that classifies data. But what if, instead of a single assistant, you could orchestrate an entire team of AI specialists that assign work among themselves, collaborate, and make sequential decisions without human intervention? This is no longer science fiction: it’s called Agentic AI, and it’s redefining what an automated process truly means.

---

1. The Conceptual Leap: From Tool to Agent

The key lies in agency. An AI agent doesn’t just execute an instruction—it perceives its environment (data, outputs from other agents, triggers), defines a goal, and takes actions to achieve it.

Think of the difference between a grammar-checking tool and a professional editor who decides to rewrite a paragraph for greater impact. That’s the shift from tool to agent.

---

2. The Power Is in the Orchestration: A Multi-Agent Flow in Action

This emerges when several agents, each with a specific role, work together. Here’s a concrete example of what could be implemented in process automation:

• Agent 1 (Researcher): Monitors news sources and market alerts. Detects a headline relevant to a client.
• Agent 2 (Analyst): Takes that headline, cross-references internal client data, and generates a brief impact assessment.
• Agent 3 (Strategist): Based on that assessment, decides on the best action: prepare a tailored proposal? Alert an executive? Choose the right path.
• Agent 4 (Executor): Carries out the action: drafts a personalized email, schedules a notification, or creates a task for a human.

This workflow—which once took hours or days of back‑and‑forth—now executes autonomously in minutes, 24/7, thanks to agent orchestration.

---

3. Why This Excites Us: Key Benefits

• Complex Problem Solving: Breaks down solutions into manageable steps, mirroring team-based reasoning.
• Fault Tolerance and Adaptability: If one agent fails to reach a goal, the flow can reroute, request help, or ask for additional data (from another agent or a human).
• Next-Level Efficiency: It doesn’t automate isolated tasks—it automates full cognitive processes. This frees human talent for oversight, creativity, and exception handling.

---

4. How to Start Exploring (Without the Hype Trap)

Building these flows requires a mindset shift. Based on our learning so far, a good starting point is:

• Map an existing process clearly, identifying decisions and branching paths.
• Define clear “roles”: What will each agent do? Specialization is essential.
• Establish a communication protocol: How will data and information be exchanged? (APIs, structured messages, specific formats, etc.)
• Keep humans in the loop: Design checkpoints and supervision moments. Human judgment should remain the ultimate authority.

Agentic AI is not about replacing jobs—it’s about amplifying organizational capabilities so they become more proactive, resilient, and intelligent. We are moving from being tool users to becoming architects of autonomous digital ecosystems.

---

Let me ask you:

• What process in your area do you think would benefit from having an “AI team” working in the background?
• Have you explored tools like Autogen, CrewAI, or any other agent orchestrators using LLMs?

I’d love to read your insights and experiences in the comments.

---

Ricardo F.
Passionate about the practical application of AI to transform business processes. Currently exploring the potential of multi‑agent workflows as QA Automation at Oxigent Technologies.

While working as a CE with a system based on an Event‑Driven Architecture (EDA) pattern, I wanted to evaluate the possibility of using this architecture in more everyday tasks. For this case, I chose a control and attendance system that could be used during dog‑walking days organized by an animal shelter located in San Antonio de Benagéber, Valencia, Spain.

The main idea is to assist in coordinating the walks so that volunteers always know—visually and intuitively—which dogs have gone out, which dogs are currently walking, and any other necessary information to ensure the day runs smoothly.

Basically, the system consists of an entry point that triggers an event. The system then analyzes whether it is an entry or exit event and displays it on a dashboard. Later on, we will go deeper and—if possible—make it more complex. For example, adding the ability to obtain metrics about the walking days and the dogs, or adding warning indicators in case two reactive dogs might go out at the same time.

---

Solution Architecture (General Overview)

Ingestion (Producers):

A single API receives all events (QR, NFC, AI).

Routing (Event Bus):

An event bus classifies and distributes the events.

Logic (Consumers):

A “brain” function processes “Entry” and “Exit” events.

State (Database):

A database stores the current state (INSIDE/OUTSIDE) and timestamps.

Visualization (Dashboard):

The dashboard updates in real time.

---

1. Ingestion: Amazon API Gateway

To prevent the mobile app (used for QR/NFC) or the AI model from connecting directly to the logic layer, I use a single, secure, and scalable entry point.

• Service: Amazon API Gateway
• How it works:
  A REST API is created (e.g., POST /events).
  All devices send a simple JSON payload to this endpoint.

---

2. Routing: Amazon EventBridge

API Gateway performs no computation. Its only task is to pass the event on to the central event bus.

• Service: Amazon EventBridge
• How it works:
  API Gateway places the event into EventBridge.
  EventBridge evaluates the event and decides where to send it based on Rules.

---

3. Logic and State: AWS Lambda + Amazon DynamoDB

This is where the magic happens. EventBridge forwards all events to a “brain” function that maintains the dogs’ state.

• Services: AWS Lambda and Amazon DynamoDB
• Database (DynamoDB):
  A table called EstadoPerros is created.
• Function (Lambda):
  A Lambda function called ProcesarMovimientoPerro is created.
  EventBridge triggers it every time an event arrives.

Lambda Logic:

• IF the event action is "SALIDA" (Exit):
  Process the dog as “going out.”
• IF the event action is "ENTRADA" (Entry):
  Process the dog as “coming back.”

---

4. Visualization: Real‑Time Dashboard

The dashboard must receive changes instantly, without a page refresh.

• Services: AWS AppSync or AWS IoT Core (WebSockets)
• How it works (with AppSync):
  1. EventBridge has a second rule:
     “If an event contains nuevo_estado…”
  2. The target of this rule is AppSync.
  3. The dashboard uses the AppSync client library to subscribe to updates.
  4. When AppSync receives an event like:
     {"id_perro": "p-001", "nuevo_estado": "FUERA"}
     it sends it via WebSocket to all connected dashboards.
  5. The dashboard updates the icon for p-001 to “OUTSIDE” in real time.

---

5. Total Time Calculation

To track information for the day:

• tiempo_paseo_total_hoy is already being calculated and stored in DynamoDB each time a dog returns from a walk.
• When the dashboard loads for the first time, it simply queries DynamoDB (via API Gateway) to retrieve the current state and total time for all dogs.

---

Additional Task: Daily Reset

I need a way to reset the tiempo_paseo_total_hoy counter to 0 every day.

• Service: Amazon EventBridge Scheduler
• How it works:
  A scheduled rule (“cron job”) is created to run every day at midnight.
  The target is a new Lambda function (ResetContadoresDiarios) that scans the DynamoDB table and sets tiempo_paseo_total_hoy = 0 for all dogs.

---

Implementation Notes

Whenever possible, I will use IaC (Terraform) for implementation and commit the code to my GitHub account.

---

Thanks to Oxigent Technologies for providing the resources for this POC.
Thanks for reading this far, and I welcome all suggestions!

Martin P.

In the past decade, blockchain technology has emerged as a revolutionary solution for building decentralized and secure systems. Beyond its association with cryptocurrencies, blockchain offers a vast field of opportunities for developers interested in creating innovative applications.

Blockchain development involves creating and maintaining decentralized applications (dApps) and smart contracts that run on platforms like Ethereum, Hyperledger, and Binance Smart Chain. To work in this sector, it’s essential to master:

• Programming languages: Solidity is essential for Ethereum, while Go, JavaScript, and Python are useful for other platforms. With the recent rise of the Solana ecosystem, Rust has become a highly sought-after language.
• Cryptography: Understanding techniques such as asymmetric encryption, hash functions, and digital signatures is crucial to ensure application security.
• Data structures and algorithms: Familiarity with structures like Merkle trees and consensus algorithms such as Proof of Work (PoW) and Proof of Stake (PoS) is necessary for designing efficient blockchain systems.

Additionally, using specialized tools enhances the development process:

• Development environments: Frameworks like Truffle and Hardhat streamline the compilation, testing, and deployment of smart contracts.
• APIs and libraries: Web3.js and ethers.js enable interaction between web applications and the blockchain.
• Version control systems: Git is indispensable for efficient collaboration and source code management.

Adopting best practices is more important than ever for success in blockchain projects:

• Writing secure code: It’s vital to prevent vulnerabilities such as reentrancy attacks and overflows.
• Thorough documentation: Keeping detailed records of the code and its functionality facilitates audits and future collaboration.
• Rigorous testing: Implementing unit and integration tests ensures the correct functioning of smart contracts.

Blockchain development represents an exciting frontier in technology, offering opportunities to create innovative solutions and transform industries. Mastering technical skills, using the right tools, and adhering to best practices will position developers to lead in this dynamic field. As blockchain adoption continues to grow, those prepared to face its challenges will be in a privileged position to drive the digital future.

-P. Riera

Artificial Intelligence has transformed many industries, and software development is no exception. GitHub Copilot, powered by GPT-4 AI, is a tool that assists developers in many programming languages, making it easier to write code, boosting productivity, and reducing errors.

GitHub Copilot has become an essential tool for development. It quickly and effectively provides real-time code suggestions. This article explores its features, limitations, and the impact it’s having on programming.

What is GitHub Copilot?

GitHub Copilot is an AI tool developed by GitHub in collaboration with OpenAI. It is based on the OpenAI Codex model, which has been trained on publicly available source code datasets from GitHub repositories. Designed to interact directly with code as it is written, Copilot provides suggestions for code snippets, full functions, and even complex algorithms—tailored to the context of the project.

---

Key Features

1. Smart Autocomplete

Copilot suggests complete code snippets as you type, significantly reducing development time.

Example in C#:

// Developer comment: Method to fetch products from a database
public async Task> GetProductsAsync()
{
using var context = new AppDbContext();
return await context.Products.ToListAsync();
}

Copilot will analyze the intent and generate the appropriate code.

---

2. Code Generation from Descriptions

You can write comments in natural language, and Copilot will automatically generate the corresponding code—saving developers from having to write repetitive code.

Example:

// Generate a method that calculates the sum of two numbers

Copilot will generate:

public int Sum(int a, int b)
{
return a + b;
}

3. Refactoring and Optimization

It suggests improvements, analyzes your code, and provides refactorings and optimizations to make it more efficient and readable.

---

4. Support for Different Technologies

Besides .NET and C#, Copilot supports many programming languages, including Python, JavaScript, TypeScript, Ruby, Go, and more.

---

5. Contextual Learning & Repetitive Tasks

As you use Copilot, it adapts to your coding style, analyzes your existing code, and improves its suggestions. It also offers alternatives if it detects code that could be improved.

---

6. Code Explanation

Copilot can explain code line by line, making it easier to understand what it does and helping you learn the language.

Example:

/explain @”^[A-Za-z]{1,3}\d{1,4}$”

Copilot will generate:

The code snippet @”^[A-Za-z]{1,3}\d{1,4}$” is a regular expression (regex) pattern used to validate a specific string format, in this case, a license plate number. Let’s break it down:

^: Asserts position at the start of the string.

[A-Za-z]{1,3}: Matches 1 to 3 alphabetic characters. Square brackets [] define a character class including uppercase (A–Z) and lowercase (a–z) letters. The quantifier {1,3} means this part must occur at least once and up to three times.

\d{1,4}: After the letters, matches 1 to 4 digits. \d is a shorthand for any digit (same as [0–9]). {1,4} indicates it must occur between one and four times.

$: Asserts position at the end of the string. In short, this regex validates strings that start with 1 to 3 letters followed by 1 to 4 digits, with nothing else before or after—ideal for validating alphanumeric license plate formats.

---

7. Project Structuring

Copilot can help organize your code—create folders, organize classes and interfaces, and work with a well-structured project layout.

Example:

/new api

Copilot will generate:

8. Bug Detection and Fixing

One of Copilot’s most useful features is its ability to detect bugs and suggest more efficient and optimized fixes.

Example:

/fix var sortedValues = values.OrderByDescending((value, index) => value * weights[index]);

Copilot will generate:

var sortedValues = values
.Select((value, index) => new { Value = value, Weight = weights[index] })
.OrderByDescending(pair => pair.Value * pair.Weight)
.Select(pair => pair.Value)
.Take(2)
.ToArray();

9. Security and Testing

Even if your code is secure, Copilot can suggest security improvements. It can also generate unit and integration tests—saving time and effort.

Example:

/test Sum

Impact on Programming

GitHub Copilot is changing how programming is done in several ways:

• Improved productivity: By automating repetitive tasks and offering precise code suggestions, Copilot significantly increases developer productivity.
• Accelerated learning curve: Beginners benefit from Copilot’s suggestions to understand syntax, code patterns, and improve their knowledge of languages and algorithms.
• Error reduction: Copilot helps developers avoid common mistakes and ensures code consistency.
• Encouraging experimentation: With Copilot handling boilerplate code, developers can focus more on experimenting and exploring new ideas.

---

Ethical Considerations and Limitations

While GitHub Copilot offers many benefits, it’s essential to keep its limitations and ethical implications in mind:

• Code quality: Copilot’s suggestions aren’t always perfect—it might provide solutions that don’t fit your intended results. Developers should always review and test generated code.
• Copyright concerns: Since Copilot is trained on publicly available code, there are concerns about ownership. A paid enterprise version exists where Copilot doesn’t share or store code externally, helping maintain security and privacy.
• Over-reliance: Developers should avoid becoming too dependent on Copilot, as it may hinder the development of their own programming skills.

---

Conclusion

GitHub Copilot represents a significant advancement in AI-assisted programming. Its ability to generate contextually relevant code suggestions has the potential to transform how developers write software. However, it’s crucial to use Copilot responsibly and recognize its limitations. After all, AI lacks the intuition and experience that human developers bring to the table. Therefore, developers remain essential—and AI won’t be replacing us anytime soon.

💡 If you haven’t tried it yet, now is the perfect time to integrate GitHub Copilot into your workflow and boost your productivity! 🚀