As a Senior Engineering Manager at ThoughtSpot, I focus on improving developer productivity for our engineering, SRE, and support teams. We're introducing smarter workflows and are now leveraging AI to boost efficiency.
ThoughtSpot has transitioned from an appliance-based product to a SaaS model, allowing faster development cycles and greater innovation. By incorporating AI tools like GitHub Copilot and custom solutions, we've streamlined everything from code reviews to answering customer queries.
This transformation is helping us tackle the challenges of breaking down monolithic systems into microservices while managing the complexities of common code dependencies.
TL;DR
Build and test analytics using ThoughtSpot has helped make key business decisions with respect to product development.
AI tools like GitHub Copilot and custom AI-driven solutions are helping developers automate tasks such as code generation, refactoring, and review.
A self-service portal allows developers to provision environments on demand while controlling cloud costs.
ThoughtSpot's AI efforts aim to boost productivity without compromising quality or security in software development.
The future of productivity in development will focus on balancing speed, complexity, and security in the AI-driven landscape.
Build and Test Analytics
Given that our product was majorly a monolithic product, the build and test times were quite long, causing major developer grief. Iterating through code changes was a painfully slow process due to flakiness in tests, longer build times, and a complex dependency graph. To solve this critical problem, we developed an in-house analytics solution using ThoughtSpot to gain deeper insights into our Bazel and Gradle build and test processes. By creating custom dashboards tailored to the needs of our developers and managers, we empowered teams to make data-driven decisions at all levels.
Our tailored analytics solution allowed us to identify both short-term optimizations and long-term improvements necessary to support our transition to microservices. The insights gained from our in-house build and test analytics have been instrumental in driving improvements in developer productivity and code quality while maintaining the robustness of our software.
Notably, our analytics solution helped us catch regressions early in the development process, preventing potential issues from reaching production. Further, the insights we gained highlighted the need to break down our monolithic architecture into smaller, more manageable microservices. This realization has been a key driver in our ongoing architectural transformation.
Breaking the Monolith: From Single-Tenant to Microservices
Our journey at ThoughtSpot is one that many companies face—moving from a monolithic architecture to a microservices approach. The challenge isn’t just breaking apart the monolith, but doing so in a way that maintains performance, avoids dependency issues, and allows both new and old systems to co-exist smoothly.
When we were primarily a single-tenant system, customizations were built into the monolith, which increased build times and slowed down productivity. The transition to microservices and multi-tenant architecture means that services can be decoupled. Still, it requires careful planning to ensure contractual dependencies between old and new systems don’t cause breaks.
One of the major concerns during this transition is managing common code dependencies. These dependencies are shared across the entire platform. Breaking services out of the monolith meant we had to ensure code versioning was standardized and that changes in the monolith didn’t interfere with the microservices.
Ensuring smooth transitions between microservices and monolithic components is not just about splitting code—it's about maintaining performance and consistency across all dependencies.
To address this, we started leveraging the power of build tools such as Bazel and Gradle extensively. We also started leveraging Bazel to optimize our deployments. We are now focusing on consolidating our tech stack into a unified build system to use Bazel, which presents several complexities. Bazel has helped us manage cross-language builds more effectively, reducing the friction in our transition to a microservices-based architecture.
AI-Driven Developer Productivity
One of the most exciting aspects of my work has been our growing use of AI tools to support developer productivity, leading to more streamlined workflows and faster delivery of high-quality software. We have already integrated GitHub Copilot, which allows developers to write boilerplate code faster, catch bugs earlier, and even suggest test cases. But this is just one piece of the puzzle. We have further invested in 2 more areas—an AI bot and code review.
AI-Driven Tools and Integration Bots for Developer Support
Beyond GitHub Copilot, we have developed several AI-driven tools designed to support our internal teams, including integration bots. Leveraging Large Language Models (LLMs), integration bots efficiently index and retrieve information from knowledge sources such as documentation, Confluence pages, and community discussions.
Our AI bot, in particular, provides developers, customer support, and SREs with instant access to critical information, related to frequently asked questions, deployment processes, or troubleshooting steps. Instead of spending time searching through multiple resources, users can simply ask the bot questions to instantly receive accurate, detailed answers and relevant documentation. By linking to authoritative sources of truth, these bots empower teams to enhance efficiency and reduce friction. This ultimately enables our teams to serve customers faster and more effectively.
AI-Assisted Code Reviews
On the code review side, we've integrated AI-assisted reviews. AI acts as the first layer, catching common errors such as coding standard violations and potential security vulnerabilities, saving time for both developers and reviewers by handling the initial review. This allows the main reviewer to focus on more complex aspects without needing to address basic issues or those that might be easily overlooked. Senior engineers are still responsible for overseeing more complex code, but AI takes care of simpler review tasks, freeing up their time for more challenging problems. We're also exploring the use of AI for auto-refactoring code, especially for smaller pull requests. Although larger, more complex codebases still need human attention.
Our approach is to leverage AI for efficiency while maintaining high standards and retaining the critical human element needed for complex decision-making.
Building a Unified Self-Service Portal
Another major step toward improving developer productivity at ThoughtSpot was the creation of a self-service portal for provisioning containerized environments. This internal tool was designed to help developers request and manage the environments they need for both development and testing, without relying on external resources or manual processes.
The portal has two primary functions. First, it allows developers to quickly request the infrastructure they need for running tests across multiple public clouds like AWS, GCP, and Azure. Second, it ensures that these environments are cost-efficient by automatically applying leasing policies to prevent cloud resource leakage. This is crucial, given that cloud costs can quickly spiral out of control if not managed effectively.
Our self-service portal empowers developers to provision their environments on demand while keeping cloud costs under control through intelligent resource management.
What’s unique about this portal is that it was built in-house to suit our specific needs. Although there are open-source tools like Backstage available for similar purposes, we chose to develop our own solution due to its low complexity and the flexibility it provides in adding new features over time. This has allowed us to integrate cost-management tools directly into the system, making it a powerful, unified platform for our developers.
The Future of Developer Productivity
Looking ahead, the landscape of developer productivity is rapidly changing, and AI is at the forefront of this shift. Traditionally, productivity in software development was measured by how quickly a developer could learn a new programming language or framework. Today, tools like GitHub Copilot and other AI-driven assistants allow developers to get up to speed in minutes, rather than weeks or months. This is changing the nature of how we think about developer productivity and the challenges that come with it.
In the future, developer productivity won’t be about writing code faster—it will be about ensuring the quality, security, and scalability of that code.
As AI tools become more integrated into the development process, companies will need to address new challenges:
How do you maintain the complexity necessary for enterprise-level software while relying on AI-generated code?
How do you ensure that the security of your codebase isn’t compromised by the use of widely available AI models?
These are the questions that we’re grappling with as we continue to integrate AI into our workflows. At ThoughtSpot, we’re focused on ensuring that while AI may help us code faster, our CI/CD pipelines, testing frameworks, and overall software quality processes evolve just as quickly. The end goal is to maintain high levels of developer satisfaction and productivity while keeping the quality and security of our software at the forefront.
Key Points to Remember
Build and test analytics helped identify long-term and short-term improvements needed to aid velocity and productivity:
Leveraging Build Analytics: Build and test analytics provided insights for developers and KPIs for managers, enabling data-driven decisions, catching regressions, and identifying the need to break down the monolith.
Monolithic to Microservices Transition: ThoughtSpot is transitioning from a monolith to microservices, carefully managing common code dependencies to avoid disruptions.
Riding the GenAI wave: The integration of AI tools like GitHub Copilot and custom AI bots has been instrumental in improving developer productivity.
Self-Service Portal: Our internal self-service portal has streamlined the provisioning of environments, ensuring developers have what they need without excessive cloud costs.
Code Refactoring: AI-driven code refactoring is helping us save time on simpler tasks, though human oversight is still needed for more complex issues.
The Future of Productivity: AI is changing the way we measure productivity in software development, but quality and security must remain top priorities.
Preparing for tomorrow
As we continue to integrate AI into our development workflows, it’s clear that the nature of developer productivity is evolving. The ability to write code faster is no longer the main measure of success. Instead, companies must focus on maintaining code quality, ensuring security, and preparing for the long-term implications of widespread AI adoption in software development.
At ThoughtSpot, we’re excited to be at the forefront of this shift, and we’re committed to ensuring that as AI accelerates the development process, the robustness and security of our software continue to meet the highest standards.
