Blog

Engineering in the AI Era


**Social commerce** is not a chatbot pasted onto a website. It is commerce-native conversations: every message maps to orders, business units, and associates in your commerce backend.

## Architecture that scales

1. **Messaging gateway** — WhatsApp Business API (or simulator for demos) with verified webhooks
2. **Identity layer** — phone → commercetools Associate → Business Unit scope
3. **Intent router** — keywords first, **LangGraph** agents for free-text with tool calls
4. **CRM inbox** — human agents with order context, proposals, audit trail
5. **Headless storefronts** — same commercetools catalog powers D2C and B2B

## Why LangGraph on top of commerce APIs

Free-text distributor messages ("where is order RC-10042?" / "approve the change") need **stateful** reasoning:

- Plan which CT API to call
- Execute with BU-scoped credentials
- Format reply for messaging UI
- Escalate to CRM on low confidence

LangGraph makes this debuggable — each node is testable, unlike one-shot prompts.

## Social commerce metrics that matter

- Time-to-status for order inquiries
- Proposal approval rate via messaging
- CRM handle time with linked order context
- D2C conversion unaffected by B2B channel load

## Takeaway

Start with structured intents and a shared inbox. Add LangChain/LangGraph when free-text volume justifies it. Keep humans in the loop for money-moving actions.


How to connect messaging channels, CRM inboxes, and headless commerce APIs into one social selling system — lessons from Rich Cookies USA.

Social Commerce with commercetools and LangGraph


The development era shifted from **chat UIs** to **agentic systems** that call tools, read repos, and execute workflows. Here's the stack I actually ship with in 2026.

## LLM landscape (what I use and why)

| Model family | Best for | Production notes |
|--------------|----------|------------------|
| **GPT-4o / o-series** | General reasoning, multimodal | Strong tool calling; watch token cost at scale |
| **Claude (Anthropic)** | Long context, careful codegen | Excellent for refactors and spec adherence |
| **Gemini** | Google ecosystem integrations | Good when GCP-native |
| **Llama / Qwen (via Ollama)** | Local-first, privacy, job automation | Zero cloud bill; tune prompts per hardware |
| **Open-weight (HF)** | Fine-tune & domain agents | Pair with LangGraph for guardrails |

No single winner — I route by **latency, cost, privacy, and tool compatibility**.

## Model Context Protocol (MCP)

**MCP** standardizes how agents connect to databases, APIs, and IDEs. Instead of bespoke integrations per tool, you expose **resources + tools** once. This is why Cursor, Claude Desktop, and platform teams are converging on MCP servers for:

- Postgres / commerce APIs
- GitHub PR workflows
- Internal admin panels

## Agent patterns that survive production

1. **Graphs over chains** — LangGraph state machines with explicit human gates
2. **Tool allowlists** — never give agents open network access
3. **Observability** — log every tool call with correlation IDs
4. **Fallback paths** — keyword routers when LLM confidence is low (social commerce order lookups do this well)

## AEO / GEO / llms.txt

Discovery is no longer только Google. Answer engines (Perplexity, ChatGPT browse) and **llms.txt** files help models cite you accurately. I ship structured data + machine-readable profiles on every client site now.

## Takeaway

Treat LLMs as **orchestration layers**, not magic. The engineers who win in 2026 pair models with MCP, graphs, and boring reliability engineering.


How GPT-4o, Claude, Gemini, Ollama, and Model Context Protocol are reshaping how senior engineers build products — not just demos.

LLMs, MCP, and the Agentic Web in 2026


**AI-native IDE workflows** are not "let the model write everything." They're **compressed senior loops**: explore → diff → verify → ship.

## My Cursor stack

- **Project rules** — encoding conventions (commercetools patterns, SEO requirements, Node 18)
- **MCP servers** — browser, Postgres, GitHub without context switching
- **Agent for breadth** — refactors, test scaffolding, content migrations
- **Human for judgment** — architecture, security, product tradeoffs

## What AI accelerates on real client work

| Task | AI role | My role |
|------|---------|---------|
| Coveo integration boilerplate | Generate adapter | Review ranking + analytics |
| n8n workflow JSON | Draft nodes | Secure webhooks + idempotency |
| Portfolio / marketing copy | Draft + SEO pass | Truth-check claims |
| LangGraph nodes | Scaffold tools | Define state + guardrails |

## Discipline beats vibe coding

"Vibe coding" demos well; production FinTech and commerce need **verification gates**:

- `npm run build` before every success claim
- No secrets in prompts or commits
- Diff scope control — one feature per PR mentally even when solo

## Takeaway

Cursor is a **force multiplier for senior engineers**, not a replacement. The portfolio you're reading was built with AI assistance and human review — same model I use for Wizly, Revenued, and Rich Cookies deliveries.


How I use Cursor, rules, MCP, and agent review to ship faster without sacrificing senior-engineer judgment.

Cursor and AI-Native Development Workflows


Cloud LLM bills add up. For **personal automation** and **sensitive workflows**, I run **Ollama** locally and orchestrate with **n8n** + **Python**.

## Architecture (Job Hunt Automation pattern)

```
n8n cron → Next.js API → Python ingest → Ollama tailor → Gmail PDF → Postgres
```

- **Discover** jobs via Playwright
- **Filter** in dashboard
- **Compose** cover letters + emails with local model
- **Track** applications and replies

## When local wins

- Secrets stay on your machine (encrypted git-crypt)
- Unlimited iterations during prompt tuning
- No per-token anxiety for batch jobs

## When cloud wins

- Highest reasoning quality for architecture decisions
- Multimodal (screenshots, PDFs) at scale
- SLA-backed APIs for customer-facing agents

## Hardware reality (Mac / Linux)

- 8–16GB RAM: 7B–8B quant models for drafting
- 32GB+: 14B models for better instruction following
- Always measure **time-to-first-token** vs cloud latency

## Takeaway

**Hybrid LLM strategy**: Ollama for volume and privacy; GPT/Claude for customer-facing agent peaks. Engineer the router — don't pick one religion.


Why I run Ollama for job-hunt automation, resume tailoring, and client PoCs — and when to still use OpenAI or Claude.

Local LLMs with Ollama — Private Automation That Scales to Zero Cloud Cost


Open-source contributions aren't just resume padding — they're how senior engineers stay current with large-scale codebases and give back to the tools their teams depend on daily.

## Projects I've contributed to

Recent activity includes **storybookjs/storybook**, **CapSoftware/Cap**, **tscircuit/tscircuit**, and **archestra-ai/archestra** — spanning UI tooling, screen recording for developers, and circuit design.

## What I contribute

- Bug fixes from real-world usage patterns
- PR reviews that catch edge cases
- Small features that unblock other contributors
- Documentation clarifications

## Balancing client work and OSS

I contribute in focused bursts — often when a client project surfaces a bug I can fix upstream, or when a tool I use daily has a gap I can fill. This keeps contributions meaningful rather than performative.

## Benefits for employers and clients

- Exposure to code review standards at scale
- Deeper understanding of framework internals
- Faster debugging when issues arise in production
- Credibility in technical discussions

## How to start

Pick one tool your team already uses. Fix a "good first issue." Submit a small PR. Repeat. Consistency beats heroic one-time contributions.

## Takeaway

OSS keeps skills sharp and builds trust in the community. If you're a hiring manager evaluating candidates, sustained contributions to real projects are a strong signal.


Why and how I contribute to open-source projects like Storybook and Cap while working on enterprise client deliverables.

Contributing to Developer Tools: Storybook, Cap, and Beyond


**Wizly** is building the infrastructure for **AI-powered knowledge businesses** — where expertise compounds while the expert sleeps.

## Three primitives

1. **Knowledge Hub** — ingest newsletters, decks, calls, docs into structured expertise
2. **AI Twin** — voice-faithful agent for 24/7 client Q&A
3. **Collections** — packaged, monetizable knowledge products

## Engineering challenges I care about

- **Trust** — twins must cite sources, not hallucinate authority
- **Monetization** — payments + lead gen without friction
- **Onboarding** — 4-week pioneer path from audit → launch
- **Community** — verified experts, peer validation, office hours

## Parallel to commerce agents

The same agentic patterns apply:

| Wizly (consulting) | Commerce (Rich Cookies) |
|--------------------|-------------------------|
| Twin answers methodology | Bot answers order status |
| Collections = products | Catalog = SKUs |
| Human escalation | CRM inbox |

LangGraph + tool APIs + human gates — different domain, same architecture.

## Takeaway

The next decade of senior careers isn't "replace experts" — it's **multiply experts** with twins, hubs, and honest guardrails.


How AI Twins, Knowledge Hubs, and Collections turn senior consultants into scalable businesses — product patterns from wizly.app.

AI Twins and the Future of Expertise — Lessons from Wizly


**Composable commerce** (commercetools, Contentful, Algolia, Adyen) gave us flexible storefronts. **AI** is now the personalization layer on top.

## Stack I ship

- **Next.js** storefronts with ISR for SEO
- **commercetools** for catalog, cart, B2B business units
- **Algolia / Coveo** for search + merchandising rules
- **LLM layer** for recommendations, support copy, and social commerce intents

## AI use cases that actually ship

| Use case | Approach |
|----------|----------|
| PLP ranking hints | Rules + ML scores, not pure LLM |
| Support / order chat | LangGraph + commerce API tools |
| Content generation | Constrained templates + human review |
| Social selling | Structured intents first, LLM second |

## Social commerce connection

B2B distributors don't want a generic chatbot — they want **order numbers, proposals, and approvals** wired to commercetools. That's social commerce, not gimmicks.

## Takeaway

AI in commerce wins when it respects **APIs, scopes, and audit trails** — same discipline as payments and PCI.


Headless commerce + LLM recommendations, search, and social selling — patterns from Jaycar, American Golf, Ethel M, and Rich Cookies.

Composable Commerce Meets AI Personalization in 2026


Search is splitting into **traditional SEO**, **Answer Engine Optimization (AEO)**, and **Generative Engine Optimization (GEO)**. I implement all three on client and portfolio sites.

## Checklist I ship every time

- **Canonical URLs** + absolute Open Graph images
- **JSON-LD** — Person, WebSite, CreativeWork, BlogPosting
- **sitemap.xml** + **robots.txt** (allow GPTBot, ClaudeBot, PerplexityBot where appropriate)
- **llms.txt** — machine-readable profile for AI crawlers
- **Core Web Vitals** budgets on PLP/PDP

## Why llms.txt matters

LLMs hallucinate careers if they only scrape nav links. A structured **llms.txt** at `/llms.txt` gives:

- Accurate role framing (Lead, PO, CTO-capable)
- Real project list with URLs
- Skills and contact — citeable facts

## GEO vs keyword stuffing

GEO isn't tricking models — it's **clarity**: who you are, what you shipped, with evidence links. Same ethos as good technical writing.

## Takeaway

Treat your portfolio like a **public API for your career**. Structured data is documentation for robots.


How I implement JSON-LD, sitemaps, llms.txt, and Core Web Vitals so humans and LLMs both find and cite your work accurately.

AEO, GEO, llms.txt, and Technical SEO in the AI Search Era


**React + TypeScript** remains the default for every serious storefront and dashboard I touch. In 2026 the debate isn't "TS or JS" — it's **where rendering happens**.

## Rendering choices

| Pattern | Use when |
|---------|----------|
| **SSR** | Personalized, auth-gated pages |
| **ISR** | PLP/PDP SEO at scale |
| **Client components** | Cart, chat, dashboards |
| **Server actions** | Mutations with colocated validation |

## Type safety across boundaries

- Zod (or similar) at API edges
- Generated types from GraphQL / OpenAPI where possible
- Strict `tsconfig` on greenfield; incremental strict on legacy

## Performance habits

- Image optimization via `next/image`
- Route-level code splitting
- Measure INP on interactive checkout — not just LCP hero scores

## Takeaway

Server Components didn't kill SPAs — they **relocated work** to the right tier. Senior frontend work in 2026 is orchestration, not component count.


Practical patterns for Next.js App/Pages router, server components, and type-safe APIs on enterprise commerce and FinTech projects.

TypeScript, React, and Server Components in 2026


The path to **senior front-end** in 2026 is not more CSS tricks — it's **systems thinking** plus **AI leverage**.

## Core competencies

1. **TypeScript by default** — types at API boundaries save client projects
2. **Next.js rendering model** — know when SSR, ISR, or client-only wins
3. **Accessibility** — not optional on enterprise and government work
4. **Performance budgets** — INP and LCP tied to revenue on commerce sites
5. **Design systems** — Storybook, tokens, consistent component APIs

## AI as accelerator

Use Cursor/Copilot for boilerplate; **you** own architecture, security review, and UX judgment. Senior means knowing when **not** to accept a diff.

## Portfolio proof

Ship real case studies: Coveo on Adobe EXL, commercetools PLPs, OTT players — with **metrics** and **tech infographics**, not lorem ipsum.

## Takeaway

Senior front-end is **product impact through UI engineering**. AI raises the floor; judgment and ownership raise the ceiling.


Beyond tutorials — TypeScript, Next.js, design systems, performance, and AI-assisted workflows for engineers who ship production UI.

How to Be a Senior Front-End Developer in the AI Era


AI agents are moving from demos to production. With **LangGraph.js**, you can orchestrate multi-step reasoning loops where an LLM plans, acts, observes results, and iterates — similar to how a developer debugs code.

## Why LangGraph for agents

Unlike single-shot prompt chains, LangGraph models agent behavior as a **state machine**. Each node is a step (plan, execute, validate), and edges define transitions based on outcomes. This makes agents debuggable, testable, and safe to deploy.

## A practical pattern: code execution agents

In my [AiAgentRunJS](https://github.com/nitin-rachabathuni/AiAgentRunJS) project, the agent:

1. Receives a task in natural language
2. Generates JavaScript to solve it
3. Executes code in a sandboxed environment
4. Reads stdout/errors and retries if needed

This pattern works for data transforms, API glue code, and internal tooling.

## Safety first

Production agents need guardrails:

- **Sandbox execution** — never run arbitrary code on the main process
- **Token budgets** — cap LLM calls per request
- **Tool allowlists** — restrict which APIs the agent can call
- **Human-in-the-loop** — confirm destructive actions

## Combining with n8n

LangGraph handles reasoning; **n8n** handles scheduling, webhooks, and integrations. Together they form a powerful automation stack for teams that don't want to build everything from scratch.

## Takeaway

Start with a narrow, well-defined agent (e.g. "transform this CSV schema"). Add tools incrementally. Measure success by tasks completed without human intervention — not by how impressive the demo looks.


How to design tool-using AI agents that write and execute code safely in Node.js production environments.

Building AI Agents with LangGraph.js


Headless commerce separates the **presentation layer** (Next.js storefront) from the **commerce engine** (commercetools). This architecture scales better for multi-brand, multi-region retailers — but integration complexity is real.

## Architecture that works

A proven stack I've used across multiple client projects:

- **Next.js** — SSR/ISR for SEO and performance
- **commercetools** — product catalog, cart, checkout APIs
- **Contentful** — marketing content and page composition
- **Adyen** — payments with PCI-compliant tokenization
- **Algolia** — fast, faceted product search

## Data migration is the hard part

Moving from legacy platforms (e.g. Salesforce Commerce Cloud) to commercetools requires mapping product types, variants, categories, and customer records. Plan for:

- Staged migrations with rollback paths
- Data validation scripts
- Parallel running during cutover

## Performance wins

ISR lets you cache product listing pages while keeping cart/checkout dynamic. Image optimization via Next.js `Image` component and CDN edge caching dramatically improves LCP scores.

## SEO and discoverability

Each product and category page needs unique meta titles, structured data (`Product` schema), and canonical URLs. Headless doesn't mean invisible to Google — it means you control every HTML tag.

## Takeaway

Headless commerce pays off at scale. Invest early in integration patterns, content modeling, and observability — your future self (and your merchandising team) will thank you.


Lessons from building enterprise e-commerce for Jaycar, American Golf, Caroma, and other global retail brands.

Headless Commerce with Next.js and commercetools


OTT platforms face unique performance challenges: large media payloads, global audiences, device fragmentation, and real-time features. Here's what worked on a production streaming application.

## Adaptive bitrate streaming

Serve multiple quality levels and let the player switch based on bandwidth. This reduces buffering — the #1 cause of user drop-off on streaming apps.

## CDN and edge strategy

- Place static assets and poster images on a global CDN
- Use signed URLs for premium content
- Pre-warm caches before major content releases

## Next.js-specific optimizations

- **Lazy load** below-the-fold content and recommendation carousels
- **Virtualize** long content lists instead of rendering thousands of DOM nodes
- **Code-split** player SDKs — they're heavy and not needed on every page

## Measuring what matters

Track LCP (hero poster image), INP (player controls responsiveness), and CLS (layout shifts when recommendations load). Set budgets per page type: home, detail, watch.

## Security without sacrificing UX

DRM, tokenized auth, and geo-restrictions add latency. Cache auth tokens client-side with short TTLs and refresh in the background.

## Takeaway

OTT performance is a product feature, not an afterthought. Users compare your app to Netflix and YouTube — meet them where expectations live.


Performance strategies for streaming applications — adaptive bitrate, CDN tuning, and Next.js optimizations from the Viu OTT project.

Optimizing OTT Platforms for Core Web Vitals


*Sustainable communities are essential for the well-being of both people and the planet. They are designed to minimize environmental impact, promote social equity, and enhance the overall quality of life. In creating such communities, architecture plays a crucial role.*


Architecture is not solely about creating aesthetically pleasing structures; it also has the power to shape our environment in a sustainable manner. From the design phase to construction and beyond, architects have the opportunity to incorporate sustainable principles that can significantly impact the community.


> "Good product come from good people, and all problems are solved by good design. Keep doing good design." 
> <cite>— Stephen Gardiner</cite>

Architects can employ various strategies to foster sustainability. First and foremost, they can prioritize energy efficiency by designing buildings that minimize energy consumption and incorporate renewable energy sources. This includes utilizing natural lighting, employing energy-efficient materials, and implementing efficient insulation systems.

Furthermore, sustainable architecture promotes the use of eco-friendly materials, such as recycled and locally sourced materials, which reduces the carbon footprint associated with construction. By considering the life cycle of materials and designing for disassembly, architects can enable easier recycling and reuse in the future.

## Navbar active State

```javascript
useEffect(() => {
  const activeLink = navRef.current.querySelector(".active");
  if (activeLink) {
    activeLinkRef.current = activeLink;
    setIndicatorPosition({
      left: activeLink.offsetLeft,
      width: activeLink.offsetWidth,
    });
  }
}, [mainMenu]);
```

Additionally, architects can design spaces that encourage community engagement and social interaction. By incorporating public gathering areas, green spaces, and pedestrian-friendly infrastructure, they create opportunities for residents to connect, fostering a sense of community.

In conclusion, sustainable communities are not merely a product of chance; they are a result of thoughtful and intentional architectural design. Architects have the power to shape our built environment in a way that promotes sustainability, energy efficiency, and community well-being. By embracing sustainable principles and incorporating them into their designs, architects contribute significantly to the creation of sustainable communities.

# Markdown syntax guide

## Headers

# This is a Heading h1
## This is a Heading h2 
###### This is a Heading h6

## Emphasis

*This text will be italic*  
_This will also be italic_

**This text will be bold**  
__This will also be bold__

_You **can** combine them_

## Lists

### Unordered

* Item 1
* Item 2
* Item 2a
* Item 2b

### Ordered

1. Item 1
1. Item 2
1. Item 3
  1. Item 3a
  1. Item 3b

## Images

![This is an alt text.](/images/blog/05.jpg "This is a sample image.")

## Links

You may be visiting [a Next.JS theme](https://themeforest.net/user/platol).

## Blockquotes

> Markdown is a lightweight markup language with plain-text-formatting syntax, created in 2004 by John Gruber with Aaron Swartz.

## Tables

| Left columns  | Right columns |
| ------------- | -------------:|
| left foo      | right foo     |
| left bar      | right bar     |
| left baz      | right baz     |

## Blocks of code

```javascript
let message = 'Hello world';
alert(message);
```

## Inline code

This web site is using `markedjs/marked`.


[![NextJS Font](https://img.youtube.com/vi/L8_98i_bMMA/maxresdefault.jpg)](https://www.youtube.com/watch?v=L8_98i_bMMA)

Using Fonts in Next.js (Google Fonts, Local Fonts, Tailwind CSS)

Sustainable communities are essential for the well-being of both people and the planet

The Role of a Developer in Creating Communities


Creating a user-friendly and accessible website is crucial for ensuring that visitors can easily navigate and engage with your content. By optimizing usability and accessibility, you can enhance the overall user experience and reach a wider audience. Here are some effective strategies to improve your website's usability and accessibility:

1. **Clear Navigation:** Implement a well-organized and intuitive navigation menu that helps users easily find the information they need. Use descriptive labels and hierarchical structures to guide visitors through your site.

2. **Responsive Design:** Ensure your website is mobile-friendly and responsive across various devices and screen sizes. This will enable users to access your content seamlessly, regardless of the device they're using.

3. **Readable Fonts and Contrast:** Choose legible fonts and maintain a sufficient contrast between the text and background colors. This makes the content easier to read, especially for users with visual impairments.

4. **Alternative Text (Alt Tags):** Add descriptive alt tags to all images, providing text alternatives for visually impaired users or when images cannot be loaded. Alt tags also improve search engine optimization (SEO) by making your content more accessible to search engines.

> "Accessibility is the ability to access and benefit from a system, regardless of disability or impairment." - [W3C Web Accessibility Initiative](https://www.w3.org/WAI/fundamentals/accessibility-intro/)

5. **Captioned Media:** Include captions or transcripts for videos and audio content to ensure that users with hearing impairments can comprehend the information being conveyed.

6. **Consistent Layout and Design:** Maintain a consistent design across your website, including headers, footers, and navigation elements. Consistency helps users navigate and understand your site's structure more easily.

7. **Forms and Interactive Elements:** Design forms and interactive elements with clear instructions and error messages. Ensure they are keyboard accessible, allowing users to navigate without relying solely on a mouse.

By implementing these strategies, you can significantly improve the usability and accessibility of your website, making it more inclusive and user-friendly. Remember, an accessible website benefits all users, regardless of their abilities, and contributes to a positive online experience for everyone.

Creating a user-friendly and accessible website is crucial for ensuring that visitors can easily navigate and engage with your content

Ways to improve usability and accessibility


Designers play a crucial role in shaping the web as we know it today. Their creative vision and innovative approaches have revolutionized the way we interact with websites and digital content. In this blog post, we will explore the contributions of some influential designers who have left a lasting impact on the web.

## 1. Jony Ive

Jony Ive, the former Chief Design Officer at Apple, played a pivotal role in transforming the aesthetic and user experience of Apple products. His minimalist and sleek designs, seen in iconic products like the iPhone and MacBook, set new standards for user-centered design and simplicity.

> "Design is not just what it looks like and feels like. Design is how it works." - Jony Ive

## 2. Sara Soueidan

Sara Soueidan is a front-end web developer and designer known for her expertise in SVG and CSS. Her extensive contributions to the web include advocating for accessible and inclusive design practices. Sara's tutorials, articles, and speaking engagements have empowered countless designers and developers to create more inclusive web experiences.

> "Our job is to push the boundaries, break the rules, and bring forth new ideas." - Sara Soueidan

## 3. Ethan Marcotte

Ethan Marcotte is widely credited with coining the term "responsive web design." His groundbreaking article on responsive design sparked a paradigm shift in web development, emphasizing the need for websites to adapt seamlessly across different devices and screen sizes. Today, responsive design is a standard practice in the industry.

> "The goal of a designer is to listen, observe, understand, sympathize, empathize, synthesize, and glean insights that enable them to 'make the invisible visible.'" - Ethan Marcotte

These designers have transformed the web landscape through their visionary ideas and commitment to user-centric design. Their influence continues to shape the way we navigate and experience the online world. As we move forward, let's celebrate and learn from their contributions, inspiring the next generation of web designers to make their mark on the digital realm.



Designers play a crucial role in shaping the web as we know it today

Designers who changed the web


Aspiring web designers often have a rosy picture in mind when they embark on their career journey. However, there are certain aspects of this profession that often go unmentioned. In this article, we will shed light on 10 things nobody told you about being a web designer.

## 1. Constant Learning is Essential

Web design is an ever-evolving field, and to stay ahead, you must embrace continuous learning. Technologies, design trends, and user expectations change rapidly, so be prepared to adapt and grow.

## 2. Client Communication is Crucial

Web design involves working closely with clients to bring their visions to life. Effective communication skills are paramount to understand client requirements, manage expectations, and provide satisfactory solutions.

> "Good communication is the bridge between confusion and clarity." - Nat Turner

## 3. User Experience (UX) is Key

Creating visually appealing websites is important, but a seamless user experience is equally vital. Web designers must prioritize UX to ensure that visitors have a positive and intuitive interaction with the websites they design.

## 4. Collaboration is Powerful

Web design projects often require collaboration with other professionals, such as developers, content creators, and marketers. Working as a team fosters innovation, improves problem-solving, and enhances the overall quality of the end product.

## 5. Feedback is Inevitable

Constructive criticism and client feedback are an integral part of the web design process. Embrace feedback as an opportunity to refine your skills and deliver a better final product.

## 6. Time Management is a Skill

Web design projects come with deadlines, and effective time management is crucial. Develop strategies to prioritize tasks, stay organized, and meet project milestones without compromising quality.

## 7. Code Maintenance is Ongoing

Writing clean, efficient code is only the beginning. Web designers often overlook the fact that code maintenance is an ongoing responsibility. Regular updates, bug fixes, and security patches are essential to ensure websites remain functional and secure.

## 8. Keeping Up with SEO Matters

Search Engine Optimization (SEO) plays a vital role in the success of websites. Web designers should understand the basics of SEO and implement best practices to improve a website's visibility and search engine rankings.

## 9. Continuous Testing is Necessary

Thoroughly testing websites across different devices, browsers, and user scenarios is crucial. Testing helps identify and rectify usability issues, ensuring a seamless experience for all visitors.

## 10. Success Requires Passion and Resilience

Web design can be demanding and challenging. To succeed, passion for the craft and resilience in the face of obstacles are essential. Embrace the ups and downs, stay motivated, and never stop pursuing your passion.

Now that you know these 10 hidden aspects of being a web designer, you can approach your career journey with a deeper understanding and be better prepared for the road ahead.

To read more about web design, visit [Web Design 101](https://example.com/web-design-101).

> "Design is not just what it looks like and feels like. Design is how it works." - Steve Jobs

Aspiring web designers often have a rosy picture in mind when they embark on their career journey