DEV Community: Ali Ahsan

I Built an AI-Powered BusinessOS in 3 Days with Cursor — Here's What I Learned About Modern Software Engineering

Ali Ahsan — Tue, 30 Jun 2026 05:39:22 +0000

Over the last three days, I built an AI-powered BusinessOS application using Cursor Pro. The experience was fascinating because it gave me a firsthand look at how AI-assisted development is changing the way software can be built.

The backend was developed with .NET 10, ASP.NET Core, Entity Framework Core, ASP.NET Identity, JWT Authentication, RAG (Retrieval-Augmented Generation), Fluent Validation, Serilog, SQL Server, and other supporting libraries and architectural patterns. The frontend was built with Angular, Bootstrap, Chart.js, TypeScript, and modern web development practices to create a responsive and scalable user experience.

Yes, a large part of the implementation was generated through AI-assisted workflows. I used prompts from OpenAI and orchestrated the development process through Cursor. However, this journey reinforced an important lesson: AI can generate code, but it cannot replace software engineering decisions.

One thing I will not do is share a localhost URL and claim that everything magically works. I have spent years learning software development fundamentals from scratch, and that experience made a huge difference during this project. Understanding architecture, database design, authentication, API structure, business workflows, scalability concerns, and trade-offs allowed me to guide the AI rather than simply accept whatever it generated.

The most surprising part was the speed. Building the same application manually would likely have taken months of development time. With AI assistance, I was able to move significantly faster and focus more on architecture, validation, integration, and product decisions.

There were also some interesting challenges. I burned through millions of tokens across multiple sessions. The project grew rapidly, generated a large number of files, consumed considerable storage during development, and occasionally pushed both the tooling and my machine to their limits.

At one point, I could feel burnout approaching. Instead of forcing myself to continue coding endlessly, I paused and solved a couple of LeetCode problems before returning to the project. That small break helped me stay productive and maintain focus.

My biggest takeaway from this journey is that orchestration is becoming one of the most valuable skills in modern software engineering. Having a clear database design, well-defined goals, a solid architecture, and an understanding of trade-offs matters more than ever. AI can accelerate implementation, but engineers still need to decide what should be built, why it should be built, and how all the pieces fit together.

AI is dramatically increasing development speed, but good engineering judgment remains the real multiplier.

This project reminded me that the future belongs to developers who can combine strong fundamentals with AI-powered workflows. The tools are evolving rapidly, but understanding systems, architecture, and trade-offs is what turns generated code into a real product.

Building this was an incredible learning experience, and it gave me an even clearer picture of what is possible with modern development.

How to Enhance Learning Speed?

Ali Ahsan — Tue, 23 Jun 2026 04:09:30 +0000

Learning faster is one of the most valuable skills in today’s fast-changing world. Whether you’re a student, a developer, or someone trying to upskill in your career, the ability to absorb and apply knowledge quickly gives you a serious advantage.

But here’s the important truth: learning speed is not a talent — it’s a system.
You don’t “become fast” at learning. You build conditions that make learning faster.

Let’s break down what actually works.

Understand How Your Brain Learns (Not How You Think It Learns)

Most people assume learning means reading more or watching more tutorials. But real learning happens in three steps:

Encoding (understanding new information)
Storage (consolidating it in memory)
Retrieval (being able to use it)

If you skip retrieval, you don’t really learn — you just recognize information.

The fastest learners focus on recall over re-reading.

Instead of re-reading notes, try:

Closing the book and explaining the concept out loud
Writing what you remember
Teaching it to someone else

Use Active Recall (The Fastest Learning Hack)

Active recall is the process of forcing your brain to retrieve information without looking at it.

Example:
Instead of reading a programming concept 5 times, ask:

“Can I explain this without looking?”
“Can I solve a problem using it?”

This creates stronger neural connections and drastically improves retention.

If passive learning is “watching someone lift weights,” active recall is “actually lifting them.”

Spaced Repetition Beats Cramming Every Time

Your brain forgets information quickly unless it’s reinforced over time.

The forgetting curve is real — you lose most information within days if you don’t revisit it.

Spaced repetition fixes this:

Review after 1 day
Then after 3 days
Then after 7 days
Then after 15+ days

This method helps you learn more in less total study time.

Learn in “Problem Mode,” Not “Content Mode”

Most learners stay in content consumption mode:

Watching tutorials
Reading blogs
Highlighting notes

Fast learners switch to problem-solving mode early.

For example:
If you're learning programming:

Don’t just watch CRUD tutorials
Build a small project immediately
Break things and fix them

Mistakes are not failures — they are accelerated learning signals.

Reduce Cognitive Load (Stop Multitasking)

Your brain has limited working memory. If you overload it, learning slows down.

Avoid:

Switching tabs constantly
Studying multiple topics at once
Multitasking while learning

Instead:

Focus on one concept at a time
Use deep work sessions (25–50 minutes)
Remove distractions completely

Speed comes from focus, not rush.

Teach What You Learn (Feynman Technique)

One of the most powerful learning methods is teaching.

If you can’t explain something simply, you don’t understand it yet.

Try this:

Learn a topic
Explain it in simple language
Identify gaps
Re-learn and simplify again

This instantly exposes weak understanding and strengthens memory.

Build Feedback Loops, Not Just Study Time

Most people measure learning by hours. Fast learners measure by feedback.

Ask:

Did I solve something?
Did I improve compared to yesterday?
What mistake did I repeat?

Without feedback, learning becomes slow and blind.

Final Thoughts

Learning speed is not about consuming more information. It’s about building a system where your brain is forced to:

Recall instead of recognize
Practice instead of watch
Teach instead of just read
Focus instead of multitask

Once you shift from passive learning to active learning, your speed increases naturally — without extra effort.

The goal is simple:

Don’t study harder. Learn smarter.

The One GitHub Repository Every System Design Learner Should Bookmark

Ali Ahsan — Mon, 15 Jun 2026 10:50:59 +0000

When I first started learning system design, I made the same mistake many developers make.

I spent hours watching YouTube videos, saving courses, and collecting blog posts. Every resource seemed to explain a small piece of the puzzle, but I struggled to connect everything together.

Questions like these kept appearing in my mind:

How does Netflix handle millions of users?
Why do companies use caching?
When should I choose SQL over NoSQL?
What exactly is database sharding?
How do large systems stay available even when servers fail?

Finding answers was difficult because most resources focused on individual concepts rather than the bigger picture.

Then I discovered a GitHub repository that changed the way I learned system design.

System Design Primer

Repository Link:

https://github.com/donnemartin/system-design-primer

With more than 300,000 stars, System Design Primer is one of the most popular software engineering repositories on GitHub.

But its popularity is not the reason I recommend it.

What makes it valuable is how it organizes complex system design concepts into a structured learning path.

Instead of jumping randomly between topics, you can learn how modern systems are built from the ground up.

What You'll Learn

1. Scalability Fundamentals

One of the first concepts every engineer encounters is scalability.

The repository explains:

Vertical Scaling
Horizontal Scaling
Load Distribution
Performance Bottlenecks

Many developers understand how to build applications.

Fewer understand how to keep those applications running when traffic grows from hundreds of users to millions.

This section provides that foundation.

2. Load Balancing

Imagine your application receives thousands of requests every second.

A single server cannot handle unlimited traffic.

This is where load balancers become essential.

The repository explains:

How load balancers work
Why they improve availability
Different balancing strategies
Real-world architecture examples

Understanding this topic alone can significantly improve your architectural thinking.

3. Caching

Caching is one of the simplest ways to improve performance.

Instead of repeatedly fetching data from a database, frequently accessed information can be stored in memory.

The repository covers:

Cache-aside pattern
Write-through caching
Cache invalidation
Distributed caching concepts

These are techniques used by companies such as Netflix, Facebook, and Amazon to reduce latency and improve user experience.

4. SQL vs NoSQL

This is one of the most common questions in system design interviews.

Many developers know the definitions.

Fewer understand the trade-offs.

System Design Primer explains:

Relational databases
NoSQL databases
Consistency models
Use cases for each approach

After studying this section, database decisions become much easier.

5. Database Sharding

As applications grow, databases eventually become bottlenecks.

At that point, simply upgrading hardware is no longer enough.

The repository introduces concepts such as:

Sharding
Replication
Partitioning
Database scaling strategies

These topics are critical for understanding large-scale systems.

6. Distributed Systems

This is where system design becomes truly interesting.

The repository explores:

CAP Theorem
Consistency
Availability
Partition Tolerance
Distributed architecture challenges

These concepts help explain why building reliable systems at scale is so difficult.

And why large technology companies invest heavily in infrastructure engineering.

Why I Recommend This Repository

Many learning resources teach system design.

Very few teach it in a structured and practical way.

System Design Primer succeeds because it:

Starts from fundamentals
Uses diagrams extensively
Explains trade-offs clearly
Covers interview preparation
Provides references for deeper learning

Whether your goal is:

Becoming a better backend developer
Preparing for system design interviews
Understanding large-scale architectures
Growing into a senior engineering role

This repository provides tremendous value.

My Advice

Don't try to read the entire repository in one weekend.

Instead:

Week 1:
Focus on scalability and load balancing.

Week 2:
Learn caching and databases.

Week 3:
Study distributed systems and CAP theorem.

Week 4:
Practice solving system design problems.

Consistency will teach you far more than rushing through the material.

Final Thoughts

The internet is full of system design resources.

Courses, videos, books, and blogs are all useful.

But if I had to recommend just one free resource for developers who want to understand how modern software systems work, System Design Primer would be near the top of the list.

It's free.

It's practical.

And it's one of the best learning resources available on GitHub today.

Repository:
https://github.com/donnemartin/system-design-primer

If you're serious about software engineering, it's worth bookmarking.