It Started With “We Need a Website” — And Turned Into Something Much Bigger

Arabian Insights — built for Qatar’s workforce needs.

My journey of building Arabian Insights, a B2B business website in Qatar, from a simple idea into a real digital platform designed to help people understand, trust and contact the company

“We need a website for our company.”

That was basically where this project started.

It sounded simple.

Build a few pages.

Add the company details.

Show the services.

Add some images.

Put a phone number somewhere.

Deploy it.

Done.

But while working on Arabian Insights, I slowly realised that I wasn’t really building just another company website.

I was trying to build something that could help a business explain itself clearly, build trust and eventually turn a visitor into a real enquiry.

That changed the way I looked at the whole project.

What started as:

“Build a website.”

slowly became:

“Build a digital system that actually helps the business.”

And that is where the real journey started.

First, I Had to Understand the Business

Before thinking about code, design or animations, I first had to understand what Arabian Insights actually does.

Arabian Insights is a Qatar-based company working across manpower supply, staffing, recruitment and several business support services.

The people visiting this website are not usually casual visitors.

They may be:

A construction company looking for workers.

A project manager looking for manpower.

A business looking for recruitment support.

A company searching for subcontracting or MEP services.

Or someone simply trying to find a reliable business partner in Qatar.

So I asked myself a very basic question:

What should a visitor understand within the first few seconds?

The answer was simple.

Who is this company?

What do they provide?

Can I trust them?

How do I contact them?

Those four questions became the foundation for almost everything I built.

A Website Should Do More Than Look Good

A beautiful website is nice.

Smooth animations are nice.

Good typography is nice.

Nice images are nice.

But none of them matter much if the website does not help the business.

That was one of the biggest lessons from this project.

The goal wasn’t just:

“Make it look modern.”

The actual goal was:

“Make it easy for the right person to understand the company and contact them.”

So the website needed clear actions.

Things like:

Request Manpower

Contact through WhatsApp

Call the company

Send an email

The visitor shouldn’t have to search around the website wondering what to do next.

A good website should quietly guide them.

That became a big part of the design thinking.

The Website Was Really a Lead-Generation Tool

At first glance, Arabian Insights may look like a normal corporate website.

But I started treating it as something slightly different.

A lead-generation website.

The goal wasn’t simply to get people to visit.

The goal was to move the right visitor from:

Visitor → Understanding → Trust → Enquiry

That sounds simple.

But it affects almost every small decision.

Where should the button be?

How much text should be in the hero section?

What should come first — services or company information?

How quickly can someone reach WhatsApp?

Is the contact information easy to find?

Does the website clearly show the industries the company works with?

The moment I started thinking this way, the project stopped being about individual sections.

It became about the entire journey.

One Simple Form Became More Important Than a Fancy Feature

Most company websites have a contact form that looks like this:

Name.

Email.

Message.

Submit.

It works.

But for this business, that information alone is not very useful.

So instead of creating only a generic form, I focused more on the actual information the company might need.

For example:

Who are you?

Which company are you from?

What service do you need?

How many workers do you require?

When do you need them?

Now compare two messages.

The first one says:

“Hi, I need more information.”

The second one says:

“We need 20 workers for our project next month.”

The second message gives the business something useful immediately.

And that’s where I realised something important.

Sometimes a simple form can create more value than an impressive animation.

Good UI is not always about looking better.

Sometimes it is about asking the right question at the right time.

Why WhatsApp Became Part of the Website

Developers love building things.

Sometimes maybe a little too much.

A simple project starts with:

“We need a website.”

Then suddenly you start thinking:

Maybe users need accounts.

Maybe I should build a customer dashboard.

Maybe I need a database.

Maybe I should build a custom chat system.

Maybe I need notifications.

And suddenly a small corporate website starts becoming a startup.

For Arabian Insights, none of that was necessary.

If someone wants to speak with the business, WhatsApp already solves the problem.

So the journey could be:

Website → WhatsApp → Real Conversation

Simple.

Fast.

Useful.

No unnecessary steps.

That became another important lesson for me.

Technology should simplify the business process, not make it more complicated.

Choosing the Technology

Once I understood what the website actually needed to do, choosing the technology became much easier.

For this project, I used:

Next.js for the frontend.

Sanity CMS for content management.

Git and GitHub for version control.

Vercel for deployment.

Hostinger for the domain.

And direct communication through WhatsApp, email and phone.

But the goal was never to add technology just because it sounded impressive.

Every tool needed a reason to exist.

Next.js helped me structure the project properly and gave me a good foundation for performance and SEO.

Sanity allowed the website content to be managed more easily.

Git and GitHub helped me manage the development process.

Vercel made production deployment straightforward.

The domain gave the project a proper professional identity.

The main lesson wasn’t:

“Use Next.js.”

It was:

“Understand the problem first. Choose the technology after.”

Building the Frontend in a Cleaner Way

Another thing I focused on was avoiding repeated code wherever possible.

Instead of treating every page as one giant block, the interface could be broken into reusable sections.

Navigation.

Hero sections.

Service cards.

Industry sections.

Contact sections.

Forms.

Buttons.

Footers.

Calls to action.

This may sound like a small technical detail.

But imagine the same button appears in five places.

Later the client says:

“Can we change the wording of this button?”

If you built five separate versions, now you have five different places to change.

That’s how small projects slowly become difficult to maintain.

Reusable components helped keep the project cleaner.

And it reminded me that good development isn’t only about making something work today.

It is also about making tomorrow’s changes easier.

Then Came the 167 MB Problem

This was probably one of the most practical lessons from the whole project.

The website was visually heavy.

It included approximately:

30 images

and

3 videos

The three videos together were around:

167 MB before optimisation.

On a computer folder, 167 MB doesn’t feel like a huge problem.

But websites are different.

Because someone has to download those files.

Possibly on mobile data.

Possibly on a slow internet connection.

Possibly on an older phone.

And suddenly:

“This video looks amazing.”

can quickly turn into:

“Why is the website taking forever to load?”

That created a completely different challenge.

I needed to keep the visual quality without destroying the performance.

Making the Website Faster Without Making It Boring

Performance became an important part of the development process.

Images needed to be optimised.

Videos needed compression.

Not every media file needed to load immediately.

Content below the first screen could wait.

Mobile users didn’t always need exactly the same large assets as desktop users.

The real goal became balance.

The website still needed to look professional.

But it also needed to feel fast.

Because users do not care how beautiful your 100 MB background video is if they leave before it loads.

That was a useful reality check.

Performance is not just a developer problem.

It directly affects:

User experience.

SEO.

Conversions.

Trust.

And potentially business enquiries.

Mobile Wasn’t Just a Smaller Desktop

Another important part of the project was responsive design.

A website can look perfect on a large monitor and completely fall apart on a phone.

Headings become too large.

Three-column layouts become impossible to read.

Buttons become too small.

Forms become uncomfortable.

Videos behave differently.

Navigation needs to change.

So mobile design couldn’t simply be:

“Shrink everything.”

The better question was:

“How should this information behave on a smaller screen?”

For example:

A three-column layout on desktop might become a single vertical layout on mobile.

The information stays the same.

The presentation changes.

That sounds simple, but it changes how you think about responsive design.

And for Arabian Insights, mobile was important.

Someone may receive the website link through WhatsApp and open it instantly from their phone.

The website has to work properly in that moment.

Why I Used Sanity CMS

Another question came up during development:

What happens when the company needs to update something?

Maybe they want to:

Change a service description.

Add a service.

Replace an image.

Update a page.

Change a headline.

If every piece of content is hardcoded into the website, then even a small change might require opening the code again.

That is why I used Sanity CMS.

In very simple terms, think of a CMS as a control panel for website content.

The frontend controls how everything looks.

The CMS controls what the content says.

This creates a cleaner separation.

And it makes future updates easier.

More importantly, the website becomes capable of growing.

localhost Was Only the Beginning

When you are developing a website, you usually see it running on your own computer first.

Something like:

localhost:3000

Everything feels easy there.

Then you put the website online.

And suddenly the project becomes real.

Now there are other things to deal with.

Domain configuration.

DNS.

SSL.

Hosting.

Production builds.

Environment settings.

Business email.

Search engine visibility.

And that is where I learned something very clearly.

Writing the code is only one part of delivering a real website.

A website can work perfectly on your computer and still fail online because of one wrong DNS record.

That’s not the glamorous side of development.

But it is the real side.

DNS Tried to Become the Main Character

Nobody really talks about DNS when showing off a website project.

You usually see:

The homepage.

Animations.

UI.

Nice screenshots.

But DNS?

Not so much.

Yet if the DNS is wrong, nobody gets to see any of those beautiful screenshots.

Connecting the custom domain meant making sure the domain provider and hosting platform were correctly connected.

And once again, it was another reminder:

A real-world project contains many problems that don’t appear in design mockups.

Sometimes you can spend hours building something beautiful, only to discover that the thing stopping it from working is one small configuration.

Welcome to production.

Professional Email Was Also Part of the Project

Arabian Insights also needed professional business communication.

Instead of relying only on a normal free email account, the project included domain-based communication for areas like:

Sales.

HR.

General enquiries.

It may sound like a small thing.

But business trust is built through small details.

Compare receiving an email from:

**company12345@gmail.com**

with receiving one directly from the company’s official domain.

The second one immediately feels more professional.

And this project helped me understand that a company’s online identity isn’t just the website.

It includes:

The domain.

The email.

The design.

The content.

The contact experience.

The branding.

The website is simply the place where many of those things meet.

SEO Was Part of the Build

Another important goal was SEO — Search Engine Optimisation.

In simple words:

SEO helps Google understand what your website is about.

For Arabian Insights, this is important because someone in Qatar might search for things like:

manpower supply company in Qatar

recruitment services Qatar

staffing company Qatar

MEP manpower Qatar

business support services Qatar

The website needs a chance to appear when people search for those kinds of services.

But good SEO doesn’t mean repeating keywords everywhere.

Writing:

“Best manpower company Qatar, manpower company Qatar, manpower Qatar…”

again and again doesn’t suddenly make a website good.

It just makes the content terrible.

The better foundation is:

Clear page titles.

Correct headings.

Useful content.

Fast loading.

Mobile-friendly design.

Good website structure.

Proper descriptions.

Search-engine-friendly pages.

And making sure Google can actually find and index the website.

Google Search Console also became part of the post-launch setup.

This taught me another important lesson.

Deployment isn’t the end of the project.

It is the point where the website starts dealing with the real world.

Coding and Building Are Not the Same Thing

One of my favourite lessons from this project was understanding the difference between coding and actually building a solution.

When learning development, we often think in terms of:

Frontend.

Backend.

Database.

API.

Deployment.

But clients don’t normally speak like that.

A client doesn’t say:

“Please create a component-based Next.js frontend with a headless CMS, responsive layouts, SEO architecture and optimised media delivery.”

They usually say:

“We need a website.”

Or:

“We need more customers.”

And that is where the developer’s real job begins.

You have to turn that simple request into:

Research.

Design.

UX.

Technology choices.

Development.

Forms.

Performance.

Mobile responsiveness.

SEO.

Hosting.

Deployment.

Domain.

Email.

Testing.

And a lot of small decisions nobody sees.

That is the difference between writing code and solving a real business problem.

What I Would Do Differently Next Time

No project is perfect.

And that’s one of the best parts of building real things.

You find problems.

You learn from them.

And you approach the next project differently.

If I were rebuilding Arabian Insights today, one of the biggest things I would plan earlier is the media system.

Images and videos can quickly become a problem if they aren’t planned properly.

So I would think earlier about:

Image sizes.

Video compression.

Where videos should be stored.

Which content loads first.

Which media mobile users receive.

How much bandwidth each page needs.

I would also plan the CMS structure and SEO content structure earlier.

Instead of only thinking:

“We need a Services page.”

I would think:

Service.

Title.

Description.

Industry.

Image.

CTA.

SEO title.

Meta description.

URL.

That makes the website easier to scale later.

And honestly, these are the kinds of lessons tutorials can’t completely teach.

You understand them much better when the problem appears in an actual project.

The Biggest Lesson Wasn’t Next.js

The biggest lesson from this project wasn’t Next.js.

It wasn’t Sanity.

It wasn’t Vercel.

It wasn’t CSS.

And somehow, it wasn’t even DNS.

Although DNS definitely tried.

The biggest lesson was:

Don’t start with technology. Start with the problem.

Developers can easily make projects more complicated than they need to be.

You start thinking:

Let’s add a database.

Let’s build authentication.

Let’s create a dashboard.

Let’s add a custom messaging system.

Let’s add another API.

Let’s add another framework.

And suddenly you’ve built half of an enterprise platform.

But the original requirement was:

“Help people understand the business and contact the company.”

That’s what mattered for Arabian Insights.

Everything else had to support that goal.

And that’s probably the most important development principle I took from the project:

Good architecture is not about how much technology you can add.

It’s about knowing what you don’t need to add.

From a Website Into a Business Tool

Arabian Insights started as a normal website requirement.

But during the project, I ended up working across:

UI design.

Frontend development.

Next.js.

Sanity CMS.

Responsive web design.

Image optimisation.

Video optimisation.

SEO.

Lead generation.

WhatsApp integration.

Business email.

Domain configuration.

DNS.

Vercel deployment.

And production setup.

But the technology isn’t really the interesting part.

The interesting part is how everything connected.

The design affected performance.

Performance affected SEO.

SEO affected how people could discover the business.

The website affected trust.

The enquiry form affected leads.

WhatsApp affected communication.

The domain and professional email affected credibility.

Every piece had some connection to the next.

And that’s what changed how I now think about web development.

A website isn’t simply a collection of pages.

It is a small system sitting between a business and the people that business wants to reach.

The Project Is Live

What started as a simple requirement eventually became a real production website.

You can explore the live project here:

→ arabianinsightsqa.com

Building Arabian Insights helped me understand something that I think will stay with me for a long time:

The code creates the website.

But understanding the problem creates the right website.

And that’s the part of development that interests me the most.

Because:

localhost:3000 is where development starts.

It definitely isn’t where the project ends.

Ahammed Sheez K AI Developer — Excape AI

Project: Arabian Insights Live Website → arabianinsightsqa.com