I started LexisAi as a simple AI text utility.
The idea was straightforward: give a user some text, let them describe what they want changed, and return a useful result.
But turning that basic idea into a real product introduced a lot more engineering problems than I expected.
The basic architecture
LexisAi has a frontend where users interact with the writing tools and a server layer that handles things that shouldn't be trusted to the client.
The general flow looks like:
User
↓
React UI
↓
API request
↓
Server
↓
AI generation
↓
Validation / processing
↓
Response
↓
UI result
I kept the API-related logic on the server rather than exposing sensitive credentials in the frontend.
Usage limits
One of the interesting parts was building a usage system for the free plan.
The current idea is simple:
Free Plan
→ 10 successful AI actions / month
Pro Plan
→ Higher usage limit
A successful generation increments the usage counter.
But failed requests shouldn't consume someone's allowance.
That distinction matters because otherwise a temporary API failure could effectively punish the user.
I also added monthly rollover logic so the free allowance resets when a new month begins.
Subscription verification
Adding payments introduced another important rule:
The frontend shouldn't be trusted to decide whether someone is Pro.
The server verifies the payment and subscription status before granting Pro access.
The simplified flow is:
User clicks Upgrade
↓
Payment initialized
↓
User completes payment
↓
Server verifies transaction
↓
Subscription activated
↓
Pro features unlocked
For LexisAi, I'm using Paystack with Kenyan currency and mobile-money/card payment options.
AI output reliability
Another challenge wasn't just generating text.
It was making sure the AI doesn't confidently invent information.
For example, if a user asks LexisAi to summarize a document, the system shouldn't suddenly introduce a date, company claim, statistic, or event that wasn't supported by the provided material.
So I've been working on making the product more grounded and explicit about what information is actually available.
This has been one of the biggest lessons for me:
An AI feature isn't finished just because the model produces an answer.
You also have to think about what happens when the model is wrong.
Building while learning
LexisAi has also been a practical lesson in software engineering.
I've had to deal with things like:
API errors
authentication and payment verification
usage tracking
React issues
caching
service workers
production builds
environment variables
frontend/server boundaries
handling streaming responses
preventing unsupported AI claims
Some bugs were tiny.
Some bugs made absolutely no sense at first. 😂
But every one of them taught me something.
I'm still improving the architecture as I learn, rather than pretending the first version is perfect.
That's probably my favorite part of building in public.
LexisAi is live, but the engineering journey is far from finished.
If you're also building an AI product, I'd love to hear what technical problem has been the hardest for you.
👉 https://ai-text-utility.ai.studio/
Top comments (0)