Ipsator is a product and technology consultancy that partners with organizations globally to craft products customers love—spanning strategy, design, mobile, and web applications.
We’ve had the privilege of building multiple products used by millions. One of them has processed over 35 million transactions from more than 20 million users. The accompanying app holds a 4.8 rating on the Google Play Store, with over 12 million installs. Another product we developed handled more than 500,000 requests per minute and facilitated transactions worth over ₹230 million in a single day. We accomplish all of this while ensuring full compliance with financial, tax, and regulatory requirements through the use of analytics, reports, and dashboards.
Through this blog, we hope to share our learnings from building these systems.
Where It All Began
Ipsator was founded in 2013 with a simple goal: help organizations understand their customers better. Our first product focused on turning customer feedback into actionable insights across business roles.
In 2015, we conducted a pilot project with Indian Railways to collect passenger feedback on the newly launched Gatiman Express. Based on the insights gathered, we supported IRCTC in implementing several service-related policy changes. Notable examples include the addition of diabetic-friendly meals and baby milk to the onboard menu. This led to a more ambitious project in 2017 — a complete rebuild of the IRCTC eCatering platform. The first version went live in just two months. Since launching in 2018, we have scaled the platform by 80 times in terms of transactions, even accounting for the COVID years when services were temporarily suspended.
Since then, we’ve worked on a wide variety of systems — each with its own set of challenges, constraints, and lessons.
How We Think: Our Engineering Principles
Engineering Mindset
- Right tool, right job. We believe in using the right tool for the right job. We’re not tied to a single framework, language, or style—we strive to choose the most suitable technology based on our understanding. We may not always be right, but we embrace experimentation and learning from failure.
- Simplicity > complexity. We believe in keeping things simple. We don’t start with a microservices architecture or a Kubernetes cluster unless the project truly requires that scale. While we prefer to keep our code and structure modular, we don’t over-engineer systems to handle millions of users from day one—unless that’s a specific requirement.
- Open by default. We strive to use open-source technologies wherever possible and aim to keep our architecture cloud-agnostic. Many of our applications can be deployed on any cloud provider—or even on self-hosted local servers.
- Small, empowered teams. We don’t believe in throwing people at problems—instead, we empower small teams to work closely together to deliver great products.
- Efficiency matters. We strive to maximize performance from our cloud resources and encourage teams to consider the cost implications of any technology. We welcome optimizations that achieve the same performance with fewer resources.
- Everything is a trade-off. We believe that every decision has two sides. We encourage our teams to carefully weigh the pros and cons of any technology, language, or framework. It’s important to understand potential pitfalls before choosing a path—and to be mindful of its long-term consequences.
- Continuous refactoring and upgradation. We are highly conscious of technical debt and encourage our teams to adopt the latest versions of languages, frameworks, and technologies. This often results in writing less code, faster execution, and more efficient resource usage in the future.
Code & Design Quality
- Readable over clever. We are highly focused on code quality and consistency. We prioritize writing readable code over clever one-liners.
- Feature flags over fear. We favor making quick changes using feature flags and remote configurations. However, any change that leads to slower response times must be justified.
- Design with clarity. We strive to maintain a strong design aesthetic while prioritizing usability. We are committed to consistent layouts, reducing cognitive load, minimizing clutter, ensuring good spacing, and creating simple interactions. We prefer designs that are natural, intuitive, and obvious, rather than relying on clever hacks. Our process always starts with design systems that feature consistent, reusable components, ensuring responsiveness and scalability through a modular structure.
Observability & Delivery
- Measure everything. We strongly believe in the saying, ‘If you can’t measure it, you can’t improve it.’ Observability plays a crucial role in all our applications—monitoring everything from user actions to API responses. This approach has helped us identify various bottlenecks in our systems and improve responsiveness across the board.
- Iterate in small steps. We believe in deploying small, incremental changes rather than releasing a large set of features all at once. This approach helps us gauge the usage and adoption of new functionalities. Most of the time, we push changes when they are working 99% of the time, rather than waiting for perfection.
- Developers own quality. We encourage our developers to self-test rather than relying on QA. We view the QA role more as bug hunters than testers.
Culture & Collaboration
- Cross-functional by default. We encourage everyone to collaborate with cross-functional teams to gain broader perspectives. Our operations and support teams regularly engage with the tech team to share customer and user feedback. We also encourage our tech teams to interact directly with end users—sometimes even traveling or taking customer calls—to foster empathy for other roles.
- Mistakes are welcome. Everyone makes mistakes. Rather than frowning upon them, we embrace them as opportunities to learn and improve. The key, however, is not repeating the same mistakes.
- Work hard, play often. All work and no play makes one a dull person. We regularly play sports like cricket, badminton, and table tennis during the day. Some of us also enjoy video games like Counter-Strike, among others. We believe that having fun is equally important, so we regularly hang out over games and food. We also have board games session in our office.
Our current tech stack
- Most of our performance-critical, transaction-heavy backends are written in Java. Previously, we used the Play framework, but most of our new applications now use Spring Boot. We have also used Node.js(TypeScript) in cases where the workload was better suited for full-stack development.
- We heavily use Python for most of our data science and machine learning/AI workloads, utilizing FastAPI to expose APIs when required.
- We have used MySQL as our primary database for transactional workloads, but we are increasingly adopting Postgres for new applications. We’ve used MongoDB for a few applications where the data was content-heavy. Additionally, we are exploring several time-series databases for analytics and Clickhouse for our observability stack.
- We use Redis for caching, and it has proven to be highly reliable.
- Most of our web applications are written in the React.js-based framework, Next.js; however, we have used multiple other frameworks depending on the needs of the product, including Angular, Astro, Remix, or just pure vanilla React.js.
- When it comes to mobile technology, we’ve explored a variety of options depending on the requirements. We use native Kotlin for some customer-oriented apps and React Native where cross-platform functionality is more important than aesthetics. We’re also using Flutter for a new app we’re building.
- We currently use SQS as our messaging queue but are planning a migration to Kafka.
- Most of our backend services are currently routed through an Nginx proxy behind an AWS Elastic Load Balancer (ELB), and we’re planning to migrate to HAProxy for greater control and performance tuning.
- We use a self-hosted instance of Sentry to monitor and track application errors across our services.
- We use Graphite and Grafana for monitoring our APIs, while Firebase Performance Monitoring offers valuable insights based on real-world user metrics. For alerting, tools like CloudWatch and Better Uptime support our on-call teams with timely notifications. Additionally, we’ve developed custom Python scripts to track variations in user flows and conversion funnels.
- Coming to CI/CD, we use Jenkins and GitHub Actions for many of our build & deployment automations. We also leverage frameworks like Netlify for web deployments, as well as our custom tooling.
- Having used mainstream tools like Jira & Asana, we hopped onto Linear to plan and stay on top of our tasks. Given our commitment to FOSS, we are keenly looking at adopting Huly.
- It shouldn’t come as a surprise that Figma is our primary design tool, along with Canva for visual work. For graphics and image editing, we are adopting GIMP.
- We use a lot of self-hosted servers for development and testing, while all of our production load is deployed on cloud-like AWS. We also use Oracle Cloud, GCP for a few projects.
- We utilize VMware ESXi and Proxmox for enterprise-grade on-prem clusters of servers. Since we develop platform and CPU-architecture agnostic services, we are able to ship applications across multiple on-prem and cloud infrastructures.
- We have used Cloudflare and AWS Cloudfront as CDN, enabling the required performance and security achievements.
- For Blogs - We use multiple headless CMS, mainly WordPress. This combination enables the right blend of features and performance of our blogs. The blogs are then connected via GraphQL APIs of these headless CMS to fetch and form pages and content. We also use Stellate for GraphQL query caching, further improving the performance.
What You Can Expect from This Blog
Through this blog, we’ll share in-depth tech dives, stories of crafting great products, insights into our company culture, lessons from our failures, infrastructure optimizations, and most importantly, the small but impactful learnings we encounter along the way.
Here’s to continuous learning and growth.
