The Client Application Layer  /

We deliver flexible and adaptable client applications across various platforms and technologies. Our expertise covers mobile, web, desktop, and even custom embedded devices. We equip them with intuitive user interfaces (UIs) optimized for the chosen platform (native or web-based).

Endpoint: EMQX  /

A scalable, high-performance, and distributed MQTT message broker we use for managing our IoT and other machine-to-machine (M2M) applications. Built on the Erlang/OTP platform, it offers exceptional concurrency and fault tolerance. EMQX supports the latest MQTT version, including features like shared subscriptions, message expiration, and user properties.

Endpoint: RabbitMQ  /

RabbitMQ is a high-performance message broker software built on Erlang/OTP for reliable high-volume message routing between applications. It's lightweight, scalable, and supports multiple protocols and streaming.

Endpoint: GraphQl  /

A query language specifically designed for APIs. It allows clients to request exactly the data they need, avoiding unnecessary data transfer. This streamlined approach makes it ideal for complex applications that rely on data from multiple sources.

Endpoint: RESTful API  /

Our team has extensive experience working with RESTful APIs. We create efficient APIs for various needs, from small-scale integrations to when it's best applicable in Backend-as-a-Service (BaaS) solutions. We follow best practices and design principles to create reliable APIs. Our focus is on minimizing latency, implementing effective caching strategies, and running efficient database queries.

Web: LiveView  /

LiveView is a framework for dynamic and interactive web applications. It leverages server-rendered HTML built on the Elixir programming language and Phoenix web framework. LiveView automatically updates the browser in real-time as server-side changes occur, creating a seamless user experience. It offers SEO benefits through server-side rendering and faster initial page loads. LiveView applications scale efficiently, both on a single server and across multiple servers.

Core: Elixir  /

Elixir is a functional programming language at the heart of our development process. It allows us to build applications that are:
More maintainable and reliable: Clear and concise code that simplifies maintenance.
Scalable and high-performance: Elixir is designed for efficient use of resources and can handle large workloads.

Elixir leverages the BEAM Virtual Machine, known for its robust concurrency and fault tolerance.

Embedded: Nerves  /

Nerves is an Elixir-based framework for developing real-time IoT applications on embedded multi-core microprocessors. Our Elixir expertise allows us to leverage Nerves' efficient core to create lean applications that maximize resource utilization. Nerves utilizes the BEAM virtual machine, known for its high availability, scalability, and fault tolerance, making it ideal for mission-critical embedded systems.

Web: Phoenix  /

Phoenix is a web development framework built on Elixir. It uses the Model-View-Presenter (MVP) pattern for organized code structure. Inheriting from Elixir's Erlang Virtual Machine (BEAM), Phoenix offers strong concurrency and fault tolerance. Designed for simplicity, efficiency, and scalability, We use Phoenix in building real-time web applications, APIs, and single-page applications (SPAs). It provides powerful features like channels for efficient data exchange, and websockets for real-time updates.

Core: Erlang-OTP  /

The most advanced tool in building massively scalable, concurrent applications with strict uptime requirements. Ideal for telecoms, banking, and other demanding sectors, it's trusted by leading companies for critical systems.

Why Erlang?  /

Reduced complexity: Erlang simplifies code management and infrastructure needs for large-scale applications.

Increased Scalability & Uptime: It handles high user volumes efficiently, minimizing downtime and vulnerabilities.

Built for Concurrent Operations: Erlang's core design optimizes distribution, fault tolerance, and concurrency.

At Amai Interactive, we leverage Erlang/OTP interoprability with Elixir to focus on building robust, scalable, and highly available systems, leaving the underlying complexity to the powerful tools at our disposal.

Core: Rust  /

A systems programming language that prioritizes safety and performance. It offers built-in concurrency and memory management for resource-intensive applications. This translates to reliable software, ideal for mission-critical development at Amai Interactive.

NIF: For high-performance tasks, We utilizes Native Implemented Functions (NIFs). Rust is the preferred choice due to its speed, memory and thread safety, ensuring secure integration with the Elixir/Erlang BEAM virtual machine.

Embedded: Rust  /

Rust's minimal runtime and memory control make it ideal for embedded systems. It prevents memory bugs, manages concurrency efficiently, and produces small, efficient binaries for secure and performant embedded applications.

Embedded: Qt  /

Qt is a versatile cross-platform framework for developing multi-platform applications and graphical user interfaces. It runs on major desktop, mobile, and embedded platforms, making it a truly universal development tool.

Our experienced team builds high-performance embedded applications with Qt, including native graphical user interfaces for diverse displays, interactive visual applications for touchscreens, and immersive visualization experiences.

Leveraging Qt’s optimization tools and best practices, we create applications that run smoothly even on resource-constrained devices.

Database: Neo4j  /

For projects demanding analysis of relationships within data, Our profficiency in Neo4j gets the job done. As a graph database management system that stores data as interconnected points and the links between them, Neo4j proves invaluable for uncovering relationships and patterns.

Database: PostgreSQL  /

PostgreSQL is a feature-rich relational database management system known for its extensibility and SQL compliance. It excels at handling various workloads, from small applications to large, high-traffic systems.

Database: Mnesia  /

Mnesia is a distributed, soft real-time database built for the Erlang programming language. Part of the Open Telecom Platform (OTP), it offers unique features suited for specific applications:
Distributed: Data is replicated across servers for high availability and fault tolerance.

Soft Real-Time: Mnesia targets predictable response times, making it ideal for telecom or trading platforms.

Erlang-Native: Tight integration with Erlang allows seamless data access and manipulation.

Transactional: ACID transactions ensure data consistency and integrity.

Lifecycle: Agile  /

We are passionate about crafting beautiful, efficient, and maintainable code. However, we understand that speed and adaptability are crucial in today's dynamic environment. That's why we leverage Agile methodologies to deliver exceptional client software, faster and more effectively.

Our Agile Process:
Planning: Collaborate to define vision, roadmap, and priorities.
Sprints: Break work into modular sprints with clear goals.
Daily Stand-ups: Share progress, identify roadblocks, ensure conformity.
Reviews: Continuously improve based on feedback.
Testing and Quality Assurance: Ensure bug-free, high-standard software. In a dynamic business environment, we help you easily adapt to changing requirements and market trends. Our Agile framework ensures your software remains relevant and competitive.

Lifecycle: Observability  /

Building and deploying apps is just the beginning. Optimal performance, stability, and exceptional user experience require constant monitoring. Our observability and monitoring services help ensure your app's health.

Our Experienced Team:
- Implements and manages various observability tools and platforms.
- Stays current with the latest technologies and best practices.

How We Deliver Value  /

Metrics & Logging: We establish comprehensive solutions capturing key performance indicators (KPIs) for efficient issue diagnosis.

Distributed Tracing: We use advanced tools to map request flows and identify performance bottlenecks.

Real-Time Alerts: You'll be notified of potential issues before they escalate, enabling proactive action.

Customizable Dashboards: Clear visualizations provide actionable insights into app health and performance.

Root Cause Analysis: Our team identifies the root cause of issues, saving you time and resources.

Performance Optimization: We analyze performance data and recommend steps to improve response times and overall efficiency.

Lifecycle: Test Coverage  /

We prioritize reliable software that meets your needs and delivers a positive user experience. We achieve this through comprehensive testing practices.

Our Approach:
High Test Coverage: We employ various methods like unit, integration, and end-to-end tests to ensure all functionalities are thoroughly tested. Test-Driven Development (TDD): TDD encourages upfront design and requirement analysis, leading to cleaner, more maintainable code.

Benefits:
Reduced Risk: Rigorous testing minimizes bugs and ensures a smooth user experience.
Improved Maintainability: Well-written tests act as documentation, simplifying future modifications.
Enhanced Confidence: High test coverage provides peace of mind for you and your users.
Faster Development: TDD can identify issues early, preventing rework and streamlining development cycles.
Continuous Improvement:
We continuously refine testing practices and tools to achieve optimal efficiency.