What is Xray’s Test Repository?

The Test Repository in Xray for Jira allows software tests to be organized hierarchically within Jira projects, facilitating efficient management of both manual and automated tests.

The QA team can create folders and subfolders to organize their tests, aligning them either with the functional architecture of the software or with the test strategy defined by the team. This structure is intuitive, since it resembles the way files are organized in any operating system.

What does the Test Repository provide us?

At WATA Factory, we find several advantages in using the Test Repository to improve the organization and quality of our tests:

• Hierarchical structuring of tests: Organize tests into folders and subfolders, making it easier to navigate and locate specific cases. For example, test cases can be segmented by modules, functionalities, versions, or test types.
• Greater visibility and control: The hierarchical organization provides a clear overview of the status and location of each test within the project, improving process monitoring and traceability between requirements, test cases, and executions.
• Compatibility with Agile methodologies and Continuous Integration: Adapts to Agile and CI practices, enabling test management aligned with fast development cycles and continuous delivery.
• Improved collaboration: Functional and technical teams can work in parallel, quickly finding the tests relevant to their scope.
• Scalability: Ideal for large projects with hundreds or thousands of test cases.

Tips to optimize the use of Test Repository

• Design the hierarchy carefully: Plan the folder structure in advance, since each test can only belong to one folder.
• Complement it with Test Sets: While the Test Repository provides a hierarchical structure, Xray’s Test Sets can be used to group tests across projects or based on specific criteria, offering additional flexibility.

Test Repository as a bridge toward automation

Organizing the test suite with Test Repository also serves as a bridge between manual and automated testing.

The QA team can begin by defining manual test cases within the folders of the Test Repository, organizing them according to requirements or acceptance criteria defined in Jira tickets.

As QA executes manual tests through Test Executions, they can identify which ones are most suitable for automation (e.g., repetitive tests, regression tests, or high-risk tests).

At that point, once the candidates for automation have been identified, Xray allows linking automated results to existing Tests through integration with frameworks such as Cucumber, JUnit, or TestNG.

Once automated, the same manual Test can continue to be used to store evidence of execution, simply by marking it as an automated test through the Test Type, while maintaining the same Test Issue in Jira and ensuring traceability.

Test Repository at WATA Factory

At WATA Factory, we consider a tool like Xray’s Test Repository essential for our QA teams. It improves test management in software projects not only by providing order and clarity, but also by making our test suites more scalable and easing the transition toward automation.

The post Test Repository Organization. A Little Order Before Automation appeared first on WATA Factory.

In this series, we will take a deep dive into the world of page builders – their evolution, popular options available today, how to integrate them into your site, performance considerations, security implications, and much more. Whether you’re a WordPress beginner looking to understand page builders or an experienced user wanting to learn best practices, you’ll find useful information and analysis in this series. Stay tuned for future articles where we’ll compare top page builder plugins head-to-head and make recommendations based on different use cases. To kick things off, let’s start by looking at the history of page builders and how they came to be so popular.

Evolution of Page Builders: A Brief History

In the ever-evolving world of web development, the rise of page builders has undoubtedly been one of the most transformative changes. Their journey from simple drag-and-drop tools to sophisticated design and development platforms is a testament to the rapidly changing needs of both developers and end-users. Let’s take a moment to journey through the evolution of these tools.

The Pre-Page Builder Era (Pre-2010s)

Before the proliferation of page builders, creating a website, especially on WordPress, required a fair amount of coding knowledge. Themes were the primary means of customisation, and any significant design alterations often required diving deep into CSS, PHP, or JavaScript. This era was marked by:

• Static Themes: Websites largely relied on static themes that had limited customisation options.
• Manual Coding: For deeper customisations, developers had to manually edit theme files, which could be both time-consuming and error-prone.
• Limited User Accessibility: Non-technical users often found it challenging to make even minor modifications without a developer’s help.

The Birth of Drag-and-Drop (Early 2010s)

As WordPress grew in popularity, there was a clear demand for tools that allowed more straightforward website design customisation. The early 2010s saw the introduction of the first drag-and-drop page builders. These tools were revolutionary because:

• User-Friendly Design: They allowed users to visually design their web pages without writing a single line of code.
• Module-Based Building: Features like text blocks, images, and buttons could be dragged onto pages, making design a modular process.
• Rise of the Freelancer: With these tools, freelance designers and developers could produce high-quality sites faster than before.

Advanced Features and Flexibility (Mid-2010s to Early 2020s)

The success of the early page builders spurred innovation. Newer tools introduced advanced functionalities, including:

• Responsive Design Controls: As mobile browsing became dominant, page builders adapted by offering tools to design for various screen sizes.
• Pre-built Templates: Many builders started offering pre-made design templates, further speeding up the design process.
• Theme Builders: Beyond just pages, some tools began allowing users to design entire themes, including headers, footers, and archive pages.
• Integration Capabilities: Integration with other plugins, tools, and platforms became a selling point, further embedding page builders into the WordPress ecosystem.

The Modern Era (2020s and Beyond)

Today’s page builders are more than just design tools. They’re comprehensive platforms that cater to both developers and non-developers alike. The modern era is marked by:

• Developer-Friendly Features: Advanced customisation using custom code, hooks, and filters is now standard.
• AI and Automation: The latest page builders increasingly leverage artificial intelligence to assist in design, content generation, optimisation, and user experience enhancements.
• E-commerce Integration: With the continued growth of online shopping, many page builders now offer seamless integration with e-commerce platforms like WooCommerce.
• Global Design Settings: Modern builders allow for site-wide design changes, making brand consistency easier to achieve.
• Performance Optimisation: Advanced caching, lazy loading, and code optimisation features have become standard.
• Accessibility Compliance: Modern page builders now include built-in accessibility features to help create WCAG-compliant websites.

The Importance of Page Builders in Modern Web Development

The digital age has brought with it an insatiable demand for websites. From small businesses to global corporations, from bloggers to online educators, the need for a robust online presence is more pressing than ever. Amidst this backdrop, page builders have emerged as pivotal tools, playing an indispensable role in modern web development. Here, we delve into why these tools have become such crucial assets.

Democratising Web Design and Development

• Levelling the Playing Field: Page builders have made it possible for individuals without a coding background to create and manage professional-looking websites. This democratisation means that even small businesses or solo entrepreneurs can have an online presence comparable to larger entities.
• Facilitating Creativity: Without the constraints of coding, users can focus on the creative aspects of web design, experimenting with layouts, colours, and graphics until they achieve their desired look.

Speed and Efficiency

• Rapid Prototyping: With page builders, creating mock-ups or prototypes becomes a breeze. Developers and designers can quickly showcase different design ideas to clients or stakeholders, facilitating faster decision-making.
• Streamlined Workflows: The drag-and-drop interfaces of most page builders mean that creating a webpage is often as simple as selecting the desired elements and placing them appropriately. This efficiency can significantly cut down project timelines.

Cost-Effective Web Development

• Reduced Development Costs: The ease and speed with which websites can be created using page builders often translate to reduced development costs, especially for businesses that might otherwise have had to hire external agencies or developers.
• Maintenance Savings: Many page builders offer easy-to-use interfaces for updates and changes, reducing the need for ongoing developer intervention for minor site modifications.

Flexibility and Customisation

• Tailored User Experiences: Modern page builders come equipped with a multitude of modules, widgets, and design options. This vast array of choices allows for the creation of highly customised user experiences, tailored to specific audience needs or brand guidelines.
• Extensibility: Many page builders are designed to be extensible, meaning developers can add custom plugins or modules to further enhance functionality.

Integration with Modern Web Tools

• Seamless Integrations: Whether it’s e-commerce platforms, email marketing tools, social media feeds, or AI-powered chatbots, most page builders now offer seamless integrations, ensuring that websites can have all the features they need without compatibility issues.
• API Access: For more advanced integrations, many page builders provide API access, allowing developers to create custom connections with other software or platforms.

Responsiveness and Mobile Optimization

• Mobile-First Design: With the majority of web traffic now coming from mobile devices, having a mobile-optimised site is essential. Page builders typically offer advanced tools to ensure designs look and function perfectly across devices of all sizes.
• Performance Optimisation: Beyond just design, many page builders also offer comprehensive features to optimise website performance, ensuring fast load times and smooth user experiences across all devices.

Future-Ready Features

• AI-Powered Assistance: Many 2025 page builders now include AI assistants that can help with content creation, design suggestions, and even SEO optimisation.
• Advanced Analytics Integration: Built-in analytics and conversion tracking help users understand their website’s performance without additional plugins.

In summary, page builders are not just tools; they are catalysts that have transformed the landscape of web development. They’ve bridged the gap between coding expertise and design aspirations, ensuring that in the modern web era, anyone can carve out their niche in the digital space with elegance and efficiency.

In this first article, we covered the origins and growth of page builders in WordPress over the past decade and a half. We learned how they have evolved from simple drag-and-drop editors into robust, AI-enhanced tools for building complete WordPress sites. Now that we understand the landscape, we’re ready to dive into the details in our upcoming articles.

Follow our blog for new articles for this series!

The post Introduction to WordPress Page Builders in 2025 appeared first on WATA Factory.

On Thursday, we kicked things off with a buffet breakfast at the office. The table was full of croissants, pastries, and strong coffee. We sat together, laughed, talked – and slowly got into the right mindset.

Then Eliezer L. welcomed everyone, walked us through the agenda, and explained how the talks, workshops, and breaks would be structured. From the very start, it felt like an important day was ahead of us.

DevOps and Kubernetes with Laura

Next, the stage belonged to Laura Morillo-Velarde, Platform Engineer at Seedtag, Google Developer Expert in Cloud, and Google Cloud Certified Professional Cloud Architect. With over twelve years of experience in cloud environments, Laura joined our All Hands bringing the clarity and accessibility she is known for. From the very first minutes, we knew we were going to learn a lot from her.

Spread across several blocks, Laura turned every moment into an opportunity to learn. We started with the basics of DevOps, understanding how these principles foster collaboration, reduce errors, and give us more confidence in our daily work.

We then explored the so-called “7 Cs”: continuous integration, continuous delivery, continuous deployment, continuous testing, continuous monitoring, continuous feedback, andcontinuous improvement. These weren’t just buzzwords on a slide – with simple examples, Laura showed how each “C” connects to the next, creating a never-ending cycle that drives constant progress.

Laura explained everything in a clear, relatable way, avoiding unnecessary jargon and using examples that felt close to home. Even colleagues not working directly with these tools were able to follow along and see their value.

The morning flew by. After a quick coffee break, we jumped into Kubernetes.

We discovered how it helps us deploy applications in the cloud, scale them, and ensure they run reliably. We realized it’s much more than just a tool: it’s a way of working that makes us more efficient, optimizes resources, and guarantees stability.

For the lunch buffet, we enjoyed tortillas, empanadas, fuet, and other treats that vanished quickly. Between bites, conversations carried on in a more relaxed tone.

In the afternoon, Laura took us into the practical side. We looked at real-world examples of deployments, monitoring, and automation, and learned how crucial it is to keep configurations tidy and balance loads across applications.

We wrapped up the day with an open Q&A session. Even after hours of intense learning, curiosity and motivation filled the room. We asked questions, debated, and shared our own experiences – leaving with heads full of ideas and the sense of having made the most of the day.

Putting Concepts into Practice

Friday began with a relaxed Andalusian breakfast at a local mesón: fresh toast with Serrano ham, sliced tomatoes, olive oil, and coffee. A perfect start to recharge our energy.

Back at the office, it was time for the hands-on sessions with Pedro G.. If Thursday was about learning the concepts, Friday was about putting them into practice. In the first session, we deployed applications, checked configurations, worked with monitoring, and reviewed automation processes. Pedro guided us step by step, answered questions as they came, and adapted the flow to our needs.

After a short coffee break, we returned for the second and final practical session. This was the moment to consolidate everything we’d learned: we tested real cases, made mistakes, fixed them, and learned together. The best part was seeing how yesterday’s theory had become practice – with our own hands.

The farewell came almost unnoticed, leaving us with the feeling of having made the most of these two days. We took home not only valuable technical knowledge from Laura but also something just as important: the experience of learning together as a team.

In the end, this September 2025 All Hands was the perfect blend of learning and team spirit. Two days that not only boosted our confidence with Kubernetes but also gave us the joy of discovering new things side by side.

And yes – we’re already counting the days until the next All Hands.

The post All Hands September 2025: Learning Kubernetes at WATA Factory appeared first on WATA Factory.

This time, we’ll dive deep into the world of Kubernetes, continuing the exciting journey we began in our recent Ibérica Labs. Expect two days full of learning, hands-on experimentation, and plenty of moments to connect, share, and grow stronger as a team.

Day 1 – A full-day Kubernetes deep dive

Thursday kicks off with a warm welcome and a hearty breakfast — the perfect way to fuel up before a day packed with insights and discovery.

Our guest expert is Laura Morillo-Velarde, currently Platform Engineer at Seedtag. With more than 12 years of experience building scalable and reliable systems, Laura brings deep expertise in areas such as microservices, Kubernetes, web development, testing, and agile methodologies.

She’s also a Google Developer Expert in Cloud and a Google Cloud Certified Professional Cloud Architect, recognitions that highlight her solid track record and dedication to the craft.

Throughout the workshop, Laura will share practical strategies for designing scalable infrastructures for Rails, Node, Python, and multi-stack applications. The day will combine hands-on practice with strategic insights, helping us not only understand how to deploy and orchestrate applications in Kubernetes, but also why each decision matters.

To keep our energy high, we’ll break for coffee and reflections, and around midday we’ll come together for a team-building lunch, enjoying good food while reconnecting with colleagues.

By the end of the day, everyone will leave with actionable knowledge and practical skills ready to be applied to real projects.

Day 2 – Hands-on practice and collective growth

Friday starts with a classic Andalusian breakfast, fueling us for a day fully dedicated to practice and collaboration.

The focus will be on applying Thursday’s concepts: everyone will work at their own pace, but the real value will come from the team dynamic — troubleshooting together, sharing knowledge, and lifting each other up.

This collaborative approach turns individual progress into collective growth, reinforcing the bonds that make WATA Factory unique.

By the end of these two days, we’ll not only have leveled up our technical skills, but also strengthened the connections that drive our culture forward. This All Hands will leave us better prepared, more confident, and more united than ever.

Building on Ibérica Labs

In our last Ibérica Labs, we explored how Kubernetes and Bitbucket could enhance our CI/CD pipelines. Together, we deployed Bitbucket Runners in a Kubernetes cluster, automated integrations, orchestrated components, and experimented with Helm to manage preconfigured packages.

This All Hands picks up exactly where we left off — taking what we learned and pushing it further. It’s an opportunity to tackle more complex challenges, refine our workflows, and keep building on the spirit of exploration and collaboration that defines WATA Factory.

The post WATA Factory is getting ready for the September All Hands appeared first on WATA Factory.

At WATA Factory, we believe continuous learning isn’t just a nice-to-have — it’s essential for staying ahead in the ever-evolving world of web development.

Today, we start with a book that perfectly embodies this spirit: Mastering JavaScript: Advanced Techniques for Modern Web Development by Carlos Azaustre.

Key technical details

• Title: Mastering JavaScript: Advanced Techniques for Modern Web Development
• Author: Carlos Azaustre
• Publisher: Independently published
• Pages: 99 pages
• Language: Spanish
• Format: Physical copy available in our internal library

Book synopsis

Mastering JavaScript goes far beyond teaching syntax or quick fixes. Carlos Azaustre offers a comprehensive journey through the core of JavaScript, then masterfully connects these fundamentals to the architecture of today’s leading frameworks — React, Vue, Angular, and Svelte.
The book begins by strengthening vanilla JavaScript skills, an often underestimated but absolutely vital foundation. From there, it explores complex topics such as:

• Component-based design.
• Routing strategies.
• State management.
• Reactive programming.

What makes this book stand out is its blend of theory and practical application — concepts are brought to life with real code examples that prepare readers to build robust, scalable, and modern web applications.

Why do we love this book?

One of the main strengths of this book is how it manages to connect the fundamentals with the bigger picture. Many developers jump straight into frameworks, but without understanding the underlying principles, progress can be limited. Azaustre takes the time to reinforce the basics before guiding the reader into more advanced concepts, ensuring the knowledge is solid and applicable.

Here’s why this book deserves a spot on every developer’s desk:

• Foundational Strength: Reinforces vanilla JavaScript, the bedrock of all frameworks.
• Framework Mastery: Explains React, Vue, Angular, and Svelte from the inside out.
• Hands-On Learning: Code samples and exercises encourage active problem-solving.
• Clarity & Accessibility: Advanced concepts explained in a digestible way.
• Future-Ready Skills: Builds a deep understanding adaptable to new technologies.

By the end, readers don’t just “know” JavaScript — they think in JavaScript, a skill that translates into faster debugging, cleaner code, and better architectural decisions.

Who will benefit from reading this?

Whether you’re building your first dynamic web app or architecting large-scale front-end projects, Mastering JavaScript has something to offer:

• Front-end developers who want to go beyond basic framework usage.
• Junior developers seeking a strong, practical JavaScript foundation.
• Software engineers interested in scalable architecture.
• Tech enthusiasts curious about the inner workings of popular frameworks

About the author: Carlos Azaustre

Carlos Azaustre is an internationally recognised expert in JavaScript and front-end development, holding both Google Developer Expert (GDE) and Microsoft MVP titles. With over a decade of experience, he has a knack for turning complex code into clear, understandable lessons that stick.

Through talks, tutorials, and open-source projects, Carlos has built a strong community of developers worldwide. In Mastering JavaScript, he shares not just the “how” but the “why” behind modern JavaScript, helping developers write cleaner, smarter, and future-proof code.

WATA Factory’s commitment to growth through learning

At WATA Factory, learning isn’t a side project — it’s part of our DNA. Our internal library and initiatives like this monthly book series reflect our commitment to nurturing talent, sparking curiosity, and pushing our team to continuously expand their expertise.
We know real growth happens when curiosity meets the right resources. That’s why our library is not a dusty shelf, but a living, evolving space where every team member can discover new tools, sharpen skills, and find inspiration to elevate their craft.

Each month, we carefully select a title that can unlock new skills, challenge perspectives, and spark innovation. Books like Mastering JavaScript demonstrate how mastering fundamentals and understanding the “why” behind technology build a foundation for long-term success.

And here’s the best part: when our people grow, our clients benefit. Better-trained developers deliver cleaner code, stronger collaboration, and scalable, adaptable, future-proof solutions. That’s the WATA Factory way — investing in our team to deliver the very best.

Ready to explore?

Mastering JavaScript is now available in our internal library. We encourage all employees to grab a copy, dive deep, and discover how a stronger command of JavaScript can open new doors in modern web development.
Don’t forget to share your thoughts and insights with the team — because learning is always better together. Stay tuned for next month’s pick! And as always, feel free to suggest books or topics you’d like us to explore.

The post Mastering JavaScript with Carlos Azaustre: Our new monthly book series kicks off! appeared first on WATA Factory.

Introduction

At WATA Factory, we have been using Java quite extensively both in our clients’ projects as well as for internal projects. Despite (or maybe even because of) its already proud age of 25 years, Java is still widely used.

While there are generally better, non-java-based alternatives available for the frontend, such as Angular (using Typescript), React (using JavaScript) or Flutter (using Dart), Java is still often the best choice for backend development, and it is used extensively in projects of all kinds. For big, enterprise-level applications, it is still almost the industry standard.

Of course, we all stand on the shoulders of giants, and nobody would be so crazy as to try to develop an entire application from scratch. Instead, we use application frameworks. In Java, there are quite a few. Which one is best suited depends entirely on the project requirements:

• Jakarta EE (formerly Java EE) – Large-Scale enterprise apps
• Hibernate – a Java Object-Relationship-Mapping framework that works with JPA and simplifies working with databases
• Quarkus – Cloud and Microservices, very lightweight
• Spring framework – Probably the most popular, suited for Microservices, REST-Apps

In this article we will look at Spring, or, more precisely, Spring Boot. It is built on top of the Spring framework and has been designed to simplify the development of standalone, production-ready applications.

Why Spring Boot?

When starting to develop a new application from scratch, traditionally with Java EE or Spring (without the Boot) a lot of configuration and boiler plate code was necessary. Manage dependencies, make sure everything works together, and then there is still the topic of deploying the application on a suitable application server, which can be very complex. For a big enterprise application, such extensive configuration and fine-grained control might actually be needed, but for smaller projects, this seems like a lot of overhead.

This is where Spring Boot comes in. It was designed to simplify the development of standalone, production-ready Spring applications. It does so by removing the need for complex configuration, applying the principle of “Convention over Configuration”.

Convention over Configuration

This principle means that Spring Boot tries to provide sensible defaults for things that would in other cases have to be configured manually. For example, unless you configure it differently, Spring Boot already includes an embedded Tomcat server, no configuration at all needed.

It also auto-configures components based on default values and classpath dependencies, thus considerably reducing the boilerplate code one must write to get an application off the ground and start being productive.

The Spring Boot Initializr

Another feature of Spring Boot that helps to get started as fast as possible is the Spring Boot Initializr. This web-based tool allows configuring and generating an entire project and eliminates the need for manual setup and provides a ready-to-run project structure.

Creating a Demo Application

Let us now create a working Spring boot application using the initializr

Go to https://start.spring.io/

• Choose your project management. Since we are using Java, we will go with Maven (Gradle also works with Maven – in the end it is probably a question of personal taste. While Gradle is less verbose and arguably more powerful, Maven is “tried and tested” and offers a plugin for almost any situation imaginable)
• Choose the language. We will choose Java
• Select the Spring Boot Version. This defaults to the current stable version, which is usually the best choice.
• Enter your metadata: For this simple demo, we will go with the defaults
• Choose ‘Jar’ as your packaging. This means that the compiled application will be available as an executable jar.
• Finally, select the Java version. You should use the one that you have installed on your system

The most interesting part is on the right, hidden behind the button “Add Dependencies”. Clicking here lets you add all kinds of dependencies without having to dive into maven central and searching by yourself. Each one comes with a small description. The list includes developer tools, web-related dependencies, databases (both SQL and Non-SQL), cloud, security, templating for server-side rendering, messaging, testing, AI and more.

For our little demo we will select the following:

• Spring Web: Lets us create REST endpoints easily and provides the embedded Apache Tomcat as the default container
• Spring Boot DevTools: Offers some quality-of-life tools like live reload during development and faster startup
• Lombok: Saves writing a lot of boilerplate code for POJOs
• Spring Data JPA: Database connectivity
• H2 Database: Create a simple in-memory database for this project.

Now click on “generate” to download a Zip-file. Then unzip the file and just open it with the IDE of your choice. For this demo, we will use IntelliJ.

The initializr should have created the following files (there should be some other folders and files, but these are the important ones):

• demo/src/main/java/com/example/demo/DemoApplication.java:
  The main executable for the app. Execute this file to start the app.
• Demo/src/main/resources/application.properties:
  The main configuration file for the app. While this is a standard java properties file, you could also use YAML instead.
• pom.xml:
  All dependencies and build plugins are managed here.

Creating the First Endpoint

With the setup out of the way, we can now create our first endpoint. This one is going to be very basic and only displays text.

First, create new Java file in the same folder as DemoApplication.java and name it HelloWataController.java. Now add the following code:

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/hello")
public class HelloWataController {

    @GetMapping
    public String sayHello() {
        return "Hello WATA Factory!";
    }
}

And that is all! Now run the application by executing DemoApplication.java. You might have to execute the Maven clean and install jobs first.

Then open your browser and navigate to http://localhost:8080/hello. Unsurprisingly, you should see ”Hello WATA Factory!” displayed in your browser window.

Now, this endpoint is not very useful, but it serves to show with how few actual lines of code you can set up a working web application in Spring Boot.

Adding a Database

In the next step, we will add database support. That is why we added the H2 Database pack in the Initializr, after all. This database is only in-memory and will therefore be deleted after closing the application, but the setup process is the same for any kind of SQL-database. For this little demo we will read from a database of books.

First, we need to configure the DB connection in our application.properties file. Add the following lines to the file:

spring.application.name=demo

spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update

Defining the Entity class

Next, we will create our entity POJO class. Create a package called “book” below “com.example.demo”, and in that package create a new file called Book.java. Add the following code the newly created class:

@Entity
@Getter
@Setter
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String author;
}

This is our entity class that models the database entries for the ”book”-table, as denoted by the “@Entity” annotation.

The “@Getter” and “@Setter” annotations come from the Lombok package we added in the initializr and add getters and setters for the attributes at compile time, so that we do not need to add them manually.

The other two annotations define which of the attributes is the primary key for the entity, and how it is created.

In Spring Boot terms, the class that reads and writes entities from and to the database is called a repository. Therefore, we need to create a repository class for our Book-entity. Let’s call it “BookRepository.java” and put it right next to our entity class. It has only one line:

public interface BookRepository extends JpaRepository<Book, Long> { }

Defining the Service

In a classic three-tier-architecture, you normally do not access a repository directly from your endpoint. This is in order to isolate the different levels of the application from each other, which is generally good practice. Instead, you access the database through a service class.

Let’s create this class now, and call it, unsurprisingly, “BookService.java”. Here is the code for it:

@Service
public class BookService {
 
    @Autowired
    private BookRepository bookRepository;
 
    public List<Book> getAllBooks() {
        return bookRepository.findAll();
    }
 
    public Book getBookById(Long id) {
        return bookRepository.findById(id).orElse(null);
    }
 
    public void deleteBook(Long id) {
        bookRepository.deleteById(id);
    }
}

All in all, we have three methods, one for getting all books, one to find a book by id, and one to delete a book from the database. But wait a minute, we never implemented those methods we are calling here in our BookRepository.java! In fact, our repository class is only an empty one-liner interface!

This is another nice feature of Spring Boot, and another example of the “convention over configuration”-philosophy. These methods will “just work” out-of-the-box without the need to implement anything. There are a lot of possibilities to access a database without actually having to write SQL.

Defining the Controller

Now the only thing left for our application is to make these methods accessible to the outside world. We will do so by creating a controller class that exposes three REST endpoints, one for each method:

@RestController
@RequestMapping("/api/books")
public class BookController {
 
    @Autowired
    private BookService bookService;
 
    @GetMapping
    public List<Book> getAllBooks() {
        return bookService.getAllBooks();
    }
 
    @GetMapping("/{id}")
    public Book getBookById(@PathVariable Long id) {
        return bookService.getBookById(id);
    }
 
    @DeleteMapping("/{id}")
    public void deleteBook(@PathVariable Long id) {
        bookService.deleteBook(id);
    }
}

Adding Data to the Database

Start the application again. Since we are using an in-memory database, it gets deleted every time the application is shut down. Therefore, first, we must add some data that we can then query through our endpoints.

You can do so by opening your browser to http://localhost:8080/h2-console. Use the data defined in application.properties to access the in-memory database. This opens another screen where you can run some SQL commands to populate the database with some books. Here are some inserts that you can use:

INSERT INTO BOOK VALUES(1, 'George Orwell', '1984');
INSERT INTO BOOK VALUES(2, 'J.R.R. Tolkien', 'The Lord of the Rings');
INSERT INTO BOOK VALUES(3, 'Franz Kafka', 'Metamorphosis');

In case that you (like me) find it cumbersome to have to repeat this step every time you restart the application, you can simply save these inserts into a file called data.sql and place it in the src/main/resources directory. Also, in application.properties, you will have to change the line

spring.datasource.url=jdbc:h2:mem:testdb

To

spring.datasource.url=jdbc:h2:file:./data/demo

They will now get executed automatically every time the application starts.

 This is yet another good example of Spring Boot’s “Convention over Configuration” philosophy: You could, of course, configure a different filename and a different directory, but if you are content with these sensible defaults, it works right out of the box without having to hardly configure anything at all.

Testing the Application

Now that we have some data inserted into our database, we can test our endpoints. The easiest way to do this is by using a tool such as Postman, as it easily lets you try out the different http methods such as GET and DELETE. If you prefer the command line, curl might be your tool of choice.

Making a GET request to http://localhost:8080/api/books should yield the following response:

To only retrieve the book with id=2, call http://localhost:8080/api/books/2:

Let us now delete the book with id=2 from the database by making a DELETE request, and then again retrieving all books to make sure it is really gone:

All done! As we have tested, our endpoints work as expected.

Of course, this little example is merely a proof of concept. It lacks security, testing, and of course a front end.  

Conclusion

At WATA Factory, we have and are using Java for our backend in both internal and external projects. While it is often perceived as being more cumbersome and difficult to set up than, for example, Javascript-based alternatives like NodeJS, this article has shown with how few actual lines of code a working application server can be set up in order to start getting productive as fast as possible.

The post Using Spring Boot to set up a REST-application server appeared first on WATA Factory.

This is exactly where Stella Circle comes in. Based in Berlin, the platform offers precise, focused peer-level consulting for those who need to act and decide quickly.

But delivering this kind of value at scale takes more than just vision. It takes a digital product that’s fast, intuitive, secure — and profoundly human.

That’s where we at WATA Factory come in.

As Stella Circle’s long-standing technology partner, we’ve been supporting the platform from day one. In its current development phase, our mission was clear: Make the platform smarter, more scalable, and more helpful — without losing its soul.

Here’s how we approached it and what we believe it means for the future of digital consulting.

Reinventing the member experience

Digital platforms often struggle with relevance. They offer features — but no clarity. For Stella Circle, it was clear: the product must feel like a conversation, not a form. Thoughtful dialogue instead of administrative interaction.

That’s why we started by rethinking how members describe themselves and what they’re looking for. Leadership skills and management styles — once treated as separate categories — were merged into a cohesive framework: easier to complete, more effective to interpret.

But we didn’t stop at structure. We introduced contextual questions, allowing for a more intuitive and flexible self-positioning process. Instead of forcing users into predefined boxes, the platform now listens more intelligently.

We also rewrote and reorganised choice fields — the way real leaders think and speak. Because great UX is not just about usability — it’s about empathy.

The result: a smooth, smart, and human-centred onboarding process. Executives can now articulate their needs more clearly — and the system learns more meaningfully from them.

From static directory to strategic matchmaking

One of the most exciting developments was the transformation of the expert directory into a smart recommendation engine.

Stella Circle’s founders can now input the context of a leadership role — responsibilities, team dynamics, challenges — and instantly receive strategic matches from the member pool. These are not simple keyword matches, but intelligent recommendations based on leadership style, expertise, context, and fit.

To enable this, we developed a flexible matching algorithm tailored to the Stella Circle methodology. It doesn’t replace human judgment — it enhances it, factoring in members’ leadership styles, experience, and, most importantly, their individual aspirations.

We also designed an interface that presents these matches not as search results, but as strategic suggestions — always in tune with the intentions and preferences of the client.

The platform is evolving technically without sacrificing its human-centred approach.

New roles, clearer status labels

As Stella Circle grows, it requires targeted access control and responsible scaling.

We supported the implementation of a new user role designed to protect data privacy: team members can now access only the profiles they manage — not the entire platform.

Additionally, two new member statuses were introduced: Passive Membership and Terminated Membership. This gives the team more control over the user lifecycle, reduces noise, and enables sustainable community management.

These aren’t just administrative features — they’re part of the foundation of a trustworthy, scalable platform.

Little details, big trust

Alongside the major improvements, we also focused on subtle enhancements that foster trust and transparency:

• Legal documents like the privacy policy and legal notice are now available as professionally formatted PDFs — accessible anytime.
• During registration, pricing information is now separated by membership level, making the value of each option clearer to users.

These changes may seem small — but they follow a clear principle: clarity at every step builds lasting trust. Because users don’t just remember what a platform can do — they remember how it made them feel.

Why this matters: The next generation of digital consulting

The evolution of Stella Circle isn’t just a product story. It’s a glimpse into where consulting is heading: more agile, more digital, more personal.

At WATA Factory, we’re proud to help shape this future. Our work with Stella Circle shows what’s possible when you combine deep user insight, intelligent design, and scalable tech.

Whether you’re building a B2B marketplace, a premium membership platform, or a decision-support tool, the principles remain the same:

• Design for ways of thinking, not data structures.
• Build trust through clarity, not complexity.
• And never forget the human factor — even in the most sophisticated system.

We love building digital platforms that grow with their users — without losing what makes them meaningful.

Because when a platform is called Stella Circle, reaching for the stars is simply part of the plan.

Have a product with potential? Let’s turn it into something stellar.
From early vision to scalable reality — we’re here for the journey.
info@wata.es

The post How to evolve a premium digital consulting platform: the Stella Circle case study appeared first on WATA Factory.

While there aren’t any open positions right now, we’re always interested in getting to know people who share our values and mindset.

If you believe you’d be a great fit for WATA Factory, feel free to send us your CV using the form below. We’ll keep your details on file and reach out if a role becomes available that matches your profile.

Please note that we won’t reply immediately — we’ll only contact you if there’s a clear fit. In the meantime, thanks for thinking of us!

The post We’re not hiring at the moment, but we’d still love to hear from you appeared first on WATA Factory.

Closed for vacation. Open to enjoyment.

The sun is blazing, the waves are calling – and at WATA Factory, we’ve decided to answer that call. From July 28 to August 8, we’re taking a break to recharge, disconnect, and – why not – perfect the art of the siesta under a beach umbrella.

During this time, emails and calls will be on pause, patiently waiting for our return. But don’t worry: on August 11, we’ll be back, fully recharged and ready to dive back into the projects and solutions we’re passionate about.

Until then, enjoy summer the way it’s meant to be! See you after the break.

— The WATA Factory Team

The post WATA Factory is on vacation from July 28 to August 8 appeared first on WATA Factory.

That’s why we recently held the second edition of Ibérica Labs—a space for learning and collaboration where our teams explore, test, and apply new technologies and methodologies to keep raising the bar.

This time, we faced an unexpected twist: a sudden power outage forced us to move the entire session online at short notice. Instead of being a setback, it became proof that with motivation and teamwork, any challenge can be turned into an opportunity.

The focus of this edition was on two areas that are key to the future of digital development:

• Digital accessibility, ensuring our products are truly inclusive and usable by everyone, regardless of ability or limitation.
• Optimisation of continuous integration and deployment (CI/CD) processes with Kubernetes and Bitbucket Pipelines, enabling faster, higher-quality, and more scalable cloud deployments.

How we organised the labs: tailored learning for specialised teams

To make the most of everyone’s skills, we structured the labs into two learning paths:

1. Accessibility Lab
   Aimed at our QA, Design, and Project Lead teams. The goal was to build a deeper understanding of how to spot and remove accessibility barriers in digital applications. Beyond theory, we focused on concrete practices that directly improve the real user experience.
2. Kubernetes + Bitbucket Pipelines Lab
   Aimed at our developers. Here we concentrated on advanced automation and orchestration with Kubernetes. Using Bitbucket Pipelines, we deployed our own runners on K8s clusters and connected the infrastructure to optimise the entire CI/CD cycle.

Every session was designed to be practical, so the knowledge gained could be applied right away in WATA projects.

Deep dive into accessibility: responsibility and practice

One of the main themes was digital accessibility—a responsibility that doesn’t just lie with designers, testers, or project leads. Accessibility should never be a last-minute add-on, but an integral part of product creation from the start.

In the accessibility lab, our teams worked on:

• understanding how digital barriers exclude users with disabilities or specific needs,
• identifying accessibility issues early in design and development phases, not only via audits or automated tools,
• analysing our own products through practical cases to uncover actionable improvements,
• beginning to build a best practices guide to embed accessibility systematically across teams.

We also explored tools for automated accessibility testing—while always keeping in mind that empathy and human judgment are what turn rules into truly inclusive experiences.

Kubernetes and Bitbucket: building modern CI/CD processes

For our developers, the Kubernetes and Bitbucket lab was an in-depth look at core cloud technologies:

• Bitbucket Runners on Kubernetes: We learned how to set up and manage our own runners within K8s clusters, giving us independence from external services and the ability to scale resources on demand.
• CI/CD automation: We connected pipelines with Kubernetes orchestration so build, test, and deployment tasks run smoothly and automatically.
• Helm management: We used Helm to handle predefined packages, simplifying installations and updates while keeping infrastructure consistent and reproducible.
• End-to-end orchestration: We practised combining all these elements to build resilient, agile infrastructure that can grow with WATA’s projects.

This positions us at the cutting edge of cloud development best practices, with deployments that are reliable, fast, and scalable.

Continuous learning as a pillar of growth

At WATA Factory, training is not optional—it’s a cornerstone of our culture. Ibérica Labs are more than training sessions: they are opportunities to share knowledge, test new technologies, and strengthen cross-team collaboration.

By investing in continuous learning, we:

• adapt quickly to new trends and requirements,
• put concrete improvements into practice,
• build a motivated team with cutting-edge skills,
• and deliver innovative, inclusive, and scalable solutions to our clients.

Want to apply these approaches in your projects?

If you want to make your digital products more accessible and inclusive, or if you’re looking to optimise your CI/CD processes with Kubernetes and Bitbucket Pipelines, our experts at WATA Factory are here to help.

We offer:

• Accessibility audits that identify barriers and propose practical solutions,
• Consulting and tailored training for your teams in cloud technologies and CI/CD,
• Implementation and support for secure, scalable, automated deployments,
• and clear, actionable reports to guide efficient decisions.

Get in touch with us today to see how we can turn your developments into high-impact technological solutions—with the quality, inclusivity, and efficiency your users deserve.

The post This is how we experienced our latest Ibérica Labs: accessibility and Kubernetes, two challenges tackled through practice appeared first on WATA Factory.