Building Luveian: How Three College Students Built a Branding Agency

Back in 2023, I met Rajyavardhan Singh at GDG Bhilai. We got talking about this idea – what if we combined my coding skills with his business sense to land actual clients under a proper brand name instead of just being random freelancers? That's how Luveian started. Not a registered company, just a brand we chose ourselves with a website and portfolio to make us look legit.

The division was simple. I handle all the technical work – coding, development, implementation. Rajyavardhan manages client acquisition and business operations. But here's the thing, I also had to train him on the marketing side. Google Ads, campaign management, how to set budgets, track conversions, all that stuff. Someone had to know how to run ads properly and that someone ended up being both of us.

The Third Pillar: Design

Then there's Humaira Ambreen. She's our UI/UX designer and honestly, she's been the backbone of this whole operation. While Rajyavardhan and I were figuring out the business side, Humaira was guiding us on what to do next, how to approach projects, what makes sense design-wise.

Her designs gave soul to our projects. We're not talking about basic templates or generic layouts. Proper design systems, clean interfaces, the kind of work that makes clients stop and actually look at what you built. She works in Figma, creates complete mockups with component libraries, and I implement them in code.

The collaboration works because we communicate throughout. She designs something, I tell her what's buildable and what needs adjustment from a technical perspective, we iterate, then I build it. No friction, no "that's not possible" arguments. Just clean workflow.

Client Acquisition and Pitching

Getting clients as college students isn't easy. You have to convince people that you can deliver professional work even though you're young and don't have some big agency backing you. This is where the approach mattered.

I ended up being the front guy during pitches. Not literally like Steve Jobs on stage, but I'd present our technical capabilities, show what we can build, explain how we'd solve their specific problems. Rajyavardhan handled the business conversation and Humaira would present the design approach. Three college students presenting like we knew what we were doing because we actually did.

We landed around 2-3 clients this way. Not huge numbers but each one was a proper project with real scope and actual payment.

Competing Against an Actual Agency

One project stands out. There was another company bidding for the same client – an actual agency with employees and everything. We were just three students with a brand name. They quoted lower than us. We charged more but the client still chose us.

Why? Product quality and approach. We showed them what we could build using modern web technologies. Three.js for 3D graphics, WebGL for advanced visual effects, the kind of stuff you see on big company websites. We weren't just making basic websites, we were implementing what we saw in products from bigger companies and trying to make something better.

The client saw the difference. They paid us more than what the other agency was asking because they valued the quality of what we were going to deliver.

Technical Implementation

Most of my development work at Luveian involved building things from scratch. I used Rust heavily for backend services and performance-critical applications. Node.js and Express for API servers where it made sense.

For frontend work with visual effects, Three.js became essential. 3D graphics rendering, WebGL shaders, animation systems. We studied what companies like Apple, Stripe, and other design-forward tech companies were doing with their web experiences and tried to implement similar quality.

The tech stack varied by project but Rust was my go-to for anything that needed performance. Building web servers with Axum, async operations with Tokio, systems programming where memory safety matters. No garbage collection pauses, proper concurrency, code that compiles down to efficient machine code.

Learning Through Doing

Luveian forced me to learn things I wouldn't have learned otherwise. Google Ads isn't something you pick up as a developer normally. Understanding campaign structure, keyword targeting, bid strategies, conversion tracking, analytics integration – I had to learn all this to train Rajyavardhan and to understand our own marketing.

SEO was another deep dive. Getting a client's page to rank first in search results isn't luck, it's understanding how search engines work. Semantic HTML, proper meta tags, structured data markup, site speed optimization, Core Web Vitals. Technical SEO is engineering, not marketing magic.

Implementing tracking and analytics taught me how businesses actually measure success. Google Analytics 4 setup, custom event tracking, understanding user behavior through data. Setting up Tag Manager to handle third-party scripts cleanly. Search Console for monitoring how Google sees your site.

The entire digital marketing ecosystem became part of my skill set because building websites for clients means understanding how they'll actually use those websites to grow their business.

The Rust Advantage

Using Rust for client projects gave us a technical edge. When you need a service that handles concurrent connections efficiently, or processes data without memory leaks, or needs to be deployed and just run reliably without constant babysitting – Rust delivers.

Built WebSocket servers that manage real-time connections with minimal resource usage. File processing services that leverage multi-core CPUs properly with parallel processing. API endpoints that respond fast under load. The kind of backend infrastructure that clients don't see but definitely notice when their applications just work smoothly.

The type system catches bugs at compile time. No runtime crashes from null pointer dereferences or race conditions. Memory safety without the overhead of garbage collection. These aren't just theoretical benefits, they're practical advantages when you're building production systems for paying clients.

Design-Driven Development

Working with Humaira changed how I approach development. She doesn't just make things pretty, she thinks through user flows, interaction patterns, accessibility, the entire user experience. Then she translates that into Figma designs that I can actually implement.

My job is taking those designs and building them with high fidelity. CSS Grid and Flexbox for layouts. Responsive design that works across devices. Animations and transitions that match the design specs. Using Three.js to implement 3D elements and WebGL for custom visual effects that make the sites stand out.

The goal was always to match or exceed what we saw from bigger companies. If we're showing a client a mockup with advanced 3D graphics and smooth animations, we better be able to actually build it. And we did.

The Business Education

Running Luveian taught me things they don't teach in CS courses. Client communication and managing expectations. Translating technical concepts into language that non-technical clients understand. Explaining why certain approaches cost more or take longer without sounding like you're making excuses.

Requirement gathering where you have to figure out what clients actually need versus what they think they want. Getting sign-off on features before building them to avoid scope creep. Delivering on time and on budget so clients actually trust you with future work.

Learning Google Ads meant understanding how to structure campaigns, write ad copy that converts, manage budgets, track ROI. Then teaching this to Rajyavardhan so he could handle the marketing side independently.

The entire process of building a brand from nothing – choosing a name, making a website, creating a portfolio, pitching clients, delivering projects, getting testimonials – taught me more about how businesses actually work than any amount of theory ever could.

What Actually Happened

We landed 2-3 legitimate clients. Not huge numbers but each one was a real project with proper scope and actual payment. We beat out an established agency on one project by charging more but delivering better quality. We implemented modern web technologies that most local agencies weren't even attempting.

I learned Google Ads, SEO, analytics, campaign management, and client relations on top of the technical development work. Rajyavardhan learned marketing and business operations with my training. Humaira provided the design foundation and strategic guidance that held everything together.

One client's page reached first position in search results through proper SEO implementation. That's a concrete win that came from understanding technical SEO and implementing it correctly.

Technical Stack Summary

Here's what I actually used building Luveian projects:

Backend work primarily in Rust using Axum and Tokio. Node.js with Express where it made sense for certain API services. MongoDB for flexible data storage.

Frontend visual effects with Three.js for 3D graphics and WebGL for custom shaders. Standard web stack with modern CSS, responsive design, and performance optimization.

Deployment and infrastructure through various platforms. CI/CD pipelines for automated deployment. Proper environment variable management and security practices.

Google Analytics, Tag Manager, and Search Console for tracking and optimization. Google Ads for client acquisition and campaign management.

Current Status

Luveian is still around. We're still taking client work when the right projects come along. The brand name setup worked – it gives us credibility that three random college students wouldn't have on their own.

Every project is different. Different technical requirements, different client needs, different design approaches. That variety is what makes it interesting. You're constantly solving new problems and learning new technologies.

Check out what we're building at luviean.com. And if you need development work that combines solid technical implementation with modern design and proper marketing understanding – that's exactly what we do.