Coder Legion - Recent posts tagged appdevelopment

9 Affordable Mobile App Development Companies in the UAE for Startups in 2026

Thu, 15 Oct 2026 13:40:45 +0000

Launching a startup in the UAE requires the right technology, a clear business strategy, and a reliable development partner. With growing demand for digital services, Mobile App Development Dubai has become an important investment for entrepreneurs looking to improve customer engagement, streamline operations, and expand their businesses. However, choosing the right development company can be challenging when budgets are limited and competition is high.
Whether you are building an e-commerce platform, a food delivery application, a fintech solution, or an AI-powered business tool, selecting an affordable mobile app development company in UAE can help turn your idea into a market-ready product. Here are nine companies to consider when researching potential technology partners in 2026.

1. DXB APPS

DXB APPS is a company to consider for businesses seeking end-to-end mobile application development. Its publicly available website highlights mobile app development, security, scalable solutions, and services for startups and established organizations.

For founders planning an MVP or a feature-rich business application, DXB APPS is worth including in an initial shortlist. Potential project requirements may include user registration, payment integration, customer dashboards, booking systems, and analytics.

Before signing a contract, ask for a detailed quotation covering design, development, testing, deployment, and maintenance. Startups should also confirm whether the proposed solution supports future feature expansion without requiring a complete rebuild.

2. A2Solutions

A2Solutions is another option for entrepreneurs exploring mobile app development in Dubai. Its published company content discusses mobile applications, cross-platform development, and solutions for business models such as marketplaces and on-demand services.

This makes the company worth evaluating if your startup needs an application that connects customers with service providers, manages bookings, or facilitates digital transactions. Depending on your requirements, ask whether reusable components or cross-platform technologies could reduce development time and cost.

Founders should compare the proposed technical architecture, project milestones, and support arrangements before deciding whether A2Solutions fits their budget and launch schedule.

3. Mobiria Solutions

Mobiria Solutions is included in this list for startups researching potential mobile technology partners in the UAE. Before engaging the company, request current information about its mobile development capabilities, completed projects, and experience working with early-stage businesses.

A suitable development partner should understand how to prioritize essential features, design an intuitive user experience, and deliver a product that can be tested with real customers.

If your startup is building a marketplace, subscription platform, or customer-facing service, ask for relevant case studies and a clear MVP proposal. Verify the company's current service portfolio and pricing directly before making a commitment.

4. Intertec Systems

Intertec Systems is an established technology services provider with a broader focus on digital transformation, enterprise applications, cloud, cybersecurity, and AI-related solutions. Its official website also highlights application development and management capabilities.

For startups developing business-critical platforms or preparing for complex operational requirements, these capabilities may be relevant. Potential areas to explore include enterprise integrations, workflow automation, secure application architecture, and AI-enabled business processes.

However, startups with limited funding should establish whether the company's delivery model and commercial terms fit an early-stage project. Compare the scope and cost with those of smaller specialist agencies before selecting a partner.

5. SafCodes

SafCodes offers mobile app development services in Dubai, including iOS and Android applications, cross-platform development, and ready-made solutions for businesses. Its website also describes delivery application packages for entrepreneurs who want to launch more quickly.

This can be relevant for startups operating in food delivery, grocery delivery, logistics, or other on-demand sectors. A ready-made solution may reduce initial development work when its existing features closely match the business model.

Before choosing this approach, check customization limits, source-code ownership, third-party licensing, payment integration, and recurring fees. A lower initial price is useful only if the application can support your operational needs and future growth.

6. AADX

AADX is another company on the shortlist for businesses exploring app development services in the UAE. Startups should contact the company directly to confirm its current offerings, technical expertise, and experience with applications similar to their proposed products.

When evaluating AADX, focus on whether the team can translate business requirements into a practical development roadmap. Ask how it handles UX/UI design, backend development, security testing, app-store submissions, and post-launch maintenance.

For founders working with limited capital, a phased delivery plan can be particularly helpful. Begin with the features necessary to validate demand, then add advanced capabilities after gathering user feedback and establishing a sustainable business model.

7. Business Apps

Business Apps is included as an option for entrepreneurs looking for technology solutions that support business processes and customer interactions. Before shortlisting the company, verify its current mobile application development services and request examples relevant to your industry.

A startup may need an app for appointment scheduling, inventory management, customer loyalty, field operations, or online sales. The right development partner should be able to identify the simplest practical solution rather than recommend unnecessary features.

Ask whether the company can integrate the application with your existing website, CRM, payment provider, or business software. Clear documentation and a transparent support agreement can help reduce long-term costs.

8. WallStreet Mobile Apps

WallStreet Mobile Apps provides mobile app development services in Dubai, with its published offerings covering native, hybrid, Android, iOS, and business-focused applications.

The company is worth evaluating if your startup needs a dedicated mobile experience, an e-commerce application, or a digital product designed around specific customer journeys. Founders should discuss their target audience, preferred platforms, performance requirements, and expected user growth during the discovery stage.

To assess affordability, request an itemized proposal and compare it with other vendors offering a similar scope. Confirm delivery timelines, revision policies, testing procedures, intellectual property rights, and the cost of ongoing technical support.

9. Techasoft

Techasoft offers mobile application development services in Dubai, including Android, iOS, and cross-platform solutions. Its published service information also outlines a development process covering requirements analysis, interface design, engineering, testing, and deployment.

This makes Techasoft an option for founders seeking a development partner to support an application from planning through launch. Potential projects include customer service platforms, educational apps, healthcare applications, and business productivity tools.

If you are comparing providers, ask for examples of comparable projects, the proposed technology stack, and the resources assigned to your application. A detailed statement of work will help establish whether the proposed budget includes all the features and services you need.

How to Choose an Affordable Mobile App Development Company in UAE

Choosing a vendor based on the lowest quotation alone can lead to unexpected expenses. Instead, assess the following factors before making your decision:

Project portfolio: Request live applications and case studies relevant to your industry.
Technical capabilities: Determine whether you need an Android App Development Company, an iOS App Development Company, or a team experienced in both platforms.
MVP-first approach: Prioritize essential features and validate your business idea before investing in advanced functionality.
Transparent pricing: Confirm what is included in design, development, testing, deployment, and maintenance.
Security and compliance: Discuss data protection, access controls, payment security, and applicable UAE requirements.
Post-launch support: Clarify bug fixes, updates, hosting, and ongoing maintenance fees.
Ownership and scalability: Ensure your contract clearly addresses source code, intellectual property, and future development.
How Much Does Mobile App Development Cost in Dubai in 2026?
The cost of mobile application development depends on the complexity of the product, platform requirements, design, integrations, and security needs. Published 2026 estimates vary considerably, but a basic MVP may cost approximately AED 10,000–90,000, while more complex applications can cost substantially more. These figures are broad market estimates, not quotations from the nine companies listed above.

Startups can control costs by choosing a focused feature set, considering cross-platform development, and requesting milestone-based payments. Remember to budget separately for marketing, hosting, maintenance, and future improvements.

Final Thoughts

Finding the right mobile app development partner is an important step toward building a sustainable startup in the UAE. DXB APPS, A2Solutions, Mobiria Solutions, Intertec Systems, SafCodes, AADX, Business Apps, WallStreet Mobile Apps, and Techasoft are nine names to research as part of your selection process.

The best choice depends on your business model, budget, technical requirements, and growth plans. Whether you need a Mobile App Development Company in Abu Dhabi or a Mobile App Development Agency in Dubai, prioritize proven capabilities, transparent communication, and a clear delivery plan.

As AI adoption grows, startups may also consider an AI App Development Company if intelligent search, personalized recommendations, or workflow automation offers measurable business value. Ultimately, the strongest investment is an application that solves a genuine customer problem and can evolve with your business.

How to Build an Interactive Web App Without Writing Code

Mon, 12 Oct 2026 08:40:18 +0000

Building a web application no longer requires you to write every line of HTML, CSS, JavaScript, or backend code yourself. No-code development platforms allow users to design interfaces, organize data, configure application logic, and connect services through visual editors.

These tools make it possible for entrepreneurs, small business owners, freelancers, and nontechnical professionals to develop applications that solve practical problems. Examples include appointment booking systems, customer portals, project management dashboards, membership platforms, internal business tools, and online directories.

However, building an interactive application involves more than arranging buttons and choosing colors. A functional app needs a clear purpose, a reliable data structure, rules governing user actions, appropriate access controls, and a way to publish and maintain the finished product.

This guide explains how to build an interactive web app without writing code, from choosing the right platform to testing and launching your application.

Define What Your Web App Will Do
Before opening a no-code builder, establish the problem your application will solve.

A common mistake is starting with the design instead of the function. An attractive interface will not compensate for an application that fails to help users complete their tasks.

Start by answering three questions:

Who will use the application?
What specific problem will it solve?
What should users be able to accomplish inside it?
For example, imagine you want to create an appointment booking application for a small business. Customers should be able to view available services, select a date, submit their contact information, and receive booking confirmation. The business owner should be able to review appointments and manage the schedule.

These requirements establish the essential features before development begins.

Create a short list of functions that the first version must include. For a booking application, that might mean service listings, appointment forms, availability management, booking records, and an administrative dashboard.

Avoid adding every possible feature at the beginning. Build the smallest useful version first, then expand it after testing.

Choose a No-Code Platform
Your platform determines which features you can build, how you manage application data, and how much technical flexibility you have.

Several platforms serve different types of projects.

Bubble
Bubble is worth considering when you need a web application with custom workflows, database operations, conditional logic, and interactive user interfaces. Its visual editor allows users to arrange interface elements and configure actions without manually writing application code.

Bubble's documentation covers interface design, databases, responsive layouts, workflows, and conditional behavior. These capabilities make it relevant to applications that require more than a conventional informational website. Bubble documentation and responsive design guide.

Examples include customer portals, booking systems, membership applications, and business dashboards.

Glide
Glide is useful when your application depends heavily on structured business data. Its platform supports data sources such as Glide Tables, Google Sheets, Excel, Airtable, and supported SQL databases, subject to the relevant plan and configuration requirements.

Its visual development tools let users combine data with interface components and actions. Glide documentation.

This makes Glide worth evaluating for inventory trackers, team directories, operational dashboards, and other applications that display and update organized records.

Webflow
Webflow is particularly relevant when visual website design, content management, and interactive website experiences are central to the project.

Its CMS supports structured, reusable content that can appear across multiple pages. The platform also provides visual site-building and publishing tools. Webflow Help Center.

For projects requiring complex application logic, extensive user-specific data, or advanced account management, assess whether Webflow alone meets the requirements or whether an additional application or integration is necessary.

How to make the choice
Do not select a platform solely because its interface looks easy to use. Check its database capabilities, supported integrations, authentication options, publishing arrangements, usage limits, and total cost.

Build a short prototype before committing to a paid plan. Confirm that the platform can support the functions your project actually needs.

Plan the Application's Pages and Navigation
Once you have selected a platform, map out the pages users will need.

A straightforward application might include:

Home page: Explains the application's purpose and directs visitors to its main functions.
Registration and login pages: Allow users to create accounts and access protected features, when accounts are required.
Dashboard: Displays information relevant to the current user.
Main function page: Provides the application's primary service, such as booking appointments or managing tasks.
Profile or settings page: Allows users to manage permitted account details.
Administrative page: Gives authorized staff access to management functions.
Not every application requires all these pages. A public directory, for example, may not need registration, while a private client portal probably will.

Sketch the navigation before building. Decide where each button leads and which pages require authentication. Keep important actions easy to locate, particularly on mobile screens.

Use consistent typography, spacing, colors, and button styles. A coherent interface makes the application easier to navigate and maintain.

Design the Interface With Visual Components
No-code builders generally provide visual components that can be placed on a page and configured through an editor.

Depending on the platform, these may include text blocks, buttons, forms, images, menus, tables, cards, navigation bars, and reusable containers.

Start with the components required for your core workflow.

For a booking app, you might create a service list, a date selection control, a contact form, a confirmation message, and a page showing existing appointments.

Give each component a clear purpose. A button labeled "Book Appointment" communicates its function more directly than a vague label such as "Continue" when the action creates a booking.

Pay attention to responsive design. Your application should remain usable on desktop computers, tablets, and smartphones. Bubble's responsive design documentation explains how layouts can adapt to different screen sizes within its visual editor. Read the responsive design guide.

Test the layout at several screen widths. Check whether forms remain readable, navigation remains accessible, and buttons are easy to tap.

Create the Database and Organize Your Data
Interactive applications usually need to store information. A booking application needs appointment records, a task manager needs task records, and a customer portal needs customer information.

Your no-code platform may provide a built-in database or allow you to connect an external data source.

Before adding records, identify the information your application must store.

For a booking system, you might need the following data types:

Users: Names, email addresses, and account identifiers.
Services: Service names, descriptions, and durations.
Appointments: Customer references, service references, dates, times, and booking statuses.
Keep related information organized instead of placing every field into one large, unstructured table.

Establish how records relate to one another. An appointment, for example, should reference the customer and service associated with it. This makes it easier to display booking details and manage records consistently.

Use the platform's visual data editor to create fields, configure relationships, and connect page components to the appropriate records.

If you use Glide, its documentation explains how to add and manage supported data sources through the Data Editor. External integrations may have plan requirements and synchronization considerations, so check those details before choosing your data architecture. Glide data source documentation.

Before entering real customer information, establish appropriate access permissions and avoid collecting data that the application does not need.

Add Interactivity With Workflows and Actions
This is the stage that turns a collection of pages into a working application.

An interactive feature responds to a user action. A button might save a record, a form might create an appointment, or a menu might display different content according to the user's permissions.

No-code platforms let you configure many of these behaviors through visual workflows, action settings, and conditional rules.

Consider a task management application. When a user clicks "Add Task," the application should validate the submitted information, save the task, and display the new record in the task list.

A workflow could follow this sequence:

The user opens the task form.
The user enters a task title and due date.
The application checks whether required fields are completed.
The user submits the form.
The application creates a task record.
The task list refreshes or displays the newly created task.
The application confirms that the task was saved.
Bubble documents workflows as sequences of actions triggered by events such as button clicks or page loads. Its visual tools also support conditions that determine how application elements behave. Bubble user manual.

You can apply similar principles to booking confirmations, search filters, account settings, approval processes, and task status updates.

Configure error messages as carefully as successful actions. If a required field is missing, explain what the user must correct. If an operation fails, do not display a success message.

Test each workflow independently before connecting all the features together.

Connect External Services When Necessary
Your application may need services that the no-code platform does not provide directly. Examples include email delivery, payment processing, calendar synchronization, customer relationship management, and external data sources.

Integrations can connect these services without requiring you to build every function yourself.

Start by identifying the exact task that needs an external service. If your booking application must send appointment confirmations, investigate supported email integrations. If it must accept online payments, review compatible payment providers and their requirements.

Check the following before connecting any service:

Whether the integration supports your intended workflow.
Whether it requires a paid subscription or usage-based fees.
What permissions it requests.
Whether it can exchange the necessary data with your application.
How errors and failed transactions are handled.
Some integrations require API credentials or configuration beyond basic drag-and-drop editing. Follow the provider's official documentation and never expose private API keys in publicly accessible page elements.

Add integrations only when they serve a clear purpose. Each additional service introduces another dependency that may require monitoring and maintenance.

Configure User Accounts and Data Security
If your application stores private information or offers different functions to different users, security must be part of the initial design.

Determine which users can view, create, edit, and delete each type of record. A customer should not automatically gain access to another customer's appointments merely because both accounts use the same application.

For example, a booking application might have customer and administrator roles. Customers can view their own bookings, while authorized administrators can manage the overall schedule.

Configure authentication, authorization, database privacy rules, and workflow conditions according to the platform's documentation. Hiding a button from a user is not sufficient protection if the underlying action or data remains accessible through another route.

Bubble's official security documentation explains how privacy rules restrict access to database records and why application builders must configure those protections correctly. Read Bubble's privacy rules guide.

Also consider secure account recovery, access to uploaded files, the handling of personal information, and the removal of access when a user no longer needs it.

If the application handles payments, sensitive customer information, or business-critical records, assess whether you need professional security testing before launch.

Test Every Important Function Before Launch
An application that works in the editor is not necessarily ready for public use.

Testing should cover the complete user journey, not just individual pages. Create test accounts and perform the same tasks that real users will perform.

For a booking application, test whether a customer can select a service, submit a valid appointment, receive the expected confirmation, and view the correct booking record.

Then test failure conditions. Submit an incomplete form, attempt to select an unavailable appointment time, and check what happens when a required integration fails.

Use this practical checklist:

All navigation links lead to the correct destinations.

Forms validate required fields.

Submitted records are saved correctly.

Search and filtering return the intended results.

Buttons trigger the correct actions.

Users cannot access records they are not authorized to view.

Pages remain usable on mobile and desktop screens.

Error messages explain what users should do next.

External integrations work as intended.

The application has been tested with realistic sample data.

Ask a few people who were not involved in building the app to test it. Their difficulties can reveal confusing navigation, unclear instructions, and errors that you overlooked.

Bubble provides a preview environment for testing an application before deployment. Its documentation also explains the distinction between development and live environments. Read the app preview guide.

Publish the App and Monitor Its Performance
When the application passes testing, prepare it for public use.

Review the platform's publishing requirements, domain options, subscription limits, and hosting arrangements. Configure the application's name, branding, and any required account or privacy information.

If you intend to use a custom domain, follow the platform's instructions for connecting it. Confirm that the application loads correctly through its intended public address and that its navigation and integrations continue to work after deployment.

Bubble, for example, documents deployment from its editor and distinguishes the development environment from the live application. Read the publishing guide.

After launch, monitor user feedback, application errors, data quality, and usage limits. Fix defects before adding more features. Keep backups or appropriate recovery arrangements where available, and review access permissions as your user base grows.

You should also review the platform's pricing as usage increases. A prototype with a few test users may have different resource requirements from a production application serving a large customer base. Check current plan terms rather than assuming that an initial free or low-cost arrangement will remain sufficient.

What Are the Limitations of No-Code Development?
No-code tools reduce the need to write application code, but they do not remove every technical constraint.

Complex integrations, unusual business rules, specialized performance requirements, and advanced security needs may require expert assistance or custom development. Some platforms also impose restrictions on integrations, data sources, hosting, or access to application logic.

Platform dependence is another consideration. Before building a business around a no-code application, understand how you can export your data, migrate to another service, maintain integrations, and recover from service interruptions.

You remain responsible for designing the application correctly, protecting user information, complying with applicable requirements, and testing changes before they affect customers.

The right platform is therefore not necessarily the one with the largest feature list. It is the one that can meet your specific requirements within your budget and technical capabilities.

Final Consideration
Building an interactive web app without writing code is a practical option for people who want to turn an idea into a working digital product without developing every component from scratch.

The process starts with a defined problem, followed by platform selection, interface design, database organization, workflow configuration, integrations, security, testing, and deployment.

For applications that require extensive custom workflows and database operations, evaluate Bubble. For data-driven business tools, consider Glide. For visually designed websites with structured content, investigate Webflow and determine whether additional application functionality is necessary.

Start with one useful feature, test it thoroughly, and expand only when the initial version works reliably. A smaller application that performs its intended tasks correctly is a better starting point than a complicated product filled with unfinished functions.

AI App Development Costs in 2026: A Developer's Honest Breakdown

Tue, 21 Apr 2026 08:06:57 +0000

Every developer has been in this conversation: a client or stakeholder asks how much an AI product will cost to build, and the honest answer — "it depends" — never lands well. Here's a more useful version of that answer, broken down the way engineers actually think about scope.

Start with the workflow, not the model

The most common scoping mistake is leading with model selection. Teams spend time debating which LLM to use before anyone has defined what the system actually needs to do. This creates estimates that look technical but are built on undefined requirements.
A more reliable approach: map the system blocks first. Input layer — data ingestion, validation, permissions. Intelligence layer — model routing, prompt logic, fallback behavior. Experience layer — interface flows, error states, trust prompts. Operations layer — monitoring, logging, governance, support.

This structure exposes non-model work early, which is where estimates most often break down.

Real cost ranges for production systems

These cover full production readiness, not prototypes or internal demos.
Assistant and support tools — $40K to $120K. Retrieval-augmented generation over internal knowledge, basic routing logic, chat interface. Complexity spikes with strict RBAC requirements, multi-language support, or high-accuracy domain constraints.

Meeting intelligence — $80K to $200K. Audio ingestion pipeline, diarization, summarization, structured action extraction, CRM or project tool integration. Recurring inference costs scale fast — model this before committing to pricing.

Recommendation and personalization engines — $120K to $350K. Behavior data pipelines, feature engineering, ranking logic, A/B experimentation layer. Backend complexity consistently exceeds frontend complexity by a wide margin.

Document automation and computer vision — $100K to $300K. OCR, layout parsing, classification, extraction pipelines. Annotation overhead and false-positive control drive QA costs well beyond model training.

The seven cost buckets engineers underestimate

Discovery and architecture — requirements definition, data audit, system design, dependency mapping. Skipping this creates technical debt before a single line of production code is written.
Product and model implementation — application engineering, model integration, orchestration, API layer. This is the visible work. The rest of this list is what gets missed.

Data preparation and governance — ingestion, cleaning, labeling, schema design, access controls, retention policies. In most real projects this takes two to three times longer than planned.
UX, trust, and error handling — output formatting, confidence signaling, graceful degradation, correction flows. These directly affect adoption metrics and are routinely treated as polish rather than core engineering work.

Quality, security, and compliance — load testing, adversarial testing, permission controls, audit logging, compliance checks. Deferred security work returns as incident response at peak usage.
Launch instrumentation — event schema design, analytics pipeline, funnel definitions, experiment infrastructure. Without this the team is flying blind post-launch.
Ongoing optimization — prompt versioning, model updates, latency tuning, cost controls, infrastructure scaling. This is not a phase that ends — it is a continuous workstream that should be staffed and budgeted from day one.

Hidden complexity that breaks timelines

Integration surface area is almost always underestimated. Connecting model outputs to existing enterprise systems — auth layers, legacy APIs, permission models, data formats — frequently takes longer than the model integration itself. Scope this explicitly and independently.
Reliability requirements in production are different from reliability requirements in staging. Auditability, rollback capabilities, graceful fallback chains, and SLA commitments add meaningful engineering effort that rarely appears in early proposals.

Usage modeling matters more than most teams realize. Inference costs at 10x expected volume can change the unit economics of an entire product. Run the numbers before launch, not after the first billing cycle.

A planning formula worth using

Total quarterly cost = delivery milestone budget + recurring usage budget + optimization reserve
Optimization reserve should be 15 to 30 percent of the delivery milestone budget depending on requirement uncertainty. Run three adoption scenarios — conservative, expected, aggressive — and evaluate cost sensitivity at each. Large swings between scenarios indicate areas that need architectural attention before scale.

The bottom line for engineers scoping AI work

The hardest part of AI cost estimation is not the model work — it is everything around the model. Data pipelines, integration layers, reliability infrastructure, and ongoing optimization consistently account for more total cost than the core ML components. Surfacing this early makes for better estimates, better conversations with stakeholders, and better products.

Full breakdown and planning framework: https://unicornplatform.com/blog/budgeting-ai-app-development-in-2026/

How to Keep a Telemedicine MVP Small Without Creating Bigger Problems Later

Thu, 16 Apr 2026 15:00:00 +0000

A lot of founders say they want to build a telemedicine MVP.
But when the feature list starts growing, it usually stops being one MVP.

It turns into:
A patient app
A doctor dashboard
An admin panel
Secure messaging
Video consultation
Billing
Maybe even EHR integration

That is where budgets start moving faster than expected.

One thing I have seen often in healthcare product planning is this: teams focus on screens first and compliance later. In the US market, that order creates problems. If your product handles patient data, HIPAA affects the build from day one. That means access controls, audit logs, vendor choices, data flow, and storage decisions cannot be treated as later clean-up work.

The smarter way to plan a telemedicine MVP is to narrow version one around one clear care journey.

For example, version one may only need:
Patient intake
Appointment booking
Secure video visits
Follow-up messaging
Basic provider access

That is very different from trying to launch a full virtual care platform in one go.

Another mistake is assuming that cost depends mostly on UI or number of screens. In telemedicine, pricing shifts more because of what sits underneath: roles, permissions, video setup, secure data handling, logging, and vendor agreements. Even a simple-looking workflow can become expensive if the backend responsibilities are heavy.

The article also makes a useful point about platform choice. If patients are the main daily users, mobile may lead. If providers work mostly from desks, a web dashboard may be more practical. In many cases, the first release ends up being a mixed setup: mobile for patients and web for providers.

The main lesson:
A telemedicine MVP should prove one workflow well, not imitate a complete hospital system too early.

I wrote a longer breakdown here for founders planning in the US market.

Why Many App Cost Calculators Still Miss the Real Work

Fri, 13 Mar 2026 14:30:00 +0000

Most app cost calculators look helpful at first.

They ask for a few inputs:

Platform
Number of screens
Complexity
Maybe a few features

Then they return a number.

The problem is not that calculators are useless. The problem is that many of them simplify the wrong part of the project. The visible part of an app is not always the part that decides the budget. That is why a lot of founders feel confused when they get different quotes for what sounds like the same product.

A short feature list may look like this:

Login
Profile
Payments
Notifications
Dashboard

That sounds simple enough. But behind those features sit questions like:

What backend rules are needed?
Does the app need admin tools?
How many user roles exist?
What happens when a payment fails?
What QA depth is included?
Who handles release work?
What is expected after launch?

If two teams answer those questions differently, they are not really pricing the same app. That is why one quote may look low and another may look high, even when both are based on the same screen list.

A lot of the budget difference usually comes from four areas.

1. Backend and Admin Work

The frontend gets most of the attention early because it is easy to picture.
But real products often need:

Dashboards
Roles and permissions
Logs
Exports
Support tools
Approval flows
Moderation actions

These parts often appear late in planning, even though they can add a lot of work.

2. QA Depth

Testing is often treated as a final step.
In practice, serious QA includes:

Device coverage
Regression testing
Edge cases
Re-checking after fixes
Release validation

If the product includes payments, subscriptions, messaging, or broader device support, the testing effort can increase quickly.

3. Integrations

Third-party tools always sound smaller than they really are. Payments, SMS, maps, analytics, storage, and notifications all create extra setup, testing, and failure handling work.

4. Release and Post-Launch Work

Launch is not the end of the technical effort.
Teams still need to deal with:

Environment setup
Build preparation
Submission steps
Review feedback
Crash monitoring
Updates
Ongoing fixes

That is why a calculator is only useful when it helps teams see what is behind the numbers. A better model would not just say, Your app costs X.

It should help people understand:

What is included
What makes the numbers move
What changes between MVP and a more complete version
Which feature choices affect time the most

That is the idea behind the calculator I’ve put together for USA startup teams.
It helps estimate:

Build hours
Budget range
Timeline
Feature impact
Maintenance planning

If you want the full guide and calculator, it is here.

Your App Worked Perfectly… Until the OS Killed It

Sat, 24 Jan 2026 22:03:23 +0000

A production story from real apps. For a long time, I thought process death was an edge case. Something you read about in docs. Something that might happen, but not in real life. After all, my apps worked fine. QA was happy. Users were using them.

Then production taught me otherwise.

It Started With Autonemo

While working on Autonemo, a vehicle tracking app, everything looked solid:

Live vehicle tracking
Trip status
Ongoing routes
Driver activity

You open the app → tracking works.
You background it → come back → still works.

Until users started reporting something strange:

“Sometimes when I come back to the app, tracking is gone.”
“The trip looks like it never started.”

No crashes.
No ANRs.
No error logs.

Just… wrong state.

The Bug I Couldn’t Reproduce

On my phone:

High RAM
Latest Android
No aggressive background killing

I could switch apps, come back, and everything was fine.

But real users?

Budget devices
Old OS versions
Heavy multitasking

That’s when I realized:

The OS was killing the app in the background.

Not pausing it. Not stopping it nicely.
Killing the process.

The Mistake (Flutter)

At that time, critical tracking state lived only in memory:

class TrackingState {
  bool isTripActive = false;
  String? vehicleId;
}

As long as the app was alive:

UI was correct
Tracking looked accurate

But once the OS killed the process:

Memory was wiped
State reset
App restarted as if nothing was happening

No crash = no alert.
Just broken logic.

“Okay, Fixed” — Then VivaUtilities Happened

Later, while working on VivaUtilities, a Flutter app for meal and leave management, I saw the same issue — but this time in a different form.

Users would:

Start applying for leave
Fill half the form
Switch apps (email, calendar, messages)
Come back…

And the form was empty.

Again:

No crash
No error
Just lost progress

And again, QA couldn’t reproduce it consistently.

The Common Pattern I Missed

I finally stopped looking at features and started looking at lifecycle.

Both apps had the same assumption:

“If the app goes to background, my state is still there.”

That assumption is wrong.

On Flutter:

Widgets rebuild
Controllers recreate
Providers restart

If the process is dead, everything in memory is gone.

The Flutter Fix: Persist What Matters

I changed how I decided what to persist.

Not everything. Only what would hurt to lose.

await prefs.setBool('is_trip_active', true);
await prefs.setString('vehicle_id', vehicleId);

Then restored it on app start, not later.

For UI-related state, I also started using state restoration (which I had ignored before):

class LeaveFormScreen extends StatefulWidget {
  const LeaveFormScreen({super.key});

  @override
  State<LeaveFormScreen> createState() => _LeaveFormScreenState();
}

class _LeaveFormScreenState extends State<LeaveFormScreen>
    with RestorationMixin {

  final RestorableString reason = RestorableString('');

  @override
  String get restorationId => 'leave_form';

  @override
  void restoreState(RestorationBucket? oldBucket, bool initialRestore) {
    registerForRestoration(reason, 'leave_reason');
  }
}

This alone prevented a whole class of “random reset” complaints.

Then Native Android Taught Me the Same Lesson (VivaCash)

I thought this was a Flutter-specific problem.

Then VivaCash proved me wrong.

VivaCash is a native Android app written in Java, handling sensitive MFS flows:

Amount input
Transaction steps
OTP flows
App switching (SMS, banking apps)

Users reported:

“I went to check OTP and came back — transaction restarted.”

Again:

No crash
No exception
Just lost state

The Java Trap: Trusting Memory Too Much

The code looked innocent:

public class PaymentViewModel extends ViewModel {
    public double amount = 0.0;
}

I assumed:

“ViewModel survives rotation, so I’m safe.”

But ViewModel does not survive process death.

When the OS killed the app:

ViewModel was recreated
Amount reset
Flow broken

The Real Fix on Android: `SavedStateHandle`

Once we moved critical state into SavedStateHandle, the issue disappeared:

public class PaymentViewModel extends ViewModel {

    private SavedStateHandle handle;

    public PaymentViewModel(SavedStateHandle handle) {
        this.handle = handle;
    }

    public void setAmount(double amount) {
        handle.set("amount", amount);
    }

    public double getAmount() {
        Double value = handle.get("amount");
        return value != null ? value : 0.0;
    }
}

Now:

Rotation → safe
Background kill → safe
Process recreation → safe

The Rule I Ship Apps With Now

After Autonemo. After VivaUtilities. After VivaCash.

This is the rule I never break:

If losing it would confuse or frustrate the user, it does not belong
only in memory.

Memory is temporary. The OS is ruthless. Users don’t care why it happened.

Why This Bug Is So Dangerous

It passes QA
It doesn’t crash
It only happens on real devices
It slowly destroys trust

And users don’t complain loudly. They just stop using your app.

Final Thought

Your app doesn’t fail when it crashes.

It fails when the OS kills it — and your app pretends nothing important was happening.

That’s a silent failure. And those are the worst ones.

Why Theme Setup Matters (More Than You Think)

Tue, 18 Nov 2025 10:30:26 +0000

Dark mode isn’t just aesthetics anymore — it’s part of the vibe. Users expect apps to feel native, polished, and flexible. Good theming isn’t just flipping background colors; it’s about creating a consistent design language that can scale across dozens of screens. Flutter makes this super smooth with its built-in theming system, but you’ve gotta wire it right from day one.

So let's set up a proper Light + Dark theme structure that’s clean, maintainable, and future-proof.

️ Step 1: Create Your Theme Files

Don’t dump theme code directly into main.dart. That’s chaos energy. Instead, create a dedicated folder:

lib/
theme/

light_theme.dart
dark_theme.dart
theme_colors.dart

Example: light_theme.dart
import 'package:flutter/material.dart';
import 'theme_colors.dart';

ThemeData lightTheme = ThemeData(
brightness: Brightness.light,
primaryColor: AppColors.primary,
scaffoldBackgroundColor: Colors.white,
appBarTheme: const AppBarTheme(

backgroundColor: Colors.white,
foregroundColor: Colors.black87,
elevation: 0,

),
colorScheme: const ColorScheme.light(),
);

Example: dark_theme.dart
import 'package:flutter/material.dart';
import 'theme_colors.dart';

ThemeData darkTheme = ThemeData(
brightness: Brightness.dark,
primaryColor: AppColors.primary,
scaffoldBackgroundColor: Colors.black,
appBarTheme: const AppBarTheme(

backgroundColor: Colors.black,
foregroundColor: Colors.white,
elevation: 0,

),
colorScheme: const ColorScheme.dark(),
);

Example: theme_colors.dart
import 'package:flutter/material.dart';

class AppColors {
static const primary = Color(0xFF6750A4);
}

Separating colors like this makes it easier to manage branding changes without nuking your whole codebase.

Step 2: Set Up Theme Switching

Most apps either follow system theme automatically or give users a toggle. Flutter makes both easy.

Inside main.dart:
import 'package:flutter/material.dart';
import 'theme/light_theme.dart';
import 'theme/dark_theme.dart';

void main() {
runApp(const MyApp());
}

class MyApp extends StatefulWidget {
const MyApp({super.key});

@override
State createState() => _MyAppState();
}

class _MyAppState extends State {
ThemeMode themeMode = ThemeMode.system;

@override
Widget build(BuildContext context) {

return MaterialApp(
  title: 'Themed App',
  theme: lightTheme,
  darkTheme: darkTheme,
  themeMode: themeMode,
  home: HomeScreen(
    onThemeChange: (mode) {
      setState(() => themeMode = mode);
    },
  ),
);

}
}

This gives your app three modes:
ThemeMode.light
ThemeMode.dark
ThemeMode.system (the smart default)

️ Step 3: Add a Toggle Switch in Your UI
Give users control. At minimum, drop a Switch somewhere in your settings screen.
Example settings widget:
class HomeScreen extends StatelessWidget {
final Function(ThemeMode) onThemeChange;
const HomeScreen({super.key, required this.onThemeChange});

@override
Widget build(BuildContext context) {

final currentBrightness = MediaQuery.of(context).platformBrightness;

return Scaffold(
  appBar: AppBar(title: const Text('Theme Demo')),
  body: Column(
    children: [
      ListTile(
        title: const Text("Light Mode"),
        leading: const Icon(Icons.light_mode),
        onTap: () => onThemeChange(ThemeMode.light),
      ),
      ListTile(
        title: const Text("Dark Mode"),
        leading: const Icon(Icons.dark_mode),
        onTap: () => onThemeChange(ThemeMode.dark),
      ),
      ListTile(
        title: const Text("System Default"),
        leading: const Icon(Icons.phone_android),
        subtitle: Text("Current: $currentBrightness"),
        onTap: () => onThemeChange(ThemeMode.system),
      ),
    ],
  ),
);

}
}

This setup is simple but super effective — and instantly feels like a real, production app.

Step 4: Customize Widgets with Theme Extensions (Pro Level)

Once your app grows, you’ll hit the limits of stock ThemeData. That’s where Theme Extensions come in — letting you build your own reusable style blocks.

Example:
class ExtraColors extends ThemeExtension {
final Color cardBackground;
const ExtraColors({required this.cardBackground});

@override
ExtraColors copyWith({Color? cardBackground}) {

return ExtraColors(cardBackground: cardBackground ?? this.cardBackground);

}

@override
ExtraColors lerp(ThemeExtension? other, double t) {

if (other is! ExtraColors) return this;
return ExtraColors(
  cardBackground: Color.lerp(cardBackground, other.cardBackground, t)!,
);

}
}

Add it inside your theme:

extensions: const [ ExtraColors(cardBackground: Colors.grey), ],

This is the kinda structure big apps use — scalable, organized, clean.

Step 5: Test Like a Pro
Don’t trust your eyes; test with Flutter’s built-in theme toggling.

Run:
flutter run --dart-define=theme=light
flutter run --dart-define=theme=dark

Or in DevTools:
Click the "Device Settings" tab
Flip system theme live
Watch your app glow up

Final Thoughts
Dark mode isn’t "optional polish" anymore. It’s part of the standard UX checklist. Flutter gives you a ridiculously good theming system out of the box — but only if you structure it right. With separate theme files, ThemeMode switching, extensions, and organized color management, your app instantly jumps into that premium tier where everything feels intentional.

Building “R U Ready” – My Flutter Dating App Development Journey

Tue, 04 Nov 2025 11:59:38 +0000

I’ve been working on a new project called R U Ready, a full-featured Flutter dating app, and it’s been one of the most technically enriching experiences in my Flutter journey.

The goal is to build a real-time, scalable, and intuitive dating platform using Flutter + Firebase as the core stack. I started with a modular architecture to ensure clean separation between UI, logic, and data layers — applying principles of Clean Architecture and MVVM for maintainability.

Key modules include:

Authentication Layer using Firebase Auth (Email/Mobile)

Profile Management with dynamic Firestore data binding

Swipe Engine built with custom animation controllers for smooth profile transitions

Chat System using Firestore real-time streams and optimized query listeners

App Theming & State Management implemented via Provider and ChangeNotifier for reactive UI updates

Throughout the process, I’ve learned how to fine-tune Firestore query performance, implement pagination, handle context-safe navigation, and optimize rebuilds using widget lifecycle awareness.

Currently, I’m focusing on extending the architecture for Reels and Group Chat features while integrating AdMob monetization and in-app upgrades.

Every commit teaches me something new about building production-grade apps with Flutter.

Understanding Prefix Sum: A Simple Concept With Powerful Impact

Sun, 26 Oct 2025 07:57:12 +0000

In DSA, some of the most elegant solutions come from simple ideas applied smartly. One such gem is Prefix Sum — a concept that can turn a brute force problem into an efficient one-liner.

Think of prefix sum like a running total that saves you from recalculating the same work again and again.

Why Prefix Sum Matters

Imagine you have an array of numbers and you’re repeatedly asked:

What’s the sum of elements between index `L` and `R`?

The naïve way would be looping from L to R every single time — O(n) per query. But what if you had already stored the total up to every point? Then answering each query becomes O(1). That’s the magic of prefix sums.

Real-World Example

Let’s say you’re analyzing daily sales data over a year.

Without prefix sum: every time you want to know total sales between Day 20 and Day 200, you loop and add 180 values.
With prefix sum: you just do prefix[200] - prefix[19]. Instant.

This idea is used everywhere — from analytics dashboards and stock trend calculations to optimizing subarray problems in competitive programming.

How It Works — Pseudocode

Given array arr[0..n-1]
Let prefix[0] = arr[0]

For i from 1 to n-1:
    prefix[i] = prefix[i-1] + arr[i]

Now, the sum of elements from L to R can be found in constant time:

if L == 0:
    range_sum = prefix[R]
else:
    range_sum = prefix[R] - prefix[L-1]

Why You Should Learn This Early

Prefix sum isn’t just another trick — it’s a building block. Once you master it, problems like “range sum queries,” “subarray sums,” or even some “difference array” techniques become intuitive. It also forms the foundation for 2D prefix sums (think image processing, matrix problems, heatmaps, etc.).

Explore a Real Problem

In my detailed Medium article, I’ve explained how to use this concept to find the sum of elements in a given range, step by step with a practical example and code.
Read it here

Learning prefix sum once can save you countless loops in future problems.
If you’re diving into DSA, this is one of those must-know techniques that will keep coming back in interviews and contests.

How Prefix Sum Powers Real-World Speed: From Games to Dashboards

Sat, 18 Oct 2025 08:11:28 +0000

Ever wondered how apps and games show instant totals—like scores, analytics, or stats without lag?
Behind that speed often hides a humble hero: Prefix Sum.

Imagine this:
You’ve got an array of numbers and multiple queries like:

“What’s the sum of values between index L and R?”

Looping through each query works… until you need to do it thousands of times. That’s when performance tanks.

The Real Trick

Prefix Sum precomputes totals so you don’t repeat work.

Example:
If arr = [2, 5, 1, 3], then prefix = [2, 7, 8, 11].

Want the sum from L to R?

Sum(L, R) = prefix[R] - prefix[L-1]

(Or just prefix[R] if L = 0).
No loops. Instant results.

Pseudo Code

# Build prefix sum
prefix[0] = arr[0]
for i from 1 to n-1:
    prefix[i] = prefix[i-1] + arr[i]

# Answer queries fast
for each (L, R):
    if L == 0:
        result = prefix[R]
    else:
        result = prefix[R] - prefix[L-1]

Real World Impact

Finance & Analytics : Quick running totals & range calculations
Games : Instant score or health bar updates
Data Dashboards : Fast aggregations over large datasets

Naive way → O(N) per query
Prefix Sum → O(1) per query

It’s a tiny trick with big real-world impact.

For a full explanation with code, visuals, and edge cases, check out my Medium:
Mastering Prefix Sum — The Foundation of Fast Queries

From Nobody to Category Leader: How We Accidentally Started the PhoneUse Race

Tue, 26 Aug 2025 13:57:12 +0000

Hey everyone,

Back in April, I shared an early demo of DroidRun a side project we built to let AI agents interact with Android phones like real users.

Originally, it was just a tool to automate app usage and collect structured market intelligence. No UI. No docs. No product. Just a working prototype.

Then things escalated. We posted a short demo. It went viral. Within 48 hours, we hit 2,000+ GitHub stars. Shortly after, we closed our first funding round.

Other teams started entering the space. A few copied our approach. A Chinese university lab briefly overtook us on benchmarks.But we kept building and open-sourced everything.

We launched DroidRun on Product Hunt in July and to our surprise, we became Product of the Day.

It was a huge moment that confirmed this new category PhoneUse agents was real.
Since then, we’ve been focused on turning a prototype into a framework and building an actual ecosystem around it.

Now, we’re looking for people who want to help shape what comes next:

Agent/LLM developers
Growth hackers & community people
Open-source contributors
Moderators for our new subreddit
This category is moving fast, and it’s still early. If you’re curious, skeptical, or just want to build — come join us.

www.droidrun.ai

We’re still just getting started.

Why I Started Creating Models in My Flutter Project

Wed, 20 Aug 2025 18:01:17 +0000

When I was building my music app in Flutter, I began with the “quick and dirty” way of handling data. You know that vibe coding flow — fetch some JSON, dump it in a Map<String, dynamic>, and just wire it up to the UI. It felt fast at first, but it quickly turned into a mess.

Take this example: I was fetching playback data from my service and passing it around like this:

class PlaybackWidget extends StatelessWidget {
  final Map<String, dynamic> playbackData;

  PlaybackWidget({required this.playbackData});

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Text("Now playing: ${playbackData['title']}"),
        Text("Artist: ${playbackData['artist']}"),
        Text("Mode: ${playbackData['playbackMode']}"),
      ],
    );
  }
}

It worked. But every time I typed playbackData['title'], I felt uneasy. One typo like playbackData['titel'] and boom — runtime error. On top of that, the widget didn’t tell me what kind of data it really expected. Was playbackMode a string? An enum? A number? I had to keep it all in my head.

Switching to Models

After wrestling with this a few times, I finally decided to create a proper model for my playback data.

enum PlaybackMode { repeat, shuffle, normal }

class Playback {
  final String title;
  final String artist;
  final PlaybackMode playbackMode;

  Playback({
    required this.title,
    required this.artist,
    required this.playbackMode,
  });

  factory Playback.fromJson(Map<String, dynamic> json) {
    return Playback(
      title: json['title'],
      artist: json['artist'],
      playbackMode: PlaybackMode.values.firstWhere(
        (e) => e.toString() == 'PlaybackMode.${json['playbackMode']}',
      ),
    );
  }

  Map<String, dynamic> toJson() {
    return {
      'title': title,
      'artist': artist,
      'playbackMode': playbackMode.name,
    };
  }
}

Now my widget looked much cleaner:

class PlaybackWidget extends StatelessWidget {
  final Playback playback;

  PlaybackWidget({required this.playback});

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Text("Now playing: ${playback.title}"),
        Text("Artist: ${playback.artist}"),
        Text("Mode: ${playback.playbackMode.name}"),
      ],
    );
  }
}

Suddenly everything felt safer. Autocomplete worked, I didn’t worry about typos, and my code told me exactly what kind of data I was dealing with.

What I Learned

Models might look like “extra code” at first, but in reality, they save time and mental energy. Instead of juggling raw maps everywhere, you give your app a solid data structure to lean on.

In my case, once I switched to models in my music app, my code got way easier to maintain. Adding new fields, refactoring, or passing data between widgets stopped being a headache.

So if you’re just hacking away in Flutter and think models are overkill — trust me, they’re not. Future-you will thank present-you for adding them.

How I Paid Off a Little Technical Debt in My Flutter Music App

Fri, 15 Aug 2025 12:08:11 +0000

So here’s the story.
I was facing a technical debt kind of issue in my Flutter music app — my MusicPlaybackService was doing two jobs:

Talking to the audio engine (audio_service + just_audio) to play/pause/skip.
Acting like a ChangeNotifier to update the UI about song lists, current song, etc.

Why this was bad

At first, it felt convenient.
"Why not just let one class handle everything, right?"

But here’s the problem with one giant class doing multiple jobs:

Unnecessary widget rebuilds: Even small playback state changes could cause the entire UI to refresh.
Harder debugging: Was a bug coming from the UI or the audio engine? You never know without digging deep.
Tight coupling: Any change in playback logic risked breaking the UI.
Poor testability: Couldn’t mock or test the UI without pulling in the full audio player.

The Refactor

I split the responsibilities like this:

Before:

MusicPlaybackService
   ↳ Handles playback (play/pause/skip)
   ↳ Stores allSongs, currentSong
   ↳ Notifies UI of changes

After:

MusicPlaybackService   → Only handles audio playback logic
PlaybackProvider       → Holds UI-facing state & notifies widgets

How the new structure works

MusicPlaybackService → Talks to the background audio handler, keeps pure playback logic. No notifyListeners() here.
PlaybackProvider → Watches the service, stores the current song list, play state, etc., and only notifies the UI when something UI-relevant changes.

Benefits I noticed immediately

Fewer unnecessary rebuilds → smoother scrolling, faster tab switches.
Easier debugging → I instantly know whether an issue is in the audio engine or UI.
More modular code → I can swap playback logic without rewriting UI state.
Better testing → I can mock the provider without worrying about actual audio playback.

Lesson learned

If your service class is doing too much — step back and split the responsibilities.
It’s like having a drummer who’s also trying to do the vocals and mix the sound live. Eventually… something’s going to be off-beat.

Why does my Flutter music player jump from 0:00 to actual time? (One-liner fix inside!)

Fri, 08 Aug 2025 05:35:20 +0000

I hit a weird (but common) UI issue in my Flutter music player app:

Whenever I tapped the mini player to open the full screen player, the seek bar would flash 0:00 for a split second — and then jump to the actual current timestamp.

It looked like playback was restarting every time. Spoiler: it wasn’t.

What was happening?

The full screen player uses a StreamBuilder to listen to the current position (Stream). But when the widget builds, that stream hasn’t emitted anything yet — so it shows 0:00 by default.

Only after the stream sends the actual position does the UI update. That tiny delay causes the annoying visual "jump".

initialData: musicService.currentPosition,

Adding this to the StreamBuilder gives it a starting value immediately — the latest position we already have from our service.

So now the UI starts at the right place without waiting for the stream to emit.

No more flicker. No more weird jumps. Just smooth playback

Hope this helps someone else!

Music App Bug: Songs Broke on Switching — Here’s Why

Sun, 03 Aug 2025 22:32:31 +0000

I was facing this annoying issue in Flutter music player:

When you tap songs quickly (like switching from one to another), playback breaks, mini player disappears, and you have to tap again to play. It was 2-3 times out of every 10 switch.

It took me a while to trace it. I tried:

Making our playback function async
Adding delays
Debugging tap triggers

But nothing worked.

Then I found the real culprit:

await _player.stop(); //  this innocent-looking line was breaking everything

The Wrong Code

In the background audio handler's updateQueue() method:

Future<void> updateQueue(List<MediaItem> newQueue) async {
  final newAudioSources = newQueue.map((item) {
    final uri = item.extras?['uri'] as String;
    return AudioSource.uri(Uri.parse(uri));
  }).toList();

  await _player.setAudioSource(_playlist, initialIndex: 0);
  await _player.stop(); // ❌ this line breaks playback!

  queue.add(newQueue);
}

What’s the Problem?

This creates a race condition:

setAudioSource() loads and prepares the new song(s).
Immediately after, stop() wipes the loaded source.
So by the time the player is supposed to play, there's nothing left
to play.

This bug especially shows up during rapid song switching, because set -> stop -> play happens too fast and gets out of sync.

The Right Code

Future<void> updateQueue(List<MediaItem> newQueue) async {
  final newAudioSources = newQueue.map((item) {
    final uri = item.extras?['uri'] as String;
    return AudioSource.uri(Uri.parse(uri));
  }).toList();

  _playlist.clear();
  _playlist.addAll(newAudioSources);

  await _player.setAudioSource(_playlist, initialIndex: 0);

  if (_player.playing) {
    await _player.play();
  }

  queue.add(newQueue);
}

If you're using just_audio and audio_service, never call stop() right after setAudioSource().
You're basically loading a song and immediately throwing it away.

Let the player handle resets internally unless you truly need to stop everything.

Happy building!

Development Journey

Sun, 03 Aug 2025 05:30:05 +0000

Whether it's native mobile development with Java/Kotlin or building cross-platform apps with Flutter, the journey from idea to launch is a mix of creativity, engineering, and problem-solving.

During development, I focus on:

Scalable architecture (MVVM, Clean Architecture)

Crash-free experiences with proper null safety & exception handling

Clean UI/UX that adapts to all screen sizes

Battery & network optimization for real-world usage

Modular & maintainable code

Native integrations (Maps, Sensors, Notifications)

Post-release, app maintenance is just as critical:

Library & SDK upgrades

Monitoring with Firebase Crashlytics or Sentry

Ensuring Play Store compliance

Responding to user feedback with meaningful updates

I’m currently working on projects that blend user delight with solid performance — the kind of builds that make both developers and users smile.

Let’s connect, collaborate, or just geek out over code!
DM me if you're building something amazing.

More here:
Portfolio: https://coderlegion.com/user/Dilip Kumar
✍️ Medium: https://medium.com/@dilip.kumar.96995
Dev.to: https://dev.to/dilip_kumardk_b41b9418
LinkedIn: https://www.linkedin.com/in/dilip-kumar-327653308/
X/Twitter: https://x.com/dilipdk1994
Facebook: https://www.facebook.com/profile.php?id=61575617745742
Threads: https://www.threads.com/@dkdilip94k
Instagram: https://www.instagram.com/dkdilip94k/

Lightweight Flutter Development Environment Setup for Beginners

Sat, 02 Aug 2025 01:47:26 +0000

When I first started with Flutter, I was hyped. That excitement lasted right up until I installed Android Studio and realized I had just turned my humble laptop into a jet engine. Everything lagged. My RAM was crying. Booting a sample app felt like launching Photoshop… three times.

If you’ve got a low-end PC or just don’t want to waste half your RAM on tools you don’t need, I’ve got some good news: you can build Flutter apps without Android Studio or an emulator, and the experience is way smoother than you’d expect.

In this post, I’ll show you a lean, beginner-friendly setup that’s fast, easy, and runs great on modest machines. You’ll go from installing Flutter to running your first app on a real Android device, no bloat, no sweat.

Why Skip Android Studio and Emulators?

Resource hog: Android Studio is heavy, especially on lower-end systems.
Slow startup: Emulators are notoriously slow, and even fast machines struggle.
Overkill: Most beginners don’t need all the advanced features IDEs offer.
Better testing: Physical devices give real-world feedback, touch, screen sizes, and performance.

So instead of the typical heavyweight stack, I put together a setup that focuses only on the essentials:

️ Tools You’ll Use

Here’s the minimalist toolkit:

VS Code: Lightweight editor with just the Flutter & Dart extensions.
Flutter SDK: The main framework, of course.
Physical Android Device + USB – Real hardware > virtual device.
Scrcpy: A slick screen mirroring tool for real-time device display on your PC.

And if you want to skip a few manual steps, I also built a small free tool that automates part of the setup and makes launching your project a one-click process (link at the end of the post ).

Step-by-Step Setup

1. Install Flutter SDK

Start by downloading Flutter from the official Flutter site. Extract the archive somewhere like C:\flutter or your home directory on Linux/macOS.

Then add the flutter/bin directory to your system’s PATH variable so you can run flutter from any terminal.

Finally, verify everything’s okay with:

flutter doctor

This checks for missing dependencies and gives setup suggestions.

2. Install VS Code and Extensions

Download Visual Studio Code. Once installed, add these extensions:

Flutter (from Dart Code)
Dart (from Dart Code)

These give you hot reload, widget trees, snippets, and more, without the heavy IDE baggage.

3. Enable Developer Mode on Your Android Device

You’ll be using a real phone instead of an emulator, it's lighter, faster, and more realistic.

Here’s what to do:

Go to Settings > About Phone
Tap Build number 7 times to enable Developer Options
Head to Developer Options and enable USB Debugging
Plug in your phone and allow USB permissions when prompted

Then run:

flutter devices

You should see your phone listed. If not, you may need drivers (on Windows) or to install ADB tools (on Linux/macOS).

4. Install and Run Scrcpy

This is the magic sauce. Scrcpy mirrors your Android screen to your desktop in real time, without the lag or resource drain of an emulator.

You can install it via:

GitHub Releases
Or package managers like Scoop or Chocolatey (Windows)

Once installed, run scrcpy in your terminal, and your device screen pops up on your desktop, touch works, mouse works, and latency is super low.

5. Launch Your App

Now you're ready to run your app:

Open your project in VS Code
Connect your phone
Run:

flutter run

Or hit F5 in VS Code.

The app runs directly on your device, and mirrors via Scrcpy. Hot reload works like magic, and your PC stays cool and quiet.

Why This Works (and Works Well)

VS Code is snappy and customizable.
Flutter CLI handles all the build/run logic.
Real devices give better debugging signals and real-world testing.
Scrcpy feels like an emulator without being one, it's lightweight, fast, and surprisingly powerful.

This setup is perfect for:

Students or devs with 4–8GB RAM machines
Those just learning Flutter
Anyone tired of emulator lag or Android Studio boot times

Bonus: Free Setup Tool

To make life easier, I created a small free tool that helps automate part of this setup. It:

Launches your project with flutter run
Opens Scrcpy automatically
Simplifies environment setup

The tool is available for free at the bottom of the detailed setup guide on Kumotechs:
Detailed Setup Guide + Tool on Kumotechs

It includes a .bat file for Windows and a quick Markdown setup guide to help you get started faster.

Final Thoughts

I’ve used this setup on a low-spec laptop (imagine: 4GB RAM, Celeron, cracked screen) and still managed to run, build, and debug real Flutter apps with no drama. If you’re new to Flutter or just want a cleaner way to work, this setup is game-changing.

Flutter doesn’t have to be heavy. You just need the right tools, and maybe a little rebellion against Android Studio.

Check out the full post on Kumotechs for the full code snippets, common pitfalls, VS Code tricks, and to grab the free tool.
Full Post Here

Got questions or wanna share your setup? Drop a comment below. Let’s build smarter.

Query Smarter, Not Harder

Sat, 26 Jul 2025 19:58:21 +0000

If you're building a music app with on_audio_query, it’s tempting to call querySongs() everywhere—home screen, playlists, search, etc. But this means repeated storage scans → slower UI, battery drain, and unnecessary complexity.

The Wrong Way – Querying Every Time

final OnAudioQuery audioQuery = OnAudioQuery();

Future<List<SongModel>> getSongs() async {
  return await audioQuery.querySongs(); // Called in every screen
}

In each screen:

final songs = await getSongs(); // Repeats scan again

Fetch once in a service (e.g., MusicPlaybackService):

class MusicPlaybackService extends ChangeNotifier {
  List<SongModel> _allSongs = [];

  Future<void> loadSongs() async {
    final OnAudioQuery query = OnAudioQuery();
    _allSongs = await query.querySongs();
    notifyListeners();
  }

  List<SongModel> get allSongs => _allSongs;
}

Provide it globally:

runApp(
  ChangeNotifierProvider(
    create: (_) {
      final service = MusicPlaybackService();
      service.loadSongs(); // Fetch once
      return service;
    },
    child: MyApp(),
  ),
);

Reuse anywhere without re-querying:

final allSongs = context.watch().allSongs;

Benefits

No repeated disk access.
Faster UI transitions (playlist, search, player use the same list).
Centralized state → easier maintenance.

Fixing a Tricky Playback Issue in My Flutter Music App

Thu, 24 Jul 2025 10:37:42 +0000

I recently ran into a subtle but super frustrating issue in my Flutter music player app using just_audio and audio_service. It had to do with updating the playback queue when selecting a new song — and I want to share how I fixed it.

The Problem

Let’s say I have 5 songs:

a  b  c  d  e

Here's what was happening:

I open the app and click on song b.

Music starts playing . I can see the notification with controls.

I click next in the notification → it moves to c. Perfect!

I go back to the app and tap on song a.

Now... song plays but playback control like next and previous don't work.

So clearly, something went wrong when I tried to load a new playlist and song from the UI.

My (Buggy) Code

This is how I was updating the queue in my AudioHandler:

Future<void> updateQueue(List<MediaItem> newQueue) async {
  await _player.stop();              // Stop current audio
  _playlist.clear();                 //  Clear existing playlist

  final audioSources = newQueue.map((item) {
    final uri = item.extras?['uri'] as String;
    return AudioSource.uri(Uri.parse(uri));
  }).toList();

  _playlist.addAll(audioSources);   //  Add new items to old list
  await _player.setAudioSource(_playlist); //  Reuse the same playlist

  queue.add(newQueue);              //  Update the queue
}

The Hidden Issue

I was clearing and modifying the same _playlist instance that was already connected to the player.

just_audio doesn't always like it when you mutate a ConcatenatingAudioSource after it's been set — especially if it's already active in playback.

That caused inconsistent behavior.

The Fix: Use a Fresh Playlist Instance

Instead of modifying the existing _playlist, I now create a brand new ConcatenatingAudioSource every time I update the queue:

@override
Future<void> updateQueue(List<MediaItem> newQueue) async {
  await _player.stop(); // Stop safely

  final newAudioSources = newQueue.map((item) {
    final uri = item.extras?['uri'] as String;
    return AudioSource.uri(Uri.parse(uri));
  }).toList();

  final newPlaylist = ConcatenatingAudioSource(children: newAudioSources); // Fresh playlist

  await _player.setAudioSource(newPlaylist); // Clean set

  _playlist.clear();         // Optional: if you track items
  _playlist.addAll(newAudioSources);

  queue.add(newQueue);       // Update queue after setting source
}

When working with just_audio and audio_service, always pass a new AudioSource instance when switching playlists or queues.
Avoid mutating an existing one after it’s been assigned to the player. Otherwise, you'll run into strange bugs like:

Next/Previous buttons breaking
Playback getting stuck
Notifications going out of sync

How AI Flipped the Way We Learn to Code

Fri, 18 Jul 2025 16:51:56 +0000

Not long ago, learning to code meant starting with fundamentals, reading documentation, and slowly building projects from scratch.

Today, the process feels completely different.

I often begin by asking an AI to generate the code. Then, when something breaks—or doesn’t work the way I expect—I dig into the details, debug line by line, look into tutorials, articles and figure out the logic afterward.

It’s like learning in reverse: build first, understand later. And honestly, it’s a surprisingly effective way to learn fast.

AI hasn’t just changed the tools we use—it’s reshaping the entire learning process.

Do you find yourself learning this way too? Or do you stick to the traditional “concepts first” approach?

Reelora

Thu, 03 Jul 2025 08:09:19 +0000

Body Highlights:

Journey of building Reelora from scratch

Key features (Smart Search, Pagination, Firebase Login, TMDB API integration)

UI decisions (Dark Mode, shimmer loaders, scroll-based triggers)

Handling offline states and in-app updates

Open testing feedback loop & future plan

CTA:
Try the app on Play Store (Open Testing):
https://play.google.com/store/apps/details?id=com.dk.reelora

Live on Play Store this Sunday
iOS coming next

Coder Legion - Recent posts tagged appdevelopment

9 Affordable Mobile App Development Companies in the UAE for Startups in 2026

1. DXB APPS

2. A2Solutions

3. Mobiria Solutions

4. Intertec Systems

5. SafCodes

6. AADX

7. Business Apps

8. WallStreet Mobile Apps

9. Techasoft

How to Choose an Affordable Mobile App Development Company in UAE

Final Thoughts

How to Build an Interactive Web App Without Writing Code

AI App Development Costs in 2026: A Developer's Honest Breakdown

How to Keep a Telemedicine MVP Small Without Creating Bigger Problems Later

Why Many App Cost Calculators Still Miss the Real Work

1. Backend and Admin Work

2. QA Depth

3. Integrations

4. Release and Post-Launch Work

Your App Worked Perfectly… Until the OS Killed It

It Started With Autonemo

The Bug I Couldn’t Reproduce

The Mistake (Flutter)

“Okay, Fixed” — Then VivaUtilities Happened

The Common Pattern I Missed

The Flutter Fix: Persist What Matters

Then Native Android Taught Me the Same Lesson (VivaCash)

The Java Trap: Trusting Memory Too Much

The Real Fix on Android: SavedStateHandle

The Rule I Ship Apps With Now

Why This Bug Is So Dangerous

Final Thought

Why Theme Setup Matters (More Than You Think)

Building “R U Ready” – My Flutter Dating App Development Journey

Understanding Prefix Sum: A Simple Concept With Powerful Impact

Why Prefix Sum Matters

What’s the sum of elements between index L and R?

Real-World Example

How It Works — Pseudocode

Why You Should Learn This Early

Explore a Real Problem

How Prefix Sum Powers Real-World Speed: From Games to Dashboards

The Real Trick

Pseudo Code

Real World Impact

From Nobody to Category Leader: How We Accidentally Started the PhoneUse Race

Why I Started Creating Models in My Flutter Project

Switching to Models

What I Learned

How I Paid Off a Little Technical Debt in My Flutter Music App

Why this was bad

The Refactor

How the new structure works

Benefits I noticed immediately

Lesson learned

Why does my Flutter music player jump from 0:00 to actual time? (One-liner fix inside!)

What was happening?

Music App Bug: Songs Broke on Switching — Here’s Why

The Wrong Code

What’s the Problem?

The Right Code

Development Journey

Lightweight Flutter Development Environment Setup for Beginners

Why Skip Android Studio and Emulators?

️ Tools You’ll Use

Step-by-Step Setup

1. Install Flutter SDK

2. Install VS Code and Extensions

3. Enable Developer Mode on Your Android Device

4. Install and Run Scrcpy

5. Launch Your App

Why This Works (and Works Well)

Bonus: Free Setup Tool

Final Thoughts

Query Smarter, Not Harder

The Wrong Way – Querying Every Time

The Better Way – Query Once, Share via Provider

Fixing a Tricky Playback Issue in My Flutter Music App

The Real Fix on Android: `SavedStateHandle`

What’s the sum of elements between index `L` and `R`?