DEV Community: Digital Innovations

Laravel vs MERN Stack: Which One is Better for Modern Web Development?

Digital Innovations — Tue, 12 May 2026 12:07:22 +0000

Laravel vs MERN Stack: Which One is Better for Modern Web Development?

The web development industry is evolving rapidly, and businesses today have countless technology options available for building websites, web applications, SaaS platforms, CRMs, enterprise systems, and mobile-connected platforms. Among the most discussed technologies in modern development are Laravel and the MERN Stack.

Looking for a reliable Website Development Company in Gurgaon for your business growth? Digital Innovations delivers scalable websites, custom software, and modern web applications designed for performance and long-term success.

Developers, startups, and enterprises often debate which technology stack is better. Some prefer Laravel because of its structured architecture and fast backend development, while others prefer MERN because of its modern JavaScript ecosystem and highly interactive frontend capabilities.

Digital Innovations is a trusted Website Development Company in Gurgaon offering custom web development, eCommerce solutions, CRM systems, and mobile-friendly business websites for startups and enterprises.

The truth is that both Laravel and MERN are powerful technologies. However, they solve problems differently and are suitable for different types of projects.

If you are planning to build a scalable digital product, understanding the actual differences between Laravel and MERN Stack can help you choose the right technology for long-term success.

As a leading Website Development Company in Gurgaon, Digital Innovations helps businesses build secure, SEO-friendly, and high-performance websites using modern technologies like Laravel, React, Flutter, and Node.js.

Understanding Laravel

Laravel is a modern PHP framework designed for building secure and scalable web applications. It follows the MVC (Model-View-Controller) architecture, which helps developers organize code efficiently and maintain large applications more easily.

Laravel became highly popular because it simplified traditional PHP development. Earlier PHP projects often became difficult to manage as applications grew larger. Laravel introduced elegant syntax, reusable components, built-in security, and powerful development tools that transformed the PHP ecosystem.

One of the biggest advantages of Laravel is that it provides many built-in functionalities out of the box. Developers do not need to build everything from scratch.

Laravel includes:

Authentication systems
Database ORM (Eloquent)
API support
Caching systems
Queue management
Email handling
Task scheduling
Middleware support
Security layers

This makes Laravel extremely efficient for business applications and enterprise software development.

Today, Laravel is widely used for:

CRM development
ERP systems
Educational portals
eCommerce websites
Healthcare platforms
Booking systems
SaaS dashboards
Enterprise web applications

Understanding MERN Stack

MERN Stack is not a single framework. It is a collection of four JavaScript technologies working together to create full-stack applications.

MERN stands for:

MongoDB
Express.js
React.js
Node.js

The biggest advantage of MERN is that developers can use JavaScript throughout the entire application, including frontend, backend, APIs, and database operations.

This unified language ecosystem improves development flexibility and makes frontend-backend communication smoother.

React.js is one of the strongest reasons behind MERN’s popularity. It allows developers to create highly dynamic, responsive, and modern user interfaces.

Node.js powers the backend with an event-driven non-blocking architecture, making it highly efficient for handling multiple simultaneous requests.

MongoDB, being a NoSQL database, provides flexibility for applications where data structures frequently change.

MERN Stack is commonly used for:

SaaS products
Social networking platforms
Real-time chat systems
Live dashboards
Project management tools
Streaming platforms
Interactive business applications
Startup products

Development Philosophy Difference

The fundamental difference between Laravel and MERN lies in their development philosophy.

Laravel focuses on structured development. It provides predefined architecture patterns and built-in functionalities that simplify backend-heavy application development.

MERN, on the other hand, focuses on flexibility and frontend interactivity. Developers have more freedom in structuring applications but may need additional setup and configuration.

Laravel prioritizes convention and organized backend systems.

MERN prioritizes dynamic frontend experiences and scalable JavaScript ecosystems.

This difference significantly impacts project planning, development speed, and maintenance.

Frontend Experience and User Interface

Modern users expect smooth, fast, and interactive digital experiences. Frontend performance and user experience have become major deciding factors in web application success.

Laravel traditionally uses Blade templating for frontend rendering. Blade is lightweight and efficient for server-rendered applications. Laravel can also integrate with frontend technologies like Vue.js or React.js when needed.

For business dashboards, admin panels, and management systems, Laravel’s frontend capabilities are usually sufficient and highly stable.

However, MERN Stack offers a completely different frontend experience through React.js.

React uses component-based architecture, allowing developers to create reusable UI elements and highly dynamic interfaces. Applications built with React feel more like native mobile apps because of faster rendering and smooth transitions.

This makes MERN particularly strong for:

Interactive SaaS dashboards
Real-time systems
Social media platforms
AI-based applications
Startup products
Customer-facing platforms

When user experience is the top priority, many businesses prefer MERN because React delivers modern UI performance exceptionally well.

Backend Development Comparison

Laravel is known for simplifying backend development significantly.

With Laravel, developers can quickly create:

APIs
Authentication systems
Admin panels
Database management systems
Role-based access controls
Business workflows

Laravel’s built-in tools reduce development time substantially.

For example, tasks that require manual setup in many technologies are already available in Laravel through official packages and libraries.

MERN backend development uses Node.js and Express.js. While Node.js is powerful and scalable, developers often need to configure many backend functionalities manually.

This gives greater flexibility but may increase architecture complexity.

Laravel is generally faster for:

Business software
Management systems
Structured workflows
Enterprise applications

MERN is generally better for:

High-concurrency systems
Real-time communication
Event-driven applications
Dynamic APIs

Database Architecture Differences

Laravel commonly uses relational databases such as:

MySQL
PostgreSQL
MariaDB

Relational databases work extremely well for structured business data where relationships between tables are important.

For example:

Banking systems
HR software
Inventory systems
ERP platforms
Accounting software

These systems require strict data integrity and relationships.

MERN Stack usually uses MongoDB, which is a NoSQL database.

MongoDB stores data in flexible JSON-like documents rather than fixed relational tables.

This flexibility benefits:

Rapidly evolving applications
Startups changing features frequently
Unstructured datasets
Dynamic user-generated content

MongoDB can speed up development during early-stage product building.

However, for highly structured enterprise systems, relational databases often remain more reliable.

Scalability and Performance

Scalability is critical for businesses expecting future growth.

Laravel can scale efficiently when optimized correctly using:

Redis caching
Load balancing
Database optimization
Queue workers
Cloud infrastructure

Large enterprise applications successfully run on Laravel globally.

However, MERN Stack has an advantage for applications requiring high concurrency and real-time processing.

Node.js uses asynchronous architecture, allowing it to process multiple requests simultaneously without blocking operations.

This makes MERN highly suitable for:

Live chat applications
Streaming systems
Collaborative tools
Real-time tracking platforms
AI-powered live systems

For highly interactive and concurrent applications, MERN usually performs better.

Security Comparison

Security is one of the strongest areas of Laravel.

Laravel provides built-in protection against:

SQL injection
CSRF attacks
Cross-site scripting
Password vulnerabilities
Session hijacking

Security implementation in Laravel is relatively straightforward because many protections are built directly into the framework.

MERN applications can also be highly secure, but security often depends heavily on developer expertise and proper configuration.

Improperly configured Node.js applications may introduce vulnerabilities.

For enterprise businesses handling sensitive information, Laravel is often preferred because of its mature security ecosystem.

Development Cost and Maintenance

Budget is a major factor for startups and businesses.

Laravel development is often:

Faster to launch
Easier to maintain
More cost-effective
Simpler for backend-heavy systems

Because Laravel includes many built-in functionalities, development teams can reduce coding time significantly.

MERN development may require:

Advanced frontend specialists
React expertise
More architecture planning
Additional third-party libraries

This can slightly increase development cost.

However, for highly scalable modern platforms, the investment in MERN may provide better long-term flexibility.

Community and Ecosystem

Both Laravel and MERN have massive communities.

Laravel has:

Excellent documentation
Strong developer ecosystem
Rich package libraries
Stable long-term support

MERN benefits from:

Huge JavaScript ecosystem
React community innovation
Large npm package ecosystem
Rapid frontend advancements

Both technologies are future-proof and actively evolving.

Which One Should You Choose?

There is no universal winner between Laravel and MERN Stack.

The best technology depends entirely on your business goals and project requirements.

Choose Laravel if you need:

Business management systems
Secure enterprise applications
Faster backend development
Budget-friendly scalability
Structured database systems

Choose MERN Stack if you need:

Interactive modern interfaces
Real-time functionality
Scalable SaaS platforms
Dynamic frontend experiences
High-concurrency applications

Some companies even combine both technologies to leverage their strengths together.

For example:

Laravel APIs with React frontend
Node.js microservices with Laravel admin systems

Hybrid architectures are becoming increasingly common.

Final Thoughts

Laravel and MERN Stack are both excellent technologies capable of powering large-scale applications.

The real success of a project depends not only on technology selection but also on:

Architecture planning
Development quality
Security implementation
UI/UX optimization
Scalability strategy
Long-term maintenance

Businesses should focus less on trends and more on selecting technologies aligned with their actual operational needs.

Laravel remains one of the best choices for structured business applications and enterprise systems.

MERN Stack continues dominating modern startup ecosystems because of its frontend flexibility and scalability.

In the end, the “best” technology is the one that solves your business problems efficiently, scales with growth, and delivers the best user experience for your audience.

CMS vs Custom Developed Websites: Which One Should You Choose?

Digital Innovations — Tue, 05 May 2026 12:13:45 +0000

CMS vs Custom Developed Websites: Which One Should You Choose?

In today’s digital-first world, choosing the right approach for your website is a critical decision. Businesses often find themselves deciding between a CMS-based website and a custom-developed solution. Each option has its own strengths, limitations, and ideal use cases.

Digital Innovation is a trusted website development company in Gurgaon delivering scalable and high-performance web solutions for modern businesses. Their expert team builds custom platforms designed for growth, performance, and user engagement.

What is a CMS Website?

A Content Management System (CMS) is a platform that allows you to create and manage a website without deep technical knowledge. Popular CMS platforms like WordPress, Magento, and OpenCart provide ready-made templates, plugins, and tools to quickly build websites.

Looking for a reliable website development company in Gurgaon? Digital Innovation offers end-to-end web development services with modern technologies, ensuring secure, fast, and SEO-friendly websites tailored to your business needs.

Advantages of CMS:

Faster development and deployment
Lower initial cost
Easy content management without coding
Large ecosystem of plugins and themes

Limitations of CMS:

Limited customization for complex features
Performance issues with heavy plugins
Security risks if not maintained properly
Dependency on third-party tools

What is a Custom Developed Website?

A custom-developed website is built from scratch using technologies like React, Laravel, Node.js, or Spring Boot. It is tailored specifically to your business requirements.

Advantages of Custom Development:

Fully customized design and functionality
Better performance and scalability
High-level security and control
No unnecessary features or bloat

Limitations of Custom Development:

Higher initial investment
Longer development time
Requires technical expertise for management

Key Differences Between CMS and Custom Websites

Flexibility:
CMS platforms are limited to available plugins and themes, while custom websites offer unlimited flexibility.

Scalability:
Custom websites are more scalable and can handle complex business logic and high traffic efficiently.

Cost:
CMS is cost-effective initially, but custom development provides better long-term value for growing businesses.

Performance:
Custom websites are optimized for speed, whereas CMS websites may slow down due to multiple plugins.

Security:
Custom-built solutions offer better security control, while CMS platforms are more vulnerable if not regularly updated.

Which One Should You Choose?

The right choice depends on your business goals:

Choose a CMS if:
You need a simple website, blog, or small e-commerce store with a limited budget and quick launch timeline.
Choose Custom Development if:
You need advanced features, scalability, high performance, or a unique platform such as SaaS, marketplace, or enterprise solution.

Final Thoughts

There is no one-size-fits-all answer. A CMS is perfect for quick and cost-effective solutions, while custom development is ideal for businesses aiming for long-term growth, flexibility, and competitive advantage.

Before making a decision, evaluate your budget, timeline, scalability needs, and technical requirements. Choosing the right approach can significantly impact your business success in the long run.

Why System Architecture Decisions Made Early Can Make or Break Your Software in the Long Run

Digital Innovations — Sun, 29 Mar 2026 16:26:03 +0000

The silent cost of "we'll fix it later"

One of the most common patterns in software teams is deferring architectural decisions choosing the quickest path now with a vague plan to refactor later. The problem? "Later" rarely comes. Technical debt compounds silently until a simple feature request takes six weeks instead of two days.

This isn't a failure of intent. It's a failure of awareness. Most developers aren't taught to think about system boundaries, coupling, and data flow alongside writing functions. Architecture lives in a different mental layer and that gap is expensive.

A common misconception: architecture only matters at scale. In reality, decisions about module boundaries, database schema, and API contracts become load-bearing walls fast — even at 1,000 users.

Monolith vs microservices: the misunderstood debate
The industry has spent years debating this as if one is objectively better. The truth is context-dependent: both are valid, and the right choice depends entirely on team size, deployment maturity, and domain complexity.

A well-structured monolith with clear internal module boundaries often outperforms a poorly designed microservices setup. The key question isn't "which pattern?" — it's "what are the natural seams in our domain?"
Choosing between architectures becomes much clearer when you start with a domain map and a realistic growth projection. Many experienced software development companies begin client engagements with exactly this exercise — not to sell services, but because it genuinely surfaces constraints that change the entire technical direction.

The role of system design in developer onboarding

Rarely discussed: how your architecture is documented directly affects how fast new engineers become productive. Systems with clear service boundaries, well-named modules, and explicit data contracts let new hires make meaningful contributions within days. Systems without them can take months to navigate safely.
This is why architecture is not just a technical concern — it's an organizational one. Teams that treat system design as a living, documented artifact consistently outperform those that rely on implicit tribal knowledge.

Observability: the missing foundation

Most systems are built to run. Fewer are built to be understood when something goes wrong. Observability structured logging, distributed tracing, meaningful metrics is typically retrofitted rather than designed in from the start.
The cost appears at 2 AM during an incident when your team is staring at raw logs trying to reconstruct what happened. Tools like OpenTelemetry, Grafana, and Datadog are mature enough that there's no excuse for flying blind in production, even for small teams. Investing in observability early is one of the highest-leverage architectural decisions a team can make.

When should you revisit your architecture?

Architecture isn't set-and-forget. Clear signals that it's time to reassess: deployment frequency dropping, feature velocity slowing, on-call burden increasing, or new hires taking more than two weeks to ship their first change. These are symptoms, not causes — and the root cause is almost always architectural drift.

Architecture reviews are a structured way to surface hidden risk before it becomes a crisis. A good software development company brings cross-industry experience that internal teams often lack they've seen the same failure patterns play out across domains and can name what's happening before it becomes critical.

Takeaway
You don't need to build perfect architecture upfront — that's impossible. But you do need to be intentional about the decisions you're making and the ones you're consciously deferring. Document the trade-offs. Draw the boundaries. Name the seams.
These habits compound over time just as much as technical debt does — just in the opposite direction.

Written with insights from the team at Digital Innovation, where we believe good architecture is the foundation of every great product. Learn more about our work as a software development company in Gurgaon.

The Future of Website Development: How Digital Innovation Is Reshaping Online Experiences in 2025

Digital Innovations — Sun, 29 Mar 2026 16:00:40 +0000

The web is no longer just a place to share information — it's the primary arena for business growth, brand identity, and customer experience. As we move deeper into 2025, website development is undergoing a fundamental transformation driven by AI, performance-first engineering, and hyper-personalization.

Whether you're a startup founder or a seasoned developer, staying ahead of these shifts isn't optional — it's survival.

1. AI-powered development workflows

AI is now embedded across the entire development lifecycle. From GitHub Copilot to automated testing pipelines, developers who embrace these tools ship 2–3× faster without sacrificing quality. Use AI for boilerplate generation, accessibility audits, and SEO meta-tag automation — not just code completion.

2. Core Web Vitals as a competitive moat

Google's algorithm increasingly rewards fast, stable, and interactive pages. Businesses investing in LCP, FID, and CLS optimization see measurable lifts in organic traffic and conversions. This is where the right [website development partner] makes a real difference — technical SEO built into the architecture from day one, not bolted on later.

3. Headless CMS and composable architecture

Monolithic CMS platforms are giving way to composable stacks — Contentful, Sanity, or Storyblok paired with Next.js or Astro frontends. The result: faster pages, better developer experience, and content teams that move independently of developers.

4. Accessibility is now a legal and UX imperative

WCAG 2.2 compliance is a baseline expectation in most markets. Accessible sites consistently outperform non-accessible ones on engagement metrics. Build with accessibility first, not as an afterthought.

5. Progressive Web Apps are eating native apps

PWAs now deliver near-native performance with a fraction of the development cost. For businesses looking to reach mobile users without maintaining separate iOS and Android codebases, PWAs are the strategic play in 2025.

Final thoughts

Digital innovation in web development is a permanent shift, not a trend. The teams winning in 2026 invest in performance, AI augmentation, and composable infrastructure.

If you're ready to modernize your web presence, explore our digital innovation web development services →

Flutter vs Native App Development in 2026: Which One Should Businesses Choose?

Digital Innovations — Sun, 15 Mar 2026 12:49:46 +0000

If you are planning to build a mobile application in 2026, one of the biggest decisions is choosing the right development approach. Businesses and startups often face a common question: should they go with Flutter cross-platform development or build native apps for Android and iOS separately?

At Digital Innovations, we work with startups and enterprises to build scalable mobile applications using both modern cross-platform frameworks and native technologies. Learn more about Digital Innovations

Choosing the right technology affects development cost, performance, scalability, and time to market. In this article, we will explore the differences between Flutter and native development to help you decide which approach fits your business needs.

Understanding Flutter App Development

Flutter is a modern UI toolkit developed by Google that allows developers to build Android and iOS apps from a single codebase. Instead of writing separate code for each platform, developers write one application that runs on both systems.

Flutter uses the Dart programming language and provides a rich set of widgets for creating visually attractive applications.

Key advantages of Flutter

Single codebase development allows developers to write one codebase that works across multiple platforms, which significantly reduces development time.

Faster development cycle is possible because Flutter supports hot reload, allowing developers to instantly see UI changes without restarting the app.

Lower development cost is another benefit since a single team can build both Android and iOS apps.

Consistent UI across platforms is possible because Flutter renders its own UI components, ensuring the design looks the same on different devices.

Because of these advantages, Flutter has become very popular among startups and businesses launching MVP products quickly.

Understanding Native App Development

Native development means building apps specifically for each platform using the official technologies.

For example Android apps are built using Kotlin or Java, while iOS apps are developed using Swift or Objective-C.

Native apps directly interact with device hardware and operating system features, which often results in higher performance.

Key advantages of native development

Best performance is achieved because native apps are optimized for each platform and run faster.

Better access to device features allows developers to integrate hardware functions like camera, sensors, Bluetooth, and system APIs more efficiently.

Stronger security can be implemented because developers can use platform-specific security features.

Better platform integration ensures that apps follow platform design guidelines and system behaviors.

This is why large-scale applications such as banking apps, ride-sharing platforms, and high-performance gaming apps often use native development.

Flutter vs Native Development Comparison

Development speed is faster with Flutter because developers build one application that works on multiple platforms. Native development requires separate Android and iOS projects which increases development time.

Development cost is usually lower with Flutter because a single development team can handle both platforms. Native development typically requires two specialized teams.

Performance is generally better in native apps because they directly interact with the operating system. However Flutter performance has improved significantly and works well for most business applications.

User experience in native apps follows platform-specific design guidelines which may feel more natural to users. Flutter maintains consistent design across platforms which is beneficial for many applications.

Maintenance is easier in Flutter because there is only one codebase. Native apps require updates and maintenance for both Android and iOS versions.

API calling, caching, and performance optimization in both Flutter and native platforms.

Flutter API Calling Example

Flutter commonly uses the http package for API requests.

`import 'package:http/http.dart' as http;
import 'dart:convert';

Future fetchUsers() async {
final response = await http.get(Uri.parse('https://api.example.com/users'));

if (response.statusCode == 200) {
var data = json.decode(response.body);
print(data);
} else {
throw Exception('Failed to load users');
}
}`

Android Native API Example (Kotlin)

Android developers often use Retrofit for API communication.

`interface ApiService {
@get("users")
suspend fun getUsers(): Response>
}

val retrofit = Retrofit.Builder()
.baseUrl("https://api.example.com/")
.addConverterFactory(GsonConverterFactory.create())
.build()

val service = retrofit.create(ApiService::class.java)`

iOS Native API Example (Swift)

iOS developers typically use URLSession to fetch data.

`let url = URL(string: "https://api.example.com/users")!

URLSession.shared.dataTask(with: url) { data, response, error in
guard let data = data else { return }
let json = try? JSONSerialization.jsonObject(with: data)
print(json)
}.resume()`

Flutter Caching Example

Flutter apps often use SharedPreferences or local databases for caching.

`import 'package:shared_preferences/shared_preferences.dart';

Future saveData(String value) async {
final prefs = await SharedPreferences.getInstance();
await prefs.setString('cached_data', value);
}`

Android Native Caching Example

Android apps commonly use Room database for local caching.

@Entity data class User( @PrimaryKey val id: Int, val name: String )

Flutter Performance Optimization

Use const widgets whenever possible to reduce rebuilds.

const Text( 'Hello Flutter', style: TextStyle(fontSize: 20), );

Android Performance Optimization
Use RecyclerView instead of older ListView implementations.

recyclerView.layoutManager = LinearLayoutManager(this) recyclerView.adapter = UserAdapter(userList)

RecyclerView improves scrolling performance for large datasets.

iOS Performance Optimization

Use lazy loading for table views.

tableView.dequeueReusableCell(withIdentifier: "UserCell", for: indexPath)

When Should You Choose Flutter

Flutter is ideal for startups building MVP applications, businesses that want faster time to market, projects with limited budgets, applications that require consistent design across platforms, and companies that want easier long-term maintenance.

Flutter works especially well for ecommerce apps, service platforms, booking apps, and many business applications.

When Should You Choose Native Development

Native development is the best option when the application requires high performance, relies heavily on hardware features, or needs advanced platform integration.

It is also a better choice for complex gaming apps, enterprise platforms, or applications with strict security requirements.

Mobile App Development Trends in 2026

The mobile app ecosystem continues to evolve rapidly. Many modern applications now integrate AI capabilities such as chatbots, smart recommendations, and predictive analytics.

Cross-platform development is becoming increasingly popular as frameworks like Flutter enable faster development and easier maintenance.

Cloud-based mobile backends allow applications to scale efficiently and handle large numbers of users.

Security and privacy have also become critical priorities, encouraging developers to implement stronger authentication and data protection systems.

Businesses that adopt modern mobile technologies early often gain a competitive advantage in the market.

Final Thoughts

Both Flutter and native development offer unique advantages. The right choice depends on your project requirements, performance expectations, development budget, and long-term goals.

Flutter is a powerful option for businesses that want faster development and lower costs, while native development remains ideal for high-performance and complex applications.

If you are planning to build a mobile application and need expert guidance, our team at Digital Innovations helps startups and enterprises design, develop, and scale modern mobile applications.

Explore our mobile app development services here Digital Innovations

Why Modern Web Applications Fail to Scale (And How to Fix It)

Digital Innovations — Sat, 28 Feb 2026 08:14:17 +0000

*Why Modern Web Applications Fail to Scale (And How to Fix It)
*
Most web applications don’t fail because of bad ideas. They fail because of poor architecture decisions made early in development.

After working on multiple production projects, we’ve seen common scaling mistakes repeated across startups and enterprises.

*1. Monolithic Code Without Structure
*
Many teams build everything in one large codebase without clear separation of concerns. It works at MVP stage, but once traffic grows, deployments become risky and debugging becomes painful.

Fix:
Adopt modular architecture. Use service layers, repository patterns, or microservices where necessary.

** 2. Ignoring Performance from Day One
**
Unoptimized queries, no caching, and heavy frontend bundles can destroy performance.

Fix:

Use database indexing properly
Implement caching (Redis or server-side caching)
Optimize frontend bundles with code splitting and lazy loading

*3. Choosing the Wrong Tech Stack
*
Not every project needs microservices. Not every app needs serverless. Overengineering can slow development.

Fix:
Choose stack based on:

Expected traffic
Budget
Team expertise
Time to market

For example:

React + Laravel works great for scalable SaaS
Next.js is ideal for SEO-heavy platforms
Flutter is powerful for cross-platform mobile apps

*4. No CI/CD and DevOps Planning
*
Manual deployments increase downtime and production bugs.

Fix:
Set up CI/CD pipelines, use staging environments, and automate testing early.

** 5. Lack of Monitoring
**
If you don’t track performance, you won’t know when things break.

Fix:
Implement logging, server monitoring, and performance tracking tools.

Final Thoughts

Scalability is not a feature you add later. It’s a mindset you build from the start.

The best-performing applications are not just well-coded — they are well-architected.

If you’re building a web product today, think beyond launch. Think about 10x growth.