DEV Community: Dragonsoft DevSecOps

ITSM案例 | 某全球諮詢公司：從 ServiceNow 到 HaloITSM，實現效率、靈活性與成本節約的全面提升

Dragonsoft DevSecOps — Tue, 11 Aug 2026 05:45:43 +0000

本案例來源HaloITSM。由HaloITSM授權合作夥伴——龍智（DragonSoft）为您带来分享解读，旨在通過這一成功案例，為您展現 HaloITSM 在降本增效、敏捷部署和用戶體驗方面的卓越能力。如需試用HaloITSM，請隨時聯繫龍智團隊。

隨著 inlumi 的業務持續擴展，他們亟需一套能夠跟上發展節奏的 ITSM 解決方案。面對 ServiceNow 日益上漲的成本、複雜的定制化以及不斷下滑的技術支持，inlumi 最終決定轉用 HaloITSM 平臺。

許可成本降低 30%
回應時效提升 20%
一套方案覆蓋 12 個國家/地區

關於 inlumi

inlumi 是一家全球性諮詢公司，總部位於荷蘭烏得勒支，專注於財務報告與企業績效管理。自 2000 年成立以來，inlumi 已從一家小眾諮詢公司發展為遍佈 12 個國家、擁有 250 餘名員工的國際化組織。inlumi 致力於服務大型企業客戶，並不斷尋求最佳技術解決方案來提升其運營水準。

面臨的挑戰

隨著 inlumi 的業務不斷擴張，其對強大的 IT 服務管理（ITSM）平臺的需求也與日俱增。

ServiceNow 作為他們的解決方案已使用多年，但卻限制了他們的發展步伐：inlumi 希望為客戶提供新的集成方案，並開始探索 AI 功能，而這些在 ServiceNow 中要麼實施難度太大，要麼價格極其高昂。此外，他們還面臨以下問題：

• 成本持續攀升：儘管價格不斷上漲，inlumi 卻未能看到相應的價值提升或功能增強。

• 定制化複雜：雖然 ServiceNow 具備 inlumi 所需的功能，但對其進行配置以滿足特定的需求，這點往往既困難又耗時。ServiceNow 的開箱即用功能無法滿足他們的需求，迫使他們不得不額外付費購買附加模組。

• 支持品質下降：隨著時間的推移，inlumi 發現 ServiceNow 的技術支持水準和回應速度都在下滑。

這些問題促使 inlumi 開始評估市面上的其他 ITSM 解決方案，以便更好地契合其不斷發展的需求。

需求

inlumi 進行了全面的市場分析，對多款 ITSM 平臺進行了對比評估，其中包括再次考量 ServiceNow。他們的核心需求包括：

• 解決方案需要開箱即用且功能豐富

• 具備更直觀、更友好的用戶介面

• 具備強大的集成能力，能夠與 CRM 系統、財務系統和註冊系統相容

• 具有高性價比的許可模式，期望新解決方案的許可成本可降低 30%

• 提供可靠且回應及時的技術支持

經過評估，HaloITSM 成為唯一能夠滿足其全部需求的平臺。

"Halo的脫穎而出，不僅僅在於價格優勢，更在於我們雙方的合作方式、他們對產品的定位，還有他們售前團隊與我們通力合作，共同打造出的應用案例，清晰展示了該產品的能力和應用場景。”——Frank Wessels，首席技術官

解決方案

從一開始，inlumi 就對 Halo 的強大功能印象深刻。其遷移體驗的關鍵亮點包括：

• 即時價值與豐富功能：許多在 ServiceNow 中難以或無法實現的功能，在 Halo 中都已經開箱可用。每當 inlumi 詢問特定功能時，得到的回答始終是“沒問題，我們可以做到”。

• 無縫實施：遷移過程順暢直觀，確保了內部團隊和客戶都能夠快速上手。

• 卓越的用戶體驗：Halo 具備簡潔的介面和用戶友好的導航，使客服人員和客戶都能高效地使用系統。一些細節改進，例如可以直接在文本字段中插入截圖（而在 ServiceNow 中需要單獨上傳附件），徹底改變了他們與客戶的交互方式。

• 強大的可定制性，無需複雜編碼：與 ServiceNow 不同，借助Halo，inlumi 團隊無需高級編程技能即可自定義表單和工作流，讓新部門和流程的創建變得和構想一樣簡單。輕鬆創建具有動態可見性的工單類型更是顛覆性的改變——這在過去必須通過編寫腳本來實現。

• 透明且高性價比的許可模式：Halo 的核心套件已包含基本功能和集成，無需再額外購買昂貴的附加許可。

“從一開始，我就被Halo所提供的無限可能深深折服，特別是當我們列出了一份願望清單，上面都是 ServiceNow 做不到或極難實現的功能時。Halo 團隊的回應總是非常乾脆：‘沒問題，我們能做到，而且是這樣做的。’”——Marissa Nijhof，ITSM 專家
成果

向 Halo ITSM的轉型為 inlumi 帶來了顯著收益：

• 效率提升：Halo 的直觀特性使團隊工作效率大幅提高，減少了系統配置和故障排障的時間。

• 溝通與支持改善：Halo 的支持服務品質卓越，回應速度快，技術水準高。

• 面向未來增長的可擴展性：inlumi 擁有清晰的發展路線圖，將 Halo 視為長期的 IT 服務管理合作夥伴，以支持其持續擴張和創新。

• 許可成本降低 30%：這不僅體現在整體許可成本的下降，還得益於併發許可模式，允許多個客服人員通過共用許可訪問系統。

"許多之前從未使用過 ServiceNow 的部門，現在都主動要求使用 Halo。有部門來找我提出特定的表單需求，而我能用拖拽功能自己搞定，這種感覺真的太好了。" ——Marissa Nijhof，ITSM 專家

結論

切換至 Halo ITSM後，inlumi 得到了一個更敏捷、成本更低，且更加易用的解決方案，完美契合自身業務需求。現在，inlumi 能夠靈活高效地調整和擴展其流程，同時享有優質支持和增強功能。Halo 不僅滿足了inlumi 的需求，甚至超出了預期，為他們今後的持續發展奠定了堅實基礎。

系統部署完成後，inlumi 正著手進行優化升級。盡可能實現自動化是他們當前的首要任務——而此前在 ServiceNow 平臺中，如果不額外付費則無法實現這一功能。他們還對 AI 落地充滿期待，計畫從自動解決方案推薦、AI 分流和知識庫增強等方面著手。

隨著組織內其他部門也看到 Halo 帶來的實際收益，inlumi 正計畫將其擴展為全面的企業服務管理（ESM）解決方案。

HaloITSM中國授權合作夥伴——龍智（DragonSoft）

作為 HaloITSM 在中國的官方授權代理商，龍智（DragonSoft）已經通過HaloTISM官方的技術認證，將向中國、香港用戶提供從需求調研、方案定制、系統實施到本地化支持的一站式服務。我們不僅交付國際領先的工具，更提供貼合本土企業需求的最佳實踐，確保您的 ITSM/ESM 轉型順利落地。

如果您也正面臨 ITSM 工具選型、替換或升級的困擾，渴望打造一個統一、智能且高性價比的服務管理平臺，歡迎隨時聯繫龍智，獲取Halo產品諮詢與演示：

官網: www.hkdsdtech.com

電話: +852-51679050

郵箱: marketing@hkdsdtech.com

Java Application Server Selection Guide: WebLogic vs. Tomcat Comparative Analysis (Featuring Perforce JRebel for Enhanced Productivity)

Dragonsoft DevSecOps — Tue, 11 Aug 2026 05:42:50 +0000

Originally published on the Perforce blog. For expert guidance and support, reach out to DragonSoft, an authorized Perforce partner.

When selecting a Java enterprise application architecture, WebLogic and Tomcat represent two fundamentally different technology paths. WebLogic, provided by Oracle, is a full-featured, commercial-grade application server, making it the premier choice for handling large-scale, complex, and highly compliant Jakarta EE mission-critical workloads. In contrast, Tomcat is an open-source, lightweight Servlet container from the Apache Software Foundation. Thanks to its free and agile nature, it has become the gold standard for microservices architectures and Spring Boot applications.

Choosing the wrong server not only causes performance bottlenecks but also leads to exorbitant migration costs and budget-draining licensing fees. Translated and adapted by DragonSoft—a technology service provider deeply specializing in DevOps and engineering productivity—this article delivers an in-depth analysis of the differences between these two mainstream Java servers. We will break down core dimensions such as licensing costs, Jakarta EE specification compliance, and operations and technical support, helping your team make the most cost-effective infrastructure decision.
Furthermore, whether your team ultimately opts for the robust WebLogic or the agile Tomcat, frequent code builds and server restarts will inevitably consume valuable development time. Therefore, this article will also reveal how to leverage enterprise-grade instant hot reload technologies like Perforce JRebel to eliminate application server deployment wait times. This ensures that while you establish a solid architectural foundation, you are also maximizing the delivery efficiency of your Java team.

So, in real-world technology stack selection, what are the essential differences between these two widely deployed Java servers? Let's first dive into WebLogic and its enterprise-grade positioning.

WebLogic: Commercial Support & Full Feature Set

Oracle WebLogic Server is a full-featured Java application server that supports the complete Java EE (now Jakarta EE) specification. This includes enterprise features such as Enterprise JavaBeans (EJB), Java Messaging Service (JMS), Java Transaction API (JTA), Java Connector Architecture (JCA), and more. For organizations running complex, multi-tier enterprise applications, these capabilities are essential.

WebLogic is designed with large-scale deployments in mind. Its architecture supports clustering, load balancing, high availability, and failover—capabilities that matter when downtime is not an option.

Financial institutions, healthcare organizations, and government agencies frequently choose WebLogic precisely because of this reliability at scale.
As a commercial product, WebLogic comes with paid Oracle support, regular security patches, and long-term maintenance guarantees. Organizations operating in regulated industries or under strict SLAs often find this level of vendor-backed support non-negotiable.

Tomcat: Open Source & Lightweight

Apache Tomcat is an open-source web server and Servlet container for Java code. It's a production-ready Java development tool used to implement many types of Jakarta EE (formerly known as Java EE) specifications.

Tomcat is designed to be fast, lightweight, and easy to deploy. Because it implements only a subset of the Jakarta EE specification, it is often chosen by teams that need to serve Java web applications quickly, without the overhead of a full application server.

The open-source nature of Tomcat also makes it highly accessible. There are no licensing fees, a vast community of contributors maintaining its codebase, and an extensive library of documentation and third-party integrations exists.

Key Similarities Between WebLogic and Tomcat

Core Java Functionality
Both WebLogic and Tomcat are built to run Java-based web applications. Both implement the Jakarta Servlet specification, meaning Java servlets and JSPs will run on either platform. Both support HTTPS, session management, and standard Java web application packaging.

Key Differences Between WebLogic and Tomcat

Licensing
Tomcat is free and open-source, distributed under the Apache License 2.0. There are no per-core, per-processor, or per-user licensing fees. Organizations of any size can deploy Tomcat at scale without licensing overhead.

WebLogic is a commercial product licensed by Oracle. Licensing costs vary based on deployment model, number of processors, and the specific edition (Standard, Enterprise, or Suite). For large deployments, WebLogic licensing represents a significant investment to be weighed against the value of its enterprise features.

Jakarta EE Compatibility
Tomcat implements the Jakarta Servlet, JSP, and Expression Language specifications. It does not natively support the full Jakarta EE suite, which means features such as EJB, JMS, JTA, and JCA are not available out of the box.

WebLogic provides certified compliance with the full Jakarta EE specification. All enterprise Java APIs are available natively, eliminating the need for third-party integrations for core enterprise services.

Support
Tomcat relies on community support, and while this community is large and active, there is no formal SLA-backed support directly from Apache.

WebLogic comes with Oracle's commercial support infrastructure, including access to My Oracle Support (MOS), critical patch updates, and long-term product maintenance. For enterprises with strict uptime requirements or regulatory obligations, this structured support model carries significant value.

When Should I Use WebLogic?

WebLogic is the right choice when your application environment demands enterprise-grade features, compliance, and long-term vendor support.

Choose WebLogic if:
• Your application relies on full Jakarta EE services without the overhead of integrating multiple third-party libraries.
• You are operating in a regulated industry where vendor-backed support and guaranteed patch schedules are required.
• You need a proven, certified platform for mission-critical systems where application server stability is non-negotiable.

WebLogic's operational complexity and licensing cost make it a serious commitment, but for enterprises where full functionality and support come first, that investment is consistently justified.

When Should I Use Tomcat?

Tomcat is the right choice when simplicity, speed, and cost-efficiency are priorities—and when your application does not require the full Jakarta EE feature set.

Choose Tomcat if:
• Budget constraints make commercial licensing impractical, and community support is sufficient for your operational needs.
• You need to deploy quickly, with a lightweight footprint and minimal server configuration overhead.
• Running in containers/cloud
• Using Spring Boot

Tomcat's strength is its simplicity. When your application architecture is well defined and does not require the full Jakarta EE functionality, Tomcat is a fast, reliable, and cost-effective choice.

Final Thoughts

WebLogic offers more robust features, commercial-grade support, and enterprise-scale reliability. Tomcat offers a lean, open-source foundation for teams that value speed, flexibility, and cost efficiency.

The decision comes down to what your application actually requires. If you are running complex, distributed enterprise applications with regulatory constraints and strict uptime SLAs, WebLogic's depth and Oracle support justify the investment. If you are deploying web applications or microservices with a modern framework like Spring, Tomcat's simplicity and zero licensing cost are compelling.

Before committing to either platform, map your application's dependencies against the feature sets described here. A thorough requirements analysis will consistently surface the right choice and protect your organization from the cost of migrating later.

Whether you choose to move forward with WebLogic, Tomcat, or another application server, JRebel integrates seamlessly with leading Java IDEs, frameworks, and technologies. Eliminate redeploys and get instant feedback on your code changes.

About Perforce JRebel
Accelerate Java Development with Instant Code Reloading

Perforce JRebel is a JVM plugin that accelerates Java application development by eliminating time-consuming build and redeployment cycles.
With Perforce JRebel, you simply write your code and refresh your browser. It is compatible with all Java applications, spanning desktop, web, microservices, and enterprise environments. Whether deployed on a local server, a remote server, or in the cloud, JRebel effortlessly reloads your changes.

Eliminate time-consuming build and redeployment cycles in Java development.
Visualize the impact of code changes in real time.
Minimize developer downtime and unbudgeted labor costs.
Preserve application state seamlessly across reloads.

DragonSoft Insights & Support

Choosing between WebLogic and Tomcat is fundamentally about finding the optimal balance between enterprise-grade robustness and lightweight flexibility. Whichever application server you select, the key lies in seamlessly integrating it into your technology stack and maximizing engineering productivity through an efficient development toolchain.
As an authorized Perforce partner, DragonSoft provides genuine licensing and expert technical support for JRebel. We ensure rapid integration and accelerated Java application development for your team.

Contact the DragonSoft team today to claim your 14-day free trial of Perforce JRebel or to discuss your Java development optimization needs:

🌐 Website: www.hkdsdtech.com
📞 Phone: +852-51679050
✉️ Email: marketing@hkdsdtech.com

Introducing Cursor in Jira: Enabling AI Agents to Execute Engineering Tasks Directly

Dragonsoft DevSecOps — Tue, 11 Aug 2026 05:36:44 +0000

Originally published on the Atlassian blog. Curated by DragonSoft, an Atlassian Platinum Partner.

As AI fundamentally reshapes the software development lifecycle, a critical question emerges for engineering leaders: How do we seamlessly integrate AI agents into the team's operational context, rather than letting them remain as siloed coding assistants?

Atlassian’s newly launched Cursor in Jira integration directly answers this challenge. It transforms Jira into the central orchestration hub for human-AI collaboration, bridging the gap between rich work context and actual code execution to forge a single, cohesive workflow.

As an Atlassian Platinum Partner, DragonSoft brings you this expert breakdown. We aim to help you quickly unlock the core value and practical use cases of this new integration, providing a strategic roadmap for your organization's transition to AI-native development.

Starting today, Jira teams can assign work directly to Cursor, where a cloud agent will pick it up and begin working.

You can steer agents directly from Jira, your IDE, or Cursor on the web. When Cursor needs input or is ready for review, it will notify you in Jira. When it opens a pull request, it will be automatically linked back to Jira.

Based on a multi-year DX study of AI usage and engineering throughput, we've seen developer velocity failing to keep pace with model capability because agents lack context. The respondents cite things like context switching, planning, alignment, bug triage, and review as primary friction points outside of their IDE.

Now, Atlassian is enabling AI-native workflows right from Jira for any engineering team using Cursor.

"The question we're asking isn't how do we get engineers to use more AI. It's how do we build a system where humans and agents are working from the same context, toward the same goals. Assigning work directly to Cursor from Jira, with all that rich context, is a meaningful step towards being able to orchestrate agents effectively at scale." ——Jason Andrews，Vice President – Engineering Operations, Cisco

Intent to action with Cursor in Jira:

Trigger agents directly from Jira: Assign a work item to @cursor or mention @cursor in a comment to start a new agent session for the task at hand.

Automate workflows: Create rules that automatically assign certain tasks to Cursor, helping you tackle repetitive work and improve code quality.

Enable the whole team to make changes: Any team member can use Cursor to start tasks and open a pull request, without needing to set up a local dev environment.

Work with rich context: Use Rovo to enrich your task with context from across Atlassian's Teamwork Graph, then assign to Cursor so it has more context with less manual effort.

Enable spec-driven development flows: Automatically sync agent-readable specs with collaboration documents in Confluence, and work items, plans, and goals

"We're seeing teams ship the fastest when they give their agents as much context as possible. Jira is where work is defined, and engineers build in Cursor. Now that context can easily be shared, with Jira as the orchestration layer connecting all of it." —— Tamar Yehoshua，Chief Product and AI Officer, Atlassian

All context. No switch. Update Jira directly from Cursor.

Atlassian holds the full context of work: issues, linked specs, dependencies, decisions, and the teams working on all of it.

Now, local agents can access that context directly within the terminal, browser, or app with Atlassian's Teamwork Graph CLI or the Rovo MCP.

With a simple command, engineers in Cursor can update work items, tag teammates for review, surface Confluence specs and decisions attached to their work, check release status and dependencies, and more. The Teamwork Graph from Atlassian provides a live, intelligent map of your organization's people, work, and knowledge. It gives coding agents the precise context they need to deliver more accurate results with fewer tokens. In our internal testing, agents that leverage Teamwork Graph context achieved a 44% improvement in answer quality and used 48% fewer tokens.

"With Atlassian's Teamwork Graph CLI, developers have full project context—issues, dependencies, Confluence pages—right inside Cursor. With Cursor in Jira, anyone on the team can go from a ticket to a merge-ready PR without switching tools. This partnership connects your planning tools with your coding agents so they share the same context. Our shared customers tell us it's fundamentally changing the first hour of every task and allowing them to ship faster."—— Tido Carriero，Head of Engineering, Product, & Design, Cursor

Teams can keep Jira work items and Confluence documentation up to date directly from Cursor. This turns single-player AI software development into a multiplayer workflow grounded in the same system of record. No context switching required.

Availability

Cursor in Jira is now available with every paid Jira subscription.

To learn more, reach out to DragonSoft, an Atlassian Platinum Partner.

DragonSoft Insights & Support

Atlassian's launch of Cursor in Jira marks a paradigm shift in R&D collaboration: moving from "human-driven tooling" to "context-driven AI agents." When Jira serves as the orchestration layer, the AI Agent is no longer just a siloed coding assistant, but a collaborative partner seamlessly integrated into the end-to-end workflow.

As an officially authorized Atlassian partner, DragonSoft provides genuine licensing, deployment, implementation, and technical support for the full suite of Atlassian products, including Jira, Confluence, Jira Service Management, and Rovo. Furthermore, we offer expert consulting and tailored solutions for requirements analysis, solution customization, and Agent integration, empowering your team to smoothly transition to AI-native development.

Contact DragonSoft today to get installation and usage support for Cursor in Jira, or to explore comprehensive Atlassian solutions for your enterprise.

🌐 Website: www.hkdsdtech.com

📞 Phone: +852-51679050

✉️ Email: marketing@hkdsdtech.com

Automating Build Chains: A Practical Guide to Integrating AI Agents with TeamCity

Dragonsoft DevSecOps — Mon, 03 Aug 2026 12:25:30 +0000

Originally published on JetBrains.com by Sergei Ugdyzhekov. For expert guidance and support, please contact DragonSoft, an authorized JetBrains partner.

As AI Agents evolve from merely proposing solutions to executing closed-loop workflows, the CI/CD configuration paradigm is undergoing a fundamental shift. The feedback loop—once reliant on developers' repetitive manual debugging—is now being autonomously driven by agents.

This article demonstrates the end-to-end synergy between AI Agents and TeamCity: from reading documentation and proposing solutions, to invoking REST APIs to configure build chains, observing outcomes, and iteratively refining the setup. Explore a new approach to CI/CD automation.

TL;DR: At some point, we crossed an interesting threshold. AI agents can now set up TeamCity build configurations and even full build chains, add build features, and configure parameters.

This works because TeamCity documentation is structured and accessible through MCP via Context7, and because agents can rely on tools like the TeamCity CLI and the skill.teamcity-cli

I ran a couple of experiments recently to see how far this can go in practice.

1 In search of a solution

First, I asked ChatGPT to come up with a solution for a customer request.

ChatGPT read TeamCity documentation via Context7 and proposed a setup that included:

• multiple build configurations

• two aggregate builds

• two build chains combining them

• triggers based on file extensions

• artifact and snapshot dependencies

So far, this is what you would expect from a capable LLM: a reasonably solid design.

Then I passed this solution to Codex and asked it to actually set everything up in TeamCity Nightly, in my personal sandbox project.

Five minutes later, I had a working demo.

There were some mistakes, but they were fixed in a few more minutes. Codex used the TeamCity REST API and executed the setup step by step via teamcity api commands, effectively reproducing the entire configuration from the original description.

The interesting part here is not that the configuration was correct on the first try. It was not.

The interesting part is how quickly the agent could:

• apply the configuration

• observe what did not work

• adjust and retry

What matters here is that the gap between describing a pipeline and actually having it running is now very small. The agent does not stop at producing a plan. It executes it and iterates until the result is usable.

At this point, the agent is not just describing a solution. It is implementing and refining it.

2 Go project

In the second experiment, I cloned a small personal Go project from GitHub and asked Codex to set up CI for it in TeamCity.

It created a simple pipeline with “Tests” and “Build” configurations.

One funny detail: it managed to reuse my GitHub PAT from the gh utility to create the VCS root. “Stole” is not exactly the right word here, but it definitely felt funny.

The success condition was simple: the build should be green.

It was not.

After a few attempts, the agent figured out that Go was missing in the build agent environment. It then modified the build steps to work around this and retried until the build passed.

In other words, the agent is not just configuring TeamCity. It is working towards a goal and adapting its actions based on what happens during the build.

After reviewing the result, I noticed that Go tests were not reported properly in TeamCity.I pointed this out.

The agent updated the configuration, added the required build feature, and on the next run the test results were reported correctly.

What these experiments show

In both cases, the agent followed a similar pattern:

• read documentation

• propose a solution

• apply it through the API

• observe the result

• iterate until the goal is reached

This loop is the main difference compared to earlier experiments with LLMs.

Instead of stopping at “here is how you could configure it”, the agent continues until the system actually works. This turns CI configuration into an iterative process that can converge on its own, instead of stopping at a static definition written upfront.

Conclusion

TeamCity works with AI agents, and AI agents can meaningfully help configure it. But the more interesting finding is how they go about it.

In both experiments the same pattern emerged: the agent didn’t stop at producing a configuration. It applied it, watched what happened, and kept adjusting until the pipeline ran. That feedback loop, which normally requires a developer to run the pipeline, read the output, fix something, and run it again, was happening inside the system on its own.

That said, these are early results. Agents need clear goals, good documentation, and a controlled environment to operate in. Setup tasks that used to take several manual iterations can now converge faster, with the agent handling much of the cycle.

DragonSoft Insights & Support

The fusion of AI Agents and TeamCity unlocks the true potential of modern development automation. But turning cutting-edge technology into real business value requires more than just software—it demands expert toolchain guidance and reliable, localized support.

As an Authorized JetBrains Partner, DragonSoft delivers comprehensive TeamCity solutions. From flexible licensing and strategic planning to seamless implementation, team training, and 24/7 technical support, we’ve got you covered. We don’t just hand over a tool; we embed TeamCity seamlessly into your existing tech stack and engineering workflows, empowering your team to make the leap from manual configuration to intelligent, automated operations.

Whether you're evaluating TeamCity for the first time or looking to optimize your current CI/CD pipelines, we provide end-to-end guidance—from initial assessment to successful, scalable deployment.

Ready to elevate your engineering productivity? Contact us today for a customized trial and consultation:

🌐 Website: www.hkdsdtech.com

📞 Phone: +852-51679050

✉️ Email: marketing@hkdsdtech.com

How to Accelerate Java Development by Using Perforce JRebel in Cursor

Dragonsoft DevSecOps — Mon, 03 Aug 2026 12:19:46 +0000

This guide walks you through leveraging Perforce JRebel directly in Cursor to supercharge your Java development. Ready to equip your team with JRebel? Contact DragonSoft, an authorized Perforce partner, for expert guidance and licensing support.

Generative AI is changing the way we work — and Java developers are not immune to that upheaval. AI-native IDEs like Cursor automate repetitive tasks, detect bugs and code errors, and speed up the development workflow.

However, writing code faster is only half the battle for more efficient Java development. Experienced and novice Java developers alike still face frustrating delays when waiting for builds and redeploys, which slow down their iteration speed.

JRebel solves this problem by eliminating redeploys entirely while maintaining application state. When you combine JRebel with Cursor, you accelerate your Java workflow from code generation to final testing, saving time and enabling innovation.

What Is Cursor?

Cursor is an AI-native IDE built on a VS Code fork. It embeds artificial intelligence directly into the development workflow. Instead of acting as a simple chat assistant, Cursor operates as an active collaborator that plans architecture, writes full functions, and refactors large blocks of code.

Is Cursor Good for Java Development?

Yes. Cursor has made a significant investment to improve Java support in the past year, including speeding up the Java Language Server Protocol (LSP) and contributing to the open-source VS Code ecosystem. According to Cursor, these updates deliver project imports that are 10% faster and reduce debugger scans from 5+ seconds to mere milliseconds in large codebases.

What's the Difference Between Cursor and Traditional IDEs?
IntelliJ IDEA is a traditional IDE that relies on plugins to add AI features. The developer prompts the AI, and the AI provides suggestions. As of March 2026, Cursor is also available in all JetBrains IDEs, including IntelliJ IDEA, through the Agent-Client Protocol (ACP). The ACP is not a plugin; it is an open source protocol that defines how Cursor and IntelliJ communicate with each other.

Cursor is an AI-native IDE. It operates autonomously to complete entire engineering tasks, including code completion, refactoring, error detection, and more. Cursor securely indexes your entire repository, navigates files, and runs commands directly in the terminal.

Can I Use Cursor in IntelliJ?

Yes. Developers who rely on JetBrains IDEs can now access Cursor through the Agent Client Protocol (ACP). This integration allows you to run Cursor agents directly inside IntelliJ IDEA, PyCharm, and WebStorm. You get the powerful AI assistance of Cursor while keeping the robust Java support of IntelliJ.

For many Java developers, this integration represents the best of both worlds. They can leverage the AI functions of Cursor and the robust Java support of IntelliJ IDEA, all without having to manually copy and paste code from Cursor to IntelliJ IDEA.

How Java Developers Are Using Cursor

Java developers apply Cursor to automate routine tasks and redirect their energy toward complex problem-solving.

Intelligent code completion: Cursor predicts your next lines of code based on class structures, method signatures, and surrounding logic. This reduces keystrokes and helps you build features faster.
Refactoring: The AI agent analyzes your codebase for inefficiencies and suggests improvements. This keeps technical debt low and maintains a secure code structure.
Error detection: Cursor identifies complex bugs, concurrency issues, and logic errors that traditional static code analyzers often miss.
Autonomous agents: You can instruct the Cursor agent to add a new feature, and the agent will plan the steps, write the code across multiple files, and verify the results.

How to Install & Use JRebel in Cursor

Cursor is a fork of VS Code, so it supports extensions from the Open VSX registry. You can install the JRebel plugin in Cursor, Windsurf, Kiro, or any other VS Code fork using the exact same process.

Installing JRebel With the Open VSX Registry Extension

The simplest way to install the JRebel plugin in Cursor is through the Open VSX Registry. Follow the instructions in this video to get started or read them here.

Final Thoughts

The combination of JRebel and Cursor offers a unique advantage for Java developers seeking efficiency and innovation. By integrating the time-saving capabilities of JRebel with the intelligent automation of Cursor, you can drastically streamline your workflow from code creation to deployment.

DragonSoft Insights & Support

The integration of JRebel and Cursor is far more than just "hot reload + AI coding." It fundamentally redefines the developer inner loop for Java: AI helps you code faster, while JRebel lets you verify those changes instantly.

In an era where Developer Experience is a true competitive advantage, every second saved from build waits translates directly into measurable productivity gains for your team.

How to Get Started with JRebel?
As an Authorized Perforce Partner, DragonSoft provides comprehensive JRebel solutions, including flexible licensing, technical enablement, and best-practice consulting.

We don't just deliver software; we seamlessly embed JRebel into your existing tech stack and engineering workflows, empowering your team to achieve measurable leaps in development productivity.

Contact the DragonSoft team today to claim your 14-day free JRebel trial, or to request a customized enterprise licensing and deployment plan.

🌐 Website: www.hkdsdtech.com

📞 Phone: +852-51679050

✉️ Email: marketing@hkdsdtech.com

Deep Dive: SonarQube Plugin for Cursor – How It Works, Setup, and Enterprise Implementation Support

Dragonsoft DevSecOps — Mon, 03 Aug 2026 12:15:45 +0000

In today's landscape of ubiquitous AI coding tools, generating code quickly is no longer the challenge. The real pain point for engineering teams is generating code they can trust. As AI agents like Cursor routinely generate hundreds of lines of code at a time, deferring quality and security validation until the CI pipeline or pull request (PR) review stage exponentially increases both risk and rework costs.

To address this, SonarSource has officially launched a SonarQube plugin for Cursor, shifting deterministic code quality gates and security scanning directly into the AI coding session. As an authorized SonarQube partner, DragonSoft is here to provide an exclusive, first-look breakdown of this new plugin. We are committed to helping your engineering teams harness the full potential of AI while rigorously safeguarding your code quality and security baselines.

TL;DR overview

The SonarQube plugin for Cursor connects Cursor to a SonarQube instance via MCP Server to deliver deterministic, in-chat code quality and security verification.

This extension installs specific sonar-* skills to query quality gate status, assess dependency risks, check code coverage, and scan 450+ secret types before code generation.

Driven by the SonarQube CLI runtime, it executes Agentic Analysis to automatically analyze, surface inline findings, and apply rule-driven fixes on every file the agent touches.

The plugin enables the verify step of the Agent-Centric Development Cycle (AC/DC), resolving code quality issues immediately within the active session rather than delaying until CI/PR reviews.

What is the SonarQube plugin for Cursor?

If you're already using Cursor to write code, you've probably felt the gap between how fast the agent generates and how long it takes to find out whether the output holds up. CI catches things. PR review catches more. But neither happens in the same session that writes your code.

The SonarQube plugin for Cursor closes that gap. It connects Cursor to your SonarQube instance through the SonarQube MCP Server and installs a set of sonar-* skills into your project. From there, Cursor can query quality gate status, list open issues, check code coverage and duplication, and assess dependency risks without you ever leaving the chat. The same quality profiles and gates your organization already has in place govern every result.

One thing worth knowing if you're also using the SonarQube for IDE extension inside Cursor: the two are complementary. The extension drives real-time editor feedback through Connected Mode; this plugin drives the in-chat agent loop. They don't overlap — they stack.

How does the SonarQube plugin for Cursor work?

Setup runs through a single sonar-integrate skill after installing the plugin from the Cursor marketplace. That skill runs the sonar integrate cursor command which prompts for and wires authentication, the MCP server, hooks, an Agentic Analysis rule, and a Context Augmentation skill into the .agent/skills/ directory. It's idempotent, so re-running it reports what's already in place rather than overwriting things. Alternatively, with the SonarQube CLI already installed, all it takes is a single sonar integrate cursor command to get everything up and running.

Under the hood, the SonarQube CLI is the runtime everything depends on.

Secrets scanning on every prompt and file read. A beforeSubmitPrompt hook scans every prompt before it reaches the model. If a recognized credential pattern is detected—the plugin covers 450+ secret types—the prompt is blocked outright and never sent. A preToolUse hook and a beforeReadFile hook run the same scanner in front of file reads. When either fires a denial, the plugin also appends the file path to .cursorignore, which is what actually prevents Cursor from reaching the file on subsequent attempts.

Context Augmentation before generation. Sonar Context Augmentation delivers your coding guidelines, architectural intent, third-party dependency health, and semantic navigation to Cursor at prompt time. The agent picks this up on the first prompt of a session and carries it forward, so code generation is informed by SonarQube's view of your project from the start. (Context Augmentation is currently only available on SonarQube Cloud).

Agentic Analysis on every file the agent touches. A Cursor rule installed by sonar integrate tells the agent to run sonar analyze agentic on each file it creates or edits before ending the turn. Findings surface inline. Where a rule-driven fix is available, the agent applies it and re-runs analysis to confirm the issue is resolved before handing control back. The turn doesn't close until each remaining finding is either fixed or explicitly left open with a reason.

The result is the same closed loop the plugin delivers in other agent environments: guide with context, verify every edit, fix before the session ends.

Why should I verify code quality inside Cursor during the session?

AI models are probabilistic. The same prompt can produce different output on different days, and the same model can produce subtly different results across a long session. That makes deterministic, independent code verification essential — SonarQube produces the same result for the same code every time, giving you an auditable standard that agent self-review can't replicate.

This is the Verify step of Sonar's Agent-Centric Development Cycle (AC/DC) in practice: guide the agent with context and constraints, verify output deterministically, and solve issues in the same session. Catching a problem at the point of generation is faster and less disruptive than catching it in CI or during a PR review — and small errors compound. When an agent writes hundreds of lines before verification runs, a missed issue early can propagate through the rest of the output.

How do I set up the SonarQube plugin in Cursor?

Install the SonarQube plugin from the Cursor marketplace, open your project in a new Cursor Agent session, and run sonar-integrate in the chat. The skill walks you through authentication, scopes the integration to your project, and writes the MCP registration, hooks, rule, and Context Augmentation skill into place. Once that's done, open Settings → Tools & MCPs and toggle sonarqube on — Cursor doesn't enable MCP servers automatically after setup.

The full walkthrough, including step-by-step screenshots and a worked example using a real open source project, is in the Cursor plugin blueprint.

Accelerate with Cursor. Build trust with SonarQube. In this new era of agent-centric development, seamlessly embedding SonarQube’s deterministic validation into your AI workflow is no longer optional—it is the definitive path to efficient, secure, and compliant software delivery.

As an authorized SonarQube partner, DragonSoft is dedicated to delivering comprehensive, full-lifecycle code quality management solutions for your enterprise. Partner with us to gain:

Expert Implementation & Integration Support: We provide seamless on-premise or cloud deployment of any SonarQube edition, alongside robust integration with your existing CI/CD pipelines and AI coding tools (like Cursor).
Targeted Training & Enablement: We deliver customized training for your Engineering, Security, and DevOps teams, ensuring code quality best practices are rapidly adopted across your organization.
Dedicated Technical Support: Enjoy localized, high-priority technical assurance with rapid response times to resolve any SonarQube operational challenges your team may face.

Website: www.hkdsdtech.com

Phone: +852-51679050

Email: marketing@hkdsdtech.com

The Decision Maker’s Guide to Puppet: What is Perforce Puppet? Which Edition of Puppet is Right for You?

Dragonsoft DevSecOps — Mon, 03 Aug 2026 09:13:31 +0000

As your infrastructure expands, you need a solution that securely scales as quickly as your organization grows. In this article, Dragonsoft, an authorized Perforce partner, will guide you through the modern automation landscape to help you make the right choice for your organization, including comparisons for each edition of Puppet, from open source to enterprise-ready options.

What is Perforce Puppet

Perforce Puppet empowers people to innovate through infrastructure automation. For more than a dozen years, Puppet has led the way in IT infrastructure automation to simplify complexity for the masses in order to strengthen customers’ security posture, compliance standards, and business resiliency beyond the data center to the cloud. More than 40,000 organizations — including more than 80 percent of the Global 5000 — have benefited from Puppet’s open source and commercial solutions.

What to Consider When Choosing Automation Solutions Like Puppet

What happens when your IT matures? IT maturity can mean a lot of things, but in a digital-first world, it almost always means new problems to solve.

As your business grows, your infrastructure must evolve to keep up. Your IT teams need to strengthen security, ensure compliance, enhance observability, and stay audit-ready without sacrificing performance or reliability. Even if your IT footprint isn’t expanding, it may shift laterally, introducing complexity without adding scale. Legacy tools and technical debt can still hold you back. Regardless of how it happens, your infrastructure will face growing pains.

One thing is certain: Your IT doesn't get easier to manage on its own.

So naturally, you turn to automation to handle the expanding workloads and increased expectations. All of a sudden, you’re writing scripts, automating tasks, and saving mountains of time by keeping everything in your desired state. Automation empowers infrastructure teams to be more focused and productive and break through the limits of human scale. Soon, you can’t imagine ever doing development, operations, or DevOps differently.

But before long, those growing pains start to show up again. You find that the tools, solutions, and processes that kept your IT afloat in the past don’t cut it anymore. The security, scale, and sophistication of your IT are essential to business success, but in a fast-paced, ever-changing digital landscape, new challenges and complexity are never far behind.

The IT Automation Landscape: A Brief Overview

Broadly, IT automation solutions fall into three categories: open source automation tools, open core solutions, and enterprise platforms. Each has distinct strengths and limitations, making them suitable for different use cases. Here’s a quick comparison of Puppet offerings to support informed decision-making.

OpenSource Puppet

Open Source Puppet is freely available for organizations looking to adopt automation. It appeals to businesses with limited budgets or that have an open source-first model and the resources to build and maintain it. But open source tools have underlying costs: They require significant in-house expertise and ongoing maintenance. They also often lack rigorous security testing, which can present issues for organizations with compliance and SLA requirements.

Puppet Core

Puppet Core is designed to balance cost efficiency with security. It delivers reliable, stable, and secure software builds that are consistently updated and rigorously tested. Hardened binaries, defect support, and guaranteed SLAs reduce the burden on internal teams, letting them focus on keeping their systems running smoothly with Puppet instead of worrying about the security of their infrastructure automation solution.

Puppet Enterprise Platform

For organizations prioritizing scalability and future growth, an enterprise infrastructure automation and management platform is the go-to choice. With advanced features, enhanced integrations and capabilities, and dedicated support, the Puppet Enterprise platform is designed to ensure long-term efficiency and resiliency in large, complex environments.

Enterprise organizations benefit from the advanced capabilities of an infrastructure operations platform that scales with their needs — particularly businesses with a strong focus on security and compliance and who are unwilling to sacrifice innovation.

Puppet Products Compared

Puppet is here to support your path to more resilient IT — especially when you need to handle greater complexity, support a growing userbase, and speed up evelopment.

All editions of Puppet are built on the same proven foundation, but there are key differences to consider.

In short:

• Open Source Puppet automates and enforces desired state without cost, although maintaining it requires trained resources and involves greater manual effort.

• Puppet Core is for those who want the same hands-on control of Open Source Puppet but require hardened, stable builds with vendor-backed SLAs.

• The Puppet Enterprise platform is built for enterprise teams who need their automation to work for them — not the other way around. The AI-powered user experience and intuitive GUI interface help users get started quickly, and advanced capabilities and exclusive third-party integrations increase productivity at every level.

“The more we use Puppet Enterprise, the more we find we can do with it. Puppet Enterprise comes with many modules to help us manage our Puppet setup more easily. The open source version does not come with these modules … Every new upgrade of Puppet proves to be more innovative, and brings exciting features that we want.”——Pope Davis, Senior Director of systems Engineering, NYSE/ICE

Why Organizations Choose Puppet Core

Puppet Core builds on the powerful automation capabilities of Open Source Puppet and adds additional peace of mind for security-conscious organizations. Backed by Perforce, a trusted DevOps partner with over 30 years experience supporting global enterprises, releases undergo rigorous testing and include signed, hardened binaries. Defects can be reported via a customer portal and guaranteed SLAs ensure quick remediation for high and critical CVEs on Puppet software. Puppet Core also incorporates built-in enforcement of popular security baselines to ensure your infrastructure is continuously verified as compliant.

Why Organizations Choose the Puppet Enterprise Platform

As infrastructure grows and compliance demands intensify, organizations often outgrow the limitations of their automation tools. Whether it’s the need to scale rapidly or respond swiftly to security vulnerabilities, teams require a platform that evolves with them.

That's why many who start with Open Source Puppet or Puppet Core later transition to Puppet Enterprise: to gain the advanced features, enterprise support, and integrated capabilities that modern environments demand.

Deciding Which Puppet Solution Your Organization Should Choose

l Choose OpenSource Puppet if:

• You have minimal security and compliance requirements

• You don’t need formal SLAs for your Puppet software

• Your infrastructure is relatively simple and not spread across hybrid/cloud environments

• You don’t require the latest OS support or access to enterprise-grade agent updates

l Choose Puppet Core if:

• You need releases with secure, signed binaries

• Your team has the in-house expertise to manage infrastructure automation software

• You prefer a hands-on, code-centric approach to infrastructure management

l Choose the Puppet Enterprise platform if:

• Your IT infrastructure is large, complex, or hybrid (e.g., thousands of servers, multi-cloud)

• You want intuitive, GUI-based tools to manage the full infrastructure lifecycle

• You want to empower more team members to access infrastructure insights and take action (without needing Puppet expertise) through AI-driven, natural language interaction

• You need a solution that scales without adding operational overhead or tool sprawl

• You want seamless integration with your existing security, observability, and self-service tools

• You require centralized control for compliance reporting, vulnerability remediation, and audit readiness

• You aim to build powerful automation workflows without reinventing your toolchain

• Your organization is growing — whether through scale, expansion, or complexity

• You’re ready to simplify infrastructure management and increase operational efficiency

The Puppet Enterprise platform is the only solution that combines both model-based (declarative) and task-based (imperative) capabilities in a way that enables you to scale

your hybrid infrastructure as your automation footprint grows. With both agent-based and agentless capabilities, the Puppet Enterprise platform gives your organization the flexibility to automate what you want, how you want, wherever you want.

Next Steps: Getting Started

Ready to take the next step with Puppet?

Whether you're just beginning or expanding your automation journey, our team at Dragonsoft, an authorized Perforce partner,is here to help. We'll work with you to assess your current environment, understand your goals, and chart a clear path to a more secure, efficient, and resilient infrastructure.

Schedule a demo or connect with our team to explore the best Puppet solution for your organization.

Website: www.hkdsdtech.com

Phone: +852-51679050

Email: marketing@hkdsdtech.com

Product Overview: Perforce Delphix – Test Data Management for DevOps

Dragonsoft DevSecOps — Mon, 27 Jul 2026 02:57:28 +0000

Today, while many software development teams reap the benefits of automated coding, they find themselves slowed down by traditional test data management (TDM). Manual requests, ticketing queues, stale data, and compliance gaps—these conventional TDM approaches are fundamentally at odds with modern DevOps practices, severely dragging down both developer productivity and software quality.

How can you break through the data bottleneck and accelerate software delivery? You need a modern, DevOps-ready test data management solution: Perforce Delphix.

In this article, DragonSoft—an authorized Perforce partner—explores how Delphix leverages an API-first architecture to seamlessly integrate data delivery into CI/CD pipelines. Discover how this helps your team power millions of monthly CI/CD runs and ship higher-quality software, faster.

Digital Transformation Requires a Modern Approach to TDM

Traditionally, organizations have gained economies of scale by centralizing test data management (TDM), often through the use of tools that subset, mask, and synthesize test data. However, with the adoption of DevOps, a new set of challenges has emerged. In particular, many software development teams still rely on a manual, ticket-driven request-fulfill model in which developers and testers often find their requests queuing behind others. These manual, legacy TDM approaches are completely incongruent with modern DevOps practices and CI/CD processes that depend on API-driven automation and fast feedback to development teams.

As a result, many of the DevOps benefits related to developer productivity and software quality remain constrained by slow, stale, and low quality test data. To address modern challenges, DevOps teams must expand past legacy TDM practices and automate data delivery to CI/CD pipelines via unified APIs.

Deliver Realistic, Compliant Test Data in Minutes Not Days

Delphix provides an API-first DevOps TDM solution for multi-cloud environments that combines continuous data compliance with continuous data delivery. Ephemerally delivering compliant data into unlimited parallel test environments unlocks Dev/Test/QA teams to build and run more exhaustive unit and integration tests without blocking shared data resources for adjacent teams. Administrators can also identify and protect sensitive data before provisioning to users through integrated data masking. Finally, the Delphix DevOps Data Platform provides software development and testing teams with data APIs—including the ability to refresh, rewind, bookmark, group, tag, branch, and share test data—to accelerate DevOps productivity and improve application quality.

Features

Sync with Any Test Data Source
Delphix works across all clouds and apps, synchronizing with multi-generational data sources to capture a complete record of data changes.
• Non-disruptive, continuous sync
• Connect to production data sources, backups, and staging replicas
• Efficiently store data with 100x space efficiency

Easily Manage & Distribute Data
Efficiently version and distribute datasets to non-production environments.
• Instantly deploy enterprise data with greater cost-performance & speed
• Quickly sync, version, and distribute compliant datasets
• Easily deliver versioned datasets to anywhere in the multi-cloud enterprise

Simplified Data Compliance
Automatically identify and mask sensitive data values to meet compliance for GDPR, CCPA, HIPAA, and more.
• Preserve referential integrity
• Produce realistic values for testing
• Predefined and customizable masking algorithms

Transform Environments to Test at DevOps Speed
Use APIs to refresh to the latest data, rewind for cleanup, branch datasets, bookmark, and version data alongside code.
• Integrate data delivery into CI/CD pipelines
• Clean up data following destructive testing
• Spin up/down ephemeral environments

Open and Extensible
Delphix provides APIs to manage data operations across multi-generational multi-cloud environments.
• Comprehensive set of REST APIs
• Integrate with CI/CD and monitoring tools
• Continuously sync with production data and refresh downstream

Key Benefits

Double Project Velocity
Automatically provision fresh, compliant, and complete production datasets. Run exhaustive unit and integration tests in parallel improving test speed so teams can collaborate with fast feedback.
Improve Software Quality
Masked production data maintains real data handling situations for developers to exhaustively test their code and catch potential defects before production.
Achieve Compliance
Identify and protect sensitive data in test environments to meet compliance with GDPR, CCPA, HIPAA, and other privacy laws.

How to Get Started with Perforce Delphix?

Experience how Perforce Delphix can unlock the full potential of your data. As an authorized Perforce partner, DragonSoft provides comprehensive Delphix consulting and technical support services to help enterprises accelerate data-driven DevOps transformation.

● In-Depth Scenario Consulting
Our technical experts will gain a deep understanding of your current DevOps environment and data challenges, then design a tailored solution covering the entire process—from data source synchronization and data masking strategies to CI/CD pipeline integration.

● Localized Implementation and Support
With rapid response capabilities, we support your journey from PoC validation to production deployment, ensuring seamless integration between Delphix, your multi-cloud architecture, and existing toolchains.

● Continuous Enablement and Optimization
We provide team training, best practice guidance, and long-term technical support to help your teams fully leverage data API capabilities and enable Delphix to continuously drive DevOps efficiency improvements.

Don't let slow, outdated test data continue to hold back your release cycles. Contact DragonSoft today to get your exclusive Perforce Delphix solution and product demo:

Website: www.hkdsdtech.com
Phone: 852-51679050
Email: marketing@hkdsdtech.com

DragonSoft Jira Add-on | WorkflowWise v2.12.1 Released: More Flexible Approval Strategies and Smoother Cloud Migration Paths

Dragonsoft DevSecOps — Mon, 27 Jul 2026 02:41:51 +0000

Recently, DragonSoft’s independently developed Jira core extension Add-on — WorkflowWise - Parallel Approval and Workflow Extension — has released a major update, with both the Data Center and Cloud editions upgraded simultaneously to v2.12.1.

This release focuses on two key areas: more flexible approval rule configuration and seamless enterprise migration to the cloud. Through a more intelligent workflow engine, WorkflowWise helps organizations handle complex business scenarios with greater agility while supporting their cloud transformation strategies.

Release Highlights: Two Major Feature Enhancements

1. Enhanced Approval Threshold Control (Based on User Count and Percentage)
In version 2.12.1, we redesigned the approval condition evaluation engine. Administrators can now configure approval thresholds based on both number of approvers and approval percentage when setting up approval steps. This allows approval workflows to move beyond rigid system constraints and better align with real-world business decision-making scenarios.

Through flexible rule combinations, organizations can easily implement common approval strategies, including:

· Single Rejection Rule (Veto Approval): Configure the rejection condition as “Number of Rejections ≥ 1.” Any single approver’s rejection can immediately reject the entire request, making it ideal for high-risk scenarios such as security compliance and financial approvals.

· Unanimous Approval: Set the approval condition to “Approval Percentage ≥ 100%,” requiring all approvers to approve before proceeding. This ensures critical decisions are fully aligned.

· Majority-Based Decision Making: Set the approval condition to “Approval Percentage ≥ 50%,” enabling agile collaboration scenarios such as technical review committees and product requirement reviews while balancing efficiency and consensus.

2. Seamless Migration Support from Data Center to Cloud
As Atlassian continues to accelerate its cloud-first strategy, more enterprises are planning migrations from Data Center to Cloud editions. To support this transition, WorkflowWise Data Center Edition introduces a dedicated DC-to-Cloud Migration Export Center. The system can now generate fully compatible Cloud migration configuration packages and approval history packages with one click.

Key migration improvements include:

· Intelligent Filtering to Prevent Migration Errors: The system automatically identifies and filters complex rules that cannot be seamlessly migrated to Cloud environments, such as certain script-based conditions, preventing migration failures at the source.

· Batch Export to Avoid Timeout Issues: For enterprise customers with large volumes of historical data, WorkflowWise supports exporting historical approval records in time-based batches, effectively resolving timeout challenges during large-scale data exports.

Migration Recommendation: Since cross-platform migration involves changes to underlying data structures, we strongly recommend testing migration packages in a sandbox environment before importing them into your production Cloud environment. This helps validate the compatibility of JQL queries, custom permission rules, and other configurations in advance, ensuring business continuity.

Who Should Consider This Upgrade?

● Jira Administrators Leverage the new threshold-based approval rules to easily configure approval workflows that match complex enterprise governance requirements. For organizations planning a Data Center-to-Cloud migration, the new migration export center helps reduce implementation risks and operational workload.

● Project Managers and Product Managers Dynamically adjust approval ratios based on team size and business requirements, eliminating the need for frequent workflow modifications caused by organizational changes and improving configuration flexibility.

● Enterprise Architects and Operations Leaders Use segmented historical approval data exports to support compliance archiving and governance requirements during migration projects.

● Security and Compliance Teams Implement veto approval mechanisms at critical approval checkpoints, ensuring high-risk operations receive review from designated roles before execution and better meeting compliance requirements.

How to Get and Upgrade WorkflowWise

WorkflowWise v2.12.1 is now available. Visit DragonSoft’s official Atlassian Marketplace page to access the latest version and view complete release notes and configuration guides.

→Get or Update Now:

WorkflowWise - Parallel Approval and Workflow Extension (Atlassian Marketplace)

→Professional Technical Support:

If you need assistance with configuring new approval thresholds, evaluating cloud migration strategies, or using WorkflowWise, DragonSoft’s expert team is ready to provide one-on-one consulting and implementation support.

Continue Enhancing Your Atlassian Investment with DragonSoft Add-ons
As an Atlassian Platinum Partner, DragonSoft continues to develop enterprise-grade Add-ons compatible with both Data Center and Cloud environments. We also provide customized development and Add-on development services to meet the diverse business needs of customers worldwide.

Explore DragonSoft’s popular Atlassian Add-ons:

DragonSoft | Atlassian Marketplace

The release of WorkflowWise v2.12.1 represents another important product evolution driven by customer feedback and continuous improvement. Whether you are looking to make approval decisions better aligned with business logic or planning your cloud migration journey, this update is designed to help you manage Jira workflows more efficiently and confidently.

*Contact DragonSoft today to upgrade and experience more streamlined approval management and smoother cloud migration.
*
Website: www.hkdsdtech.com

Phone: 852-51679050

Email: marketing@hkdsdtech.com

ITSM Guide | Jira Service Management Standard vs. Cloud Premium Comparison and Upgrade Guidance

Dragonsoft DevSecOps — Mon, 27 Jul 2026 02:34:48 +0000

Enterprise expectations for IT service management have long moved beyond the scope of traditional “ticketing systems.” Collaboration barriers between development, operations, and business teams, increasingly complex change management processes, and the growing frequency of security incidents are driving organizations to seek a service management platform that is more agile, intelligent, and scalable.

As a Platinum Solution Partner of Atlassian, **DragonSoft **has a deep understanding of the challenges and requirements Chinese enterprises face throughout their service management transformation journey. We have witnessed numerous customers begin their evolution with Jira Service Management Standard and gradually advance toward higher levels of service management maturity. Jira Service Management Cloud Premium represents a critical milestone in this journey. With capabilities including AIOps-powered intelligent operations, automated change management, advanced incident response, and robust asset management, Premium provides comprehensive support for building an end-to-end, high-speed service management framework.

So, what makes Premium significantly more powerful than Standard? Which advanced capabilities can truly help your teams improve efficiency and drive greater business value?

Jira Service Management Cloud Premium offers a complete, modern platform that scales.

Upgrade to Premium for a platform that empowers high velocity service management, from request intake to incident resolution, for all of your teams: DevOps, IT, HR and customer service.

Automated change management. Advanced incident resolution. Accelerated AIOps. Robust asset management. With Jira Service Management Cloud Premium, you get the tools your team needs to accelerate incident resolution and modernize service management at scale. Your organization gains:

Modernize end-to-end service management —

Deliver exceptional service experiences with advanced capabilities to streamline request intake, accelerate incident response, deploy changes faster, and more – all on a single platform.

Accelerate incident resolution with AIOps —

Enable Dev and Ops teams to intelligently detect, resolve, and prevent incidents to deliver high-performing services at scale. Reduce alert fatigue and swarm on incidents more efficiently with AI-powered alert grouping, incident creation, and PIR generation.

Securely scale service management —

Empower your admins with added controls and security safeguards. Provide teams with the keys to build and customize their own services using no-code capabilities within an IT-regulated environment.

60,000 customers trust Jira Service Management.
Leader in the 2024 Gartner Magic Quadrant™ for DevOps Platforms.
Leader in 2023 Forrester Wave for Enterprise Service Management.

Unlock high velocity service teams.

Whether you're just getting started, or looking to switch to a faster, more flexible ITSM solution, Jira Service Management has all the features your team needs to deliver great service, fast on the same platform where developers and business teams already work.

Over 55,000 customers worldwide trust Jira Service Management to help them centralize and resolve service requests, respond to incidents, streamline changes, collect and maintain knowledge, manage assets and configuration items, and more.

With intuitive workflows and the ability to work autonomously, Jira Service Management unlocks high-velocity service teams across the business, not just within IT.

Jira Service Management is built on Atlassian's unified cloud technology platform that powers open and efficient collaboration between teams, information, and workflows across your enterprise.

Atlassian's System of Work makes it easy for all teams in any organization to work together, fast. Jira Service Management is a key component. Give your teams a central view of their work and use integrations across the Atlassian portfolio and over 5,000 third party tools to make work flow.

"Jira Service Management has allowed us to centralize our information into one point, making it easy to perform queries or searches, or even simply run reports." — ANDREW TOOLAN, SOFTWARE ENGINEER, CANVA

See how Jira Service Management Cloud Premium stacks up.

Jira Service Management Cloud Premium is equipped with the advanced capabilities you need for modern IT service management. Compare with our Standard to see why it's the perfect time to upgrade.

Moving from Standard to Premium is not simply an accumulation of features—it represents a fundamental transformation in service management philosophy, evolving from reactive support to proactive prevention and intelligent enablement. Whether your team is struggling with incident response efficiency or looking to automate change management within a compliant framework, Jira Service Management Cloud Premium provides ready-to-use solutions designed to address these challenges.

Why Choose DragonSoft as Your Upgrade Partner?

● Deep Expertise in the Atlassian Ecosystem DragonSoft is an officially certified Atlassian Solution Partner with extensive experience in Jira Service Management implementation, migration, and upgrades. We have supported customers across a wide range of industries, including finance, manufacturing, internet services, and automotive.

● Localized Professional Services We provide technical consulting, solution design, and implementation support in both Chinese and English, eliminating communication barriers caused by language and time zones while ensuring seamless collaboration throughout the project.

● End-to-End Delivery Capabilities From requirements analysis and solution design to data migration, go-live training, and ongoing operations support, DragonSoft delivers full-lifecycle services through a one-stop approach, enabling your team to adopt the platform quickly and transition smoothly.

● Customized Best Practices We do more than provide licenses. By combining our expertise with your specific business scenarios, we help you maximize the value of Premium’s advanced capabilities—including AIOps, automation, and asset management—to unlock the full potential of modern service management.

Contact the** DragonSoft** team today to receive a complimentary upgrade assessment and a tailored solution plan. We will help you fully leverage the capabilities of Jira Service Management Cloud Premium and empower your business with more efficient, intelligent operations.

Website: www.hkdsdtech.com

Phone: 852-51679050

Email: marketing@hkdsdtech.com

Stop Waiting for Redeploys: How JRebel Keeps Java Developers in the Flow State

Dragonsoft DevSecOps — Mon, 29 Jun 2026 07:58:41 +0000

In the era of microservices and containerized environments, the "redeploy" cycle has become the silent killer of developer productivity. With 54% of Java developers reporting redeployment times of over five minutes, the friction is real. In this post, we explore the architectural challenges behind this trend and discuss how JVM plugins like JRebel can streamline the inner loop, allowing for instant code changes without the need for full redeployments.

Let's discuss how to reclaim your coding time.

Executive Summary

Java development environments are more complex than ever, and these complexities are creating barriers to innovation.
As your business looks to do more with less in 2025, keep these tenets in mind:

Enterprise development environments are growing more complex, leading to lower productivity for development teams.
Many Java teams are hesitant to add development staff in 2025, which makes arming these teams with the right productivity tools critical to achieving ever-expanding business requirements.

Read on for actionable insights for easing complexity and improving developer experience by incorporating the right Java tools.

The State of Enterprise Java Development

There’s a reason that Java is regarded as the stable backbone of business applications across industries. As the development language turns 30 this year, the ecosystem behind the language is as vibrant as ever. That’s a testament to the calculated evolution and continued investment that has kept Java so relevant for three decades running.

But that vibrant ecosystem comes as a double-edged sword: Enterprise Java development environments are more complex than ever.

Microservices may not be living up to their billing of efficiency. More and more developers are turning to more than one IDE as a part of their day-to-day development workflow. Cloud development environments — while popular for the flexibility they afford — are causing remote redeploy times to skyrocket.

These obstacles can put up barriers in developers’ workflows and limit a company’s ability to innovate. But with the right focus on developer productivity (and the right tools to back up that strategy), enterprise companies can carve out whitespace to innovate amid the complexity. Read on to discover how.

Understanding the Makeup of Enterprise Java Tech Stacks

To understand the development challenges faced by businesses that rely on Java, it’s important to understand the makeup of their development environments. In our recent survey of enterprise Java teams, we found ongoing shifts ranging from distribution selection, to architectural approaches, to IDEs.

Due to pricing pressure from commercial JDK distributions like Oracle Java, we’re seeing more and more enterprises every year choosing to use open source Java distributions like OpenJDK. With that shift, we’re also seeing most enterprises migrating to long-term support versions — ensuring that they have a secure and supported foundation for their applications.

At an architectural level, enterprise Java teams are continuing to lean into microservices-based architectures. Unfortunately for many teams, the move to microservices hasn’t resulted in decreased complexity or significantly faster redeploys.

As we note in a later section, microservices-based applications have a way of growing more complex over their lifespan — moving from a set of loosely-connected services to a big ball of mud. For enterprises still working with monolithic applications, that reality isn’t any better.

In 2025, we’ve noted that redeploy times for enterprise Java development environments have lengthened — showing that there will be development hurdles no matter which route you take.

Empowering development teams to overcome these hurdles — whether that’s with tools or improved processes — is critical.

Key Stats on Enterprise Java Tech Stacks

68% of enterprise Java developers say security is an important factor for upgrading JDK versions.
47% of enterprise Java developers use more than one IDE in their day-to-day workflows.
73% of enterprise Java developers are using remote, containerized, or cloud-based development environments.
54% of enterprise Java developers say that redeploys for remote development environments take 5 minutes or more.
21% of enterprises aren’t using cloud development environments, whether due to costs, regulations, security concerns, or other reasons.

Why Developer Experience Matters

Developer experience is the practice of eliminating friction in a developer’s workflow. This can take many forms, from implementing productivity teams to investigate and implement tools, to offering developers freedom to construct their individual development environments in the way they see fit.

And while developer experience may not seem like it contributes to the bottom line, happier developers write better code. More specifically, developers who can spend more time doing what they want to be doing, i.e., writing quality code, will produce better code more quickly.

Principles of crafting good developer experience can also be translated from IDEs and architecture types to developers’ toolsets.

Take AI tools, for instance. While AI may purport to do developers’ jobs for them, using such tools — especially in their infancy — can sometimes create more friction than freedom. Developers may spend more time trying to write a perfect prompt or correct an error than it would have for them to complete the task unassisted.

Improving developer experience through Java tools requires investing in the right tools that improve developer experience without adding overhead.

Now Is the Time to Invest in Java Tools

While headlines report widespread hiring freezes, 58% of enterprise Java users said their companies plan to add developer headcount in the coming year. That stat is heartening considering that economic headwinds continue to shift. But the undercurrent is concerning; 32% were unsure of hiring plans for the coming year and 9% were not planning to add headcount.

Java leaders are looking for solutions that can help fill the gap without the costs of adding an additional full-time developer. That’s where Java development tools come in. 36% of enterprise respondents said they expect to increase their Java development tool budget in 2025 and 51% are unsure. But our Java experts believe those numbers should be higher.

Why? 26% of enterprise developers say that insufficient developer tools are their biggest barrier to developer productivity. Java tools don’t replace a full-time developer, but the right tools can foster efficiency in enterprise development environments no matter how many developers are in seat — now or in the future.

Enterprises Demand Purpose-Built Development Tools

Enterprise developers and leaders value robust, enterprise-grade development tools — and the data backs that claim.When asked what AI tools they turned to, 52% selected GitHub CoPilot, whereas respondents from smaller companies favored ChatGPT*. This cohort recognizes the value of investing in robust, purpose-built development tools to improve their team’s productivity.

Many developers are finding that free tools don’t offer the support or integration they need for complex enterprise environments. Investing in purpose-built development tools yields dividends in increased productivity and reduced friction.

Recommendations for Decision Makers

Enterprise leaders play a critical role in setting their Java development teams up for success. Here are actionable recommendations to overcome complexity in your enterprise Java development environment and enhance the developer experience.

1.Invest in Developer-Centric Tools
Evaluate and adopt tools that solve specific bottlenecks, such as long redeploy times that break developer flow or fragmented environments that add hurdles. Solutions like JRebel can significantly improve developer productivity by helping developers stay focused.

2.Automate Tasks Where Possible
Automate repetitive tasks such as testing,deployment, and error detection using AI-powered tools. This allows developers to focus their time on coding.

3.Support Individuality in Developer’s Workspace
Empower your developers to choose tools and configurations that align with their individual workflows. Allowing flexibility in IDEs or plugins enhances the developer experience and improves productivity.

4.Make Developer Experience a KPI
Create cross-functional productivity teams to continually assess tools, test new possibilities, and optimize workflows based on developer feedback.

5.Track ROI for Developer Tools
Developer tools only help ease enterprise development environment complexity if developers actually use them. Teams should look for tools that offer real-time ROI reporting, or, for teams with more developer productivity groups, consider investing in a platform that consolidates productivity metrics across the breadth of your productivity toolset.

How JRebel Can Ease Java Development Environment Complexity

JRebel is a JVM plugin that enables users to visualize code changes instantly while maintaining application state.This enables Java developers to test code more frequently so your business can boost code quality and go to market faster. Developers also stay in “flow state,” i.e., they keep coding instead of checking email and grabbing coffee.

A few minutes here and there spent waiting on redeploys might not seem like a huge issue, but when extrapolated over an entire enterprise Java development team of 100+ Java developers, those minutes can quickly add up to months of development time wasted waiting.

With JRebel, your team can:

Accelerate time to market and increase code quality.
Integrate with all aspects of your Java development environment, including all popular cloud providers and IDEs.
Provide real-time reporting on ROI across your development team.

Enterprise Java development environments are complex enough; your tools shouldn’t be. Fortunately, JRebel integrates directly with all popular IDEs (including IntelliJ IDEA, VS Code, and Eclipse), and all popular cloud providers (including AWS, Microsoft Azure, and Google Cloud Platform).

Developers test code more frequently when they’re not hindered by long redeploys. With JRebel, developers aren’t tempted to batch code changes in an effort to save time. Visualizing code changes instantly with every small tweak helps developers write better code in less time.

Final Thoughts

Enterprise Java development environments are more complex than ever before, but with the help of the right Java development tools, your team can still innovate. By leveraging modern Java development tools and prioritizing the developer experience, enterprises can overcome the challenges of slow workflows, fragmented tools, and high turnover.

Improving developer productivity is an investment in your team’s ability to innovate and thrive in today’s complex enterprise Java environments.

About Perforce JRebel

Perforce JRebel is a Java developer productivity tool that allows developers to view code changes instantly and skip redeploys while maintaining application state. JRebel is trusted by leading brands worldwide to help Java developers write better code, faster.

Let’s find the perfect solution for your team — request a personalized JRebel quote today.

Make code changes instantly visible and say goodbye to redeploy wait times in Java development!

Dragonsoft is dedicated to helping enterprises eliminate friction within their development toolchains and build efficient, modern R&D systems. As an authorized Perforce Partner, we go beyond providing enterprise-grade licensing for JRebel; we offer comprehensive, end-to-end services encompassing consulting, evaluation, deployment, training, and technical support.

Whether you are looking to adopt JRebel to solve the bottleneck of long redeploy times in microservices and cloud environments, or planning to scale up your Java team's delivery speed and code quality across the enterprise, Dragonsoft delivers customized best-practice solutions tailored to your unique needs.

JetBrains Junie GA Release: Bridging IDE Toolchains with Agentic AI

Dragonsoft DevSecOps — Mon, 29 Jun 2026 07:56:43 +0000

In daily development, many AI coding assistants confidently write code in the wrong direction, forcing developers to waste significant time on subsequent reviews and troubleshooting. JetBrains' official AI coding agent, Junie, is dedicated to cracking this problem with remarkable results—it recently secured the number-one spot on the authoritative SWE-Rebench coding agent benchmark.
Junie has now officially left its Beta phase and is generally available. As a professional DevSecOps solution provider and an authorized JetBrains Partner, Dragonsoft provides an in-depth analysis of the heavyweight upgrades in Junie's official release:
It not only minimizes invalid executions and wasted tokens through an advanced "plan before coding" mode, but also directly drives the native IDE debugger for breakpoint troubleshooting, and performs code reviews while maintaining complete project context. Additionally, Junie supports a flexible, vendor-lock-in-free model strategy, empowering developers to utilize either frontier models or local runtimes.

Junie started as an experiment. We asked, “What if an AI coding agent didn’t just guess at the details of your project, but actually used the same tools you do?” Over the last year, that experiment turned into a product used by developers every day – inside the IDE and the terminal.

Today, the JetBrains AI coding agent is leaving Beta. This isn’t a rename or a repackage. The parts of Junie that matter most are stable, connected, and ready for real work. Junie plans before it codes, debugs with the real debugger, reviews PRs while considering your project’s context, and runs long tasks while you focus on other things.

On the latest run of SWE-Rebench – an independent agent benchmark – Junie placed as the number-one coding agent.

“SWE-Rebench draws fresh tasks each cycle to keep the evaluation honest, so results move from run to run. In this cycle Junie came out as the top model-harness, with 61.6% resolved and a 72.7% pass@5 — placing it ahead of the other agents and competitive with raw frontier models”
Alexander Golubev Research Lead at Nebius

We believe that delegating work to an agent should be something you can afford to do often, not just for heroic one-offs. Thus Junie supports any model, without lock-in – and that’s how you control cost. Use the latest models from frontier labs from day zero, or point Junie at a local runtime. It’s the lever that lets you decide what each task costs. Top-tier reasoning models are powerful but expensive; smaller models are fast and cheap. Junie lets you put each one where it does the most good. Cost efficiency stops being a property of the tool and becomes a dial you hold.

Here’s what comes with the move to general availability:

Advanced Plan mode: The agent thinks before it codes

One of the most common causes of failure in AI coding agents is unwavering confidence when they are totally incorrect – they start implementing before anyone has agreed on what they’re doing. You end up reviewing a PR that solves the wrong problem or burning tokens on a path you would have rejected in the first thirty seconds.

Plan mode fixes that by making the plan a first-class artifact.

Before Junie writes code, it produces a structured document with tabs for product requirements, technical design, delivery stages, and (when requested) testing strategy. You read the doc. You edit it directly in your editor. You approve it. And then Junie implements it.

This approach is superior to “better prompting”, for a few reasons:

The plan is a real document. It lives in .junie/plans. You can commit it, and it becomes living task documentation, not a throwaway chat message.
The agent asks the right questions. When requirements are ambiguous, Junie asks multiple-choice and freeform questions to pin things down, instead of guessing and hoping.
Junie plans before it codes – meaning fewer wasted tokens and fewer broken PRs. Every wasted implementation run is tokens you paid for and a review cycle you’ll have to do anyway. Plan on a strong model; implement on a cheap one. The agent doesn’t wander, so your bill stays low.

Enter Plan mode with Shift+Tab. Open the plan with Ctrl+P. And when you’re ready, hit Confirm to implement the changes.

Agentic debugging: Junie uses the debugger, not println

When something goes wrong, most coding agents add log statements. Junie opens the debugger.

With the GA version, Junie can drive your IDE’s debugger the way you would:

Start or join a debug session. Junie can launch a run configuration, debug a test, or take over an existing session you already have open.
Set breakpoints anywhere that matters, including project code, library code, SDK code – even decompiled .class files and sources inside JARs. If your IDE can step into it, Junie can set a breakpoint in it.
Inspect the real runtime state. Stack frames, thread state, expression evaluation, run-to-line – Junie collects actual evidence instead of theorizing about what your code might be doing.

This allows Junie to use debugging patterns that you previously had to work with manually:

“Debug and figure out why this test fails only on the second iteration.” Fully autonomous – Junie drives the whole thing.
“Prepare the debugger, I’ll trigger the UI flow.” Junie sets up breakpoints and waits for you.
“Continue my current debug session and tell me why this value becomes null.” Hand off routine inspection work while you think about the bigger picture.

Today this works end to end in JetBrains IDEs with an AI subscription.

Remote control: Start a task, and keep an eye on it from anywhere

Some work doesn’t fit in a focused 30-minute session, for example a Spring Boot upgrade, a migration to Java records, or adding test coverage to a legacy service. These are exactly the tasks autonomous agents are good at – and it’s even better when you don’t have to sit and watch.

Start a task from your laptop. Check progress from your phone during a meeting. Review the PR over coffee. Junie runs asynchronously and keeps the session available from anywhere you sign in.

Code review without lost context

Most review tools see your codebase for the first time when the PR opens. Junie reviews with the same project context it uses to write code: your build, your tests, your conventions, your past decisions.
Three entry points. Trigger a review from GitHub Actions or GitLab (including on-prem), or by using the /review command in the CLI or the plugin. Set the scope to unstaged changes, staged changes, or a diff against main – your call.
Interactive walkthrough. Junie highlights each meaningful change, explains the design decision behind it, and gives you accept/reject controls inline. Drop a PR comment on the spot when something looks wrong.
Adaptation to your focus. Ask a follow-up question and Junie reorders the remaining review around what you care about, instead of marching through files alphabetically.

Deep IDE integration: An AI coding agent that uses your IDE’s tools

Junie has always worked inside JetBrains IDEs. Earlier this year we showed you how to connect it. In Junie’s GA version, we’ve rebuilt that integration on top of ACP (the Agent Communication Protocol), the same protocol Junie CLI uses to talk to your IDE.

One engine, many surfaces. The same agent is behind the AI chat, the dedicated Junie tool window, and Junie CLI. Improvements ship once and show up everywhere.
Your IDE, the agent’s toolbox. Junie uses your IDE’s semantic index, build configurations, test runners, and debugger, not its own approximation of them.
Database integration. Junie connects to the databases configured in your IDE through DataGrip and the JetBrains Database plugin, and then it queries your real data and writes, fixes, and validates SQL in the same session that handles your code.

What this adds up to Individually, each of these features solves a specific problem. Together, they change what an agent is for.

An agent that understands your project, lets you approve the work before doing it, runs it while you’re doing something else, debugs it properly when things break, reviews your PRs with the full project context, and queries your real data – that’s an agent you can actually delegate to.

That’s the bar we set for leaving Beta.
Getting started

Junie is available in all JetBrains IDEs and through Junie CLI in your terminal. If you already have a JetBrains AI subscription, everything works out of the box.
Bring Your Own Key works too – enjoy access to Anthropic, OpenAI, Google, and others.
Junie connects to local model runtimes – point it at LiteLLM, LMStudio, Ollama and the agent runs using whatever model you have loaded on your own machine. Prompts and code never shared externally.

Install Junie, open your project, and test it out on a real task (maybe one you’ve been procrastinating on).

Then tell us what broke, what surprised you, and what you’d like to see next. Every feature above came from that feedback loop, and it doesn’t end with the move to GA.

Seamlessly integrate cutting-edge AI technology into your enterprise R&D pipeline!

Dragonsoft is dedicated to helping enterprises build secure, efficient, and modern R&D automation systems. As an authorized JetBrains Partner, we go beyond merely providing enterprise-grade licensing for JetBrains products. We offer comprehensive, end-to-end services encompassing consulting, evaluation, deployment, training, and technical support.

Whether you are looking to adopt JetBrains AI to unleash developer productivity or planning to scale standardized, automated AI coding workflows across your organization, Dragonsoft delivers customized best-practice solutions tailored to your unique needs.