Component Library

/// Web & CMS Development
I build the site I designed and wrote, so nothing gets lost in the handoff. Next.js front-ends, a headless CMS your team can actually use, and pages that load in about a second. No agency relay. No plugin stack holding it together.






Most web development gets handed to a team that never spoke to the person who wrote the copy or drew the design.
So the spacing drifts, the hover states get invented on the spot, and the section that was supposed to carry the whole argument ends up squeezed into whatever the template allowed. Then a plugin gets installed to patch the difference.
That's how you get a site that loads in five seconds, or one nobody on your team can edit without breaking the layout. The gap isn't talent. It's the handoff.
I write the copy, design the page, and build it myself, so the intent behind every section survives all the way into the code and into a CMS your team can actually run.


/// WHAT YOU GET
Component Library

Front-End Development


Speed & Technical SEO
CMS Setup

A reusable component library for your website — navigation, buttons, forms, content sections, cards, testimonials, pricing blocks, and calls to action. Every page stays visually consistent, and building the next one is assembly rather than design from scratch.
The approved design turned into a responsive, production-ready website in Next.js and React. Every section is tested across desktop, tablet, and mobile, with close attention to spacing, typography, interactions, and accessibility.
Clean semantic markup, optimised images, server-rendered pages, structured metadata, XML sitemaps, and canonical tags, with Core Web Vitals treated as a target rather than an afterthought. Every important page is fast and crawlable from launch.
The site wired to an editable CMS — Sanity, WordPress, or Shopify. Your team updates pages, publishes articles, adds case studies, and replaces images without touching code or booking developer time.
/// Why My Development

I build the same file I designed, so spacing, states, and type scale ship exactly as approved. No developer guessing what a hover was meant to do, and no design review where half the feedback is 'that's not what the Figma said'.
Speed is decided by what goes into the build, not by what gets optimized after. I agree a page-weight and Core Web Vitals target upfront, then hold the build to it — images, fonts, scripts, and all.
Editors get labelled fields and previews, not a wall of raw blocks that break the layout when someone pastes a long headline. If you can write an email, you can update your own site without opening a support ticket.
Semantic headings, clean URLs, metadata, structured data, sitemaps, and fast server rendering are part of the build. Your pages arrive crawlable on day one instead of waiting for a plugin to patch the gaps.
You get the repository, the hosting, the CMS, and a walkthrough recording. Standard framework, standard patterns, documented decisions — so the next developer can pick it up without a rebuild.
/// Technologies I Work With
The technology gets chosen from what the site has to do, how often your team will change it, and how it needs to perform — not from whichever framework I happen to like this year.
Next.js for fast, scalable marketing websites, content platforms, SaaS sites, and custom web applications. Server rendering and static generation keep important pages quick to load and readable by search engines without waiting on JavaScript.
React for reusable interfaces, interactive tools, dashboards, calculators, forms, and application features that need more flexibility than a page template can give them.
Custom front-ends connected to a headless CMS such as Sanity. Editors get a straightforward place to work while the site itself stays fast, secure, and free to change independently of the content.
WordPress built and customised where it genuinely suits the team already running it — custom themes, reusable page sections, performance work, and content migration.
Shopify storefronts, landing pages, custom sections, and headless commerce for businesses that need a store their own team can edit and that is built around conversion.
/// Who I Work With
The common thread is a business that needs more than another template, and does not want a site that becomes someone else’s problem to maintain the week after launch.
Marketing sites, product pages, documentation, and application interfaces for teams who need to explain what they have built clearly, and need it live sooner than a committee would allow.
A development partner for design, branding, SEO, and marketing agencies who want reliable front-end work without carrying an in-house engineering team between projects.
Consultants, law firms, finance companies, insurers, and other service businesses whose site has to establish trust first and generate qualified enquiries second.
Replacing a site that has become slow, dated, or painful to edit — while protecting the URLs, content, analytics, and search visibility the current one has already earned.
Scalable blog, resource, case study, and landing page systems for brands that publish regularly and need their own team to run it without a developer in the loop.
/// Our Work Process
Before any code, I map every page, every content type, and every place your team will need to edit something later. That becomes the sitemap, the CMS schema, and a fixed performance target. You approve the plan before the build starts, so scope creep has nowhere to hide.

The approved design gets built component by component in Next.js, matched to the Figma file down to spacing and states. Responsive from the smallest breakpoint up, accessible by default, and reviewed on a live preview URL you can click through at any point.

I wire the front-end to your CMS so every headline, image, and case study is editable without touching code. Fields get plain-English labels and validation, content gets migrated in, and your team gets a walkthrough of exactly how to change things.

Redirects, metadata, structured data, sitemap, and analytics all go in before the DNS switch, so you keep the rankings you already have. Then I run the Lighthouse and cross-browser pass, ship it, and stay on hand for the first weeks live.

/// Website Migration
An existing site can move to a faster, more manageable stack without being treated as a blank page. Before development starts I go through the current pages, URLs, metadata, content, analytics, forms, integrations, and search performance, so the rebuild begins from a record of what you have rather than a guess at it.
Pages that already earn their place get kept. Sections that underperform get improved. Anything removed is redirected to the closest relevant destination rather than left to return a 404.
/// What I Won't Do
A good build is defined as much by what I leave out as by what I put in. These are the shortcuts I turn down, keeping your site fast, secure, and cheap to maintain long after launch.
Drag-and-drop builders ship a large stylesheet and a stack of scripts to render a headline. I build components in code, so the browser downloads what the page actually uses — and the sections stay editable through the CMS either way.
A bought theme plus fifteen plugins is fifteen things that can break, conflict, or get exploited. I build what your site actually needs, so there is less surface area to maintain and less to go wrong.
Standard framework, standard patterns, documented decisions, and the repository handed to you at launch. If you hire someone else next year, they can pick it up without proposing a rebuild.
Nothing goes live until it clears the Core Web Vitals target we agreed, on a real mid-range phone rather than a desktop on office wifi. A site that only performs on your laptop is not finished.
Years of experience
Repeat clients
Successful projects
Avg. Lighthouse score
/// What It Plugs Into
A site that cannot talk to the tools around it turns your team into the integration — copying enquiries into a spreadsheet by hand. These connections get built in, not added once the copying gets annoying.
Website forms connected to HubSpot, Salesforce, Pipedrive, or whichever CRM you already run, so a new enquiry reaches the right pipeline on its own. Submissions are recorded server-side as well as emailed — email is the part that fails silently, and a lead you never heard about looks identical to a lead that never came.
Google Analytics, Tag Manager, Search Console, advertising pixels, and conversion events set up while the pages are being built, so which actions count is a decision rather than something reverse-engineered months later. Consent is wired at the same time, so tracking loads once a visitor has agreed to it.
Newsletter and lead-generation forms connected to Mailchimp, ConvertKit, Brevo, or another provider — and stored with your own content as well, so the list stays exportable if you ever change platform.
Calendly, Cal.com, or a similar scheduler embedded where the visitor already decided, so the gap between wanting a call and having one booked is a click rather than a reply chain across two timezones.
Stripe, Shopify, or another payment system integrated for product sales, subscriptions, deposits, and paid services, with the checkout path treated as part of the design rather than a redirect at the end of it.
Third-party APIs, internal tools, databases, and bespoke business systems connected where the project needs more than a standard plugin — usually the integration nobody's off-the-shelf template accounted for.
/// Accessibility
Someone who cannot use your site rarely tells you. They leave, and it arrives in your dashboard as an ordinary bounce. So this is handled during the build, where it costs nothing, rather than after a complaint, where it costs a retrofit.
Headings in order, buttons that are actually buttons, form fields tied to their labels. A screen reader then announces the page instead of reading out a wall of unlabelled boxes and leaving the listener to guess which one submits the form.
Menus, modals, sliders, and forms can all be reached, operated, and escaped from the keyboard. This is where bought themes usually fall down: the dropdown opens on hover and there is no way back out of it.
Text and background pairs are checked while the design is still being approved. Catching it there is a colour decision; catching it after launch is a repaint of your brand across every page.
The editor asks for it as the image is added and flags anything left blank, so describing images does not depend on whoever is publishing that day remembering to.
To be clear about what this is not: a default build standard, not a compliance certificate. If you need a formal WCAG audit or a VPAT for procurement, say so at the scoping stage and it gets planned in rather than discovered late.

Most agencies split your site across a writer, a designer, and a development team, and the intent leaks at every handoff. I take it end to end myself, so what you approved in the design is what goes live, on a stack your team can keep running long after launch.
Pixel-Accurate Builds
Core Web Vitals Tuning
Editor-Friendly CMS
Post-Launch Support
Sites shipped
Avg. load time
Happy Clients
Industry
/// What I Build
The five-to-twenty page site your business actually runs on. Built in Next.js with every section editable through the CMS, so your team can ship a new service page or case study without booking developer time for a headline change.
/// Support After Launch
Going live is the point at which a site starts being used, not the point at which the work is finished. Handover, documentation, and a support window are part of the project rather than an upsell after it.
A recorded walkthrough showing your team how to edit pages, publish content, manage images, and use the parts of the site they will touch most. Recorded rather than live, so the person who joins in six months gets the same briefing.
Development issues found during the agreed post-launch window get resolved as part of the project, not quoted as new work.
Page speed, Core Web Vitals, broken links, and crawl issues reviewed after launch, when real traffic and real content start behaving differently from a staging site.
For ongoing maintenance clients, dependencies updated and security advisories reviewed so the foundation stays current instead of quietly ageing.
Landing pages, sections, integrations, and application features added as the business grows, on the component library already built rather than from scratch.
You receive the repository, CMS access, hosting access, and the technical documentation. None of it is conditional on keeping me around afterwards.
Testimonial


I have had a great experience working with him. We were working on a project about a saas app. He played a good role in the collaboration of copywriting and UI design. Recommended.
Founder, GoalFlow



We needed a website UI for Bangla Venture that looked professional and guided the user without friction. Hamidul, nailed the visual hierarchy. It’s a pixel-perfect design that perfectly captures what Bangla Ventures stands for.
Founder, Banglaventure



Titas joined the Growminion team to handle writing and design for our local SEO clients. He consistently delivers high-quality work, and we’ve had a fantastic experience working with him.
Founder, Growminion



Titas helped us design a product landing page for Peanela, and the experience was excellent. He understood our requirements clearly, delivered a clean and professional design, and maintained great quality throughout the project.
Managing Partner, Peanela

/// Project Scope
Each project is quoted on its actual development scope rather than pushed into one of three packages. A focused landing page and a full marketing site, an online store, or a custom application are not the same piece of work, and pricing them as if they were only helps whoever wrote the package.
Once your requirements are clear, you get a written scope covering the deliverables, the timeline, who is responsible for what, and the cost — before any work begins.
Got Questions?
Next.js and React for the front-end, with a headless CMS such as Sanity behind it. If your team is already on WordPress or Shopify, I work with those too, either as a custom theme or as a headless back-end behind a modern front-end.
Yes, that's the point. Every headline, image, and page section is wired to the CMS with plain-English field labels and live preview, so your team can publish changes without touching code or booking developer time.
Both. I write the copy, design the page in Figma, and build it myself, so what you approve in design is exactly what ships. If you already have a design from another team, I can build from that file as well.
Most marketing sites take three to five weeks from scope to launch, depending on page count and how ready the content is. Single landing pages take about a week. Web apps and commerce builds run longer and get a scoped timeline upfront.
Not if it's handled properly. I map every existing URL to its new destination with 301 redirects, carry over metadata and structured data, and submit a fresh sitemap at launch. Most rebuilds gain traffic from the speed improvement rather than lose it.
You own everything: the repository, the hosting account, the CMS, and a recorded walkthrough of how it all fits together. I stay available for the first weeks live to catch anything, and I offer ongoing maintenance if you want it, but you're never locked in.
Blogs