We caught up with Haishi Bai, Principal Architect at Microsoft, whose career has been shaped less by a traditional path in automotive and more by a lifelong commitment to learning and open source innovation. Known for his contributions to Eclipse SDV projects like Eclipse Symphony and, of course, his talks and mentorship at the Eclipse SDV Hackathons, Haishi has spent the past decade immersed in open source communities, driving tools that empower developers worldwide. Influenced by a problem-solving mindset formed during his education in China, and guided by the belief that passion should lead one’s work, he continues to approach every challenge as an opportunity to build something meaningful.

When and how did you start your career in automotive?

I actually never started a formal career in automotive. I still see myself as a student of the industry: learning continuously while contributing through open source initiatives like Eclipse Symphony.

 How has open source software influenced or changed your work and career?

Open source has shaped almost everything I do. For the past decade, I’ve worked almost exclusively on open source projects. It’s been an exciting and rewarding journey, helping kick off projects like DAPR, KEDA, Copecetic, Eclipse Symphony, and others. Seeing these tools grow and support developer communities has been one of the most fulfilling parts of my career.

 What has been your #1 benefit of joining the Eclipse SDV Working Group?

For me, it’s the learning experience. Through the Working Group, I’ve had the chance to meet OEMs, developers, entrepreneurs, and visionaries from around the world. Every conversation teaches me something new.

Image

What’s your 1-sentence pitch for Eclipse Symphony – why is it worth getting involved in the project?

A platform-agnostic workload orchestrator designed to manage workloads across cloud and highly heterogeneous edge environments.

 How would you describe Eclipse SDV in three hashtags?
#OpenInnovation #SoftwareDefinedFuture #GlobalCollaboration 

“Open source has shaped almost everything I do.”

What first got you interested in technology or software development growing up in China?

In middle school, I was part of the math team, and we were given access to the school computer lab. The moment I saw the blinking green cursor, I was hooked. The idea that you could build an entire universe with just code was almost ethereal to me – and that feeling has stayed with me ever since.

Were there particular experiences in your education in China that influenced your approach to problem-solving?

China’s education system is excellent at developing engineers. I was trained to think objectively, work systematically, and use data-driven decisions to solve complex problems. At the same time, the environment also encourages pushing for excellence while finding creative ways to tackle seemingly impossible goals.

“The idea that you could build an entire universe with just code was almost ethereal to me.”

Are there values from your upbringing that guide your work or career decisions today?

One value that has always stayed with me is that you’re truly living only when you pursue what you’re passionate about. Otherwise, you’re just surviving. I feel incredibly fortunate to make a living doing what I love, and that mindset helps turn challenges and difficulties into exciting adventures. It keeps me reaching for harder, more meaningful problems to solve.

Image

 

Previous SDV committer interviews:

Luca Cominardi (Eclipse Zenoh)

Frank Märkle (Eclipse OpenDUT)

Kerstin Keller (Eclipse eCAL)

Elena Gantner (Eclipse S-CORE)

Michael Engel (Eclipse BlueChi)

Nhan Luong (Eclipse Autowrx)

Diana Kupfer

Wed, 2025-12-10 07:20

This article is a sponsored by Accessible UX Research

Smashing Library expands again! We’re so happy to announce our newest book, Accessible UX Research, is now available for download in eBook formats. Michele A. Williams takes us for a deep dive into the real world of UX testing, and provides a road map for including users with different abilities and needs in every phase of testing.

But the truth is, you don’t need to be conducting UX testing or even be a UX professional to get a lot out of this book. Michele gives in-depth descriptions of the assistive technology we should all be familiar with, in addition to disability etiquette, common pitfalls when creating accessible prototypes, and so much more. You’ll refer to this book again and again in your daily work.

This is also your last chance to get your printed copy at our discounted presale price. We expect printed copies to start shipping in early 2026. We know you’ll love this book, but don’t just take our word for it — we asked a few industry experts to check out Accessible UX Research too:

“Accessible UX Research stands as a vital and necessary resource. In addressing disability at the User Experience Research layer, it helps to set an equal and equitable tone for products and features that resonates through the rest of the creation process. The book provides a solid framework for all aspects of conducting research efforts, including not only process considerations, but also importantly the mindset required to approach the work.

This is the book I wish I had when I was first getting started with my accessibility journey. It is a gift, and I feel so fortunate that Michele has chosen to share it with us all.”

Eric Bailey, Accessibility Advocate

“User research in accessibility is non-negotiable for actually meeting users’ needs, and this book is a critical piece in the puzzle of actually doing and integrating that research into accessibility work day to day.”

Devon Pershing, Author of The Accessibility Operations Guidebook

“Our decisions as developers and designers are often based on recommendations, assumptions, and biases. Usually, this doesn’t work, because checking off lists or working solely from our own perspective can never truly represent the depth of human experience. Michele’s book provides you with the strategies you need to conduct UX research with diverse groups of people, challenge your assumptions, and create truly great products.”

Manuel Matuzović, Author of the Web Accessibility Cookbook

“This book is a vital resource on inclusive research. Michele Williams expertly breaks down key concepts, guiding readers through disability models, language, and etiquette. A strong focus on real-world application equips readers to conduct impactful, inclusive research sessions. By emphasizing diverse perspectives and proactive inclusion, the book makes a compelling case for accessibility as a core principle rather than an afterthought. It is a must-read for researchers, product-makers, and advocates!”

Anna E. Cook, Accessibility and Inclusive Design Specialist

About The Book

The book isn’t a checklist for you to complete as a part of your accessibility work. It’s a practical guide to inclusive UX research, from start to finish. If you’ve ever felt unsure how to include disabled participants, or worried about “getting it wrong,” this book is for you. You’ll get clear, practical strategies to make your research more inclusive, effective, and reliable.

Inside, you’ll learn how to:

• Plan research that includes disabled participants from the start,
• Recruit participants with disabilities,
• Facilitate sessions that work for a range of access needs,
• Ask better questions and avoid unintentionally biased research methods,
• Build trust and confidence in your team around accessibility and inclusion.

The book also challenges common assumptions about disability and urges readers to rethink what inclusion really means in UX research and beyond. Let’s move beyond compliance and start doing research that reflects the full diversity of your users. Whether you’re in industry or academia, this book gives you the tools — and the mindset — to make it happen.

High-quality hardcover, 320 pages. Written by Dr. Michele A. Williams. Cover art by Espen Brunborg. Print edition shipping early 2026. eBook now available for download. Download a free sample (PDF, 2.3MB) and reserve your print copy at the presale price.

“Accessible UX Research” shares successful strategies that’ll help you recruit the participants you need for the study you’re designing. (Large preview)

Contents

1. Disability mindset: For inclusive research to succeed, we must first confront our mindset about disability, typically influenced by ableism.
2. Diversity of disability: Accessibility is not solely about blind screen reader users; disability categories help us unpack and process the diversity of disabled users.
3. Disability in the stages of UX research: Disabled participants can and should be part of every research phase — formative, prototype, and summative.
4. Recruiting disabled participants: Recruiting disabled participants is not always easy, but that simply means we need to learn strategies on where to look.
5. Designing your research: While our goal is to influence accessible products, our research execution must also be accessible.
6. Facilitating an accessible study: Preparation and communication with your participants can ensure your study logistics run smoothly.
7. Analyzing and reporting with accuracy and impact: How you communicate your findings is just as important as gathering them in the first place — so prepare to be a storyteller, educator, and advocate.
8. Disability in the UX research field: Inclusion isn’t just for research participants, it’s important for our colleagues as well, as explained by blind UX Researcher Dr. Cynthia Bennett.

The book will challenge your disability mindset and what it means to be truly inclusive in your work. (Large preview)

Who This Book Is For

Whether a UX professional who conducts research in industry or academia, or more broadly part of an engineering, product, or design function, you’ll want to read this book if…

1. You have been tasked to improve accessibility of your product, but need to know where to start to facilitate this successfully.
2. You want to establish a culture for accessibility in your company, but not sure how to make it work.
3. You want to move from WCAG/EAA compliance to established accessibility practices and inclusion in research practices and beyond.
4. You want to improve your overall accessibility knowledge and be viewed as an Accessibility Specialist for your organization.

About the Author

Dr. Michele A. Williams is owner of M.A.W. Consulting, LLC – Making Accessibility Work. Her 20+ years of experience include influencing top tech companies as a Senior User Experience (UX) Researcher and Accessibility Specialist and obtaining a PhD in Human-Centered Computing focused on accessibility. An international speaker, published academic author, and patented inventor, she is passionate about educating and advising on technology that does not exclude disabled users.

Technical Details

• ISBN: 978-3-910835-03-0 (print)
• Quality hardcover, stitched binding, ribbon page marker.
• Free worldwide airmail shipping from Germany early 2026. We are currently unable to ship printed books to the United States due to customs clearance issues. If you have any questions, please contact us any time.
• eBook now available for download as PDF, ePUB, and Amazon Kindle.
• Order the eBook for instant download now.
• Reserve your print copy at the presale price.

Community Matters ❤️

Producing a book takes quite a bit of time, and we couldn’t pull it off without the support of our wonderful community. A huge shout-out to Smashing Members for the kind, ongoing support. The eBook is and always will be free for Smashing Members. Plus, Members get a friendly discount when purchasing their printed copy. Just sayin’! 😉

More Smashing Books & Goodies

Promoting best practices and providing you with practical tips to master your daily coding and design challenges has always been (and will be) at the core of everything we do at Smashing.

In the past few years, we were very lucky to have worked together with some talented, caring people from the web community to publish their wealth of experience as printed books that stand the test of time. Trine, Heather, and Steven are three of these people. Have you checked out their books already?

The Ethical Design Handbook

A practical guide on ethical design for digital products.

Add to cart $44

Understanding Privacy

Everything you need to know to put your users first and make a better web.

Add to cart $44

Touch Design for Mobile Interfaces

Learn how touchscreen devices really work — and how people really use them.

Add to cart $44

So, you’ve just built an incredible AI application using Build in Google’s AI Studio. You hit Deploy, the code flies through the ether, and your app is live! But then you look at the URL. It’s something like: https://burning-man-animal-cuddle-614365371127.us-west1.run.app/.

While I personally love the vibe of “Burning Man Animal Cuddle”, your users might find it a bit… suspicious. You bought a cool domain on Namecheap (like vibe-compose.com), and you want to use that instead.

If you’ve never connected a Google Cloud Run service to a third-party registrar like Namecheap, the “DNS Dance” can be confusing. Here is exactly how to do it without pulling your hair out.

Step 1: Add the Mapping in Cloud Run

First, head over to your Google Cloud Console and navigate to Cloud Run domains. Find your project in the dropdown list in the top left (ex: Generative Language Client). You’ll see a button to Add Mapping in the Domain Mappings section.

In the dropdown:

• Select service: Pick your app.

• Select a verified domain: Choose “Verify a new domain…”

• Base domain: Type your root domain (e.g., vibe-compose.com). Do not type www yet. We start with the root.

Step 2: The Verification Dance

Google needs to know you actually own the domain before they route traffic to it. When you click verify, a modal will pop up giving you a TXT record.

Once you’ve entered in your website name and hit Continue, copy that long string of text. It’s time to leave Google for a moment and head to Namecheap.

• Log into Namecheap.

• Go to your Domain List -> Manage -> Advanced DNS.

• Click Add New Record.

• Select TXT Record.

• Host: @

• Value: Paste that Google verification string here.

• TTL: Automatic.

• Save changes.

☕ Coffee Break: DNS changes usually take a while. Wait 2 minutes, then go back to the Google Cloud tab and press VERIFY.

Step 3: Mapping the “Naked” Domain

Once verified, the hard part begins. You want your site to load at vibe-compose.com (no www). This is called the “Naked” or “Root” domain.

Cloud Run does not use CNAMEs for root domains. It uses A Records (IPv4) and AAAA Records (IPv6). Cloud Run will display a list of IP addresses. You need to add all of them to Namecheap.

In Namecheap Advanced DNS, your list should look like the image above:

• 4 A Records: Host is @, Values are the IPs ending in .32.21, .34.21, .36.21, and .38.21.

• 4 AAAA Records: Host is @, Values are the long IPv6 addresses.

Step 4: Don’t Forget the www

If you stop now, vibe-compose.com will work, but www.vibe-compose.com will crash. We need to map the subdomain too.

• Go back to Cloud Run Domain Mappings.

• Click Add Mapping again.

• Type www.vibe-compose.com.

• Google will tell you to add a CNAME.

• Back in Namecheap, add one final record:

• Type: CNAME Record

• Host: www

• Value: ghs.googlehosted.com.

⚠️ The “Gotcha”: Many devs accidentally paste ghs.googlehosted.com into the “Host” field. Don’t do that! The Host is www. If Namecheap adds a period at the end, that should be okay.

Step 5: The spinning wheel of patience

Once your DNS records are in, head back to the Cloud Run dashboard. You will see your domains listed with a yellow spinner or a green checkmark.

What is happening now?

DNS Propagation: Google is checking to see if Namecheap updated (can take 10 mins to 24 hours).

Certificate Provisioning: Once DNS is found, Google automatically creates a managed SSL certificate for you.

Conclusion

Taking the extra 5 minutes to map a custom domain adds a massive layer of polish to your projects. Now, instead of sending people to burning-man-animal-cuddle, you can send them to vibe-compose.com.

(Though, honestly, I’m going to miss the animal cuddles).

Happy Coding! 🚀

💱 Building a Currency Converter Using Flask

I created this project because I needed a simple way to check currency differences while living in Switzerland. As a Korean currently residing here, I often shop in nearby countries like Germany or Austria, or sometimes order items from Korea. Every time, I found myself wondering how the prices compared to Swiss Francs and what the actual cost would be after conversion.

This project was born out of that everyday frustration. By using an external API, the converter provides real-time exchange rates and helps calculate accurate values instantly. It’s a practical tool built from a real need — and a great learning experience at the same time.

📂 1. Project Structure

currency_converter/
│── app.py
└── templates/
    └── index.html

🧠 2. How It Works

• User enters amount + selects currencies
• Flask sends a request to the Frankfurter API
• The API returns live exchange rates in JSON
• Flask calculates the converted amount and renders it in the template
• Includes error handling + same-currency logic

🖥️ 3. Backend Code (app.py)

from flask import Flask, render_template, request
import requests

app = Flask(__name__)

API_URL = "https://api.frankfurter.app/latest"   # Frankfurter API endpoint

@app.route("/", methods=["GET", "POST"])
def index():
    result = None

    if request.method == "POST":
        amount = float(request.form.get("amount"))
        from_currency = request.form.get("from")
        to_currency = request.form.get("to")

        # Prevent conversion between identical currencies
        if from_currency == to_currency:
            result = {
                "from": from_currency,
                "to": to_currency,
                "amount": amount,
                "converted": amount,
                "rate": 1.0
            }
            return render_template("index.html", result=result)

        # Request to Frankfurter API
        url = f"{API_URL}?from={from_currency}&to={to_currency}"
        response = requests.get(url)
        data = response.json()

        print("API Response:", data)

        try:
            rate = data["rates"][to_currency]
            converted = round(amount * rate, 2)

            result = {
                "from": from_currency,
                "to": to_currency,
                "amount": amount,
                "converted": converted,
                "rate": rate
            }
        except KeyError:
            result = {
                "error": "Conversion failed. Please check the currency codes."
            }

    return render_template("index.html", result=result)

if __name__ == "__main__":
    app.run(debug=True)

🌐 4. Frontend Template (index.html)

<!DOCTYPE html>
<html>
<head>
    <title>Currency Converter</title>
    <style>
        body { 
            font-family: 'Inter', sans-serif; 
            padding: 20px; 
            display: flex;
            flex-direction: column;
            align-items: center;
            background-color: #f4f7f6;
        }
        h1 { color: #2c3e50; margin-bottom: 20px; }
        form {
            display: flex;
            flex-direction: column;
            align-items: center;
            padding: 20px;
            background: #ffffff;
            border-radius: 10px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
        }
        input, select, button { 
            padding: 12px; 
            margin: 8px 0; 
            border: 1px solid #ccc;
            border-radius: 6px;
            width: 100%;
            box-sizing: border-box;
        }
        button {
            background-color: #3498db;
            color: white;
            font-weight: bold;
            cursor: pointer;
        }
        button:hover { background-color: #2980b9; }
        .result-box {
            margin-top: 30px;
            padding: 20px;
            background: #ecf0f1;
            border-radius: 10px;
            max-width: 400px;
            width: 100%;
            text-align: center;
        }
        .error-message { color: #e74c3c; font-weight: bold; }
    </style>

    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
</head>
<body>

    <h1>Currency Converter</h1>

    <form method="POST" style="width: 100%; max-width: 400px;">
        <input type="number" step="0.01" name="amount" placeholder="Enter Amount" required>

        <select name="from">
            <option value="CHF">CHF (Swiss Franc)</option>
            <option value="USD">USD (US Dollar)</option>
            <option value="EUR">EUR (Euro)</option>
            <option value="KRW">KRW (South Korean Won)</option>
        </select>

        <select name="to">
            <option value="KRW">KRW (South Korean Won)</option>
            <option value="EUR">EUR (Euro)</option>
            <option value="USD">USD (US Dollar)</option>
            <option value="CHF">CHF (Swiss Franc)</option>
        </select>

        <button type="submit">Convert</button>
    </form>

    {% if result %}
        <div class="result-box">
            {% if result.error %}
                <p class="error-message">Error: {{ result.error }}</p>
            {% else %}
                <h3>Result</h3>
                <p>
                    {{ result.amount }} {{ result.from }} →
                    <span style="font-weight: bold; color: #27ae60;">
                        {{ result.converted }} {{ result.to }}
                    </span>
                </p>
                <p>Exchange Rate: 1 {{ result.from }} = {{ result.rate }} {{ result.to }}</p>
            {% endif %}
        </div>
    {% endif %}

</body>
</html>

📘 5. What I Learned

• How to build a web form and process POST requests in Flask
• How to fetch live data from an external API
• How to handle JSON responses safely
• How to render data dynamically with Jinja2
• Basic UI styling with HTML + CSS

🔧 6. Try It Yourself — Easy Improvements

Here are some beginner-friendly tasks you can try on your own:

• Add input validation — prevent empty or negative numbers.
• Show conversion history — save each result to a list or database.
• Add more currencies — expand the dropdown list.
• Improve the UI — center the layout, add icons, or change colors.
• Make a mobile-friendly version — adjust spacing for small screens.

Small steps like these help you understand Flask more deeply.
Try one or two and watch how quickly the project evolves!

Augmented reality (AR) is no longer a futuristic concept—it’s here, transforming industries, reshaping customer experiences, and redefining how we interact with digital content. From retail and education to healthcare and entertainment, AR offers businesses a unique way to merge the physical and digital worlds.

At Zoolatech, we specialize in building immersive augmented reality projects that help brands stand out, engage users, and deliver measurable business results. But behind every impressive AR experience lies a structured, methodical development process. In this article, we’ll take you through each stage of our workflow, explaining how we turn an idea into a fully functional AR solution—step by step.

Step 1: Understanding the Vision and Defining Objectives

Every successful AR project starts with a clear understanding of the client’s goals. Before diving into design or development, our team at Zoolatech focuses on discovering the why behind the project.

Key Questions We Ask

What business problem are we solving?

Who is the target audience?

What type of AR experience will deliver the most value (marketing campaign, education tool, e-commerce feature, etc.)?

What are the measurable success criteria (engagement, conversions, brand awareness)?

We conduct workshops and brainstorming sessions with the client to gather insights. This step ensures the project has a strategic direction from the start. It’s not just about building cool tech—it’s about creating meaningful experiences that align with business goals.

Example Scenario

Imagine a retail brand that wants to use AR to let customers “try on” furniture in their homes before buying. The objective is to boost confidence and reduce return rates. Once this purpose is defined, the rest of the process becomes much clearer.

Step 2: Research and Feasibility Study

After defining objectives, our team conducts in-depth research. We analyze market trends, competitors, and technological possibilities to find the best approach for the project.

What We Evaluate

Platform feasibility: Should the app be built for iOS, Android, or as a web-based experience?

AR frameworks: Comparison of ARKit, ARCore, Unity, Unreal Engine, and WebAR solutions.

Hardware requirements: Understanding the device capabilities needed for an optimal experience.

User experience implications: How AR fits naturally into user interactions.

This research phase ensures that our solution is realistic, scalable, and delivers the best performance possible.

At Zoolatech, we always balance innovation with practicality—our goal is to push boundaries while maintaining technical reliability.

Step 3: Concept Design and Storyboarding

Once we know what’s possible, we move into creative design. Here, imagination meets strategy. Our designers, AR experts, and storytellers work together to visualize the user experience from start to finish.

Storyboarding and UX Flow

We start by mapping the entire user journey. Storyboards and wireframes help us outline how users will interact with digital elements in the real world. Each touchpoint—scanning an object, triggering an animation, or engaging with 3D models—is carefully planned.

Visual Style and Brand Identity

Next, we develop the visual direction. We ensure that every aspect of the AR experience aligns with the brand’s identity—colors, tone, and style.

For instance, if we’re creating an AR experience for a fashion brand, we might emphasize elegance and simplicity. For an educational AR tool, clarity and engagement become the top priorities.

This stage bridges creativity with purpose, ensuring the AR experience is both functional and emotionally engaging.

Step 4: Technical Architecture and Prototype Development

Once the concept is finalized, our engineers take over. This is where Zoolatech’s technical expertise truly shines.

Building the Foundation

We create the system architecture that supports the AR experience. This includes:

Backend infrastructure for data management

API integrations

Real-time rendering systems

Tracking and recognition algorithms

Depending on the complexity, we might build a quick proof of concept (POC) to validate the technical approach. This small-scale prototype helps us confirm that our chosen tools and frameworks will work seamlessly in real-world conditions.

Tools and Technologies

We typically use tools like:

Unity 3D or Unreal Engine for advanced AR development

ARKit (iOS) and ARCore (Android) for mobile apps

Three.js or 8th Wall for web-based AR experiences

Blender or Maya for 3D modeling and animation

This foundation allows us to build stable, high-performance AR applications that can run smoothly across devices.

Step 5: 3D Modeling and Asset Creation

The visual assets are the heart of every AR experience. Whether it’s a virtual product, a 3D character, or an animated environment, the assets determine how realistic and engaging the final experience will be.

Creating Realistic 3D Assets

Our 3D artists at Zoolatech meticulously model every element. Depending on the project’s goal, the assets can range from stylized visuals to hyper-realistic renders.

We use advanced texturing and lighting techniques to ensure that digital objects integrate naturally into the user’s real environment. This attention to detail enhances immersion and believability.

Optimization for Performance

AR apps must run efficiently, even on mid-range devices. Therefore, we focus heavily on optimization—reducing polygon counts, compressing textures, and balancing quality with speed.

This ensures that the AR experience is visually stunning without overloading the device’s processing power.

Step 6: Development and Integration

With assets and architecture ready, our developers begin full-scale implementation. This is the most intensive stage of the AR project lifecycle.

Core Development Tasks

Implementing object tracking and spatial recognition

Integrating animations and interactions

Connecting backend systems and databases

Building user interface elements

Testing device compatibility

We follow agile methodologies, breaking the development into sprints. This approach allows for continuous testing and iteration, ensuring flexibility and transparency for our clients.

Real-World Testing

AR development requires continuous field testing. Lighting conditions, surfaces, and camera performance all affect how AR behaves. That’s why we test in various real-world environments to fine-tune the user experience.

This hands-on validation process helps ensure that our augmented reality projects perform flawlessly across contexts.

Step 7: Quality Assurance and Usability Testing

Quality assurance (QA) is not just about fixing bugs—it’s about guaranteeing a smooth, intuitive, and immersive experience.

Multi-Stage Testing Approach

Functional testing: Verifying all features work as intended.

Performance testing: Measuring speed, responsiveness, and stability.

UX testing: Observing how users interact with the AR experience.

Cross-platform testing: Ensuring compatibility with various devices and OS versions.

Our QA team replicates real-world conditions—poor lighting, different surfaces, and varying device cameras—to ensure reliability under all circumstances.

Beta Testing

Before launch, we often release a beta version to a small group of users. This helps us collect feedback, identify usability issues, and refine interactions.

The goal is to eliminate friction points and ensure that the final experience is intuitive for first-time users.

Step 8: Deployment and Launch

Once testing is complete, we prepare for deployment. Depending on the project type, this could mean:

Submitting to the App Store or Google Play

Hosting on a web platform for browser-based experiences

Integrating into an existing app or product ecosystem

Launch Strategy

Our launch process includes final performance optimization, analytics setup, and scalability testing.

At Zoolatech, we also help clients create marketing materials—demo videos, user guides, and social media teasers—to support the AR project’s public release.

The goal is to ensure a seamless go-live experience where everything—from app performance to user onboarding—is flawless.

Step 9: Post-Launch Support and Maintenance

AR technology evolves rapidly, and maintaining performance requires continuous updates.

After launch, we provide ongoing support to monitor performance, fix issues, and update features based on user feedback.

Maintenance Includes

Regular updates for new OS versions

Security patches and bug fixes

Adding new features or content

Analyzing user data for future improvements

This commitment to long-term success is one of the reasons clients trust Zoolatech for their AR development needs. We don’t just build and walk away—we partner with our clients for sustainable growth.

Step 10: Data Analysis and Continuous Improvement

One of the biggest advantages of digital experiences like AR is the ability to collect actionable data.

We help clients track:

Engagement metrics: Time spent, number of interactions

Conversion rates: How AR influences purchase behavior

User feedback: Ratings, reviews, and survey responses

Technical data: Performance logs, device usage, session stability

These insights guide future updates and improvements. Over time, this data-driven approach allows us to enhance engagement, refine UX, and maximize ROI for each augmented reality project.

Best Practices We Follow

Throughout our development process, Zoolatech adheres to industry best practices that ensure quality, scalability, and long-term value.

1. Human-Centered Design

Every AR experience is built around the end user. We prioritize intuitive interactions, accessibility, and emotional engagement.

1. Scalability from Day One

Our solutions are designed to evolve—whether it’s adding new content, supporting new devices, or integrating with other digital systems.

1. Collaboration and Transparency

Clients are part of the journey from the first concept meeting to final deployment. We use collaborative tools for updates, feedback, and progress tracking.

1. Ethical and Responsible Innovation

We ensure that our AR solutions respect privacy and use data responsibly. Transparency and trust are integral to our process.

The Zoolatech Advantage

Building augmented reality projects requires a perfect blend of creativity, technology, and strategic thinking. At Zoolatech, we combine these elements to deliver immersive AR solutions that drive real-world impact.

Our multidisciplinary team—comprising developers, designers, UX strategists, and data analysts—works together seamlessly to bring ideas to life. With expertise across industries, we’ve developed AR applications for retail, healthcare, education, and entertainment sectors.

What sets us apart is our holistic approach. We don’t just develop apps—we craft digital experiences that connect people, inspire emotion, and create measurable value.

Final Thoughts

The journey from idea to fully functional AR experience involves careful planning, technical excellence, and creative vision. By following a structured, step-by-step development process, we ensure that every project meets the highest standards of quality, performance, and user satisfaction.

At Zoolatech, we’re passionate about shaping the future through augmented reality projects that push boundaries and redefine possibilities. Whether you’re envisioning a marketing campaign, an interactive product visualization, or a cutting-edge training tool, our team is ready to turn your concept into a remarkable AR reality.

If you’ve tried to deploy AI agents to production, you know the pain.

The POC works beautifully on your laptop. But then reality hits: orchestration complexity, observability gaps, compliance requirements, infrastructure management, and integration hell.

The numbers don’t lie:
95% of agentic AI projects never make it past proof-of-concept (MIT’s research blames the technology).

The Problem
Enterprises are rushing to build AI agents, but the DevOps tooling hasn’t caught up. You’re stuck duct-taping together:

• Custom orchestration scripts that break under load
• Makeshift observability for debugging agent behavior
• Manual compliance and security configurations
• Infrastructure that doesn’t auto-scale or self-heal

Each project reinvents the wheel. Your AI team shouldn’t be infrastructure engineers.

Enter Phinite.ai (http://Phinite.ai)

We built the DevOps platform that AI agents deserve. Think of it as the missing infrastructure layer between your agent code and production deployment.

What makes it different?

🎯 No-code orchestration

Drag-and-drop multi-agent workflows. Compatible with LangGraph, AutoGen, CrewAI—bring your own framework.

☁️ Cloud agnostic

Deploy anywhere: Azure, AWS, GCP, or on-premises. No vendor lock-in. Your infrastructure, your choice.

🔒 Enterprise-ready from day one

Built-in security, compliance, and role-based access controls. Production-grade from the start.

📈 Auto-scaling & self-healing

Kubernetes-native architecture that scales with demand and recovers from failures automatically.

🔍 Observability built-in

Track agent behavior, debug conversations, and optimize performance without cobbling together monitoring tools.

⚡ 10x faster deployment

What takes weeks of infrastructure work now takes hours. Deploy agents, not YAML.

Join our Beta 🚀

We’re opening up our beta program to developers and teams building agentic AI systems.

Beta perks:

• Free platform credits to build and deploy agents
• Direct access to our founding team
• Influence the product roadmap
• Preferred early adopter pricing

Who should apply:

• Developers building AI agent applications
• Engineering teams exploring multi-agent architectures
• DevOps professionals managing AI infrastructure
• Anyone frustrated with current agent deployment tools

👉 Apply here: https://app.youform.com/forms/6nwdpm0y

Benchmarking is an important part of writing efficient Kotlin code. The kotlinx-benchmark library helps you measure and compare performance across different implementations or hardware configurations.

However, raw text results only take you so far. Sometimes you need to visualize your data, not just read it. That’s where Kotlin notebooks come in.

Kotlin notebooks combine the expressiveness of Kotlin with the interactivity of notebook-style development. They give you one convenient place where you can:

• Load results as structured data.
• Explore results using the DataFrame API.
• Visualize results with charts.

Why use notebooks for benchmarking?

Let’s say you’ve run a benchmark suite and obtained text output from kotlinx.benchmark:

Benchmark                              Mode     Cnt Score    Error  Units

maps.LinearSearch                      avgt     10  12.500 ± 0.900  ms/op

maps.BinarySearch                      avgt     10   8.300 ± 0.600  ms/op

maps.HashLookup                        avgt     10   4.700 ± 0.400  ms/op

lists.Filter                           avgt     10  15.200 ± 1.200  ms/op

lists.Map                              avgt     10   9.800 ± 0.700  ms/op

The table works fine for a quick look, but once you accumulate more data, it becomes harder to navigate. Visualizing the same data gives you an instant overview of which implementations perform better and how stable the results are.

You can use Kotlin notebooks to visualise that data quickly:

You can also run the same notebook on another machine and compare the results visually, revealing performance differences between environments or commits.

Comparing benchmark results

Kotlin notebooks make it easy to analyze and plot results from one or more benchmark runs.
For example, you can:

• Read benchmark JSON files generated by kotlinx-benchmark.
• Convert the results into typed DataFrames.
• Compute metrics such as percentage improvements.
• Plot the results with Kandy charts.
• Account for confidence intervals to perform statistically rigorous comparisons.

Several benchmark examples are available in the examples folder of the kotlinx-benchmark repository. 

Generating and sharing notebooks

Once your notebook is ready, you can:

• Create a GitHub gist to share results quickly.
• Commit the notebook to your project for reproducible performance tracking.
• Publish it with JetBrains Datalore for interactive viewing online.

This workflow makes benchmark results easier to understand and share with your team.

Learn more

• kotlinx-benchmark examples
• Kotlin Notebook documentation

Recently I had to integrate a database migration tool into our CI pipeline. At first we picked golang-migrate because it is popular and widely recommended. Everything looked fine until we started running real migrations.

Pretty quickly we ran into issues that made the workflow harder than expected. Stored procedures caused trouble because of delimiter handling. If a migration failed, it often ended up in a dirty state and we had to roll it back manually. There was no built-in history table, so tracking what actually happened required extra effort. And with the default settings we could only run one SQL statement per migration, which was too limiting for our use case.

After spending time trying to work around these problems, I started looking for alternatives and found yoyo-migrate. It has not been updated for about a year, but the functionality is so simple that I do not think it needs frequent releases. I decided to give it a try and it worked surprisingly well.

What I liked most is how straightforward it is. It supports multiple SQL statements, runs everything inside a transaction so you do not need to roll anything back manually, and handles stored procedures without issues. It also supports both .sql and .py migrations, which makes it very convenient for pipelines where you need to mix schema changes with data transformations or aggregation logic.

yoyo-migrate is not as popular as golang-migrate, but in my case it did the job better. It was easier to work with, caused fewer problems and fit the workflow without forcing us into hacks or manual fixes. Sometimes the less popular tool simply fits the real task better.

Another set of updates for the 2025.3 versions of ReSharper and Rider has just been released. This release contains important bug-fixes as well as feature updates.

Let’s take a look at what’s been improved.

Rider 2025.3.0.4

Multi-agent experience in the AI Chat window: Junie and Claude Agent

Claude Agent has become the first third-party AI agent natively integrated into JetBrains IDEs. With its addition, JetBrains introduces a multi-agent experience that brings even more flexibility and power to your development workflow. Now that Claude Agent and Junie are available in the same chat interface, you can switch between agents seamlessly and get the right kind of assistance for every task.

The easiest way to start working with any agent now is to launch it directly from the AI chat. However, the Junie plugin (and some of its features exclusively) will still be available for you if you prefer to use Junie it this way.

Learn more here.

Transparent AI quota tracking in the IDE

You can now view your remaining AI credits, renewal date, and top-up balance directly inside your IDE, and if you run out of credits, you can initiate a top-up from there as well. This update makes it easier to monitor and manage your AI resources – bringing more clarity and convenience to your AI usage. 

In Junie, if your task uses more than 1.2 AI credits, you will get a notification. This feature is currently available in the Junie plugin and will be coming to the AI chat soon.

Learn more about AI quotas in this blog post.

[Coming Soon] Bring Your Own Key

With BYOK, you will be able to connect to OpenAI, Anthropic, or any OpenAI API-compatible local model using your own API key, without logging into JetBrains AI. This gives you more control over how you use AI in IntelliJ IDEA, and it’s ideal if you prefer to work with a specific provider.

This setup is particularly powerful when paired with a JetBrains AI subscription (including the free tier), which provides enhanced completion, extra models, and bonus credits while still allowing you to use your own key for chat and agents.

Learn more here. 

Game development

Rider now provides cloud-powered multi-line code completion for shaders in Unity, Unreal Engine, and Godot projects.For Godot developers, cloud completion suggestions are also available for GDScript files.

Working with databases

Rider replaces the term query console with query file – because consoles have essentially always been files, and it’s time the UI reflected that. We’ve also simplified the workflow, making it more discoverable and consistent. You can learn more about the change in this post. 

Notable fixes included in this build:

• We’ve resolved the issue of excessive memory usage when opening .NET 6 solutions [RIDER-132952].
• Rider now ships with the correct IJent version, restoring full WSL support. Git, Docker integration, terminals, and device discovery over WSL work reliably again. [IJPL-219668]
• Deploying to Android devices now works reliably again. Rider correctly uploads the application APK file, even when a previous version is already installed on the device. [RIDER-132740]
• Rendered documentation now correctly displays code containing < and > characters. [RIDER-119249]
• Search Everywhere now returns results in a stable, predictable order. [RIDER-132113]
• Source-generated files from System.Text.Json are now detected correctly and no longer produce false errors. [RIDER-132634]

For the complete list of resolved issues, please refer to our issue tracker. 

ReSharper 2025.3.0.4 

Here are the most notable fixes included in this update:

• SQL/NoSQL support can now be excluded from the dotUltimate installer. An installation key is available for silent setups, allowing teams to omit these features when not needed. [RSRP-501992]
• The Unit Test Output panel in Out-of-Process mode now shows vertical scrollbars correctly, making long test output fully navigable again. [RSRP-501537]

For the full list of issues resolved in this build, please refer to our issue tracker.

You can download the latest builds from our website (Rider, ReSharper) or via the Toolbox App. You can also update Rider as a snap.

With the holidays just around the corner and the year coming to a cheerful close, we’re ringing in the final JetBrains Academy plugin update of 2025, version 2025.11!

This release focuses on the introduction of the standalone Hyperskill plugin, expands achievement-sharing to IDE-based courses, and brings a number of improvements and fixes to make your learning experience smoother than ever.

To explore the latest improvements, install the JetBrains Academy plugin or update to the latest version from Settings | Plugins in your JetBrains IDE.

Dedicated Hyperskill plugin

Hyperskill learners are now getting a more streamlined and dedicated learning experience! Hyperskill is moving out of the JetBrains Academy plugin into a standalone plugin built specifically for the Hyperskill learning experience. All learning in-IDE capabilities stay the same.

This change brings several benefits:

• Faster updates delivered directly by the Hyperskill team.
• Simpler, cleaner navigation with everything in one place.
• A more consistent and focused learning workflow.

The JetBrains Academy plugin will continue to support JetBrains Academy and Coursera courses, while all Hyperskill content is now available only through the new free Hyperskill Academy plugin.

Details for Hyperskill learners

If you are already working in Hyperskill, your existing projects and progress are safe and will still be there for you – no manual migration required. To continue learning in your IDE, you’ll just have to switch to the new plugin.

Here’s what you need to do:

1. Update to the latest version of the JetBrains Academy plugin.
2. Install the new Hyperskill Academy plugin from the Marketplace tab in your IDE and sign in with your Hyperskill account in Settings/Preferences | Tools | Hyperskill.
3. Open your existing projects and continue learning right where you left off – everything will appear automatically once you sign in.

Hyperskill learners can also switch to the Hyperskill Academy plugin directly from their course. If you open a course you previously started in the JetBrains Academy plugin, you’ll see a notification with an option to install the Hyperskill plugin and continue the course there.

This change is all about giving you a more streamlined and reliable learning environment that’s designed to support your growth every step of the way.

If you have any questions, you can check the full FAQ in our dedicated blog post about the Hyperskill Academy plugin or get in touch with Hyperskill Support.

JetBrains Academy: Celebrate Your Achievements!

Hyperskill includes a fun feature that lets you share your progress on X and LinkedIn, and with this update, we’re bringing that same experience to our in-IDE courses.

Now, when you complete 80% of an IDE course, you’ll receive a notification in your IDE with the option to share your achievement. It’s a simple way to mark how far you’ve come, whether you want to boost your portfolio, stay motivated, or just enjoy a small moment of celebration with the community. Sharing your progress can be a great confidence boost, and it reminds you that learning isn’t just about reaching the finish line, but about appreciating the milestones along the way. Your post might even inspire someone else to start learning, too.

For the full list of issues addressed in the JetBrains Academy plugin’s 2025.11 update, see our issue tracker.

We hope you enjoy this release! As always, please share your feedback with us in the comments section below, and use our issue tracker to report any issues or bugs you encounter.

The JetBrains Academy team