Everything you need to know about Ash Framework
Ash Framework is the game-changing toolkit for Elixir developers. With modular, plug-and-play building blocks, Ash cuts down on development time and effort. Letting you do more with less code. In this guide we'll explore what is Ash Framework, how it works and when to use it.
Contents
- What is Ash Framework?
- Core concepts
- Why use Ash Framework?
- Standout features
- Ash Framework vs. alternatives
- When to use Ash
- Adoption is growing
- Real-world applications
- Challenges and considerations
- Resources and documentation
- Join the community
- Ash Framework book
- Ash Premium Support
- Conclusion
What is Ash Framework
Ash Framework is a declarative, resource-oriented backend framework for building web applications in the Elixir programming language. It simplifies web app development by focusing on resources, which act as the core building blocks for database schemas, APIs, background jobs, and more.
Ash is designed to work seamlessly with popular tools like Phoenix, Postgres, and GraphQL. This makes it a versatile choice for modern web development.
Unlike traditional MVC frameworks, Ash emphasises extensibility and flexibility, allowing developers to build scalable systems with minimal boilerplate.
Core concepts
Resources
At the heart of Ash Framework are "Resources." A resource represents a single entity in your application—such as a database table, an API endpoint, or a background job. Resources are defined declaratively, specifying attributes, relationships, actions, and policies.
For example:
defmodule MyApp.Post do
use Ash.Resource,
data_layer: AshPostgres.DataLayer
attributes do
attribute :title, :string
attribute :body, :string
end
relationships do
belongs_to :author, MyApp.Author
end
end
Declarative Programming
Ash embraces declarative programming principles. Instead of writing imperative code to define behaviour (e.g., writing SQL queries), you describe what your application should do in terms of rules and configurations. This approach reduces complexity and makes your code easier to understand and maintain.
Why use Ash Framework?
Ash Framework offers several advantages:
- Declarative Resource Modelling: Ash enables developers to define application structures declaratively, reducing boilerplate and automating backend tasks like schema generation, API creation, and authorisation.
- Extensibility and Integration: Ash supports seamless integration with Elixir tools like Phoenix, Postgres, and GraphQL while offering extensibility through custom extensions for unique business needs.
- Automation of Routine Tasks: The framework automates repetitive backend operations, allowing developers to focus on business logic and innovation rather than technical complexities.
- Scalability and Maintainability: Ash’s declarative approach ensures consistent abstractions across your application. This reduces technical debt and makes scaling easier as your system grows.
- Unified Abstraction Layer: By unifying data sources (e.g., databases, APIs, caches) under a single abstraction, Ash simplifies resource management and enhances maintainability.
Standout features
Ash Framework is constantly being expanded by the Ash Core team and the open source community. New features are regularly being announced at Elixir Fourm. Here are some of the highlights.
Generated APIs: Ash can generate GraphQL and JSON APIs directly from your code. Generated GraphQL schemas and OpenAPI specifications ensure your frontend teams and external integrators have everything they need to start using your APIs.
Best in class security: AshAuthentication provides a turn-key solution for login with multiple strategies from simple passwords to magic links and SSO. Ash's authorisation and system is baked in to the core of the framework, ensuring that every action is authorised before executing. Multi-tenancy is also a 1st class feature of Ash. This keeps your customer data isolated and rest assured there can't be leakage of private information.
Realtime Systems: Ash has built-in functionality to notify your users when important changes happen. Watch dashboards update in realtime as the data changes.
Migrations made easy: Ash keeps track of the shape of your data and automatically generates the migrations needed to update your database on each deploy. Your CI pipeline can detect when the code has been updated without the necessary migrations, preventing a bad deploy before it happens.
High Performance by default: Ash GraphQL APIs intelligently bulk load data, selecting only the information necessary, ensuring the most efficient use of your database, without any hand-tuning. Bulk Updates and Atomic Updates allow Ash to make large changes to you data as fast as possible.
Ash Framework vs. alternatives
When evaluating Ash Framework, understanding its position among alternatives helps you make the right architectural decisions for your project.
Ash and Phoenix: Complementary frameworks
Ash and Phoenix serve complementary roles rather than competing. Phoenix handles the web layer (HTTP, routing, templates), while Ash focuses on the application layer (business logic, data access). This separation allows each to excel in its domain:
- Phoenix provides best-in-class real-time capabilities with channels and LiveView
- Ash offers declarative resource definitions and robust domain modelling
- Together, they create a comprehensive full-stack solution
Phoenix uses imperative code with contexts and schemas, while Ash employs a declarative approach with explicit domain modelling and reduced boilerplate. Where Phoenix is evolving its security practices, Ash has built security from the ground up with first-class actors and authorisation.
Comparing across programming languages
When looking beyond Elixir, trade-offs become apparent. Ruby on Rails offers rapid development and a mature ecosystem but struggles with real-time features. Django provides a comprehensive toolkit but lacks Elixir's concurrency model. Laravel delivers elegant PHP syntax with widespread hosting options but shares similar real-time limitations. React/Next.js enables unified JavaScript development but requires additional infrastructure for real-time capabilities.
The Elixir stack with Ash shines particularly for real-time applications, highly concurrent systems, and complex domain modelling. Its functional approach and BEAM VM advantages make it ideal for applications where reliability and scalability are paramount.
Adoption is growing
The number of applications built using Ash is growing all the time, as can be seen by the increasing number GitHub stars or the thriving community the Ash Discord channel.
Real-world applications
At Alembic, we've been building Ash apps - both big and small - for several years now. Here are some examples of what Ash can achieve.
Heathcare Communication Platform
Transforming Healthcare Communication with Elixir and Ash Framework
Facing fragmented communication systems that hindered patient engagement and provider efficiency, a digital healthcare pioneer partnered with us to accelerate their delivery. Using Elixir and Ash Framework we delivered solutions that streamlined patient-provider communication across multiple channels. Combined with our technical expertise and ongoing Ash Premium Support, we dramatically reduced their development time while enhancing system scalability and reliability.
Vexillum
From Paper to Precision Workflows
Alembic's partnership with Vexillum produced a platform that revolutionises heavy equipment maintenance workflows by digitising paper-based processes. Leveraging Ash, Phoenix LiveView and Elixir, Alembic delivered a real-time web application and a native iOS work delivery app in Swift and SwiftUI. This enabled Vexillum to streamline work design, enhance safety, and reduce costs swiftly. This collaboration underscores Alembic's commitment to lean, agile solutions and its ability to deliver impactful software efficiently.
Hiring, onboarding, and team productivity with Ash
Onboarding
Ash's declarative nature and consistent design patterns significantly lower the barrier for new developers joining a team. By eliminating much of the boilerplate that typically comes with building APIs and business logic, Ash provides a clear and structured entry point into the codebase.
Instead of having to understand ad-hoc implementations or custom logic scattered across controllers and contexts, developers learn by exploring Ash Resources, which act as self-contained, expressive documentation of domain behavior. The availability of Ash’s tooling, such as the Ash API documentation generator, helps make the system transparent from day one.
Smaller teams
Reduce reliance on specialist roles — more is handled by Ash.
One of Ash’s strongest advantages is its ability to enable small teams to achieve more with less. Tasks that traditionally require backend specialists — like setting up authentication, defining API endpoints, handling validations, and enforcing access control — can often be handled declaratively in Ash.
This means fewer handoffs between roles, reduced coordination overhead, and a smoother product development process. For startups or lean engineering teams, this translates to faster iteration cycles and fewer dependencies on senior engineers to manage infrastructure concerns.
Consistency and maintainability
Ash enforces a structured, resource-based design that naturally leads to consistent implementations across modules. This consistency means team members spend less time understanding each other's code and more time solving product problems.
When resources are defined in similar ways, extending functionality or refactoring becomes a far less risky and more predictable process. As a result, long-term maintainability improves, and technical debt accumulates more slowly.
Documentation and introspection
Because Ash relies heavily on DSLs, much of the system becomes self-documenting. Developers can understand an entire resource — including its actions, validations, relationships, and access policies — by reading a single file. This reduces reliance on tribal knowledge or outdated external documentation.
Ash also supports automatic API documentation via AshGraphQL and AshJsonApi extensions, which improves internal developer experience and supports collaboration with frontend or external API consumers.
Team productivity gain
Ash allows engineering teams to spend less time on infrastructure and more time on business logic. It promotes declarative thinking, faster prototyping, and streamlined code reviews. When teams no longer need to manually scaffold CRUD operations, or enforce policy checks at every API endpoint, they can invest more energy in innovation and product differentiation. Over time, this leads to faster delivery and more stable software systems.
Adoption and migration strategy
Greenfield projects: Ideal for quick MVPs.
Ash is particularly well-suited for greenfield applications where speed, consistency, and maintainability are high priorities. Teams can move quickly by using Ash’s declarative resources to scaffold domain logic and APIs with minimal boilerplate. It’s an ideal choice for startups, internal tools, and proof-of-concept platforms where fast iteration is key, and future extensibility is critical.
Scaling up: Built to support growth
Ash’s architecture is built for scalability, allowing applications to handle increased user demand or new business requirements without significant retooling. Features like filtering, pagination, and policy enforcement are optimised for performance, ensuring smooth scaling as your application grows.
Brownfield: Start by migrating one module or domain.
For existing Phoenix applications or legacy Elixir services, Ash can be adopted incrementally. A common strategy is to identify a self-contained module, feature, or new domain that can be re-implemented using Ash. This approach allows teams to evaluate Ash’s value without requiring a wholesale rewrite. Migrating a well-scoped feature or service also provides a learning opportunity for the team and reveals integration points with existing codebases.
Co-existence: Run Ash and traditional Phoenix side by side.
Ash and traditional Phoenix/Ecto code can operate side by side within the same codebase. This hybrid approach makes it easier to experiment or pilot Ash without disrupting established systems. For instance, a new admin dashboard or API can be developed using Ash, while the main user-facing product continues to run on Phoenix. Teams can selectively refactor legacy components into Ash over time.
Evaluate ROI through a pilot project
A successful migration starts with a small, high-impact pilot. Choose a domain where Ash’s declarative model and rapid scaffolding can demonstrate quick wins — such as reducing custom code, improving consistency, or delivering a new feature in less time. Metrics to consider include reduced lines of code, improved test coverage, faster time-to-market, or simplified onboarding for new developers. Based on these learnings, CTOs can make informed decisions on wider adoption.
Technical considerations:
- Ensure your team is comfortable with functional programming and Elixir idioms.
- Set up clear module boundaries and dependency management to separate Ash components.
- Validate integration with existing CI/CD, monitoring, and authentication/authorization tools.
- Document early wins and lessons learned to support team alignment and stakeholder buy-in.
Adopting Ash doesn’t have to be an all-or-nothing move. A phased strategy focused on modularity, measurable outcomes, and team readiness can lead to successful long-term integration.
Performance, observability & DevOps
Performance
Ash leverages Elixir's lightweight concurrency model, powered by the BEAM virtual machine, to deliver exceptional performance out of the box. By reducing boilerplate and abstracting repetitive patterns, Ash minimises the risk of performance bottlenecks due to inconsistent implementation across teams.
It is especially well-suited for applications that require high throughput and real-time data processing, such as admin dashboards, internal platforms, or APIs handling complex business rules. Since Ash runs on Elixir, it inherits excellent scalability characteristics that support fault-tolerant, distributed systems.
Observability
Ash supports modern observability standards through integration with Elixir’s :telemetry tooling, enabling the emission of detailed performance and operational metrics. These telemetry events can be routed into established observability platforms such as Prometheus, Grafana, Datadog, Honeycomb, or OpenTelemetry-compatible tools.
Logging is structured and consistent thanks to the framework's declarative design, making it easier to trace behaviours, debug issues, and monitor key application events.
Deployment
Ash fits seamlessly into standard Elixir deployment workflows. Whether you're deploying to a cloud service, containerised environments like Docker/Kubernetes, or using OTP releases, Ash apps are deployed just like any other Elixir/Phoenix application. Its consistency and modularity reduce deployment surprises and help ensure reproducibility across environments.
CI/CD integration
Teams already using CI/CD pipelines with Elixir or Phoenix will find that Ash introduces no additional complexity. Test automation benefits from Ash’s predictable patterns and reduced boilerplate, making it easier to write and maintain unit and integration tests. Ash also supports database sandboxing for tests and integrates well with tools such as GitHub Actions, GitLab CI, CircleCI, and more.
With strong support for introspection and metadata generation, it’s also easier to automate documentation, schema validation, and API consistency checks as part of a robust DevOps strategy.
FAQs & common misconceptions about Ash
1. Is Ash too opinionated and rigid for custom applications? Not at all. While Ash provides a strong set of conventions to help teams move fast, it’s built with flexibility in mind. Through its modular DSLs and extension mechanisms, Ash allows custom behaviours to be layered on top without modifying core logic. You can always write custom Elixir when you need full control.
2. Does Ash lock you into a specific way of working? Ash encourages a resource-oriented approach, but it does not prevent you from integrating with Phoenix controllers, custom contexts, or using raw Ecto queries when necessary. You’re never locked in — you can adopt Ash incrementally or even use it alongside traditional Phoenix code.
3. Is Ash production-ready? Yes. While still a growing framework, Ash is being used in production by multiple companies across different industries. It’s backed by a dedicated team and has robust support for performance, observability, and API contracts, making it a viable choice for critical applications.
4. Is Ash only useful for internal tools or CRUD apps? While Ash excels at building CRUD-heavy tools, it’s also powerful enough for complex business systems and workflows. Its support for relationships, custom actions, event handling, and policy-based authorisation allows teams to model real-world domains elegantly.
5. Is the learning curve too steep for new team members? Ash’s declarative style may take some getting used to, especially for developers coming from imperative paradigms. However, the learning curve is rewarded with reduced boilerplate and increased consistency. Teams report faster onboarding and easier long-term maintenance.
6. Does using Ash mean abandoning Phoenix? Not at all. Ash and Phoenix complement each other. Phoenix provides the UI and routing layer, while Ash handles resource logic and APIs. Many teams use both in tandem to build robust full-stack applications.
7. How well does Ash scale in larger systems? Ash’s resource-based structure makes it easier to organise code across domains. The separation of concerns and support for actions, policies, and validations promotes scalable and maintainable design, especially in large Elixir applications.
8. What if I need full control over the database layer? You still have it. Ash uses Ecto under the hood, and you can write custom queries or override default behaviours when necessary. You're not abstracted away from the database — you're given helpful defaults that can be customised.
9. How active is the Ash community and ecosystem? The community is growing steadily, with active contributors, frequent releases, and support channels like Discord. While smaller than Phoenix or Rails, it is highly engaged and welcoming to newcomers.
10. Can Ash be adopted gradually in an existing project? Absolutely. Many teams begin by using Ash for a single module or feature and expand from there. Its modular nature makes it easy to test in isolation, evaluate its benefits, and scale usage based on team comfort and project needs.
11. How do I handle the "magic" and heavy use of macros in Ash? Ash does rely on macros and metaprogramming techniques that can feel "magical" to developers who prefer explicit code. This abstraction can lead to challenges when debugging or understanding how the framework operates under the hood. To mitigate this, encourage developers to read the documentation thoroughly, use the framework's introspection tools, and leverage the active community support. Start with smaller, well-defined resources before tackling complex domains to build confidence with the framework's patterns.
12. Is it difficult to balance abstraction and customization in Ash? Ash provides escape hatches for custom behavior, but these can add complexity if overused. The key is finding the right balance—use Ash's declarative features for standard patterns and reserve customizations for truly unique business logic. When deviating from defaults, document your decisions and centralize custom behavior in well-named modules to maintain maintainability.
13. How do I address the limited talent pool for Elixir and Ash developers? Elixir has a smaller developer community compared to mainstream languages, and Ash's newer status within Elixir further narrows the talent pool. Teams adopting Ash should plan to invest in training existing developers, budget for longer onboarding times, and potentially develop internal learning resources. Consider partnering with consultancies specializing in Elixir/Ash or leveraging the framework's community resources to accelerate knowledge transfer.
Ash Framework resources and documentation
Ash has extensive guides and documentation available, including:
- AshHQ - check out AshHQ for all the latest releases and updates.
- Ash Weekly Newsletter - A weekly look into the goings on of the Ash Framework ecosystem.
- HexDocs - The official documentation for detailed guides are available on HexDocs.
- Alembic Blog - The Alembic technical blog also provides regular updates, insights guides about getting the most out of Ash.
- GitHub - The Ash project on GitHub has all the source code for the various Ash libraries.
Join the community
Ash has a thriving community that is contributing it’s rapid growth and adoption. You can join the conversation in these forums:
- Ash Discord - where you'll find people collaborating on code, sharing knowledge, adding ideas and discussing the Elixr ecosystem.
- Elixir Forum - The Ash section on Elixir fourm is a great place to ask questions and find out what other people have been building with Ash.
- Elixir Subreddit - where you can join the conversation about the broader Elixir ecosystem.
Ash Framework book
The Ash Framework Book, written by Alembian's Rebecca Le and Zach Daniel, will teach your everything know about build Ash apps. Coauthored by the creator of Ash, this book is packed with insider knowledge, best practices, and actionable guidance to get you started fast. By the end, you’ll have the skills and confidence to create applications that grow with your needs.
Ash Premium Support
If you need more active guidance Alembic’s Ash Premium Support service provides a direct line to our team of Ash Experts for fast, high-quality support that improves your knowledge and speeds up delivery.
Conclusion
Ash Framework is a transformative tool for teams looking to modernise their tech stack. Its declarative nature simplifies backend logic while complementing the Phoenix framework for web interfaces. Whether building POCs/MVPs or migrating legacy systems, Ash helps achieve scalability, maintainability, and faster development cycles.
Adopting Ash could be the key to unlocking your team’s potential—start exploring today!
Alembic technical blog
The Alembic technical blog also provides regular updates, insights guides about getting the most out of Ash.
Ash Framework Consulting
Understanding Multitenancy in Ash Framework: A Practical Guide
In multi-customer applications, securely separating customer data is essential. While Elixir developers might be familiar with Ecto's manual approaches to multitenancy, Ash framework offers this as a built-in feature. Ash uses both simple attribute-based and powerful context-based strategies. This provides flexible, effective data isolation and identity management, which maintains a clean API as your needs evolve.
Nicholas Hammond
4 March 2025 – 3 min read
Ash Framework Consulting
Igniter - Rethinking code generation with project patching
Ash Framework is ~4 years old, and we’ve only just now introduced generators and installers. As of Ash 3.1, we’ve now got generators and installers, thanks to our latest project Igniter! First, we’ll cover why I avoided them for so long. Then we dive into how Igniter changes the game!
Zach Daniel
16 July 2024 – 8 min read
Ash Framework
Announcing Ash Authentication
We're extremely pleased to announce the first public release of `ash_authentication` and `ash_authentication_phoenix`. Ash Authentication allows you to authenticate users in your Elixir applications using a simple DSL on your Ash resources.
James Harton
17 January 2023 – 3 min read
Ash Framework
Customising Ash Authentication with Phoenix LiveView
Authentication is a crucial part of most web applications. With the release of Ash Authentication, we are now able to authenticate users in Elixir applications using simple DSL on Ash resources. In this blog post, we will show you how to customise Ash Authentication with Phoenix LiveView.
Will Tan
19 March 2023 – 4 min read
Ash Framework
From Iron to Algorithms: How development frameworks are transforming software engineering
Just as engineering in the built environment changed radically during the industrial revolution in the 18th century, software development is in the process of going through our own period of rapid change, transitioning from the era of individual craftsmanship to industrialisation and automation.
Ben Melbourne
3 May 2024 – 3 min read