AI agents are being shipped to production faster than most integration layers were designed to handle. When workflows start breaking, it is usually not the model that is causing the trouble. It is authentication edge cases, permission boundaries, API limits, or long-running automations that quietly fail.

Platforms like Workato still appear early in evaluations, but teams are increasingly testing alternatives as systems become more API-driven and agent-initiated. By 2026, integrations are expected to behave like core infrastructure rather than background tooling.

This article looks at six Workato alternatives teams are actively using in 2026. The focus is on how these platforms behave in real environments, what they support well, and where trade-offs arise as workflows move beyond simple automations.

Before diving deeper, here is a quick TL;DR of the platforms worth considering.

TL;DR

If you want the quick takeaway, these are the Workato alternatives teams are actively evaluating in 2026 👇

• Composio: Designed for AI agents running in production, with a large tool ecosystem, runtime execution, on-prem deployment, and MCP-native support.
• Tray.ai: A good fit for complex, predefined enterprise workflows that need deep API orchestration.
• Zapier: Optimized for quick, lightweight automations across common SaaS tools.
• Make.com: Best for visually modeling complex, predefined workflows with branching, loops, and data transformation, especially for ops and business teams.
• n8n: Ideal for teams that want full control through open-source, self-hosted automation with custom logic and deep API access.

Why a Workato Alternative Makes Sense in 2026

Integration platforms now sit directly on the execution path of modern systems. AI agents trigger actions across SaaS tools, internal services, and customer-facing workflows. Under real usage, issues around authentication, permissions, API limits, and long-running processes surface quickly.

This reality has pushed teams to look more closely at how integration tools behave beyond initial setup. Attention has shifted toward failure handling, state management, and visibility once workflows are live. These factors often determine whether a platform supports production workloads or becomes a source of operational friction.

In 2026, expectations are clear. Teams evaluating alternatives in the Workato category prioritize predictable behavior, operational control, and safe execution for agent-initiated actions over surface-level features or polished builders.

Here are the six Workato alternatives teams are actively using in 2026, along with where each one tends to fit best.

Comparison Table

Workato Alternatives Explained

1. Composio

Composio is a developer-first platform that connects AI agents with 500+ apps, APIs, and workflows. It is built for teams deploying agents into real production environments, where integrations need to behave predictably and survive ongoing API changes rather than just work in controlled demos.

The platform is structured around agent-initiated actions instead of static automation flows. Common integration pain points, such as authentication, permission scoping, retries, and rate limits, are managed centrally, reducing the operational overhead that typically slows teams down as systems scale.

Composio emphasizes consistency and control at the execution layer. Tools are exposed with clear schemas and stable behavior, helping agents remain reliable across long-running workflows and high-volume use cases without constant manual intervention.

Features

• 500+ agent-ready integrations across SaaS and internal systems
• Centralized handling of OAuth, token refresh, retries, and API limits
• Native Model Context Protocol support with managed servers
• Python and TypeScript SDKs with CLI tooling
• Works with major agent frameworks and LLM providers
• Execution visibility and control for agent-triggered actions

Why is Composio a strong Workato alternative

Composio is designed for agent-driven execution where actions are selected at runtime rather than defined as static workflows. This model fits modern AI systems that need to interact with many external tools while maintaining consistent behavior around permissions, retries, and API limits.

By centralizing integration logic and exposing tools through stable, structured interfaces, Composio reduces operational overhead as systems scale. Teams can focus on agent behavior and decision-making while the platform handles execution details reliably across production environments.

Best for

Teams building AI agents that must operate across multiple services in production, especially when reliability and developer control matter more than visual workflow builders.

Benefits

• Faster production readiness for agent-based systems
• Reduced integration maintenance and breakage
• More predictable behavior under real-world load
• Cleaner separation between agent logic and tooling
• Better handling of auth and API edge cases

2. Tray (Tray.ai)

Tray.ai is built for teams that need to orchestrate complex, API-heavy workflows across large SaaS environments. It is commonly used when automations span many systems and require detailed control over branching, transformations, and execution flow.

The platform is optimized for structured automation rather than agent-native execution. Workflows are typically defined upfront and refined over time, which works well for predictable processes but can introduce friction for highly dynamic, agent-driven use cases.

Features

• Visual workflow builder with advanced branching and conditional logic
• Deep API connectors with support for custom requests
• Data mapping and transformation across steps
• Built-in retries, error handling, and execution controls
• Enterprise governance, access control, and security features

Why Tray is a viable alternative

Tray offers significantly more flexibility than basic iPaaS tools as workflows become more complex. Its strength lies in handling detailed API interactions and multi-step orchestration without requiring teams to build and maintain custom infrastructure.

Pros

• Strong support for complex and long-running workflows
• Fine-grained control over logic and execution
• Well-suited for enterprise-scale automation
• Reduces reliance on custom orchestration code

Cons

• Less suited for highly dynamic or agent-driven execution
• Setup and maintenance can be heavier than simpler tools
• Visual workflows can become hard to manage at a large scale

3. Zapier

Zapier is widely used for connecting everyday SaaS tools through simple, event-driven automations. It is optimized for speed and accessibility, allowing teams to set up workflows quickly without needing deep technical knowledge or custom infrastructure.

The platform works best when workflows are short, predictable, and built around common triggers and actions. While it has added more advanced features over time, its core strength remains ease of use rather than handling complex or highly dynamic execution patterns.

Features

• Thousands of prebuilt app integrations
• Trigger-and-action-based workflow builder
• Basic branching and filtering logic
• Built-in scheduling and webhook support
• Fast setup with minimal configuration

Why Zapier is a viable alternative

Zapier lowers the barrier to automation and remains a practical choice for teams that need to move quickly. For straightforward integrations and internal workflows, it often delivers results faster than heavier iPaaS platforms.

Pros

• Extremely easy to use and quick to deploy
• Broad integration coverage across SaaS tools
• Minimal operational overhead
• Accessible to non-technical teams

Cons

• Limited support for complex or long-running workflows
• Not well suited for agent-driven or API-heavy execution
• Can become expensive at scale
• Limited control over execution details

4. n8n

n8n is an open-source, developer-friendly automation platform that gives teams full control over how workflows are built, executed, and hosted. Unlike fully managed iPaaS tools, n8n can be self-hosted, making it attractive for teams that want ownership over infrastructure, data, and execution behavior.

n8n workflows are built using a node-based visual editor, but the platform is fundamentally code-capable. Teams can inject custom JavaScript logic, call arbitrary APIs, and design workflows that closely mirror real system behavior. This makes n8n flexible enough for non-standard integrations while still offering a visual layer for orchestration.

While n8n is increasingly used alongside AI systems, it is not agent-native by default. Agent-driven execution, retries, permission control, and long-running reliability must be explicitly designed and maintained by the team.

Features

• Open-source core with optional managed hosting
• Visual node-based workflow builder
• Custom code steps with full JavaScript support
• Native HTTP, webhook, and API integration nodes
• Self-hosting support for security and compliance needs
• Extensible via custom nodes and plugins

Why n8n is a viable alternative

n8n appeals to teams that want flexibility without vendor lock-in. By owning the execution environment, teams can tailor workflows to exact requirements, integrate deeply with internal systems, and adapt quickly as APIs or business logic change.

For organizations with engineering resources, n8n provides a powerful foundation for building bespoke automation layers that align closely with internal architecture.

Pros

• Full control over execution and infrastructure
• Open-source and highly extensible
• Strong fit for custom and internal integrations
• Suitable for self-hosted and regulated environments

Cons

• Operational responsibility sits with the team
• Requires engineering effort to maintain reliability
• Not designed for agent-native, runtime action selection
• Auth handling, retries, and governance must be built manually

5. Make.com

Make.com focuses on visual workflow orchestration for teams that need more flexibility than basic trigger-action tools, without moving fully into code-first systems. Workflows, called scenarios, are built using a drag-and-drop interface that supports branching, looping, data transformation, and conditional logic.

Make.com sits between lightweight automation tools and enterprise iPaaS platforms. It is often evaluated when teams want to model moderately complex processes across SaaS tools, internal systems, and APIs, while keeping workflows understandable to non-engineers.

The platform assumes workflows are largely defined upfront. While it supports HTTP modules and custom API calls, execution remains scenario-driven rather than agent-selected at runtime.

Features

• Visual, drag-and-drop scenario builder with branching and loops
• Broad SaaS integration library with custom HTTP/API modules
• Data mapping, filtering, and transformation tools
• Scheduling, webhooks, and event-based triggers
• Execution history and basic error handling controls

Why Make.com is a viable alternative

Make.com offers significantly more control than simple automation tools while remaining accessible to operations and business teams. It allows complex logic to be expressed visually, which makes it easier to reason about workflows that span multiple systems without introducing full custom infrastructure.

For teams that want flexibility but still value visual clarity and faster iteration, Make.com can serve as a practical middle layer between no-code tools and developer-heavy platforms.

Pros

• Strong visual modeling for complex workflows
• More flexible logic than basic trigger-action tools
• Good balance between power and usability
• Suitable for cross-functional teams

Cons

• Workflows must be largely predefined
• Not designed for dynamic, agent-initiated execution
• Limited control over deep API governance and permission boundaries
• Debugging becomes harder as scenarios grow large and interconnected

Comparison Table

• ✅ Native and well-supported
• ⚠️ Possible but not core
• ❌ Not a primary focus

Which One Should You Choose?

The right platform depends on what your system needs to optimize for. A practical way to think about the decision in 2026 is to map it to how your workflows actually behave.

• Speed to production: Choose an agent-first platform with deep tool coverage, native agent protocol support, and solid SDKs.
• Governance and compliance: Prioritize platforms that offer audit logs, policy controls, role-based access, and strong security guarantees.
• Permission control: Look for fine-grained scopes, runtime authorization, and safe handling of agent-initiated actions.
• Embedded integrations: Pick a platform designed for in-app, customer-facing integration flows with customizable UX.
• Rapid experimentation: Visual builders and fast setup help validate workflows quickly.
• Long-term control: Developer-centric or API-first platforms tend to scale better as systems become more complex.

A common pattern is to start with tools optimized for speed and iteration, then move to an agent-focused integration layer once workflows become production-critical.

Closing

Choosing an integration platform in 2026 comes down to how well it supports real execution, not how polished it looks in setup. As AI agents take on more responsibility inside products and internal systems, integrations need to behave predictably under load, handle edge cases cleanly, and surface failures clearly.

Each platform covered here optimizes for a different set of constraints. Composio focuses on agent-driven execution; Tray and Zapier support structured automation at different levels of complexity. Make.com excels at visually modeling complex, predefined workflows, and n8n appeals to teams that want open-source flexibility and infrastructure ownership. The right choice depends less on feature breadth and more on how closely a platform matches the way your systems actually operate in production.

Teams that evaluate these tools through the lens of reliability, control, and long-term maintenance tend to make better decisions than those optimizing for speed alone. In 2026, integration layers are no longer optional infrastructure. They are part of how systems execute.

February is a strange little month. Short, quiet, and typically uneventful. There are fewer distractions and fewer launches, which makes it the ideal time to slow down and take a look at what is actually driving the tech world at the moment.

This issue leans into that calm, with Trisha Gee joining us as our featured content guest and sharing her thoughts and observations on the latest Java news and how it’s shaping developers’ lives. We explore where Java is heading next, what running on the latest LTS really means, and how the platform keeps improving without chasing hype. Add in some practical tutorials, Kotlin updates, AI gradually becoming capable of more and more everyday development tasks, and a few thoughtful takes along the way, and you have a February read that is relaxed in tone, but rich in ideas. 

Let’s go! 

Featured Content

Trisha Gee

Trisha Gee is a Java Champion, author, and internationally recognized speaker with over two decades of experience in software development. Known for her deep expertise in Java, high-performance systems, and developer productivity, Trisha has worked as a developer and leader in organizations ranging from startups to global enterprises. She’s passionate about sharing knowledge and helping developers write more expressive and efficient code.

Trisha is the author of multiple technical books, including Head First Java (3rd Edition) and Getting to Know IntelliJ IDEA, and she frequently contributes to developer communities through blogs, webinars, and international conferences. She’s also a strong advocate for grassroots learning and regularly supports local user groups and meetups to help developers connect, grow, and thrive. When she’s not writing or coding, she’s championing inclusive practices and mentoring the next generation of developers.

Happy February, dear readers of Java Annotated Monthly! For those of us in the northern hemisphere, the words “Happy” and “February” do not usually go together. However, I do see the upside of the dark months of January and February, mostly in that things are fairly quiet, travel (for me) is usually limited, and it’s a time to take stock of how you want the rest of the year to go.

So let’s look at Java (weird, for a Java newsletter). We now know the list of features coming in Java 26. Java 25, the current version, is the latest LTS, so although you may not be ready to look at Java 26 yet, you should be running on Java 25. It’s incredible to me that Java is still evolving after all these years, and in elegant and useful ways. In Data-Oriented Programming for Java: Beyond Records, Brian Goetz talks about how data can best be represented in Java, and specifically what carrier classes are. I’m always fascinated by how the language evolves and how the engineers decide which features to add or update (like records or carrier classes). If you are too, you should watch this interview with Georges Saab. He also talks about the value of learning (I learned fairly recently that “Hello World” in Java is much simpler to write thanks to new language features). Watch Marit demonstrate them in IntelliJ IDEA. And if you are keen to expand your IntelliJ IDEA/JetBrains IDE knowledge to expert level, maybe you’ll be interested in JetBrains’ Productivity With IntelliJ IDEA full-day workshop, which is led by me!

I mentioned travel earlier in this piece – sadly I will not be going to JavaOne this year, which is super disappointing. JavaOne is where I got started with presenting at conferences, and it’s a place where I always meet interesting people, whether they are speakers, engineers working on Java itself, Java Champions, Java User Group leaders, or attendees there to learn something new. Tickets are still available, so I recommend taking a look.

That’s all from me! Remember, February is short, and it’ll be spring soon.

Java News

Fresh releases, future plans, and the inside story from the Java team. If you want to know where Java is heading and why it matters, start here:

• Java News Roundup 1, 2, 3, 4
• JavaOne Sessions and Keynotes!
• JEP 525 Brings Timeout Handling and Joiner Refinements to Java’s Structured Concurrency
• Java’s Plans for 2026 – Inside Java Newscast #104
• Carrier Classes; Beyond Records – Inside Java Newscast #105
• Java 26: what’s new?

Java Tutorials and Tips

Enjoy deep dives, advice on practical fixes, and “wait, that’s possible now?” moments: 

• Java Warmup and the Scaling Loop Problem
• Pointer Arithmetic in Modern Java
• 1B Rows with the Memory API – JEP Cafe #25
• Command completion: IntelliJ IDEA with less shortcuts
• Moving Applications From JDK 21 to JDK 25: What You Need to Know”
• Hello 2026: From a Java Dev Who Coded (and Caffeinated) Too Much in 2025 
• Virtual Thread States 
• Your Programs Are Not Single-Threaded
• Enterprise Java in Practice: Fragmentation, Platforms and Real-World Trade-offs
• How a 40-Line Fix Eliminated a 400x Performance Gap
• Functional Optics for Modern Java – Part 1
• Run Into the New Year with Java’s Ahead-of-Time Cache Optimizations
• Bootstrapping a Java File System
• Episode 44 “Java, Collections & Generics, BeJUG”
• The Java Time Bug That Still Lives in Production

Kotlin Corner

Kotlin continues to mature without losing its edge. This section covers new releases, tooling improvements, and guidance that helps teams avoid common traps.

• How to Avoid Common Pitfalls With JPA and Kotlin
• The Journey to Compose Hot Reload 1.0.0 | The Kotlin Blog
• All the New Features in Kotlin 2.3 
• Ktor 3.4.0 Is Now Available! 
• Exposed 1.0 Is Out! 
• The Journey to Compose Hot Reload 1.0.0 
• Building AI Agents in Kotlin – Part 4: Delegation and Sub-Agents 
• Update your Kotlin projects for Android Gradle Plugin 9.0 

AI 

AI is moving from experiments to everyday development work. These articles explore agents, frameworks, and patterns with a clear eye on production reality:

• Article: Agentic Terminal – How Your Terminal Comes Alive with CLI Agents
• Dev Guide: How to choose your LLM without ruining your Java code (2026 Edition)
• AI-Driven Development with Olivia McVicker
• AI Assisted Development: Real World Patterns, Pitfalls, and Production Readiness
• Bring AI into your Jakarta EE apps with LangChain4J-CDI
• Building Effective Agents with Spring AI (Part 1)
• Spring AI Agentic Patterns (Part 1): Agent Skills – Modular, Reusable Capabilities 
• Spring AI Agentic Patterns (Part 2): AskUserQuestionTool – Agents That Clarify Before Acting 
• My first two months using AI 
• Spring AI Agentic Patterns (Part 3): Why Your AI Agent Forgets Tasks (And How to Fix It) 
• Codex Is Now Integrated Into JetBrains IDEs

Languages, Frameworks, Libraries, and Technologies

From Spring and Quarkus to testing and garbage collection, this section is about trade-offs. It highlights tools and approaches that stand up to real workloads and real teams:

• This Week in Spring 1, 2, 3, 4
• From Detection to Remediation: Wiz in Your JetBrains IDE
• Quarkus: A Runtime and Framework for Cloud-Native Java
• Optimizing Java for the Cloud-Native Era with Quarkus
• Avoiding Fake Drift in Unit Tests 
• A Bootiful Podcast: Spring Security lead Rob Winchon Spring Security 7
• Flaky Tests: a journey to beat them all
• A Better Way of Creating Dev Services
• A Bootiful Podcast: Jonatan Ivanov on how to measure all the things with Micrometer
• Towards faster builds
• The Ultimate 10 Years Java Garbage Collection Guide (2016–2026) – Choosing the Right GC for Every Workload
• The Marco Show: Are Integrated Tests a Scam? TDD, Architecture, Fast Feedback – J. B. Rainsberger | The Marco Show
• Spring Boot 4 + jSpecify : Say Goodbye to NullPointerExceptions
• All You Want to Know About Spring API Versioning
• Marco Behler on a Bootiful Podcast
• I’m changing my mind about serverless 

Conferences and Events

Check out the events that offer chances to meet the community, hear new ideas, and recharge your enthusiasm for building software: 

• Jfokus – Stockholm, Sweden, February 2–4
• Voxxed Days Ticino – Lugano, Switzerland, February 6; Marit van Dijk and Anton Arhipov will present their topics. Join the session to listen and meet them in person.
• Voxxed Days CERN – Meyrin, Switzerland, February 10; Marit van Dijk will talk about how to increase your productivity in IntelliJ IDEA.
• ConFoo Montreal – Montreal, Canada, February 25–27
• IntelliJ IDEA Conf – Online, March 26-27 – Registration is open!

Culture and Community

Technical skill grows faster when paired with reflection. Here you will find stories about leadership, learning, and the people behind the code: 

• Dimitry Jemerov on IntelliJ @ 25, Kotlin, and so much more
• Why is my Talk selected? Reflections from a Program Committee Reviewer
• Taking the Technical Leadership Path
• Culture Through Tension: Leading Interdisciplinary Teams with Nick Gillian
• The Beginner’s Guide to Deliberate Practice
• 8 Logical Fallacies That Mess Us All Up 
• Marit van Dijk and Anton Arhipov: 25 Years of IntelliJ IDEA

And Finally…

Here are the most interesting articles for the past month from the IntelliJ IDEA blog: 

• IntelliJ IDEA Conf 2026: Learn From the People Building the JVM Ecosystem
• Spring Boot Debugging – Now Remote
• Spring Data JDBC Made Easy with IntelliJ IDEA
• How to Avoid Common Pitfalls With JPA and Kotlin

That’s it for today! We’re always collecting ideas for the next Java Annotated Monthly – send us your suggestions via email or X by February 20. Don’t forget to check out our archive of past JAM issues for any articles you might have missed!

Recently, news from Postman has caused quite a stir in the developer community. According to their official blog and emails sent to users, Postman’s pricing and product plans are undergoing a major overhaul effective March 1, 2026.

The most critical change is to the Free plan, which currently supports team collaboration. It will be adjusted to single-user only. This means that if your team relies on the free version of Postman for collaborative API development and testing, you will soon be forced to upgrade to a paid Team plan.

For many small teams with limited budgets, open-source contributors, and learners, this is an issue that cannot be ignored. When a familiar tool no longer offers free collaboration, finding a suitable alternative becomes urgent.

What Do the Changes to Postman Mean?

Before discussing alternatives, it’s necessary to clearly understand the specific impact of Postman’s adjustments. This change isn’t just a simple feature reduction; it’s a strategic shift in product positioning that directly affects how free users operate.

Core Restrictions of the Free Plan

According to Postman, starting March 1, 2026, the new Free plan will be strictly limited to a single user.

This means the workflow of inviting multiple members to a Workspace, sharing API Collections, and synchronizing development progress—features we’ve taken for granted—will no longer exist in the free version. Any scenario requiring collaboration between two or more people will require migration to a paid plan.

For users accustomed to collaborating within Postman, this presents a direct challenge. Either the entire team pays for collaboration features, or you regress to a primitive state where everyone manages APIs locally on their own machines—a move that undoubtedly kills development efficiency and consistency.

Why You Need an Alternative

Postman’s new plans introduce many powerful features, such as native AI capabilities, deeper integration with Git workflows, and a brand-new API Catalog. These are indeed attractive for large enterprises or teams pursuing extreme efficiency.

However, for many developers and smaller teams, the most basic and core requirement is simply stable and free team collaboration. When this fundamental need becomes a paid feature, cost becomes an unavoidable factor.

Therefore, finding a tool that satisfies core functions like API design, debugging, and testing, while also providing complete team collaboration capabilities on a free tier, is the most practical choice.

Enter Apidog, an all-in-one API collaboration platform that combines API design, development, and testing. With its robust free team collaboration capabilities, it has become a top contender for developers looking to migrate.

Try it

Why Choose Apidog?

Among the myriad of API tools available, Apidog has a very clear positioning: an all-in-one API platform built for team collaboration. It is not just an API request tool; it spans the entire API lifecycle from design and documentation to development, testing, and release.

Most importantly, Apidog’s core team collaboration features are generous for free users, making it the ideal choice to counter Postman’s policy changes.

Here is a simple comparison to visualize Apidog’s advantages in team collaboration:

As shown in the table, while Postman’s free version retreats to being a personal tool, Apidog continues to champion team collaboration as a core value. It doesn’t just solve the problem of “can we collaborate?”; it offers richer functionality in the depth and breadth of that collaboration.

Migrating from Postman to Apidog

Moving from a familiar tool to a new one often brings anxiety about data loss and learning curves. Fortunately, Apidog provides a seamless Postman data import feature, making the entire migration process smooth and painless.

The process consists of two main steps: exporting data from Postman and importing it into Apidog.

1. Exporting Postman Data

In Postman, your core assets are usually Collections and Environments.

A Collection is a set of all your saved API requests, including URLs, methods, headers, bodies, etc. An Environment stores variables for different contexts, such as API_HOST for development versus production.

First, you need to export this data to files.

1. Open the Postman client and find the Collection you want to export in the left navigation bar.

1. Click the three dots (...) icon next to the Collection and select Export.

2. In the popup window, choose the recommended Collection v2.1 format and save the JSON file to your local machine.

Next, export your environments in the same way. Click the Environments tab on the left, find the environment you need, click the three dots (...), select Export, and save it as a JSON file.

2. Importing Data into Apidog

Once you have your JSON files, you can import them into Apidog.

1. Open Apidog and enter your project.

2. Click “Settings” (usually a gear icon) in the left sidebar.

3. Select “Import Data” and choose the “Postman” option.

Apidog will present an upload interface. You can drag and drop your exported Collection and Environment JSON files directly into the upload area. Apidog supports uploading multiple files at once and will automatically recognize and process them.

After uploading, Apidog parses the file content, seamlessly converting Postman requests, directory structures, and environment variables into Apidog’s interfaces and environments. Once the import is successful, you’ll see all your familiar API requests ready to go in the Apidog interface.

Start Collaborating in Apidog

With data migration complete, you can now truly experience the collaborative benefits of Apidog.

Invite Team Members

The first step in collaboration is building your team. In Apidog, inviting colleagues is straightforward.

1. Click on “Settings” or “Members/Permissions” in your project or team dashboard.

2. Invite new members via a shareable link or email invitation.

Unlike Postman’s upcoming single-user limit, Apidog allows you to add up to 4 team members for free. It also offers a flexible permission management system, allowing you to assign different roles (Admin, Editor, Read-only, etc.) to ensure project data security.

Experience the All-in-One Workflow

Apidog’s strength lies in its “All-in-One” design philosophy. It’s not just a Postman replacement; it’s a platform that covers the full API lifecycle.

• Design First: Collaboration often starts with API design. You can define paths, parameters, request bodies, and response structures visually directly on the platform.

• Auto-Generated Docs: Once the API is designed, professional and beautiful API documentation is generated automatically. You can share this online with frontend colleagues or third-party partners, who can view and debug directly in their browser without installing software.

• Smart Mocks: For frontend developers, Apidog’s Mock function is a game-changer. Based on your API design, Apidog automatically generates realistic Mock data. This means frontend work doesn’t need to wait for the backend interface to be finished—you can develop and integrate based on Mock data immediately, significantly boosting parallel development efficiency.

• Automated Testing: When the backend interface is ready, team members can perform debugging and automated testing within Apidog. You can combine multiple requests into a test case, set assertions to verify results, and run all tests with one click to generate detailed reports.

Conclusion

Facing Postman’s free tier adjustments, there’s no need to panic. The tech ecosystem is constantly evolving. While Postman’s choice is part of their business strategy, for the vast majority of developers and teams, this is an opportunity to discover and embrace tools like Apidog—tools designed for modern team collaboration that are more integrated, efficient, and generous with their free tiers.

If you have ever tested a location feature in New York City, you know the moment.
Your pin looks fine in Brooklyn. Your ETA is steady on a wide avenue. Then you get into Midtown, or you duck into the subway, and suddenly the map jumps across blocks, the user “teleports,” and support tickets start sounding personal.
NYC is a stress test for anything location-based. It is also a great forcing function. If you can make your location UX feel reliable here, it will usually feel solid everywhere else.
This is a practical playbook for building location features that do not fall apart in NYC, with an emphasis on product behavior, offline strategy, map matching, and the unglamorous stuff that actually ships.

Why NYC breaks “normal” location features

NYC has three recurring failure modes:

Subway dead zones

Connectivity drops, then returns in bursts.
Apps that assume a constant stream of updates will show stale data or thrash.

Urban canyon GPS drift

Tall buildings cause multipath and bad fixes.
You get jittery pins, sudden direction flips, and “wrong side of the street” issues that wreck pickup and routing.

Background reality

OS background limits mean “real-time” is a budget, not a promise.
If you oversample, you burn battery and get killed by the OS.
The fix is not “get better GPS.” The fix is designing the system so the user experience stays believable when the data gets messy.

Start with the product goal: reliable UX, not perfect accuracy

Before you touch code, decide what “good enough” means for each feature:
ETA can tolerate small drift if it updates predictably.
Nearby results need stability more than precision (nobody wants results reshuffling every second).
Geofences need clear thresholds and debouncing.
Pickup / meet point needs the highest confidence and the most conservative rules.
A simple approach that works well:
Define an acceptable error band per feature (example: 30m for “nearby,” 10m for “pickup,” 100m for “city-level”).
If the location fix is outside the band, do not pretend. Show a degraded experience (more on that below).

Build a location confidence score (and gate your UI with it)

Raw latitude and longitude are not enough. You need a quality signal that you can use to decide what to show.
At minimum, track:
accuracy (meters)
speed
heading
provider / source (when available)
timestamp
Then compute a basic confidence level.
Here is a lightweight pattern that keeps you honest:
if accuracy_m <= 10 and age_s <= 5:
confidence = “high”
elif accuracy_m <= 30 and age_s <= 15:
confidence = “medium”
else:
confidence = “low”

Now you can make product decisions that feel human:
High: show precise pin, enable “confirm pickup,” update ETA normally.
Medium: show pin but reduce animation, avoid snapping hard, keep UI stable.
Low: show “last known” state, widen search radius, pause certain actions, ask for confirmation.
This is the single biggest shift. It stops your app from acting overconfident.

Surviving subway dead zones: offline-first, outbox, and “stale but honest” UI

When the network drops, the system should not panic. It should behave predictably.

Use an outbox pattern for events

If you have location events, pings, check-ins, or status updates, store them locally first, then sync when possible.
onLocationEvent(e):
saveToOutbox(e)
trySync()

trySync():
if networkAvailable:
sendBatch(outbox)
markSentOnSuccess()

Key details:
Batch sends when reconnecting (avoid a flood).
Make sends idempotent (same event twice should not create chaos).
Keep a cap and a retention window (do not store forever).

Design for staleness

Users can handle stale data. What they hate is false freshness.
Use simple UI cues:
“Updated 2m ago”
a subtle stale indicator
a fallback state: “Reconnecting…”
And importantly: do not animate a pin if you have not received a meaningful update.

Taming urban canyon drift: smoothing + map matching without “teleporting”

Two mistakes show up all the time:
trusting every fix equally
snapping too aggressively and making the user jump
A better approach is two-stage:
Local smoothing (cheap, fast, reduces jitter)
Selective snapping (only when it helps and only when confidence supports it)

Stage 1: simple smoothing

You do not need fancy math to get a win.
Reject fixes with terrible accuracy.
Apply a moving average to the last N points.
Use speed and heading to ignore obvious spikes.
if new.accuracy_m > 50:
ignore
else:
points.add(new)
smoothed = average(points.last(5))

Stage 2: snap with guardrails

Snapping is useful for vehicles on roads. It is dangerous for pedestrians, parks, plazas, and dense blocks.
Guardrails that prevent the worst behavior:
snap only when confidence is high
snap only if the snap delta is within a threshold (example: <= 20m)
never snap if it causes a backward jump relative to recent movement
If you do snap, animate it gently and do it consistently. Random snapping feels like bugs.

Background and battery: treat updates like a budget

If your app “updates constantly,” the OS will eventually disagree.
Good patterns:
event-driven updates when possible
dynamic throttling (faster updates when actively navigating, slower when idle)
a clear “active tracking” mode vs passive mode
Example rule set:
foreground navigation: 1–2s
active but not navigating: 5–10s
background: 15–60s (depending on platform allowances)
Also: keep your UI stable. A slightly delayed update that looks smooth is better than high-frequency chaos.

NYC testing checklist (the part most teams skip)

Do not call it done until you test NYC-like conditions. Not just a quick walk around the block.
Routes that uncover real problems:
Midtown avenues (tall building canyon)
a bridge approach and crossing (GPS + speed edge cases)
a park segment (snapping mistakes show up fast)
subway segment with a reconnect burst
What to measure during tests:
% of updates with high/medium/low confidence
average accuracy and age
snap delta distribution (how far you are snapping)
“teleport” events (large jump in short time)
ETA error drift over time
If you need real NYC field testing and production-grade location reliability, partnering with experienced mobile app developers in New York can save weeks of guesswork.

What to log so you can actually fix it

If you cannot see it, you cannot fix it.
At minimum, log these with user consent and clear retention rules:
accuracy_m, age_s, provider
speed, heading
background vs foreground state
confidence level
snap delta (if snapping)
network state (online / offline)
Then build a simple incident playbook:
If teleport events spike, check accuracy filtering and snap thresholds.
If confidence is mostly low in Midtown, your UX should degrade instead of pretending.
If battery complaints rise, check background sampling and “always on” behavior.

The bottom line

NYC will expose every shortcut you take with location.
If you build with confidence gating, offline-first thinking, smoothing before snapping, and a realistic background budget, your app stops feeling fragile.
You will still get messy data. You will just stop letting messy data control the user experience.

Last month, I went down a rabbit hole: I implemented six classic sorting algorithms from scratch in pure Python (Bubble, Selection, Insertion, Merge, Quick, Heap) and benchmarked them properly on CPython.

I expected the usual Big-O story. What I got was a reality check: Python’s interpreter overhead changes everything.

Textbooks say Quick/Merge/Heap are fast. In Python? They’re okay… but sorted() (Timsort) beats them by 5–150×. Here’s why — and when you should never write your own sort.

The Surprise Results (Real Benchmarks)

I tested on random, nearly-sorted, reversed, and duplicate-heavy data using timeit with warm-ups, median timing, and GC controls.

Key shocks:

• Insertion sort beats Merge/Quick on <100 elements (low overhead wins).
• Bubble sort dies at ~1,000 elements due to expensive comparisons.
• Timsort (built-in) exploits real-world patterns and runs in C — untouchable.

Why Hand-Written Sorts Lose in Python

1. Comparisons are expensive: a > b → method dispatch, type checks (not one CPU instruction).
2. Recursion overhead: Quick sort’s function calls are costly.
3. Memory allocations: Merge sort creates thousands of temporary lists → GC pauses.
4. Timsort is a hybrid genius: Detects runs, uses insertion sort for small chunks, merges adaptively — all in optimized C.

Example: Insertion sort (often the small-data winner):

def insertion_sort(arr):
    arr = arr.copy()
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

The Verdict

Never implement your own sort in production Python.

Use sorted() or .sort() — they’re faster, stable, and battle-tested.

Do it only for learning purposes or rare edge cases.

Want the full deep dive?

• Detailed explanations
• All source code
• Benchmark script
• Raw benchmark data

👉 Read the complete post on my blog:

https://emitechlogic.com/sorting-algorithm-in-python/

Run the benchmarks yourself

• GitHub Repository:
  https://github.com/Emmimal/python-sorting-benchmarks

What surprised you most about Python’s sorting performance?

Drop a comment — curious to hear your take.

Why senior engineers need visibility, not vanity

There’s a phase in almost every engineering career where growth slows — not technically, but professionally.

You’re shipping solid systems.
You’re mentoring others.
You’re solving harder, more ambiguous problems.

Yet opportunities don’t scale the same way.

This isn’t a skill issue.
It’s a signal issue.

The silent plateau

Many mid-level and senior engineers fall into a quiet trap:

“My work should speak for itself.”

Inside your company, it often does.
Outside it, no one hears it.

When your resume reaches a hiring manager, they don’t just skim bullets. They Google you. They open GitHub. They scan LinkedIn. They look for context.

What they find — or don’t find — shapes the conversation before the first interview.

Silence is rarely interpreted as humility.
More often, it’s interpreted as absence.

Visibility ≠ self-promotion

Visibility is frequently misunderstood.

It does not mean:

• Becoming a full-time content creator
• Posting daily threads
• Building a loud personal brand persona

Real visibility is quieter and far more technical.

It means:

• Making your thinking discoverable
• Leaving artifacts others can learn from
• Creating public proof of how you reason

Good engineers already do this work internally — in design docs, RFCs, postmortems, and code reviews.

The only difference is where it lives.

What worked for me

My career trajectory changed when I started treating public platforms as extensions of my engineering workflow.

• GitHub became an architectural diary — not just code dumps
• Blogs became postmortems and reflections, not tutorials for beginners
• Talks and mentoring became public learning, not performances

None of this was optimized for reach or virality.
It was optimized for clarity.

Over time, those artifacts quietly led to:

• Open-source recognition (recognized as a GitHub Star)
• Speaking opportunities (spoken at many tech meetups)
• Roles I never formally applied for

Not because I marketed myself — but because my thinking was visible.

What senior engineers often underestimate

At senior levels, how you think matters more than what you know.

Two engineers may know the same tools.
What differentiates them is judgment.

But judgment only compounds when it’s observable.

That’s why:

• Design documents
• Write-ups
• Architecture explainers

are not distractions from “real work.”

They are career assets.

They show how you break down ambiguity, make trade-offs, and communicate decisions — the exact skills companies struggle to assess in interviews.

A calm approach that actually scales

This doesn’t require a lifestyle change.

You don’t need to do everything.

👉 One solid repository per quarter
👉 One thoughtful article every few months
👉 Occasional sharing of learnings

That’s enough.

A senior engineer with public clarity has asymmetric leverage — not because they’re louder, but because they’re easier to trust.

Closing reflection

These patterns became clearer to me while reflecting on my own journey — from building widely used developer tools to leading engineering teams. Those reflections eventually came together as Digital Footprint for Software Engineers, not as a guide to self-promotion, but as a practical way to think about visibility as engineering signal.

Because at some point, your code really does stop being enough — and that’s not a failure. It’s a transition.

Start building your digital footprint today. I hope my recently launched book helps you take that first step.

In the last few years, vibe coding has taken center stage by changing who can build software, but not what it takes to build it well. It is a development style defined by natural language prompts, rapid iteration, and an emphasis on getting things working fast.

Powered by AI-assisted tools and accessible platforms, vibe coding has genuinely democratized building . Startups, solo devs, and even non-technical founders can now create prototypes in hours, not months. That’s worth celebrating.

But as the hype grows, an important distinction is getting lost in the noise.

We’re starting to confuse vibe coding with software engineering.

And while they both involve code, they serve very different purposes and come with very different risks.

Where Vibe Coding Shines

Vibe coding works best when you’re:

• Testing an idea
• Prototyping fast
• Building internal tools
• Exploring creatively

It accelerates iteration and lowers the cost of experimentation. It’s a massive enabler for innovation, especially in early-stage product work.

The market agrees. According to Roots Analysis, the global vibe coding market is expected to grow from $2.96B in 2025 to $325B by 2040 – a 36.79% CAGR.

But the faster something grows, the more important it becomes to ask:
Is this still the right tool for the job?

The Foundations Vibe Coding Often Skips

What vibe coding often skips, and what experienced developers obsess over, are the foundations that keep systems standing:

• Clear, stable requirements
• Non-functional constraints (scale, security, latency)
• Architectural boundaries
• Testing strategies
• Maintainability
• Long-term risk

The Most Expensive Problems Don’t Show Up in Demos

In vibe coding, it’s easy to build something that feels finished, but ultimately collapses when it’s time to expose it to real users, real load, or when it’s time to scale. We’ve seen projects that look great on the surface but require complete rewrites just to support users, integrate with systems, or handle basic growth.

It’s not a failure of intent but a misunderstanding of complexity.

Traditional Engineering Brings Weight

Professional software development brings structure and, with it, intentional weight:

• It’s more expensive
• It takes longer
• It often requires external talent (agencies, architects, senior engineers)
• And it can feel heavy for early-stage work

But when the goal is durability, this is the discipline that delivers it. You’re building something to last. You need it to handle change, load, integration, regulation – things that don’t show up in a prototype demo.

Still, this is where many builders get stuck: cost and speed.

That’s where many builders hit a wall.

A New Middle Ground: Orchestrated Multi-Agent Systems

So, what comes next?

We believe the next evolution isn’t about choosing between speed or structure, it’s about deliberately combining both.

Enter multi-agent systems (MAS). Autonomous agents that specialize in different aspects of the software lifecycle (planning, architecture, coding, testing, optimization).

Without Orchestration, AI Just Scales Chaos

Crucially, the breakthrough isn’t the agents themselves. It’s in the orchestration layer.

Without orchestration, agents operate in silos.
With orchestration, they act like a coordinated engineering team.

What MAS Orchestration Enables:

• Sequenced collaboration across AI agents (e.g. planner → coder → reviewer → tester)
• Integrated workflows across tools, platforms, and services
• Parallel execution to reduce latency and speed up delivery
• Maintainability through modular agent updates without breaking the system
• Smarter fallback and reliability mechanisms (e.g. retries, circuit breakers, role reassignment)

In short: orchestration turns “vibe” into “system”.

We Use This Because We Want To Ship

At Brunelly, we didn’t adopt orchestration as a theory. We use it because we have to ship real systems. Our CTO refers to LLMs as “a slightly messier version of me.” And that is impressive.

If you want to read more about Brunelly’s orchestration, check out our CTO’s Guy Powell’s Substack.

Or if you prefer to test it out for yourself, feel free it’s live!

Three Phases of Modern Software Building

As we move into 2026, here’s the shift we see:

You Don’t Need Extremes. You Need Intent.

You don’t need to abandon vibe coding or overinvest in full-stack teams before you’re ready.

But if you’re trying to build something credible and scalable, and you’re looking for that elusive balance between speed and structure, multi-agent orchestration may offer a smarter third path.

Final Thought: Speed Is Optional. Clarity Isn’t.

The real question isn’t whether vibe coding is “good” or “bad.”
The question is: What are you building, and what will it take to get it there?

If you’re testing the waters, move fast and explore.
If you’re building the backbone of a product or company, slow down, think deeply, and choose the right system.

And 2026 is going to reward the teams who can do both intelligently.

Today, we’re introducing the JetBrains Console, which provides enhanced AI management and analytics for organizations, including new capabilities to manage, observe, and control AI usage and costs across teams.

AI is no longer an experiment for most development teams. It’s becoming part of the core toolchain. As usage increases, so does the need for clarity. Leaders need to understand how AI is used, how it affects day-to-day work, and how to manage it responsibly in an organization.

As a first step, these new capabilities are designed to provide that clarity, with governance and observability built in from the start. We will continue to further develop AI governance functionalities to provide even greater transparency.

Centralized AI governance across teams

Organizations can now use the JetBrains Console to manage AI usage and costs at the company or team level. In the AI settings section, you can:

• Enable AI on the organization or team level.
• Control access to AI tools and agents, including Junie, Claude Agent, and OpenAI Codex.
• Manage a shared pool of AI Credits.
• Set default and per-user credit limits.
• Configure data collection options.

Once enabled, AI capabilities are available directly inside developers’ JetBrains IDEs, with no additional setup or workflow changes required. This makes it possible to roll out AI incrementally and avoid ungoverned usage.

Managing AI Credits and licenses

As AI usage grows, visibility into licenses and consumption becomes critical.

The Users and licensing tab in the AI management section provides a single view of:

• License availability and assignment throughout the organization.
• Included AI Credit usage.
• Remaining top-up credits.

Admins can assign licenses that include AI Credits, such as AI Pro, AI Ultimate, All Products Pack, and dotUltimate, to individual users. Access can be granted or restricted as needed, with changes taking effect immediately.

For teams or individuals with higher usage needs, additional AI Credit limits can be configured per user or applied in bulk. This allows organizations to support power AI users without removing default values in the company.

Observability into AI usage and adoption

AI adoption rarely looks the same across teams. Some developers integrate it deeply into their workflow, while others use it occasionally or not at all.

The console provides clear visibility into how AI is used throughout the organization, helping you understand adoption patterns and plan budgets better.

Track AI adoption and engagement over time

The Active AI users chart shows how many developers actively use AI, making it easier to understand adoption trends and engagement levels across teams. You can find more details on how we calculate these metrics here.

Monitor AI Credit consumption

AI Credit usage can be analyzed over any time period, both for credits included in your AI license and top-up credits. This data supports more informed planning around budgets and usage limits.

Spot when developers reach their AI Credit limits

The console also shows how frequently users reach their monthly AI Credit limits. This makes it easier to identify friction points and adjust limits where needed, whether at the team or individual level.

Understanding how AI influences development work

Beyond usage and cost, the console provides early insights into how AI is used and received by developers. The AI activity and impact charts are intended to support comparison and informed decisions. 

In upcoming releases, we will introduce more advanced metrics and API access to help organizations assess the impact of AI on engineering and business outcomes.

Acceptance of AI-generated code

The AI-generated code and acceptance rate charts show how often AI-generated code is accepted by developers and act as indicators of quality and relevance.

You can use this data to compare the tools or agents you have integrated into AI Assistant (Junie, Claude Code, OpenAI Codex, and others that will be supported in the future). This helps you identify where suggestions consistently fall short of expectations and decide where configuration, enablement, or tool choice should be revisited.

You can find more details on how we calculate these metrics here.

AI-modified code

The AI-modified code charts highlight the relative footprint of different AI tools and features within the codebase.

This helps teams understand exactly where AI is making meaningful contributions to development.

AI feature activity

The AI feature activity chart shows how developers interact with AI inside the IDE, including chat usage and suggestion volume.

These insights help distinguish experimentation from sustained use and identify mismatches between enabled capabilities and actual developer behavior.

Get started

AI management and analytics are now available at no additional cost to all commercial customers with AI licenses via the JetBrains Console. Access is role-based, allowing organizations to define who can manage AI settings, view usage and adoption data, and assign licenses. 

To get started, open the AI management section in the JetBrains Console. For more details, refer to the documentation or visit the AI for Business page.

We’re working to further enhance AI management and governance capabilities for organizations. Upcoming features include:

• Centralized Bring Your Own Key (BYOK) management for AI providers.
• MCP management for your organization.
• Centralized codebase indexing (RAG).
• AI guardrails and AI audit.
• More advanced usage analytics dashboards and API access.

Want to stay updated on what’s next? Subscribe to the JetBrains AI newsletter below.

Starting from version 2026.1, IntelliJ-based IDEs will run natively on Wayland in supported desktop configurations. This follows Wayland’s ascendance to the position of primary display server across contemporary Linux distributions.

By making this change in our EAP releases first, we hope to be able to give more Linux users the opportunity to try the native Wayland mode in their IDE, gather their feedback, and prepare more comprehensively for the general rollout in one of the upcoming major versions.

What changes?

Instead of running as X applications, IntelliJ-based IDEs will now automatically enable native Wayland support in a Wayland-capable desktop environment.

Since the last preview in 2024.2, we have enhanced stability across several Wayland server implementations, added drag-and-drop functionality and input methods (IMs) support, and made a significant step towards native-looking window decorations.

Wayland differs profoundly from X11 in several technical ways. As a result, even though the user interface should largely look and feel the same, these underlying distinctions may be noticeable:

• Some windows and dialogs, e.g. Project Structure and Alerts, may not be centered on the screen or keep their previous location. This is due to the window manager having total control over windows’ locations in Wayland, which it is not always possible to override on the application side.
• The splash screen on IDE startup will not appear as it cannot be reliably centered on the screen.
• Some popups, such as Search Everywhere and Recent Locations, may not be moved outside of the main frame.
• Window decorations (such as the title bar, window control buttons, shadows, and rounded corners), where present, may not fully adhere to the current desktop theme.

Some of these distinctions affect many Wayland users across other applications, and the Wayland community is actively addressing them. It is possible that they will be resolved in future versions of Wayland implementations and IntelliJ-based IDEs.

X11 is still supported

In a Linux desktop environment that does not support Wayland, IntelliJ-based IDEs will continue to work as X applications. It is also possible to switch to using X11 on any Wayland desktop because an X.Org implementation called XWayland is always available for compatibility with older applications. To do that, add -Dawt.toolkit.name=XToolkit to the VM options list (Help | Edit Custom VM Options…) and restart the IDE.

Is my IDE running in X11 or Wayland mode?

If you are curious about which mode your IntelliJ-based IDE is currently running in, you can find out by going to the About dialog (Help | About) and checking which toolkit is in use. Click on the Copy and Close button, and you’ll then see the toolkit’s name towards the top of the copied text:

Toolkit: sun.awt.wl.WLToolkit

This information is also available in idea.log; for example:

INFO - #c.i.p.i.b.AppStarter - toolkit: sun.awt.wl.WLToolkit

Configurations supported in the future

Wayland support for Remote Development mode is currently a work in progress. In the meantime, Remote Development mode will continue to operate as before and not enable native Wayland support automatically.

Technical details

Native Wayland support is mostly concentrated in one subsystem called WLToolkit. If you were one of the early adopters of this mode, you had to specify the -Dawt.toolkit.name=WLToolkit VM option manually. This will continue to work, but it is no longer necessary.

The launcher will supply a new option to the IDE: -Dawt.toolkit.name=auto. The “auto” option will be resolved into either WLToolkit or XToolkit based on the following rule:

• If wl_display_connect() succeeds, “auto” is replaced with WLToolkit, and therefore the application is launched in the native Wayland mode.
• Otherwise, “auto” is replaced with XToolkit, and the application is launched in X11 mode.

Like every other aspect of JetBrains Runtime, the platform that powers IntelliJ-based IDEs, WLToolkit is fully open-source. JetBrains is also a key contributor to the OpenJDK project Wakefield, which is dedicated to ensuring that all Java applications execute natively on Wayland. New features and fixes are regularly published to the project’s GitHub repository. 

Feedback

We are very grateful for the dedication and valuable input from our users who participated in the Wayland Preview program. The time and effort you invested in reporting issues were instrumental, not only in identifying critical bugs but also in helping us accurately prioritize the roadmap for improvements and the implementation of key features.

We are pleased to announce that the upcoming version 2026.1 incorporates fixes for a substantial number of the reported problems. These fixes address a wide range of stability, performance, and desktop integration issues, marking a major milestone in the maturity of our Wayland support.

This major platform transition is a work in progress. We are actively investigating and developing fixes, prioritizing core areas like rendering, popups, window management, input methods (IMs), and desktop integration. Please subscribe to and vote for relevant issues for updates. Your patience and feedback are crucial as we work toward a stable, performant, modern, and feature-complete experience.

FOSDEM is a very special kind of event, and the 2006 edition was no exception. It is organised at a university campus, it is free for attendees, and there is a massive amount of exhibitors that are involved in open source in one way or the other. It is the place to be for the open source community, no question about that.

Since there were no Java devroom at the conference this year, some dedicated members of the Java community met up at Bier Centraal on Saturday night. As always when we meet, there were some discussions and ideas coming out of it. Nobody will ever know if it is because fo the Belgian beer or not…

Among other things, we planned for how we can scramble to see if we can get the Java devroom back at FOSDEM next year.

True to tradition, Eclipse Foundation had a booth at FOSDEM. We were almost 20 present from the Foudation at FOSDEM this year, so the booth had excellent coverage from the various technologies and projects that are represented among the more than 400 projects at Eclipse Foundation. The spin-the-wheel-to-win-swag was extremely popular. As was the chance to win a Lego set in the raffle at the end of each day. FOSDEM is an excellent event for us to meet and talk to the open source community.

Ivar Grimstad

Tue, 2026-02-03 07:32